/** * Handles routing information received from command-line arguments * * @param array $arguments */ PHP_METHOD(Phalcon_CLI_Router, handle){ zval *arguments = NULL, *namespace_name, *module_name = NULL, *task_name = NULL, *action_name = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &arguments); if (!arguments) { PHALCON_INIT_VAR(arguments); array_init(arguments); } else { PHALCON_SEPARATE_PARAM(arguments); } if (Z_TYPE_P(arguments) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_cli_router_exception_ce, "Arguments must be an Array"); return; } PHALCON_INIT_VAR(module_name); PHALCON_INIT_VAR(namespace_name); PHALCON_INIT_VAR(task_name); PHALCON_INIT_VAR(action_name); /** * Check for a module */ if (phalcon_array_isset_string(arguments, SS("module"))) { PHALCON_OBS_NVAR(module_name); phalcon_array_fetch_string(&module_name, arguments, SL("module"), PH_NOISY); phalcon_array_unset_string(&arguments, SS("module"), PH_COPY); } /** * Check for a namespace */ if (phalcon_array_isset_string(arguments, SS("namespace"))) { PHALCON_OBS_NVAR(namespace_name); phalcon_array_fetch_string(&namespace_name, arguments, SL("namespace"), PH_NOISY); phalcon_array_unset_string(&arguments, SS("namespace"), PH_COPY); } /** * Check for a task */ if (phalcon_array_isset_string(arguments, SS("task"))) { PHALCON_OBS_NVAR(task_name); phalcon_array_fetch_string(&task_name, arguments, SL("task"), PH_NOISY); phalcon_array_unset_string(&arguments, SS("task"), PH_COPY); } /** * Check for an action */ if (phalcon_array_isset_string(arguments, SS("action"))) { PHALCON_OBS_NVAR(action_name); phalcon_array_fetch_string(&action_name, arguments, SL("action"), PH_NOISY); phalcon_array_unset_string(&arguments, SS("action"), PH_COPY); } phalcon_update_property_this(this_ptr, SL("_module"), module_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_namespace"), namespace_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_task"), task_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_action"), action_name TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_params"), arguments TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Builds a HTML FORM tag * * <code> * echo Phalcon\Tag::form("posts/save"); * echo Phalcon\Tag::form(array("posts/save", "method" => "post")); * </code> * * Volt syntax: * <code> * {{ form("posts/save") }} * {{ form("posts/save", "method": "post") }} * </code> * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, form){ zval *parameters = NULL, *params = NULL, *params_action = NULL, *action = NULL; zval *url, *code, *avalue = NULL, *key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, ¶meters); if (!parameters) { PHALCON_INIT_VAR(parameters); } else { PHALCON_SEPARATE_PARAM(parameters); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 1); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } if (phalcon_array_isset_long(params, 0)) { PHALCON_OBS_VAR(params_action); phalcon_array_fetch_long(¶ms_action, params, 0, PH_NOISY_CC); } else { if (phalcon_array_isset_string(params, SS("action"))) { PHALCON_OBS_NVAR(params_action); phalcon_array_fetch_string(¶ms_action, params, SL("action"), PH_NOISY_CC); } else { PHALCON_INIT_NVAR(params_action); } } /** * By default the method is POST */ if (!phalcon_array_isset_string(params, SS("method"))) { phalcon_array_update_string_string(¶ms, SL("method"), SL("post"), PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(action); if (Z_TYPE_P(params_action) != IS_NULL) { PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); PHALCON_CALL_METHOD_PARAMS_1(action, url, "get", params_action); } /** * Check for extra parameters */ if (phalcon_array_isset_string(params, SS("parameters"))) { PHALCON_OBS_NVAR(parameters); phalcon_array_fetch_string(¶meters, params, SL("parameters"), PH_NOISY_CC); PHALCON_SCONCAT_SV(action, "?", parameters); } if (Z_TYPE_P(action) != IS_NULL) { phalcon_array_update_string(¶ms, SL("action"), &action, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<form", 1); 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(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(avalue); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\""); } zend_hash_move_forward_ex(ah0, &hp0); } phalcon_concat_self_str(&code, SL(">") TSRMLS_CC); RETURN_CTOR(code); }
/** * Builds a SCRIPT[type="javascript"] tag * * <code> * echo Phalcon\Tag::javascriptInclude("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false); * echo Phalcon\Tag::javascriptInclude("javascript/jquery.js"); * </code> * * Volt syntax: * <code> * {{ javascript_include("http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js", false) }} * {{ javascript_include("javascript/jquery.js") }} * </code> * * @param array $parameters * @param boolean $local * @return string */ PHP_METHOD(Phalcon_Tag, javascriptInclude){ zval *parameters = NULL, *local = NULL, *params = NULL, *first_param; zval *url, *params_src, *src, *eol, *code, *value = NULL, *key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, ¶meters, &local); if (!parameters) { PHALCON_INIT_VAR(parameters); } if (!local) { PHALCON_INIT_VAR(local); ZVAL_BOOL(local, 1); } else { PHALCON_SEPARATE_PARAM(local); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 2); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); phalcon_array_append(¶ms, local, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } if (!phalcon_array_isset_string(params, SS("src"))) { if (phalcon_array_isset_long(params, 0)) { PHALCON_OBS_VAR(first_param); phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC); phalcon_array_update_string(¶ms, SL("src"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_string(¶ms, SL("src"), SL(""), PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_NVAR(local); ZVAL_STRING(local, "", 1); if (phalcon_array_isset_long(params, 1)) { PHALCON_OBS_NVAR(local); phalcon_array_fetch_long(&local, params, 1, PH_NOISY_CC); } else { if (phalcon_array_isset_string(params, SS("local"))) { PHALCON_OBS_NVAR(local); phalcon_array_fetch_string(&local, params, SL("local"), PH_NOISY_CC); phalcon_array_unset_string(¶ms, SS("local"), PH_SEPARATE); } } if (!phalcon_array_isset_string(params, SS("type"))) { phalcon_array_update_string_string(¶ms, SL("type"), SL("text/javascript"), PH_SEPARATE TSRMLS_CC); } if (zend_is_true(local)) { /** * URLs are generated through the 'url' service */ PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); PHALCON_OBS_VAR(params_src); phalcon_array_fetch_string(¶ms_src, params, SL("src"), PH_NOISY_CC); PHALCON_INIT_VAR(src); PHALCON_CALL_METHOD_PARAMS_1(src, url, "get", params_src); phalcon_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<script", 1); 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(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\""); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_SCONCAT_SV(code, "></script>", eol); RETURN_CTOR(code); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_File, get){ zval *key_name, *lifetime = NULL, *options, *prefix, *filtered; zval *prefixed_key, *cache_dir, *cache_file; zval *frontend, *time, *ttl = NULL, *modified_time, *difference; zval *not_expired, *cached_content, *processed; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, filtered); phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key); if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); /** * Check if the file has expired */ PHALCON_INIT_VAR(time); PHALCON_CALL_FUNC(time, "time"); if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_INIT_VAR(ttl); PHALCON_CALL_METHOD(ttl, frontend, "getlifetime", PH_NO_CHECK); } else { PHALCON_CPY_WRT(ttl, lifetime); } PHALCON_INIT_VAR(modified_time); PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file); PHALCON_INIT_VAR(difference); sub_function(difference, time, ttl TSRMLS_CC); PHALCON_INIT_VAR(not_expired); is_smaller_function(not_expired, difference, modified_time TSRMLS_CC); /** * The content is only retrieved if the content has not expired */ if (PHALCON_IS_TRUE(not_expired)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file); PHALCON_INIT_VAR(processed); PHALCON_CALL_METHOD_PARAMS_1(processed, frontend, "afterretrieve", cached_content, PH_NO_CHECK); RETURN_CCTOR(processed); } } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Routes to a controller/action using a string or array uri * * @param string $uri */ PHP_METHOD(Phalcon_Dispatcher, forward){ zval *uri = NULL, *parts = NULL, *params = NULL, *value = NULL, *key = NULL; zval *c0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL; zval *a0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(uri) == IS_ARRAY) { PHALCON_CPY_WRT(parts, uri); } else { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_explode(r0, c0, uri TSRMLS_CC); PHALCON_CPY_WRT(parts, r0); } eval_int = phalcon_array_isset_long(parts, 0); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_long(&r1, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_filter_alphanum(r2, r1); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r2 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 0); } else { eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, parts, SL("controller"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r4); phalcon_filter_alphanum(r4, r3); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r4 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, this_ptr, "getcontrollername", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r5 TSRMLS_CC); } } eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_long(&r6, parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r7); phalcon_filter_alphanum(r7, r6); phalcon_update_property_zval(this_ptr, SL("_actionName"), r7 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_long(&r8, parts, 1, PHALCON_NOISY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_actionName"), r8 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 1); } else { eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r9); phalcon_array_fetch_string(&r9, parts, SL("action"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r10); phalcon_filter_alphanum(r10, r9); phalcon_update_property_zval(this_ptr, SL("_actionName"), r10 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r11); PHALCON_CALL_METHOD(r11, this_ptr, "getactionname", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_actionName"), r11 TSRMLS_CC); } } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(params, a0); if (phalcon_valid_foreach(parts TSRMLS_CC)) { ah0 = Z_ARRVAL_P(parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_e10f_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e10f_1; } else { PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); if (Z_TYPE_P(key) == IS_LONG) { PHALCON_INIT_VAR(r12); phalcon_array_fetch(&r12, parts, key, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(¶ms, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_e10f_1; fee_e10f_1: if(0){} } else { return; } phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Restores the internal state of a Phalcon\Db\Column object * * @param array $data * @return \Phalcon\Db\Column */ PHP_METHOD(Phalcon_Db_Column, __set_state){ zval *data, *definition, *column_name, *column_type; zval *not_null, *primary, *size, *dunsigned, *after; zval *is_numeric, *first, *bind_type, *column; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &data); if (Z_TYPE_P(data) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column state must be an array"); return; } PHALCON_INIT_VAR(definition); array_init(definition); if (!phalcon_array_isset_string(data, SS("_columnName"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column name is required"); return; } PHALCON_OBS_VAR(column_name); phalcon_array_fetch_string(&column_name, data, SL("_columnName"), PH_NOISY_CC); if (phalcon_array_isset_string(data, SS("_type"))) { PHALCON_OBS_VAR(column_type); phalcon_array_fetch_string(&column_type, data, SL("_type"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("type"), &column_type, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_notNull"))) { PHALCON_OBS_VAR(not_null); phalcon_array_fetch_string(¬_null, data, SL("_notNull"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("notNull"), ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_primary"))) { PHALCON_OBS_VAR(primary); phalcon_array_fetch_string(&primary, data, SL("_primary"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("primary"), &primary, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_size"))) { PHALCON_OBS_VAR(size); phalcon_array_fetch_string(&size, data, SL("_size"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("size"), &size, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_unsigned"))) { PHALCON_OBS_VAR(dunsigned); phalcon_array_fetch_string(&dunsigned, data, SL("_unsigned"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("unsigned"), &dunsigned, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_after"))) { PHALCON_OBS_VAR(after); phalcon_array_fetch_string(&after, data, SL("_after"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("after"), &after, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_isNumeric"))) { PHALCON_OBS_VAR(is_numeric); phalcon_array_fetch_string(&is_numeric, data, SL("_isNumeric"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("isNumeric"), &is_numeric, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_first"))) { PHALCON_OBS_VAR(first); phalcon_array_fetch_string(&first, data, SL("_first"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("first"), &first, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(data, SS("_bindType"))) { PHALCON_OBS_VAR(bind_type); phalcon_array_fetch_string(&bind_type, data, SL("_bindType"), PH_NOISY_CC); phalcon_array_update_string(&definition, SL("bindType"), &bind_type, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(column); object_init_ex(column, phalcon_db_column_ce); phalcon_call_method_p2_noret(column, "__construct", column_name, definition); RETURN_CTOR(column); }
/** * Builds a SELECT statement * * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect, select){ zval *definition, *escape_char = NULL, *columns, *selected_columns; zval *column = NULL, *column_item = NULL, *column_sql = NULL, *columns_sql = NULL; zval *column_domain = NULL, *column_domain_sql = NULL, *column_alias = NULL; zval *column_alias_sql = NULL, *tables, *selected_tables; zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins; zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL; zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL; zval *join_conditions = NULL, *where_conditions; zval *where_expression, *group_items, *group_fields; zval *group_field = NULL, *group_expression = NULL, *group_sql; zval *group_clause, *having_conditions, *having_expression; zval *order_fields, *order_items, *order_item = NULL; zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL; zval *order_sql_item_type = NULL, *order_sql, *limit_value; zval *number, *offset; 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", &definition) == FAILURE) { RETURN_MM_NULL(); } if (Z_TYPE_P(definition) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SELECT definition"); return; } if (!phalcon_array_isset_string(definition, SS("tables"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'tables' is required in the definition array"); return; } if (!phalcon_array_isset_string(definition, SS("columns"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_OBS_VAR(escape_char); phalcon_read_property(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC); } else { PHALCON_INIT_NVAR(escape_char); } PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC); if (Z_TYPE_P(columns) == IS_ARRAY) { PHALCON_INIT_VAR(selected_columns); array_init(selected_columns); if (!phalcon_is_iterable(columns, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(column); /** * Escape column name */ PHALCON_OBS_NVAR(column_item); phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY_CC); if (Z_TYPE_P(column_item) == IS_ARRAY) { PHALCON_INIT_NVAR(column_sql); PHALCON_CALL_METHOD_PARAMS_2(column_sql, this_ptr, "getsqlexpression", column_item, escape_char); } else { if (PHALCON_IS_STRING(column_item, "*")) { PHALCON_CPY_WRT(column_sql, column_item); } else { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char); } else { PHALCON_CPY_WRT(columns_sql, column_item); } } } /** * Escape column domain */ PHALCON_OBS_NVAR(column_domain); phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY_CC); if (zend_is_true(column_domain)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql); } else { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } /** * Escape column alias */ if (phalcon_array_isset_long(column, 2)) { PHALCON_OBS_NVAR(column_alias); phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY_CC); if (zend_is_true(column_alias)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " AS ", escape_char, column_alias, escape_char); } else { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " AS ", column_alias); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(columns_sql); phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC); } else { PHALCON_CPY_WRT(columns_sql, columns); } /** * Check and escape tables */ PHALCON_OBS_VAR(tables); phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY_CC); if (Z_TYPE_P(tables) == IS_ARRAY) { PHALCON_INIT_VAR(selected_tables); array_init(selected_tables); if (!phalcon_is_iterable(tables, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(table); PHALCON_INIT_NVAR(sql_table); PHALCON_CALL_METHOD_PARAMS_2(sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(tables_sql); phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC); } else { PHALCON_CPY_WRT(tables_sql, tables); } PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSV(sql, "SELECT ", columns_sql, " FROM ", tables_sql); /** * Check for joins */ if (phalcon_array_isset_string(definition, SS("joins"))) { PHALCON_OBS_VAR(joins); phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY_CC); if (!phalcon_is_iterable(joins, &ah2, &hp2, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(join); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY_CC); PHALCON_OBS_NVAR(table); phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY_CC); PHALCON_INIT_NVAR(sql_table); PHALCON_CALL_METHOD_PARAMS_2(sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(sql_join); PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table); /** * Check if the join has conditions */ if (phalcon_array_isset_string(join, SS("conditions"))) { PHALCON_OBS_NVAR(join_conditions_array); phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY_CC); if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) { PHALCON_INIT_NVAR(join_expressions); array_init(join_expressions); if (!phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(join_condition); PHALCON_INIT_NVAR(join_expression); PHALCON_CALL_METHOD_PARAMS_2(join_expression, this_ptr, "getsqlexpression", join_condition, escape_char); phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah3, &hp3); } PHALCON_INIT_NVAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC); PHALCON_SCONCAT_SV(sql_join, " ON ", join_conditions); } } phalcon_concat_self(&sql, sql_join TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } } /** * Check for a WHERE clause */ if (phalcon_array_isset_string(definition, SS("where"))) { PHALCON_OBS_VAR(where_conditions); phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY_CC); PHALCON_INIT_VAR(where_expression); PHALCON_CALL_METHOD_PARAMS_2(where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression); } /** * Check for a GROUP clause */ if (phalcon_array_isset_string(definition, SS("group"))) { PHALCON_INIT_VAR(group_items); array_init(group_items); PHALCON_OBS_VAR(group_fields); phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY_CC); if (!phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(group_field); PHALCON_INIT_NVAR(group_expression); PHALCON_CALL_METHOD_PARAMS_2(group_expression, this_ptr, "getsqlexpression", group_field, escape_char); phalcon_array_append(&group_items, group_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah4, &hp4); } PHALCON_INIT_VAR(group_sql); phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC); PHALCON_INIT_VAR(group_clause); PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql); phalcon_concat_self(&sql, group_clause TSRMLS_CC); /** * Check for a HAVING clause */ if (phalcon_array_isset_string(definition, SS("having"))) { PHALCON_OBS_VAR(having_conditions); phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY_CC); PHALCON_INIT_VAR(having_expression); PHALCON_CALL_METHOD_PARAMS_2(having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression); } } /** * Check for a ORDER clause */ if (phalcon_array_isset_string(definition, SS("order"))) { PHALCON_OBS_VAR(order_fields); phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY_CC); PHALCON_INIT_VAR(order_items); array_init(order_items); if (!phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(order_item); PHALCON_OBS_NVAR(order_expression); phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY_CC); PHALCON_INIT_NVAR(order_sql_item); PHALCON_CALL_METHOD_PARAMS_2(order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char); /** * In the numeric 1 position could be a ASC/DESC clause */ if (phalcon_array_isset_long(order_item, 1)) { PHALCON_OBS_NVAR(sql_order_type); phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY_CC); PHALCON_INIT_NVAR(order_sql_item_type); PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type); } else { PHALCON_CPY_WRT(order_sql_item_type, order_sql_item); } phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah5, &hp5); } PHALCON_INIT_VAR(order_sql); phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC); PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql); } /** * Check for a LIMIT condition */ if (phalcon_array_isset_string(definition, SS("limit"))) { PHALCON_OBS_VAR(limit_value); phalcon_array_fetch_string(&limit_value, definition, SL("limit"), PH_NOISY_CC); if (Z_TYPE_P(limit_value) == IS_ARRAY) { PHALCON_OBS_VAR(number); phalcon_array_fetch_string(&number, limit_value, SL("number"), PH_NOISY_CC); /** * Check for a OFFSET condition */ if (phalcon_array_isset_string(limit_value, SS("offset"))) { PHALCON_OBS_VAR(offset); phalcon_array_fetch_string(&offset, limit_value, SL("offset"), PH_NOISY_CC); PHALCON_SCONCAT_SVSV(sql, " LIMIT ", number, " OFFSET ", offset); } else { PHALCON_SCONCAT_SV(sql, " LIMIT ", number); } } else { PHALCON_SCONCAT_SV(sql, " LIMIT ", limit_value); } } RETURN_CTOR(sql); }
/** * Phalcon\Db\Reference constructor * * @param string $referenceName * @param array $definition */ PHP_METHOD(Phalcon_Db_Reference, __construct){ zval *reference_name = NULL, *definition = NULL, *referenced_table = NULL; zval *columns = NULL, *referenced_columns = NULL, *schema = NULL; zval *referenced_schema = NULL, *number_columns = NULL; zval *number_referenced_columns = NULL; zval *r0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &reference_name, &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } phalcon_update_property_zval(this_ptr, SL("_referenceName"), reference_name TSRMLS_CC); eval_int = phalcon_array_isset_string(definition, SL("referencedTable")+1); if (eval_int) { PHALCON_INIT_VAR(referenced_table); phalcon_array_fetch_string(&referenced_table, definition, SL("referencedTable"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_referencedTable"), referenced_table TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced table is required"); return; } eval_int = phalcon_array_isset_string(definition, SL("columns")+1); if (eval_int) { PHALCON_INIT_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_columns"), columns TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Foreign key columns are required"); return; } eval_int = phalcon_array_isset_string(definition, SL("referencedColumns")+1); if (eval_int) { PHALCON_INIT_VAR(referenced_columns); phalcon_array_fetch_string(&referenced_columns, definition, SL("referencedColumns"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_referencedColumns"), referenced_columns TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced columns of the foreign key are required"); return; } eval_int = phalcon_array_isset_string(definition, SL("schema")+1); if (eval_int) { PHALCON_INIT_VAR(schema); phalcon_array_fetch_string(&schema, definition, SL("schema"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_schema"), schema TSRMLS_CC); } eval_int = phalcon_array_isset_string(definition, SL("referencedSchema")+1); if (eval_int) { PHALCON_INIT_VAR(referenced_schema); phalcon_array_fetch_string(&referenced_schema, definition, SL("referencedSchema"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_referencedSchema"), referenced_schema TSRMLS_CC); } PHALCON_INIT_VAR(number_columns); phalcon_fast_count(number_columns, columns TSRMLS_CC); PHALCON_INIT_VAR(number_referenced_columns); phalcon_fast_count(number_referenced_columns, referenced_columns TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r0); is_not_equal_function(r0, number_columns, number_referenced_columns TSRMLS_CC); if (zend_is_true(r0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Number of columns is not equals than the number of columns referenced"); return; } PHALCON_MM_RESTORE(); }
/** * Renders a view * * @param string $path * @param array $params * @return string */ PHP_METHOD(Phalcon_Mvc_View_Simple, render){ zval *path, *params = NULL, *cache, *is_started = NULL, *key = NULL, *lifetime = NULL; zval *cache_options, *content = NULL, *view_params; zval *merged_params = NULL, *is_fresh; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &path, ¶ms); if (!params) { PHALCON_INIT_VAR(params); } /** * Create/Get a cache */ PHALCON_INIT_VAR(cache); phalcon_call_method(cache, this_ptr, "getcache"); if (Z_TYPE_P(cache) == IS_OBJECT) { /** * 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(cache_options); phalcon_read_property_this(&cache_options, this_ptr, SL("_cacheOptions"), PH_NOISY_CC); /** * Check if the user has defined a different options to the default */ 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); } if (phalcon_array_isset_string(cache_options, SS("lifetime"))) { PHALCON_OBS_NVAR(lifetime); phalcon_array_fetch_string(&lifetime, cache_options, SL("lifetime"), PH_NOISY); } } /** * 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_md5(key, path); } /** * We start the cache using the key set */ PHALCON_INIT_VAR(content); phalcon_call_method_p2(content, cache, "start", key, lifetime); if (Z_TYPE_P(content) != IS_NULL) { phalcon_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC); RETURN_CCTOR(content); } } } /** * Create a virtual symbol table */ phalcon_create_symbol_table(TSRMLS_C); phalcon_ob_start(TSRMLS_C); PHALCON_OBS_VAR(view_params); phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC); /** * Merge parameters */ if (Z_TYPE_P(params) == IS_ARRAY) { if (Z_TYPE_P(view_params) == IS_ARRAY) { PHALCON_INIT_VAR(merged_params); phalcon_fast_array_merge(merged_params, &view_params, ¶ms TSRMLS_CC); } else { PHALCON_CPY_WRT(merged_params, params); } } else { PHALCON_CPY_WRT(merged_params, view_params); } /** * internalRender is also reused by partials */ phalcon_call_method_p2_noret(this_ptr, "_internalrender", path, merged_params); /** * Store the data in output into the cache */ if (Z_TYPE_P(cache) == IS_OBJECT) { PHALCON_INIT_NVAR(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_noret(cache, "save"); } else { phalcon_call_method_noret(cache, "stop"); } } else { phalcon_call_method_noret(cache, "stop"); } } phalcon_ob_end_clean(TSRMLS_C); PHALCON_OBS_NVAR(content); phalcon_read_property_this(&content, this_ptr, SL("_content"), PH_NOISY_CC); RETURN_CCTOR(content); }
/** * Phalcon\Mvc\Model\Query\Builder constructor * * @param array $params */ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct){ zval *params = NULL, *conditions = NULL, *columns, *group_clause; zval *having_clause, *order_clause, *limit_clause; zval *for_update, *shared_lock; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶ms) == FAILURE) { RETURN_MM_NULL(); } if (!params) { PHALCON_INIT_VAR(params); } if (Z_TYPE_P(params) == IS_ARRAY) { /** * Process conditions */ if (phalcon_array_isset_long(params, 0)) { PHALCON_OBS_VAR(conditions); phalcon_array_fetch_long(&conditions, params, 0, PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_conditions"), conditions TSRMLS_CC); } else { if (phalcon_array_isset_string(params, SS("conditions"))) { PHALCON_OBS_NVAR(conditions); phalcon_array_fetch_string(&conditions, params, SL("conditions"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_conditions"), conditions TSRMLS_CC); } } /** * Assign COLUMNS clause */ if (phalcon_array_isset_string(params, SS("columns"))) { PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, params, SL("columns"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_columns"), columns TSRMLS_CC); } /** * Assign GROUP clause */ if (phalcon_array_isset_string(params, SS("group"))) { PHALCON_OBS_VAR(group_clause); phalcon_array_fetch_string(&group_clause, params, SL("group"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_group"), group_clause TSRMLS_CC); } /** * Assign HAVING clause */ if (phalcon_array_isset_string(params, SS("having"))) { PHALCON_OBS_VAR(having_clause); phalcon_array_fetch_string(&having_clause, params, SL("having"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_group"), having_clause TSRMLS_CC); } /** * Assign ORDER clause */ if (phalcon_array_isset_string(params, SS("order"))) { PHALCON_OBS_VAR(order_clause); phalcon_array_fetch_string(&order_clause, params, SL("order"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_order"), order_clause TSRMLS_CC); } /** * Assign LIMIT clause */ if (phalcon_array_isset_string(params, SS("limit"))) { PHALCON_OBS_VAR(limit_clause); phalcon_array_fetch_string(&limit_clause, params, SL("limit"), PH_NOISY_CC); phalcon_update_property_zval(this_ptr, SL("_limit"), limit_clause TSRMLS_CC); } /** * Assign FOR UPDATE clause */ if (phalcon_array_isset_string(params, SS("for_update"))) { PHALCON_OBS_VAR(for_update); phalcon_array_fetch_string(&for_update, params, SL("for_update"), PH_NOISY_CC); if (zend_is_true(for_update)) { phalcon_update_property_bool(this_ptr, SL("_forUpdate"), 1 TSRMLS_CC); } } /** * Assign SHARED LOCK clause */ if (phalcon_array_isset_string(params, SS("shared_lock"))) { PHALCON_OBS_VAR(shared_lock); phalcon_array_fetch_string(&shared_lock, params, SL("shared_lock"), PH_NOISY_CC); if (zend_is_true(shared_lock)) { phalcon_update_property_bool(this_ptr, SL("_sharedLock"), 1 TSRMLS_CC); } } } PHALCON_MM_RESTORE(); }
/** * Restore a Phalcon\Db\Reference object from export * * @param array $data * @return Phalcon\Db\Reference */ PHP_METHOD(Phalcon_Db_Reference, __set_state){ zval *data = NULL, *constraint_name = NULL, *referenced_schema = NULL; zval *referenced_table = NULL, *columns = NULL, *referenced_columns = NULL; zval *definition = NULL, *reference = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } eval_int = phalcon_array_isset_string(data, SL("_referenceName")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "_referenceName parameter is required"); return; } else { PHALCON_INIT_VAR(constraint_name); phalcon_array_fetch_string(&constraint_name, data, SL("_referenceName"), PH_NOISY_CC); } eval_int = phalcon_array_isset_string(data, SL("_referencedSchema")+1); if (eval_int) { PHALCON_INIT_VAR(referenced_schema); phalcon_array_fetch_string(&referenced_schema, data, SL("_referencedSchema"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(referenced_schema); ZVAL_NULL(referenced_schema); } eval_int = phalcon_array_isset_string(data, SL("_referencedTable")+1); if (eval_int) { PHALCON_INIT_VAR(referenced_table); phalcon_array_fetch_string(&referenced_table, data, SL("_referencedTable"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(referenced_table); ZVAL_NULL(referenced_table); } eval_int = phalcon_array_isset_string(data, SL("_columns")+1); if (eval_int) { PHALCON_INIT_VAR(columns); phalcon_array_fetch_string(&columns, data, SL("_columns"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(columns); ZVAL_NULL(columns); } eval_int = phalcon_array_isset_string(data, SL("_referencedColumns")+1); if (eval_int) { PHALCON_INIT_VAR(referenced_columns); phalcon_array_fetch_string(&referenced_columns, data, SL("_referencedColumns"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(referenced_columns); ZVAL_NULL(referenced_columns); } PHALCON_INIT_VAR(definition); array_init(definition); 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_VAR(reference); object_init_ex(reference, phalcon_db_reference_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(reference, "__construct", constraint_name, definition, PH_CHECK); RETURN_CTOR(reference); }
/** * Returns a PHQL statement built based on the builder parameters * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){ zval *dependency_injector = NULL, *models, *conditions = NULL; zval *one, *number_models, *invalid_condition; zval *model = NULL, *service_name, *meta_data, *model_instance; zval *no_primary = NULL, *primary_keys, *first_primary_key; zval *column_map = NULL, *attribute_field = NULL, *exception_message; zval *primary_key_condition, *phql, *columns; zval *selected_columns = NULL, *column = NULL, *alias = NULL, *aliased_column = NULL; zval *joined_columns = NULL, *selected_column = NULL, *selected_models; zval *selected_model = NULL, *joined_models, *joins; zval *join = NULL, *join_model = NULL, *join_conditions = NULL, *join_alias = NULL; zval *join_type = NULL, *group, *group_items, *group_item = NULL; zval *escaped_item = NULL, *joined_items = NULL, *having, *order; zval *order_items, *order_item = NULL, *limit, *number; zval *offset = NULL; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5; HashPosition hp0, hp1, hp2, hp3, hp4, hp5; zval **hd; zend_class_entry *ce0; PHALCON_MM_GROW(); PHALCON_OBS_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_INIT_NVAR(dependency_injector); PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault"); phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC); } PHALCON_OBS_VAR(models); phalcon_read_property(&models, this_ptr, SL("_models"), PH_NOISY_CC); if (Z_TYPE_P(models) == IS_ARRAY) { if (!phalcon_fast_count_ev(models TSRMLS_CC)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query"); return; } } else { if (!zend_is_true(models)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query"); return; } } PHALCON_OBS_VAR(conditions); phalcon_read_property(&conditions, this_ptr, SL("_conditions"), PH_NOISY_CC); if (phalcon_is_numeric(conditions)) { /** * If the conditions is a single numeric field. We internally create a condition * using the related primary key */ if (Z_TYPE_P(models) == IS_ARRAY) { PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(number_models); phalcon_fast_count(number_models, models TSRMLS_CC); PHALCON_INIT_VAR(invalid_condition); is_smaller_function(invalid_condition, one, number_models TSRMLS_CC); if (PHALCON_IS_TRUE(invalid_condition)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Cannot build the query. Invalid condition"); return; } PHALCON_OBS_VAR(model); phalcon_array_fetch_long(&model, models, 0, PH_NOISY_CC); } else { PHALCON_CPY_WRT(model, models); } PHALCON_INIT_VAR(service_name); ZVAL_STRING(service_name, "modelsMetadata", 1); /** * Get the models metadata service to obtain the column names, column map and * primary key */ PHALCON_INIT_VAR(meta_data); PHALCON_CALL_METHOD_PARAMS_1(meta_data, dependency_injector, "getshared", service_name); ce0 = phalcon_fetch_class(model TSRMLS_CC); PHALCON_INIT_VAR(model_instance); object_init_ex(model_instance, ce0); if (phalcon_has_constructor(model_instance TSRMLS_CC)) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(model_instance, "__construct", dependency_injector); } PHALCON_INIT_VAR(no_primary); ZVAL_BOOL(no_primary, 1); PHALCON_INIT_VAR(primary_keys); PHALCON_CALL_METHOD_PARAMS_1(primary_keys, meta_data, "getprimarykeyattributes", model_instance); if (phalcon_fast_count_ev(primary_keys TSRMLS_CC)) { if (phalcon_array_isset_long(primary_keys, 0)) { PHALCON_OBS_VAR(first_primary_key); phalcon_array_fetch_long(&first_primary_key, primary_keys, 0, PH_NOISY_CC); /** * The PHQL contains the renamed columns if available */ if (PHALCON_GLOBAL(orm).column_renaming) { PHALCON_INIT_VAR(column_map); PHALCON_CALL_METHOD_PARAMS_1(column_map, meta_data, "getcolumnmap", model_instance); } else { PHALCON_INIT_NVAR(column_map); } if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, first_primary_key)) { PHALCON_OBS_VAR(attribute_field); phalcon_array_fetch(&attribute_field, column_map, first_primary_key, PH_NOISY_CC); } else { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", first_primary_key, "\" isn't part of the column map"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_CPY_WRT(attribute_field, first_primary_key); } PHALCON_INIT_VAR(primary_key_condition); PHALCON_CONCAT_SVSVSV(primary_key_condition, "[", model, "].[", attribute_field, "] = ", conditions); PHALCON_CPY_WRT(conditions, primary_key_condition); ZVAL_BOOL(no_primary, 0); } } /** * A primary key is mandatory in these cases */ if (PHALCON_IS_TRUE(no_primary)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Source related to this model does not have a primary key defined"); return; } } PHALCON_INIT_VAR(phql); ZVAL_STRING(phql, "SELECT ", 1); PHALCON_OBS_VAR(columns); phalcon_read_property(&columns, this_ptr, SL("_columns"), PH_NOISY_CC); if (Z_TYPE_P(columns) != IS_NULL) { if (Z_TYPE_P(columns) == IS_ARRAY) { PHALCON_INIT_VAR(selected_columns); array_init(selected_columns); if (!phalcon_is_iterable(columns, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(alias, ah0, hp0); PHALCON_GET_FOREACH_VALUE(column); if (Z_TYPE_P(alias) == IS_LONG) { phalcon_array_append(&selected_columns, column, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_NVAR(aliased_column); PHALCON_CONCAT_VSV(aliased_column, column, " AS ", alias); phalcon_array_append(&selected_columns, aliased_column, PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(joined_columns); phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC); phalcon_concat_self(&phql, joined_columns TSRMLS_CC); } else { phalcon_concat_self(&phql, columns TSRMLS_CC); } } else { if (Z_TYPE_P(models) == IS_ARRAY) { PHALCON_INIT_NVAR(selected_columns); array_init(selected_columns); if (!phalcon_is_iterable(models, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_KEY(alias, ah1, hp1); PHALCON_GET_FOREACH_VALUE(model); if (Z_TYPE_P(alias) == IS_LONG) { PHALCON_INIT_NVAR(selected_column); PHALCON_CONCAT_SVS(selected_column, "[", model, "].*"); } else { PHALCON_INIT_NVAR(selected_column); PHALCON_CONCAT_SVS(selected_column, "[", alias, "].*"); } phalcon_array_append(&selected_columns, selected_column, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_NVAR(joined_columns); phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC); phalcon_concat_self(&phql, joined_columns TSRMLS_CC); } else { PHALCON_SCONCAT_SVS(phql, "[", models, "].*"); } } /** * Join multiple models or use a single one if it is a string */ if (Z_TYPE_P(models) == IS_ARRAY) { PHALCON_INIT_VAR(selected_models); array_init(selected_models); if (!phalcon_is_iterable(models, &ah2, &hp2, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_FOREACH_KEY(alias, ah2, hp2); PHALCON_GET_FOREACH_VALUE(model); if (Z_TYPE_P(alias) == IS_STRING) { PHALCON_INIT_NVAR(selected_model); PHALCON_CONCAT_SVSVS(selected_model, "[", model, "] AS [", alias, "]"); } else { PHALCON_INIT_NVAR(selected_model); PHALCON_CONCAT_SVS(selected_model, "[", model, "]"); } phalcon_array_append(&selected_models, selected_model, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } PHALCON_INIT_VAR(joined_models); phalcon_fast_join_str(joined_models, SL(", "), selected_models TSRMLS_CC); PHALCON_SCONCAT_SV(phql, " FROM ", joined_models); } else { PHALCON_SCONCAT_SVS(phql, " FROM [", models, "]"); } /** * Check if joins were passed to the builders */ PHALCON_OBS_VAR(joins); phalcon_read_property(&joins, this_ptr, SL("_joins"), PH_NOISY_CC); if (Z_TYPE_P(joins) == IS_ARRAY) { if (!phalcon_is_iterable(joins, &ah3, &hp3, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(join); /** * The joined table is in the first place of the array */ PHALCON_OBS_NVAR(join_model); phalcon_array_fetch_long(&join_model, join, 0, PH_NOISY_CC); /** * The join conditions are in the second place of the array */ PHALCON_OBS_NVAR(join_conditions); phalcon_array_fetch_long(&join_conditions, join, 1, PH_NOISY_CC); /** * The join alias is in the second place of the array */ PHALCON_OBS_NVAR(join_alias); phalcon_array_fetch_long(&join_alias, join, 2, PH_NOISY_CC); /** * Join type */ PHALCON_OBS_NVAR(join_type); phalcon_array_fetch_long(&join_type, join, 3, PH_NOISY_CC); /** * Create the join according to the type */ if (zend_is_true(join_type)) { PHALCON_SCONCAT_VSVS(phql, join_type, " JOIN [", join_model, "]"); } else { PHALCON_SCONCAT_SVS(phql, " JOIN [", join_model, "]"); } /** * Alias comes first */ if (zend_is_true(join_alias)) { PHALCON_SCONCAT_SVS(phql, " AS [", join_alias, "]"); } /** * Conditions then */ if (zend_is_true(join_conditions)) { PHALCON_SCONCAT_SV(phql, " ON ", join_conditions); } zend_hash_move_forward_ex(ah3, &hp3); } } if (Z_TYPE_P(conditions) == IS_STRING) { PHALCON_SCONCAT_SV(phql, " WHERE ", conditions); } /** * Process group parameters */ PHALCON_OBS_VAR(group); phalcon_read_property(&group, this_ptr, SL("_group"), PH_NOISY_CC); if (Z_TYPE_P(group) != IS_NULL) { if (Z_TYPE_P(group) == IS_ARRAY) { PHALCON_INIT_VAR(group_items); array_init(group_items); if (!phalcon_is_iterable(group, &ah4, &hp4, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(group_item); if (phalcon_is_numeric(group_item)) { phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(group_item, SL(".") TSRMLS_CC)) { phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_NVAR(escaped_item); PHALCON_CONCAT_SVS(escaped_item, "[", group_item, "]"); phalcon_array_append(&group_items, escaped_item, PH_SEPARATE TSRMLS_CC); } } zend_hash_move_forward_ex(ah4, &hp4); } PHALCON_INIT_VAR(joined_items); phalcon_fast_join_str(joined_items, SL(", "), group_items TSRMLS_CC); PHALCON_SCONCAT_SV(phql, " GROUP BY ", joined_items); } else { if (phalcon_is_numeric(group)) { PHALCON_SCONCAT_SV(phql, " GROUP BY ", group); } else { if (phalcon_memnstr_str(group, SL(".") TSRMLS_CC)) { PHALCON_SCONCAT_SV(phql, " GROUP BY ", group); } else { PHALCON_SCONCAT_SVS(phql, " GROUP BY [", group, "]"); } } } PHALCON_OBS_VAR(having); phalcon_read_property(&having, this_ptr, SL("_having"), PH_NOISY_CC); if (Z_TYPE_P(having) != IS_NULL) { PHALCON_SCONCAT_SV(phql, " HAVING ", having); } } /** * Process order clause */ PHALCON_OBS_VAR(order); phalcon_read_property(&order, this_ptr, SL("_order"), PH_NOISY_CC); if (Z_TYPE_P(order) != IS_NULL) { if (Z_TYPE_P(order) == IS_ARRAY) { PHALCON_INIT_VAR(order_items); array_init(order_items); if (!phalcon_is_iterable(order, &ah5, &hp5, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(order_item); if (phalcon_is_numeric(order_item)) { phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(order_item, SL(".") TSRMLS_CC)) { phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_NVAR(escaped_item); PHALCON_CONCAT_SVS(escaped_item, "[", order_item, "]"); phalcon_array_append(&order_items, escaped_item, PH_SEPARATE TSRMLS_CC); } } zend_hash_move_forward_ex(ah5, &hp5); } PHALCON_INIT_NVAR(joined_items); phalcon_fast_join_str(joined_items, SL(", "), order_items TSRMLS_CC); PHALCON_SCONCAT_SV(phql, " ORDER BY ", joined_items); } else { PHALCON_SCONCAT_SV(phql, " ORDER BY ", order); } } /** * Process limit parameters */ PHALCON_OBS_VAR(limit); phalcon_read_property(&limit, this_ptr, SL("_limit"), PH_NOISY_CC); if (Z_TYPE_P(limit) != IS_NULL) { if (Z_TYPE_P(limit) == IS_ARRAY) { PHALCON_OBS_VAR(number); phalcon_array_fetch_string(&number, limit, SL("number"), PH_NOISY_CC); if (phalcon_array_isset_string(limit, SS("offset"))) { PHALCON_OBS_VAR(offset); phalcon_array_fetch_string(&offset, limit, SL("offset"), PH_NOISY_CC); if (phalcon_is_numeric(offset)) { PHALCON_SCONCAT_SVSV(phql, " LIMIT ", number, " OFFSET ", offset); } else { PHALCON_SCONCAT_SVS(phql, " LIMIT ", number, " OFFSET 0"); } } else { PHALCON_SCONCAT_SV(phql, " LIMIT ", number); } } else { if (phalcon_is_numeric(limit)) { PHALCON_SCONCAT_SV(phql, " LIMIT ", limit); PHALCON_OBS_NVAR(offset); phalcon_read_property(&offset, this_ptr, SL("_offset"), PH_NOISY_CC); if (Z_TYPE_P(offset) != IS_NULL) { if (phalcon_is_numeric(offset)) { PHALCON_SCONCAT_SV(phql, " OFFSET ", offset); } else { phalcon_concat_self_str(&phql, SL(" OFFSET 0") TSRMLS_CC); } } } } } RETURN_CTOR(phql); }
/** * Reads the cookie-related info from the SESSION to restore the cookie as it was set * This method is automatically called internally so normally you don't need to call it * * @return Phalcon\Http\Cookie */ PHP_METHOD(Phalcon_Http_Cookie, restore){ zval *restored, *dependency_injector, *service; zval *session, *name, *key, *definition, *expire, *domain; zval *path, *secure, *http_only; PHALCON_MM_GROW(); PHALCON_OBS_VAR(restored); phalcon_read_property_this(&restored, this_ptr, SL("_restored"), PH_NOISY_CC); if (!zend_is_true(restored)) { PHALCON_OBS_VAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) == IS_OBJECT) { PHALCON_INIT_VAR(service); ZVAL_STRING(service, "session", 1); PHALCON_INIT_VAR(session); phalcon_call_method_p1(session, dependency_injector, "getshared", service); PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); PHALCON_INIT_VAR(key); PHALCON_CONCAT_SV(key, "_PHCOOKIE_", name); PHALCON_INIT_VAR(definition); phalcon_call_method_p1(definition, session, "get", key); if (Z_TYPE_P(definition) == IS_ARRAY) { if (phalcon_array_isset_string(definition, SS("expire"))) { PHALCON_OBS_VAR(expire); phalcon_array_fetch_string(&expire, definition, SL("expire"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_expire"), expire TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("domain"))) { PHALCON_OBS_VAR(domain); phalcon_array_fetch_string(&domain, definition, SL("domain"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_domain"), domain TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_string(&path, definition, SL("path"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_path"), path TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("secure"))) { PHALCON_OBS_VAR(secure); phalcon_array_fetch_string(&secure, definition, SL("secure"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_secure"), secure TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("httpOnly"))) { PHALCON_OBS_VAR(http_only); phalcon_array_fetch_string(&http_only, definition, SL("httpOnly"), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_httpOnly"), http_only TSRMLS_CC); } } } phalcon_update_property_bool(this_ptr, SL("_restored"), 1 TSRMLS_CC); } RETURN_THIS(); }
/** * 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 TSRMLS_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); phalcon_array_unset_string(&descriptor, SS("username"), PH_COPY); } 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); phalcon_array_unset_string(&descriptor, SS("password"), PH_COPY); } else { PHALCON_INIT_NVAR(password); } /** * 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); phalcon_array_unset_string(&descriptor, SS("options"), PH_COPY); } else { PHALCON_INIT_NVAR(options); array_init(options); } /** * Remove the dialectClass from the descriptor if any */ if (phalcon_array_isset_string(descriptor, SS("dialectClass"))) { phalcon_array_unset_string(&descriptor, SS("dialectClass"), PH_COPY); } /** * 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); phalcon_is_iterable(descriptor, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(key, ah0, hp0); PHALCON_GET_HVALUE(value); PHALCON_INIT_NVAR(dsn_attribute); PHALCON_CONCAT_VSV(dsn_attribute, key, "=", value); phalcon_array_append(&dsn_parts, dsn_attribute, PH_COPY); 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); } PHALCON_OBS_VAR(pdo_type); phalcon_read_property(&pdo_type, this_ptr, SL("_type"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(dsn); PHALCON_CONCAT_VSV(dsn, pdo_type, ":", dsn_attributes); /** * Default options */ phalcon_array_update_long_long(&options, PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION, PH_COPY); /* phalcon_array_update_long_long(&options, PDO_ATTR_CASE, PDO_CASE_LOWER, PH_COPY); phalcon_array_update_long_long(&options, PDO_ATTR_CURSOR, PDO_CURSOR_SCROLL, PH_COPY); */ /** * 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); if (zend_is_true(persistent)) { phalcon_array_update_long_bool(&options, PDO_ATTR_PERSISTENT, 1, PH_COPY); } } /** * 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(NULL, pdo, "__construct", dsn, username, password, options); phalcon_update_property_zval(this_ptr, SL("_pdo"), pdo TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Appends a condition to the current conditions using an OR operator * * @param string $conditions * @param array $bindParams * @param array $bindTypes * @return Phalcon\Mvc\Model\Criteria */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, orWhere){ zval *conditions, *bind_params = NULL, *bind_types = NULL; zval *params = NULL, *current_conditions, *new_conditions = NULL; zval *current_bind_params, *merged_params = NULL; zval *current_bind_types, *merged_params_types = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 2, &conditions, &bind_params, &bind_types); if (!bind_params) { PHALCON_INIT_VAR(bind_params); } if (!bind_types) { PHALCON_INIT_VAR(bind_types); } if (Z_TYPE_P(conditions) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Conditions must be string"); return; } PHALCON_OBS_VAR(params); phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC); if (phalcon_array_isset_string(params, SS("conditions"))) { PHALCON_OBS_VAR(current_conditions); phalcon_array_fetch_string(¤t_conditions, params, SL("conditions"), PH_NOISY_CC); PHALCON_INIT_VAR(new_conditions); PHALCON_CONCAT_SVSVS(new_conditions, "(", current_conditions, ") OR (", conditions, ")"); } else { PHALCON_CPY_WRT(new_conditions, conditions); } phalcon_update_property_array_string(this_ptr, SL("_params"), SS("conditions"), new_conditions TSRMLS_CC); /** * Update or merge existing bound parameters */ if (Z_TYPE_P(bind_params) == IS_ARRAY) { PHALCON_OBS_NVAR(params); phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC); if (phalcon_array_isset_string(params, SS("bind"))) { PHALCON_OBS_VAR(current_bind_params); phalcon_array_fetch_string(¤t_bind_params, params, SL("bind"), PH_NOISY_CC); PHALCON_INIT_VAR(merged_params); phalcon_fast_array_merge(merged_params, ¤t_bind_params, &bind_params TSRMLS_CC); } else { PHALCON_CPY_WRT(merged_params, bind_params); } phalcon_update_property_array_string(this_ptr, SL("_params"), SS("bind"), merged_params TSRMLS_CC); } /** * Update or merge existing bind types parameters */ if (Z_TYPE_P(bind_types) == IS_ARRAY) { PHALCON_OBS_NVAR(params); phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC); if (phalcon_array_isset_string(params, SS("bindTypes"))) { PHALCON_OBS_VAR(current_bind_types); phalcon_array_fetch_string(¤t_bind_types, params, SL("bindTypes"), PH_NOISY_CC); PHALCON_INIT_VAR(merged_params_types); phalcon_fast_array_merge(merged_params_types, ¤t_bind_types, &bind_types TSRMLS_CC); } else { PHALCON_CPY_WRT(merged_params_types, bind_types); } phalcon_update_property_array_string(this_ptr, SL("_params"), SS("bindTypes"), merged_params_types TSRMLS_CC); } RETURN_THIS(); }
/** * Generates a SELECT tag * * @param array $parameters * @param array $data */ PHP_METHOD(Phalcon_Tag_Select, selectField){ zval *parameters, *data = NULL, *params = NULL, *eol, *id = NULL, *name, *value = NULL; zval *use_empty = NULL, *empty_value = NULL, *empty_text = NULL, *code; zval *avalue = NULL, *key = NULL, *close_option, *options = NULL, *using; zval *resultset_options, *array_options; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &data) == FAILURE) { RETURN_MM_NULL(); } if (!data) { PHALCON_INIT_VAR(data); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 2); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); phalcon_array_append(¶ms, data, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(eol); zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC); if (!phalcon_array_isset_long(params, 0)) { PHALCON_OBS_VAR(id); phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC); phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_OBS_NVAR(id); phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC); if (!phalcon_array_isset_string(params, SS("name"))) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC); if (!zend_is_true(name)) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } } if (!phalcon_array_isset_string(params, SS("id"))) { phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (!phalcon_array_isset_string(params, SS("value"))) { PHALCON_INIT_VAR(value); PHALCON_CALL_STATIC_PARAMS_2(value, "phalcon\\tag", "getvalue", id, params); } else { PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("value")); } PHALCON_INIT_VAR(use_empty); ZVAL_BOOL(use_empty, 0); if (phalcon_array_isset_string(params, SS("useEmpty"))) { if (!phalcon_array_isset_string(params, SS("emptyValue"))) { PHALCON_INIT_VAR(empty_value); ZVAL_STRING(empty_value, "", 1); } else { PHALCON_OBS_NVAR(empty_value); phalcon_array_fetch_string(&empty_value, params, SL("emptyValue"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("emptyValue")); } if (!phalcon_array_isset_string(params, SS("emptyText"))) { PHALCON_INIT_VAR(empty_text); ZVAL_STRING(empty_text, "Choose...", 1); } else { PHALCON_OBS_NVAR(empty_text); phalcon_array_fetch_string(&empty_text, params, SL("emptyText"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("emptyText")); } PHALCON_OBS_NVAR(use_empty); phalcon_array_fetch_string(&use_empty, params, SL("useEmpty"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("useEmpty")); } PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<select", 1); if (Z_TYPE_P(params) == IS_ARRAY) { 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(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(avalue); if (Z_TYPE_P(key) != IS_LONG) { if (Z_TYPE_P(avalue) != IS_ARRAY) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\""); } } zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_SCONCAT_SV(code, ">", eol); PHALCON_INIT_VAR(close_option); PHALCON_CONCAT_SV(close_option, "</option>", eol); if (zend_is_true(use_empty)) { /** * Create an empty value */ PHALCON_SCONCAT_SVSVV(code, "\t<option value=\"", empty_value, "\">", empty_text, close_option); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("useEmpty")); } if (phalcon_array_isset_long(params, 1)) { PHALCON_OBS_VAR(options); phalcon_array_fetch_long(&options, params, 1, PH_NOISY_CC); } else { PHALCON_CPY_WRT(options, data); } if (Z_TYPE_P(options) == IS_OBJECT) { /** * The options is a resultset */ if (!phalcon_array_isset_string(params, SS("using"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required"); return; } else { PHALCON_OBS_VAR(using); phalcon_array_fetch_string(&using, params, SL("using"), PH_NOISY_CC); if (Z_TYPE_P(using) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array"); return; } } /** * Create the SELECT's option from a resultset */ PHALCON_INIT_VAR(resultset_options); PHALCON_CALL_SELF_PARAMS_4(resultset_options, this_ptr, "_optionsfromresultset", options, using, value, close_option); phalcon_concat_self(&code, resultset_options TSRMLS_CC); } else { if (Z_TYPE_P(options) == IS_ARRAY) {
/** * Phalcon\Db\Column constructor * * @param string $columnName * @param array $definition */ PHP_METHOD(Phalcon_Db_Column, __construct){ zval *column_name, *definition, *type, *not_null; zval *primary, *size, *is_numeric = NULL, *scale, *dunsigned; zval *auto_increment, *first, *after, *bind_type; zval *t0 = NULL, *t1 = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &column_name, &definition); phalcon_update_property_this(this_ptr, SL("_columnName"), column_name TSRMLS_CC); /** * Get the column type, one of the TYPE_* constants */ if (phalcon_array_isset_string(definition, SS("type"))) { PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, definition, SL("type"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type is required"); return; } /** * Check if the field is nullable */ if (phalcon_array_isset_string(definition, SS("notNull"))) { PHALCON_OBS_VAR(not_null); phalcon_array_fetch_string(¬_null, definition, SL("notNull"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_notNull"), not_null TSRMLS_CC); } /** * Check if the field is primary key */ if (phalcon_array_isset_string(definition, SS("primary"))) { PHALCON_OBS_VAR(primary); phalcon_array_fetch_string(&primary, definition, SL("primary"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_primary"), primary TSRMLS_CC); } if (phalcon_array_isset_string(definition, SS("size"))) { PHALCON_OBS_VAR(size); phalcon_array_fetch_string(&size, definition, SL("size"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC); } /** * Check if the column has a decimal scale */ if (phalcon_array_isset_string(definition, SS("scale"))) { PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 3); PHALCON_INIT_VAR(is_numeric); is_equal_function(is_numeric, type, t0 TSRMLS_CC); if (PHALCON_IS_NOT_TRUE(is_numeric)) { PHALCON_INIT_VAR(t1); ZVAL_LONG(t1, 7); is_equal_function(is_numeric, type, t1 TSRMLS_CC); } if (PHALCON_IS_TRUE(is_numeric)) { PHALCON_OBS_VAR(scale); phalcon_array_fetch_string(&scale, definition, SL("scale"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_scale"), scale TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type does not support scale parameter"); return; } } /** * Check if the field is unsigned (only MySQL) */ if (phalcon_array_isset_string(definition, SS("unsigned"))) { PHALCON_OBS_VAR(dunsigned); phalcon_array_fetch_string(&dunsigned, definition, SL("unsigned"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_unsigned"), dunsigned TSRMLS_CC); } /** * Check if the field is numeric */ if (phalcon_array_isset_string(definition, SS("isNumeric"))) { PHALCON_OBS_NVAR(is_numeric); phalcon_array_fetch_string(&is_numeric, definition, SL("isNumeric"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_isNumeric"), is_numeric TSRMLS_CC); } /** * Check if the field is auto-increment/serial */ if (phalcon_array_isset_string(definition, SS("autoIncrement"))) { if (PHALCON_IS_LONG(type, 0)) { PHALCON_OBS_VAR(auto_increment); phalcon_array_fetch_string(&auto_increment, definition, SL("autoIncrement"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_autoIncrement"), auto_increment TSRMLS_CC); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type cannot be auto-increment"); return; } } /** * Check if the field is placed at the first position of the table */ if (phalcon_array_isset_string(definition, SS("first"))) { PHALCON_OBS_VAR(first); phalcon_array_fetch_string(&first, definition, SL("first"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_first"), first TSRMLS_CC); } /** * Name of the column which is placed before the current field */ if (phalcon_array_isset_string(definition, SS("after"))) { PHALCON_OBS_VAR(after); phalcon_array_fetch_string(&after, definition, SL("after"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_after"), after TSRMLS_CC); } /** * The bind type to cast the field when passing it to PDO */ if (phalcon_array_isset_string(definition, SS("bindType"))) { PHALCON_OBS_VAR(bind_type); phalcon_array_fetch_string(&bind_type, definition, SL("bindType"), PH_NOISY_CC); phalcon_update_property_this(this_ptr, SL("_bindType"), bind_type TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Returns a slice of the resultset to show in the pagination * * @return stdClass */ PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){ zval *show = NULL, *config = NULL, *items = NULL, *page_number = NULL, *zero = NULL, *one = NULL; zval *smaller = NULL, *n = NULL, *page = NULL, *last_show_page = NULL, *start = NULL; zval *last_page = NULL, *possible_pages = NULL, *total_pages = NULL; zval *compare = NULL, *page_items = NULL, *i = NULL, *valid = NULL, *current = NULL, *maximum_pages = NULL; zval *next = NULL, *additional_page = NULL, *before = NULL, *remainder = NULL; zval *pages_total = NULL; zval *r0 = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); PHALCON_INIT_VAR(show); phalcon_read_property(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC); PHALCON_INIT_VAR(config); phalcon_read_property(&config, this_ptr, SL("_config"), PH_NOISY_CC); PHALCON_INIT_VAR(items); phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC); PHALCON_INIT_VAR(page_number); phalcon_read_property(&page_number, this_ptr, SL("_page"), PH_NOISY_CC); if (Z_TYPE_P(page_number) == IS_NULL) { PHALCON_INIT_VAR(page_number); ZVAL_LONG(page_number, 1); } PHALCON_INIT_VAR(zero); ZVAL_LONG(zero, 0); PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(smaller); is_smaller_function(smaller, show, zero TSRMLS_CC); if (Z_TYPE_P(smaller) == IS_BOOL && Z_BVAL_P(smaller)) { PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less"); return; } PHALCON_INIT_VAR(n); phalcon_fast_count(n, items TSRMLS_CC); PHALCON_INIT_VAR(page); object_init(page); PHALCON_INIT_VAR(last_show_page); sub_function(last_show_page, page_number, one TSRMLS_CC); PHALCON_INIT_VAR(start); mul_function(start, show, last_show_page TSRMLS_CC); PHALCON_INIT_VAR(last_page); sub_function(last_page, n, one TSRMLS_CC); PHALCON_INIT_VAR(possible_pages); div_function(possible_pages, last_page, show TSRMLS_CC); PHALCON_INIT_VAR(total_pages); PHALCON_CALL_FUNC_PARAMS_1(total_pages, "ceil", possible_pages); if (Z_TYPE_P(items) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator"); return; } if (Z_TYPE_P(page_number) == IS_NULL) { PHALCON_INIT_VAR(page_number); ZVAL_LONG(page_number, 0); } PHALCON_INIT_VAR(compare); is_smaller_function(compare, start, zero TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less"); return; } PHALCON_INIT_VAR(page_items); array_init(page_items); PHALCON_INIT_VAR(compare); is_smaller_function(compare, zero, n TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { PHALCON_INIT_VAR(compare); is_smaller_or_equal_function(compare, start, n TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", start, PH_NO_CHECK); } else { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", one, PH_NO_CHECK); PHALCON_INIT_VAR(page_number); ZVAL_LONG(page_number, 1); } PHALCON_INIT_VAR(i); ZVAL_LONG(i, 1); ws_e435_0: PHALCON_INIT_VAR(r0); PHALCON_CALL_METHOD(r0, items, "valid", PH_NO_CHECK); PHALCON_CPY_WRT(valid, r0); if (Z_TYPE_P(valid) != IS_BOOL || (Z_TYPE_P(valid) == IS_BOOL && !Z_BVAL_P(valid))) { goto we_e435_0; } PHALCON_INIT_VAR(current); PHALCON_CALL_METHOD(current, items, "current", PH_NO_CHECK); phalcon_array_append(&page_items, current, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(compare); is_smaller_or_equal_function(compare, show, i TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { goto we_e435_0; } PHALCON_SEPARATE(i); increment_function(i); goto ws_e435_0; we_e435_0: if(0){} } phalcon_update_property_zval(page, SL("items"), page_items TSRMLS_CC); phalcon_update_property_long(page, SL("first"), 1 TSRMLS_CC); PHALCON_INIT_VAR(maximum_pages); phalcon_add_function(maximum_pages, start, show TSRMLS_CC); PHALCON_INIT_VAR(compare); is_smaller_function(compare, maximum_pages, n TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 1); PHALCON_INIT_VAR(next); phalcon_add_function(next, page_number, t0 TSRMLS_CC); } else { PHALCON_INIT_VAR(compare); is_equal_function(compare, maximum_pages, n TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { PHALCON_CPY_WRT(next, n); } else { PHALCON_INIT_VAR(possible_pages); div_function(possible_pages, n, show TSRMLS_CC); PHALCON_INIT_VAR(additional_page); phalcon_add_function(additional_page, possible_pages, one TSRMLS_CC); PHALCON_INIT_VAR(next); PHALCON_CALL_FUNC_PARAMS_1(next, "intval", additional_page); } } PHALCON_INIT_VAR(compare); is_smaller_function(compare, total_pages, next TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { PHALCON_CPY_WRT(next, total_pages); } phalcon_update_property_zval(page, SL("next"), next TSRMLS_CC); PHALCON_INIT_VAR(compare); is_smaller_function(compare, one, page_number TSRMLS_CC); if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) { PHALCON_INIT_VAR(before); sub_function(before, page_number, one TSRMLS_CC); } else { PHALCON_INIT_VAR(before); ZVAL_LONG(before, 1); } phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC); phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC); PHALCON_INIT_VAR(remainder); mod_function(remainder, n, show TSRMLS_CC); PHALCON_INIT_VAR(possible_pages); div_function(possible_pages, n, show TSRMLS_CC); if (!phalcon_compare_strict_long(remainder, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(next); phalcon_add_function(next, possible_pages, one TSRMLS_CC); PHALCON_INIT_VAR(pages_total); PHALCON_CALL_FUNC_PARAMS_1(pages_total, "intval", possible_pages); } else { PHALCON_CPY_WRT(pages_total, possible_pages); } phalcon_update_property_zval(page, SL("last"), pages_total TSRMLS_CC); phalcon_update_property_zval(page, SL("total_pages"), pages_total TSRMLS_CC); RETURN_CTOR(page); }
/** * Transforms an intermediate representation for a expression into a database system valid expression * * @param array $expression * @param string $escapeChar * @return string */ PHP_METHOD(Phalcon_Db_Dialect, getSqlExpression){ zval *expression, *escape_char = NULL, *type, *name = NULL, *escaped_name = NULL; zval *domain, *escaped_domain = NULL, *value = NULL, *operator = NULL; zval *left = NULL, *expression_left = NULL, *right = NULL, *expression_right = NULL; zval *binary_expr, *unary_expr = NULL, *expression_group; zval *sql_arguments, *arguments, *argument = NULL, *argument_expression = NULL; zval *arguments_joined, *function_expression = NULL; zval *sql_items, *items, *item = NULL, *item_expression = NULL; zval *list_expression, *group_expression; zval *exception_message; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &expression, &escape_char) == FAILURE) { RETURN_MM_NULL(); } if (!escape_char) { PHALCON_INIT_VAR(escape_char); } else { PHALCON_SEPARATE_PARAM(escape_char); } if (PHALCON_GLOBAL(db).escape_identifiers) { if (Z_TYPE_P(escape_char) == IS_NULL) { PHALCON_OBS_NVAR(escape_char); phalcon_read_property(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC); } } if (Z_TYPE_P(expression) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression"); return; } if (!phalcon_array_isset_string(expression, SS("type"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression"); return; } PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, expression, SL("type"), PH_NOISY_CC); /** * Resolve qualified expressions */ if (PHALCON_IS_STRING(type, "qualified")) { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY_CC); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(escaped_name); PHALCON_CONCAT_VVV(escaped_name, escape_char, name, escape_char); } else { PHALCON_CPY_WRT(escaped_name, name); } /** * A domain could be a table/schema */ if (phalcon_array_isset_string(expression, SS("domain"))) { PHALCON_OBS_VAR(domain); phalcon_array_fetch_string(&domain, expression, SL("domain"), PH_NOISY_CC); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(escaped_domain); PHALCON_CONCAT_VVVSV(escaped_domain, escape_char, domain, escape_char, ".", escaped_name); } else { PHALCON_INIT_NVAR(escaped_domain); PHALCON_CONCAT_VSV(escaped_domain, domain, ".", escaped_name); } RETURN_CTOR(escaped_domain); } RETURN_CCTOR(escaped_name); } /** * Resolve literal expressions */ if (PHALCON_IS_STRING(type, "literal")) { PHALCON_OBS_VAR(value); phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); } /** * Resolve binary operations expressions */ if (PHALCON_IS_STRING(type, "binary-op")) { PHALCON_OBS_VAR(operator); phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY_CC); PHALCON_OBS_VAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC); PHALCON_INIT_VAR(expression_left); PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_OBS_VAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY_CC); PHALCON_INIT_VAR(expression_right); PHALCON_CALL_METHOD_PARAMS_2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_INIT_VAR(binary_expr); PHALCON_CONCAT_VSVSV(binary_expr, expression_left, " ", operator, " ", expression_right); RETURN_CTOR(binary_expr); } /** * Resolve unary operations expressions */ if (PHALCON_IS_STRING(type, "unary-op")) { PHALCON_OBS_NVAR(operator); phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY_CC); /** * Some unary operators uses the left operand... */ if (phalcon_array_isset_string(expression, SS("left"))) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC); PHALCON_INIT_NVAR(expression_left); PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_INIT_VAR(unary_expr); PHALCON_CONCAT_VV(unary_expr, expression_left, operator); RETURN_CTOR(unary_expr); } /** * ...Others uses the right operand */ if (phalcon_array_isset_string(expression, SS("right"))) { PHALCON_OBS_NVAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY_CC); PHALCON_INIT_NVAR(expression_right); PHALCON_CALL_METHOD_PARAMS_2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_INIT_NVAR(unary_expr); PHALCON_CONCAT_VV(unary_expr, operator, expression_right); RETURN_CTOR(unary_expr); } } /** * Resolve placeholder */ if (PHALCON_IS_STRING(type, "placeholder")) { PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); } /** * Resolve parentheses */ if (PHALCON_IS_STRING(type, "parentheses")) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC); PHALCON_INIT_NVAR(expression_left); PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_INIT_VAR(expression_group); PHALCON_CONCAT_SVS(expression_group, "(", expression_left, ")"); RETURN_CTOR(expression_group); } /** * Resolve function calls */ if (PHALCON_IS_STRING(type, "functionCall")) { PHALCON_OBS_NVAR(name); phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY_CC); PHALCON_INIT_VAR(sql_arguments); array_init(sql_arguments); if (phalcon_array_isset_string(expression, SS("arguments"))) { PHALCON_OBS_VAR(arguments); phalcon_array_fetch_string(&arguments, expression, SL("arguments"), PH_NOISY_CC); if (!phalcon_is_iterable(arguments, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(argument); PHALCON_INIT_NVAR(argument_expression); PHALCON_CALL_METHOD_PARAMS_2(argument_expression, this_ptr, "getsqlexpression", argument, escape_char); phalcon_array_append(&sql_arguments, argument_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(arguments_joined); phalcon_fast_join_str(arguments_joined, SL(", "), sql_arguments TSRMLS_CC); PHALCON_INIT_VAR(function_expression); PHALCON_CONCAT_VSVS(function_expression, name, "(", arguments_joined, ")"); } else { PHALCON_INIT_NVAR(function_expression); PHALCON_CONCAT_VS(function_expression, name, "()"); } RETURN_CTOR(function_expression); } /** * Resolve lists */ if (PHALCON_IS_STRING(type, "list")) { PHALCON_INIT_VAR(sql_items); array_init(sql_items); PHALCON_OBS_VAR(items); phalcon_array_fetch_long(&items, expression, 0, PH_NOISY_CC); if (!phalcon_is_iterable(items, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(item); PHALCON_INIT_NVAR(item_expression); PHALCON_CALL_METHOD_PARAMS_2(item_expression, this_ptr, "getsqlexpression", item, escape_char); phalcon_array_append(&sql_items, item_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(list_expression); phalcon_fast_join_str(list_expression, SL(", "), sql_items TSRMLS_CC); PHALCON_INIT_VAR(group_expression); PHALCON_CONCAT_SVS(group_expression, "(", list_expression, ")"); RETURN_CTOR(group_expression); } /** * Resolve * */ if (PHALCON_IS_STRING(type, "all")) { PHALCON_MM_RESTORE(); RETURN_STRING("*", 1); } /** * Expression type wasn't found */ PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Invalid SQL expression type '", type, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message); return; }
/** * Generates SQL to add the table creation options * * @param array $definition * @return array */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, _getTableOptions){ zval *definition = NULL, *table_options = NULL, *engine = NULL, *sql_engine = NULL; zval *auto_increment = NULL, *sql_autoincrement = NULL; zval *table_collation = NULL, *collation_parts = NULL, *sql_charset = NULL; zval *sql_collate = NULL, *number_options = NULL, *sql_table_options = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL; zval *c0 = NULL, *c1 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(table_options); array_init(table_options); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r0, SL("ENGINE")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC); PHALCON_INIT_VAR(engine); phalcon_array_fetch_string(&engine, r1, SL("ENGINE"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, definition, SL("options"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, r2, SL("ENGINE"), PH_NOISY_CC); if (zend_is_true(r3)) { PHALCON_INIT_VAR(sql_engine); PHALCON_CONCAT_SV(sql_engine, "ENGINE=", engine); phalcon_array_append(&table_options, sql_engine, PH_SEPARATE TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_string(&r4, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r4, SL("AUTO_INCREMENT")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r5); phalcon_array_fetch_string(&r5, definition, SL("options"), PH_NOISY_CC); PHALCON_INIT_VAR(auto_increment); phalcon_array_fetch_string(&auto_increment, r5, SL("AUTO_INCREMENT"), PH_NOISY_CC); if (zend_is_true(auto_increment)) { PHALCON_INIT_VAR(sql_autoincrement); PHALCON_CONCAT_SV(sql_autoincrement, "AUTO_INCREMENT=", auto_increment); phalcon_array_append(&table_options, sql_autoincrement, PH_SEPARATE TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_string(&r6, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r6, SL("TABLE_COLLATION")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r7); phalcon_array_fetch_string(&r7, definition, SL("options"), PH_NOISY_CC); PHALCON_INIT_VAR(table_collation); phalcon_array_fetch_string(&table_collation, r7, SL("TABLE_COLLATION"), PH_NOISY_CC); if (zend_is_true(table_collation)) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "_", 1); PHALCON_INIT_VAR(collation_parts); phalcon_fast_explode(collation_parts, c0, table_collation TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_long(&r8, collation_parts, 0, PH_NOISY_CC); PHALCON_INIT_VAR(sql_charset); PHALCON_CONCAT_SV(sql_charset, "DEFAULT CHARSET=", r8); phalcon_array_append(&table_options, sql_charset, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(sql_collate); PHALCON_CONCAT_SV(sql_collate, "COLLATE=", table_collation); phalcon_array_append(&table_options, sql_collate, PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_VAR(number_options); phalcon_fast_count(number_options, table_options TSRMLS_CC); if (!phalcon_compare_strict_long(number_options, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, " ", 1); PHALCON_INIT_VAR(sql_table_options); phalcon_fast_join(sql_table_options, c1, table_options TSRMLS_CC); RETURN_CTOR(sql_table_options); } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Returns a slice of the resultset to show in the pagination * * @return stdClass */ PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){ zval *v0 = NULL, *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL, *v5 = NULL, *v6 = NULL; zval *v7 = NULL, *v8 = NULL, *v9 = NULL, *v10 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL; zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL, *t11 = NULL, *t12 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL; zval *r21 = NULL, *r22 = NULL, *r23 = NULL, *r24 = NULL, *r25 = NULL, *r26 = NULL, *r27 = NULL; zval *r28 = NULL; zval *i0 = NULL, *i1 = NULL, *i2 = NULL; zval *a0 = NULL; zval *p2[] = { NULL }, *p3[] = { NULL }, *p4[] = { NULL }, *p5[] = { NULL }; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_limitRows", sizeof("_limitRows")-1, PHALCON_NOISY_FETCH TSRMLS_CC); PHALCON_CPY_WRT(v0, t0); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_config", sizeof("_config")-1, PHALCON_NOISY_FETCH TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, t1, "data", strlen("data"), PHALCON_NOISY_FETCH TSRMLS_CC); PHALCON_CPY_WRT(v1, r0); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_page", sizeof("_page")-1, PHALCON_NOISY_FETCH TSRMLS_CC); PHALCON_CPY_WRT(v2, t2); if (Z_TYPE_P(v2) == IS_NULL) { PHALCON_INIT_VAR(v2); ZVAL_LONG(v2, 1); } PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_1(r1, "count", v1, 0x008); PHALCON_CPY_WRT(v3, r1); PHALCON_ALLOC_ZVAL_MM(i0); object_init(i0); PHALCON_CPY_WRT(v4, i0); PHALCON_INIT_VAR(t3); ZVAL_LONG(t3, 1); PHALCON_ALLOC_ZVAL_MM(r2); sub_function(r2, v2, t3 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); mul_function(r3, v0, r2 TSRMLS_CC); PHALCON_CPY_WRT(v5, r3); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_INIT_VAR(t4); ZVAL_LONG(t4, 1); PHALCON_ALLOC_ZVAL_MM(r5); sub_function(r5, v3, t4 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r6); div_function(r6, r5, v0 TSRMLS_CC); Z_ADDREF_P(r6); PHALCON_CALL_FUNC_PARAMS_1(r4, "ceil", r6, 0x00D); Z_DELREF_P(r6); PHALCON_CPY_WRT(v6, r4); if (Z_TYPE_P(v1) != IS_OBJECT) { PHALCON_ALLOC_ZVAL_MM(i1); object_init_ex(i1, phalcon_paginator_exception_class_entry); PHALCON_INIT_VAR(p2[0]); ZVAL_STRING(p2[0], "Invalid data for paginator", 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(i1, "__construct", 1, p2, PHALCON_CALL_CHECK); zend_throw_exception_object(i1 TSRMLS_CC); Z_ADDREF_P(i1); PHALCON_MM_RESTORE(); return; } if (Z_TYPE_P(v2) == IS_NULL) { PHALCON_INIT_VAR(v2); ZVAL_LONG(v2, 0); } PHALCON_INIT_VAR(t5); ZVAL_LONG(t5, 0); PHALCON_INIT_VAR(r7); is_smaller_function(r7, v5, t5 TSRMLS_CC); if (zend_is_true(r7)) { PHALCON_ALLOC_ZVAL_MM(i2); object_init_ex(i2, phalcon_paginator_exception_class_entry); PHALCON_INIT_VAR(p3[0]); ZVAL_STRING(p3[0], "The start page number is zero or less", 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(i2, "__construct", 1, p3, PHALCON_CALL_CHECK); zend_throw_exception_object(i2 TSRMLS_CC); Z_ADDREF_P(i2); PHALCON_MM_RESTORE(); return; } PHALCON_INIT_VAR(a0); array_init(a0); phalcon_update_property_zval(v4, "items", strlen("items"), a0 TSRMLS_CC); PHALCON_INIT_VAR(t6); ZVAL_LONG(t6, 0); PHALCON_INIT_VAR(r8); is_smaller_function(r8, t6, v3 TSRMLS_CC); if (zend_is_true(r8)) { PHALCON_INIT_VAR(r9); is_smaller_or_equal_function(r9, v5, v3 TSRMLS_CC); if (zend_is_true(r9)) { Z_ADDREF_P(v5); p4[0] = v5; PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p4, PHALCON_CALL_DEFAULT); Z_DELREF_P(p4[0]); } else { PHALCON_INIT_VAR(p5[0]); ZVAL_LONG(p5[0], 1); PHALCON_CALL_METHOD_PARAMS_NORETURN(v1, "seek", 1, p5, PHALCON_CALL_DEFAULT); PHALCON_INIT_VAR(v2); ZVAL_LONG(v2, 1); } PHALCON_INIT_VAR(v7); ZVAL_LONG(v7, 1); ws_e435_0: PHALCON_INIT_VAR(r10); PHALCON_CALL_METHOD(r10, v1, "valid", PHALCON_CALL_DEFAULT); if (!zend_is_true(r10)) { goto we_e435_0; } PHALCON_INIT_VAR(r11); PHALCON_CALL_METHOD(r11, v1, "current", PHALCON_CALL_DEFAULT); PHALCON_INIT_VAR(t7); phalcon_read_property(&t7, v4, "items", sizeof("items")-1, PHALCON_NOISY_FETCH TSRMLS_CC); Z_ADDREF_P(r11); phalcon_array_append(t7, r11 TSRMLS_CC); phalcon_update_property_zval(v4, "items", strlen("items"), t7 TSRMLS_CC); PHALCON_INIT_VAR(r12); is_smaller_or_equal_function(r12, v0, v7 TSRMLS_CC); if (zend_is_true(r12)) { goto we_e435_0; } PHALCON_SEPARATE(v7); increment_function(v7); goto ws_e435_0; we_e435_0: if(0) { }; } phalcon_update_property_long(v4, "first", strlen("first"), 1 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r13); phalcon_add_function(r13, v5, v0 TSRMLS_CC); PHALCON_INIT_VAR(r14); is_smaller_function(r14, r13, v3 TSRMLS_CC); if (zend_is_true(r14)) { PHALCON_INIT_VAR(t8); ZVAL_LONG(t8, 1); PHALCON_ALLOC_ZVAL_MM(r15); phalcon_add_function(r15, v2, t8 TSRMLS_CC); PHALCON_CPY_WRT(v8, r15); } else { PHALCON_ALLOC_ZVAL_MM(r16); phalcon_add_function(r16, v5, v0 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r17); is_equal_function(r17, r16, v3 TSRMLS_CC); if (zend_is_true(r17)) { PHALCON_CPY_WRT(v8, v3); } else { PHALCON_ALLOC_ZVAL_MM(r18); PHALCON_ALLOC_ZVAL_MM(r19); div_function(r19, v3, v0 TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_1(r18, "intval", r19, 0x00E); PHALCON_INIT_VAR(t9); ZVAL_LONG(t9, 1); PHALCON_ALLOC_ZVAL_MM(r20); phalcon_add_function(r20, r18, t9 TSRMLS_CC); PHALCON_CPY_WRT(v8, r20); } } PHALCON_INIT_VAR(r21); is_smaller_function(r21, v6, v8 TSRMLS_CC); if (zend_is_true(r21)) { PHALCON_CPY_WRT(v8, v6); } phalcon_update_property_zval(v4, "next", strlen("next"), v8 TSRMLS_CC); PHALCON_INIT_VAR(t10); ZVAL_LONG(t10, 1); PHALCON_INIT_VAR(r22); is_smaller_function(r22, t10, v2 TSRMLS_CC); if (zend_is_true(r22)) { PHALCON_INIT_VAR(t11); ZVAL_LONG(t11, 1); PHALCON_ALLOC_ZVAL_MM(r23); sub_function(r23, v2, t11 TSRMLS_CC); PHALCON_CPY_WRT(v9, r23); } else { PHALCON_INIT_VAR(v9); ZVAL_LONG(v9, 1); } phalcon_update_property_zval(v4, "before", strlen("before"), v9 TSRMLS_CC); phalcon_update_property_zval(v4, "current", strlen("current"), v2 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r24); mod_function(r24, v3, v0 TSRMLS_CC); if (zend_is_true(r24)) { PHALCON_ALLOC_ZVAL_MM(r25); PHALCON_ALLOC_ZVAL_MM(r26); div_function(r26, v3, v0 TSRMLS_CC); PHALCON_CALL_FUNC_PARAMS_1(r25, "intval", r26, 0x00E); PHALCON_INIT_VAR(t12); ZVAL_LONG(t12, 1); PHALCON_ALLOC_ZVAL_MM(r27); phalcon_add_function(r27, r25, t12 TSRMLS_CC); PHALCON_CPY_WRT(v10, r27); } else { PHALCON_ALLOC_ZVAL_MM(r28); div_function(r28, v3, v0 TSRMLS_CC); PHALCON_CPY_WRT(v10, r28); } phalcon_update_property_zval(v4, "last", strlen("last"), v10 TSRMLS_CC); phalcon_update_property_zval(v4, "total_pages", strlen("total_pages"), v10 TSRMLS_CC); PHALCON_RETURN_CTOR(v4); }
/** * Generates SQL to create a table in MySQL * * @param string $tableName * @param string $schemaName * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable){ zval *table_name = NULL, *schema_name = NULL, *definition = NULL; zval *table = NULL, *temporary = NULL, *sql = NULL, *create_lines = NULL, *columns = NULL; zval *column = NULL, *column_name = NULL, *column_definition = NULL; zval *column_line = NULL, *attribute = NULL, *indexes = NULL, *index = NULL; zval *index_name = NULL, *column_list = NULL, *index_sql = NULL, *references = NULL; zval *reference = NULL, *name = NULL, *referenced_table = NULL, *referenced_columns = NULL; zval *constaint_sql = NULL, *reference_sql = NULL, *joined_lines = NULL; zval *options = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *t0 = NULL, *t1 = NULL; zval *c0 = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } eval_int = phalcon_array_isset_string(definition, SL("columns")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVSVS(table, "`", schema_name, "`.`", table_name, "`"); } else { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVS(table, "`", table_name, "`"); } PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 0); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r0, SL("temporary")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, r1, SL("temporary"), PH_NOISY_CC); if (zend_is_true(r2)) { PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 1); } } } if (Z_TYPE_P(temporary) == IS_BOOL && Z_BVAL_P(temporary)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TEMPORARY TABLE ", table, " (\n\t"); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TABLE ", table, " (\n\t"); } PHALCON_INIT_VAR(create_lines); array_init(create_lines); PHALCON_INIT_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC); if (!phalcon_valid_foreach(columns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_52be_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_52be_2; } PHALCON_INIT_VAR(column); ZVAL_ZVAL(column, *hd, 1, 0); PHALCON_INIT_VAR(column_name); PHALCON_CALL_METHOD(column_name, column, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(column_definition); PHALCON_CALL_METHOD_PARAMS_1(column_definition, this_ptr, "getcolumndefinition", column, PH_NO_CHECK); PHALCON_INIT_VAR(column_line); PHALCON_CONCAT_SVSV(column_line, "`", column_name, "` ", column_definition); PHALCON_INIT_VAR(attribute); PHALCON_CALL_METHOD(attribute, column, "isnotnull", PH_NO_CHECK); if (zend_is_true(attribute)) { PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, " NOT NULL", 1); phalcon_concat_self(&column_line, t0 TSRMLS_CC); } PHALCON_INIT_VAR(attribute); PHALCON_CALL_METHOD(attribute, column, "isautoincrement", PH_NO_CHECK); if (zend_is_true(attribute)) { PHALCON_INIT_VAR(t1); ZVAL_STRING(t1, " AUTO_INCREMENT", 1); phalcon_concat_self(&column_line, t1 TSRMLS_CC); } phalcon_array_append(&create_lines, column_line, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_52be_2; fee_52be_2: eval_int = phalcon_array_isset_string(definition, SL("indexes")+1); if (eval_int) { PHALCON_INIT_VAR(indexes); phalcon_array_fetch_string(&indexes, definition, SL("indexes"), PH_NOISY_CC); if (!phalcon_valid_foreach(indexes TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(indexes); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_52be_3: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_52be_3; } PHALCON_INIT_VAR(index); ZVAL_ZVAL(index, *hd, 1, 0); PHALCON_INIT_VAR(index_name); PHALCON_CALL_METHOD(index_name, index, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD(columns, index, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK); if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) { PHALCON_INIT_VAR(index_sql); PHALCON_CONCAT_SVS(index_sql, "PRIMARY KEY (", column_list, ")"); } else { PHALCON_INIT_VAR(index_sql); PHALCON_CONCAT_SVSVS(index_sql, "KEY `", index_name, "` (", column_list, ")"); } phalcon_array_append(&create_lines, index_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto fes_52be_3; fee_52be_3: if(0){} } eval_int = phalcon_array_isset_string(definition, SL("references")+1); if (eval_int) { PHALCON_INIT_VAR(references); phalcon_array_fetch_string(&references, definition, SL("references"), PH_NOISY_CC); if (!phalcon_valid_foreach(references TSRMLS_CC)) { return; } ah2 = Z_ARRVAL_P(references); zend_hash_internal_pointer_reset_ex(ah2, &hp2); fes_52be_4: if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){ goto fee_52be_4; } PHALCON_INIT_VAR(reference); ZVAL_ZVAL(reference, *hd, 1, 0); PHALCON_INIT_VAR(name); PHALCON_CALL_METHOD(name, reference, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD(columns, reference, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_table); PHALCON_CALL_METHOD(referenced_table, reference, "getreferencedtable", PH_NO_CHECK); PHALCON_INIT_VAR(referenced_columns); PHALCON_CALL_METHOD(referenced_columns, reference, "getreferencedcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", referenced_columns, PH_NO_CHECK); PHALCON_INIT_VAR(constaint_sql); PHALCON_CONCAT_SVSVS(constaint_sql, "CONSTRAINT `", name, "` FOREIGN KEY (", column_list, ")"); PHALCON_INIT_VAR(reference_sql); PHALCON_CONCAT_VSVSVS(reference_sql, constaint_sql, " REFERENCES `", referenced_table, "`(", column_list, ")"); phalcon_array_append(&create_lines, reference_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); goto fes_52be_4; fee_52be_4: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ",\n\t", 1); PHALCON_INIT_VAR(joined_lines); phalcon_fast_join(joined_lines, c0, create_lines TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CONCAT_VS(r3, joined_lines, "\n)"); phalcon_concat_self(&sql, r3 TSRMLS_CC); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_INIT_VAR(options); PHALCON_CALL_METHOD_PARAMS_1(options, this_ptr, "_gettableoptions", definition, PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CONCAT_SV(r4, " ", options); phalcon_concat_self(&sql, r4 TSRMLS_CC); } RETURN_CTOR(sql); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_File, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *last_key = NULL, *prefix, *filtered, *frontend, *options; zval *cache_dir, *cache_file, *cached_content = NULL; zval *prepared_content, *is_buffering; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!key_name) { PHALCON_INIT_NVAR(key_name); } if (!content) { PHALCON_INIT_NVAR(content); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } if (!stop_buffer) { PHALCON_INIT_NVAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (Z_TYPE_P(key_name) == IS_NULL) { PHALCON_INIT_VAR(last_key); phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_NVAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, filtered); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, last_key); if (!zend_is_true(content)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_METHOD(cached_content, frontend, "getcontent", PH_NO_CHECK); } else { PHALCON_CPY_WRT(cached_content, content); } /** * We use file_put_contents to repect open-base-dir directive */ PHALCON_INIT_VAR(prepared_content); PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content, PH_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content); PHALCON_INIT_VAR(is_buffering); PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering", PH_NO_CHECK); if (PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD_NORETURN(frontend, "stop", PH_NO_CHECK); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns an array of prepared attributes for Phalcon\Tag helpers * according to the element's parameters * * @param array $attributes * @param boolean $useChecked * @return array */ PHP_METHOD(Phalcon_Forms_Element, prepareAttributes){ zval *attributes = NULL, *use_checked = NULL, *name, *widget_attributes = NULL; zval *default_attributes, *merged_attributes = NULL; zval *value, *current_value; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, &attributes, &use_checked); if (!attributes) { PHALCON_INIT_VAR(attributes); } if (!use_checked) { PHALCON_INIT_VAR(use_checked); ZVAL_BOOL(use_checked, 0); } PHALCON_OBS_VAR(name); phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC); /** * Create an array of parameters */ if (Z_TYPE_P(attributes) != IS_ARRAY) { PHALCON_INIT_VAR(widget_attributes); array_init(widget_attributes); } else { PHALCON_CPY_WRT(widget_attributes, attributes); } phalcon_array_update_long(&widget_attributes, 0, &name, PH_COPY | PH_SEPARATE TSRMLS_CC); /** * Merge passed parameters with default ones */ PHALCON_OBS_VAR(default_attributes); phalcon_read_property_this(&default_attributes, this_ptr, SL("_attributes"), PH_NOISY_CC); if (Z_TYPE_P(default_attributes) == IS_ARRAY) { PHALCON_INIT_VAR(merged_attributes); phalcon_fast_array_merge(merged_attributes, &default_attributes, &widget_attributes TSRMLS_CC); } else { PHALCON_CPY_WRT(merged_attributes, widget_attributes); } /** * Get the current element's value */ PHALCON_INIT_VAR(value); phalcon_call_method(value, this_ptr, "getvalue"); /** * If the widget has a value set it as default value */ if (Z_TYPE_P(value) != IS_NULL) { if (zend_is_true(use_checked)) { /** * Check if the element already has a default value, compare it with the one in the * attributes, if they are the same mark the element as checked */ if (phalcon_array_isset_string(merged_attributes, SS("value"))) { PHALCON_OBS_VAR(current_value); phalcon_array_fetch_string(¤t_value, merged_attributes, SL("value"), PH_NOISY_CC); if (PHALCON_IS_EQUAL(current_value, value)) { phalcon_array_update_string_string(&merged_attributes, SL("checked"), SL("checked"), PH_SEPARATE TSRMLS_CC); } } else { /** * Evaluate the current value and mark the check as checked */ if (zend_is_true(value)) { phalcon_array_update_string_string(&merged_attributes, SL("checked"), SL("checked"), PH_SEPARATE TSRMLS_CC); } phalcon_array_update_string(&merged_attributes, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC); } } else { phalcon_array_update_string(&merged_attributes, SL("value"), &value, PH_COPY | PH_SEPARATE TSRMLS_CC); } } RETURN_CCTOR(merged_attributes); }
/** * Builds a HTML TEXTAREA tag * *<code> * echo Phalcon\Tag::textArea(array("comments", "cols" => 10, "rows" => 4)) *</code> * * Volt syntax: *<code> * {{ text_area("comments", "cols": 10, "rows": 4) }} *</code> * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, textArea){ zval *parameters, *params = NULL, *id = NULL, *name, *content = NULL, *code; zval *avalue = NULL, *key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, ¶meters); if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 1); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } if (!phalcon_array_isset_long(params, 0)) { if (phalcon_array_isset_string(params, SS("id"))) { PHALCON_OBS_VAR(id); phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC); phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } } PHALCON_OBS_NVAR(id); phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC); if (!phalcon_array_isset_string(params, SS("name"))) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC); if (!zend_is_true(name)) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } } if (!phalcon_array_isset_string(params, SS("id"))) { phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (phalcon_array_isset_string(params, SS("value"))) { PHALCON_OBS_VAR(content); phalcon_array_fetch_string(&content, params, SL("value"), PH_NOISY_CC); phalcon_array_unset_string(¶ms, SS("value"), PH_SEPARATE); } else { PHALCON_INIT_NVAR(content); PHALCON_CALL_SELF_PARAMS_2(content, this_ptr, "getvalue", id, params); } PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<textarea", 1); 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(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(avalue); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\""); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_SCONCAT_SVS(code, ">", content, "</textarea>"); RETURN_CTOR(code); }
/** * Lists table indexes * * @param string $table * @param string $schema * @return Phalcon_Db_Index[] */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, describeIndexes){ zval *table = NULL, *schema = NULL, *sql = NULL, *describe = NULL, *indexes = NULL, *index = NULL; zval *key_name = NULL, *index_objects = NULL, *index_columns = NULL; zval *name = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL; zval *t0 = NULL; zval *a0 = NULL, *a1 = NULL, *a2 = NULL; zval *i0 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_INIT_VAR(schema); ZVAL_NULL(schema); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_STATIC_PARAMS_2(r0, "phalcon_db_dialect_mysql", "describeindexes", table, schema); PHALCON_CPY_WRT(sql, r0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 1); PHALCON_CALL_METHOD_PARAMS_2(r1, this_ptr, "fetchall", sql, t0, PHALCON_NO_CHECK); PHALCON_CPY_WRT(describe, r1); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(indexes, a0); if (phalcon_valid_foreach(describe TSRMLS_CC)) { ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_321f_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_321f_2; } PHALCON_INIT_VAR(index); ZVAL_ZVAL(index, *hd, 1, 0); PHALCON_INIT_VAR(r2); phalcon_array_fetch_string(&r2, index, SL("Key_name"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(key_name, r2); eval_int = phalcon_array_isset(indexes, key_name); if (!eval_int) { PHALCON_INIT_VAR(a1); array_init(a1); phalcon_array_update(&indexes, key_name, &a1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } PHALCON_INIT_VAR(r3); phalcon_array_fetch_string(&r3, index, SL("Column_name"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update_multi_append_2(&indexes, key_name, r3, PHALCON_NO_SEPARATE_THX TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_321f_2; fee_321f_2: if(0){} } else { return; } PHALCON_INIT_VAR(a2); array_init(a2); PHALCON_CPY_WRT(index_objects, a2); if (phalcon_valid_foreach(indexes TSRMLS_CC)) { ah1 = Z_ARRVAL_P(indexes); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_321f_3: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_321f_3; } else { PHALCON_INIT_VAR(name); PHALCON_GET_FOREACH_KEY(name, ah1, hp1); } PHALCON_INIT_VAR(index_columns); ZVAL_ZVAL(index_columns, *hd, 1, 0); PHALCON_INIT_VAR(i0); object_init_ex(i0, phalcon_db_index_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", name, index_columns, PHALCON_CHECK); phalcon_array_update(&index_objects, name, &i0, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto fes_321f_3; fee_321f_3: if(0){} } else { return; } RETURN_CTOR(index_objects); }
/** * Builds a LINK[rel="stylesheet"] tag * * <code> * echo Phalcon\Tag::stylesheetLink("http://fonts.googleapis.com/css?family=Rosario", false); * echo Phalcon\Tag::stylesheetLink("css/style.css"); * </code> * * Volt Syntax: *<code> * {{ stylesheet_link("http://fonts.googleapis.com/css?family=Rosario", false) }} * {{ stylesheet_link("css/style.css") }} *</code> * * @param array $parameters * @param boolean $local * @return string */ PHP_METHOD(Phalcon_Tag, stylesheetLink){ zval *parameters = NULL, *local = NULL, *params = NULL, *first_param; zval *url, *url_href, *href, *code, *value = NULL, *key = NULL, *five; zval *doctype, *eol, *is_xhtml; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, ¶meters, &local); if (!parameters) { PHALCON_INIT_VAR(parameters); } if (!local) { PHALCON_INIT_VAR(local); ZVAL_BOOL(local, 1); } else { PHALCON_SEPARATE_PARAM(local); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 2); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); phalcon_array_append(¶ms, local, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } if (!phalcon_array_isset_string(params, SS("href"))) { if (phalcon_array_isset_long(params, 0)) { PHALCON_OBS_VAR(first_param); phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC); phalcon_array_update_string(¶ms, SL("href"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_string(¶ms, SL("href"), SL(""), PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_NVAR(local); ZVAL_STRING(local, "", 1); if (phalcon_array_isset_long(params, 1)) { PHALCON_OBS_NVAR(local); phalcon_array_fetch_long(&local, params, 1, PH_NOISY_CC); } else { if (phalcon_array_isset_string(params, SS("local"))) { PHALCON_OBS_NVAR(local); phalcon_array_fetch_string(&local, params, SL("local"), PH_NOISY_CC); phalcon_array_unset_string(¶ms, SS("local"), PH_SEPARATE); } } if (!phalcon_array_isset_string(params, SS("type"))) { phalcon_array_update_string_string(¶ms, SL("type"), SL("text/css"), PH_SEPARATE TSRMLS_CC); } if (zend_is_true(local)) { PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); PHALCON_OBS_VAR(url_href); phalcon_array_fetch_string(&url_href, params, SL("href"), PH_NOISY_CC); PHALCON_INIT_VAR(href); PHALCON_CALL_METHOD_PARAMS_1(href, url, "get", url_href); phalcon_array_update_string(¶ms, SL("href"), &href, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<link rel=\"stylesheet\"", 1); 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(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\""); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(five); ZVAL_LONG(five, 5); PHALCON_OBS_VAR(doctype); phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC); PHALCON_INIT_VAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); /** * Check if Doctype is XHTML */ PHALCON_INIT_VAR(is_xhtml); is_smaller_function(is_xhtml, five, doctype TSRMLS_CC); if (zend_is_true(is_xhtml)) { PHALCON_SCONCAT_SV(code, " />", eol); } else { PHALCON_SCONCAT_SV(code, ">", eol); } RETURN_CTOR(code); }
/** * Lists table references * * @param string $table * @param string $schema * @return Phalcon_Db_Reference[] */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, describeReferences){ zval *table = NULL, *schema = NULL, *sql = NULL, *references = NULL, *describe = NULL; zval *reference = NULL, *constraint_name = NULL, *reference_objects = NULL; zval *array_reference = NULL, *name = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL; zval *a0 = NULL, *a1 = NULL, *a2 = NULL, *a3 = NULL, *a4 = NULL, *a5 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; zval *i0 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_INIT_VAR(schema); ZVAL_NULL(schema); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_STATIC_PARAMS_2(r0, "phalcon_db_dialect_mysql", "describereferences", table, schema); PHALCON_CPY_WRT(sql, r0); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(references, a0); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 1); PHALCON_CALL_METHOD_PARAMS_2(r1, this_ptr, "fetchall", sql, t0, PHALCON_NO_CHECK); PHALCON_CPY_WRT(describe, r1); if (phalcon_valid_foreach(describe TSRMLS_CC)) { ah0 = Z_ARRVAL_P(describe); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_321f_4: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_321f_4; } PHALCON_INIT_VAR(reference); ZVAL_ZVAL(reference, *hd, 1, 0); PHALCON_INIT_VAR(r2); phalcon_array_fetch_string(&r2, reference, SL("CONSTRAINT_NAME"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(constraint_name, r2); eval_int = phalcon_array_isset(references, constraint_name); if (!eval_int) { PHALCON_INIT_VAR(a1); array_init(a1); PHALCON_INIT_VAR(r3); phalcon_array_fetch_string(&r3, reference, SL("REFERENCED_TABLE_SCHEMA"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update_string(&a1, SL("referencedSchema"), &r3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(r4); phalcon_array_fetch_string(&r4, reference, SL("REFERENCED_TABLE_NAME"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update_string(&a1, SL("referencedTable"), &r4, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(a2); array_init(a2); phalcon_array_update_string(&a1, SL("columns"), &a2, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(a3); array_init(a3); phalcon_array_update_string(&a1, SL("referencedColumns"), &a3, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); phalcon_array_update(&references, constraint_name, &a1, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } PHALCON_INIT_VAR(r5); phalcon_array_fetch_string(&r5, reference, SL("COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC); if (Z_TYPE_P(references) == IS_ARRAY) { PHALCON_INIT_VAR(t1); phalcon_array_fetch(&t1, references, constraint_name, PHALCON_SILENT TSRMLS_CC); } if (Z_REFCOUNT_P(t1) > 1) { phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC); } if (Z_TYPE_P(t1) != IS_ARRAY) { convert_to_array(t1); phalcon_array_update(&references, constraint_name, &t1, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } if (Z_TYPE_P(t1) == IS_ARRAY) { PHALCON_INIT_VAR(t2); phalcon_array_fetch_string(&t2, t1, SL("columns"), PHALCON_SILENT TSRMLS_CC); } if (Z_REFCOUNT_P(t2) > 1) { phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC); } if (Z_TYPE_P(t2) != IS_ARRAY) { convert_to_array(t2); phalcon_array_update_string(&t1, SL("columns"), &t2, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } phalcon_array_append(&t2, r5, PHALCON_NO_SEPARATE_THX TSRMLS_CC); PHALCON_INIT_VAR(r6); phalcon_array_fetch_string(&r6, reference, SL("REFERENCED_COLUMN_NAME"), PHALCON_NOISY TSRMLS_CC); if (Z_TYPE_P(references) == IS_ARRAY) { PHALCON_INIT_VAR(t3); phalcon_array_fetch(&t3, references, constraint_name, PHALCON_SILENT TSRMLS_CC); } if (Z_REFCOUNT_P(t3) > 1) { phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC); } if (Z_TYPE_P(t3) != IS_ARRAY) { convert_to_array(t3); phalcon_array_update(&references, constraint_name, &t3, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } if (Z_TYPE_P(t3) == IS_ARRAY) { PHALCON_INIT_VAR(t4); phalcon_array_fetch_string(&t4, t3, SL("referencedColumns"), PHALCON_SILENT TSRMLS_CC); } if (Z_REFCOUNT_P(t4) > 1) { phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_CTOR TSRMLS_CC); } if (Z_TYPE_P(t4) != IS_ARRAY) { convert_to_array(t4); phalcon_array_update_string(&t3, SL("referencedColumns"), &t4, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } phalcon_array_append(&t4, r6, PHALCON_NO_SEPARATE_THX TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_321f_4; fee_321f_4: if(0){} } else { return; } PHALCON_INIT_VAR(a4); array_init(a4); PHALCON_CPY_WRT(reference_objects, a4); if (phalcon_valid_foreach(references TSRMLS_CC)) { ah1 = Z_ARRVAL_P(references); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_321f_5: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_321f_5; } else { PHALCON_INIT_VAR(name); PHALCON_GET_FOREACH_KEY(name, ah1, hp1); } PHALCON_INIT_VAR(array_reference); ZVAL_ZVAL(array_reference, *hd, 1, 0); PHALCON_INIT_VAR(i0); object_init_ex(i0, phalcon_db_reference_ce); PHALCON_INIT_VAR(a5); array_init(a5); PHALCON_INIT_VAR(r7); phalcon_array_fetch_string(&r7, array_reference, SL("referencedSchema"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update_string(&a5, SL("referencedSchema"), &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(r8); phalcon_array_fetch_string(&r8, array_reference, SL("referencedTable"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update_string(&a5, SL("referencedTable"), &r8, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(r9); phalcon_array_fetch_string(&r9, array_reference, SL("columns"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update_string(&a5, SL("columns"), &r9, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_INIT_VAR(r10); phalcon_array_fetch_string(&r10, array_reference, SL("referencedColumns"), PHALCON_NOISY TSRMLS_CC); phalcon_array_update_string(&a5, SL("referencedColumns"), &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(i0, "__construct", name, a5, PHALCON_CHECK); phalcon_array_update(&reference_objects, name, &i0, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto fes_321f_5; fee_321f_5: if(0){} } else { return; } RETURN_CTOR(reference_objects); }
/** * Builds HTML IMG tags * * <code> * echo Phalcon\Tag::image("img/bg.png"); * echo Phalcon\Tag::image(array("img/photo.jpg", "alt" => "Some Photo")); * </code> * * Volt Syntax: * <code> * {{ image("img/bg.png") }} * {{ image("img/photo.jpg", "alt": "Some Photo") }} * </code> * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, image){ zval *parameters = NULL, *params = NULL, *first_param, *url, *url_src; zval *src, *code, *value = NULL, *key = NULL, *five, *doctype, *is_xhtml; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, ¶meters); if (!parameters) { PHALCON_INIT_VAR(parameters); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 1); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } if (!phalcon_array_isset_string(params, SS("src"))) { if (phalcon_array_isset_long(params, 0)) { PHALCON_OBS_VAR(first_param); phalcon_array_fetch_long(&first_param, params, 0, PH_NOISY_CC); phalcon_array_update_string(¶ms, SL("src"), &first_param, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { phalcon_array_update_string_string(¶ms, SL("src"), SL(""), PH_SEPARATE TSRMLS_CC); } } PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); PHALCON_OBS_VAR(url_src); phalcon_array_fetch_string(&url_src, params, SL("src"), PH_NOISY_CC); PHALCON_INIT_VAR(src); PHALCON_CALL_METHOD_PARAMS_1(src, url, "get", url_src); phalcon_array_update_string(¶ms, SL("src"), &src, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<img", 1); 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(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", value, "\""); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(five); ZVAL_LONG(five, 5); PHALCON_OBS_VAR(doctype); phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC); /** * Check if Doctype is XHTML */ PHALCON_INIT_VAR(is_xhtml); is_smaller_function(is_xhtml, five, doctype TSRMLS_CC); if (zend_is_true(is_xhtml)) { phalcon_concat_self_str(&code, SL(" />") TSRMLS_CC); } else { phalcon_concat_self_str(&code, SL(">") TSRMLS_CC); } RETURN_CTOR(code); }
/** * Generates SQL to create a table in MySQL * * @param string $tableName * @param string $schemaName * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable){ zval *table_name = NULL, *schema_name = NULL, *definition = NULL; zval *table = NULL, *temporary = NULL, *sql = NULL, *create_lines = NULL, *column = NULL; zval *column_line = NULL, *index = NULL, *index_name = NULL, *column_list = NULL; zval *reference = NULL, *reference_sql = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL, *r19 = NULL, *r20 = NULL; zval *r21 = NULL, *r22 = NULL, *r23 = NULL; zval *t0 = NULL, *t1 = NULL; zval *c0 = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVSVS(table, "`", schema_name, "`.`", table_name, "`"); } else { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVS(table, "`", table_name, "`"); } PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 0); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r0, SL("temporary")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, r1, SL("temporary"), PH_NOISY_CC); if (zend_is_true(r2)) { PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 1); } } } if (zend_is_true(temporary)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TEMPORARY TABLE ", table, " (\n\t"); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TABLE ", table, " (\n\t"); } PHALCON_INIT_VAR(create_lines); array_init(create_lines); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, definition, SL("columns"), PH_NOISY_CC); if (!phalcon_valid_foreach(r3 TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(r3); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_52be_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_52be_2; } PHALCON_INIT_VAR(column); ZVAL_ZVAL(column, *hd, 1, 0); PHALCON_INIT_VAR(r4); PHALCON_CALL_METHOD(r4, column, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(r5); PHALCON_CALL_SELF_PARAMS_1(r5, this_ptr, "getcolumndefinition", column); PHALCON_INIT_VAR(column_line); PHALCON_CONCAT_SVSV(column_line, "`", r4, "` ", r5); PHALCON_INIT_VAR(r6); PHALCON_CALL_METHOD(r6, column, "isnotnull", PH_NO_CHECK); if (zend_is_true(r6)) { PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, " NOT NULL", 1); phalcon_concat_self(&column_line, t0 TSRMLS_CC); } PHALCON_INIT_VAR(r7); PHALCON_CALL_METHOD(r7, column, "isautoincrement", PH_NO_CHECK); if (zend_is_true(r7)) { PHALCON_INIT_VAR(t1); ZVAL_STRING(t1, " AUTO_INCREMENT", 1); phalcon_concat_self(&column_line, t1 TSRMLS_CC); } phalcon_array_append(&create_lines, column_line, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_52be_2; fee_52be_2: if(0){} eval_int = phalcon_array_isset_string(definition, SL("indexes")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_string(&r8, definition, SL("indexes"), PH_NOISY_CC); if (!phalcon_valid_foreach(r8 TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(r8); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_52be_3: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_52be_3; } PHALCON_INIT_VAR(index); ZVAL_ZVAL(index, *hd, 1, 0); PHALCON_INIT_VAR(index_name); PHALCON_CALL_METHOD(index_name, index, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(r9); PHALCON_CALL_METHOD(r9, index, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_SELF_PARAMS_1(column_list, this_ptr, "getcolumnlist", r9); if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) { PHALCON_INIT_VAR(r10); PHALCON_CONCAT_SVS(r10, "PRIMARY KEY (", column_list, ")"); phalcon_array_append(&create_lines, r10, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(r11); PHALCON_CONCAT_SVSVS(r11, "KEY `", index_name, "` (", column_list, ")"); phalcon_array_append(&create_lines, r11, PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto fes_52be_3; fee_52be_3: if(0){} } eval_int = phalcon_array_isset_string(definition, SL("references")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r12); phalcon_array_fetch_string(&r12, definition, SL("references"), PH_NOISY_CC); if (!phalcon_valid_foreach(r12 TSRMLS_CC)) { return; } ah2 = Z_ARRVAL_P(r12); zend_hash_internal_pointer_reset_ex(ah2, &hp2); fes_52be_4: if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){ goto fee_52be_4; } PHALCON_INIT_VAR(reference); ZVAL_ZVAL(reference, *hd, 1, 0); PHALCON_INIT_VAR(r13); PHALCON_CALL_METHOD(r13, reference, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(r14); PHALCON_CALL_METHOD(r14, reference, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(r15); PHALCON_CALL_SELF_PARAMS_1(r15, this_ptr, "getcolumnlist", r14); PHALCON_INIT_VAR(reference_sql); PHALCON_CONCAT_SVSV(reference_sql, "CONSTRAINT `", r13, "` FOREIGN KEY (", r15); PHALCON_INIT_VAR(r16); PHALCON_CALL_METHOD(r16, reference, "getreferencedtable", PH_NO_CHECK); PHALCON_INIT_VAR(r17); PHALCON_CALL_METHOD(r17, reference, "getreferencedcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(r18); PHALCON_CALL_SELF_PARAMS_1(r18, this_ptr, "getcolumnlist", r17); PHALCON_INIT_VAR(r19); PHALCON_CONCAT_SVSVS(r19, ") REFERENCES `", r16, "`(", r18, ")"); phalcon_concat_self(&reference_sql, r19 TSRMLS_CC); phalcon_array_append(&create_lines, reference_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); goto fes_52be_4; fee_52be_4: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ",\n\t", 1); PHALCON_ALLOC_ZVAL_MM(r20); phalcon_fast_join(r20, c0, create_lines TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r21); PHALCON_CONCAT_VS(r21, r20, "\n)"); phalcon_concat_self(&sql, r21 TSRMLS_CC); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r22); PHALCON_CALL_SELF_PARAMS_1(r22, this_ptr, "_gettableoptions", definition); PHALCON_ALLOC_ZVAL_MM(r23); PHALCON_CONCAT_SV(r23, " ", r22); phalcon_concat_self(&sql, r23 TSRMLS_CC); } RETURN_CTOR(sql); }