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);
}
/* {{{ Cassandra\Date::fromDateTime() */
PHP_METHOD(Date, fromDateTime)
{
cassandra_date *self;
zval *zdatetime;
php5to7_zval retval;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zdatetime) == FAILURE) {
return;
}
zend_call_method_with_0_params(PHP5TO7_ZVAL_MAYBE_ADDR_OF(zdatetime),
php_date_get_date_ce(),
NULL,
"gettimestamp",
&retval);
if (!PHP5TO7_ZVAL_IS_UNDEF(retval) &&
Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_P(retval)) == IS_LONG) {
object_init_ex(return_value, cassandra_date_ce);
self = PHP_CASSANDRA_GET_DATE(return_value);
self->date = cass_date_from_epoch(PHP5TO7_Z_LVAL_MAYBE_P(retval));
zval_ptr_dtor(&retval);
return;
}
}
PHP_METHOD(TypeSet, create)
{
cassandra_type *self;
cassandra_set *set;
php5to7_zval_args args = NULL;
int argc = 0, i;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "*",
&args, &argc) == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_TYPE(getThis());
object_init_ex(return_value, cassandra_set_ce);
set = PHP_CASSANDRA_GET_SET(return_value);
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(set->type), getThis());
if (argc > 0) {
for (i = 0; i < argc; i++) {
if (!php_cassandra_set_add(set, PHP5TO7_ZVAL_ARG(args[i]) TSRMLS_CC)) {
PHP5TO7_MAYBE_EFREE(args);
return;
}
}
PHP5TO7_MAYBE_EFREE(args);
}
}
PHP_METHOD(TypeCollection, valueType)
{
cassandra_type *self;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_TYPE(getThis());
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(self->value_type), 1, 0);
}
PHP_METHOD(DefaultColumn, type)
{
cassandra_column *self;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_COLUMN(getThis());
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(self->type), 1, 0);
}
PHP_METHOD(BatchStatement, add)
{
zval *statement = NULL;
zval *arguments = NULL;
cassandra_batch_statement_entry *batch_statement_entry = NULL;
cassandra_statement *self = NULL;
#if PHP_MAJOR_VERSION >= 7
zval entry;
#endif
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &statement, &arguments) == FAILURE) {
return;
}
if (!instanceof_function(Z_OBJCE_P(statement), cassandra_simple_statement_ce TSRMLS_CC) &&
!instanceof_function(Z_OBJCE_P(statement), cassandra_prepared_statement_ce TSRMLS_CC)) {
INVALID_ARGUMENT(statement, "an instance of Cassandra\\SimpleStatement or Cassandra\\PreparedStatement");
}
self = PHP_CASSANDRA_GET_STATEMENT(getThis());
batch_statement_entry = (cassandra_batch_statement_entry *) ecalloc(1, sizeof(cassandra_batch_statement_entry));
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(batch_statement_entry->statement), statement);
if (arguments) {
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(batch_statement_entry->arguments), arguments);
}
#if PHP_MAJOR_VERSION >= 7
ZVAL_PTR(&entry, batch_statement_entry);
zend_hash_next_index_insert(&self->statements, &entry);
#else
zend_hash_next_index_insert(&self->statements,
&batch_statement_entry, sizeof(cassandra_batch_statement_entry *),
NULL);
#endif
}
PHP_METHOD(DefaultTable, gcGraceSeconds)
{
cassandra_table *self;
php5to7_zval value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = PHP_CASSANDRA_GET_TABLE(getThis());
php_cassandra_get_table_field(self->meta, "gc_grace_seconds", &value TSRMLS_CC);
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(value), 0, 1);
}
PHP_METHOD(DefaultTable, memtableFlushPeriodMs)
{
cassandra_table *self;
php5to7_zval value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = PHP_CASSANDRA_GET_TABLE(getThis());
php_cassandra_get_table_field(self->meta, "memtable_flush_period_in_ms", &value TSRMLS_CC);
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(value), 0, 1);
}
PHP_METHOD(DefaultTable, compactionStrategyOptions)
{
cassandra_table *self;
php5to7_zval value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = PHP_CASSANDRA_GET_TABLE(getThis());
php_cassandra_get_table_field(self->meta, "compaction_strategy_options", &value TSRMLS_CC);
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(value), 0, 1);
}
PHP_METHOD(DefaultTable, bloomFilterFPChance)
{
cassandra_table *self;
php5to7_zval value;
if (zend_parse_parameters_none() == FAILURE)
return;
self = PHP_CASSANDRA_GET_TABLE(getThis());
php_cassandra_get_table_field(self->meta, "bloom_filter_fp_chance", &value TSRMLS_CC);
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(value), 0, 1);
}
PHP_METHOD(TypeCollection, create)
{
cassandra_type *self;
cassandra_collection *collection;
php5to7_zval_args args = NULL;
int argc = 0, i;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "*",
&args, &argc) == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_TYPE(getThis());
object_init_ex(return_value, cassandra_collection_ce);
collection = PHP_CASSANDRA_GET_COLLECTION(return_value);
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(collection->type), getThis());
if (argc > 0) {
for (i = 0; i < argc; i++) {
if (!php_cassandra_validate_object(PHP5TO7_ZVAL_ARG(args[i]),
PHP5TO7_ZVAL_MAYBE_P(self->value_type) TSRMLS_CC)) {
PHP5TO7_MAYBE_EFREE(args);
return;
}
if (!php_cassandra_collection_add(collection, PHP5TO7_ZVAL_ARG(args[i]) TSRMLS_CC)) {
PHP5TO7_MAYBE_EFREE(args);
return;
}
}
PHP5TO7_MAYBE_EFREE(args);
}
}
/* {{{ Cassandra\Date::toDateTime() */
PHP_METHOD(Date, toDateTime)
{
cassandra_date *self;
zval *ztime = NULL;
cassandra_time* time_obj = NULL;
php5to7_zval datetime;
php_date_obj *datetime_obj = NULL;
char *str;
int str_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &ztime) == FAILURE) {
return;
}
if (ztime != NULL) {
time_obj = PHP_CASSANDRA_GET_TIME(ztime);
}
self = PHP_CASSANDRA_GET_DATE(getThis());
PHP5TO7_ZVAL_MAYBE_MAKE(datetime);
php_date_instantiate(php_date_get_date_ce(), PHP5TO7_ZVAL_MAYBE_P(datetime) TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 7
datetime_obj = php_date_obj_from_obj(Z_OBJ(datetime));
#else
datetime_obj = zend_object_store_get_object(datetime TSRMLS_CC);
#endif
str_len = spprintf(&str, 0, "%lld",
cass_date_time_to_epoch(self->date,
time_obj != NULL ? time_obj->time : 0));
php_date_initialize(datetime_obj, str, str_len, "U", NULL, 0 TSRMLS_CC);
efree(str);
RETVAL_ZVAL(PHP5TO7_ZVAL_MAYBE_P(datetime), 0, 1);
}
PHP_METHOD(TypeMap, create)
{
cassandra_type *self;
cassandra_map *map;
php5to7_zval_args args = NULL;
int argc = 0, i;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "*",
&args, &argc) == FAILURE) {
return;
}
if (argc % 2 == 1) {
PHP5TO7_MAYBE_EFREE(args);
zend_throw_exception_ex(cassandra_invalid_argument_exception_ce, 0 TSRMLS_CC,
"Not enough values, maps can only be created " \
"from an even number of values, where each odd " \
"value is a key and each even value is a value, " \
"e.g create(key, value, key, value, key, value)");
return;
}
self = PHP_CASSANDRA_GET_TYPE(getThis());
object_init_ex(return_value, cassandra_map_ce);
map = PHP_CASSANDRA_GET_MAP(return_value);
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(map->type), getThis());
if (argc > 0) {
for (i = 0; i < argc; i += 2) {
if (!php_cassandra_map_set(map,
PHP5TO7_ZVAL_ARG(args[i]),
PHP5TO7_ZVAL_ARG(args[i + 1]) TSRMLS_CC)) {
PHP5TO7_MAYBE_EFREE(args);
return;
}
}
PHP5TO7_MAYBE_EFREE(args);
}
}
/* {{{ Cassandra\Timestamp::type() */
PHP_METHOD(Timestamp, type)
{
php5to7_zval type = php_cassandra_type_scalar(CASS_VALUE_TYPE_TIMESTAMP TSRMLS_CC);
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(type), 1, 1);
}
const char *validator;
size_t validator_length;
PHP5TO7_ZVAL_UNDEF(result);
value = cass_column_meta_field_by_name(meta, "validator");
ASSERT_SUCCESS_VALUE(cass_value_get_string(value, &validator,
&validator_length), result);
PHP5TO7_ZVAL_MAYBE_MAKE(result);
object_init_ex(PHP5TO7_ZVAL_MAYBE_P(result), cassandra_default_column_ce);
column = PHP_CASSANDRA_GET_COLUMN(PHP5TO7_ZVAL_MAYBE_P(result));
ASSERT_SUCCESS_BLOCK(php_cassandra_get_column_field(meta, "column_name",
&column->name TSRMLS_CC),
zval_ptr_dtor(&result);
PHP5TO7_ZVAL_UNDEF(result);
return result;
);
if (php_cassandra_parse_column_type(validator, validator_length,
&column->reversed, &column->frozen,
&column->type TSRMLS_CC) == FAILURE) {
zval_ptr_dtor(&result);
PHP5TO7_ZVAL_UNDEF(result);
return result;
}
PHP_METHOD(ExecutionOptions, __get)
{
char *name;
php5to7_size name_len;
cassandra_execution_options *self = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
return;
}
self = PHP_CASSANDRA_GET_EXECUTION_OPTIONS(getThis());
if (name_len == 11 && strncmp("consistency", name, name_len) == 0) {
if (self->consistency == -1) {
RETURN_NULL();
}
RETURN_LONG(self->consistency);
} else if (name_len == 17 && strncmp("serialConsistency", name, name_len) == 0) {
if (self->serial_consistency == -1) {
RETURN_NULL();
}
RETURN_LONG(self->serial_consistency);
} else if (name_len == 8 && strncmp("pageSize", name, name_len) == 0) {
if (self->page_size == -1) {
RETURN_NULL();
}
RETURN_LONG(self->page_size);
} else if (name_len == 16 && strncmp("pagingStateToken", name, name_len) == 0) {
if (!self->paging_state_token) {
RETURN_NULL();
}
PHP5TO7_RETURN_STRINGL(self->paging_state_token,
self->paging_state_token_size);
} else if (name_len == 7 && strncmp("timeout", name, name_len) == 0) {
if (PHP5TO7_ZVAL_IS_UNDEF(self->timeout)) {
RETURN_NULL();
}
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(self->timeout), 1, 0);
} else if (name_len == 9 && strncmp("arguments", name, name_len) == 0) {
if (PHP5TO7_ZVAL_IS_UNDEF(self->arguments)) {
RETURN_NULL();
}
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(self->arguments), 1, 0);
} else if (name_len == 11 && strncmp("retryPolicy", name, name_len) == 0) {
if (PHP5TO7_ZVAL_IS_UNDEF(self->retry_policy)) {
RETURN_NULL();
}
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(self->retry_policy), 1, 0);
} else if (name_len == 9 && strncmp("timestamp", name, name_len) == 0) {
char *string;
if (self->timestamp == INT64_MIN) {
RETURN_NULL();
}
#ifdef WIN32
spprintf(&string, 0, "%I64d", (long long int) self->timestamp);
#else
spprintf(&string, 0, "%lld", (long long int) self->timestamp);
#endif
PHP5TO7_RETVAL_STRING(string);
efree(string);
}
}
php5to7_zval
php_cassandra_create_index(cassandra_ref *schema,
const CassIndexMeta *meta TSRMLS_DC)
{
php5to7_zval result;
cassandra_index *index;
const char *name;
size_t name_length;
PHP5TO7_ZVAL_UNDEF(result);
PHP5TO7_ZVAL_MAYBE_MAKE(result);
object_init_ex(PHP5TO7_ZVAL_MAYBE_P(result), cassandra_default_index_ce);
index = PHP_CASSANDRA_GET_INDEX(PHP5TO7_ZVAL_MAYBE_P(result));
index->meta = meta;
index->schema = php_cassandra_add_ref(schema);
cass_index_meta_name(meta, &name, &name_length);
PHP5TO7_ZVAL_MAYBE_MAKE(index->name);
PHP5TO7_ZVAL_STRINGL(PHP5TO7_ZVAL_MAYBE_P(index->name), name, name_length);
return result;
}
PHP_METHOD(DefaultIndex, name)
{
cassandra_index *self;
if (zend_parse_parameters_none() == FAILURE)
PHP_METHOD(ExecutionOptions, __construct)
{
zval *options = NULL;
cassandra_execution_options *self = NULL;
php5to7_zval *consistency = NULL;
php5to7_zval *serial_consistency = NULL;
php5to7_zval *page_size = NULL;
php5to7_zval *paging_state_token = NULL;
php5to7_zval *timeout = NULL;
php5to7_zval *arguments = NULL;
php5to7_zval *retry_policy = NULL;
php5to7_zval *timestamp = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &options) == FAILURE) {
return;
}
if (!options) return;
if (Z_TYPE_P(options) != IS_ARRAY) {
INVALID_ARGUMENT(options, "an array");
}
self = PHP_CASSANDRA_GET_EXECUTION_OPTIONS(getThis());
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "consistency", sizeof("consistency"), consistency)) {
if (php_cassandra_get_consistency(PHP5TO7_ZVAL_MAYBE_DEREF(consistency), &self->consistency TSRMLS_CC) == FAILURE) {
return;
}
}
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "serial_consistency", sizeof("serial_consistency"), serial_consistency)) {
if (php_cassandra_get_serial_consistency(PHP5TO7_ZVAL_MAYBE_DEREF(serial_consistency), &self->serial_consistency TSRMLS_CC) == FAILURE) {
return;
}
}
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "page_size", sizeof("page_size"), page_size)) {
if (Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(page_size)) != IS_LONG || Z_LVAL_P(PHP5TO7_ZVAL_MAYBE_DEREF(page_size)) <= 0) {
throw_invalid_argument(PHP5TO7_ZVAL_MAYBE_DEREF(page_size), "page_size", "greater than zero" TSRMLS_CC);
return;
}
self->page_size = Z_LVAL_P(PHP5TO7_ZVAL_MAYBE_DEREF(page_size));
}
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "paging_state_token", sizeof("paging_state_token"), paging_state_token)) {
if (Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(paging_state_token)) != IS_STRING) {
throw_invalid_argument(PHP5TO7_ZVAL_MAYBE_DEREF(paging_state_token), "paging_state_token", "a string" TSRMLS_CC);
return;
}
self->paging_state_token = estrndup(Z_STRVAL_P(PHP5TO7_ZVAL_MAYBE_DEREF(paging_state_token)),
Z_STRLEN_P(PHP5TO7_ZVAL_MAYBE_DEREF(paging_state_token)));
self->paging_state_token_size = Z_STRLEN_P(PHP5TO7_ZVAL_MAYBE_DEREF(paging_state_token));
}
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "timeout", sizeof("timeout"), timeout)) {
if (!(Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(timeout)) == IS_LONG && Z_LVAL_P(PHP5TO7_ZVAL_MAYBE_DEREF(timeout)) > 0) &&
!(Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(timeout)) == IS_DOUBLE && Z_DVAL_P(PHP5TO7_ZVAL_MAYBE_DEREF(timeout)) > 0) &&
!(Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(timeout)) == IS_NULL)) {
throw_invalid_argument(PHP5TO7_ZVAL_MAYBE_DEREF(timeout), "timeout", "a number of seconds greater than zero or null" TSRMLS_CC);
return;
}
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(self->timeout), PHP5TO7_ZVAL_MAYBE_DEREF(timeout));
}
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "arguments", sizeof("arguments"), arguments)) {
if (Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(arguments)) != IS_ARRAY) {
throw_invalid_argument(PHP5TO7_ZVAL_MAYBE_DEREF(arguments), "arguments", "an array" TSRMLS_CC);
return;
}
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(self->arguments), PHP5TO7_ZVAL_MAYBE_DEREF(arguments));
}
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "retry_policy", sizeof("retry_policy"), retry_policy)) {
if (Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(retry_policy)) != IS_OBJECT &&
!instanceof_function(Z_OBJCE_P(PHP5TO7_ZVAL_MAYBE_DEREF(retry_policy)),
cassandra_retry_policy_ce TSRMLS_CC)) {
throw_invalid_argument(PHP5TO7_ZVAL_MAYBE_DEREF(retry_policy),
"retry_policy",
"an instance of Cassandra\\RetryPolicy" TSRMLS_CC);
return;
}
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(self->retry_policy), PHP5TO7_ZVAL_MAYBE_DEREF(retry_policy));
}
if (PHP5TO7_ZEND_HASH_FIND(Z_ARRVAL_P(options), "timestamp", sizeof("timestamp"), timestamp)) {
if (Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(timestamp)) == IS_LONG) {
self->timestamp = Z_LVAL_P(PHP5TO7_ZVAL_MAYBE_DEREF(timestamp));
} else if (Z_TYPE_P(PHP5TO7_ZVAL_MAYBE_DEREF(timestamp)) == IS_STRING) {
if (!php_cassandra_parse_bigint(Z_STRVAL_P(PHP5TO7_ZVAL_MAYBE_DEREF(timestamp)),
Z_STRLEN_P(PHP5TO7_ZVAL_MAYBE_DEREF(timestamp)),
&self->timestamp TSRMLS_CC)) {
return;
}
} else {
throw_invalid_argument(PHP5TO7_ZVAL_MAYBE_DEREF(timestamp), "timestamp", "an integer or integer string" TSRMLS_CC);
return;
}
}
}
/* {{{ Cassandra\Date::type() */
PHP_METHOD(Date, type)
{
php5to7_zval type = php_cassandra_type_scalar(CASS_VALUE_TYPE_DATE TSRMLS_CC);
RETURN_ZVAL(PHP5TO7_ZVAL_MAYBE_P(type), 1, 1);
}
php5to7_zval
php_cassandra_create_function(cassandra_ref* schema,
const CassFunctionMeta *meta TSRMLS_DC)
{
php5to7_zval result;
cassandra_function *function;
const char *full_name;
size_t full_name_length;
PHP5TO7_ZVAL_UNDEF(result);
PHP5TO7_ZVAL_MAYBE_MAKE(result);
object_init_ex(PHP5TO7_ZVAL_MAYBE_P(result), cassandra_default_function_ce);
function = PHP_CASSANDRA_GET_FUNCTION(PHP5TO7_ZVAL_MAYBE_P(result));
function->schema = php_cassandra_add_ref(schema);
function->meta = meta;
cass_function_meta_full_name(function->meta, &full_name, &full_name_length);
PHP5TO7_ZVAL_MAYBE_MAKE(function->signature);
PHP5TO7_ZVAL_STRINGL(PHP5TO7_ZVAL_MAYBE_P(function->signature), full_name, full_name_length);
return result;
}
PHP_METHOD(DefaultFunction, name)
{
cassandra_function *self;
if (zend_parse_parameters_none() == FAILURE)
PHP_METHOD(DefaultCluster, connect)
{
CassFuture *future = NULL;
char *hash_key;
php5to7_size hash_key_len = 0;
char *keyspace = NULL;
php5to7_size keyspace_len;
zval *timeout = NULL;
cassandra_psession *psession;
cassandra_cluster *cluster = NULL;
cassandra_session *session = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &keyspace, &keyspace_len, &timeout) == FAILURE) {
return;
}
cluster = PHP_CASSANDRA_GET_CLUSTER(getThis());
object_init_ex(return_value, cassandra_default_session_ce);
session = PHP_CASSANDRA_GET_SESSION(return_value);
session->default_consistency = cluster->default_consistency;
session->default_page_size = cluster->default_page_size;
session->persist = cluster->persist;
if (!PHP5TO7_ZVAL_IS_UNDEF(session->default_timeout)) {
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(session->default_timeout),
PHP5TO7_ZVAL_MAYBE_P(cluster->default_timeout));
}
if (session->persist) {
php5to7_zend_resource_le *le;
hash_key_len = spprintf(&hash_key, 0, "%s:session:%s",
cluster->hash_key, SAFE_STR(keyspace));
if (PHP5TO7_ZEND_HASH_FIND(&EG(persistent_list), hash_key, hash_key_len + 1, le) &&
Z_RES_P(le)->type == php_le_cassandra_session()) {
psession = (cassandra_psession *) Z_RES_P(le)->ptr;
session->session = psession->session;
future = psession->future;
}
}
if (future == NULL) {
php5to7_zend_resource_le resource;
session->session = cass_session_new();
if (keyspace) {
future = cass_session_connect_keyspace(session->session, cluster->cluster, keyspace);
} else {
future = cass_session_connect(session->session, cluster->cluster);
}
if (session->persist) {
psession = (cassandra_psession *) pecalloc(1, sizeof(cassandra_psession), 1);
psession->session = session->session;
psession->future = future;
#if PHP_MAJOR_VERSION >= 7
ZVAL_NEW_PERSISTENT_RES(&resource, 0, psession, php_le_cassandra_session());
PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, &resource, sizeof(php5to7_zend_resource_le));
CASSANDRA_G(persistent_sessions)++;
#else
resource.type = php_le_cassandra_session();
resource.ptr = psession;
PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, resource, sizeof(php5to7_zend_resource_le));
CASSANDRA_G(persistent_sessions)++;
#endif
}
}
if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) {
if (session->persist) {
efree(hash_key);
} else {
cass_future_free(future);
}
return;
}
if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) {
if (session->persist) {
if (PHP5TO7_ZEND_HASH_DEL(&EG(persistent_list), hash_key, hash_key_len + 1)) {
session->session = NULL;
}
efree(hash_key);
} else {
cass_future_free(future);
}
return;
}
if (session->persist)
efree(hash_key);
}
