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();
}
/**
* Outputs a message formatting it with HTML
*
*<code>
* $flash->outputMessage('error', $message);
*</code>
*
* @param string $type
* @param string $message
*/
PHP_METHOD(Phalcon_Flash, outputMessage){
zval *type, *message, *automatic_html, *classes;
zval *type_classes, *joined_classes, *css_classes = NULL;
zval *eol = NULL, *implicit_flush, *content, *msg = NULL, *html_message = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(automatic_html);
phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC);
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_OBS_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC);
if (phalcon_array_isset(classes, type)) {
PHALCON_OBS_VAR(type_classes);
phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC);
if (Z_TYPE_P(type_classes) == IS_ARRAY) {
PHALCON_INIT_VAR(joined_classes);
phalcon_fast_join_str(joined_classes, SL(" "), type_classes TSRMLS_CC);
PHALCON_INIT_VAR(css_classes);
PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\"");
} else {
PHALCON_INIT_NVAR(css_classes);
PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\"");
}
} else {
PHALCON_INIT_NVAR(css_classes);
ZVAL_STRING(css_classes, "", 1);
}
PHALCON_INIT_VAR(eol);
PHALCON_INIT_NVAR(eol);
ZVAL_STRING(eol, PHP_EOL, 1);
}
PHALCON_OBS_VAR(implicit_flush);
phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC);
if (Z_TYPE_P(message) == IS_ARRAY) {
/**
* We create the message with implicit flush or other
*/
if (PHALCON_IS_FALSE(implicit_flush)) {
PHALCON_INIT_VAR(content);
ZVAL_STRING(content, "", 1);
}
/**
* We create the message with implicit flush or other
*/
if (!phalcon_is_iterable(message, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(msg);
/**
* We create the applying formatting or not
*/
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_NVAR(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, 0);
} else {
phalcon_concat_self(&content, html_message TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* We return the message as string if the implicit_flush is turned off
*/
if (PHALCON_IS_FALSE(implicit_flush)) {
RETURN_CTOR(content);
}
} else {
/**
* We create the applying formatting or not
*/
if (PHALCON_IS_TRUE(automatic_html)) {
PHALCON_INIT_NVAR(html_message);
PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol);
} else {
PHALCON_CPY_WRT(html_message, message);
}
/**
* We return the message as string if the implicit_flush is turned off
*/
if (PHALCON_IS_TRUE(implicit_flush)) {
zend_print_zval(html_message, 0);
} else {
RETURN_CCTOR(html_message);
}
}
PHALCON_MM_RESTORE();
}
/**
* 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();
}
/**
* 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);
}
/**
* Returns a PHQL statement built based on the builder parameters
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){
zval *dependency_injector = NULL, *models, *conditions = NULL;
zval *one, *number_models, *invalid_condition;
zval *model = NULL, *service_name, *meta_data, *model_instance;
zval *no_primary = NULL, *primary_keys, *first_primary_key;
zval *column_map = NULL, *attribute_field = NULL, *exception_message;
zval *primary_key_condition, *phql, *columns;
zval *selected_columns = NULL, *column = NULL, *alias = NULL, *aliased_column = NULL;
zval *joined_columns = NULL, *selected_column = NULL, *selected_models;
zval *selected_model = NULL, *joined_models, *joins;
zval *join = NULL, *join_model = NULL, *join_conditions = NULL, *join_alias = NULL;
zval *join_type = NULL, *group, *group_items, *group_item = NULL;
zval *escaped_item = NULL, *joined_items = NULL, *having, *order;
zval *order_items, *order_item = NULL, *limit, *number;
zval *offset = NULL;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
zend_class_entry *ce0;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_INIT_NVAR(dependency_injector);
PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault");
phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC);
}
PHALCON_OBS_VAR(models);
phalcon_read_property(&models, this_ptr, SL("_models"), PH_NOISY_CC);
if (Z_TYPE_P(models) == IS_ARRAY) {
if (!phalcon_fast_count_ev(models TSRMLS_CC)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
} else {
if (!zend_is_true(models)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query");
return;
}
}
PHALCON_OBS_VAR(conditions);
phalcon_read_property(&conditions, this_ptr, SL("_conditions"), PH_NOISY_CC);
if (phalcon_is_numeric(conditions)) {
/**
* If the conditions is a single numeric field. We internally create a condition
* using the related primary key
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(number_models);
phalcon_fast_count(number_models, models TSRMLS_CC);
PHALCON_INIT_VAR(invalid_condition);
is_smaller_function(invalid_condition, one, number_models TSRMLS_CC);
if (PHALCON_IS_TRUE(invalid_condition)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Cannot build the query. Invalid condition");
return;
}
PHALCON_OBS_VAR(model);
phalcon_array_fetch_long(&model, models, 0, PH_NOISY_CC);
} else {
PHALCON_CPY_WRT(model, models);
}
PHALCON_INIT_VAR(service_name);
ZVAL_STRING(service_name, "modelsMetadata", 1);
/**
* Get the models metadata service to obtain the column names, column map and
* primary key
*/
PHALCON_INIT_VAR(meta_data);
PHALCON_CALL_METHOD_PARAMS_1(meta_data, dependency_injector, "getshared", service_name);
ce0 = phalcon_fetch_class(model TSRMLS_CC);
PHALCON_INIT_VAR(model_instance);
object_init_ex(model_instance, ce0);
if (phalcon_has_constructor(model_instance TSRMLS_CC)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(model_instance, "__construct", dependency_injector);
}
PHALCON_INIT_VAR(no_primary);
ZVAL_BOOL(no_primary, 1);
PHALCON_INIT_VAR(primary_keys);
PHALCON_CALL_METHOD_PARAMS_1(primary_keys, meta_data, "getprimarykeyattributes", model_instance);
if (phalcon_fast_count_ev(primary_keys TSRMLS_CC)) {
if (phalcon_array_isset_long(primary_keys, 0)) {
PHALCON_OBS_VAR(first_primary_key);
phalcon_array_fetch_long(&first_primary_key, primary_keys, 0, PH_NOISY_CC);
/**
* The PHQL contains the renamed columns if available
*/
if (PHALCON_GLOBAL(orm).column_renaming) {
PHALCON_INIT_VAR(column_map);
PHALCON_CALL_METHOD_PARAMS_1(column_map, meta_data, "getcolumnmap", model_instance);
} else {
PHALCON_INIT_NVAR(column_map);
}
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, first_primary_key)) {
PHALCON_OBS_VAR(attribute_field);
phalcon_array_fetch(&attribute_field, column_map, first_primary_key, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", first_primary_key, "\" isn't part of the column map");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
PHALCON_CPY_WRT(attribute_field, first_primary_key);
}
PHALCON_INIT_VAR(primary_key_condition);
PHALCON_CONCAT_SVSVSV(primary_key_condition, "[", model, "].[", attribute_field, "] = ", conditions);
PHALCON_CPY_WRT(conditions, primary_key_condition);
ZVAL_BOOL(no_primary, 0);
}
}
/**
* A primary key is mandatory in these cases
*/
if (PHALCON_IS_TRUE(no_primary)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Source related to this model does not have a primary key defined");
return;
}
}
PHALCON_INIT_VAR(phql);
ZVAL_STRING(phql, "SELECT ", 1);
PHALCON_OBS_VAR(columns);
phalcon_read_property(&columns, this_ptr, SL("_columns"), PH_NOISY_CC);
if (Z_TYPE_P(columns) != IS_NULL) {
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_columns);
array_init(selected_columns);
if (!phalcon_is_iterable(columns, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(column);
if (Z_TYPE_P(alias) == IS_LONG) {
phalcon_array_append(&selected_columns, column, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(aliased_column);
PHALCON_CONCAT_VSV(aliased_column, column, " AS ", alias);
phalcon_array_append(&selected_columns, aliased_column, PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
phalcon_concat_self(&phql, columns TSRMLS_CC);
}
} else {
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_NVAR(selected_columns);
array_init(selected_columns);
if (!phalcon_is_iterable(models, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(model);
if (Z_TYPE_P(alias) == IS_LONG) {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", model, "].*");
} else {
PHALCON_INIT_NVAR(selected_column);
PHALCON_CONCAT_SVS(selected_column, "[", alias, "].*");
}
phalcon_array_append(&selected_columns, selected_column, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_NVAR(joined_columns);
phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC);
phalcon_concat_self(&phql, joined_columns TSRMLS_CC);
} else {
PHALCON_SCONCAT_SVS(phql, "[", models, "].*");
}
}
/**
* Join multiple models or use a single one if it is a string
*/
if (Z_TYPE_P(models) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_models);
array_init(selected_models);
if (!phalcon_is_iterable(models, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(alias, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(model);
if (Z_TYPE_P(alias) == IS_STRING) {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVSVS(selected_model, "[", model, "] AS [", alias, "]");
} else {
PHALCON_INIT_NVAR(selected_model);
PHALCON_CONCAT_SVS(selected_model, "[", model, "]");
}
phalcon_array_append(&selected_models, selected_model, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
}
PHALCON_INIT_VAR(joined_models);
phalcon_fast_join_str(joined_models, SL(", "), selected_models TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " FROM ", joined_models);
} else {
PHALCON_SCONCAT_SVS(phql, " FROM [", models, "]");
}
/**
* Check if joins were passed to the builders
*/
PHALCON_OBS_VAR(joins);
phalcon_read_property(&joins, this_ptr, SL("_joins"), PH_NOISY_CC);
if (Z_TYPE_P(joins) == IS_ARRAY) {
if (!phalcon_is_iterable(joins, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(join);
/**
* The joined table is in the first place of the array
*/
PHALCON_OBS_NVAR(join_model);
phalcon_array_fetch_long(&join_model, join, 0, PH_NOISY_CC);
/**
* The join conditions are in the second place of the array
*/
PHALCON_OBS_NVAR(join_conditions);
phalcon_array_fetch_long(&join_conditions, join, 1, PH_NOISY_CC);
/**
* The join alias is in the second place of the array
*/
PHALCON_OBS_NVAR(join_alias);
phalcon_array_fetch_long(&join_alias, join, 2, PH_NOISY_CC);
/**
* Join type
*/
PHALCON_OBS_NVAR(join_type);
phalcon_array_fetch_long(&join_type, join, 3, PH_NOISY_CC);
/**
* Create the join according to the type
*/
if (zend_is_true(join_type)) {
PHALCON_SCONCAT_VSVS(phql, join_type, " JOIN [", join_model, "]");
} else {
PHALCON_SCONCAT_SVS(phql, " JOIN [", join_model, "]");
}
/**
* Alias comes first
*/
if (zend_is_true(join_alias)) {
PHALCON_SCONCAT_SVS(phql, " AS [", join_alias, "]");
}
/**
* Conditions then
*/
if (zend_is_true(join_conditions)) {
PHALCON_SCONCAT_SV(phql, " ON ", join_conditions);
}
zend_hash_move_forward_ex(ah3, &hp3);
}
}
if (Z_TYPE_P(conditions) == IS_STRING) {
PHALCON_SCONCAT_SV(phql, " WHERE ", conditions);
}
/**
* Process group parameters
*/
PHALCON_OBS_VAR(group);
phalcon_read_property(&group, this_ptr, SL("_group"), PH_NOISY_CC);
if (Z_TYPE_P(group) != IS_NULL) {
if (Z_TYPE_P(group) == IS_ARRAY) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
if (!phalcon_is_iterable(group, &ah4, &hp4, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(group_item);
if (phalcon_is_numeric(group_item)) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(group_item, SL(".") TSRMLS_CC)) {
phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", group_item, "]");
phalcon_array_append(&group_items, escaped_item, PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), group_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " GROUP BY ", joined_items);
} else {
if (phalcon_is_numeric(group)) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
if (phalcon_memnstr_str(group, SL(".") TSRMLS_CC)) {
PHALCON_SCONCAT_SV(phql, " GROUP BY ", group);
} else {
PHALCON_SCONCAT_SVS(phql, " GROUP BY [", group, "]");
}
}
}
PHALCON_OBS_VAR(having);
phalcon_read_property(&having, this_ptr, SL("_having"), PH_NOISY_CC);
if (Z_TYPE_P(having) != IS_NULL) {
PHALCON_SCONCAT_SV(phql, " HAVING ", having);
}
}
/**
* Process order clause
*/
PHALCON_OBS_VAR(order);
phalcon_read_property(&order, this_ptr, SL("_order"), PH_NOISY_CC);
if (Z_TYPE_P(order) != IS_NULL) {
if (Z_TYPE_P(order) == IS_ARRAY) {
PHALCON_INIT_VAR(order_items);
array_init(order_items);
if (!phalcon_is_iterable(order, &ah5, &hp5, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(order_item);
if (phalcon_is_numeric(order_item)) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(order_item, SL(".") TSRMLS_CC)) {
phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escaped_item);
PHALCON_CONCAT_SVS(escaped_item, "[", order_item, "]");
phalcon_array_append(&order_items, escaped_item, PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_NVAR(joined_items);
phalcon_fast_join_str(joined_items, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(phql, " ORDER BY ", joined_items);
} else {
PHALCON_SCONCAT_SV(phql, " ORDER BY ", order);
}
}
/**
* Process limit parameters
*/
PHALCON_OBS_VAR(limit);
phalcon_read_property(&limit, this_ptr, SL("_limit"), PH_NOISY_CC);
if (Z_TYPE_P(limit) != IS_NULL) {
if (Z_TYPE_P(limit) == IS_ARRAY) {
PHALCON_OBS_VAR(number);
phalcon_array_fetch_string(&number, limit, SL("number"), PH_NOISY_CC);
if (phalcon_array_isset_string(limit, SS("offset"))) {
PHALCON_OBS_VAR(offset);
phalcon_array_fetch_string(&offset, limit, SL("offset"), PH_NOISY_CC);
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SVSV(phql, " LIMIT ", number, " OFFSET ", offset);
} else {
PHALCON_SCONCAT_SVS(phql, " LIMIT ", number, " OFFSET 0");
}
} else {
PHALCON_SCONCAT_SV(phql, " LIMIT ", number);
}
} else {
if (phalcon_is_numeric(limit)) {
PHALCON_SCONCAT_SV(phql, " LIMIT ", limit);
PHALCON_OBS_NVAR(offset);
phalcon_read_property(&offset, this_ptr, SL("_offset"), PH_NOISY_CC);
if (Z_TYPE_P(offset) != IS_NULL) {
if (phalcon_is_numeric(offset)) {
PHALCON_SCONCAT_SV(phql, " OFFSET ", offset);
} else {
phalcon_concat_self_str(&phql, SL(" OFFSET 0") TSRMLS_CC);
}
}
}
}
}
RETURN_CTOR(phql);
}
/**
* Updates data on a table using custom RBDM SQL syntax
*
* <code>
* //Updating existing robot
* $success = $connection->update(
* "robots",
* array("name")
* array("New Astro Boy"),
* "id = 101"
* );
*
* //Next SQL sentence is sent to the database system
* UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
* </code>
*
* @param string $table
* @param array $fields
* @param array $values
* @param string $whereCondition
* @param array $dataTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, update){
zval *table, *fields, *values, *where_condition = NULL;
zval *data_types = NULL, *placeholders, *update_values;
zval *bind_data_types = NULL, *value = NULL, *position = NULL, *field = NULL;
zval *set_clause_part = NULL, *bind_type = NULL, *set_clause;
zval *update_sql = NULL, *success;
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|zz", &table, &fields, &values, &where_condition, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!where_condition) {
PHALCON_INIT_NVAR(where_condition);
}
if (!data_types) {
PHALCON_INIT_NVAR(data_types);
}
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_INIT_VAR(update_values);
array_init(update_values);
if (Z_TYPE_P(data_types) == IS_ARRAY) {
PHALCON_INIT_VAR(bind_data_types);
array_init(bind_data_types);
} else {
PHALCON_CPY_WRT(bind_data_types, data_types);
}
if (!phalcon_valid_foreach(values TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(values);
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(position, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
eval_int = phalcon_array_isset(fields, position);
if (eval_int) {
PHALCON_INIT_NVAR(field);
phalcon_array_fetch(&field, fields, position, PH_NOISY_CC);
if (Z_TYPE_P(value) == IS_OBJECT) {
PHALCON_INIT_NVAR(set_clause_part);
PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value);
phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
PHALCON_INIT_NVAR(set_clause_part);
PHALCON_CONCAT_VS(set_clause_part, field, " = null");
} else {
PHALCON_INIT_NVAR(set_clause_part);
PHALCON_CONCAT_VS(set_clause_part, field, " = ?");
phalcon_array_append(&update_values, value, PH_SEPARATE TSRMLS_CC);
if (Z_TYPE_P(data_types) == IS_ARRAY) {
eval_int = phalcon_array_isset(data_types, position);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Incomplete number of bind types");
return;
}
PHALCON_INIT_NVAR(bind_type);
phalcon_array_fetch(&bind_type, data_types, position, PH_NOISY_CC);
phalcon_array_append(&bind_data_types, bind_type, PH_SEPARATE TSRMLS_CC);
}
}
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:
PHALCON_INIT_VAR(set_clause);
phalcon_fast_join_str(set_clause, SL(", "), 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_NVAR(update_sql);
PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause);
}
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_3(success, this_ptr, "execute", update_sql, update_values, bind_data_types, PH_NO_CHECK);
RETURN_CCTOR(success);
}
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();
}