/**
* Commits the transaction
*
* @return boolean
*/
PHP_METHOD(Phalcon_Transaction, commit){
zval *t0 = NULL, *t1 = NULL, *t2 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
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, "notifyCommit", strlen("notifyCommit"), 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, "commit", PHALCON_CALL_DEFAULT);
PHALCON_RETURN_DZVAL(r0);
}
/**
* Phalcon\Acl\Role description
*
* @param string $name
* @param string $description
*/
PHP_METHOD(Phalcon_Acl_Role, __construct){
zval *name = NULL, *description = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &name, &description) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!description) {
PHALCON_ALLOC_ZVAL_MM(description);
ZVAL_STRING(description, "", 1);
}
if (PHALCON_COMPARE_STRING(name, "*")) {
PHALCON_THROW_EXCEPTION_STR(phalcon_acl_exception_ce, "Role name cannot be \"*\"");
return;
}
phalcon_update_property_zval(this_ptr, SL("_name"), name TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_description"), description TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Phalcon_Acl_Role description
*
* @param string $name
* @param string $description
*/
PHP_METHOD(Phalcon_Acl_Role, __construct){
zval *v0 = NULL, *v1 = NULL;
zval *i0 = NULL;
zval *p0[] = { NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &v0, &v1) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v1) {
PHALCON_INIT_VAR(v1);
ZVAL_STRING(v1, "", 1);
}
if (PHALCON_COMPARE_STRING(v0, "*")) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_acl_exception_class_entry);
PHALCON_INIT_VAR(p0[0]);
ZVAL_STRING(p0[0], "Role name cannot be \"*\"", 1);
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 1, p0, PHALCON_CALL_CHECK);
zend_throw_exception_object(i0 TSRMLS_CC);
Z_ADDREF_P(i0);
PHALCON_MM_RESTORE();
return;
}
phalcon_update_property_zval(this_ptr, "_name", strlen("_name"), v0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_description", strlen("_description"), v1 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Returns the prefix for all the generated urls. By default /
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Url, getBaseUri){
zval *base_uri = NULL, *slash, *one, *minus_one = NULL, *php_self;
zval *dirname, *dir_parts, *slice, *uri = NULL;
zval *g0 = NULL;
zval *c0 = NULL;
int eval_int;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(base_uri);
phalcon_read_property(&base_uri, this_ptr, SL("_baseUri"), PH_NOISY_CC);
if (Z_TYPE_P(base_uri) == IS_NULL) {
PHALCON_INIT_VAR(slash);
ZVAL_STRING(slash, "/", 1);
phalcon_get_global(&g0, SL("_SERVER")+1 TSRMLS_CC);
eval_int = phalcon_array_isset_string(g0, SS("PHP_SELF"));
if (eval_int) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, -1);
PHALCON_CPY_WRT(minus_one, c0);
PHALCON_INIT_VAR(php_self);
phalcon_array_fetch_string(&php_self, g0, SL("PHP_SELF"), PH_NOISY_CC);
PHALCON_INIT_VAR(dirname);
PHALCON_CALL_FUNC_PARAMS_1(dirname, "dirname", php_self);
PHALCON_INIT_VAR(dir_parts);
phalcon_fast_explode(dir_parts, slash, dirname TSRMLS_CC);
PHALCON_INIT_VAR(slice);
PHALCON_CALL_FUNC_PARAMS_3(slice, "array_slice", dir_parts, one, minus_one);
PHALCON_INIT_VAR(uri);
phalcon_fast_join(uri, slash, slice TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(uri);
ZVAL_STRING(uri, "", 1);
}
if (PHALCON_COMPARE_STRING(uri, "")) {
PHALCON_CPY_WRT(base_uri, slash);
} else {
PHALCON_INIT_NVAR(base_uri);
PHALCON_CONCAT_VVV(base_uri, slash, uri, slash);
}
phalcon_update_property_zval(this_ptr, SL("_baseUri"), base_uri TSRMLS_CC);
}
RETURN_CCTOR(base_uri);
}
/**
* Gets HTTP schema (http/https)
*
* @return string
*/
PHP_METHOD(Phalcon_Request, getScheme){
zval *r0 = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "HTTP_HTTPS", 1);
PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "getserver", c0, PHALCON_NO_CHECK);
if (PHALCON_COMPARE_STRING(r0, "on")) {
PHALCON_MM_RESTORE();
RETURN_STRING("https", 1);
}
PHALCON_MM_RESTORE();
RETURN_STRING("http", 1);
}
/**
* Gets HTTP schema (http/https)
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getScheme){
zval *https_header = NULL, *https = NULL, *scheme = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(https_header);
ZVAL_STRING(https_header, "HTTP_HTTPS", 1);
PHALCON_INIT_VAR(https);
PHALCON_CALL_METHOD_PARAMS_1(https, this_ptr, "getserver", https_header, PH_NO_CHECK);
if (PHALCON_COMPARE_STRING(https, "on")) {
PHALCON_INIT_VAR(scheme);
ZVAL_STRING(scheme, "https", 1);
} else {
PHALCON_INIT_VAR(scheme);
ZVAL_STRING(scheme, "http", 1);
}
RETURN_CTOR(scheme);
}
PHP_METHOD(Phalcon_Model_MetaData, _initializeMetaData){
zval *model = NULL, *table = NULL, *schema = NULL, *key = NULL, *connection = NULL, *is_view = NULL;
zval *exists = NULL, *meta_datas = NULL, *attributes = NULL, *primary_keys = NULL;
zval *non_primary_keys = NULL, *numeric_typed = NULL, *not_null = NULL;
zval *field_types = NULL, *identity_field = NULL, *meta_data = NULL;
zval *field_name = NULL, *type = NULL, *table_metadata = 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;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL;
zval *i0 = NULL;
zval *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL, *a6 = NULL;
zval *a7 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &model, &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_VV(r0, schema, table);
PHALCON_CPY_WRT(key, r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_metaData"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset(t0, key);
if (!eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, model, "getconnection", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(connection, r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, model, "isview", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(is_view, r2);
if (!zend_is_true(is_view)) {
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD_PARAMS_2(r3, connection, "tableexists", table, schema, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(exists, r3);
} else {
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CALL_METHOD_PARAMS_2(r4, connection, "viewexists", table, schema, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(exists, r4);
}
if (!zend_is_true(exists)) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_model_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_get_class(r6, model TSRMLS_CC);
PHALCON_CONCAT_SVSVSV(r5, "Table \"", schema, "\".\"", table, "\" doesn't exist on database when dumping information for ", r6);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r5, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
} else {
if (zend_is_true(is_view)) {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CALL_METHOD_PARAMS_2(r7, connection, "describeview", table, schema, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_datas, r7);
} else {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CALL_METHOD_PARAMS_2(r8, connection, "describetable", table, schema, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_datas, r8);
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(attributes, a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_CPY_WRT(primary_keys, a1);
PHALCON_INIT_VAR(a2);
array_init(a2);
PHALCON_CPY_WRT(non_primary_keys, a2);
PHALCON_INIT_VAR(a3);
array_init(a3);
PHALCON_CPY_WRT(numeric_typed, a3);
PHALCON_INIT_VAR(a4);
array_init(a4);
PHALCON_CPY_WRT(not_null, a4);
PHALCON_INIT_VAR(a5);
array_init(a5);
PHALCON_CPY_WRT(field_types, a5);
PHALCON_INIT_VAR(identity_field);
ZVAL_BOOL(identity_field, 0);
if (phalcon_valid_foreach(meta_datas TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(meta_datas);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_f5c6_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_f5c6_0;
}
PHALCON_INIT_VAR(meta_data);
ZVAL_ZVAL(meta_data, *hd, 1, 0);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch_string(&r9, meta_data, SL("Field"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(field_name, r9);
phalcon_array_append(&attributes, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_INIT_VAR(r10);
phalcon_array_fetch_string(&r10, meta_data, SL("Key"), PHALCON_NOISY TSRMLS_CC);
if (PHALCON_COMPARE_STRING(r10, "PRI")) {
phalcon_array_append(&primary_keys, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC);
} else {
phalcon_array_append(&non_primary_keys, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
PHALCON_INIT_VAR(r11);
phalcon_array_fetch_string(&r11, meta_data, SL("Type"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(type, r11);
phalcon_array_update(&field_types, field_name, &type, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "char", 1);
PHALCON_INIT_VAR(r12);
phalcon_fast_strpos(r12, type, c0 TSRMLS_CC);
if (Z_TYPE_P(r12) == IS_BOOL && !Z_BVAL_P(r12)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "int", 1);
PHALCON_INIT_VAR(r13);
phalcon_fast_strpos(r13, type, c1 TSRMLS_CC);
if (Z_TYPE_P(r13) != IS_BOOL || (Z_TYPE_P(r13) == IS_BOOL && Z_BVAL_P(r13))) {
PHALCON_INIT_VAR(t1);
ZVAL_BOOL(t1, 1);
phalcon_array_update(&numeric_typed, field_name, &t1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
} else {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "decimal", 1);
PHALCON_INIT_VAR(r14);
phalcon_fast_strpos(r14, type, c2 TSRMLS_CC);
if (Z_TYPE_P(r14) != IS_BOOL || (Z_TYPE_P(r14) == IS_BOOL && Z_BVAL_P(r14))) {
PHALCON_INIT_VAR(t2);
ZVAL_BOOL(t2, 1);
phalcon_array_update(&numeric_typed, field_name, &t2, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
} else {
PHALCON_INIT_VAR(c3);
ZVAL_STRING(c3, "numeric", 1);
PHALCON_INIT_VAR(r15);
phalcon_fast_strpos(r15, type, c3 TSRMLS_CC);
if (Z_TYPE_P(r15) != IS_BOOL || (Z_TYPE_P(r15) == IS_BOOL && Z_BVAL_P(r15))) {
PHALCON_INIT_VAR(t3);
ZVAL_BOOL(t3, 1);
phalcon_array_update(&numeric_typed, field_name, &t3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
}
}
}
PHALCON_INIT_VAR(r16);
phalcon_array_fetch_string(&r16, meta_data, SL("Null"), PHALCON_NOISY TSRMLS_CC);
if (PHALCON_COMPARE_STRING(r16, "NO")) {
phalcon_array_append(¬_null, field_name, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
PHALCON_INIT_VAR(r17);
phalcon_array_fetch_string(&r17, meta_data, SL("Extra"), PHALCON_NOISY TSRMLS_CC);
if (PHALCON_COMPARE_STRING(r17, "auto_increment")) {
PHALCON_CPY_WRT(identity_field, field_name);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_f5c6_0;
fee_f5c6_0:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(a6);
array_init(a6);
PHALCON_CPY_WRT(table_metadata, a6);
phalcon_array_update_long(&table_metadata, 0, &attributes, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 1, &primary_keys, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 2, &non_primary_keys, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 3, ¬_null, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 4, &field_types, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 5, &numeric_typed, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 8, &identity_field, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, SL("_metaData"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&t4, key, &table_metadata, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_metaData"), t4 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t5);
phalcon_read_property(&t5, this_ptr, SL("_changed"), PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t5)) {
PHALCON_INIT_VAR(a7);
array_init(a7);
phalcon_array_append(&a7, this_ptr, PHALCON_SEPARATE_PLZ TSRMLS_CC);
add_next_index_stringl(a7, SL("storeMetaData"), 1);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("register_shutdown_function", a7);
phalcon_update_property_bool(this_ptr, SL("_changed"), 1 TSRMLS_CC);
}
}
}
PHALCON_MM_RESTORE();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns) {
zval *table = NULL, *schema = NULL, *columns = NULL, *sql = NULL, *fetch_assoc = NULL;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *char_size = NULL, *numeric_size = NULL, *column_type = NULL;
zval *status = NULL, *attribute = NULL, *column_name = NULL, *column = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, t0, "describecolumns", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(old_column);
ZVAL_NULL(old_column);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
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(field);
PHALCON_INIT_VAR(definition);
array_init(definition);
PHALCON_INIT_VAR(char_size);
phalcon_array_fetch_string(&char_size, field, SL("size"), PH_NOISY_CC);
PHALCON_INIT_VAR(numeric_size);
phalcon_array_fetch_string(&numeric_size, field, SL("numericsize"), PH_NOISY_CC);
PHALCON_INIT_VAR(column_type);
phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC);
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("int") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("varying") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("date") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("numeric") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("char") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("timestamp") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("text") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("float") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("uuid") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
}
}
}
}
}
}
}
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("unsigned") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "PRI")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "NO")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC);
PHALCON_INIT_VAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK);
phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CTOR(columns);
}
/**
* Internal sanizite wrapper to filter_var
*
* @param mixed $value
* @param string $filter
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, _sanitize){
zval *value, *filter, *filters, *filter_object;
zval *arguments, *filtered = NULL, *type = NULL, *quote, *empty_str;
zval *escaped, *allow_fraction, *options, *exception_message;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filter) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(filters);
phalcon_read_property(&filters, this_ptr, SL("_filters"), PH_NOISY_CC);
eval_int = phalcon_array_isset(filters, filter);
if (eval_int) {
PHALCON_INIT_VAR(filter_object);
phalcon_array_fetch(&filter_object, filters, filter, PH_NOISY_CC);
/**
* If the filter is a closure we call it in the PHP userland
*/
if (phalcon_is_instance_of(filter_object, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, value, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(filtered);
PHALCON_CALL_USER_FUNC_ARRAY(filtered, filter_object, arguments);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_METHOD_PARAMS_1(filtered, filter_object, "filter", value, PH_NO_CHECK);
}
RETURN_CCTOR(filtered);
}
PHALCON_INIT_NVAR(filtered);
if (PHALCON_COMPARE_STRING(filter, "email")) {
/**
* The 'email' filter uses the filter extension
*/
PHALCON_INIT_VAR(type);
ZVAL_LONG(type, 517);
PHALCON_INIT_VAR(quote);
ZVAL_STRING(quote, "'", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(escaped);
phalcon_fast_str_replace(escaped, quote, empty_str, value TSRMLS_CC);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", escaped, type);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "int")) {
/**
* 'int' filter sanitizes a numeric input
*/
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 519);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "string")) {
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 513);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "float")) {
/**
* The 'float' filter uses the filter extension
*/
PHALCON_INIT_VAR(allow_fraction);
ZVAL_LONG(allow_fraction, 4096);
PHALCON_INIT_VAR(options);
array_init(options);
phalcon_array_update_string(&options, SL("flags"), &allow_fraction, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 520);
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_3(filtered, "filter_var", value, type, options);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "alphanum")) {
PHALCON_INIT_NVAR(filtered);
phalcon_filter_alphanum(filtered, value);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "trim")) {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "trim", value);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "striptags")) {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strip_tags", value);
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "lower")) {
if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) {
/**
* 'lower' checks for the mbstring extension to make a correct lowercase
* transformation
*/
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtolower", value);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtolower", value);
}
goto ph_end_0;
}
if (PHALCON_COMPARE_STRING(filter, "upper")) {
if (phalcon_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS) {
/**
* 'upper' checks for the mbstring extension to make a correct lowercase
* transformation
*/
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtoupper", value);
} else {
PHALCON_INIT_NVAR(filtered);
PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtoupper", value);
}
goto ph_end_0;
}
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Sanitize filter ", filter, " is not supported");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_filter_exception_ce, exception_message);
return;
ph_end_0:
RETURN_CCTOR(filtered);
}
/**
* 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, *columns = NULL;
zval *column = NULL, *column_name = NULL, *column_definition = NULL;
zval *column_line = NULL, *attribute = NULL, *indexes = NULL, *index = NULL;
zval *index_name = NULL, *column_list = NULL, *index_sql = NULL, *references = NULL;
zval *reference = NULL, *name = NULL, *referenced_table = NULL, *referenced_columns = NULL;
zval *constaint_sql = NULL, *reference_sql = NULL, *joined_lines = NULL;
zval *options = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = 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();
}
eval_int = phalcon_array_isset_string(definition, SL("columns")+1);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array");
return;
}
if (zend_is_true(schema_name)) {
PHALCON_INIT_VAR(table);
PHALCON_CONCAT_SVSVS(table, "`", schema_name, "`.`", table_name, "`");
} else {
PHALCON_INIT_VAR(table);
PHALCON_CONCAT_SVS(table, "`", table_name, "`");
}
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 0);
eval_int = phalcon_array_isset_string(definition, SL("options")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC);
eval_int = phalcon_array_isset_string(r0, SL("temporary")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, r1, SL("temporary"), PH_NOISY_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 1);
}
}
}
if (Z_TYPE_P(temporary) == IS_BOOL && Z_BVAL_P(temporary)) {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "CREATE TEMPORARY TABLE ", table, " (\n\t");
} else {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "CREATE TABLE ", table, " (\n\t");
}
PHALCON_INIT_VAR(create_lines);
array_init(create_lines);
PHALCON_INIT_VAR(columns);
phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC);
if (!phalcon_valid_foreach(columns TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(columns);
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(column_name);
PHALCON_CALL_METHOD(column_name, column, "getname", PH_NO_CHECK);
PHALCON_INIT_VAR(column_definition);
PHALCON_CALL_METHOD_PARAMS_1(column_definition, this_ptr, "getcolumndefinition", column, PH_NO_CHECK);
PHALCON_INIT_VAR(column_line);
PHALCON_CONCAT_SVSV(column_line, "`", column_name, "` ", column_definition);
PHALCON_INIT_VAR(attribute);
PHALCON_CALL_METHOD(attribute, column, "isnotnull", PH_NO_CHECK);
if (zend_is_true(attribute)) {
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " NOT NULL", 1);
phalcon_concat_self(&column_line, t0 TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
PHALCON_CALL_METHOD(attribute, column, "isautoincrement", PH_NO_CHECK);
if (zend_is_true(attribute)) {
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, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_52be_2;
fee_52be_2:
eval_int = phalcon_array_isset_string(definition, SL("indexes")+1);
if (eval_int) {
PHALCON_INIT_VAR(indexes);
phalcon_array_fetch_string(&indexes, definition, SL("indexes"), PH_NOISY_CC);
if (!phalcon_valid_foreach(indexes TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(indexes);
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(index_name);
PHALCON_CALL_METHOD(index_name, index, "getname", PH_NO_CHECK);
PHALCON_INIT_VAR(columns);
PHALCON_CALL_METHOD(columns, index, "getcolumns", PH_NO_CHECK);
PHALCON_INIT_VAR(column_list);
PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK);
if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) {
PHALCON_INIT_VAR(index_sql);
PHALCON_CONCAT_SVS(index_sql, "PRIMARY KEY (", column_list, ")");
} else {
PHALCON_INIT_VAR(index_sql);
PHALCON_CONCAT_SVSVS(index_sql, "KEY `", index_name, "` (", column_list, ")");
}
phalcon_array_append(&create_lines, index_sql, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_52be_3;
fee_52be_3:
if(0){}
}
eval_int = phalcon_array_isset_string(definition, SL("references")+1);
if (eval_int) {
PHALCON_INIT_VAR(references);
phalcon_array_fetch_string(&references, definition, SL("references"), PH_NOISY_CC);
if (!phalcon_valid_foreach(references TSRMLS_CC)) {
return;
}
ah2 = Z_ARRVAL_P(references);
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(name);
PHALCON_CALL_METHOD(name, reference, "getname", PH_NO_CHECK);
PHALCON_INIT_VAR(columns);
PHALCON_CALL_METHOD(columns, reference, "getcolumns", PH_NO_CHECK);
PHALCON_INIT_VAR(column_list);
PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_table);
PHALCON_CALL_METHOD(referenced_table, reference, "getreferencedtable", PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_columns);
PHALCON_CALL_METHOD(referenced_columns, reference, "getreferencedcolumns", PH_NO_CHECK);
PHALCON_INIT_VAR(column_list);
PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", referenced_columns, PH_NO_CHECK);
PHALCON_INIT_VAR(constaint_sql);
PHALCON_CONCAT_SVSVS(constaint_sql, "CONSTRAINT `", name, "` FOREIGN KEY (", column_list, ")");
PHALCON_INIT_VAR(reference_sql);
PHALCON_CONCAT_VSVSVS(reference_sql, constaint_sql, " REFERENCES `", referenced_table, "`(", column_list, ")");
phalcon_array_append(&create_lines, reference_sql, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_52be_4;
fee_52be_4:
if(0){}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ",\n\t", 1);
PHALCON_INIT_VAR(joined_lines);
phalcon_fast_join(joined_lines, c0, create_lines TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_VS(r3, joined_lines, "\n)");
phalcon_concat_self(&sql, r3 TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, SL("options")+1);
if (eval_int) {
PHALCON_INIT_VAR(options);
PHALCON_CALL_METHOD_PARAMS_1(options, this_ptr, "_gettableoptions", definition, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CONCAT_SV(r4, " ", options);
phalcon_concat_self(&sql, r4 TSRMLS_CC);
}
RETURN_CTOR(sql);
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns){
zval *table = NULL, *schema = NULL, *columns = NULL, *dialect = NULL, *sql = NULL, *describe = NULL;
zval *old_column = NULL, *field = NULL, *definition = NULL, *column_type = NULL;
zval *pos = NULL, *matches = NULL, *match_one = NULL, *attribute = NULL, *column_name = NULL;
zval *column = NULL;
zval *t0 = NULL;
zval *c0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_get_class_constant(t0, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, t0, PH_NO_CHECK);
PHALCON_INIT_VAR(old_column);
ZVAL_NULL(old_column);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ecef_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ecef_0;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
PHALCON_INIT_VAR(definition);
array_init(definition);
PHALCON_INIT_VAR(column_type);
phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC);
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("int") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("varchar") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("date") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("decimal") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("char") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("datetime") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("text") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("float") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("enum") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
}
}
}
}
}
}
}
}
}
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("(") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
PHALCON_INIT_VAR(matches);
array_init(matches);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(pos);
PHALCON_CALL_FUNC_PARAMS_3(pos, "preg_match", c0, column_type, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(pos)) {
eval_int = phalcon_array_isset_long(matches, 1);
if (eval_int) {
PHALCON_INIT_VAR(match_one);
phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY_CC);
phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
}
PHALCON_INIT_VAR(pos);
phalcon_fast_strpos_str(pos, column_type, SL("unsigned") TSRMLS_CC);
if (Z_TYPE_P(pos) != IS_BOOL || (Z_TYPE_P(pos) == IS_BOOL && Z_BVAL_P(pos))) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC);
}
if (!zend_is_true(old_column)) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "PRI")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "NO")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC);
PHALCON_INIT_VAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK);
phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecef_0;
fee_ecef_0:
RETURN_CTOR(columns);
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){
zval *type = NULL, *result, *row = NULL, *rows, *underscore, *empty_str;
zval *active_row, *columns_types, *column = NULL, *alias = NULL;
zval *source = NULL, *instance = NULL, *attributes = NULL, *column_map = NULL;
zval *row_model = NULL, *attribute = NULL, *column_alias = NULL, *value = NULL;
zval *model_attribute = NULL, *sql_alias = NULL, *n_alias = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_INIT_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_INIT_VAR(row);
PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetch", result, PH_NO_CHECK);
} else {
PHALCON_INIT_NVAR(row);
ZVAL_BOOL(row, 0);
}
} else {
PHALCON_INIT_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
Z_SET_ISREF_P(rows);
PHALCON_INIT_NVAR(row);
PHALCON_CALL_FUNC_PARAMS_1(row, "current", rows);
Z_UNSET_ISREF_P(rows);
if (zend_is_true(row)) {
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows);
Z_UNSET_ISREF_P(rows);
}
}
if (PHALCON_IS_NOT_FALSE(row)) {
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(active_row);
object_init_ex(active_row, phalcon_mvc_model_row_ce);
PHALCON_INIT_VAR(columns_types);
phalcon_read_property(&columns_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC);
if (!phalcon_valid_foreach(columns_types TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(columns_types);
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_KEY(alias, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(column);
PHALCON_INIT_NVAR(type);
phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(type, "object")) {
/**
* Object columns are assigned column by column
*/
PHALCON_INIT_NVAR(source);
phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY_CC);
PHALCON_INIT_NVAR(instance);
phalcon_array_fetch_string(&instance, column, SL("instance"), PH_NOISY_CC);
PHALCON_INIT_NVAR(attributes);
phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY_CC);
PHALCON_INIT_NVAR(column_map);
phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY_CC);
/**
* Assign the values from the _source_attribute notation to its real column name
*/
PHALCON_INIT_NVAR(row_model);
array_init(row_model);
if (!phalcon_valid_foreach(attributes TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(attributes);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) {
goto ph_cycle_end_1;
}
PHALCON_GET_FOREACH_VALUE(attribute);
PHALCON_INIT_NVAR(column_alias);
PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute);
PHALCON_INIT_NVAR(value);
phalcon_array_fetch(&value, row, column_alias, PH_NOISY_CC);
phalcon_array_update_zval(&row_model, attribute, &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
/**
* Assign the values to the attributes using a column map
*/
PHALCON_INIT_NVAR(model_attribute);
PHALCON_CALL_STATIC_PARAMS_3(model_attribute, "phalcon\\mvc\\model", "dumpresultmap", instance, row_model, column_map);
/**
* The complete object is assigned to an attribute with the name of the alias or
* the model name
*/
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY_CC);
phalcon_update_property_zval_zval(active_row, attribute, model_attribute TSRMLS_CC);
} else {
/**
* Scalar columns are simply assigned to the result object
*/
eval_int = phalcon_array_isset_string(column, SS("sqlAlias"));
if (eval_int) {
PHALCON_INIT_NVAR(sql_alias);
phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY_CC);
PHALCON_INIT_NVAR(value);
phalcon_array_fetch(&value, row, sql_alias, PH_NOISY_CC);
} else {
PHALCON_INIT_NVAR(value);
phalcon_array_fetch(&value, row, alias, PH_NOISY_CC);
}
/**
* If a 'balias' is defined is not an unnamed scalar
*/
eval_int = phalcon_array_isset_string(column, SS("balias"));
if (eval_int) {
phalcon_update_property_zval_zval(active_row, alias, value TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(n_alias);
phalcon_fast_str_replace(n_alias, underscore, empty_str, alias TSRMLS_CC);
phalcon_update_property_zval_zval(active_row, n_alias, value TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
phalcon_update_property_zval(this_ptr, SL("_activeRow"), active_row TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
} else {
phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Gets number of rows returned by a resulset
*
*<code>
* $result = $connection->query("SELECT * FROM robots ORDER BY name");
* echo 'There are ', $result->numRows(), ' rows in the resulset';
*</code>
*
* @return int
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, numRows){
zval *row_count = NULL, *connection, *type, *sql_statement;
zval *bind_params, *bind_types, *matches, *pattern;
zval *match, *else_clauses, *sql, *fetch_num, *result;
zval *row, *pdo_statement;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(row_count);
phalcon_read_property(&row_count, this_ptr, SL("_rowCount"), PH_NOISY_CC);
if (PHALCON_IS_FALSE(row_count)) {
PHALCON_INIT_VAR(connection);
phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
PHALCON_INIT_VAR(type);
PHALCON_CALL_METHOD(type, connection, "gettype", PH_NO_CHECK);
if (PHALCON_COMPARE_STRING(type, "sqlite")) {
/**
* SQLite returns resultsets that to the client eyes (PDO) has an arbitrary number
* of rows, so we need to perform an extra count to know that
*/
PHALCON_INIT_VAR(sql_statement);
phalcon_read_property(&sql_statement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC);
PHALCON_INIT_VAR(bind_params);
phalcon_read_property(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY_CC);
PHALCON_INIT_VAR(bind_types);
phalcon_read_property(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY_CC);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^SELECT\\s+(.*)$/i", 1);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(match);
PHALCON_CALL_FUNC_PARAMS_3(match, "preg_match", pattern, sql_statement, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(match)) {
PHALCON_INIT_VAR(else_clauses);
phalcon_array_fetch_long(&else_clauses, matches, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "SELECT COUNT(*) FROM (SELECT ", else_clauses, ")");
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, 3);
PHALCON_INIT_VAR(result);
PHALCON_CALL_METHOD_PARAMS_3(result, connection, "query", sql, bind_params, bind_types, PH_NO_CHECK);
PHALCON_INIT_VAR(row);
PHALCON_CALL_METHOD(row, result, "fetch", PH_NO_CHECK);
PHALCON_INIT_NVAR(row_count);
phalcon_array_fetch_long(&row_count, row, 0, PH_NOISY_CC);
}
} else {
PHALCON_INIT_VAR(pdo_statement);
phalcon_read_property(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
PHALCON_INIT_NVAR(row_count);
PHALCON_CALL_METHOD(row_count, pdo_statement, "rowcount", PH_NO_CHECK);
}
phalcon_update_property_zval(this_ptr, SL("_rowCount"), row_count TSRMLS_CC);
}
RETURN_CCTOR(row_count);
}
/**
* 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();
}
/**
* Builds generic INPUT tags
*
* @param string $type
* @param array $parameters
* @param boolean $asValue
* @return string
*/
PHP_METHOD(Phalcon_Tag, _inputField){
zval *type, *parameters, *as_value = NULL, *params = NULL, *value = NULL;
zval *id = NULL, *name, *code, *key = NULL, *doctype;
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, "zz|z", &type, ¶meters, &as_value) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!as_value) {
PHALCON_INIT_NVAR(as_value);
ZVAL_BOOL(as_value, 0);
}
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(value);
if (PHALCON_IS_FALSE(as_value)) {
eval_int = phalcon_array_isset_long(params, 0);
if (!eval_int) {
PHALCON_INIT_VAR(id);
phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC);
phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(id);
phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC);
eval_int = phalcon_array_isset_string(params, SS("name"));
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(name);
phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC);
if (!zend_is_true(name)) {
phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
eval_int = phalcon_array_isset_string(params, SS("id"));
if (!eval_int) {
phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(params, SS("value"));
if (!eval_int) {
PHALCON_CALL_SELF_PARAMS_1(value, this_ptr, "getvalue", id);
phalcon_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
} else {
eval_int = phalcon_array_isset_long(params, 0);
if (eval_int) {
PHALCON_INIT_NVAR(value);
phalcon_array_fetch_long(&value, params, 0, PH_NOISY_CC);
phalcon_array_update_string(¶ms, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
/**
* Automatically check inputs
*/
if (PHALCON_COMPARE_STRING(type, "checkbox")) {
if (zend_is_true(value)) {
phalcon_array_update_string_string(¶ms, SL("checked"), SL("checked"), PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_VAR(code);
PHALCON_CONCAT_SVS(code, "<input type=\"", type, "\"");
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
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_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(key) != IS_LONG) {
PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\"");
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
/**
* Check if Doctype is XHTML
*/
PHALCON_INIT_VAR(doctype);
PHALCON_CALL_SELF(doctype, this_ptr, "getdoctype");
if (phalcon_memnstr_str(doctype, SL("XHTML") TSRMLS_CC)) {
phalcon_concat_self_str(code, SL(" />") TSRMLS_CC);
} else {
phalcon_concat_self_str(code, SL(">") 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;
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_INIT_VAR(table);
PHALCON_CONCAT_SVSVS(table, "`", schema_name, "`.`", table_name, "`");
} else {
PHALCON_INIT_VAR(table);
PHALCON_CONCAT_SVS(table, "`", table_name, "`");
}
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 0);
eval_int = phalcon_array_isset_string(definition, SL("options")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC);
eval_int = phalcon_array_isset_string(r0, SL("temporary")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, r1, SL("temporary"), PH_NOISY_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 1);
}
}
}
if (zend_is_true(temporary)) {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "CREATE TEMPORARY TABLE ", table, " (\n\t");
} else {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "CREATE TABLE ", table, " (\n\t");
}
PHALCON_INIT_VAR(create_lines);
array_init(create_lines);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, definition, SL("columns"), PH_NOISY_CC);
if (!phalcon_valid_foreach(r3 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(r3);
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(r4);
PHALCON_CALL_METHOD(r4, column, "getname", PH_NO_CHECK);
PHALCON_INIT_VAR(r5);
PHALCON_CALL_SELF_PARAMS_1(r5, this_ptr, "getcolumndefinition", column);
PHALCON_INIT_VAR(column_line);
PHALCON_CONCAT_SVSV(column_line, "`", r4, "` ", r5);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_METHOD(r6, column, "isnotnull", PH_NO_CHECK);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(t0);
ZVAL_STRING(t0, " NOT NULL", 1);
phalcon_concat_self(&column_line, t0 TSRMLS_CC);
}
PHALCON_INIT_VAR(r7);
PHALCON_CALL_METHOD(r7, column, "isautoincrement", PH_NO_CHECK);
if (zend_is_true(r7)) {
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, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_52be_2;
fee_52be_2:
if(0){}
eval_int = phalcon_array_isset_string(definition, SL("indexes")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_string(&r8, definition, SL("indexes"), PH_NOISY_CC);
if (!phalcon_valid_foreach(r8 TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(r8);
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(index_name);
PHALCON_CALL_METHOD(index_name, index, "getname", PH_NO_CHECK);
PHALCON_INIT_VAR(r9);
PHALCON_CALL_METHOD(r9, index, "getcolumns", PH_NO_CHECK);
PHALCON_INIT_VAR(column_list);
PHALCON_CALL_SELF_PARAMS_1(column_list, this_ptr, "getcolumnlist", r9);
if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) {
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_SVS(r10, "PRIMARY KEY (", column_list, ")");
phalcon_array_append(&create_lines, r10, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r11);
PHALCON_CONCAT_SVSVS(r11, "KEY `", index_name, "` (", column_list, ")");
phalcon_array_append(&create_lines, r11, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_52be_3;
fee_52be_3:
if(0){}
}
eval_int = phalcon_array_isset_string(definition, SL("references")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r12);
phalcon_array_fetch_string(&r12, definition, SL("references"), PH_NOISY_CC);
if (!phalcon_valid_foreach(r12 TSRMLS_CC)) {
return;
}
ah2 = Z_ARRVAL_P(r12);
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(r13);
PHALCON_CALL_METHOD(r13, reference, "getname", PH_NO_CHECK);
PHALCON_INIT_VAR(r14);
PHALCON_CALL_METHOD(r14, reference, "getcolumns", PH_NO_CHECK);
PHALCON_INIT_VAR(r15);
PHALCON_CALL_SELF_PARAMS_1(r15, this_ptr, "getcolumnlist", r14);
PHALCON_INIT_VAR(reference_sql);
PHALCON_CONCAT_SVSV(reference_sql, "CONSTRAINT `", r13, "` FOREIGN KEY (", r15);
PHALCON_INIT_VAR(r16);
PHALCON_CALL_METHOD(r16, reference, "getreferencedtable", PH_NO_CHECK);
PHALCON_INIT_VAR(r17);
PHALCON_CALL_METHOD(r17, reference, "getreferencedcolumns", PH_NO_CHECK);
PHALCON_INIT_VAR(r18);
PHALCON_CALL_SELF_PARAMS_1(r18, this_ptr, "getcolumnlist", r17);
PHALCON_INIT_VAR(r19);
PHALCON_CONCAT_SVSVS(r19, ") REFERENCES `", r16, "`(", r18, ")");
phalcon_concat_self(&reference_sql, r19 TSRMLS_CC);
phalcon_array_append(&create_lines, reference_sql, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_52be_4;
fee_52be_4:
if(0){}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ",\n\t", 1);
PHALCON_ALLOC_ZVAL_MM(r20);
phalcon_fast_join(r20, c0, create_lines TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r21);
PHALCON_CONCAT_VS(r21, r20, "\n)");
phalcon_concat_self(&sql, r21 TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, SL("options")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r22);
PHALCON_CALL_SELF_PARAMS_1(r22, this_ptr, "_gettableoptions", definition);
PHALCON_ALLOC_ZVAL_MM(r23);
PHALCON_CONCAT_SV(r23, " ", r22);
phalcon_concat_self(&sql, r23 TSRMLS_CC);
}
RETURN_CTOR(sql);
}
/**
* Appends a message to the validator
*
* @param string $message
* @param string $field
* @param string $type
*/
PHP_METHOD(Phalcon_Model_Validator, appendMessage){
zval *v0 = NULL, *v1 = NULL, *v2 = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *i0 = NULL;
zval *p0[] = { NULL, NULL, NULL }, *p2[] = { NULL, NULL, NULL };
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &v0, &v1, &v2) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!v1) {
PHALCON_INIT_VAR(v1);
ZVAL_STRING(v1, "", 1);
} else {
PHALCON_SEPARATE_PARAM(v1);
}
if (!v2) {
PHALCON_INIT_VAR(v2);
ZVAL_STRING(v2, "", 1);
} else {
PHALCON_SEPARATE_PARAM(v2);
}
if (PHALCON_COMPARE_STRING(v1, "")) {
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_fieldName", sizeof("_fieldName")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
PHALCON_CPY_WRT(v1, t0);
}
if (PHALCON_COMPARE_STRING(v2, "")) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_INIT_VAR(p0[0]);
ZVAL_STRING(p0[0], "Validator", 1);
PHALCON_INIT_VAR(p0[1]);
ZVAL_STRING(p0[1], "", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "get_class", this_ptr, 0x049);
p0[2] = r1;
PHALCON_CALL_FUNC_PARAMS(r0, "str_replace", 3, p0, 0x01A);
PHALCON_CPY_WRT(v2, r0);
}
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_model_message_class_entry);
Z_ADDREF_P(v0);
p2[0] = v0;
Z_ADDREF_P(v1);
p2[1] = v1;
Z_ADDREF_P(v2);
p2[2] = v2;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 3, p2, PHALCON_CALL_CHECK);
Z_DELREF_P(p2[0]);
Z_DELREF_P(p2[1]);
Z_DELREF_P(p2[2]);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_messages", sizeof("_messages")-1, PHALCON_NOISY_FETCH TSRMLS_CC);
Z_ADDREF_P(i0);
phalcon_array_append(t1, i0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_messages", strlen("_messages"), t1 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Get the conditions of query
*
* @return string $query
*/
PHP_METHOD(Phalcon_Model_Query, getConditions){
zval *controller_front = NULL, *model_manager = NULL, *model_name = NULL;
zval *entity = NULL, *meta_data = NULL, *attributes = NULL, *numeric_types = NULL;
zval *i = NULL, *parameters = NULL, *conditions = NULL, *value = NULL, *param = NULL;
zval *condition = NULL, *index = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = 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 *i0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *c0 = NULL;
HashTable *ah0, *ah1, *ah2;
HashPosition hp0, hp1, hp2;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC);
if (!zend_is_true(t0)) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC(r0, "phalcon_controller_front", "getinstance");
PHALCON_CPY_WRT(controller_front, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, controller_front, "getmodelcomponent", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(model_manager, r1);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(this_ptr, "setmanager", model_manager, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(model_manager, t1);
}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "_models", sizeof("_models")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t2 TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(t2);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_a355_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_a355_0;
}
PHALCON_INIT_VAR(model_name);
ZVAL_ZVAL(model_name, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD_PARAMS_1(r2, model_manager, "getmodel", model_name, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(entity, r2);
if (!zend_is_true(entity)) {
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_model_exception_ce);
PHALCON_INIT_VAR(r3);
PHALCON_CONCAT_BOTH(r3, "The model ", model_name, " does not exist");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r3, PHALCON_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(r4);
PHALCON_CALL_METHOD(r4, model_manager, "getmetadata", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_data, r4);
PHALCON_INIT_VAR(r5);
PHALCON_CALL_METHOD_PARAMS_1(r5, meta_data, "getattributes", entity, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(attributes, r5);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_METHOD_PARAMS_1(r6, meta_data, "getdatatypesnumeric", entity, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(numeric_types, r6);
PHALCON_INIT_VAR(t3);
phalcon_read_property(&t3, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(r7);
phalcon_fast_count(r7, t3 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(parameters, a0);
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_CPY_WRT(conditions, a1);
PHALCON_INIT_VAR(t4);
phalcon_read_property(&t4, this_ptr, "_data", sizeof("_data")-1, PHALCON_NOISY TSRMLS_CC);
if (phalcon_valid_foreach(t4 TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(t4);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_a355_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_a355_1;
} else {
PHALCON_INIT_VAR(param);
PHALCON_GET_FOREACH_KEY(param, ah1, hp1);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r8);
PHALCON_CALL_FUNC_PARAMS_2(r8, "in_array", param, attributes, 0x03E);
if (zend_is_true(r8)) {
PHALCON_INIT_VAR(t5);
ZVAL_STRING(t5, "", 1);
PHALCON_INIT_VAR(r9);
is_not_identical_function(r9, t5, value TSRMLS_CC);
PHALCON_INIT_VAR(r11);
PHALCON_CALL_FUNC_PARAMS_1(r11, "is_null", value, 0x041);
PHALCON_INIT_VAR(r10);
boolean_not_function(r10, r11 TSRMLS_CC);
PHALCON_INIT_VAR(r12);
phalcon_and_function(r12, r9, r10);
if (zend_is_true(r12)) {
if (!PHALCON_COMPARE_STRING(value, "@")) {
eval_int = phalcon_array_isset(numeric_types, param);
if (eval_int) {
PHALCON_INIT_VAR(r13);
PHALCON_CONCAT_VBOTH(r13, param, " = ?", i);
PHALCON_CPY_WRT(condition, r13);
phalcon_array_update(¶meters, i, &value, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r14);
PHALCON_CONCAT_VBOTH(r14, param, " LIKE ?", i);
PHALCON_CPY_WRT(condition, r14);
PHALCON_INIT_VAR(r15);
PHALCON_CONCAT_BOTH(r15, "%", value, "%");
phalcon_array_update(¶meters, i, &r15, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&conditions, condition, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
}
}
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_a355_1;
fee_a355_1:
if(0){}
} else {
return;
}
} else {
PHALCON_INIT_VAR(t6);
phalcon_read_property(&t6, this_ptr, "_parameters", sizeof("_parameters")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(parameters, t6);
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, this_ptr, "_conditions", sizeof("_conditions")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(conditions, t7);
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(r16);
phalcon_fast_join(r16, c0, conditions TSRMLS_CC);
PHALCON_CPY_WRT(conditions, r16);
if (phalcon_valid_foreach(parameters TSRMLS_CC)) {
ah2 = Z_ARRVAL_P(parameters);
zend_hash_internal_pointer_reset_ex(ah2, &hp2);
fes_a355_2:
if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){
goto fee_a355_2;
} else {
PHALCON_INIT_VAR(index);
PHALCON_GET_FOREACH_KEY(index, ah2, hp2);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
PHALCON_INIT_VAR(r17);
PHALCON_INIT_VAR(r18);
PHALCON_CONCAT_LEFT(r18, "?", index);
PHALCON_CALL_FUNC_PARAMS_3(r17, "str_replace", r18, value, conditions, 0x003);
PHALCON_CPY_WRT(conditions, r17);
zend_hash_move_forward_ex(ah2, &hp2);
goto fes_a355_2;
fee_a355_2:
if(0){}
} else {
return;
}
if (PHALCON_COMPARE_STRING(conditions, "")) {
PHALCON_INIT_VAR(conditions);
ZVAL_STRING(conditions, "1=1", 1);
}
PHALCON_RETURN_CHECK_CTOR(conditions);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_a355_0;
fee_a355_0:
if(0){}
} else {
return;
}
PHALCON_MM_RESTORE();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>
* print_r($connection->describeColumns("posts")); ?>
* </code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns){
zval *table, *schema = NULL, *columns, *dialect, *sql, *fetch_assoc;
zval *describe, *old_column = NULL, *size_pattern, *field = NULL;
zval *definition = NULL, *column_type = NULL, *matches = NULL, *pos = NULL;
zval *match_one = NULL, *attribute = NULL, *column_name = NULL, *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_INIT_NVAR(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(old_column);
PHALCON_INIT_VAR(size_pattern);
ZVAL_STRING(size_pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
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(field);
PHALCON_INIT_NVAR(definition);
array_init(definition);
add_assoc_long_ex(definition, SS("bindType"), 2);
/**
* By checking every column type we convert it to a Phalcon\Db\Column
*/
PHALCON_INIT_NVAR(column_type);
phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC);
if (phalcon_memnstr_str(column_type, SL("int") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("varchar") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("date") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("decimal") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("char") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("datetime") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("text") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("float") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("enum") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
}
}
}
}
}
}
}
}
}
/**
* If the column type has a parentheses we try to get the column size from it
*/
if (phalcon_memnstr_str(column_type, SL("(") TSRMLS_CC)) {
PHALCON_INIT_NVAR(matches);
array_init(matches);
Z_SET_ISREF_P(matches);
PHALCON_INIT_NVAR(pos);
PHALCON_CALL_FUNC_PARAMS_3(pos, "preg_match", size_pattern, column_type, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(pos)) {
eval_int = phalcon_array_isset_long(matches, 1);
if (eval_int) {
PHALCON_INIT_NVAR(match_one);
phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY_CC);
phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
}
/**
* Check if the column is unsigned, only MySQL support this
*/
if (phalcon_memnstr_str(column_type, SL("unsigned") TSRMLS_CC)) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC);
}
if (!zend_is_true(old_column)) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
/**
* Check if the field is primary key
*/
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("key"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "PRI")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC);
}
/**
* Check if the column allows null values
*/
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("null"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "NO")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC);
}
/**
* Check if the column is auto increment
*/
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("extra"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "auto_increment")) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(column_name);
phalcon_array_fetch_string(&column_name, field, SL("field"), PH_NOISY_CC);
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK);
phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CTOR(columns);
}
/**
* Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST
*
* @param Phalcon\DI $dependencyInjector
* @param string $modelName
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput){
zval *dependency_injector = NULL, *model_name = NULL, *data = NULL;
zval *conditions = NULL, *number_data = NULL, *service = NULL, *meta_data = NULL;
zval *model = NULL, *data_types = NULL, *bind = NULL, *value = NULL, *field = NULL, *type = NULL;
zval *condition = NULL, *value_pattern = NULL, *criteria = NULL, *number_conditions = NULL;
zval *join_conditions = NULL;
zval *c0 = 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, "zzz", &dependency_injector, &model_name, &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Input data must be an Array");
return;
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A dependency injector container is required to obtain the ORM services");
return;
}
PHALCON_INIT_VAR(conditions);
array_init(conditions);
PHALCON_INIT_VAR(number_data);
phalcon_fast_count(number_data, data TSRMLS_CC);
if (!phalcon_compare_strict_long(number_data, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "modelsMetadata", 1);
PHALCON_INIT_VAR(meta_data);
PHALCON_CALL_METHOD_PARAMS_1(meta_data, dependency_injector, "getshared", service, PH_NO_CHECK);
ce0 = phalcon_fetch_class(model_name TSRMLS_CC);
PHALCON_INIT_VAR(model);
object_init_ex(model, ce0);
PHALCON_CALL_METHOD_NORETURN(model, "__construct", PH_CHECK);
PHALCON_INIT_VAR(data_types);
PHALCON_CALL_METHOD_PARAMS_1(data_types, meta_data, "getdatatypes", model, PH_NO_CHECK);
PHALCON_INIT_VAR(bind);
array_init(bind);
if (!phalcon_valid_foreach(data TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(data);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_1d26_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_1d26_0;
}
PHALCON_INIT_VAR(field);
PHALCON_GET_FOREACH_KEY(field, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
eval_int = phalcon_array_isset(data_types, field);
if (eval_int) {
if (Z_TYPE_P(value) != IS_NULL) {
if (!PHALCON_COMPARE_STRING(value, "")) {
PHALCON_INIT_VAR(type);
phalcon_array_fetch(&type, data_types, field, PH_NOISY_CC);
if (phalcon_compare_strict_long(type, 2 TSRMLS_CC)) {
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSVS(condition, field, " LIKE :", field, ":");
PHALCON_INIT_VAR(value_pattern);
PHALCON_CONCAT_SVS(value_pattern, "%", value, "%");
phalcon_array_update_zval(&bind, field, &value_pattern, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSVS(condition, field, "=:", field, ":");
phalcon_array_update_zval(&bind, field, &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_1d26_0;
fee_1d26_0:
if(0){}
}
PHALCON_INIT_VAR(criteria);
object_init_ex(criteria, phalcon_mvc_model_criteria_ce);
PHALCON_CALL_METHOD_NORETURN(criteria, "__construct", PH_CHECK);
PHALCON_INIT_VAR(number_conditions);
phalcon_fast_count(number_conditions, conditions TSRMLS_CC);
if (!phalcon_compare_strict_long(number_conditions, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(criteria, "where", join_conditions, PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(criteria, "bind", bind, PH_NO_CHECK);
}
RETURN_CTOR(criteria);
}
/**
* 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);
}
/**
* Magic method __get
*
* @param string $propertyName
*/
PHP_METHOD(Phalcon_Controller, __get){
zval *property_name = NULL, *model = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *i0 = NULL, *i1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &property_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (PHALCON_COMPARE_STRING(property_name, "view")) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "_getviewcomponent", PHALCON_NO_CHECK);
phalcon_update_property_zval(this_ptr, "view", strlen("view"), r0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "view", sizeof("view")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(t0);
}
if (PHALCON_COMPARE_STRING(property_name, "filter")) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_filter_ce);
PHALCON_CALL_METHOD_NORETURN(i0, "__construct", PHALCON_CHECK);
phalcon_update_property_zval(this_ptr, "filter", strlen("filter"), i0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "filter", sizeof("filter")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(t1);
}
if (PHALCON_COMPARE_STRING(property_name, "session")) {
PHALCON_ALLOC_ZVAL_MM(i1);
object_init_ex(i1, phalcon_session_namespace_ce);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_get_class(r1, this_ptr TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i1, "__construct", r1, PHALCON_CHECK);
phalcon_update_property_zval(this_ptr, "session", strlen("session"), i1 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, "session", sizeof("session")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_RETURN_CHECK_CTOR(t2);
}
PHALCON_ALLOC_ZVAL_MM(t3);
phalcon_read_property(&t3, this_ptr, "model", sizeof("model")-1, PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t3)) {
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, "model", sizeof("model")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(model, t4);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD_PARAMS_1(r2, model, "ismodel", property_name, PHALCON_NO_CHECK);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD_PARAMS_1(r3, model, "getmodel", property_name, PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r3);
}
}
PHALCON_ALLOC_ZVAL_MM(r4);
PHALCON_CONCAT_LEFT(r4, "Access to undefined property ", property_name);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("trigger_error", r4, 0x033);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns){
zval *table = NULL, *schema = NULL, *columns = NULL, *sql = NULL, *fetch_assoc = NULL;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *column_type = NULL;
zval *status = NULL, *matches = NULL, *pattern = NULL, *attribute = NULL, *column_name = NULL;
zval *column = NULL, *dialect = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *status2 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_ALLOC_ZVAL_MM(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(old_column);
ZVAL_NULL(old_column);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
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(field);
PHALCON_INIT_VAR(definition);
array_init(definition);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_INIT_VAR(column_type);
phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC);
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("int") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 0);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 32); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 1);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("varchar") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("date") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
PHALCON_INIT_VAR(status2);
phalcon_fast_strpos_str(status, column_type, SL("numeric") TSRMLS_CC);
phalcon_fast_strpos_str(status2, column_type, SL("decimal") TSRMLS_CC);
if ( (PHALCON_IS_NOT_FALSE(status)) || (PHALCON_IS_NOT_FALSE(status2)) ) {
add_assoc_long_ex(definition, SS("type"), 3);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 32); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 32);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("char") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 5);
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("timestamp") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 4);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("text") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 6);
phalcon_array_update_string_long(&definition, SL("size"), 2147483647, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("float") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
add_assoc_long_ex(definition, SS("type"), 7);
add_assoc_bool_ex(definition, SS("isNumeric"), 1);
add_assoc_long_ex(definition, SS("size"), 64); // default 4byte
add_assoc_long_ex(definition, SS("bindType"), 32);
} else {
add_assoc_long_ex(definition, SS("type"), 5);
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("uuid") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_long(&definition, SL("size"), 255, PH_SEPARATE TSRMLS_CC);
}
}
}
}
}
}
}
}
}
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("(") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
PHALCON_INIT_VAR(matches);
array_init(matches);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_FUNC_PARAMS_3(r0, "preg_match", pattern, column_type, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(r0)) {
eval_int = phalcon_array_isset_long(matches, 1);
if (eval_int) {
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_long(&r1, matches, 1, PH_NOISY_CC);
phalcon_array_update_string(&definition, SL("size"), &r1, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
}
PHALCON_INIT_VAR(status);
phalcon_fast_strpos_str(status, column_type, SL("unsigned") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(status)) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "1")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC);
}else {
phalcon_array_update_string_bool(&definition, SL("primary"), 0, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("notnull"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(attribute, "1")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(r0);
phalcon_fast_strpos_str(r0, column_type, SL("integer") TSRMLS_CC);
PHALCON_INIT_VAR(r1);
phalcon_array_fetch_string(&r1, definition, SL("primary"), PH_NOISY_CC);
if ((PHALCON_IS_NOT_FALSE(r0)) && (PHALCON_IS_NOT_FALSE(r1))) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, field, SL("name"), PH_NOISY_CC);
PHALCON_INIT_VAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK);
phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CTOR(columns);}
