/**
* Executes render process from dispatching data
*
*<code>
* $view->start();
* //Shows recent posts view (app/views/posts/recent.phtml)
* $view->render('posts', 'recent');
* $view->finish();
*</code>
*
* @param string $controllerName
* @param string $actionName
* @param array $params
*/
PHP_METHOD(Phalcon_Mvc_View, render){
zval *controller_name, *action_name, *params = NULL;
zval *disabled, *contents = NULL, *layouts_dir = NULL, *layout;
zval *layout_name = NULL, *engines, *pick_view, *render_view = NULL;
zval *pick_view_action, *cache = NULL, *cache_level;
zval *events_manager, *event_name = NULL, *status, *must_clean;
zval *silence = NULL, *disabled_levels, *render_level;
zval *enter_level = NULL, *templates_before, *template_before = NULL;
zval *view_temp_path = NULL, *templates_after, *template_after = NULL;
zval *main_view, *is_started, *is_fresh;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &controller_name, &action_name, ¶ms);
if (!params) {
PHALCON_INIT_VAR(params);
}
/**
* If the view is disabled we simply update the buffer from any output produced in
* the controller
*/
PHALCON_OBS_VAR(disabled);
phalcon_read_property_this(&disabled, this_ptr, SL("_disabled"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(disabled)) {
PHALCON_INIT_VAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC);
RETURN_MM_FALSE;
}
phalcon_update_property_this(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
/**
* Check if there is a layouts directory set
*/
PHALCON_OBS_VAR(layouts_dir);
phalcon_read_property_this(&layouts_dir, this_ptr, SL("_layoutsDir"), PH_NOISY_CC);
if (!zend_is_true(layouts_dir)) {
PHALCON_INIT_NVAR(layouts_dir);
ZVAL_STRING(layouts_dir, "layouts/", 1);
}
/**
* Check if the user has defined a custom layout
*/
PHALCON_OBS_VAR(layout);
phalcon_read_property_this(&layout, this_ptr, SL("_layout"), PH_NOISY_CC);
if (zend_is_true(layout)) {
PHALCON_CPY_WRT(layout_name, layout);
} else {
PHALCON_CPY_WRT(layout_name, controller_name);
}
/**
* Load the template engines
*/
PHALCON_INIT_VAR(engines);
PHALCON_CALL_METHOD(engines, this_ptr, "_loadtemplateengines");
/**
* Check if the user has picked a view diferent than the automatic
*/
PHALCON_OBS_VAR(pick_view);
phalcon_read_property_this(&pick_view, this_ptr, SL("_pickView"), PH_NOISY_CC);
if (Z_TYPE_P(pick_view) == IS_NULL) {
PHALCON_INIT_VAR(render_view);
PHALCON_CONCAT_VSV(render_view, controller_name, "/", action_name);
} else {
/**
* The 'picked' view is an array, where the first element is controller and the
* second the action
*/
PHALCON_OBS_NVAR(render_view);
phalcon_array_fetch_long(&render_view, pick_view, 0, PH_NOISY_CC);
if (phalcon_array_isset_long(pick_view, 1)) {
PHALCON_OBS_VAR(pick_view_action);
phalcon_array_fetch_long(&pick_view_action, pick_view, 1, PH_NOISY_CC);
PHALCON_CPY_WRT(layout_name, pick_view_action);
}
}
PHALCON_INIT_VAR(cache);
/**
* Start the cache if there is a cache level enabled
*/
PHALCON_OBS_VAR(cache_level);
phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
if (zend_is_true(cache_level)) {
PHALCON_CALL_METHOD(cache, this_ptr, "getcache");
}
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
/**
* Create a virtual symbol table
*/
phalcon_create_symbol_table(TSRMLS_C);
/**
* Call beforeRender if there is an events manager
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "view:beforeRender", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_FALSE;
}
}
/**
* Get the current content in the buffer maybe some output from the controller
*/
PHALCON_INIT_NVAR(contents);
PHALCON_CALL_FUNC(contents, "ob_get_contents");
phalcon_update_property_this(this_ptr, SL("_content"), contents TSRMLS_CC);
PHALCON_INIT_VAR(must_clean);
ZVAL_BOOL(must_clean, 1);
PHALCON_INIT_VAR(silence);
ZVAL_BOOL(silence, 1);
/**
* Disabled levels allow to avoid an specific level of rendering
*/
PHALCON_OBS_VAR(disabled_levels);
phalcon_read_property_this(&disabled_levels, this_ptr, SL("_disabledLevels"), PH_NOISY_CC);
/**
* Render level will tell use when to stop
*/
PHALCON_OBS_VAR(render_level);
phalcon_read_property_this(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
if (zend_is_true(render_level)) {
/**
* Inserts view related to action
*/
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(enter_level);
is_smaller_or_equal_function(enter_level, t0, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 1)) {
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, render_view, silence, must_clean, cache);
}
}
/**
* Inserts templates before layout
*/
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 2);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t1, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 2)) {
PHALCON_OBS_VAR(templates_before);
phalcon_read_property_this(&templates_before, this_ptr, SL("_templatesBefore"), PH_NOISY_CC);
/**
* Templates before must be an array
*/
if (Z_TYPE_P(templates_before) == IS_ARRAY) {
ZVAL_BOOL(silence, 0);
if (!phalcon_is_iterable(templates_before, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(template_before);
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_before);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache);
zend_hash_move_forward_ex(ah0, &hp0);
}
ZVAL_BOOL(silence, 1);
}
}
}
/**
* Inserts controller layout
*/
PHALCON_INIT_VAR(t2);
ZVAL_LONG(t2, 3);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t2, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 3)) {
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, layout_name);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache);
}
}
/**
* Inserts templates after layout
*/
PHALCON_INIT_VAR(t3);
ZVAL_LONG(t3, 4);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t3, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 4)) {
/**
* Templates after must be an array
*/
PHALCON_OBS_VAR(templates_after);
phalcon_read_property_this(&templates_after, this_ptr, SL("_templatesAfter"), PH_NOISY_CC);
if (Z_TYPE_P(templates_after) == IS_ARRAY) {
ZVAL_BOOL(silence, 0);
if (!phalcon_is_iterable(templates_after, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(template_after);
PHALCON_INIT_NVAR(view_temp_path);
PHALCON_CONCAT_VV(view_temp_path, layouts_dir, template_after);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, view_temp_path, silence, must_clean, cache);
zend_hash_move_forward_ex(ah1, &hp1);
}
ZVAL_BOOL(silence, 1);
}
}
}
/**
* Inserts main view
*/
PHALCON_INIT_VAR(t4);
ZVAL_LONG(t4, 5);
PHALCON_INIT_NVAR(enter_level);
is_smaller_or_equal_function(enter_level, t4, render_level TSRMLS_CC);
if (PHALCON_IS_TRUE(enter_level)) {
if (!phalcon_array_isset_long(disabled_levels, 5)) {
PHALCON_OBS_VAR(main_view);
phalcon_read_property_this(&main_view, this_ptr, SL("_mainView"), PH_NOISY_CC);
PHALCON_CALL_METHOD_PARAMS_5_NORETURN(this_ptr, "_enginerender", engines, main_view, silence, must_clean, cache);
}
}
/**
* Store the data in the cache
*/
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted");
if (PHALCON_IS_TRUE(is_started)) {
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh");
if (PHALCON_IS_TRUE(is_fresh)) {
PHALCON_CALL_METHOD_NORETURN(cache, "save");
} else {
PHALCON_CALL_METHOD_NORETURN(cache, "stop");
}
} else {
PHALCON_CALL_METHOD_NORETURN(cache, "stop");
}
}
}
/**
* Call afterRender event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRender", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
RETURN_MM_NULL();
}
/**
* Bind params to a SQL statement
*
* @param string $sql
* @param array $params
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, bindParams){
zval *sql_statement = NULL, *params = NULL, *number_params = NULL;
zval *sql = NULL, *pdo = NULL, *bind_value = NULL, *index = NULL, *is_numeric = NULL;
zval *value = NULL, *place_key = NULL, *replaced_sql = 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_statement, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(params) == IS_ARRAY) {
PHALCON_INIT_VAR(number_params);
phalcon_fast_count(number_params, params TSRMLS_CC);
if (zend_is_true(number_params)) {
PHALCON_CPY_WRT(sql, sql_statement);
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (!phalcon_valid_foreach(params TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(params);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_INIT_VAR(index);
PHALCON_GET_FOREACH_KEY(index, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(bind_value);
PHALCON_INIT_VAR(is_numeric);
PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", bind_value);
if (PHALCON_IS_TRUE(is_numeric)) {
PHALCON_CPY_WRT(value, bind_value);
} else {
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, pdo, "quote", bind_value, PH_NO_CHECK);
}
if (Z_TYPE_P(index) == IS_LONG) {
PHALCON_INIT_VAR(place_key);
PHALCON_CONCAT_SV(place_key, "?", index);
PHALCON_INIT_VAR(replaced_sql);
phalcon_fast_str_replace(replaced_sql, place_key, value, sql TSRMLS_CC);
PHALCON_CPY_WRT(sql, replaced_sql);
} else {
if (Z_TYPE_P(index) == IS_STRING) {
PHALCON_INIT_VAR(place_key);
PHALCON_CONCAT_SVS(place_key, ":", index, ":");
PHALCON_INIT_VAR(replaced_sql);
phalcon_fast_str_replace(replaced_sql, place_key, value, sql TSRMLS_CC);
PHALCON_CPY_WRT(sql, replaced_sql);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CCTOR(sql);
}
}
RETURN_CCTOR(sql_statement);
}
/**
* Lists table indexes
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Index[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, describeIndexes){
zval *table = NULL, *schema = NULL, *dialect = NULL, *fetch_assoc = NULL, *sql = NULL;
zval *describe = NULL, *indexes = NULL, *index = NULL, *key_name = NULL, *empty_arr = NULL;
zval *column_name = NULL, *index_objects = NULL, *index_columns = NULL;
zval *name = 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_ALLOC_ZVAL_MM(schema);
ZVAL_NULL(schema);
}
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SL("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describeindexes", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(indexes);
array_init(indexes);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(index);
PHALCON_INIT_VAR(key_name);
phalcon_array_fetch_string(&key_name, index, SL("key_name"), PH_NOISY_CC);
eval_int = phalcon_array_isset(indexes, key_name);
if (!eval_int) {
PHALCON_INIT_VAR(empty_arr);
array_init(empty_arr);
phalcon_array_update_zval(&indexes, key_name, &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_VAR(column_name);
phalcon_array_fetch_string(&column_name, index, SL("column_name"), PH_NOISY_CC);
phalcon_array_update_append_multi_2(&indexes, key_name, column_name, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(index_objects);
array_init(index_objects);
if (!phalcon_valid_foreach(indexes TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(indexes);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){
goto ph_cycle_end_1;
}
PHALCON_INIT_VAR(name);
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(index_columns);
PHALCON_INIT_VAR(index);
object_init_ex(index, phalcon_db_index_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(index, "__construct", name, index_columns, PH_CHECK);
phalcon_array_update_zval(&index_objects, name, &index, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
RETURN_CTOR(index_objects);
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeColumns){
zval *table, *schema = NULL, *columns, *dialect, *size_pattern;
zval *sql, *fetch_assoc, *describe, *old_column = NULL;
zval *field = NULL, *definition = NULL, *column_type = NULL, *pos = NULL, *attribute = NULL;
zval *matches = NULL, *match_one = NULL, *column_name = NULL, *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_INIT_NVAR(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(size_pattern);
ZVAL_STRING(size_pattern, "#\\(([0-9]+)(,[0-9]+)*\\)#", 1);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describecolumns", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(old_column);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(field);
PHALCON_INIT_NVAR(definition);
array_init(definition);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_INIT_NVAR(column_type);
phalcon_array_fetch_string(&column_type, field, SL("type"), PH_NOISY_CC);
PHALCON_INIT_NVAR(pos);
phalcon_fast_stripos_str(pos, column_type, SL("int") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(pos)) {
phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC);
if (zend_is_true(attribute)) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE TSRMLS_CC);
}
} else {
if (phalcon_memnstr_str(column_type, SL("varchar") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("date") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("decimal") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("char") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("datetime") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("text") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("float") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE TSRMLS_CC);
} else {
if (phalcon_memnstr_str(column_type, SL("enum") TSRMLS_CC)) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE TSRMLS_CC);
}
}
}
}
}
}
}
}
}
if (phalcon_memnstr_str(column_type, SL("(") TSRMLS_CC)) {
PHALCON_INIT_NVAR(matches);
array_init(matches);
Z_SET_ISREF_P(matches);
PHALCON_INIT_NVAR(pos);
PHALCON_CALL_FUNC_PARAMS_3(pos, "preg_match", size_pattern, column_type, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(pos)) {
eval_int = phalcon_array_isset_long(matches, 1);
if (eval_int) {
PHALCON_INIT_NVAR(match_one);
phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY_CC);
phalcon_array_update_string(&definition, SL("size"), &match_one, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
}
}
if (phalcon_memnstr_str(column_type, SL("unsigned") TSRMLS_CC)) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE TSRMLS_CC);
}
if (!zend_is_true(old_column)) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("pk"), PH_NOISY_CC);
if (zend_is_true(attribute)) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, field, SL("notnull"), PH_NOISY_CC);
if (zend_is_true(attribute)) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(column_name);
phalcon_array_fetch_string(&column_name, field, SL("name"), PH_NOISY_CC);
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(column, "__construct", column_name, definition, PH_CHECK);
phalcon_array_append(&columns, column, PH_SEPARATE TSRMLS_CC);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CTOR(columns);
}
/**
* Handles routing information received from the rewrite engine
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router, handle) {
zval *uri = NULL, *real_uri = NULL, *request = NULL, *route_found = NULL, *parts = NULL;
zval *params = NULL, *matches = NULL, *routes = NULL, *reversed_routes = NULL;
zval *route = NULL, *methods = NULL, *dependency_injector = NULL;
zval *service = NULL, *match_method = NULL, *pattern = NULL, *have_parenthesis = NULL;
zval *paths = NULL, *position = NULL, *part = NULL, *match_position = NULL;
zval *module = NULL, *default_module = NULL, *controller = NULL, *default_controller = NULL;
zval *action = NULL, *default_action = NULL, *params_str = NULL, *one = NULL;
zval *str_params = NULL, *slash = NULL, *params_merge = NULL, *default_params = 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", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_ALLOC_ZVAL_MM(uri);
ZVAL_NULL(uri);
}
if (!zend_is_true(uri)) {
PHALCON_INIT_VAR(real_uri);
PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri", PH_NO_CHECK);
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_INIT_VAR(request);
ZVAL_NULL(request);
PHALCON_INIT_VAR(route_found);
ZVAL_BOOL(route_found, 0);
PHALCON_INIT_VAR(parts);
array_init(parts);
PHALCON_INIT_VAR(params);
array_init(params);
PHALCON_INIT_VAR(matches);
ZVAL_NULL(matches);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
PHALCON_INIT_VAR(routes);
phalcon_read_property(&routes, this_ptr, SL("_routes"), PH_NOISY_CC);
PHALCON_INIT_VAR(reversed_routes);
PHALCON_CALL_FUNC_PARAMS_1(reversed_routes, "array_reverse", routes);
if (!phalcon_valid_foreach(reversed_routes TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(reversed_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(methods);
PHALCON_CALL_METHOD(methods, route, "gethttpmethods", PH_NO_CHECK);
if (Z_TYPE_P(methods) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_dispatcher_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "request", 1);
PHALCON_INIT_VAR(request);
PHALCON_CALL_METHOD_PARAMS_1(request, dependency_injector, "getshared", service, PH_NO_CHECK);
}
PHALCON_INIT_VAR(match_method);
PHALCON_CALL_METHOD_PARAMS_1(match_method, request, "ismethod", methods, PH_NO_CHECK);
if (PHALCON_IS_FALSE(match_method)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
}
}
PHALCON_INIT_VAR(pattern);
PHALCON_CALL_METHOD(pattern, route, "getcompiledpattern", PH_NO_CHECK);
PHALCON_INIT_VAR(have_parenthesis);
phalcon_fast_strpos_str(have_parenthesis, pattern, SL("(") TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(have_parenthesis)) {
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(route_found);
PHALCON_CALL_FUNC_PARAMS_3(route_found, "preg_match", pattern, real_uri, matches);
Z_UNSET_ISREF_P(matches);
} else {
PHALCON_INIT_VAR(route_found);
is_equal_function(route_found, pattern, real_uri TSRMLS_CC);
}
if (zend_is_true(route_found)) {
PHALCON_INIT_VAR(paths);
PHALCON_CALL_METHOD(paths, route, "getpaths", PH_NO_CHECK);
PHALCON_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
if (!phalcon_valid_foreach(paths TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(paths);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) {
goto ph_cycle_end_1;
}
PHALCON_INIT_VAR(part);
PHALCON_GET_FOREACH_KEY(part, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(position);
eval_int = phalcon_array_isset(matches, position);
if (eval_int) {
PHALCON_INIT_VAR(match_position);
phalcon_array_fetch(&match_position, matches, position, PH_NOISY_CC);
phalcon_array_update_zval(&parts, part, &match_position, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
phalcon_update_property_zval(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
phalcon_update_property_zval(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
goto ph_cycle_end_0;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if (zend_is_true(route_found)) {
eval_int = phalcon_array_isset_string(parts, SL("module")+1);
if (eval_int) {
PHALCON_INIT_VAR(module);
phalcon_array_fetch_string(&module, parts, SL("module"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), module TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("module")+1);
} else {
PHALCON_INIT_VAR(default_module);
phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("controller")+1);
if (eval_int) {
PHALCON_INIT_VAR(controller);
phalcon_array_fetch_string(&controller, parts, SL("controller"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), controller TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("controller")+1);
} else {
PHALCON_INIT_VAR(default_controller);
phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("action")+1);
if (eval_int) {
PHALCON_INIT_VAR(action);
phalcon_array_fetch_string(&action, parts, SL("action"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), action TSRMLS_CC);
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("action")+1);
} else {
PHALCON_INIT_VAR(default_action);
phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(parts, SL("params")+1);
if (eval_int) {
PHALCON_INIT_VAR(params_str);
phalcon_array_fetch_string(¶ms_str, parts, SL("params"), PH_NOISY_CC);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(str_params);
PHALCON_CALL_FUNC_PARAMS_2(str_params, "substr", params_str, one);
if (zend_is_true(str_params)) {
PHALCON_INIT_VAR(slash);
ZVAL_STRING(slash, "/", 1);
PHALCON_INIT_VAR(params);
phalcon_fast_explode(params, slash, str_params TSRMLS_CC);
}
PHALCON_SEPARATE(parts);
phalcon_array_unset_string(parts, SL("params")+1);
}
PHALCON_INIT_VAR(params_merge);
PHALCON_CALL_FUNC_PARAMS_2(params_merge, "array_merge", params, parts);
phalcon_update_property_zval(this_ptr, SL("_params"), params_merge TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 1 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(default_module);
phalcon_read_property(&default_module, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_module"), default_module TSRMLS_CC);
PHALCON_INIT_VAR(default_controller);
phalcon_read_property(&default_controller, this_ptr, SL("_defaultController"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_controller"), default_controller TSRMLS_CC);
PHALCON_INIT_VAR(default_action);
phalcon_read_property(&default_action, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_action"), default_action TSRMLS_CC);
PHALCON_INIT_VAR(default_params);
phalcon_read_property(&default_params, this_ptr, SL("_defaultParams"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_params"), default_params TSRMLS_CC);
phalcon_update_property_bool(this_ptr, SL("_wasMatched"), 0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Checks for annotations in the public methods of the controller
*
* @param string $controller
* @param string $action
* @param Phalcon\Annotations\Annotation $annotation
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, processActionAnnotation){
zval *controller, *action, *annotation, *is_route = NULL;
zval *methods = NULL, *name, *action_sufix, *empty_str;
zval *real_action_name, *action_name, *route_prefix;
zval *parameter = NULL, *paths = NULL, *position, *value, *uri = NULL, *route;
zval *converts, *convert = NULL, *param = NULL, *route_name;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &controller, &action, &annotation) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(is_route);
ZVAL_BOOL(is_route, 0);
PHALCON_INIT_VAR(methods);
PHALCON_INIT_VAR(name);
PHALCON_CALL_METHOD(name, annotation, "getname");
/**
* Find if the route is for adding routes
*/
if (PHALCON_IS_STRING(name, "Route")) {
ZVAL_BOOL(is_route, 1);
} else {
if (PHALCON_IS_STRING(name, "Get")) {
ZVAL_BOOL(is_route, 1);
ZVAL_STRING(methods, "GET", 1);
} else {
if (PHALCON_IS_STRING(name, "Post")) {
ZVAL_BOOL(is_route, 1);
PHALCON_INIT_NVAR(methods);
ZVAL_STRING(methods, "POST", 1);
} else {
if (PHALCON_IS_STRING(name, "Put")) {
ZVAL_BOOL(is_route, 1);
PHALCON_INIT_NVAR(methods);
ZVAL_STRING(methods, "PUT", 1);
} else {
if (PHALCON_IS_STRING(name, "Options")) {
ZVAL_BOOL(is_route, 1);
PHALCON_INIT_NVAR(methods);
ZVAL_STRING(methods, "OPTIONS", 1);
}
}
}
}
}
if (PHALCON_IS_TRUE(is_route)) {
PHALCON_OBS_VAR(action_sufix);
phalcon_read_property(&action_sufix, this_ptr, SL("_actionSufix"), PH_NOISY_CC);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(real_action_name);
phalcon_fast_str_replace(real_action_name, action_sufix, empty_str, action TSRMLS_CC);
PHALCON_INIT_VAR(action_name);
phalcon_fast_strtolower(action_name, real_action_name);
PHALCON_OBS_VAR(route_prefix);
phalcon_read_property(&route_prefix, this_ptr, SL("_routePrefix"), PH_NOISY_CC);
PHALCON_INIT_VAR(parameter);
ZVAL_STRING(parameter, "paths", 1);
/**
* Check for existing paths in the annotation
*/
PHALCON_INIT_VAR(paths);
PHALCON_CALL_METHOD_PARAMS_1(paths, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(paths) != IS_ARRAY) {
PHALCON_INIT_NVAR(paths);
array_init(paths);
}
phalcon_array_update_string(&paths, SL("controller"), &controller, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&paths, SL("action"), &action_name, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(position);
ZVAL_LONG(position, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, annotation, "getargument", position);
/**
* Create the route using the prefix
*/
if (Z_TYPE_P(value) != IS_NULL) {
if (!PHALCON_IS_STRING(value, "/")) {
PHALCON_INIT_VAR(uri);
PHALCON_CONCAT_VV(uri, route_prefix, value);
} else {
PHALCON_CPY_WRT(uri, route_prefix);
}
} else {
PHALCON_INIT_NVAR(uri);
PHALCON_CONCAT_VV(uri, route_prefix, action_name);
}
/**
* Add the route to the router
*/
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_2(route, this_ptr, "add", uri, paths);
if (Z_TYPE_P(methods) == IS_NULL) {
PHALCON_INIT_NVAR(parameter);
ZVAL_STRING(parameter, "methods", 1);
PHALCON_INIT_NVAR(methods);
PHALCON_CALL_METHOD_PARAMS_1(methods, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(methods) == IS_ARRAY) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods);
} else {
if (Z_TYPE_P(methods) == IS_STRING) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods);
}
}
} else {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "via", methods);
}
PHALCON_INIT_NVAR(parameter);
ZVAL_STRING(parameter, "converts", 1);
PHALCON_INIT_VAR(converts);
PHALCON_CALL_METHOD_PARAMS_1(converts, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(converts) == IS_ARRAY) {
if (!phalcon_is_iterable(converts, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(param, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(convert);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(route, "convert", param, convert);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_NVAR(parameter);
ZVAL_STRING(parameter, "name", 1);
PHALCON_INIT_VAR(route_name);
PHALCON_CALL_METHOD_PARAMS_1(route_name, annotation, "getnamedparameter", parameter);
if (Z_TYPE_P(route_name) == IS_STRING) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(route, "setname", route_name);
}
RETURN_MM_TRUE;
}
PHALCON_MM_RESTORE();
}
/**
* Inserts data into a table using custom RBDM SQL syntax
*
* <code>
* //Inserting a new robot
* $success = $connection->insert(
* "robots",
* array("Astro Boy", 1952),
* array("name", "year")
* );
*
* //Next SQL sentence is sent to the database system
* INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
* </code>
*
* @param string $table
* @param array $values
* @param array $fields
* @param array $dataTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, insert){
zval *table = NULL, *values = NULL, *fields = NULL, *data_types = NULL, *number_values = NULL;
zval *exception_message = NULL, *exception = NULL, *placeholders = NULL;
zval *insert_values = NULL, *bind_data_types = NULL, *value = NULL;
zval *position = NULL, *str_value = NULL, *bind_type = NULL, *comma = NULL;
zval *joined_values = NULL, *joined_fields = NULL, *insert_sql = NULL;
zval *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, "zz|zz", &table, &values, &fields, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!fields) {
PHALCON_ALLOC_ZVAL_MM(fields);
ZVAL_NULL(fields);
}
if (!data_types) {
PHALCON_ALLOC_ZVAL_MM(data_types);
ZVAL_NULL(data_types);
}
if (Z_TYPE_P(values) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array");
return;
}
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);
PHALCON_INIT_VAR(insert_values);
array_init(insert_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_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);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&insert_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_VAR(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);
}
}
}
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_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_3(success, this_ptr, "execute", insert_sql, insert_values, bind_data_types, PH_NO_CHECK);
RETURN_CCTOR(success);
}
/**
* Fires a event in the events manager causing that the acive listeners will be notified about it
*
* @param string $eventType
* @param object $source
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire){
zval *event_type = NULL, *source = NULL, *colon = NULL, *event_parts = NULL;
zval *exception_message = NULL, *exception = NULL, *type = NULL, *event_name = NULL;
zval *status = NULL, *events = NULL, *fire_events = NULL, *handler = NULL, *event = NULL;
zval *class_name = NULL, *arguments = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &event_type, &source) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(colon);
ZVAL_STRING(colon, ":", 1);
PHALCON_INIT_VAR(event_parts);
phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC);
eval_int = phalcon_array_isset_long(event_parts, 1);
if (!eval_int) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type);
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_events_exception_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(type);
phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(event_name);
phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(status);
ZVAL_NULL(status);
PHALCON_INIT_VAR(events);
phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC);
eval_int = phalcon_array_isset(events, type);
if (eval_int) {
PHALCON_INIT_VAR(fire_events);
phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC);
if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fire_events);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(handler);
if (Z_TYPE_P(handler) == IS_OBJECT) {
PHALCON_INIT_VAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(event, "__construct", event_name, source, PH_CHECK);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, handler TSRMLS_CC);
if (PHALCON_COMPARE_STRING(class_name, "Closure")) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(status);
PHALCON_CALL_FUNC_PARAMS_2(status, "call_user_func_array", handler, arguments);
} else {
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, handler, Z_STRVAL_P(event_name), event, source, PH_NO_CHECK);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
RETURN_CCTOR(status);
}
/**
* Lists table indexes
*
*<code>
* print_r($connection->describeIndexes('robots_parts'));
*</code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Index[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, describeIndexes){
zval *table, *schema = NULL, *dialect, *fetch_num, *sql, *describe;
zval *indexes, *index = NULL, *key_name = NULL, *empty_arr = NULL, *column_name = NULL;
zval *index_objects, *index_columns = NULL, *name = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
RETURN_MM_NULL();
}
if (!schema) {
PHALCON_INIT_VAR(schema);
}
PHALCON_OBS_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, 3);
/**
* Get the SQL required to describe indexes from the Dialect
*/
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describeindexes", table, schema);
/**
* Cryptic Guide: 2: table, 3: from, 4: to
*/
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_num);
PHALCON_INIT_VAR(indexes);
array_init(indexes);
if (!phalcon_is_iterable(describe, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(index);
PHALCON_OBS_NVAR(key_name);
phalcon_array_fetch_long(&key_name, index, 2, PH_NOISY_CC);
if (!phalcon_array_isset(indexes, key_name)) {
PHALCON_INIT_NVAR(empty_arr);
array_init(empty_arr);
phalcon_array_update_zval(&indexes, key_name, &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, index, 4, PH_NOISY_CC);
phalcon_array_update_append_multi_2(&indexes, key_name, column_name, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(index_objects);
array_init(index_objects);
if (!phalcon_is_iterable(indexes, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(index_columns);
/**
* Every index is abstracted using a Phalcon\Db\Index instance
*/
PHALCON_INIT_NVAR(index);
object_init_ex(index, phalcon_db_index_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(index, "__construct", name, index_columns);
phalcon_array_update_zval(&index_objects, name, &index, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
RETURN_CTOR(index_objects);
}
/**
* Makes the work of autoload registered classes
*
* @param string $className
* @return boolean
*/
PHP_METHOD(Phalcon_Loader, autoLoad){
zval *class_name, *events_manager, *event_name = NULL;
zval *classes, *file_path = NULL, *extensions, *ds, *namespace_separator;
zval *empty_str, *zero, *namespaces, *directory = NULL;
zval *prefix = NULL, *prefix_namespace = NULL, *file_name = NULL;
zval *fixed_directory = NULL, *extension = NULL, *complete_path = NULL;
zval *pseudo_separator, *prefixes, *no_prefix_class = NULL;
zval *ds_class_name, *ns_class_name, *directories;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &class_name) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_OBS_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name);
}
/**
* First we check for static paths for classes
*/
PHALCON_OBS_VAR(classes);
phalcon_read_property(&classes, this_ptr, SL("_classes"), PH_NOISY_CC);
if (Z_TYPE_P(classes) == IS_ARRAY) {
if (phalcon_array_isset(classes, class_name)) {
PHALCON_OBS_VAR(file_path);
phalcon_array_fetch(&file_path, classes, class_name, PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
RETURN_MM_TRUE;
}
}
PHALCON_OBS_VAR(extensions);
phalcon_read_property(&extensions, this_ptr, SL("_extensions"), PH_NOISY_CC);
PHALCON_INIT_VAR(ds);
zend_get_constant(SL("DIRECTORY_SEPARATOR"), ds TSRMLS_CC);
PHALCON_INIT_VAR(namespace_separator);
ZVAL_STRING(namespace_separator, "\\", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
/**
* Checking in namespaces
*/
PHALCON_OBS_VAR(namespaces);
phalcon_read_property(&namespaces, this_ptr, SL("_namespaces"), PH_NOISY_CC);
if (Z_TYPE_P(namespaces) == IS_ARRAY) {
if (!phalcon_is_iterable(namespaces, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(prefix, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(directory);
/**
* The class name must start with the current namespace
*/
if (phalcon_start_with(class_name, prefix, NULL)) {
/**
* Append the namespace separator to the prefix
*/
PHALCON_INIT_NVAR(prefix_namespace);
PHALCON_CONCAT_VV(prefix_namespace, prefix, namespace_separator);
PHALCON_INIT_NVAR(file_name);
phalcon_fast_str_replace(file_name, prefix_namespace, empty_str, class_name TSRMLS_CC);
if (zend_is_true(file_name)) {
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
PHALCON_INIT_NVAR(complete_path);
PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension);
PHALCON_INIT_NVAR(file_path);
phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC);
/**
* Check if a events manager is available
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
/**
* This is probably a good path, let's check if the file exist
*/
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Simulate a require
*/
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
/**
* Return true mean success
*/
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_VAR(pseudo_separator);
ZVAL_STRING(pseudo_separator, "_", 1);
/**
* Checking in prefixes
*/
PHALCON_OBS_VAR(prefixes);
phalcon_read_property(&prefixes, this_ptr, SL("_prefixes"), PH_NOISY_CC);
if (Z_TYPE_P(prefixes) == IS_ARRAY) {
if (!phalcon_is_iterable(prefixes, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(prefix, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(directory);
/**
* The class name starts with the prefix?
*/
if (phalcon_start_with(class_name, prefix, NULL)) {
/**
* Remove the prefix from the class
*/
PHALCON_INIT_NVAR(no_prefix_class);
phalcon_fast_str_replace(no_prefix_class, prefix, empty_str, class_name TSRMLS_CC);
/**
* Change the pseudo-separator '_' by the directory separator
*/
PHALCON_INIT_NVAR(file_name);
phalcon_fast_str_replace(file_name, pseudo_separator, ds, no_prefix_class TSRMLS_CC);
if (zend_is_true(file_name)) {
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
PHALCON_INIT_NVAR(complete_path);
PHALCON_CONCAT_VVSV(complete_path, fixed_directory, file_name, ".", extension);
PHALCON_INIT_NVAR(file_path);
phalcon_fast_str_replace(file_path, namespace_separator, ds, complete_path TSRMLS_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
/**
* Call 'pathFound' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah3, &hp3);
}
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
/**
* Change the pseudo-separator by the directory separator in the class name
*/
PHALCON_INIT_VAR(ds_class_name);
phalcon_fast_str_replace(ds_class_name, pseudo_separator, ds, class_name TSRMLS_CC);
/**
* And change the namespace separator by directory separator too
*/
PHALCON_INIT_VAR(ns_class_name);
phalcon_fast_str_replace(ns_class_name, namespace_separator, ds, ds_class_name TSRMLS_CC);
/**
* Checking in directories
*/
PHALCON_OBS_VAR(directories);
phalcon_read_property(&directories, this_ptr, SL("_directories"), PH_NOISY_CC);
if (Z_TYPE_P(directories) == IS_ARRAY) {
if (!phalcon_is_iterable(directories, &ah4, &hp4, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(directory);
/**
* Add a trailing directory separator if the user forgot to do that
*/
PHALCON_INIT_NVAR(fixed_directory);
phalcon_fix_path(&fixed_directory, directory, ds TSRMLS_CC);
if (!phalcon_is_iterable(extensions, &ah5, &hp5, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(extension);
/**
* Create a possible path for the file
*/
PHALCON_INIT_NVAR(file_path);
PHALCON_CONCAT_VVSV(file_path, fixed_directory, ns_class_name, ".", extension);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_checkedPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:beforeCheckPath", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Check in every directory if the class exists here
*/
if (phalcon_file_exists(file_path TSRMLS_CC) == SUCCESS) {
/**
* Call 'pathFound' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_foundPath"), file_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:pathFound", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, file_path);
}
/**
* Simulate a require
*/
if (phalcon_require(file_path TSRMLS_CC) == FAILURE) {
return;
}
/**
* Return true meaning success
*/
RETURN_MM_TRUE;
}
zend_hash_move_forward_ex(ah5, &hp5);
}
zend_hash_move_forward_ex(ah4, &hp4);
}
}
/**
* Call 'afterCheckClass' event
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "loader:afterCheckClass", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, class_name);
}
/**
* Cannot find the class return false
*/
RETURN_MM_FALSE;
}
/**
* Generates a URL
*
* @param string|array $uri
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Url, get){
zval *uri = NULL, *base_uri, *dependency_injector, *service;
zval *router, *route_name, *route, *exception_message;
zval *pattern, *replaced_pattern = NULL, *controller_name;
zval *wildcard = NULL, *action_name, *matches, *match_position;
zval *set_order, *names_pattern, *have_variables = NULL;
zval *match = NULL, *match_zero = NULL, *match_one = NULL, *value = NULL, *new_pcre_pattern = NULL;
zval *final_uri;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL };
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!uri) {
PHALCON_INIT_NVAR(uri);
}
PHALCON_INIT_VAR(base_uri);
PHALCON_CALL_METHOD(base_uri, this_ptr, "getbaseuri", PH_NO_CHECK);
if (Z_TYPE_P(uri) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(uri, SS("for"));
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_url_exception_ce, "It's necessary to define the route name with the parameter \"for\"");
return;
}
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (!zend_is_true(dependency_injector)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_url_exception_ce, "A dependency injector container is required to obtain the \"url\" service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "router", 1);
PHALCON_INIT_VAR(router);
PHALCON_CALL_METHOD_PARAMS_1(router, dependency_injector, "getshared", service, PH_NO_CHECK);
PHALCON_INIT_VAR(route_name);
phalcon_array_fetch_string(&route_name, uri, SL("for"), PH_NOISY_CC);
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_1(route, router, "getroutebyname", route_name, PH_NO_CHECK);
if (Z_TYPE_P(route) != IS_OBJECT) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Cannot obtain a route using the name \"", route_name, "\"");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_url_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(pattern);
PHALCON_CALL_METHOD(pattern, route, "getpattern", PH_NO_CHECK);
PHALCON_CPY_WRT(replaced_pattern, pattern);
eval_int = phalcon_array_isset_string(uri, SS("controller"));
if (eval_int) {
PHALCON_INIT_VAR(controller_name);
phalcon_array_fetch_string(&controller_name, uri, SL("controller"), PH_NOISY_CC);
PHALCON_INIT_VAR(wildcard);
ZVAL_STRING(wildcard, ":controller", 1);
PHALCON_INIT_VAR(r0);
phalcon_fast_str_replace(r0, wildcard, controller_name, replaced_pattern TSRMLS_CC);
PHALCON_CPY_WRT(replaced_pattern, r0);
}
eval_int = phalcon_array_isset_string(uri, SS("action"));
if (eval_int) {
PHALCON_INIT_VAR(action_name);
phalcon_array_fetch_string(&action_name, uri, SL("action"), PH_NOISY_CC);
PHALCON_INIT_NVAR(wildcard);
ZVAL_STRING(wildcard, ":action", 1);
PHALCON_INIT_VAR(r1);
phalcon_fast_str_replace(r1, wildcard, action_name, replaced_pattern TSRMLS_CC);
PHALCON_CPY_WRT(replaced_pattern, r1);
}
if (phalcon_memnstr_str(replaced_pattern, SL("{") TSRMLS_CC)) {
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(match_position);
ZVAL_LONG(match_position, 1);
PHALCON_INIT_VAR(set_order);
ZVAL_LONG(set_order, 2);
PHALCON_INIT_VAR(names_pattern);
ZVAL_STRING(names_pattern, "#{(([a-zA-Z][a-zA-Z0-9\\_\\-]*)*)(:([^}]+}?))*}#", 1);
p0[0] = names_pattern;
p0[1] = replaced_pattern;
Z_SET_ISREF_P(matches);
p0[2] = matches;
p0[3] = set_order;
PHALCON_INIT_VAR(r2);
PHALCON_CALL_FUNC_PARAMS(r2, "preg_match_all", 4, p0);
Z_UNSET_ISREF_P(p0[2]);
PHALCON_CPY_WRT(have_variables, r2);
if (zend_is_true(have_variables)) {
if (!phalcon_valid_foreach(matches TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(matches);
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(match);
PHALCON_INIT_NVAR(match_zero);
phalcon_array_fetch_long(&match_zero, match, 0, PH_NOISY_CC);
PHALCON_INIT_NVAR(match_one);
phalcon_array_fetch_long(&match_one, match, 1, PH_NOISY_CC);
eval_int = phalcon_array_isset(uri, match_one);
if (eval_int) {
PHALCON_INIT_NVAR(value);
phalcon_array_fetch(&value, uri, match_one, PH_NOISY_CC);
PHALCON_INIT_NVAR(new_pcre_pattern);
phalcon_fast_str_replace(new_pcre_pattern, match_zero, value, replaced_pattern TSRMLS_CC);
PHALCON_CPY_WRT(replaced_pattern, new_pcre_pattern);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
}
RETURN_CCTOR(replaced_pattern);
} else {
PHALCON_INIT_VAR(final_uri);
PHALCON_CONCAT_VV(final_uri, base_uri, uri);
RETURN_CTOR(final_uri);
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Config\Adapter\Ini constructor
*
* @param string $filePath
*/
PHP_METHOD(Phalcon_Config_Adapter_Ini, __construct) {
zval *file_path, *config, *process_sections;
zval *ini_config, *base_path, *exception_message;
zval *dot, *directives = NULL, *section = NULL, *value = NULL, *key = NULL, *directive_parts = NULL;
zval *left_part = NULL, *right_part = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &file_path);
PHALCON_INIT_VAR(config);
array_init(config);
PHALCON_INIT_VAR(process_sections);
ZVAL_BOOL(process_sections, 1);
PHALCON_INIT_VAR(ini_config);
PHALCON_CALL_FUNC_PARAMS_2(ini_config, "parse_ini_file", file_path, process_sections);
if (PHALCON_IS_FALSE(ini_config)) {
PHALCON_INIT_VAR(base_path);
PHALCON_CALL_FUNC_PARAMS_1(base_path, "basename", file_path);
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Configuration file ", base_path, " can't be loaded");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_config_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(dot);
ZVAL_STRING(dot, ".", 1);
if (!phalcon_is_iterable(ini_config, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(section, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(directives);
if (!phalcon_is_iterable(directives, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(value);
if (phalcon_memnstr_str(key, SL(".") TSRMLS_CC)) {
PHALCON_INIT_NVAR(directive_parts);
phalcon_fast_explode(directive_parts, dot, key TSRMLS_CC);
PHALCON_OBS_NVAR(left_part);
phalcon_array_fetch_long(&left_part, directive_parts, 0, PH_NOISY_CC);
PHALCON_OBS_NVAR(right_part);
phalcon_array_fetch_long(&right_part, directive_parts, 1, PH_NOISY_CC);
phalcon_array_update_zval_zval_zval_multi_3(&config, section, left_part, right_part, &value, 0 TSRMLS_CC);
} else {
phalcon_array_update_multi_2(&config, section, key, &value, 0 TSRMLS_CC);
}
zend_hash_move_forward_ex(ah1, &hp1);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Config\\Adapter\\Ini", "__construct", config);
PHALCON_MM_RESTORE();
}
/**
* Validates the form
*
* @param array $data
* @param object $entity
* @return boolean
*/
PHP_METHOD(Phalcon_Forms_Form, isValid){
zval *data = NULL, *entity = NULL, *elements, *not_failed = NULL, *messages;
zval *element = NULL, *validators = NULL, *name = NULL, *prepared_validators = NULL;
zval *validator = NULL, *scope = NULL, *validation = NULL, *element_messages = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &data, &entity) == FAILURE) {
RETURN_MM_NULL();
}
if (!data) {
PHALCON_INIT_VAR(data);
} else {
PHALCON_SEPARATE_PARAM(data);
}
if (!entity) {
PHALCON_INIT_VAR(entity);
}
PHALCON_OBS_VAR(elements);
phalcon_read_property(&elements, this_ptr, SL("_elements"), PH_NOISY_CC);
if (Z_TYPE_P(elements) == IS_ARRAY) {
/**
* If the user doesn't pass an entity we use the one in this_ptr->_entity
*/
if (Z_TYPE_P(entity) == IS_OBJECT) {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "bind", data, entity);
}
/**
* If the data is not an array use the one passed previously
*/
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_OBS_NVAR(data);
phalcon_read_property(&data, this_ptr, SL("_data"), PH_NOISY_CC);
}
PHALCON_INIT_VAR(not_failed);
ZVAL_BOOL(not_failed, 1);
PHALCON_INIT_VAR(messages);
array_init(messages);
if (!phalcon_is_iterable(elements, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(element);
PHALCON_INIT_NVAR(validators);
PHALCON_CALL_METHOD(validators, element, "getvalidators");
if (Z_TYPE_P(validators) == IS_ARRAY) {
if (phalcon_fast_count_ev(validators TSRMLS_CC)) {
/**
* Element's name
*/
PHALCON_INIT_NVAR(name);
PHALCON_CALL_METHOD(name, element, "getname");
/**
* Prepare the validators
*/
PHALCON_INIT_NVAR(prepared_validators);
array_init(prepared_validators);
if (!phalcon_is_iterable(validators, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(validator);
PHALCON_INIT_NVAR(scope);
array_init_size(scope, 2);
phalcon_array_append(&scope, name, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&scope, validator, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&prepared_validators, scope, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Create an implicit validation
*/
PHALCON_INIT_NVAR(validation);
object_init_ex(validation, phalcon_validation_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(validation, "__construct", prepared_validators);
PHALCON_INIT_NVAR(element_messages);
PHALCON_CALL_METHOD_PARAMS_2(element_messages, validation, "validate", data, entity);
if (phalcon_fast_count_ev(element_messages TSRMLS_CC)) {
PHALCON_INIT_NVAR(name);
PHALCON_CALL_METHOD(name, element, "getname");
phalcon_array_update_zval(&messages, name, &element_messages, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(not_failed);
ZVAL_BOOL(not_failed, 0);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* If the validation fails
*/
if (!zend_is_true(not_failed)) {
phalcon_update_property_zval(this_ptr, SL("_messages"), messages TSRMLS_CC);
}
/**
* Return the validation status
*/
RETURN_NCTOR(not_failed);
}
PHALCON_MM_RESTORE();
}
/**
* Binds data to the entity
*
* @param array $data
* @param object $entity
* @param object $entity
* @return Phalcon\Forms\Form
*/
PHP_METHOD(Phalcon_Forms_Form, bind){
zval *data, *entity, *whitelist = NULL, *elements, *value = NULL;
zval *key = NULL, *method = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &data, &entity, &whitelist) == FAILURE) {
RETURN_MM_NULL();
}
if (!whitelist) {
PHALCON_INIT_VAR(whitelist);
}
/**
* The data must be an array
*/
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_forms_exception_ce, "The data must be an array");
return;
}
PHALCON_OBS_VAR(elements);
phalcon_read_property(&elements, this_ptr, SL("_elements"), PH_NOISY_CC);
if (Z_TYPE_P(elements) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_forms_exception_ce, "There are no elements in the form");
return;
}
if (!phalcon_is_iterable(data, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (!phalcon_array_isset(elements, key)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
/**
* Use the setter if any available
*/
PHALCON_INIT_NVAR(method);
PHALCON_CONCAT_SV(method, "set", key);
if (phalcon_method_exists(entity, method TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(entity, Z_STRVAL_P(method), value);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
/**
* Use the public property if it doesn't have a setter
*/
phalcon_update_property_zval_zval(entity, key, value TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_zval(this_ptr, SL("_data"), data TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns the translation related to the given key
*
* @param string $index
* @param array $placeholders
* @return string
*/
PHP_METHOD(Phalcon_Translate_Adapter_NativeArray, query){
zval *index, *placeholders = NULL, *translate, *translation = NULL;
zval *value = NULL, *key = NULL, *key_placeholder = NULL, *replaced = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &index, &placeholders) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!placeholders) {
PHALCON_INIT_NVAR(placeholders);
}
PHALCON_INIT_VAR(translate);
phalcon_read_property(&translate, this_ptr, SL("_translate"), PH_NOISY_CC);
eval_int = phalcon_array_isset(translate, index);
if (eval_int) {
PHALCON_INIT_VAR(translation);
phalcon_array_fetch(&translation, translate, index, PH_NOISY_CC);
if (Z_TYPE_P(placeholders) == IS_ARRAY) {
if (phalcon_fast_count_ev(placeholders TSRMLS_CC)) {
if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(placeholders);
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_INIT_NVAR(key_placeholder);
PHALCON_CONCAT_SVS(key_placeholder, "%", key, "%");
PHALCON_INIT_NVAR(replaced);
phalcon_fast_str_replace(replaced, key_placeholder, value, translation TSRMLS_CC);
PHALCON_CPY_WRT(translation, replaced);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
}
RETURN_CCTOR(translation);
}
RETURN_CCTOR(index);
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
*<code>
* //Make a connection
* $connection = new Phalcon\Db\Adapter\Pdo\Mysql(array(
* 'host' => '192.168.0.11',
* 'username' => 'sigma',
* 'password' => 'secret',
* 'dbname' => 'blog',
* ));
*
* //Reconnect
* $connection->connect();
* </code>
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect){
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsn_parts;
zval *value = NULL, *key = NULL, *dsn_attribute = NULL, *dsn_attributes = NULL;
zval *pdo_type, *dsn, *options = NULL, *persistent, *pdo;
zend_class_entry *ce;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) {
RETURN_MM_NULL();
}
if (!descriptor) {
PHALCON_INIT_VAR(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (Z_TYPE_P(descriptor) == IS_NULL) {
PHALCON_OBS_NVAR(descriptor);
phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC);
}
/**
* Check for a username or use null as default
*/
if (phalcon_array_isset_string(descriptor, SS("username"))) {
PHALCON_OBS_VAR(username);
phalcon_array_fetch_string(&username, descriptor, SL("username"), PH_NOISY_CC);
phalcon_array_unset_string(&descriptor, SS("username"), PH_SEPARATE);
} else {
PHALCON_INIT_NVAR(username);
}
/**
* Check for a password or use null as default
*/
if (phalcon_array_isset_string(descriptor, SS("password"))) {
PHALCON_OBS_VAR(password);
phalcon_array_fetch_string(&password, descriptor, SL("password"), PH_NOISY_CC);
phalcon_array_unset_string(&descriptor, SS("password"), PH_SEPARATE);
} else {
PHALCON_INIT_NVAR(password);
}
/**
* Check if the user has defined a custom dsn
*/
if (!phalcon_array_isset_string(descriptor, SS("dsn"))) {
PHALCON_INIT_VAR(dsn_parts);
array_init(dsn_parts);
if (!phalcon_is_iterable(descriptor, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
PHALCON_INIT_NVAR(dsn_attribute);
PHALCON_CONCAT_VSV(dsn_attribute, key, "=", value);
phalcon_array_append(&dsn_parts, dsn_attribute, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(dsn_attributes);
phalcon_fast_join_str(dsn_attributes, SL(";"), dsn_parts TSRMLS_CC);
} else {
PHALCON_OBS_NVAR(dsn_attributes);
phalcon_array_fetch_string(&dsn_attributes, descriptor, SL("dsn"), PH_NOISY_CC);
}
PHALCON_OBS_VAR(pdo_type);
phalcon_read_property(&pdo_type, this_ptr, SL("_type"), PH_NOISY_CC);
PHALCON_INIT_VAR(dsn);
PHALCON_CONCAT_VSV(dsn, pdo_type, ":", dsn_attributes);
/**
* Check if the developer has defined custom options or create one from scratch
*/
if (phalcon_array_isset_string(descriptor, SS("options"))) {
PHALCON_OBS_VAR(options);
phalcon_array_fetch_string(&options, descriptor, SL("options"), PH_NOISY_CC);
} else {
PHALCON_INIT_NVAR(options);
array_init(options);
}
phalcon_array_update_long_long(&options, PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION, PH_SEPARATE TSRMLS_CC);
//phalcon_array_update_long_long(&options, PDO_ATTR_CASE, PDO_CASE_LOWER, PH_SEPARATE TSRMLS_CC);
phalcon_array_update_long_long(&options, PDO_ATTR_CURSOR, PDO_CURSOR_SCROLL, PH_SEPARATE TSRMLS_CC);
/**
* Check if the connection must be persistent
*/
if (phalcon_array_isset_string(descriptor, SS("persistent"))) {
PHALCON_OBS_VAR(persistent);
phalcon_array_fetch_string(&persistent, descriptor, SL("persistent"), PH_NOISY_CC);
if (zend_is_true(persistent)) {
phalcon_array_update_long_bool(&options, PDO_ATTR_PERSISTENT, 1, PH_SEPARATE TSRMLS_CC);
}
}
/**
* Create the connection using PDO
*/
ce = zend_fetch_class(SL("PDO"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(pdo);
object_init_ex(pdo, ce);
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(pdo, "__construct", dsn, username, password, options);
phalcon_update_property_zval(this_ptr, SL("_pdo"), pdo TSRMLS_CC);
PHALCON_MM_RESTORE();}
/**
* Produce the routing parameters from the rewrite information
*
* @param string $uri
*/
PHP_METHOD(Phalcon_Mvc_Router_Annotations, handle){
zval *uri = NULL, *real_uri = NULL, *processed, *annotations_service = NULL;
zval *handlers, *controller_sufix, *scope = NULL, *prefix = NULL;
zval *dependency_injector = NULL, *service = NULL, *handler = NULL;
zval *sufixed = NULL, *handler_annotations = NULL, *class_annotations = NULL;
zval *annotations = NULL, *annotation = NULL, *method_annotations = NULL;
zval *lowercased = NULL, *collection = NULL, *method = NULL;
HashTable *ah0, *ah1, *ah2, *ah3;
HashPosition hp0, hp1, hp2, hp3;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) {
RETURN_MM_NULL();
}
if (!uri) {
PHALCON_INIT_VAR(uri);
}
if (!zend_is_true(uri)) {
/**
* If 'uri' isn't passed as parameter it reads $_GET['_url']
*/
PHALCON_INIT_VAR(real_uri);
PHALCON_CALL_METHOD(real_uri, this_ptr, "_getrewriteuri");
} else {
PHALCON_CPY_WRT(real_uri, uri);
}
PHALCON_OBS_VAR(processed);
phalcon_read_property(&processed, this_ptr, SL("_processed"), PH_NOISY_CC);
if (!zend_is_true(processed)) {
PHALCON_INIT_VAR(annotations_service);
PHALCON_OBS_VAR(handlers);
phalcon_read_property(&handlers, this_ptr, SL("_handlers"), PH_NOISY_CC);
PHALCON_OBS_VAR(controller_sufix);
phalcon_read_property(&controller_sufix, this_ptr, SL("_controllerSufix"), PH_NOISY_CC);
if (!phalcon_is_iterable(handlers, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(scope);
if (Z_TYPE_P(scope) == IS_ARRAY) {
/**
* A prefix (if any) must be in position 0
*/
PHALCON_OBS_NVAR(prefix);
phalcon_array_fetch_long(&prefix, scope, 0, PH_NOISY_CC);
if (Z_TYPE_P(prefix) == IS_STRING) {
if (!phalcon_start_with(real_uri, prefix, NULL)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
if (Z_TYPE_P(annotations_service) != IS_OBJECT) {
PHALCON_OBS_NVAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "A dependency injection container is required to access the 'annotations' service");
return;
}
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "annotations", 1);
PHALCON_INIT_NVAR(annotations_service);
PHALCON_CALL_METHOD_PARAMS_1(annotations_service, dependency_injector, "getshared", service);
}
/**
* The controller must be in position 1
*/
PHALCON_OBS_NVAR(handler);
phalcon_array_fetch_long(&handler, scope, 1, PH_NOISY_CC);
phalcon_update_property_null(this_ptr, SL("_routePrefix") TSRMLS_CC);
PHALCON_INIT_NVAR(sufixed);
PHALCON_CONCAT_VV(sufixed, handler, controller_sufix);
PHALCON_INIT_NVAR(handler_annotations);
PHALCON_CALL_METHOD_PARAMS_1(handler_annotations, annotations_service, "get", sufixed);
/**
* Process class annotations
*/
PHALCON_INIT_NVAR(class_annotations);
PHALCON_CALL_METHOD(class_annotations, handler_annotations, "getclassannotations");
if (Z_TYPE_P(class_annotations) == IS_OBJECT) {
PHALCON_INIT_NVAR(annotations);
PHALCON_CALL_METHOD(annotations, class_annotations, "getannotations");
if (Z_TYPE_P(annotations) == IS_ARRAY) {
if (!phalcon_is_iterable(annotations, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(annotation);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "processcontrollerannotation", handler, annotation);
zend_hash_move_forward_ex(ah1, &hp1);
}
}
}
/**
* Process method annotations
*/
PHALCON_INIT_NVAR(method_annotations);
PHALCON_CALL_METHOD(method_annotations, handler_annotations, "getmethodsannotations");
if (Z_TYPE_P(method_annotations) == IS_ARRAY) {
PHALCON_INIT_NVAR(lowercased);
phalcon_fast_strtolower(lowercased, handler);
if (!phalcon_is_iterable(method_annotations, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(method, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(collection);
if (Z_TYPE_P(collection) == IS_OBJECT) {
PHALCON_INIT_NVAR(annotations);
PHALCON_CALL_METHOD(annotations, collection, "getannotations");
if (!phalcon_is_iterable(annotations, &ah3, &hp3, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(annotation);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "processactionannotation", lowercased, method, annotation);
zend_hash_move_forward_ex(ah3, &hp3);
}
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_bool(this_ptr, SL("_processed"), 1 TSRMLS_CC);
}
/**
* Call the parent handle method()
*/
PHALCON_CALL_PARENT_PARAMS_1_NORETURN(this_ptr, "Phalcon\\Mvc\\Router\\Annotations", "handle", real_uri);
PHALCON_MM_RESTORE();
}
/**
* Lists table references
*
*<code>
* print_r($connection->describeReferences('robots_parts'));
*</code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, describeReferences){
zval *table, *schema = NULL, *dialect, *fetch_num, *sql, *empty_arr;
zval *references, *describe, *reference = NULL, *constraint_name = NULL;
zval *referenced_schema = NULL, *referenced_table = NULL;
zval *reference_array = NULL, *column_name = NULL, *referenced_columns = NULL;
zval *reference_objects, *array_reference = NULL;
zval *name = NULL, *columns = NULL, *definition = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
RETURN_MM_NULL();
}
if (!schema) {
PHALCON_INIT_VAR(schema);
}
PHALCON_OBS_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, 3);
/**
* Get the SQL required to describe the references from the Dialect
*/
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema);
PHALCON_INIT_VAR(empty_arr);
array_init(empty_arr);
PHALCON_INIT_VAR(references);
array_init(references);
/**
* Execute the SQL returning the
*/
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_num);
if (!phalcon_is_iterable(describe, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(reference);
PHALCON_OBS_NVAR(constraint_name);
phalcon_array_fetch_long(&constraint_name, reference, 2, PH_NOISY_CC);
if (!phalcon_array_isset(references, constraint_name)) {
PHALCON_OBS_NVAR(referenced_schema);
phalcon_array_fetch_long(&referenced_schema, reference, 3, PH_NOISY_CC);
PHALCON_OBS_NVAR(referenced_table);
phalcon_array_fetch_long(&referenced_table, reference, 4, PH_NOISY_CC);
PHALCON_INIT_NVAR(reference_array);
array_init_size(reference_array, 4);
phalcon_array_update_string(&reference_array, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("columns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedColumns"), &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_zval(&references, constraint_name, &reference_array, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, reference, 1, PH_NOISY_CC);
phalcon_array_update_zval_string_append_multi_3(&references, constraint_name, SL("columns"), &column_name, 0 TSRMLS_CC);
PHALCON_OBS_NVAR(referenced_columns);
phalcon_array_fetch_long(&referenced_columns, reference, 5, PH_NOISY_CC);
phalcon_array_update_zval_string_append_multi_3(&references, constraint_name, SL("referencedColumns"), &referenced_columns, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(reference_objects);
array_init(reference_objects);
if (!phalcon_is_iterable(references, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(name, ah1, hp1);
PHALCON_GET_FOREACH_VALUE(array_reference);
PHALCON_OBS_NVAR(referenced_schema);
phalcon_array_fetch_string(&referenced_schema, array_reference, SL("referencedSchema"), PH_NOISY_CC);
PHALCON_OBS_NVAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, array_reference, SL("referencedTable"), PH_NOISY_CC);
PHALCON_OBS_NVAR(columns);
phalcon_array_fetch_string(&columns, array_reference, SL("columns"), PH_NOISY_CC);
PHALCON_OBS_NVAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, array_reference, SL("referencedColumns"), PH_NOISY_CC);
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 4);
phalcon_array_update_string(&definition, SL("referencedSchema"), &referenced_schema, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&definition, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(reference);
object_init_ex(reference, phalcon_db_reference_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", name, definition);
phalcon_array_update_zval(&reference_objects, name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
RETURN_CTOR(reference_objects);
}
/**
* Fires a event in the events manager causing that the acive listeners will be notified about it
*
* @param string $eventType
* @param object $source
* @param mixed $data
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire){
zval *event_type, *source, *data = NULL, *events, *exception_message;
zval *colon, *event_parts, *type, *event_name, *status = NULL;
zval *fire_events = NULL, *handler = NULL, *event = NULL, *arguments = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &event_type, &source, &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!data) {
PHALCON_INIT_NVAR(data);
}
if (Z_TYPE_P(event_type) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string");
return;
}
PHALCON_INIT_VAR(events);
phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC);
if (Z_TYPE_P(events) != IS_ARRAY) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!phalcon_memnstr_str(event_type, SL(":") TSRMLS_CC)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_events_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(colon);
ZVAL_STRING(colon, ":", 1);
PHALCON_INIT_VAR(event_parts);
phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC);
PHALCON_INIT_VAR(type);
phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(event_name);
phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(status);
eval_int = phalcon_array_isset(events, type);
if (eval_int) {
PHALCON_INIT_VAR(fire_events);
phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC);
if (Z_TYPE_P(fire_events) == IS_ARRAY) {
if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fire_events);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(handler);
if (Z_TYPE_P(handler) == IS_OBJECT) {
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
} else {
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
}
eval_int = phalcon_array_isset(events, event_type);
if (eval_int) {
PHALCON_INIT_NVAR(fire_events);
phalcon_array_fetch(&fire_events, events, event_type, PH_NOISY_CC);
if (Z_TYPE_P(fire_events) == IS_ARRAY) {
if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(fire_events);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) {
goto ph_cycle_end_1;
}
PHALCON_GET_FOREACH_VALUE(handler);
if (Z_TYPE_P(handler) == IS_OBJECT) {
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
} else {
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK);
}
}
}
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
if(0){}
}
}
RETURN_CCTOR(status);
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
* $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (phalcon_array_isset(data_types, wildcard)) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY_CC);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
PHALCON_CALL_FUNC_PARAMS_1(cast_value, "doubleval", value);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, cast_value);
} else {
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(statement, "bindparam", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_CALL_METHOD_NORETURN(statement, "execute");
RETURN_CCTOR(statement);
}
/**
* 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 = NULL, *fields = NULL, *values = NULL, *where_condition = NULL;
zval *data_types = NULL, *placeholders = NULL, *update_values = NULL;
zval *bind_data_types = NULL, *value = NULL, *position = NULL, *field = NULL;
zval *set_clause_part = NULL, *bind_type = NULL, *comma = NULL, *set_clause = NULL;
zval *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|zz", &table, &fields, &values, &where_condition, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!where_condition) {
PHALCON_ALLOC_ZVAL_MM(where_condition);
ZVAL_NULL(where_condition);
}
if (!data_types) {
PHALCON_ALLOC_ZVAL_MM(data_types);
ZVAL_NULL(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_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);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
PHALCON_INIT_VAR(set_clause_part);
PHALCON_CONCAT_VS(set_clause_part, field, " = null");
} else {
PHALCON_INIT_VAR(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_VAR(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(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_3(success, this_ptr, "execute", update_sql, update_values, bind_data_types, PH_NO_CHECK);
RETURN_CCTOR(success);
}
/**
* Manually bind params to a SQL statement. This method requires an active connection to a database system
*
*<code>
* $sql = $connection->bindParams('SELECT * FROM robots WHERE name = ?0', array('Bender'));
* echo $sql; // SELECT * FROM robots WHERE name = 'Bender'
*</code>
*
* @param string $sqlStatement
* @param array $params
* @return string
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, bindParams){
zval *sql_statement, *params, *sql = NULL, *pdo, *bind_value = NULL;
zval *index = NULL, *value = NULL, *place_key = NULL, *replaced_sql = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_statement, ¶ms) == FAILURE) {
RETURN_MM_NULL();
}
if (Z_TYPE_P(params) == IS_ARRAY) {
if (phalcon_fast_count_ev(params TSRMLS_CC)) {
PHALCON_CPY_WRT(sql, sql_statement);
PHALCON_OBS_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(index, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(bind_value);
if (phalcon_is_numeric(bind_value)) {
PHALCON_CPY_WRT(value, bind_value);
} else {
if (Z_TYPE_P(bind_value) == IS_OBJECT) {
PHALCON_INIT_NVAR(value);
PHALCON_CALL_FUNC_PARAMS_1(value, "strval", bind_value);
} else {
PHALCON_INIT_NVAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, pdo, "quote", bind_value);
}
}
/**
* Handle long parameters as numeric placeholders: ?0, ?1
*/
if (Z_TYPE_P(index) == IS_LONG) {
PHALCON_INIT_NVAR(place_key);
PHALCON_CONCAT_SV(place_key, "?", index);
PHALCON_INIT_NVAR(replaced_sql);
phalcon_fast_str_replace(replaced_sql, place_key, value, sql TSRMLS_CC);
PHALCON_CPY_WRT(sql, replaced_sql);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
/**
* Handle long parameters as string placeholders: :name:, :other:
*/
if (Z_TYPE_P(index) == IS_STRING) {
PHALCON_INIT_NVAR(place_key);
PHALCON_CONCAT_SVS(place_key, ":", index, ":");
PHALCON_INIT_NVAR(replaced_sql);
phalcon_fast_str_replace(replaced_sql, place_key, value, sql TSRMLS_CC);
PHALCON_CPY_WRT(sql, replaced_sql);
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
/**
* Unrecognized parameter type
*/
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CCTOR(sql);
}
}
RETURN_CCTOR(sql_statement);
}
/**
* Lists table references
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Reference[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeReferences){
zval *table, *schema = NULL, *dialect, *sql, *fetch_assoc;
zval *describe, *reference_objects, *reference_describe = NULL;
zval *number = NULL, *constraint_name = NULL, *referenced_table = NULL;
zval *from = NULL, *to = NULL, *columns = NULL, *referenced_columns = NULL;
zval *reference_array = NULL, *reference = 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|z", &table, &schema) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!schema) {
PHALCON_INIT_NVAR(schema);
}
PHALCON_INIT_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describereferences", table, schema, PH_NO_CHECK);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc, PH_NO_CHECK);
PHALCON_INIT_VAR(reference_objects);
array_init(reference_objects);
if (!phalcon_valid_foreach(describe TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(describe);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(number, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(reference_describe);
PHALCON_INIT_NVAR(constraint_name);
PHALCON_CONCAT_SV(constraint_name, "foreign_key_", number);
PHALCON_INIT_NVAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, reference_describe, SL("table"), PH_NOISY_CC);
PHALCON_INIT_NVAR(from);
phalcon_array_fetch_string(&from, reference_describe, SL("from"), PH_NOISY_CC);
PHALCON_INIT_NVAR(to);
phalcon_array_fetch_string(&to, reference_describe, SL("to"), PH_NOISY_CC);
PHALCON_INIT_NVAR(columns);
array_init(columns);
phalcon_array_append(&columns, from, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(referenced_columns);
array_init(referenced_columns);
phalcon_array_append(&referenced_columns, to, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(reference_array);
array_init(reference_array);
add_assoc_null_ex(reference_array, SS("referencedSchema"));
phalcon_array_update_string(&reference_array, SL("referencedTable"), &referenced_table, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("columns"), &columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&reference_array, SL("referencedColumns"), &referenced_columns, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(reference);
object_init_ex(reference, phalcon_db_reference_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", constraint_name, reference_array, PH_CHECK);
phalcon_array_update_zval(&reference_objects, constraint_name, &reference, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
RETURN_CTOR(reference_objects);
}
/**
* Converts bound parameters such as :name: or ?1 into PDO bind params ?
*
*<code>
* print_r($connection->convertBoundParams('SELECT * FROM robots WHERE name = :name:', array('Bender')));
*</code>
*
* @param string $sql
* @param array $params
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, convertBoundParams){
zval *sql, *params, *query_params = NULL, *placeholders;
zval *matches, *set_order, *bind_pattern, *status = NULL;
zval *place_match = NULL, *numeric_place = NULL, *value = NULL, *str_place = NULL;
zval *question, *bound_sql = NULL;
zval *r0 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL };
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql, ¶ms) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(query_params);
array_init(query_params);
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(set_order);
ZVAL_LONG(set_order, 2);
PHALCON_INIT_VAR(bind_pattern);
ZVAL_STRING(bind_pattern, "/\\?([0-9]+)|:([a-zA-Z0-9_]+):/", 1);
p0[0] = bind_pattern;
p0[1] = sql;
Z_SET_ISREF_P(matches);
p0[2] = matches;
p0[3] = set_order;
PHALCON_INIT_VAR(r0);
PHALCON_CALL_FUNC_PARAMS(r0, "preg_match_all", 4, p0);
Z_UNSET_ISREF_P(p0[2]);
PHALCON_CPY_WRT(status, r0);
if (zend_is_true(status)) {
if (!phalcon_is_iterable(matches, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(place_match);
PHALCON_OBS_NVAR(numeric_place);
phalcon_array_fetch_long(&numeric_place, place_match, 1, PH_NOISY_CC);
if (phalcon_array_isset(params, numeric_place)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, params, numeric_place, PH_NOISY_CC);
} else {
if (phalcon_array_isset_long(place_match, 2)) {
PHALCON_OBS_NVAR(str_place);
phalcon_array_fetch_long(&str_place, place_match, 2, PH_NOISY_CC);
if (phalcon_array_isset(params, str_place)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, params, str_place, PH_NOISY_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
}
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(question);
ZVAL_STRING(question, "?", 1);
PHALCON_INIT_VAR(bound_sql);
PHALCON_CALL_FUNC_PARAMS_3(bound_sql, "preg_replace", bind_pattern, question, sql);
} else {
PHALCON_CPY_WRT(bound_sql, sql);
}
/**
* Returns an array with the processed SQL and paramters
*/
PHALCON_INIT_NVAR(query_params);
array_init_size(query_params, 2);
phalcon_array_update_string(&query_params, SL("sql"), &bound_sql, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&query_params, SL("params"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC);
RETURN_CTOR(query_params);
}
/**
* Executes a prepared statement binding
*
* @param PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, _executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one = NULL, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = 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", &statement, &placeholders, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(placeholders);
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(wildcard);
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_VAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
eval_int = phalcon_array_isset(data_types, wildcard);
if (eval_int) {
PHALCON_INIT_VAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY_CC);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_VAR(cast_value);
PHALCON_CALL_FUNC_PARAMS_1(cast_value, "doubleval", value);
PHALCON_INIT_VAR(type);
ZVAL_LONG(type, 2);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
Z_SET_ISREF_P(cast_value);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(statement, "bindparam", parameter, cast_value, type, PH_NO_CHECK);
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, value, PH_NO_CHECK);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_CALL_METHOD_NORETURN(statement, "execute", PH_NO_CHECK);
RETURN_CCTOR(statement);}
/**
* Lists table indexes
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Index[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Sqlite, describeIndexes){
zval *table, *schema = NULL, *dialect, *fetch_assoc, *sql;
zval *describe, *indexes, *index = NULL, *key_name = NULL, *empty_arr = NULL;
zval *sql_index_describe = NULL, *describe_index = NULL;
zval *index_column = NULL, *column_name = NULL, *index_objects;
zval *index_columns = NULL, *name = NULL;
HashTable *ah0, *ah1, *ah2;
HashPosition hp0, hp1, hp2;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) {
RETURN_MM_NULL();
}
if (!schema) {
PHALCON_INIT_VAR(schema);
}
PHALCON_OBS_VAR(dialect);
phalcon_read_property(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(fetch_assoc);
phalcon_get_class_constant(fetch_assoc, phalcon_db_ce, SS("FETCH_ASSOC") TSRMLS_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_2(sql, dialect, "describeindexes", table, schema);
PHALCON_INIT_VAR(describe);
PHALCON_CALL_METHOD_PARAMS_2(describe, this_ptr, "fetchall", sql, fetch_assoc);
PHALCON_INIT_VAR(indexes);
array_init(indexes);
if (!phalcon_is_iterable(describe, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(index);
PHALCON_OBS_NVAR(key_name);
phalcon_array_fetch_string(&key_name, index, SL("name"), PH_NOISY_CC);
if (!phalcon_array_isset(indexes, key_name)) {
PHALCON_INIT_NVAR(empty_arr);
array_init(empty_arr);
phalcon_array_update_zval(&indexes, key_name, &empty_arr, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_INIT_NVAR(sql_index_describe);
PHALCON_CALL_METHOD_PARAMS_1(sql_index_describe, dialect, "describeindex", key_name);
PHALCON_INIT_NVAR(describe_index);
PHALCON_CALL_METHOD_PARAMS_2(describe_index, this_ptr, "fetchall", sql_index_describe, fetch_assoc);
if (!phalcon_is_iterable(describe_index, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(index_column);
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_string(&column_name, index_column, SL("name"), PH_NOISY_CC);
phalcon_array_update_append_multi_2(&indexes, key_name, column_name, 0 TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(index_objects);
array_init(index_objects);
if (!phalcon_is_iterable(indexes, &ah2, &hp2, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(name, ah2, hp2);
PHALCON_GET_FOREACH_VALUE(index_columns);
PHALCON_INIT_NVAR(index);
object_init_ex(index, phalcon_db_index_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(index, "__construct", name, index_columns);
phalcon_array_update_zval(&index_objects, name, &index, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
}
RETURN_CTOR(index_objects);
}
/**
* Converts bound params like :name: or ?1 into ? bind params
*
* @param string $sql
* @param array $params
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, convertBoundParams){
zval *sql = NULL, *params = NULL, *query_params = NULL, *placeholders = NULL;
zval *matches = NULL, *set_order = NULL, *bind_pattern = NULL, *status = NULL;
zval *place_match = NULL, *numeric_place = NULL, *value = NULL, *str_place = NULL;
zval *question = NULL, *bound_sql = NULL;
zval *r0 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL };
HashTable *ah0;
HashPosition hp0;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql, ¶ms) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(query_params);
array_init(query_params);
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_INIT_VAR(matches);
ZVAL_NULL(matches);
PHALCON_INIT_VAR(set_order);
ZVAL_LONG(set_order, 2);
PHALCON_INIT_VAR(bind_pattern);
ZVAL_STRING(bind_pattern, "/\\?([0-9]+)|:([a-zA-Z0-9_]+):/", 1);
p0[0] = bind_pattern;
p0[1] = sql;
Z_SET_ISREF_P(matches);
p0[2] = matches;
p0[3] = set_order;
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_FUNC_PARAMS(r0, "preg_match_all", 4, p0);
Z_UNSET_ISREF_P(p0[2]);
PHALCON_CPY_WRT(status, r0);
if (zend_is_true(status)) {
if (!phalcon_valid_foreach(matches TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(matches);
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(place_match);
PHALCON_INIT_VAR(numeric_place);
phalcon_array_fetch_long(&numeric_place, place_match, 1, PH_NOISY_CC);
eval_int = phalcon_array_isset(params, numeric_place);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch(&value, params, numeric_place, PH_NOISY_CC);
} else {
eval_int = phalcon_array_isset_long(place_match, 2);
if (eval_int) {
PHALCON_INIT_VAR(str_place);
phalcon_array_fetch_long(&str_place, place_match, 2, PH_NOISY_CC);
eval_int = phalcon_array_isset(params, str_place);
if (eval_int) {
PHALCON_INIT_VAR(value);
phalcon_array_fetch(&value, params, str_place, PH_NOISY_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
}
phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(question);
ZVAL_STRING(question, "?", 1);
PHALCON_INIT_VAR(bound_sql);
PHALCON_CALL_FUNC_PARAMS_3(bound_sql, "preg_replace", bind_pattern, question, sql);
} else {
PHALCON_CPY_WRT(bound_sql, sql);
}
PHALCON_INIT_VAR(query_params);
array_init(query_params);
phalcon_array_update_string(&query_params, SL("sql"), &bound_sql, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&query_params, SL("params"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC);
RETURN_CTOR(query_params);
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){
zval *type = NULL, *result, *row = NULL, *rows, *underscore, *empty_str;
zval *active_row, *columns_types, *column = NULL, *alias = NULL;
zval *source = NULL, *instance = NULL, *attributes = NULL, *column_map = NULL;
zval *row_model = NULL, *attribute = NULL, *column_alias = NULL, *value = NULL;
zval *model_attribute = NULL, *sql_alias = NULL, *n_alias = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
PHALCON_INIT_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_INIT_VAR(row);
PHALCON_CALL_METHOD_PARAMS_1(row, result, "fetch", result, PH_NO_CHECK);
} else {
PHALCON_INIT_NVAR(row);
ZVAL_BOOL(row, 0);
}
} else {
PHALCON_INIT_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
Z_SET_ISREF_P(rows);
PHALCON_INIT_NVAR(row);
PHALCON_CALL_FUNC_PARAMS_1(row, "current", rows);
Z_UNSET_ISREF_P(rows);
if (zend_is_true(row)) {
Z_SET_ISREF_P(rows);
PHALCON_CALL_FUNC_PARAMS_1_NORETURN("next", rows);
Z_UNSET_ISREF_P(rows);
}
}
if (PHALCON_IS_NOT_FALSE(row)) {
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
PHALCON_INIT_VAR(active_row);
object_init_ex(active_row, phalcon_mvc_model_row_ce);
PHALCON_INIT_VAR(columns_types);
phalcon_read_property(&columns_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC);
if (!phalcon_valid_foreach(columns_types TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(columns_types);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(alias, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(column);
PHALCON_INIT_NVAR(type);
phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY_CC);
if (PHALCON_COMPARE_STRING(type, "object")) {
/**
* Object columns are assigned column by column
*/
PHALCON_INIT_NVAR(source);
phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY_CC);
PHALCON_INIT_NVAR(instance);
phalcon_array_fetch_string(&instance, column, SL("instance"), PH_NOISY_CC);
PHALCON_INIT_NVAR(attributes);
phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY_CC);
PHALCON_INIT_NVAR(column_map);
phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY_CC);
/**
* Assign the values from the _source_attribute notation to its real column name
*/
PHALCON_INIT_NVAR(row_model);
array_init(row_model);
if (!phalcon_valid_foreach(attributes TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(attributes);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) {
goto ph_cycle_end_1;
}
PHALCON_GET_FOREACH_VALUE(attribute);
PHALCON_INIT_NVAR(column_alias);
PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute);
PHALCON_INIT_NVAR(value);
phalcon_array_fetch(&value, row, column_alias, PH_NOISY_CC);
phalcon_array_update_zval(&row_model, attribute, &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
/**
* Assign the values to the attributes using a column map
*/
PHALCON_INIT_NVAR(model_attribute);
PHALCON_CALL_STATIC_PARAMS_3(model_attribute, "phalcon\\mvc\\model", "dumpresultmap", instance, row_model, column_map);
/**
* The complete object is assigned to an attribute with the name of the alias or
* the model name
*/
PHALCON_INIT_NVAR(attribute);
phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY_CC);
phalcon_update_property_zval_zval(active_row, attribute, model_attribute TSRMLS_CC);
} else {
/**
* Scalar columns are simply assigned to the result object
*/
eval_int = phalcon_array_isset_string(column, SS("sqlAlias"));
if (eval_int) {
PHALCON_INIT_NVAR(sql_alias);
phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY_CC);
PHALCON_INIT_NVAR(value);
phalcon_array_fetch(&value, row, sql_alias, PH_NOISY_CC);
} else {
PHALCON_INIT_NVAR(value);
phalcon_array_fetch(&value, row, alias, PH_NOISY_CC);
}
/**
* If a 'balias' is defined is not an unnamed scalar
*/
eval_int = phalcon_array_isset_string(column, SS("balias"));
if (eval_int) {
phalcon_update_property_zval_zval(active_row, alias, value TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(n_alias);
phalcon_fast_str_replace(n_alias, underscore, empty_str, alias TSRMLS_CC);
phalcon_update_property_zval_zval(active_row, n_alias, value TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
phalcon_update_property_zval(this_ptr, SL("_activeRow"), active_row TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
} else {
phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC);
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect){
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsn_parts = NULL;
zval *value = NULL, *key = NULL, *dsn_attribute = NULL, *dot_comma = NULL, *dsn_attributes = NULL;
zval *pdo_type = NULL, *dsn = NULL, *options = NULL, *persistent = NULL, *pdo = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!descriptor) {
PHALCON_ALLOC_ZVAL_MM(descriptor);
ZVAL_NULL(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (Z_TYPE_P(descriptor) == IS_NULL) {
PHALCON_INIT_VAR(descriptor);
phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY_CC);
}
eval_int = phalcon_array_isset_string(descriptor, SS("username"));
if (eval_int) {
PHALCON_INIT_VAR(username);
phalcon_array_fetch_string(&username, descriptor, SL("username"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(descriptor);
phalcon_array_unset_string(descriptor, SS("username"));
} else {
PHALCON_INIT_VAR(username);
ZVAL_NULL(username);
}
eval_int = phalcon_array_isset_string(descriptor, SS("password"));
if (eval_int) {
PHALCON_INIT_VAR(password);
phalcon_array_fetch_string(&password, descriptor, SL("password"), PH_NOISY_CC);
PHALCON_SEPARATE_PARAM(descriptor);
phalcon_array_unset_string(descriptor, SS("password"));
} else {
PHALCON_INIT_VAR(password);
ZVAL_NULL(password);
}
eval_int = phalcon_array_isset_string(descriptor, SS("dsn"));
if (!eval_int) {
PHALCON_INIT_VAR(dsn_parts);
array_init(dsn_parts);
if (!phalcon_valid_foreach(descriptor TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(descriptor);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_INIT_VAR(key);
PHALCON_GET_FOREACH_KEY(key, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
PHALCON_INIT_VAR(dsn_attribute);
PHALCON_CONCAT_VSV(dsn_attribute, key, "=", value);
phalcon_array_append(&dsn_parts, dsn_attribute, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(dot_comma);
ZVAL_STRING(dot_comma, ";", 1);
PHALCON_INIT_VAR(dsn_attributes);
phalcon_fast_join(dsn_attributes, dot_comma, dsn_parts TSRMLS_CC);
} else {
PHALCON_INIT_VAR(dsn_attributes);
phalcon_array_fetch_string(&dsn_attributes, descriptor, SL("dsn"), PH_NOISY_CC);
}
PHALCON_INIT_VAR(pdo_type);
phalcon_read_property(&pdo_type, this_ptr, SL("_type"), PH_NOISY_CC);
PHALCON_INIT_VAR(dsn);
PHALCON_CONCAT_VSV(dsn, pdo_type, ":", dsn_attributes);
PHALCON_INIT_VAR(options);
array_init(options);
add_index_long(options, PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION);
add_index_long(options, PDO_ATTR_CASE, PDO_CASE_LOWER);
add_index_long(options, PDO_ATTR_CURSOR, PDO_CURSOR_SCROLL);
eval_int = phalcon_array_isset_string(descriptor, SS("persistent"));
if (eval_int) {
PHALCON_INIT_VAR(persistent);
phalcon_array_fetch_string(&persistent, descriptor, SL("persistent"), PH_NOISY_CC);
if (zend_is_true(persistent)) {
phalcon_array_update_long_bool(&options, PDO_ATTR_PERSISTENT, 1, PH_SEPARATE TSRMLS_CC);
}
}
ce0 = zend_fetch_class(SL("PDO"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(pdo);
object_init_ex(pdo, ce0);
PHALCON_CALL_METHOD_PARAMS_4_NORETURN(pdo, "__construct", dsn, username, password, options, PH_CHECK);
phalcon_update_property_zval(this_ptr, SL("_pdo"), pdo TSRMLS_CC);
PHALCON_MM_RESTORE();}
/**
* Checks whether view exists on registered extensions and render it
*
* @param array $engines
* @param string $viewPath
* @param boolean $silence
* @param boolean $mustClean
* @param Phalcon\Cache\BackendInterface $cache
*/
PHP_METHOD(Phalcon_Mvc_View, _engineRender){
zval *engines, *view_path, *silence, *must_clean;
zval *cache, *not_exists = NULL, *view_params, *views_dir;
zval *base_path, *views_dir_path, *events_manager;
zval *render_level, *cache_level, *enter_cache;
zval *is_started, *key = NULL, *lifetime = NULL, *view_options;
zval *cache_options, *cached_view, *is_fresh;
zval *engine = NULL, *extension = NULL, *view_engine_path = NULL;
zval *event_name = NULL, *status = NULL, *exception_message;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 5, 0, &engines, &view_path, &silence, &must_clean, &cache);
PHALCON_INIT_VAR(not_exists);
ZVAL_BOOL(not_exists, 1);
PHALCON_OBS_VAR(view_params);
phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC);
PHALCON_OBS_VAR(views_dir);
phalcon_read_property_this(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC);
PHALCON_OBS_VAR(base_path);
phalcon_read_property_this(&base_path, this_ptr, SL("_basePath"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir_path);
PHALCON_CONCAT_VVV(views_dir_path, base_path, views_dir, view_path);
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_OBS_VAR(render_level);
phalcon_read_property_this(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
PHALCON_OBS_VAR(cache_level);
phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
/**
* Evaluate if we need to enter in 'cache' mode
*/
PHALCON_INIT_VAR(enter_cache);
is_smaller_or_equal_function(enter_cache, cache_level, render_level TSRMLS_CC);
if (zend_is_true(enter_cache)) {
/**
* Check if the cache is started, the first time a cache is started we start the
* cache
*/
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted");
if (PHALCON_IS_FALSE(is_started)) {
PHALCON_INIT_VAR(key);
PHALCON_INIT_VAR(lifetime);
PHALCON_OBS_VAR(view_options);
phalcon_read_property_this(&view_options, this_ptr, SL("_options"), PH_NOISY_CC);
/**
* Check if the user has defined a different options to the default
*/
if (Z_TYPE_P(view_options) == IS_ARRAY) {
if (phalcon_array_isset_string(view_options, SS("cache"))) {
PHALCON_OBS_VAR(cache_options);
phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC);
if (Z_TYPE_P(cache_options) == IS_ARRAY) {
if (phalcon_array_isset_string(cache_options, SS("key"))) {
PHALCON_OBS_NVAR(key);
phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY_CC);
}
if (phalcon_array_isset_string(cache_options, SS("lifetime"))) {
PHALCON_OBS_NVAR(lifetime);
phalcon_array_fetch_string(&lifetime, cache_options, SL("lifetime"), PH_NOISY_CC);
}
}
}
}
/**
* If a cache key is not set we create one using a md5
*/
if (Z_TYPE_P(key) == IS_NULL) {
PHALCON_INIT_NVAR(key);
PHALCON_CALL_FUNC_PARAMS_1(key, "md5", view_path);
}
/**
* We start the cache using the key set
*/
PHALCON_INIT_VAR(cached_view);
PHALCON_CALL_METHOD_PARAMS_2(cached_view, cache, "start", key, lifetime);
if (Z_TYPE_P(cached_view) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_content"), cached_view TSRMLS_CC);
RETURN_MM_NULL();
}
}
/**
* This method only returns true if the cache has not expired
*/
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh");
if (!zend_is_true(is_fresh)) {
RETURN_MM_NULL();
}
}
}
/**
* Views are rendered in each engine
*/
if (!phalcon_is_iterable(engines, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(extension, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(engine);
PHALCON_INIT_NVAR(view_engine_path);
PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension);
if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) {
/**
* Call beforeRenderView if there is a events manager available
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:beforeRenderView", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, view_engine_path);
if (PHALCON_IS_FALSE(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(engine, "render", view_engine_path, view_params, must_clean);
/**
* Call afterRenderView if there is a events manager available
*/
PHALCON_INIT_NVAR(not_exists);
ZVAL_BOOL(not_exists, 0);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRenderView", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
break;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
if (PHALCON_IS_TRUE(not_exists)) {
/**
* Notify about not found views
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:notFoundView", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
if (!zend_is_true(silence)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
}
PHALCON_MM_RESTORE();
}
