/* {{{ proto Util::array_pluck(array $array, string $field[, bool $preserve_keys, bool $remove_nomatches])
Replaces each value in an array with the specified field of the array or object that used to be the value. Very useful when you have an array of objects or arrays from a database, and you only want one specific field. For example, you want an array of emails from an array of users. */
ZEND_METHOD(util, array_pluck)
{
zval *arr;
char *key;
uint keylen;
zend_bool preserve_keys = 1;
zend_bool remove_nomatches = 1;
zend_bool silent = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "as|bb", &arr, &key, &keylen, &preserve_keys, &remove_nomatches) == FAILURE) {
RETURN_NULL();
}
zval **item;
HashPosition pointer;
HashTable* arr_hash = Z_ARRVAL_P(arr);
array_init(return_value);
zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
while (zend_hash_get_current_data_ex(arr_hash, (void**) &item, &pointer) == SUCCESS) {
zval *zvalue;
MAKE_STD_ZVAL(zvalue);
ZVAL_NULL(zvalue);
zval *temp;
MAKE_STD_ZVAL(temp);
*temp = **item;
zval_copy_ctor(temp);
if (Z_TYPE_P(temp) == IS_OBJECT) {
zend_class_entry *object;
object = Z_OBJCE_P(temp);
zval *temp_data;
temp_data = zend_read_property(object, temp, key, keylen, silent TSRMLS_CC);
*zvalue = *temp_data;
} else {
zval **temp_data;
if (zend_hash_find(Z_ARRVAL_P(temp), key, keylen + 1, (void**) &temp_data) == SUCCESS) {
*zvalue = **temp_data;
}
}
char *type_key;
uint type_keylen;
ulong idx;
if (Z_TYPE_P(zvalue) != IS_NULL) {
if (preserve_keys) {
int type = zend_hash_get_current_key_ex(arr_hash, &type_key, &type_keylen, &idx, 0, &pointer);
if (type == HASH_KEY_IS_LONG) {
add_index_zval(return_value, idx, zvalue);
} else {
add_assoc_zval(return_value, type_key, zvalue);
}
} else {
add_next_index_zval(return_value, zvalue);
}
} else if (!remove_nomatches) {
int type = zend_hash_get_current_key_ex(arr_hash, &type_key, &type_keylen, &idx, 0, &pointer);
if (type == HASH_KEY_IS_LONG) {
add_index_zval(return_value, idx, temp);
} else {
add_assoc_zval(return_value, type_key, temp);
}
}
zend_hash_move_forward_ex(arr_hash, &pointer);
}
return;
}
/**
* Attaches Phalcon_Model_Base object to the active transaction
*
* @param int $pointer
* @param Phalcon_Model_Base $object
*/
PHP_METHOD(Phalcon_Transaction, attachDependency){
zval *v0 = NULL, *v1 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *r0 = NULL, *r1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(v0);
PHALCON_INIT_VAR(t0);
ZVAL_NULL(t0);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, v0, t0 TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_pointer", sizeof("_pointer")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_SEPARATE_NMO(t1);
increment_function(t1);
phalcon_update_property_zval(this_ptr, "_pointer", strlen("_pointer"), t1 TSRMLS_CC);
PHALCON_CPY_WRT(v0, t1);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_dependencies", sizeof("_dependencies")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(v1);
phalcon_array_update(t2, v0, v1 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_dependencies", strlen("_dependencies"), t2 TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(v0);
} else {
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "_dependencies", sizeof("_dependencies")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
eval_int = phalcon_array_isset(t3, v0);
PHALCON_INIT_VAR(r1);
ZVAL_BOOL(r1, eval_int);
if (!zend_is_true(r1)) {
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, "_dependencies", sizeof("_dependencies")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(v1);
phalcon_array_update(t4, v0, v1 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_dependencies", strlen("_dependencies"), t4 TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(v0);
} else {
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, this_ptr, "_pointer", sizeof("_pointer")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_SEPARATE_NMO(t5);
increment_function(t5);
phalcon_update_property_zval(this_ptr, "_pointer", strlen("_pointer"), t5 TSRMLS_CC);
PHALCON_CPY_WRT(v0, t5);
PHALCON_ALLOC_ZVAL_MM(t6);
phalcon_read_property(&t6, this_ptr, "_dependencies", sizeof("_dependencies")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(v1);
phalcon_array_update(t6, v0, v1 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_dependencies", strlen("_dependencies"), t6 TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(v0);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Phalcon_Db_Reference constructor
*
* @param string $referenceName
* @param array $definition
*/
PHP_METHOD(Phalcon_Db_Reference, __construct){
zval *reference_name = NULL, *definition = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL;
zval *t0 = NULL, *t1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &reference_name, &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_update_property_zval(this_ptr, SL("_referenceName"), reference_name TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, SL("referencedTable")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, definition, SL("referencedTable"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_referencedTable"), r0 TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced table is required");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("columns")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, SL("columns"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_columns"), r1 TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Foreign key columns are required");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("referencedColumns")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, definition, SL("referencedColumns"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_referencedColumns"), r2 TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced columns of the foreign key are required");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("schema")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, definition, SL("schema"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_schema"), r3 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("referencedSchema")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, definition, SL("referencedSchema"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_referencedSchema"), r4 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_columns"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_fast_count(r5, t0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_referencedColumns"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_fast_count(r6, t1 TSRMLS_CC);
PHALCON_INIT_VAR(r7);
is_not_equal_function(r7, r5, r6 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Number of columns is not equals than the number of columns referenced");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Builds a HTML input[type="submit"] tag
*
* @param array $params
* @return string
*/
PHP_METHOD(Phalcon_Tag, submitButton){
zval *parameters = NULL, *params = NULL, *value = NULL, *code = NULL, *avalue = NULL;
zval *key = NULL, *attribute = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_string(params, SL("value")+1);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("value")+1);
} else {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch_long(&value, params, 0, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(value);
ZVAL_STRING(value, "", 1);
}
}
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<input type=\"submit\" value=\"", value, "\" ");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_3;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_VSVS(attribute, key, "=\"", avalue, "\" ");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_3;
fee_9b93_3:
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " />", 1);
phalcon_concat_self(&code, t0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Builds a HTML FORM tag
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, form){
zval *parameters = NULL, *params = NULL, *dispatcher = NULL, *dispatch_params = NULL;
zval *action_parameters = NULL, *action = NULL, *controller_name = NULL;
zval *action_name = NULL, *url = NULL, *form_action = NULL, *code = NULL, *avalue = NULL;
zval *key = NULL, *attribute = NULL;
zval *c0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(dispatcher);
PHALCON_CALL_SELF(dispatcher, this_ptr, "getdispatcherservice");
PHALCON_INIT_VAR(dispatch_params);
PHALCON_CALL_METHOD(dispatch_params, dispatcher, "getparams", PH_NO_CHECK);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_INIT_VAR(action_parameters);
phalcon_fast_join(action_parameters, c0, dispatch_params TSRMLS_CC);
eval_int = phalcon_array_isset_long(params, 0);
if (!eval_int) {
eval_int = phalcon_array_isset_string(params, SL("action")+1);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(controller_name);
PHALCON_CALL_METHOD(controller_name, dispatcher, "getcontrollername", PH_NO_CHECK);
PHALCON_INIT_VAR(action_name);
PHALCON_CALL_METHOD(action_name, dispatcher, "getactionname", PH_NO_CHECK);
PHALCON_INIT_VAR(action);
PHALCON_CONCAT_VSV(action, controller_name, "/", action_name);
}
} else {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC);
}
eval_int = phalcon_array_isset_string(params, SL("method")+1);
if (!eval_int) {
phalcon_array_update_string_string(¶ms, SL("method"), SL("post"), PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
if (zend_is_true(action_parameters)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, url, "get", action, PH_NO_CHECK);
PHALCON_CPY_WRT(action, r0);
} else {
PHALCON_INIT_VAR(form_action);
PHALCON_CONCAT_VSV(form_action, action, "/", action_parameters);
PHALCON_INIT_VAR(action);
PHALCON_CALL_METHOD_PARAMS_1(action, url, "get", form_action, PH_NO_CHECK);
}
eval_int = phalcon_array_isset_string(params, SL("parameters")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, params, SL("parameters"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SV(r2, "?", r1);
phalcon_concat_self(&action, r2 TSRMLS_CC);
}
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<form action=\"", action, "\" ");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_5:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_5;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_VSVS(attribute, key, "= \"", avalue, "\" ");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_5;
fee_9b93_5:
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_VS(r3, code, ">");
RETURN_CTOR(r3);
}
/**
* Inserts data into a table using custom RBDM SQL syntax
*
*
*
* @param string $table
* @param array $values
* @param array $fields
* @param boolean $automaticQuotes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, insert){
zval *table = NULL, *values = NULL, *fields = NULL, *automatic_quotes = NULL;
zval *value = NULL, *key = NULL, *joined_values = NULL, *insert_sql = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL;
zval *i0 = NULL;
zval *c0 = NULL, *c1 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &table, &values, &fields, &automatic_quotes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!fields) {
PHALCON_INIT_VAR(fields);
ZVAL_NULL(fields);
}
if (!automatic_quotes) {
PHALCON_INIT_VAR(automatic_quotes);
ZVAL_BOOL(automatic_quotes, 0);
}
if (Z_TYPE_P(values) == IS_ARRAY) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, values TSRMLS_CC);
if (!zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_db_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_SVS(r1, "Unable to insert into ", table, " without data");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r1, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
} else {
if (zend_is_true(automatic_quotes)) {
if (phalcon_valid_foreach(values TSRMLS_CC)) {
ALLOC_HASHTABLE(ah0);
zend_hash_init(ah0, 0, NULL, NULL, 0);
zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*));
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e7f0_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e7f0_1;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (Z_TYPE_P(value) == IS_OBJECT) {
PHALCON_INIT_VAR(r2);
phalcon_instance_of(r2, value, phalcon_db_rawvalue_ce TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(r3);
PHALCON_CALL_METHOD_PARAMS_1(r3, this_ptr, "escapestring", value, PHALCON_NO_CHECK);
phalcon_array_update(&values, key, &r3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
goto fes_e7f0_1;
}
}
PHALCON_INIT_VAR(r4);
PHALCON_INIT_VAR(r5);
PHALCON_CALL_METHOD_PARAMS_1(r5, this_ptr, "escapestring", value, PHALCON_NO_CHECK);
PHALCON_CONCAT_SVS(r4, "'", r5, "'");
phalcon_array_update(&values, key, &r4, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e7f0_1;
fee_e7f0_1:
zend_hash_destroy(ah0);
efree(ah0);
} else {
return;
}
}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_fast_join(r6, c0, values TSRMLS_CC);
PHALCON_CPY_WRT(joined_values, r6);
if (Z_TYPE_P(fields) == IS_ARRAY) {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_fast_join(r8, c1, fields TSRMLS_CC);
PHALCON_CONCAT_SVSVSVS(r7, "INSERT INTO ", table, " (", r8, ") VALUES (", joined_values, ")");
PHALCON_CPY_WRT(insert_sql, r7);
} else {
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CONCAT_SVSVS(r9, "INSERT INTO ", table, " VALUES (", joined_values, ")");
PHALCON_CPY_WRT(insert_sql, r9);
}
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CALL_METHOD_PARAMS_1(r10, this_ptr, "query", insert_sql, PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r10);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Builds HTML IMG tags
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, image){
zval *parameters = NULL, *params = NULL, *first_param = NULL, *url = NULL, *src = NULL;
zval *code = NULL, *value = NULL, *key = NULL, *attribute = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_string(params, SL("src")+1);
if (!eval_int) {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(first_param);
phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("src"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_string(¶ms, SL("src"), SL(""), PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, params, SL("src"), PH_NOISY_CC);
PHALCON_INIT_VAR(src);
PHALCON_CALL_METHOD_PARAMS_1(src, url, "get", r0, PH_NO_CHECK);
phalcon_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<img", 1);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_8:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_8;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_SVSVS(attribute, " ", key, "=\"", value, "\"");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_8;
fee_9b93_8:
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, "/>", 1);
phalcon_concat_self(&code, t0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Generates SQL to create a table in MySQL
*
* @param string $tableName
* @param string $schemaName
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable){
zval *table_name = NULL, *schema_name = NULL, *definition = NULL;
zval *table = NULL, *temporary = NULL, *sql = NULL, *create_lines = NULL, *column = NULL;
zval *column_line = NULL, *index = NULL, *index_name = NULL, *column_list = NULL;
zval *reference = NULL, *reference_sql = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL;
zval *r21 = NULL, *r22 = NULL, *r23 = NULL, *r24 = NULL, *r25 = NULL, *r26 = NULL, *r27 = NULL;
zval *r28 = NULL, *r29 = NULL, *r30 = NULL, *r31 = NULL;
zval *a0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1, *ah2;
HashPosition hp0, hp1, hp2;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (zend_is_true(schema_name)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SVSVS(r0, "`", schema_name, "`.`", table_name, "`");
PHALCON_CPY_WRT(table, r0);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_SVS(r1, "`", table_name, "`");
PHALCON_CPY_WRT(table, r1);
}
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 0);
eval_int = phalcon_array_isset_string(definition, "options", strlen("options")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r2, "temporary", strlen("temporary")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, r3, "temporary", strlen("temporary"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 1);
}
}
}
if (zend_is_true(temporary)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_SVS(r5, "CREATE TEMPORARY TABLE ", table, " (\n\t");
PHALCON_CPY_WRT(sql, r5);
} else {
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CONCAT_SVS(r6, "CREATE TABLE ", table, " (\n\t");
PHALCON_CPY_WRT(sql, r6);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(create_lines, a0);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, definition, "columns", strlen("columns"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(r7 TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(r7);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_52be_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_52be_2;
}
PHALCON_INIT_VAR(column);
ZVAL_ZVAL(column, *hd, 1, 0);
PHALCON_INIT_VAR(r8);
PHALCON_INIT_VAR(r9);
PHALCON_CALL_METHOD(r9, column, "getname", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r10);
PHALCON_CALL_SELF_PARAMS_1(r10, this_ptr, "getcolumndefinition", column);
PHALCON_CONCAT_SVSV(r8, "`", r9, "` ", r10);
PHALCON_CPY_WRT(column_line, r8);
PHALCON_INIT_VAR(r11);
PHALCON_CALL_METHOD(r11, column, "isnotnull", PHALCON_NO_CHECK);
if (zend_is_true(r11)) {
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " NOT NULL", 1);
phalcon_concat_self(&column_line, t0 TSRMLS_CC);
}
PHALCON_INIT_VAR(r12);
PHALCON_CALL_METHOD(r12, column, "isautoincrement", PHALCON_NO_CHECK);
if (zend_is_true(r12)) {
PHALCON_INIT_VAR(t1);
ZVAL_STRING(t1, " AUTO_INCREMENT", 1);
phalcon_concat_self(&column_line, t1 TSRMLS_CC);
}
phalcon_array_append(&create_lines, column_line, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_52be_2;
fee_52be_2:
if(0){}
} else {
return;
}
eval_int = phalcon_array_isset_string(definition, "indexes", strlen("indexes")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r13);
phalcon_array_fetch_string(&r13, definition, "indexes", strlen("indexes"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(r13 TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(r13);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_52be_3:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_52be_3;
}
PHALCON_INIT_VAR(index);
ZVAL_ZVAL(index, *hd, 1, 0);
PHALCON_INIT_VAR(r14);
PHALCON_CALL_METHOD(r14, index, "getname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(index_name, r14);
PHALCON_INIT_VAR(r15);
PHALCON_INIT_VAR(r16);
PHALCON_CALL_METHOD(r16, index, "getcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r15, this_ptr, "getcolumnlist", r16);
PHALCON_CPY_WRT(column_list, r15);
if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) {
PHALCON_INIT_VAR(r17);
PHALCON_CONCAT_SVS(r17, "PRIMARY KEY (", column_list, ")");
phalcon_array_append(&create_lines, r17, PHALCON_SEPARATE_PLZ TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r18);
PHALCON_CONCAT_SVSVS(r18, "KEY `", index_name, "` (", column_list, ")");
phalcon_array_append(&create_lines, r18, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_52be_3;
fee_52be_3:
if(0){}
} else {
return;
}
}
eval_int = phalcon_array_isset_string(definition, "references", strlen("references")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r19);
phalcon_array_fetch_string(&r19, definition, "references", strlen("references"), PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(r19 TSRMLS_CC)) {
ah2 = Z_ARRVAL_P(r19);
zend_hash_internal_pointer_reset_ex(ah2, &hp2);
fes_52be_4:
if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){
goto fee_52be_4;
}
PHALCON_INIT_VAR(reference);
ZVAL_ZVAL(reference, *hd, 1, 0);
PHALCON_INIT_VAR(r20);
PHALCON_INIT_VAR(r21);
PHALCON_CALL_METHOD(r21, reference, "getname", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r22);
PHALCON_INIT_VAR(r23);
PHALCON_CALL_METHOD(r23, reference, "getcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r22, this_ptr, "getcolumnlist", r23);
PHALCON_CONCAT_SVSV(r20, "CONSTRAINT `", r21, "` FOREIGN KEY (", r22);
PHALCON_CPY_WRT(reference_sql, r20);
PHALCON_INIT_VAR(r24);
PHALCON_INIT_VAR(r25);
PHALCON_CALL_METHOD(r25, reference, "getreferencedtable", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r26);
PHALCON_INIT_VAR(r27);
PHALCON_CALL_METHOD(r27, reference, "getreferencedcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r26, this_ptr, "getcolumnlist", r27);
PHALCON_CONCAT_SVSVS(r24, ") REFERENCES `", r25, "`(", r26, ")");
phalcon_concat_self(&reference_sql, r24 TSRMLS_CC);
phalcon_array_append(&create_lines, reference_sql, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_52be_4;
fee_52be_4:
if(0){}
} else {
return;
}
}
PHALCON_ALLOC_ZVAL_MM(r28);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ",\n\t", 1);
PHALCON_ALLOC_ZVAL_MM(r29);
phalcon_fast_join(r29, c0, create_lines TSRMLS_CC);
PHALCON_CONCAT_VS(r28, r29, "\n)");
phalcon_concat_self(&sql, r28 TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, "options", strlen("options")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r30);
PHALCON_ALLOC_ZVAL_MM(r31);
PHALCON_CALL_SELF_PARAMS_1(r31, this_ptr, "_gettableoptions", definition);
PHALCON_CONCAT_SV(r30, " ", r31);
phalcon_concat_self(&sql, r30 TSRMLS_CC);
}
PHALCON_RETURN_CTOR(sql);
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Router_Rewrite, handle){
zval *uri = NULL, *parts = NULL, *params = NULL, *number_parts = NULL, *i = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_INIT_VAR(uri);
ZVAL_NULL(uri);
} else {
PHALCON_SEPARATE_PARAM(uri);
}
if (!zend_is_true(uri)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_getrewriteuri", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(uri, r0);
}
if (zend_is_true(uri)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_explode(r1, c0, uri TSRMLS_CC);
PHALCON_CPY_WRT(parts, r1);
eval_int = phalcon_array_isset_long(parts, 0);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_filter_alphanum(r3, r2);
phalcon_update_property_zval(this_ptr, "_controller", strlen("_controller"), r3 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_controller", sizeof("_controller")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
}
eval_int = phalcon_array_isset_long(parts, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, parts, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_filter_alphanum(r5, r4);
phalcon_update_property_zval(this_ptr, "_action", strlen("_action"), r5 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_action", sizeof("_action")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t1)) {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
} else {
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_fast_count(r6, parts TSRMLS_CC);
PHALCON_CPY_WRT(number_parts, r6);
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 2);
fs_ef57_0:
PHALCON_INIT_VAR(r7);
is_smaller_function(r7, i, number_parts TSRMLS_CC);
if (!zend_is_true(r7)) {
goto fe_ef57_0;
}
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, parts, i, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(¶ms, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
goto fs_ef57_0;
fe_ef57_0:
phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC);
} else {
phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC);
phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Generates SQL to add an index to a table
*
* @param string $tableName
* @param string $schemaName
* @param Phalcon_Db_Reference $reference
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, addForeignKey){
zval *table_name = NULL, *schema_name = NULL, *reference = NULL, *sql = NULL;
zval *referenced_schema = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &reference) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(reference) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Reference parameter must be an instance of Phalcon_Db_Reference");
return;
}
if (zend_is_true(schema_name)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SVSVS(r0, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD FOREIGN KEY ");
PHALCON_CPY_WRT(sql, r0);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_SVS(r1, "ALTER TABLE `", table_name, "` ADD FOREIGN KEY ");
PHALCON_CPY_WRT(sql, r1);
}
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, reference, "getname", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, reference, "getcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r4, this_ptr, "getcolumnlist", r5);
PHALCON_CONCAT_SVSVS(r2, "`", r3, "`(", r4, ") REFERENCES ");
phalcon_concat_self(&sql, r2 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, reference, "getreferencedschema", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(referenced_schema, r6);
if (zend_is_true(referenced_schema)) {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CONCAT_SVS(r7, "`", referenced_schema, "`.");
phalcon_concat_self(&sql, r7 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_METHOD(r9, reference, "getreferencedtable", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD(r11, reference, "getreferencedcolumns", PHALCON_NO_CHECK);
PHALCON_CALL_SELF_PARAMS_1(r10, this_ptr, "getcolumnlist", r11);
PHALCON_CONCAT_SVSVS(r8, "`", r9, "`(", r10, ")");
phalcon_concat_self(&sql, r8 TSRMLS_CC);
PHALCON_RETURN_CTOR(sql);
}
/**
* Generates SQL to add the table creation options
*
* @param array $definition
* @return array
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, _getTableOptions){
zval *definition = NULL, *table_options = NULL, *engine = NULL, *auto_increment = NULL;
zval *table_collation = NULL, *collation_parts = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *c0 = NULL, *c1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(table_options, a0);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r0, "ENGINE", strlen("ENGINE")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, r1, "ENGINE", strlen("ENGINE"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(engine, r2);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, r3, "ENGINE", strlen("ENGINE"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(r4)) {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CONCAT_SV(r5, "ENGINE=", engine);
phalcon_array_append(&table_options, r5, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_array_fetch_string(&r6, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r6, "AUTO_INCREMENT", strlen("AUTO_INCREMENT")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_string(&r8, r7, "AUTO_INCREMENT", strlen("AUTO_INCREMENT"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(auto_increment, r8);
if (zend_is_true(auto_increment)) {
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CONCAT_SV(r9, "AUTO_INCREMENT=", auto_increment);
phalcon_array_append(&table_options, r9, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r10);
phalcon_array_fetch_string(&r10, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset_string(r10, "TABLE_COLLATION", strlen("TABLE_COLLATION")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r11);
phalcon_array_fetch_string(&r11, definition, "options", strlen("options"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r12);
phalcon_array_fetch_string(&r12, r11, "TABLE_COLLATION", strlen("TABLE_COLLATION"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(table_collation, r12);
if (zend_is_true(table_collation)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "_", 1);
PHALCON_ALLOC_ZVAL_MM(r13);
phalcon_fast_explode(r13, c0, table_collation TSRMLS_CC);
PHALCON_CPY_WRT(collation_parts, r13);
PHALCON_ALLOC_ZVAL_MM(r14);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_array_fetch_long(&r15, collation_parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_SV(r14, "DEFAULT CHARSET=", r15);
phalcon_array_append(&table_options, r14, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r16);
PHALCON_CONCAT_SV(r16, "COLLATE=", table_collation);
phalcon_array_append(&table_options, r16, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r17);
phalcon_fast_count(r17, table_options TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, " ", 1);
PHALCON_ALLOC_ZVAL_MM(r18);
phalcon_fast_join(r18, c1, table_options TSRMLS_CC);
PHALCON_RETURN_DZVAL(r18);
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Generates SQL to add a column to a table
*
* @param string $tableName
* @param string $schemaName
* @param Phalcon_Db_Column $column
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, addColumn){
zval *table_name = NULL, *schema_name = NULL, *column = NULL, *sql = NULL, *after_position = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *t0 = NULL, *t1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &column) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(column) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column parameter must be an instance of Phalcon_Db_Column");
return;
}
if (zend_is_true(schema_name)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SVSVS(r0, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD ");
PHALCON_CPY_WRT(sql, r0);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CONCAT_SVS(r1, "ALTER TABLE `", table_name, "` ADD ");
PHALCON_CPY_WRT(sql, r1);
}
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, column, "getname", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_SELF_PARAMS_1(r4, this_ptr, "getcolumndefinition", column);
PHALCON_CONCAT_SVSV(r2, "`", r3, "` ", r4);
phalcon_concat_self(&sql, r2 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, column, "isnotnull", PHALCON_NO_CHECK);
if (zend_is_true(r5)) {
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " NOT NULL", 1);
phalcon_concat_self(&sql, t0 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_CALL_METHOD(r6, column, "isfirst", PHALCON_NO_CHECK);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(t1);
ZVAL_STRING(t1, " FIRST", 1);
phalcon_concat_self(&sql, t1 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CALL_METHOD(r7, column, "getafterposition", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(after_position, r7);
if (zend_is_true(after_position)) {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_SV(r8, " AFTER ", after_position);
phalcon_concat_self(&sql, r8 TSRMLS_CC);
}
}
PHALCON_RETURN_CTOR(sql);
}
/**
* Gets the column name in MySQL
*
* @param Phalcon_Db_Column $column
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition){
zval *column = NULL, *size = NULL, *column_sql = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(column) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column definition must be an instance of Phalcon_Db_Column");
return;
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, column, "getsize", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(size, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, column, "gettype", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_ALLOC_ZVAL_MM(r2);
is_equal_function(r2, r1, t0 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_SVS(r3, "INT(", size, ")");
PHALCON_CPY_WRT(column_sql, r3);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD(r4, column, "isunsigned", PHALCON_NO_CHECK);
if (zend_is_true(r4)) {
PHALCON_INIT_VAR(t1);
ZVAL_STRING(t1, " UNSIGNED", 1);
phalcon_concat_self(&column_sql, t1 TSRMLS_CC);
}
goto se_52be_1;
}
PHALCON_INIT_VAR(t2);
ZVAL_LONG(t2, 1);
PHALCON_ALLOC_ZVAL_MM(r5);
is_equal_function(r5, r1, t2 TSRMLS_CC);
if (zend_is_true(r5)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "DATE", 1);
goto se_52be_1;
}
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 2);
PHALCON_ALLOC_ZVAL_MM(r6);
is_equal_function(r6, r1, t3 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CONCAT_SVS(r7, "VARCHAR(", size, ")");
PHALCON_CPY_WRT(column_sql, r7);
goto se_52be_1;
}
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 3);
PHALCON_ALLOC_ZVAL_MM(r8);
is_equal_function(r8, r1, t4 TSRMLS_CC);
if (zend_is_true(r8)) {
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CALL_METHOD(r10, column, "getscale", PHALCON_NO_CHECK);
PHALCON_CONCAT_SVSVS(r9, "DECIMAL(", size, ",", r10, ")");
PHALCON_CPY_WRT(column_sql, r9);
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD(r11, column, "isunsigned", PHALCON_NO_CHECK);
if (zend_is_true(r11)) {
PHALCON_INIT_VAR(t5);
ZVAL_STRING(t5, " UNSIGNED", 1);
phalcon_concat_self(&column_sql, t5 TSRMLS_CC);
}
goto se_52be_1;
}
PHALCON_INIT_VAR(t6);
ZVAL_LONG(t6, 4);
PHALCON_ALLOC_ZVAL_MM(r12);
is_equal_function(r12, r1, t6 TSRMLS_CC);
if (zend_is_true(r12)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "DATETIME", 1);
goto se_52be_1;
}
PHALCON_INIT_VAR(t7);
ZVAL_LONG(t7, 5);
PHALCON_ALLOC_ZVAL_MM(r13);
is_equal_function(r13, r1, t7 TSRMLS_CC);
if (zend_is_true(r13)) {
PHALCON_ALLOC_ZVAL_MM(r14);
PHALCON_CONCAT_SVS(r14, "CHAR(", size, ")");
PHALCON_CPY_WRT(column_sql, r14);
goto se_52be_1;
}
PHALCON_INIT_VAR(t8);
ZVAL_LONG(t8, 6);
PHALCON_ALLOC_ZVAL_MM(r15);
is_equal_function(r15, r1, t8 TSRMLS_CC);
if (zend_is_true(r15)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "TEXT", 1);
goto se_52be_1;
}
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Unrecognized MySQL data type");
return;
se_52be_1:
PHALCON_RETURN_CTOR(column_sql);
}
static void _php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAMETERS)
{
zval *object = getThis();
char *rules;
size_t rules_len;
zend_bool compiled = 0;
UErrorCode status = U_ZERO_ERROR;
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b",
&rules, &rules_len, &compiled) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"rbbi_create_instance: bad arguments", 0);
Z_OBJ_P(return_value) = NULL;
return;
}
// instantiation of ICU object
RuleBasedBreakIterator *rbbi;
if (!compiled) {
UnicodeString rulesStr;
UParseError parseError = UParseError();
if (intl_stringFromChar(rulesStr, rules, rules_len, &status)
== FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"rbbi_create_instance: rules were not a valid UTF-8 string",
0);
RETURN_NULL();
}
rbbi = new RuleBasedBreakIterator(rulesStr, parseError, status);
intl_error_set_code(NULL, status);
if (U_FAILURE(status)) {
char *msg;
smart_str parse_error_str;
parse_error_str = intl_parse_error_to_string(&parseError);
spprintf(&msg, 0, "rbbi_create_instance: unable to create "
"RuleBasedBreakIterator from rules (%s)", parse_error_str.s? parse_error_str.s->val : "");
smart_str_free(&parse_error_str);
intl_error_set_custom_msg(NULL, msg, 1);
efree(msg);
delete rbbi;
Z_OBJ_P(return_value) = NULL;
return;
}
} else { // compiled
#if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 48
rbbi = new RuleBasedBreakIterator((uint8_t*)rules, rules_len, status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status, "rbbi_create_instance: unable to "
"create instance from compiled rules", 0);
Z_OBJ_P(return_value) = NULL;
return;
}
#else
intl_error_set(NULL, U_UNSUPPORTED_ERROR, "rbbi_create_instance: "
"compiled rules require ICU >= 4.8", 0);
Z_OBJ_P(return_value) = NULL;
return;
#endif
}
breakiterator_object_create(return_value, rbbi, 0);
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server don't return any row
*
* //Inserting data
* $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
* $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
*
* @param string $sqlStatement
* @param array $placeholders
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){
zval *sql_statement = NULL, *placeholders = NULL, *events_manager = NULL;
zval *pdo = NULL, *n = NULL, *statement = NULL, *value = NULL, *success = NULL, *affected_rows = NULL;
zval *error_info = NULL;
zval *c0 = NULL, *c1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL;
zval *i0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &sql_statement, &placeholders) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!placeholders) {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "db:beforeQuery", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_2(r0, events_manager, "fire", c0, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(r0) == IS_BOOL && !Z_BVAL_P(r0)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_count(r1, placeholders TSRMLS_CC);
if (zend_is_true(r1)) {
PHALCON_INIT_VAR(n);
ZVAL_LONG(n, 1);
PHALCON_INIT_VAR(statement);
PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK);
if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(placeholders);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_7f5d_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_7f5d_1;
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", n, value, PH_NO_CHECK);
PHALCON_SEPARATE(n);
increment_function(n);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_7f5d_1;
fee_7f5d_1:
if(0){}
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD(success, statement, "execute", PH_NO_CHECK);
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD(affected_rows, statement, "rowcount", PH_NO_CHECK);
} else {
PHALCON_INIT_VAR(success);
ZVAL_BOOL(success, 1);
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement, PH_NO_CHECK);
}
if (zend_is_true(success)) {
if (Z_TYPE_P(affected_rows) == IS_LONG) {
phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC);
if (zend_is_true(events_manager)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "db:afterQuery", 1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD_PARAMS_2(r2, events_manager, "fire", c1, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(r2) == IS_BOOL && !Z_BVAL_P(r2)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
PHALCON_INIT_VAR(error_info);
PHALCON_CALL_METHOD(error_info, pdo, "errorinfo", PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_db_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_long(&r3, error_info, 2, PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CONCAT_VSV(r4, r3, " when executing ", sql_statement);
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_array_fetch_long(&r5, error_info, 1, PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", r4, r5, PH_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
/**
* Fires a event in the events manager causing that the acive listeners will be notified about it
*
* @param string $eventType
* @param object $source
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire){
zval *event_type = NULL, *source = NULL, *colon = NULL, *event_parts = NULL;
zval *exception_message = NULL, *exception = NULL, *type = NULL, *event_name = NULL;
zval *status = NULL, *events = NULL, *fire_events = NULL, *handler = NULL, *event = NULL;
zval *class_name = NULL, *arguments = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_type, &source) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(colon);
ZVAL_STRING(colon, ":", 1);
PHALCON_INIT_VAR(event_parts);
phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC);
eval_int = phalcon_array_isset_long(event_parts, 1);
if (!eval_int) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type);
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_events_exception_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(type);
phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(event_name);
phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(status);
ZVAL_NULL(status);
PHALCON_INIT_VAR(events);
phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC);
eval_int = phalcon_array_isset(events, type);
if (eval_int) {
PHALCON_INIT_VAR(fire_events);
phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC);
if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fire_events);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(handler);
if (Z_TYPE_P(handler) == IS_OBJECT) {
PHALCON_INIT_VAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(event, "__construct", event_name, source, PH_CHECK);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, handler TSRMLS_CC);
if (PHALCON_COMPARE_STRING(class_name, "Closure")) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(status);
PHALCON_CALL_FUNC_PARAMS_2(status, "call_user_func_array", handler, arguments);
} else {
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, handler, Z_STRVAL_P(event_name), event, source, PH_NO_CHECK);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
RETURN_CCTOR(status);
}
/**
* Bind params to SQL select
*
* @param string $sqlSelect
* @param array $params
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, bindParams){
zval *sql_select = NULL, *params = NULL, *select = NULL, *pdo = NULL, *bind_value = NULL;
zval *index = NULL, *value = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_select, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, params TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_CPY_WRT(select, sql_select);
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_7f5d_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_7f5d_2;
}
PHALCON_INIT_VAR(index);
PHALCON_GET_FOREACH_KEY(index, ah0, hp0);
PHALCON_INIT_VAR(bind_value);
ZVAL_ZVAL(bind_value, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "is_numeric", bind_value);
if (zend_is_true(r1)) {
PHALCON_CPY_WRT(value, bind_value);
} else {
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, pdo, "quote", bind_value, PH_NO_CHECK);
}
if (Z_TYPE_P(index) == IS_LONG) {
PHALCON_INIT_VAR(r2);
PHALCON_CONCAT_SV(r2, "?", index);
PHALCON_INIT_VAR(r3);
phalcon_fast_str_replace(r3, r2, value, select TSRMLS_CC);
PHALCON_CPY_WRT(select, r3);
} else {
if (Z_TYPE_P(index) == IS_STRING) {
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_SVS(r4, ":", index, ":");
PHALCON_INIT_VAR(r5);
phalcon_fast_str_replace(r5, r4, value, select TSRMLS_CC);
PHALCON_CPY_WRT(select, r5);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_7f5d_2;
fee_7f5d_2:
if(0){}
RETURN_CCTOR(select);
}
RETURN_CCTOR(sql_select);
}
/**
* Returns a connection builded with the default descriptor parameters
*
*
*
* @param boolean $newConnection
* @param boolean $renovate
* @return Phalcon_Db
*/
PHP_METHOD(Phalcon_Db_Pool, getConnection){
zval *new_connection = NULL, *renovate = NULL, *database = NULL, *connection = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &new_connection, &renovate) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!new_connection) {
PHALCON_INIT_VAR(new_connection);
ZVAL_BOOL(new_connection, 0);
}
if (!renovate) {
PHALCON_INIT_VAR(renovate);
ZVAL_BOOL(renovate, 0);
}
PHALCON_OBSERVE_VAR(t0);
phalcon_read_static_property(&t0, SL("Phalcon_Db_Pool"), SL("_defaultDescriptor") TSRMLS_CC);
PHALCON_CPY_WRT(database, t0);
if (!zend_is_true(database)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Default database connection parameters was not defined");
return;
}
eval_int = phalcon_isset_property(database, SL("adapter") TSRMLS_CC);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "A valid adapter name is required");
return;
}
if (zend_is_true(new_connection)) {
if (zend_is_true(renovate)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, database, SL("adapter"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_STATIC_PARAMS_2(r0, "phalcon_db", "factory", t1, database);
phalcon_update_static_property(SL("Phalcon_Db_Pool"), SL("_connection"), r0 TSRMLS_CC);
PHALCON_OBSERVE_VAR(t2);
phalcon_read_static_property(&t2, SL("Phalcon_Db_Pool"), SL("_connection") TSRMLS_CC);
PHALCON_CPY_WRT(connection, t2);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, database, SL("adapter"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_STATIC_PARAMS_2(r1, "phalcon_db", "factory", t3, database);
PHALCON_CPY_WRT(connection, r1);
}
} else {
PHALCON_OBSERVE_VAR(t4);
phalcon_read_static_property(&t4, SL("Phalcon_Db_Pool"), SL("_connection") TSRMLS_CC);
if (!zend_is_true(t4)) {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, database, SL("adapter"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_STATIC_PARAMS_2(r2, "phalcon_db", "factory", t5, database);
phalcon_update_static_property(SL("Phalcon_Db_Pool"), SL("_connection"), r2 TSRMLS_CC);
}
PHALCON_OBSERVE_VAR(t6);
phalcon_read_static_property(&t6, SL("Phalcon_Db_Pool"), SL("_connection") TSRMLS_CC);
PHALCON_CPY_WRT(connection, t6);
}
RETURN_CHECK_CTOR(connection);
}
/**
* Updates data on a table using custom RBDM SQL syntax
*
*
*
* @param string $table
* @param array $fields
* @param array $values
* @param string $whereCondition
* @param boolean $automaticQuotes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, update){
zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL;
zval *automatic_quotes = NULL, *i = NULL, *update_values = NULL, *update_sql = NULL;
zval *field = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *a0 = NULL;
zval *c0 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|zz", &table, &fields, &values, &where_condition, &automatic_quotes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!where_condition) {
PHALCON_INIT_VAR(where_condition);
ZVAL_NULL(where_condition);
}
if (!automatic_quotes) {
PHALCON_INIT_VAR(automatic_quotes);
ZVAL_BOOL(automatic_quotes, 0);
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, fields TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_count(r1, values TSRMLS_CC);
PHALCON_INIT_VAR(r2);
is_not_equal_function(r2, r0, r1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values to update is not the same as fields");
return;
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(update_values, a0);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_SVS(r3, "UPDATE ", table, " SET ");
PHALCON_CPY_WRT(update_sql, r3);
if (phalcon_valid_foreach(fields TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e7f0_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e7f0_2;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
if (zend_is_true(automatic_quotes)) {
PHALCON_INIT_VAR(r4);
phalcon_array_fetch(&r4, values, i, PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(r4) == IS_OBJECT) {
PHALCON_INIT_VAR(r5);
phalcon_array_fetch(&r5, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(r6);
phalcon_instance_of(r6, r5, phalcon_db_rawvalue_ce TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_INIT_VAR(r8);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch(&r9, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(r8, r9, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1(r7, this_ptr, "escapestring", r8, PHALCON_NO_CHECK);
phalcon_array_update(&values, i, &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
goto fes_e7f0_2;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_INIT_VAR(r11);
PHALCON_INIT_VAR(r12);
phalcon_array_fetch(&r12, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1(r11, this_ptr, "escapestring", r12, PHALCON_NO_CHECK);
PHALCON_CONCAT_SVS(r10, "'", r11, "'");
phalcon_array_update(&values, i, &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r13);
PHALCON_INIT_VAR(r14);
phalcon_array_fetch(&r14, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VSV(r13, field, " = ", r14);
phalcon_array_append(&update_values, r13, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e7f0_2;
fee_e7f0_2:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_fast_join(r15, c0, update_values TSRMLS_CC);
phalcon_concat_self(&update_sql, r15 TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_NULL(t0);
PHALCON_INIT_VAR(r16);
is_not_equal_function(r16, where_condition, t0 TSRMLS_CC);
if (zend_is_true(r16)) {
PHALCON_ALLOC_ZVAL_MM(r17);
PHALCON_CONCAT_SV(r17, " WHERE ", where_condition);
phalcon_concat_self(&update_sql, r17 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_CALL_METHOD_PARAMS_1(r18, this_ptr, "query", update_sql, PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r18);
}
/**
* Returns a cached content
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_File, get){
zval *key_name, *lifetime = NULL, *backend, *front_end;
zval *prefix, *filtered, *prefixed_key, *cache_dir;
zval *cache_file, *time, *ttl = NULL, *modified_time, *difference;
zval *not_expired, *cached_content, *processed;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!lifetime) {
PHALCON_INIT_NVAR(lifetime);
}
PHALCON_INIT_VAR(backend);
phalcon_read_property(&backend, this_ptr, SL("_backendOptions"), PH_NOISY_CC);
PHALCON_INIT_VAR(front_end);
phalcon_read_property(&front_end, this_ptr, SL("_frontendObject"), PH_NOISY_CC);
PHALCON_INIT_VAR(prefix);
phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(filtered);
phalcon_filter_alphanum(filtered, key_name);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, filtered);
phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
PHALCON_INIT_VAR(cache_dir);
phalcon_array_fetch_string(&cache_dir, backend, SL("cacheDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(time);
PHALCON_CALL_FUNC(time, "time");
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_INIT_VAR(ttl);
PHALCON_CALL_METHOD(ttl, front_end, "getlifetime", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
PHALCON_INIT_VAR(modified_time);
PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file);
PHALCON_INIT_VAR(difference);
sub_function(difference, time, ttl TSRMLS_CC);
PHALCON_INIT_VAR(not_expired);
is_smaller_function(not_expired, difference, modified_time TSRMLS_CC);
if (PHALCON_IS_TRUE(not_expired)) {
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file);
PHALCON_INIT_VAR(processed);
PHALCON_CALL_METHOD_PARAMS_1(processed, front_end, "afterretrieve", cached_content, PH_NO_CHECK);
RETURN_CCTOR(processed);
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Builds a HTML A tag using framework conventions
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, linkTo){
zval *parameters = NULL, *text = NULL, *params = NULL, *action = NULL, *url = NULL, *internal_url = NULL;
zval *code = NULL, *value = NULL, *key = NULL, *attribute = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &text) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!text) {
PHALCON_ALLOC_ZVAL_MM(text);
ZVAL_NULL(text);
} else {
PHALCON_SEPARATE_PARAM(text);
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(¶ms, text, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
PHALCON_INIT_VAR(action);
ZVAL_STRING(action, "", 1);
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SL("action")+1);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("action")+1);
}
}
PHALCON_INIT_VAR(text);
ZVAL_STRING(text, "", 1);
eval_int = phalcon_array_isset_long(params, 1);
if (eval_int) {
PHALCON_INIT_VAR(text);
phalcon_array_fetch_long(&text, params, 1, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_string(params, SL("text")+1);
if (eval_int) {
PHALCON_INIT_VAR(text);
phalcon_array_fetch_string(&text, params, SL("text"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("text")+1);
}
}
PHALCON_INIT_VAR(url);
PHALCON_CALL_SELF(url, this_ptr, "geturlservice");
PHALCON_INIT_VAR(internal_url);
PHALCON_CALL_METHOD_PARAMS_1(internal_url, url, "get", action, PH_NO_CHECK);
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<a href=\"", internal_url, "\"");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_1;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_SVSVS(attribute, " ", key, "=\"", value, "\"");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_1;
fee_9b93_1:
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SVS(r0, ">", text, "</a>");
phalcon_concat_self(&code, r0 TSRMLS_CC);
RETURN_CTOR(code);
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_File, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *last_key = NULL, *prefix, *filtered, *front_end;
zval *backend, *cache_dir, *cache_file, *cached_content = NULL;
zval *prepared_content, *is_buffering;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!key_name) {
PHALCON_INIT_NVAR(key_name);
}
if (!content) {
PHALCON_INIT_NVAR(content);
}
if (!lifetime) {
PHALCON_INIT_NVAR(lifetime);
}
if (!stop_buffer) {
PHALCON_INIT_NVAR(stop_buffer);
ZVAL_BOOL(stop_buffer, 1);
}
if (Z_TYPE_P(key_name) == IS_NULL) {
PHALCON_INIT_VAR(last_key);
phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(prefix);
phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(filtered);
phalcon_filter_alphanum(filtered, key_name);
PHALCON_INIT_NVAR(last_key);
PHALCON_CONCAT_VV(last_key, prefix, filtered);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
PHALCON_INIT_VAR(front_end);
phalcon_read_property(&front_end, this_ptr, SL("_frontendObject"), PH_NOISY_CC);
PHALCON_INIT_VAR(backend);
phalcon_read_property(&backend, this_ptr, SL("_backendOptions"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_dir);
phalcon_array_fetch_string(&cache_dir, backend, SL("cacheDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, last_key);
if (!zend_is_true(content)) {
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_METHOD(cached_content, front_end, "getcontent", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(cached_content, content);
}
PHALCON_INIT_VAR(prepared_content);
PHALCON_CALL_METHOD_PARAMS_1(prepared_content, front_end, "beforestore", cached_content, PH_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content);
PHALCON_INIT_VAR(is_buffering);
PHALCON_CALL_METHOD(is_buffering, front_end, "isbuffering", PH_NO_CHECK);
if (PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD_NORETURN(front_end, "stop", PH_NO_CHECK);
}
if (PHALCON_IS_TRUE(is_buffering)) {
zend_print_zval(cached_content, 1);
}
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Builds a HTML TEXTAREA tag
*
* @param array $parameters
* @return string
*/
PHP_METHOD(Phalcon_Tag, textArea){
zval *parameters = NULL, *params = NULL, *id = NULL, *content = NULL, *code = NULL, *avalue = NULL;
zval *key = NULL, *attribute = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(parameters) != IS_ARRAY) {
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_CPY_WRT(params, parameters);
}
eval_int = phalcon_array_isset_long(params, 0);
if (!eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &r0, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
eval_int = phalcon_array_isset_string(params, SL("name")+1);
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(r1)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
eval_int = phalcon_array_isset_string(params, SL("id")+1);
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(params, SL("value")+1);
if (eval_int) {
PHALCON_INIT_VAR(content);
phalcon_array_fetch_string(&content, params, SL("value"), PH_NOISY_CC);
PHALCON_SEPARATE(params);
phalcon_array_unset_string(params, SL("value")+1);
} else {
PHALCON_INIT_VAR(content);
PHALCON_CALL_SELF_PARAMS_1(content, this_ptr, "getvalue", id);
}
PHALCON_INIT_VAR(code);
ZVAL_STRING(code, "<textarea ", 1);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_4:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_4;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(avalue);
ZVAL_ZVAL(avalue, *hd, 1, 0);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_INIT_VAR(attribute);
PHALCON_CONCAT_VSVS(attribute, key, "=\"", avalue, "\" ");
phalcon_concat_self(&code, attribute TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_4;
fee_9b93_4:
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CONCAT_SVS(r2, ">", content, "</textarea>");
phalcon_concat_self(&code, r2 TSRMLS_CC);
RETURN_CTOR(code);
}
PHP_COUCHBASE_LOCAL
void php_couchbase_fetch_impl(INTERNAL_FUNCTION_PARAMETERS, int multi, int oo)
{
php_couchbase_res *couchbase_res;
int argflags;
if (oo) {
argflags = PHP_COUCHBASE_ARG_F_OO;
} else {
argflags = PHP_COUCHBASE_ARG_F_FUNCTIONAL;
}
argflags |= PHP_COUCHBASE_ARG_F_ASYNC;
PHP_COUCHBASE_GET_PARAMS(couchbase_res, argflags, "");
{
php_couchbase_ctx *ctx;
if (!couchbase_res->async) {
RETURN_FALSE;
}
ctx = couchbase_res->async_ctx;
if (couchbase_res->async == 2) {
fetch_one: {
char *key;
uint key_len;
ulong index = 0;
zval **ppzval;
zval *stash = (zval *)ctx->extended_value;
if (zend_hash_num_elements(Z_ARRVAL_P(stash)) == 0) {
couchbase_res->async = 0;
zval_ptr_dtor(&stash);
efree(ctx);
couchbase_res->async_ctx = NULL;
RETURN_NULL();
}
zend_hash_internal_pointer_reset(Z_ARRVAL_P(stash));
zend_hash_get_current_data(Z_ARRVAL_P(stash), (void **)&ppzval);
RETVAL_ZVAL(*ppzval, 1, 0);
zend_hash_get_current_key_ex(Z_ARRVAL_P(stash), &key, &key_len, &index, 0, NULL);
zend_hash_index_del(Z_ARRVAL_P(stash), index);
return;
}
}
array_init(return_value);
ctx->rv = return_value;
pcbc_start_loop(couchbase_res);
if (!multi) {
zval *stash;
MAKE_STD_ZVAL(stash);
ZVAL_ZVAL(stash, return_value, 1, 0);
ctx->extended_value = (void *)stash;
zval_dtor(return_value);
couchbase_res->async = 2;
goto fetch_one;
} else {
efree(ctx);
couchbase_res->async = 0;
couchbase_res->async_ctx = NULL;
}
}
}
/**
* Rollbacks the transaction
*
* @param string $rollbackMessage
* @param Phalcon_Model_Base $rollbackRecord
* @return boolean
*/
PHP_METHOD(Phalcon_Transaction, rollback){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *i0 = NULL;
zval *p2[] = { NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v0) {
PHALCON_INIT_VAR(v0);
ZVAL_STRING(v0, "", 1);
} else {
PHALCON_SEPARATE_PARAM(v0);
}
if (!v1) {
PHALCON_INIT_VAR(v1);
ZVAL_NULL(v1);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
if (!PHALCON_COMPARE_STRING(t0, "")) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(t1);
PHALCON_SEPARATE_ARRAY(a0);
add_next_index_zval(a0, t1);
add_next_index_stringl(a0, "notifyRollback", strlen("notifyRollback"), 1);
Z_ADDREF_P(a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
Z_ADDREF_P(this_ptr);
PHALCON_SEPARATE_ARRAY(a1);
add_next_index_zval(a1, this_ptr);
Z_ADDREF_P(a1);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", a0, a1, 0x001);
Z_DELREF_P(a0);
Z_DELREF_P(a1);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CALL_METHOD(r0, t2, "rollback", PHALCON_CALL_DEFAULT);
PHALCON_CPY_WRT(v2, r0);
PHALCON_INIT_VAR(t3);
ZVAL_BOOL(t3, 1);
PHALCON_ALLOC_ZVAL_MM(r1);
is_equal_function(r1, v2, t3 TSRMLS_CC);
if (zend_is_true(r1)) {
if (PHALCON_COMPARE_STRING(v0, "")) {
PHALCON_INIT_VAR(v0);
ZVAL_STRING(v0, "Transaction aborted", 1);
}
if (zend_is_true(v1)) {
phalcon_update_property_zval(this_ptr, "_rollbackRecord", strlen("_rollbackRecord"), v1 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_transaction_failed_class_entry);
Z_ADDREF_P(v0);
p2[0] = v0;
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, "_rollbackRecord", sizeof("_rollbackRecord")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(t4);
p2[1] = t4;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 2, p2, PHALCON_CALL_CHECK);
Z_DELREF_P(p2[0]);
Z_DELREF_P(p2[1]);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect){
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsn_parts = NULL;
zval *value = NULL, *key = NULL, *dsn = NULL, *options = NULL, *persistent = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL;
zval *c0 = NULL;
zval *i0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!descriptor) {
PHALCON_ALLOC_ZVAL_MM(descriptor);
ZVAL_NULL(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (!zend_is_true(descriptor)) {
PHALCON_INIT_VAR(descriptor);
phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC);
}
eval_int = phalcon_array_isset_string(descriptor, SL("username")+1);
if (eval_int) {
PHALCON_INIT_VAR(username);
phalcon_array_fetch_string(&username, descriptor, SL("username"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(descriptor);
phalcon_array_unset_string(descriptor, SL("username")+1);
} else {
PHALCON_INIT_VAR(username);
ZVAL_NULL(username);
}
eval_int = phalcon_array_isset_string(descriptor, SL("password")+1);
if (eval_int) {
PHALCON_INIT_VAR(password);
phalcon_array_fetch_string(&password, descriptor, SL("password"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(descriptor);
phalcon_array_unset_string(descriptor, SL("password")+1);
} else {
PHALCON_INIT_VAR(password);
ZVAL_NULL(password);
}
PHALCON_INIT_VAR(dsn_parts);
array_init(dsn_parts);
if (!phalcon_valid_foreach(descriptor TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(descriptor);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_7f5d_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_7f5d_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
PHALCON_CONCAT_VSV(r0, key, "=", value);
phalcon_array_append(&dsn_parts, r0, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_7f5d_0;
fee_7f5d_0:
if(0){}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_type"), PH_NOISY_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ";", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_join(r1, c0, dsn_parts TSRMLS_CC);
PHALCON_INIT_VAR(dsn);
PHALCON_CONCAT_VSV(dsn, t0, ":", r1);
PHALCON_INIT_VAR(options);
array_init(options);
add_index_long(options, 3, 0);
add_index_long(options, 8, 2);
add_index_long(options, 10, 1);
eval_int = phalcon_array_isset_string(descriptor, SL("persistent")+1);
if (eval_int) {
PHALCON_INIT_VAR(persistent);
phalcon_array_fetch_string(&persistent, descriptor, SL("persistent"), PH_NOISY_CC);
if (zend_is_true(persistent)) {
phalcon_array_update_long_bool(&options, 12, 1, PH_SEPARATE TSRMLS_CC);
}
}
ce0 = zend_fetch_class(SL("PDO"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, ce0);
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(i0, "__construct", dsn, username, password, options, PH_CHECK);
phalcon_update_property_zval(this_ptr, SL("_pdo"), i0 TSRMLS_CC);
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Db\\Adapter\\Pdo", "__construct", descriptor);
PHALCON_MM_RESTORE();
}
/**
* Restore a Phalcon_Db_Reference object from export
*
* @param array $data
* @return Phalcon_Db_Reference
*/
PHP_METHOD(Phalcon_Db_Reference, __set_state){
zval *data = NULL, *constraint_name = NULL, *referenced_schema = NULL;
zval *referenced_table = NULL, *columns = NULL, *referenced_columns = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *i0 = NULL;
zval *a0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
eval_int = phalcon_array_isset_string(data, SL("_referenceName")+1);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "_referenceName parameter is required");
return;
} else {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, data, SL("_referenceName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(constraint_name, r0);
}
eval_int = phalcon_array_isset_string(data, SL("_referencedSchema")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, data, SL("_referencedSchema"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(referenced_schema, r1);
} else {
PHALCON_INIT_VAR(referenced_schema);
ZVAL_NULL(referenced_schema);
}
eval_int = phalcon_array_isset_string(data, SL("_referencedTable")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, data, SL("_referencedTable"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(referenced_table, r2);
} else {
PHALCON_INIT_VAR(referenced_table);
ZVAL_NULL(referenced_table);
}
eval_int = phalcon_array_isset_string(data, SL("_columns")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, data, SL("_columns"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(columns, r3);
} else {
PHALCON_INIT_VAR(columns);
ZVAL_NULL(columns);
}
eval_int = phalcon_array_isset_string(data, SL("_referencedColumns")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, data, SL("_referencedColumns"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(referenced_columns, r4);
} else {
PHALCON_INIT_VAR(referenced_columns);
ZVAL_NULL(referenced_columns);
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_db_reference_ce);
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_update_string(&a0, SL("referencedSchema"), &referenced_schema, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_string(&a0, SL("referencedTable"), &referenced_table, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_string(&a0, SL("columns"), &columns, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_string(&a0, SL("referencedColumns"), &referenced_columns, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", constraint_name, a0, PHALCON_CHECK);
RETURN_CTOR(i0);
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server return rows
*
* //Querying data
* $resultset = $connection->query("SELECT * FROM robots WHERE type='mechanical'");
* $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical"));
*
* @param string $sqlStatement
* @return Phalcon\Db\Result\Pdo
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, query){
zval *sql_statement = NULL, *events_manager = NULL, *pdo = NULL, *result = NULL;
zval *error_info = NULL;
zval *c0 = NULL, *c1 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *i0 = NULL, *i1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &sql_statement) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (zend_is_true(events_manager)) {
phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "db:beforeQuery", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_2(r0, events_manager, "fire", c0, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(r0) == IS_BOOL && !Z_BVAL_P(r0)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
PHALCON_INIT_VAR(result);
PHALCON_CALL_METHOD_PARAMS_1(result, pdo, "query", sql_statement, PH_NO_CHECK);
if (Z_TYPE_P(result) == IS_OBJECT) {
if (zend_is_true(events_manager)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "db:afterQuery", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD_PARAMS_2(r1, events_manager, "fire", c1, this_ptr, PH_NO_CHECK);
if (Z_TYPE_P(r1) == IS_BOOL && !Z_BVAL_P(r1)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_db_result_pdo_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", result, PH_CHECK);
RETURN_CTOR(i0);
}
PHALCON_INIT_VAR(error_info);
PHALCON_CALL_METHOD(error_info, pdo, "errorinfo", PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_db_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_long(&r2, error_info, 2, PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_VSV(r3, r2, " when executing ", sql_statement);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, error_info, 1, PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i1, "__construct", r3, r4, PH_CHECK);
phalcon_throw_exception(i1 TSRMLS_CC);
return;
}
/**
* Changes internal pointer to a specific position in the resultset
*
* @param int $position
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){
long i;
zval *type, *result, *rows, *position;
zval *pointer, *is_different;
HashTable *ah0;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &position) == FAILURE) {
RETURN_NULL();
}
PHALCON_MM_GROW();
pointer = phalcon_read_property(getThis(), SL("_pointer"), PH_NOISY);
/**
* We only seek the records if the current position is diferent than the passed one
*/
PHALCON_INIT_VAR(is_different);
is_not_equal_function(is_different, pointer, position);
if (PHALCON_IS_TRUE(is_different)) {
type = phalcon_read_property(getThis(), SL("_type"), PH_NOISY);
if (zend_is_true(type)) {
/**
* Here, the resultset is fetched one by one because is large
*/
result = phalcon_read_property(getThis(), SL("_result"), PH_NOISY);
PHALCON_CALL_METHOD(NULL, result, "dataseek", position);
} else {
/**
* Here, the resultset is a small array
*/
rows = phalcon_read_property(getThis(), SL("_rows"), PH_NOISY);
/**
* We need to fetch the records because rows is null
*/
if (Z_TYPE_P(rows) == IS_NULL) {
result = phalcon_read_property(getThis(), SL("_result"), PH_NOISY);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_CALL_METHOD(&rows, result, "fetchall");
phalcon_update_property_zval(getThis(), SL("_rows"), rows);
}
}
convert_to_long(position);
if(Z_TYPE_P(rows) == IS_ARRAY){
ah0 = Z_ARRVAL_P(rows);
zend_hash_internal_pointer_reset(ah0);
i = 0;
while (1) {
if (i >= Z_LVAL_P(position)) {
break;
}
zend_hash_move_forward(ah0);
i++;
}
}
phalcon_update_property_zval(getThis(), SL("_pointer"), position);
}
}
PHALCON_MM_RESTORE();}
PHP_METHOD(MsgqueForPhp_MqS, StorageClose)
{
SETUP_mqctx;
ErrorMqToPhpWithCheck(MqStorageClose(mqctx));
RETURN_NULL();
}
