/**
* List all tables on a database
*
*
*
* @param string $schemaName
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, listTables){
zval *schema_name = NULL, *sql = NULL, *tables = NULL, *all_tables = NULL, *table = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL;
zval *a0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &schema_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema_name) {
PHALCON_INIT_VAR(schema_name);
ZVAL_NULL(schema_name);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC_PARAMS_1(r0, "phalcon_db_dialect_mysql", "listtables", schema_name);
PHALCON_CPY_WRT(sql, r0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 2);
PHALCON_CALL_METHOD_PARAMS_2(r1, this_ptr, "fetchall", sql, t0, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(tables, r1);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(all_tables, a0);
if (phalcon_valid_foreach(tables TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(tables);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_321f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_321f_1;
}
PHALCON_INIT_VAR(table);
ZVAL_ZVAL(table, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
phalcon_array_fetch_long(&r2, table, 0, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(&all_tables, r2, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_321f_1;
fee_321f_1:
if(0){}
} else {
return;
}
RETURN_CTOR(all_tables);
}
/**
* Sends the headers to the client
*
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Response_Headers, send){
zval *headers_was_sent, *t, *headers, *value = NULL, *header = NULL;
zval *http_header = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(headers_was_sent);
PHALCON_CALL_FUNC(headers_was_sent, "headers_sent");
if (!zend_is_true(headers_was_sent)) {
PHALCON_INIT_VAR(t);
ZVAL_BOOL(t, 1);
PHALCON_INIT_VAR(headers);
phalcon_read_property(&headers, this_ptr, SL("_headers"), PH_NOISY_CC);
if (!phalcon_valid_foreach(headers TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(headers);
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(header, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (zend_is_true(value)) {
PHALCON_INIT_NVAR(http_header);
PHALCON_CONCAT_VSV(http_header, header, ": ", value);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("header", http_header, t);
} else {
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("header", header, t);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Uncamelize strings which are camelized
*
*<code>
* echo Phalcon\Text::camelize('CocoBongo'); //coco_bongo
*</code>
*
* @param string $str
* @return string
*/
PHP_METHOD(Phalcon_Text, uncamelize){
zval *str = NULL, *patterns = NULL, *replacement = NULL, *pattern = NULL, *match_pattern = NULL;
zval *pattern_replace = NULL, *lower_pattern = NULL, *lower_str = 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, "z", &str) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(patterns);
array_init(patterns);
add_assoc_stringl_ex(patterns, SL("/(?<=(?:[A-Z]))([A-Z]+)([A-Z][A-z])/")+1, SL("\\1_\\2"), 1);
add_assoc_stringl_ex(patterns, SL("/(?<=(?:[a-z]))([A-Z])/")+1, SL("_\\1"), 1);
if (!phalcon_valid_foreach(patterns TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(patterns);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_f8ee_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_f8ee_0;
}
PHALCON_INIT_VAR(pattern);
PHALCON_GET_FOREACH_KEY(pattern, ah0, hp0);
PHALCON_INIT_VAR(replacement);
ZVAL_ZVAL(replacement, *hd, 1, 0);
PHALCON_INIT_VAR(match_pattern);
PHALCON_CALL_FUNC_PARAMS_2(match_pattern, "preg_match", pattern, str);
if (zend_is_true(match_pattern)) {
PHALCON_INIT_VAR(pattern_replace);
PHALCON_CALL_FUNC_PARAMS_3(pattern_replace, "preg_replace", pattern, replacement, str);
PHALCON_INIT_VAR(lower_pattern);
PHALCON_CALL_FUNC_PARAMS_1(lower_pattern, "strtolower", pattern_replace);
RETURN_CTOR(lower_pattern);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_f8ee_0;
fee_f8ee_0:
PHALCON_INIT_VAR(lower_str);
PHALCON_CALL_FUNC_PARAMS_1(lower_str, "strtolower", str);
RETURN_CTOR(lower_str);
}
/**
* List all tables on a database
*
* @param string $schemaName
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, listTables){
zval *schema_name = NULL, *sql = NULL, *tables = NULL, *all_tables = NULL, *table = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &schema_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema_name) {
PHALCON_ALLOC_ZVAL_MM(schema_name);
ZVAL_NULL(schema_name);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_1(sql, t0, "listtables", schema_name, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_get_class_constant(t1, phalcon_db_ce, SL("FETCH_NUM") TSRMLS_CC);
PHALCON_INIT_VAR(tables);
PHALCON_CALL_METHOD_PARAMS_2(tables, this_ptr, "fetchall", sql, t1, PH_NO_CHECK);
PHALCON_INIT_VAR(all_tables);
array_init(all_tables);
if (!phalcon_valid_foreach(tables TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(tables);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_7f5d_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_7f5d_3;
}
PHALCON_INIT_VAR(table);
ZVAL_ZVAL(table, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
phalcon_array_fetch_long(&r0, table, 0, PH_NOISY_CC);
phalcon_array_append(&all_tables, r0, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_7f5d_3;
fee_7f5d_3:
if(0){}
RETURN_CTOR(all_tables);
}
/**
* Renders a view using the template engine
*
* @param string $path
* @param array $params
* @param bool $mustClean
*/
PHP_METHOD(Phalcon_Mvc_View_Engine_Php, render){
zval *path = NULL, *params = NULL, *must_clean = NULL, *value = NULL, *key = NULL, *contents = NULL;
zval *view = 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, "zzz", &path, ¶ms, &must_clean) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(must_clean) == IS_BOOL && Z_BVAL_P(must_clean)) {
PHALCON_CALL_FUNC_NORETURN("ob_clean");
}
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_1897_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_1897_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
if (phalcon_set_symbol(key, value TSRMLS_CC) == FAILURE){
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_1897_0;
fee_1897_0:
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
if (Z_TYPE_P(must_clean) == IS_BOOL && Z_BVAL_P(must_clean)) {
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
PHALCON_INIT_VAR(view);
phalcon_read_property(&view, this_ptr, SL("_view"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(view, "setcontent", contents, PH_NO_CHECK);
}
PHALCON_MM_RESTORE();
}
PHP_METHOD(Phalcon_Flash, _showMessage){
zval *message = NULL, *classes = NULL, *css_classes = NULL, *msg = NULL;
zval *c0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL, *t1 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &message, &classes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(classes) == IS_ARRAY) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " ", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_join(r0, c0, classes TSRMLS_CC);
PHALCON_CPY_WRT(css_classes, r0);
} else {
PHALCON_CPY_WRT(css_classes, classes);
}
if (Z_TYPE_P(message) == IS_ARRAY) {
if (phalcon_valid_foreach(message TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(message);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_3b3c_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_3b3c_0;
}
PHALCON_INIT_VAR(msg);
ZVAL_ZVAL(msg, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_INIT_VAR(t0);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_CONCAT_SVSVSV(r1, "<div class=\"", css_classes, "\">", msg, "</div>", t0);
zend_print_zval(r1, 1);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_3b3c_0;
fee_3b3c_0:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_ALLOC_ZVAL_MM(t1);
zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t1 TSRMLS_CC);
PHALCON_CONCAT_SVSVSV(r2, "<div class=\"", css_classes, "\">", message, "</div>", t1);
zend_print_zval(r2, 1);
}
PHALCON_MM_RESTORE();
}
/**
* Sets the default descriptor for database connections.
*
*
*
* @param array $options
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Pool, setDefaultDescriptor){
zval *options = NULL, *descriptor = NULL, *value = NULL, *key = NULL;
zval *i0 = 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, "z", &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(options) != IS_ARRAY) {
if (Z_TYPE_P(options) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The parameter 'options' must be an Array or Object");
return;
}
}
if (Z_TYPE_P(options) == IS_ARRAY) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init(i0);
PHALCON_CPY_WRT(descriptor, i0);
if (phalcon_valid_foreach(options TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(options);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_162f_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_162f_0;
} else {
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
}
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
phalcon_update_property_zval_zval(descriptor, key, value TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_162f_0;
fee_162f_0:
if(0){}
} else {
return;
}
} else {
PHALCON_CPY_WRT(descriptor, options);
}
phalcon_update_static_property(SL("Phalcon_Db_Pool"), SL("_defaultDescriptor"), descriptor TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *message = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(t0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t1 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(t1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_METHOD(r1, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD(r2, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_METHOD_PARAMS_3(r3, this_ptr, "_applyformat", r0, r1, r2, PH_NO_CHECK);
PHALCON_INIT_VAR(t3);
zend_get_constant(SL("PHP_EOL"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VV(r4, r3, t3);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t2, r4);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Restore a Phalcon\Http\Response\Headers object
*
* @return Phalcon\Http\Response\Headers
*/
PHP_METHOD(Phalcon_Http_Response_Headers, __set_state){
zval *data, *headers, *data_headers, *value = NULL, *key = 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", &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(headers);
object_init_ex(headers, phalcon_http_response_headers_ce);
PHALCON_CALL_METHOD_NORETURN(headers, "__construct", PH_CHECK);
eval_int = phalcon_array_isset_string(data, SS("_headers"));
if (eval_int) {
PHALCON_INIT_VAR(data_headers);
phalcon_array_fetch_string(&data_headers, data, SL("_headers"), PH_NOISY_CC);
if (!phalcon_valid_foreach(data_headers TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(data_headers);
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);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(headers, "set", key, value, PH_NO_CHECK);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
RETURN_CTOR(headers);
}
/**
* Check if HTTP method match any of the passed methods
*
* @param string|array $methods
* @return boolean
*/
PHP_METHOD(Phalcon_Http_Request, isMethod) {
zval *methods, *http_method, *is_equals = NULL, *method = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &methods) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(http_method);
PHALCON_CALL_METHOD(http_method, this_ptr, "getmethod", PH_NO_CHECK);
if (Z_TYPE_P(methods) == IS_STRING) {
PHALCON_INIT_VAR(is_equals);
is_equal_function(is_equals, methods, http_method TSRMLS_CC);
RETURN_NCTOR(is_equals);
} else {
if (!phalcon_valid_foreach(methods TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(methods);
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(method);
PHALCON_INIT_NVAR(is_equals);
is_equal_function(is_equals, method, http_method TSRMLS_CC);
if (PHALCON_IS_TRUE(is_equals)) {
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0) {}
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Prints the messages in the session flasher
*
* @param string $type
* @param boolean $remove
*/
PHP_METHOD(Phalcon_Flash_Session, output){
zval *remove = NULL, *messages, *message = NULL, *type = 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, "|z", &remove) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!remove) {
PHALCON_INIT_NVAR(remove);
ZVAL_BOOL(remove, 1);
}
PHALCON_INIT_VAR(messages);
PHALCON_CALL_METHOD_PARAMS_1(messages, this_ptr, "_getsessionmessages", remove, PH_NO_CHECK);
if (Z_TYPE_P(messages) == IS_ARRAY) {
if (!phalcon_valid_foreach(messages TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(messages);
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(type, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(message);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "outputmessage", type, message, PH_NO_CHECK);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
PHALCON_MM_RESTORE();
}
/**
* Sanizites a value with a specified single or set of filters
*
* @param mixed $value
* @param mixed $filters
* @return mixed
*/
PHP_METHOD(Phalcon_Filter, sanitize){
zval *value, *filters, *new_value = NULL, *filter = NULL, *filter_value = NULL;
zval *sanizited_value;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(filters) == IS_ARRAY) {
PHALCON_CPY_WRT(new_value, value);
if (Z_TYPE_P(value) != IS_NULL) {
if (!phalcon_valid_foreach(filters TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(filters);
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(filter);
PHALCON_INIT_NVAR(filter_value);
PHALCON_CALL_METHOD_PARAMS_2(filter_value, this_ptr, "_sanitize", new_value, filter, PH_NO_CHECK);
PHALCON_CPY_WRT(new_value, filter_value);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
RETURN_CCTOR(new_value);
}
PHALCON_INIT_VAR(sanizited_value);
PHALCON_CALL_METHOD_PARAMS_2(sanizited_value, this_ptr, "_sanitize", value, filters, PH_NO_CHECK);
RETURN_CCTOR(sanizited_value);
}
/**
* Gets attached files as Phalcon_Request_File instances
*
* @return array
*/
PHP_METHOD(Phalcon_Request, getUploadedFiles){
zval *super_files = NULL, *files = NULL, *file = NULL;
zval *g0 = NULL;
zval *r0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *i0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_get_global(&g0, "_FILES", sizeof("_FILES") TSRMLS_CC);
PHALCON_CPY_WRT(super_files, g0);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, super_files TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(files, a0);
if (phalcon_valid_foreach(super_files TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(super_files);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9aea_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9aea_0;
}
PHALCON_INIT_VAR(file);
ZVAL_ZVAL(file, *hd, 1, 0);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_request_file_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", file, PHALCON_CHECK);
phalcon_array_append(&files, i0, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9aea_0;
fee_9aea_0:
if(0){}
} else {
return;
}
PHALCON_RETURN_CTOR(files);
}
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_RETURN_CTOR(a1);
}
/**
* Gets a list of columns
*
* @param array $columnList
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnList){
zval *column_list = NULL, *str_list = NULL, *column = NULL, *column_quoted = NULL;
zval *comma = NULL, *joined_list = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column_list) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(str_list);
array_init(str_list);
if (!phalcon_valid_foreach(column_list TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(column_list);
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(column);
PHALCON_INIT_VAR(column_quoted);
PHALCON_CONCAT_SVS(column_quoted, "\"", column, "\"");
phalcon_array_append(&str_list, column_quoted, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(comma);
ZVAL_STRING(comma, ", ", 1);
PHALCON_INIT_VAR(joined_list);
phalcon_fast_join(joined_list, comma, str_list TSRMLS_CC);
RETURN_CTOR(joined_list);
}
/**
* Returns a route object by its name
*
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router, getRouteByName) {
zval *name = NULL, *routes = NULL, *route = NULL, *route_name = NULL, *is_equal = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(routes);
phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC);
if (!phalcon_valid_foreach(routes TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(routes);
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(route);
PHALCON_INIT_VAR(route_name);
PHALCON_CALL_METHOD(route_name, route, "getname", PH_NO_CHECK);
PHALCON_INIT_VAR(is_equal);
is_equal_function(is_equal, route_name, name TSRMLS_CC);
if (PHALCON_IS_TRUE(is_equal)) {
RETURN_CCTOR(route);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Gets attached files as Phalcon\Http\Request\File instances
*
* @return Phalcon\Http\Request\File[]
*/
PHP_METHOD(Phalcon_Http_Request, getUploadedFiles){
zval *super_files = NULL, *number_files = NULL, *files = NULL, *file = NULL;
zval *request_file = NULL, *empty_files = NULL;
zval *g0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_get_global(&g0, SL("_FILES")+1 TSRMLS_CC);
PHALCON_CPY_WRT(super_files, g0);
PHALCON_INIT_VAR(number_files);
phalcon_fast_count(number_files, super_files TSRMLS_CC);
if (zend_is_true(number_files)) {
PHALCON_INIT_VAR(files);
array_init(files);
if (!phalcon_valid_foreach(super_files TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(super_files);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ac06_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ac06_1;
}
PHALCON_INIT_VAR(file);
ZVAL_ZVAL(file, *hd, 1, 0);
PHALCON_INIT_VAR(request_file);
object_init_ex(request_file, phalcon_http_request_file_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(request_file, "__construct", file, PH_CHECK);
phalcon_array_append(&files, request_file, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ac06_1;
fee_ac06_1:
RETURN_CTOR(files);
}
PHALCON_INIT_VAR(empty_files);
array_init(empty_files);
RETURN_CTOR(empty_files);
}
/**
* Gets a list of columns
*
* @param array $columnList
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnList){
zval *column_list = NULL, *str_list = NULL, *column = NULL;
zval *a0 = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *c0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column_list) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(str_list, a0);
if (phalcon_valid_foreach(column_list TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(column_list);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_52be_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_52be_0;
}
PHALCON_INIT_VAR(column);
ZVAL_ZVAL(column, *hd, 1, 0);
PHALCON_INIT_VAR(r0);
PHALCON_CONCAT_SVS(r0, "`", column, "`");
phalcon_array_append(&str_list, r0, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_52be_0;
fee_52be_0:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_join(r1, c0, str_list TSRMLS_CC);
PHALCON_RETURN_DZVAL(r1);
}
/**
* Resets the request and internal values to avoid those fields will have any default value
*/
PHP_METHOD(Phalcon_Tag, resetInput){
zval *value = NULL, *key = NULL;
zval *a0 = NULL;
zval *g0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
phalcon_update_static_property(SL("phalcon\\tag"), SL("_displayValues"), a0 TSRMLS_CC);
phalcon_get_global(&g0, SL("_POST")+1 TSRMLS_CC);
if (!phalcon_valid_foreach(g0 TSRMLS_CC)) {
return;
}
ALLOC_HASHTABLE(ah0);
zend_hash_init(ah0, 0, NULL, NULL, 0);
zend_hash_copy(ah0, Z_ARRVAL_P(g0), NULL, NULL, sizeof(zval*));
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_9b93_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_9b93_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
phalcon_array_unset(g0, key);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_9b93_0;
fee_9b93_0:
zend_hash_destroy(ah0);
efree(ah0);
PHALCON_MM_RESTORE();
}
/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Uniqueness, validate){
zval *record = NULL, *field = NULL, *conditions = NULL, *compose_field = NULL;
zval *value = NULL, *manager = NULL, *meta_data = NULL, *primary_fields = NULL;
zval *primary_field = NULL, *options = 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 *i0 = NULL;
zval *a0 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *t0 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK);
if (zend_is_true(r0)) {
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getrecord", PHALCON_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(i0);
if (phalcon_clone(i0, r1 TSRMLS_CC) == FAILURE){
return;
}
PHALCON_CPY_WRT(record, i0);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_CALL_METHOD(r2, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field, r2);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(conditions, a0);
if (Z_TYPE_P(field) == IS_ARRAY) {
if (phalcon_valid_foreach(field TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(field);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_d73d_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_d73d_0;
}
PHALCON_INIT_VAR(compose_field);
ZVAL_ZVAL(compose_field, *hd, 1, 0);
PHALCON_INIT_VAR(r3);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_METHOD_PARAMS_1(r4, record, "readattribute", compose_field, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r3, "addslashes", r4, 0x00F);
PHALCON_CPY_WRT(value, r3);
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_VSVS(r5, compose_field, "='", value, "'");
phalcon_array_append(&conditions, r5, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_d73d_0;
fee_d73d_0:
if(0){}
} else {
return;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r6);
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CALL_METHOD(r7, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r6, "addslashes", r7, 0x00F);
PHALCON_CPY_WRT(value, r6);
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_VSVS(r8, field, "='", value, "'");
phalcon_array_append(&conditions, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r9);
PHALCON_CALL_METHOD(r9, record, "getmanager", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(manager, r9);
PHALCON_ALLOC_ZVAL_MM(r10);
PHALCON_CALL_METHOD(r10, manager, "getmetadata", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(meta_data, r10);
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD_PARAMS_1(r11, meta_data, "getprimarykeyattributes", record, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(primary_fields, r11);
if (phalcon_valid_foreach(primary_fields TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(primary_fields);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_d73d_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_d73d_1;
}
PHALCON_INIT_VAR(primary_field);
ZVAL_ZVAL(primary_field, *hd, 1, 0);
PHALCON_INIT_VAR(r12);
PHALCON_INIT_VAR(r13);
PHALCON_INIT_VAR(r14);
PHALCON_CALL_METHOD_PARAMS_1(r14, record, "readattribute", primary_field, PHALCON_NO_CHECK);
PHALCON_CALL_FUNC_PARAMS_1(r13, "addslashes", r14, 0x00F);
PHALCON_CONCAT_VSVS(r12, primary_field, "<>'", r13, "'");
phalcon_array_append(&conditions, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_d73d_1;
fee_d73d_1:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_fast_join(r15, c0, conditions TSRMLS_CC);
PHALCON_CPY_WRT(conditions, r15);
PHALCON_ALLOC_ZVAL_MM(r16);
PHALCON_CALL_STATIC_ZVAL_PARAMS_1(r16, record, "count", conditions);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 0);
PHALCON_INIT_VAR(r17);
is_smaller_function(r17, t0, r16 TSRMLS_CC);
if (zend_is_true(r17)) {
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_CALL_METHOD(r18, this_ptr, "getoptions", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(options, r18);
eval_int = phalcon_array_isset_string(options, "message", strlen("message")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r19);
phalcon_array_fetch_string(&r19, options, "message", strlen("message"), PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "unique", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r19, field, c1, PHALCON_NO_CHECK);
} else {
PHALCON_ALLOC_ZVAL_MM(r20);
PHALCON_CONCAT_SVS(r20, "Value of field '", field, "' is already present in another record");
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "unique", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r20, field, c2, PHALCON_NO_CHECK);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Routes to a controller/action using a string or array uri
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Dispatcher, forward){
zval *uri = NULL, *parts = NULL, *params = NULL, *value = NULL, *key = NULL;
zval *c0 = 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;
zval *a0 = 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", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(uri) == IS_ARRAY) {
PHALCON_CPY_WRT(parts, uri);
} else {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/", 1);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_explode(r0, c0, uri TSRMLS_CC);
PHALCON_CPY_WRT(parts, r0);
}
eval_int = phalcon_array_isset_long(parts, 0);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_long(&r1, parts, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_filter_alphanum(r2, r1);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), r2 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_long(parts, 0);
} else {
eval_int = phalcon_array_isset_string(parts, SL("controller")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, parts, SL("controller"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_filter_alphanum(r4, r3);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), r4 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, this_ptr, "getcontrollername", PHALCON_NO_CHECK);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), r5 TSRMLS_CC);
}
}
eval_int = phalcon_array_isset_long(parts, 1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_array_fetch_long(&r6, parts, 1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_filter_alphanum(r7, r6);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r7 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_long(&r8, parts, 1, PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r8 TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_long(parts, 1);
} else {
eval_int = phalcon_array_isset_string(parts, SL("action")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r9);
phalcon_array_fetch_string(&r9, parts, SL("action"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r10);
phalcon_filter_alphanum(r10, r9);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r10 TSRMLS_CC);
} else {
PHALCON_ALLOC_ZVAL_MM(r11);
PHALCON_CALL_METHOD(r11, this_ptr, "getactionname", PHALCON_NO_CHECK);
phalcon_update_property_zval(this_ptr, SL("_actionName"), r11 TSRMLS_CC);
}
}
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(params, a0);
if (phalcon_valid_foreach(parts TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(parts);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e10f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e10f_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(key) == IS_LONG) {
PHALCON_INIT_VAR(r12);
phalcon_array_fetch(&r12, parts, key, PHALCON_NOISY TSRMLS_CC);
phalcon_array_append(¶ms, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e10f_1;
fee_e10f_1:
if(0){}
} else {
return;
}
phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Updates data on a table using custom RBDM SQL syntax
*
* @param string $table
* @param array $fields
* @param array $values
* @param string $whereCondition
* @return boolean
*/
PHP_METHOD(Phalcon_Db, update){
zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL;
zval *placeholders = NULL, *value = NULL, *position = NULL, *field = NULL, *set_clause_part = NULL;
zval *comma = NULL, *set_clause = NULL, *update_sql = NULL, *success = 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, "zzz|z", &table, &fields, &values, &where_condition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!where_condition) {
PHALCON_ALLOC_ZVAL_MM(where_condition);
ZVAL_NULL(where_condition);
}
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
if (!phalcon_valid_foreach(values TSRMLS_CC)) {
return;
}
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);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_INIT_VAR(position);
PHALCON_GET_FOREACH_KEY(position, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
eval_int = phalcon_array_isset(fields, position);
if (eval_int) {
PHALCON_INIT_VAR(field);
phalcon_array_fetch(&field, fields, position, PH_NOISY_CC);
if (Z_TYPE_P(value) == IS_OBJECT) {
PHALCON_INIT_VAR(set_clause_part);
PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value);
phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE_PARAM(values);
phalcon_array_unset(values, position);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
PHALCON_INIT_VAR(set_clause_part);
PHALCON_CONCAT_VS(set_clause_part, field, " = null");
PHALCON_SEPARATE_PARAM(values);
phalcon_array_unset(values, position);
} else {
PHALCON_INIT_VAR(set_clause_part);
PHALCON_CONCAT_VS(set_clause_part, field, " = ?");
}
phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC);
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values in the update is not the same as fields");
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
zend_hash_destroy(ah0);
efree(ah0);
PHALCON_INIT_VAR(comma);
ZVAL_STRING(comma, ", ", 1);
PHALCON_INIT_VAR(set_clause);
phalcon_fast_join(set_clause, comma, placeholders TSRMLS_CC);
if (Z_TYPE_P(where_condition) != IS_NULL) {
PHALCON_INIT_VAR(update_sql);
PHALCON_CONCAT_SVSVSV(update_sql, "UPDATE ", table, " SET ", set_clause, " WHERE ", where_condition);
} else {
PHALCON_INIT_VAR(update_sql);
PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause);
}
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", update_sql, values, PH_NO_CHECK);
RETURN_CCTOR(success);
}
/**
* Inserts data into a table using custom RBDM SQL syntax
*
* @param string $table
* @param array $values
* @param array $fields
* @return boolean
*/
PHP_METHOD(Phalcon_Db, insert){
zval *table = NULL, *values = NULL, *fields = NULL, *number_values = NULL, *exception_message = NULL;
zval *exception = NULL, *placeholders = NULL, *value = NULL, *position = NULL;
zval *str_value = NULL, *comma = NULL, *joined_values = NULL, *joined_fields = NULL;
zval *insert_sql = NULL, *success = 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|z", &table, &values, &fields) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!fields) {
PHALCON_ALLOC_ZVAL_MM(fields);
ZVAL_NULL(fields);
}
if (Z_TYPE_P(values) == IS_ARRAY) {
PHALCON_INIT_VAR(number_values);
phalcon_fast_count(number_values, values TSRMLS_CC);
if (phalcon_compare_strict_long(number_values, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data");
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_db_exception_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
if (!phalcon_valid_foreach(values TSRMLS_CC)) {
return;
}
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);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_INIT_VAR(position);
PHALCON_GET_FOREACH_KEY(position, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(value) == IS_OBJECT) {
PHALCON_INIT_VAR(str_value);
PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value);
phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE_PARAM(values);
phalcon_array_unset(values, position);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE_PARAM(values);
phalcon_array_unset(values, position);
} else {
phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
zend_hash_destroy(ah0);
efree(ah0);
PHALCON_INIT_VAR(comma);
ZVAL_STRING(comma, ", ", 1);
PHALCON_INIT_VAR(joined_values);
phalcon_fast_join(joined_values, comma, placeholders TSRMLS_CC);
if (Z_TYPE_P(fields) == IS_ARRAY) {
PHALCON_INIT_VAR(joined_fields);
phalcon_fast_join(joined_fields, comma, fields TSRMLS_CC);
PHALCON_INIT_VAR(insert_sql);
PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")");
} else {
PHALCON_INIT_VAR(insert_sql);
PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")");
}
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", insert_sql, values, PH_NO_CHECK);
RETURN_CCTOR(success);
}
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array");
return;
}
/**
* Helper method to query records based on a relation definition
*
* @param array $relation
* @param string $method
* @param Phalcon\Mvc\Model $record
* @param array $parameters
* @return Phalcon\Mvc\Model\Resultset\Simple
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){
zval *relation = NULL, *method = NULL, *record = NULL, *parameters = NULL, *placeholders = NULL;
zval *pre_conditions = NULL, *conditions = NULL, *fields = NULL, *field = NULL;
zval *value = NULL, *referenced_field = NULL, *condition = NULL, *i = NULL;
zval *referenced_fields = NULL, *join_conditions = NULL;
zval *find_params = NULL, *find_arguments = NULL, *arguments = NULL;
zval *reference_table = NULL, *referenced_entity = NULL;
zval *connection_service = NULL, *call_object = NULL, *records = NULL;
zval *c0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &relation, &method, &record, ¶meters) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!parameters) {
PHALCON_ALLOC_ZVAL_MM(parameters);
ZVAL_NULL(parameters);
} else {
PHALCON_SEPARATE_PARAM(parameters);
}
if (Z_TYPE_P(parameters) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(parameters, SL("bind")+1);
if (eval_int) {
PHALCON_INIT_VAR(placeholders);
phalcon_array_fetch_string(&placeholders, parameters, SL("bind"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_string(parameters, SL("bind")+1);
} else {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
} else {
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
}
PHALCON_INIT_VAR(pre_conditions);
ZVAL_NULL(pre_conditions);
if (Z_TYPE_P(parameters) == IS_ARRAY) {
eval_int = phalcon_array_isset_long(parameters, 0);
if (eval_int) {
PHALCON_INIT_VAR(pre_conditions);
phalcon_array_fetch_long(&pre_conditions, parameters, 0, PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_long(parameters, 0);
} else {
eval_int = phalcon_array_isset_string(parameters, SL("conditions")+1);
if (eval_int) {
PHALCON_INIT_VAR(pre_conditions);
phalcon_array_fetch_string(&pre_conditions, parameters, SL("conditions"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(parameters);
phalcon_array_unset_string(parameters, SL("conditions")+1);
}
}
} else {
if (Z_TYPE_P(parameters) == IS_STRING) {
PHALCON_CPY_WRT(pre_conditions, parameters);
}
}
if (Z_TYPE_P(pre_conditions) != IS_NULL) {
PHALCON_INIT_VAR(conditions);
array_init(conditions);
phalcon_array_append(&conditions, pre_conditions, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(conditions);
array_init(conditions);
}
PHALCON_INIT_VAR(fields);
phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC);
if (Z_TYPE_P(fields) != IS_ARRAY) {
PHALCON_CPY_WRT(field, fields);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VS(condition, referenced_field, " = ?0");
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(referenced_fields);
phalcon_array_fetch_string(&referenced_fields, relation, SL("rf"), PH_NOISY_CC);
if (!phalcon_valid_foreach(fields TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_74b5_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_74b5_0;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK);
PHALCON_INIT_VAR(referenced_field);
phalcon_array_fetch(&referenced_field, referenced_fields, i, PH_NOISY_CC);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i);
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_74b5_0;
fee_74b5_0:
if(0){}
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC);
PHALCON_INIT_VAR(find_params);
array_init(find_params);
phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC);
if (Z_TYPE_P(parameters) == IS_ARRAY) {
PHALCON_INIT_VAR(find_arguments);
PHALCON_CALL_FUNC_PARAMS_2(find_arguments, "array_merge", find_params, parameters);
} else {
PHALCON_CPY_WRT(find_arguments, find_params);
}
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, find_arguments, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(reference_table);
phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC);
ce0 = phalcon_fetch_class(reference_table TSRMLS_CC);
PHALCON_INIT_VAR(referenced_entity);
object_init_ex(referenced_entity, ce0);
PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK);
PHALCON_INIT_VAR(connection_service);
PHALCON_CALL_METHOD(connection_service, record, "getconnectionservice", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", connection_service, PH_NO_CHECK);
PHALCON_INIT_VAR(call_object);
array_init(call_object);
phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments);
RETURN_CCTOR(records);
}
/**
* Bind params to SQL select
*
* @param string $sqlSelect
* @param array $params
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, bindParams){
zval *sql_select = NULL, *params = NULL, *select = NULL, *id_connection = NULL;
zval *bind_value = NULL, *index = NULL, *value = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL;
zval *t0 = 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", &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_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(id_connection, t0);
if (phalcon_valid_foreach(params TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_321f_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_321f_0;
} else {
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(r2);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "mysqli_real_escape_string", id_connection, bind_value);
PHALCON_CONCAT_SVS(r2, "!¡", value, "!¡");
PHALCON_CPY_WRT(value, r2);
}
if (Z_TYPE_P(index) == IS_LONG) {
PHALCON_INIT_VAR(r3);
PHALCON_CONCAT_SV(r3, "?", index);
PHALCON_INIT_VAR(r4);
phalcon_fast_str_replace(r4, r3, value, select TSRMLS_CC);
PHALCON_CPY_WRT(select, r4);
} else {
if (Z_TYPE_P(index) == IS_STRING) {
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_SVS(r5, ":", index, ":");
PHALCON_INIT_VAR(r6);
phalcon_fast_str_replace(r6, r5, value, select TSRMLS_CC);
PHALCON_CPY_WRT(select, r6);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_321f_0;
fee_321f_0:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "!¡", 1);
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "'", 1);
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_fast_str_replace(r7, c0, c1, select TSRMLS_CC);
RETURN_DZVAL(r7);
}
RETURN_CHECK_CTOR(sql_select);
}
/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon_Db_Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Mysql, describeReferences){
zval *table = NULL, *schema = NULL, *sql = NULL, *references = NULL, *describe = NULL;
zval *reference = NULL, *constraint_name = NULL, *reference_objects = NULL;
zval *array_reference = NULL, *name = 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 *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
zval *i0 = 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();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_INIT_VAR(schema);
ZVAL_NULL(schema);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_STATIC_PARAMS_2(r0, "phalcon_db_dialect_mysql", "describereferences", table, schema);
PHALCON_CPY_WRT(sql, r0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(references, a0);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_CALL_METHOD_PARAMS_2(r1, this_ptr, "fetchall", sql, t0, PHALCON_NO_CHECK);
PHALCON_CPY_WRT(describe, r1);
if (phalcon_valid_foreach(describe TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_321f_4:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_321f_4;
}
PHALCON_INIT_VAR(reference);
ZVAL_ZVAL(reference, *hd, 1, 0);
PHALCON_INIT_VAR(r2);
phalcon_array_fetch_string(&r2, reference, SL("CONSTRAINT_NAME"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(constraint_name, r2);
eval_int = phalcon_array_isset(references, constraint_name);
if (!eval_int) {
PHALCON_INIT_VAR(a1);
array_init(a1);
PHALCON_INIT_VAR(r3);
phalcon_array_fetch_string(&r3, reference, SL("REFERENCED_TABLE_SCHEMA"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a1, SL("referencedSchema"), &r3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r4);
phalcon_array_fetch_string(&r4, reference, SL("REFERENCED_TABLE_NAME"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a1, SL("referencedTable"), &r4, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(a2);
array_init(a2);
phalcon_array_update_string(&a1, SL("columns"), &a2, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(a3);
array_init(a3);
phalcon_array_update_string(&a1, SL("referencedColumns"), &a3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_array_update(&references, constraint_name, &a1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r5);
phalcon_array_fetch_string(&r5, reference, SL("COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t1);
phalcon_array_fetch(&t1, references, constraint_name, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t1) > 1) {
phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) != IS_ARRAY) {
convert_to_array(t1);
phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t1) == IS_ARRAY) {
PHALCON_INIT_VAR(t2);
phalcon_array_fetch_string(&t2, t1, SL("columns"), PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t2) > 1) {
phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t2) != IS_ARRAY) {
convert_to_array(t2);
phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&t2, r5, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
PHALCON_INIT_VAR(r6);
phalcon_array_fetch_string(&r6, reference, SL("REFERENCED_COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(references) == IS_ARRAY) {
PHALCON_INIT_VAR(t3);
phalcon_array_fetch(&t3, references, constraint_name, PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t3) > 1) {
phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) != IS_ARRAY) {
convert_to_array(t3);
phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t3) == IS_ARRAY) {
PHALCON_INIT_VAR(t4);
phalcon_array_fetch_string(&t4, t3, SL("referencedColumns"), PHALCON_SILENT TSRMLS_CC);
}
if (Z_REFCOUNT_P(t4) > 1) {
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC);
}
if (Z_TYPE_P(t4) != IS_ARRAY) {
convert_to_array(t4);
phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
phalcon_array_append(&t4, r6, PHALCON_NO_SEPARATE_THX TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_321f_4;
fee_321f_4:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(a4);
array_init(a4);
PHALCON_CPY_WRT(reference_objects, a4);
if (phalcon_valid_foreach(references TSRMLS_CC)) {
ah1 = Z_ARRVAL_P(references);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
fes_321f_5:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_321f_5;
} else {
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
}
PHALCON_INIT_VAR(array_reference);
ZVAL_ZVAL(array_reference, *hd, 1, 0);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, phalcon_db_reference_ce);
PHALCON_INIT_VAR(a5);
array_init(a5);
PHALCON_INIT_VAR(r7);
phalcon_array_fetch_string(&r7, array_reference, SL("referencedSchema"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedSchema"), &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r8);
phalcon_array_fetch_string(&r8, array_reference, SL("referencedTable"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedTable"), &r8, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch_string(&r9, array_reference, SL("columns"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("columns"), &r9, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_INIT_VAR(r10);
phalcon_array_fetch_string(&r10, array_reference, SL("referencedColumns"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update_string(&a5, SL("referencedColumns"), &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", name, a5, PHALCON_CHECK);
phalcon_array_update(&reference_objects, name, &i0, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_321f_5;
fee_321f_5:
if(0){}
} else {
return;
}
RETURN_CTOR(reference_objects);
}
/**
* Outputs a message formatting it with HTML
*
* @param string $type
* @param string $message
*/
PHP_METHOD(Phalcon_Flash, outputMessage){
zval *type = NULL, *message = NULL, *automatic_html = NULL, *classes = NULL;
zval *type_classes = NULL, *space = NULL, *joined_classes = NULL;
zval *css_classes = NULL, *eol = NULL, *implicit_flush = NULL, *content = NULL;
zval *msg = NULL, *html_message = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(automatic_html);
phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC);
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC);
eval_int = phalcon_array_isset(classes, type);
if (eval_int) {
PHALCON_INIT_VAR(type_classes);
phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC);
if (Z_TYPE_P(type_classes) == IS_ARRAY) {
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
PHALCON_INIT_VAR(joined_classes);
phalcon_fast_join(joined_classes, space, type_classes TSRMLS_CC);
PHALCON_INIT_VAR(css_classes);
PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\"");
} else {
PHALCON_INIT_VAR(css_classes);
PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\"");
}
} else {
PHALCON_INIT_VAR(css_classes);
ZVAL_STRING(css_classes, "", 1);
}
PHALCON_INIT_VAR(eol);
zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC);
}
PHALCON_INIT_VAR(implicit_flush);
phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC);
if (Z_TYPE_P(message) == IS_ARRAY) {
if (PHALCON_IS_FALSE(implicit_flush)) {
PHALCON_INIT_VAR(content);
ZVAL_STRING(content, "", 1);
}
if (!phalcon_valid_foreach(message TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(message);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_3b3c_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_3b3c_0;
}
PHALCON_INIT_VAR(msg);
ZVAL_ZVAL(msg, *hd, 1, 0);
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_VAR(html_message);
PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol);
} else {
PHALCON_CPY_WRT(html_message, msg);
}
if (PHALCON_IS_TRUE(implicit_flush)) {
zend_print_zval(html_message, 1);
} else {
phalcon_concat_self(&content, html_message TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_3b3c_0;
fee_3b3c_0:
if (PHALCON_IS_FALSE(implicit_flush)) {
RETURN_CTOR(content);
}
} else {
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_VAR(html_message);
PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol);
} else {
PHALCON_CPY_WRT(html_message, message);
}
if (PHALCON_IS_TRUE(implicit_flush)) {
zend_print_zval(html_message, 1);
} else {
RETURN_CCTOR(html_message);
}
}
PHALCON_MM_RESTORE();
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *transaction = NULL, *file_handler = NULL, *quenue = NULL, *message = NULL;
zval *message_str = NULL, *type = NULL, *time = NULL, *applied_format = NULL;
zval *applied_eol = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(transaction);
phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(transaction)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_INIT_VAR(file_handler);
phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(quenue);
phalcon_read_property(&quenue, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(quenue TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(quenue);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD(message_str, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(type);
PHALCON_CALL_METHOD(type, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(time);
PHALCON_CALL_METHOD(time, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(applied_format);
PHALCON_CALL_METHOD_PARAMS_3(applied_format, this_ptr, "_applyformat", message_str, type, time, PH_NO_CHECK);
PHALCON_INIT_VAR(t0);
zend_get_constant(SL("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_INIT_VAR(applied_eol);
PHALCON_CONCAT_VV(applied_eol, applied_format, t0);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", file_handler, applied_eol);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name = NULL, *file_name = NULL, *directory = NULL, *preffix = NULL;
zval *path = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = 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 *c0 = NULL, *c1 = NULL, *c2 = 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();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_classes"), PHALCON_NOISY TSRMLS_CC);
eval_int = phalcon_array_isset(t0, class_name);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_classes"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch(&r0, t1, class_name, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(file_name, r0);
if (phalcon_require(file_name TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_ALLOC_ZVAL_MM(t2);
phalcon_read_property(&t2, this_ptr, SL("_namespaces"), 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_0c08_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_0c08_0;
} else {
PHALCON_INIT_VAR(preffix);
PHALCON_GET_FOREACH_KEY(preffix, ah0, hp0);
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_FUNC_PARAMS_1(r1, "strlen", class_name);
PHALCON_INIT_VAR(r2);
is_smaller_function(r2, preffix, r1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_1(r3, "strlen", preffix);
PHALCON_INIT_VAR(r4);
PHALCON_CALL_FUNC_PARAMS_3(r4, "substr", class_name, c0, r3);
PHALCON_INIT_VAR(r5);
is_equal_function(r5, r4, preffix TSRMLS_CC);
if (zend_is_true(r5)) {
PHALCON_INIT_VAR(r6);
PHALCON_CONCAT_VS(r6, preffix, "\\");
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "", 1);
PHALCON_INIT_VAR(r7);
phalcon_fast_str_replace(r7, r6, c1, class_name TSRMLS_CC);
PHALCON_CPY_WRT(file_name, r7);
if (zend_is_true(file_name)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "\\", 1);
PHALCON_INIT_VAR(t3);
zend_get_constant("DIRECTORY_SEPARATOR", strlen("DIRECTORY_SEPARATOR"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r8);
PHALCON_CONCAT_VVS(r8, directory, file_name, ".php");
PHALCON_INIT_VAR(r9);
phalcon_fast_str_replace(r9, c2, t3, r8 TSRMLS_CC);
PHALCON_CPY_WRT(path, r9);
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_0c08_0;
fee_0c08_0:
if(0){}
} else {
return;
}
PHALCON_ALLOC_ZVAL_MM(t4);
phalcon_read_property(&t4, this_ptr, SL("_directories"), 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_0c08_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto fee_0c08_1;
}
PHALCON_INIT_VAR(directory);
ZVAL_ZVAL(directory, *hd, 1, 0);
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_VVS(r10, directory, class_name, ".php");
PHALCON_CPY_WRT(path, r10);
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
goto fes_0c08_1;
fee_0c08_1:
if(0){}
} else {
return;
}
PHALCON_MM_RESTORE();
}
/**
* Initialize the metadata for certain table
*
* @param Phalcon\Mvc\Model $model
* @param string $key
* @param string $table
* @param string $schema
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initializeMetaData){
zval *model, *key, *table, *schema, *meta_data, *data;
zval *table_metadata = NULL, *class_name = NULL, *exception_message = NULL;
zval *connection, *exists, *complete_table = NULL, *attributes;
zval *primary_keys, *non_primary_keys, *numeric_typed;
zval *not_null, *field_types, *field_bind_types;
zval *automatic_default, *identity_field = NULL;
zval *columns, *column = NULL, *field_name = NULL, *feature = NULL, *type = NULL;
zval *bind_type = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &model, &key, &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(meta_data);
phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC);
eval_int = phalcon_array_isset(meta_data, key);
if (!eval_int) {
PHALCON_INIT_VAR(data);
PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", key, PH_NO_CHECK);
if (Z_TYPE_P(data) != IS_NULL) {
phalcon_array_update_zval(&meta_data, key, &data, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_metaData"), meta_data TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(table_metadata);
PHALCON_CALL_METHOD(table_metadata, model, "metadata", PH_NO_CHECK);
if (Z_TYPE_P(table_metadata) != IS_ARRAY) {
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model TSRMLS_CC);
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid meta-data for model ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
PHALCON_INIT_VAR(connection);
PHALCON_CALL_METHOD(connection, model, "getconnection", PH_NO_CHECK);
PHALCON_INIT_VAR(exists);
PHALCON_CALL_METHOD_PARAMS_2(exists, connection, "tableexists", table, schema, PH_NO_CHECK);
if (!zend_is_true(exists)) {
if (zend_is_true(schema)) {
PHALCON_INIT_VAR(complete_table);
PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table);
} else {
PHALCON_CPY_WRT(complete_table, table);
}
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, model TSRMLS_CC);
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVSV(exception_message, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(attributes);
array_init(attributes);
PHALCON_INIT_VAR(primary_keys);
array_init(primary_keys);
PHALCON_INIT_VAR(non_primary_keys);
array_init(non_primary_keys);
PHALCON_INIT_VAR(numeric_typed);
array_init(numeric_typed);
PHALCON_INIT_VAR(not_null);
array_init(not_null);
PHALCON_INIT_VAR(field_types);
array_init(field_types);
PHALCON_INIT_VAR(field_bind_types);
array_init(field_bind_types);
PHALCON_INIT_VAR(automatic_default);
array_init(automatic_default);
PHALCON_INIT_VAR(identity_field);
ZVAL_BOOL(identity_field, 0);
PHALCON_INIT_VAR(columns);
PHALCON_CALL_METHOD_PARAMS_2(columns, connection, "describecolumns", table, schema, PH_NO_CHECK);
if (!phalcon_fast_count_ev(columns TSRMLS_CC)) {
if (zend_is_true(schema)) {
PHALCON_INIT_NVAR(complete_table);
PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table);
} else {
PHALCON_CPY_WRT(complete_table, table);
}
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, model TSRMLS_CC);
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVSV(exception_message, "Cannot obtain table columns for the mapped source \"", complete_table, "\" used in model ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
if (!phalcon_valid_foreach(columns TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(columns);
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(column);
PHALCON_INIT_NVAR(field_name);
PHALCON_CALL_METHOD(field_name, column, "getname", PH_NO_CHECK);
phalcon_array_append(&attributes, field_name, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(feature);
PHALCON_CALL_METHOD(feature, column, "isprimary", PH_NO_CHECK);
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_append(&primary_keys, field_name, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(feature);
PHALCON_CALL_METHOD(feature, column, "isnumeric", PH_NO_CHECK);
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(feature);
PHALCON_CALL_METHOD(feature, column, "isnotnull", PH_NO_CHECK);
if (PHALCON_IS_TRUE(feature)) {
phalcon_array_append(¬_null, field_name, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(feature);
PHALCON_CALL_METHOD(feature, column, "isautoincrement", PH_NO_CHECK);
if (PHALCON_IS_TRUE(feature)) {
PHALCON_CPY_WRT(identity_field, field_name);
}
PHALCON_INIT_NVAR(type);
PHALCON_CALL_METHOD(type, column, "gettype", PH_NO_CHECK);
phalcon_array_update_zval(&field_types, field_name, &type, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(bind_type);
PHALCON_CALL_METHOD(bind_type, column, "getbindtype", PH_NO_CHECK);
phalcon_array_update_zval(&field_bind_types, field_name, &bind_type, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_NVAR(table_metadata);
array_init(table_metadata);
phalcon_array_update_long(&table_metadata, 0, &attributes, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 4, &field_types, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long(&table_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(t0);
phalcon_read_property(&t0, this_ptr, SL("_metaData"), PH_NOISY_CC);
phalcon_array_update_zval(&t0, key, &table_metadata, PH_COPY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_metaData"), t0 TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", key, table_metadata, PH_NO_CHECK);
}
PHALCON_MM_RESTORE();
}
/**
* 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);
}
