/** * 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(); }