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);
}
