C++ cass_session_execute函数代码示例

PHP_METHOD(Rows, nextPageAsync)
{
  cassandra_rows* self = NULL;
  cassandra_session* session = NULL;
  CassFuture* future = NULL;
  cassandra_future_rows* future_rows = NULL;

  if (zend_parse_parameters_none() == FAILURE)
    return;

  self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC);

  if (!(self->result && cass_result_has_more_pages(self->result))) {
    object_init_ex(return_value, cassandra_future_value_ce);
    return;
  }

  ASSERT_SUCCESS(cass_statement_set_paging_state(self->statement->statement, self->result));

  session = (cassandra_session*) zend_object_store_get_object(self->session TSRMLS_CC);
  future = cass_session_execute(session->session, self->statement->statement);

  object_init_ex(return_value, cassandra_future_rows_ce);
  future_rows = (cassandra_future_rows*) zend_object_store_get_object(return_value TSRMLS_CC);

  Z_ADDREF_P(self->session);
  future_rows->session   = self->session;
  future_rows->statement = php_cassandra_add_ref(self->statement);
  future_rows->future    = future;
}

  bool execute_insert(CassSession* session, const std::string& table_name) {
    std::string query = str(boost::format("INSERT INTO %s (id, event_time, text_sample) VALUES (?, ?, ?)") % table_name);
    test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 3));

    // Determine if bound parameters can be used based on C* version
    if (version.major == 1) {
      test_utils::CassPreparedPtr prepared = test_utils::prepare(session, query.c_str());
      statement = test_utils::CassStatementPtr(cass_prepared_bind(prepared.get()));
    }

    boost::chrono::system_clock::time_point now(boost::chrono::system_clock::now());
    boost::chrono::milliseconds event_time(boost::chrono::duration_cast<boost::chrono::milliseconds>(now.time_since_epoch()));
    std::string text_sample(test_utils::string_from_time_point(now));

    cass_statement_bind_uuid(statement.get(), 0, test_utils::generate_time_uuid(uuid_gen));
    cass_statement_bind_int64(statement.get(), 1, event_time.count());
    cass_statement_bind_string(statement.get(), 2, text_sample.c_str());

    test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
    cass_future_wait(future.get());
    CassError code = cass_future_error_code(future.get());
    if (code != CASS_OK && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT) { // Timeout is okay
      CassString message;
      cass_future_error_message(future.get(), &message.data, &message.length);
      fprintf(stderr, "Error occurred during insert '%.*s'\n", static_cast<int>(message.length), message.data);
      return false;
    }

    return true;
  }

CassError insert_into_basic(CassSession* session, const char* key, const Basic* basic) {
  CassError rc = CASS_OK;
  CassStatement* statement = NULL;
  CassFuture* future = NULL;
  const char* query = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (?, ?, ?, ?, ?, ?);";

  statement = cass_statement_new(query, 6);

  cass_statement_bind_string(statement, 0, key);
  cass_statement_bind_bool(statement, 1, basic->bln);
  cass_statement_bind_float(statement, 2, basic->flt);
  cass_statement_bind_double(statement, 3, basic->dbl);
  cass_statement_bind_int32(statement, 4, basic->i32);
  cass_statement_bind_int64(statement, 5, basic->i64);

  future = cass_session_execute(session, statement);
  cass_future_wait(future);

  rc = cass_future_error_code(future);
  if (rc != CASS_OK) {
    print_error(future);
  }

  cass_future_free(future);
  cass_statement_free(statement);

  return rc;
}

