PHP_METHOD(FuturePreparedStatement, get) { zval* timeout = NULL; cassandra_prepared_statement* prepared_statement = NULL; cassandra_future_prepared_statement* self = (cassandra_future_prepared_statement*) zend_object_store_get_object(getThis() TSRMLS_CC); if (self->prepared_statement) { RETURN_ZVAL(self->prepared_statement, 1, 0); } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &timeout) == FAILURE) { return; } if (php_cassandra_future_wait_timed(self->future, timeout TSRMLS_CC) == FAILURE) { return; } if (php_cassandra_future_is_error(self->future TSRMLS_CC) == FAILURE) { return; } object_init_ex(return_value, cassandra_prepared_statement_ce); self->prepared_statement = return_value; Z_ADDREF_P(self->prepared_statement); prepared_statement = (cassandra_prepared_statement*) zend_object_store_get_object(return_value TSRMLS_CC); prepared_statement->prepared = cass_future_get_prepared(self->future); }
PHP_METHOD(FuturePreparedStatement, get) { zval *timeout = NULL; cassandra_statement *prepared_statement = NULL; cassandra_future_prepared_statement *self = PHP_CASSANDRA_GET_FUTURE_PREPARED_STATEMENT(getThis()); if (!PHP5TO7_ZVAL_IS_UNDEF(self->prepared_statement)) { RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(self->prepared_statement), 1, 0); } if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &timeout) == FAILURE) { return; } if (php_cassandra_future_wait_timed(self->future, timeout TSRMLS_CC) == FAILURE) { return; } if (php_cassandra_future_is_error(self->future TSRMLS_CC) == FAILURE) { return; } object_init_ex(return_value, cassandra_statement_ce); PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(self->prepared_statement), return_value); prepared_statement = PHP_CASSANDRA_GET_STATEMENT(return_value); prepared_statement->prepared = cass_future_get_prepared(self->future); }
void CassDriver::PrepareQuery() { CassError rc = CASS_OK; CassString insert_query = cass_string_init("INSERT INTO receiver_table " "(receiver_id, ts, msg_id, group_id, msg, sender_id) " "VALUES (?, ?, ?, ?, ?, ?);"); CassFuture* insert_future = cass_session_prepare(session_, insert_query); cass_future_wait(insert_future); rc = cass_future_error_code(insert_future); if (rc != CASS_OK) { PrintError(insert_future); } else { insert_prepared_ = cass_future_get_prepared(insert_future); } cass_future_free(insert_future); rc = CASS_OK; CassString select_query = cass_string_init("SELECT * FROM receiver_table " "WHERE receiver_id = ?"); CassFuture* select_future = cass_session_prepare(session_, select_query); cass_future_wait(select_future); rc = cass_future_error_code(select_future); if (rc != CASS_OK) { PrintError(select_future); } else { select_prepared_ = cass_future_get_prepared(select_future); } cass_future_free(select_future); rc = CASS_OK; CassString delete_query = cass_string_init("DELETE FROM receiver_table " "WHERE receiver_id = ?"); CassFuture* delete_future = cass_session_prepare(session_, delete_query); cass_future_wait(delete_future); rc = cass_future_error_code(delete_future); if (rc != CASS_OK) { PrintError(delete_future); } else { delete_prepared_ = cass_future_get_prepared(delete_future); } cass_future_free(delete_future); }
void CCassandraLogAgent::executeUpdateLogStatement(StringBuffer& st) { cassSession->connect(); CassandraFuture futurePrep(cass_session_prepare_n(cassSession->querySession(), st.str(), st.length())); futurePrep.wait("prepare statement"); Owned<CassandraPrepared> prepared = new CassandraPrepared(cass_future_get_prepared(futurePrep), NULL); CassandraStatement statement(prepared.getClear()); CassandraFuture future(cass_session_execute(cassSession->querySession(), statement)); future.wait("execute"); cassSession->disconnect(); }
CassError DbCassandra::PrepareQuery( CassSession *session, const char *query, const CassPrepared **prepared ) const { CassFuture *future = cass_session_prepare( session, query ); cass_future_wait( future ); CassError err = cass_future_error_code( future ); if ( err == CASS_OK ) *prepared = cass_future_get_prepared( future ); cass_future_free( future ); return err; }
void prepare_alter_schema_version_session() { // Create a new session for altering node2 and node3 system tables std::string ip_prefix = inst.ccm->get_ip_prefix(); std::stringstream whitelist_hosts; whitelist_hosts << ip_prefix << "2," << ip_prefix << "3"; cass_cluster_set_whitelist_filtering(inst.cluster, whitelist_hosts.str().c_str()); schema_alter_session = cass_session_new(); test_utils::CassFuturePtr connect_future(cass_session_connect(schema_alter_session, inst.cluster)); test_utils::wait_and_check_error(connect_future.get()); std::string update_peer("UPDATE system.peers SET schema_version=? WHERE peer='" + ip_prefix + "1'"); test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(schema_alter_session, update_peer.data(), update_peer.size())); test_utils::wait_and_check_error(prepared_future.get()); schema_alter_prepared = test_utils::CassPreparedPtr(cass_future_get_prepared(prepared_future.get())); }
CassError prepare_query(CassSession* session, const char* query, const CassPrepared** prepared) { CassError rc = CASS_OK; CassFuture* future = NULL; future = cass_session_prepare(session, query); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { *prepared = cass_future_get_prepared(future); } cass_future_free(future); return rc; }
CassError prepare_insert_into_batch(CassSession* session, const CassPrepared** prepared) { CassError rc = CASS_OK; CassFuture* future = NULL; const char* query = "INSERT INTO examples.pairs (key, value) VALUES (?, ?)"; future = cass_session_prepare(session, query); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { *prepared = cass_future_get_prepared(future); } cass_future_free(future); return rc; }
CassError prepare_select_from_basic(CassSession* session, const CassPrepared** prepared) { CassError rc = CASS_OK; CassFuture* future = NULL; const char* query = "SELECT * FROM examples.basic WHERE key = ?"; future = cass_session_prepare(session, query); cass_future_wait(future); rc = cass_future_error_code(future); if (rc != CASS_OK) { print_error(future); } else { *prepared = cass_future_get_prepared(future); } cass_future_free(future); return rc; }
/** * Check the column count of a bound statement before and after adding a * column to a table. * * @param expected_column_count_after_update */ void prepared_check_column_count_after_alter(size_t expected_column_count_after_update) { test_utils::CassSessionPtr session(test_utils::create_session(cluster)); test_utils::execute_query(session.get(), str(boost::format("USE %s") % keyspace)); test_utils::CassFuturePtr future(cass_session_prepare(session.get(), "SELECT * FROM test WHERE k = 'key1'")); BOOST_REQUIRE_EQUAL(cass_future_error_code(future.get()), CASS_OK); test_utils::CassPreparedPtr prepared(cass_future_get_prepared(future.get())); BOOST_REQUIRE(prepared); test_utils::CassStatementPtr bound_statement(cass_prepared_bind(prepared.get())); BOOST_REQUIRE(bound_statement); // Verify that the table has two columns in the metadata { test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get())); BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK); test_utils::CassResultPtr result(cass_future_get_result(result_future.get())); BOOST_CHECK_EQUAL(cass_result_column_count(result.get()), 2u); } // Add a column to the table test_utils::execute_query(session.get(), "ALTER TABLE test ADD v2 int"); // The column count shouldn't have changed { test_utils::CassFuturePtr result_future(cass_session_execute(session.get(), bound_statement.get())); BOOST_REQUIRE_EQUAL(cass_future_error_code(result_future.get()), CASS_OK); test_utils::CassResultPtr result(cass_future_get_result(result_future.get())); BOOST_CHECK_EQUAL(cass_result_column_count(result.get()), expected_column_count_after_update); } }
const CassPrepared* prepare_statement(CassSession* session, std::string query) { test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(session, query.data(), query.size())); test_utils::wait_and_check_error(prepared_future.get()); return cass_future_get_prepared(prepared_future.get()); }
void InsertThread::run() { // CONNECT TO CASSANDRA CassCluster* cluster; CassSession* session; if (!CassConnectToKeyspace("127.0.0.1", "chaos", "'class': 'SimpleStrategy', 'replication_factor': 1", &cluster, &session)) { // free resources CassFreeClusterAndSession(cluster, session); return; }// if error ... // INSERTING NUMBERS const CassPrepared *preparedInsert = NULL; CassFuture* prefuture = cass_session_prepare(session, "INSERT INTO test (group, num, minimize) VALUES (?, ?, ?) IF NOT EXISTS"); cass_future_wait(prefuture); CassError prerc = cass_future_error_code(prefuture); if (prerc != CASS_OK) { CassPrintError(prefuture); // free resources cass_future_free(prefuture); CassFreeClusterAndSession(cluster, session); return; } else preparedInsert = cass_future_get_prepared(prefuture); cass_future_free(prefuture); int group; unsigned long minimize; CassStatement* statement; CassFuture* future; CassError rcI; while (GetNextNum()) { group = num % 1000000; minimize = num; statement = cass_prepared_bind(preparedInsert); cass_statement_bind_int32(statement, 0, group); cass_statement_bind_int64(statement, 1, num); cass_statement_bind_int64(statement, 2, minimize); future = cass_session_execute(session, statement); cass_future_wait(future); rcI = cass_future_error_code(future); if (rcI != CASS_OK) { CassPrintError(future); }// if error ... cass_future_free(future); cass_statement_free(statement); // stop loop on error if (rcI != CASS_OK) break; // show progress on console if ((num % 3751) == 0) printf("%lu\n", num); }// foreach num ... // free resources cass_prepared_free(preparedInsert); CassFreeClusterAndSession(cluster, session); }