void on_create_table(CassFuture* future, void* data) {
  const char* insert_query = "INSERT INTO callbacks (key, value) "
                             "VALUES (?, ?)";
  CassUuid key;
  CassStatement* statement = NULL;
  CassFuture* insert_future = NULL;

  CassError code = cass_future_error_code(future);
  if (code != CASS_OK) {
    print_error(future);
  }

  statement = cass_statement_new(insert_query, 2);

  cass_uuid_gen_time(uuid_gen, &key);
  cass_statement_bind_uuid(statement, 0, key);
  cass_statement_bind_int64(statement, 1, cass_uuid_timestamp(key));

  insert_future = cass_session_execute((CassSession*)data, statement);

  cass_future_set_callback(insert_future, on_insert, data);

  cass_statement_free(statement);
  cass_future_free(insert_future);
}

  static std::vector<CassUuid> insert_async(CassSession* session,
                                            CassUuidGen* uuid_gen,
                                            const std::string& table_name,
                                            size_t num_concurrent_requests,
                                            std::vector<test_utils::CassFuturePtr>* futures) {
    std::string create_table_query = str(boost::format("CREATE TABLE %s (id timeuuid PRIMARY KEY, num int, str text);") % table_name);

    test_utils::execute_query(session, create_table_query);

    std::string insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(?, ?, ?)") % table_name);

    std::vector<CassUuid> ids;
    for (size_t i = 0; i < num_concurrent_requests; ++i) {
      CassUuid id = test_utils::generate_time_uuid(uuid_gen);
      test_utils::CassStatementPtr statement(cass_statement_new(insert_query.c_str(), 3));
      
      // Determine if bound parameters can be used based on C* version
      if (version.major == 1) {
        insert_query = str(boost::format("INSERT INTO %s (id, num, str) VALUES(%s, %s, 'row%s')") % table_name % test_utils::Value<CassUuid>::to_string(id) % i % i);
        statement = test_utils::CassStatementPtr(cass_statement_new(insert_query.c_str(), 0));
      } else {
        BOOST_REQUIRE(cass_statement_bind_uuid(statement.get(), 0, id) == CASS_OK);
        BOOST_REQUIRE(cass_statement_bind_int32(statement.get(), 1, i) == CASS_OK);
        std::string str_value = str(boost::format("row%d") % i);
        BOOST_REQUIRE(cass_statement_bind_string(statement.get(), 2, str_value.c_str()) == CASS_OK);
      }

      cass_statement_set_consistency(statement.get(), CASS_CONSISTENCY_QUORUM);
      futures->push_back(test_utils::CassFuturePtr(cass_session_execute(session, statement.get())));
      ids.push_back(id);
    }

    return ids;
  }

	static void ClearDatabase(Upload& upload) {
		DatabaseSession session;

		std::string str = "delete from uploadchunks where model_id = ? and upload_id = ?";
		CassStatement* statement = cass_statement_new(str.c_str(), 2);

		cass_statement_bind_uuid(statement, 0, upload.ModelId());
		cass_statement_bind_uuid(statement, 1, upload.UploadId());

		CassFuture* future = cass_session_execute(session.Session(), statement);
		cass_future_wait(future);
		cass_statement_free(statement);

		CassError rc = cass_future_error_code(future);

		if (rc != CASS_OK) {

			std::string err = std::string("Failed to execute query: ")
				+ CassandraUtils::GetCassandraError(future);

			cass_future_free(future);

			throw err;
		}
		cass_future_free(future);
	}

CassError insert_into_collections(CassSession* session, const char* key, const char* items[]) {
  CassError rc = CASS_OK;
  CassStatement* statement = NULL;
  CassFuture* future = NULL;
  CassCollection* collection = NULL;
  const char** item = NULL;
  const char* query = "INSERT INTO examples.collections (key, items) VALUES (?, ?);";

  statement = cass_statement_new(query, 2);

  cass_statement_bind_string(statement, 0, key);

  collection = cass_collection_new(CASS_COLLECTION_TYPE_SET, 2);
  for (item = items; *item; item++) {
    cass_collection_append_string(collection, *item);
  }
  cass_statement_bind_collection(statement, 1, collection);
  cass_collection_free(collection);

  future = cass_session_execute(session, statement);
  cass_future_wait(future);

  rc = cass_future_error_code(future);
  if (rc != CASS_OK) {
    print_error(future);
  }

  cass_future_free(future);
  cass_statement_free(statement);

  return rc;
}

void select_from_perf(CassSession* session, const char* query, const CassPrepared* prepared) {
  int i;
  CassFuture* futures[NUM_CONCURRENT_REQUESTS];

  for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) {
    CassStatement* statement;

    if (prepared != NULL) {
      statement = cass_prepared_bind(prepared);
    } else {
      statement = cass_statement_new(query, 0);
    }

    futures[i] = cass_session_execute(session, statement);

    cass_statement_free(statement);
  }

  for (i = 0; i < NUM_CONCURRENT_REQUESTS; ++i) {
    CassFuture* future = futures[i];
    CassError rc = cass_future_error_code(future);
    if (rc != CASS_OK) {
      print_error(future);
    } else {
      const CassResult* result = cass_future_get_result(future);
      assert(cass_result_column_count(result) == 6);
      cass_result_free(result);
    }
    cass_future_free(future);
  }
}

CassError insert_into(CassSession* session, const char* key) {
  CassError rc = CASS_OK;
  CassStatement* statement = NULL;
  CassFuture* future = NULL;
  cass_uint32_t d;
  cass_int64_t t;
  const char* query = "INSERT INTO examples.date_time (key, d, t) VALUES (?, ?, ?);";
  time_t now = time(NULL);

  d = cass_date_from_epoch(now);
  t = cass_time_from_epoch(now);

  statement = cass_statement_new(query, 3);

  cass_statement_bind_string(statement, 0, key);
  cass_statement_bind_uint32(statement, 1, d);
  cass_statement_bind_int64(statement, 2, t);

  future = cass_session_execute(session, statement);
  cass_future_wait(future);

  rc = cass_future_error_code(future);
  if (rc != CASS_OK) {
    print_error(future);
  }

  cass_future_free(future);
  cass_statement_free(statement);

  return rc;
}

    bool select_task(const std::string& query, CassConsistency consistency, int num_iterations) {
        bool is_successful = true;

        test_utils::CassStatementPtr statement(cass_statement_new(query.c_str(), 0));
        cass_statement_set_consistency(statement.get(), consistency);
        for (int i = 0; i < num_iterations; ++i) {
            test_utils::CassFuturePtr future(cass_session_execute(session, statement.get()));
            cass_future_wait(future.get());

            CassError code = cass_future_error_code(future.get());
            if (code != CASS_OK
                    && code != CASS_ERROR_LIB_REQUEST_TIMED_OUT
                    && code != CASS_ERROR_SERVER_READ_TIMEOUT) { // Timeout is okay
                CassString message;
                cass_future_error_message(future.get(), &message.data, &message.length);
                fprintf(stderr, "Error occurred during select '%.*s'\n", static_cast<int>(message.length), message.data);
                is_successful = false;
            }

            if (code == CASS_OK) {
                test_utils::CassResultPtr result(cass_future_get_result(future.get()));
                if (cass_result_row_count(result.get()) == 0) {
                    fprintf(stderr, "No rows returned from query\n");
                    is_successful = false;
                }
            }
        }

        return is_successful;
    }

  void build(const std::string& ip_prefix, int num_nodes) {
    test_utils::CassClusterPtr cluster(cass_cluster_new());
    test_utils::initialize_contact_points(cluster.get(), ip_prefix, num_nodes, 0);
    cass_cluster_set_load_balance_round_robin(cluster.get());
    cass_cluster_set_token_aware_routing(cluster.get(), cass_false);

    test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));

    for (int i = 0; i < num_nodes; ++i) {
      test_utils::CassStatementPtr statement(
            cass_statement_new("SELECT tokens, data_center FROM system.local", 0));
      test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
      test_utils::wait_and_check_error(future.get());
      test_utils::CassResultPtr result(cass_future_get_result(future.get()));
      const CassRow* row = cass_result_first_row(result.get());
      const CassValue* data_center = cass_row_get_column_by_name(row, "data_center");
      const CassValue* token_set = cass_row_get_column_by_name(row, "tokens");

      CassString str;
      cass_value_get_string(data_center, &str.data, &str.length);
      std::string dc(str.data, str.length);

      std::string ip = cass::get_host_from_future(future.get());
      test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(token_set));
      while (cass_iterator_next(iterator.get())) {
        cass_value_get_string(cass_iterator_get_value(iterator.get()), &str.data, &str.length);
        std::string token(str.data, str.length);
        tokens[boost::lexical_cast<int64_t>(token)] = Host(ip, dc);
      }
    }
  }

const CassResult* Connection::execute(CassStatement* statement)
{
	this->log("debug", "Connection::execute");

	CassFuture* result = cass_session_execute(this->_session, statement);
	CassError error = cass_future_error_code(result);

	if (error != CASS_OK) {		
		CassString message = cass_future_error_message(result);
		cass_future_free(result);

		std::ostringstream out;
		out << cass_error_desc(error) << ": " << message.data;

		this->log("error", out.str());
		throw Php::Exception(out.str());
		return nullptr;
	}

	const CassResult* res = cass_future_get_result(result);

	if (res == nullptr) {
		throw Php::Exception("Error executing query, result is null");
	}

	cass_future_free(result);

	return res;
}

CassError insert_into_basic(CassSession* session, const char* key, const Basic* basic) {
  CassError rc = CASS_OK;
  CassStatement* statement = NULL;
  CassFuture* future = NULL;

  const char* query
    = "INSERT INTO examples.basic (key, bln, flt, dbl, i32, i64) VALUES (:k, :b, :f, :d, :i32, :i64);";

  statement = cass_statement_new(query, 6);

  cass_statement_bind_string_by_name(statement, "k", key);
  cass_statement_bind_bool_by_name(statement, "b", basic->bln);
  cass_statement_bind_float_by_name(statement, "f", basic->flt);
  cass_statement_bind_double_by_name(statement, "d", basic->dbl);
  cass_statement_bind_int32_by_name(statement, "i32", basic->i32);
  cass_statement_bind_int64_by_name(statement, "i64", basic->i64);

  future = cass_session_execute(session, statement);

  cass_future_wait(future);

  rc = cass_future_error_code(future);
  if (rc != CASS_OK) {
    print_error(future);
  }

  cass_future_free(future);
  cass_statement_free(statement);

  return rc;
}

static int execute(CassSession* session, char* query, int ignore_error)
{

    CassStatement* stmt = cass_statement_new(query, 0);

    CassFuture* future = cass_session_execute(session, stmt);

    cass_statement_free(stmt);

    CassError rc = cass_future_error_code(future);
 
    if (rc != CASS_OK) {
	if (ignore_error) {
	    cass_future_free(future);
	    return 0;
	}
	
	fprintf(stderr, "Cassandra error: %s\n", cass_error_desc(rc));
	cass_future_free(future);
	return -1;
    }

    cass_future_free(future);

    return 0;
    
}

 /**
  * Execute a query on the system table
  *
  * @param is_async True if async query; false otherwise
  */
  void execute_query(bool is_async = false) {
    std::string query = "SELECT * FROM system.local";
    test_utils::CassStatementPtr statement(cass_statement_new_n(query.data(), query.size(), 0));
    test_utils::CassFuturePtr future(cass_session_execute(session_.get(), statement.get()));
    if (!is_async) {
      test_utils::wait_and_check_error(future.get());
    }
  }