diff --git a/ext/config.m4 b/ext/config.m4 index 6d558bacf30..b8846ebcc07 100644 --- a/ext/config.m4 +++ b/ext/config.m4 @@ -26,6 +26,7 @@ kernel/alternative/fcall.c \ kernel/framework/orm.c \ kernel/framework/router.c \ kernel/framework/url.c \ +interned-strings.c \ logger.c \ flash.c \ cli/dispatcher/exception.c \ diff --git a/ext/config.w32 b/ext/config.w32 index ce111c2900f..54df99d218c 100644 --- a/ext/config.w32 +++ b/ext/config.w32 @@ -8,7 +8,7 @@ if (PHP_PHALCON != "no") { ADD_SOURCES("ext/phalcon/mvc/model/query", "scanner.c parser.c builder.c lang.c statusinterface.c status.c builderinterface.c", "phalcon") ADD_SOURCES("ext/phalcon/mvc/view/engine/volt", "scanner.c parser.c compiler.c", "phalcon") ADD_SOURCES("ext/phalcon/annotations", "scanner.c parser.c reflection.c annotation.c readerinterface.c exception.c collection.c adapterinterface.c adapter.c reader.c", "phalcon") - ADD_SOURCES("ext/phalcon/.", "logger.c flash.c dispatcherinterface.c di.c cryptinterface.c db.c text.c debug.c tag.c filterinterface.c acl.c loader.c exception.c crypt.c filter.c dispatcher.c diinterface.c escaper.c config.c escaperinterface.c validation.c version.c flashinterface.c kernel.c security.c translate.c session.c", "phalcon") + ADD_SOURCES("ext/phalcon/.", "interned-strings.c logger.c flash.c dispatcherinterface.c di.c cryptinterface.c db.c text.c debug.c tag.c filterinterface.c acl.c loader.c exception.c crypt.c filter.c dispatcher.c diinterface.c escaper.c config.c escaperinterface.c validation.c version.c flashinterface.c kernel.c security.c translate.c session.c", "phalcon") ADD_SOURCES("ext/phalcon/cli/dispatcher", "exception.c", "phalcon") ADD_SOURCES("ext/phalcon/cli", "console.c router.c task.c dispatcher.c", "phalcon") ADD_SOURCES("ext/phalcon/cli/router", "exception.c", "phalcon") diff --git a/ext/interned-strings.c b/ext/interned-strings.c new file mode 100644 index 00000000000..c8e6c09e0eb --- /dev/null +++ b/ext/interned-strings.c @@ -0,0 +1,125 @@ +/* + +------------------------------------------------------------------------+ + | Phalcon Framework | + +------------------------------------------------------------------------+ + | Copyright (c) 2011-2013 Phalcon Team (http://www.phalconphp.com) | + +------------------------------------------------------------------------+ + | This source file is subject to the New BSD License that is bundled | + | with this package in the file docs/LICENSE.txt. | + | | + | If you did not receive a copy of the license and are unable to | + | obtain it through the world-wide-web, please send an email | + | to license@phalconphp.com so we can send you a copy immediately. | + +------------------------------------------------------------------------+ + | Authors: Andres Gutierrez | + | Eduar Carvajal | + | Vladimir Kolesnikov | + +------------------------------------------------------------------------+ +*/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "php_phalcon.h" +#include "kernel/main.h" +#include "kernel/string.h" + +#include "interned-strings.h" + +const char *phalcon_interned_alias = NULL; +const char *phalcon_interned_all = NULL; +const char *phalcon_interned_arguments = NULL; +const char *phalcon_interned_balias = NULL; +const char *phalcon_interned_binary_op = NULL; +const char *phalcon_interned_column = NULL; +const char *phalcon_interned_columns = NULL; +const char *phalcon_interned_conditions = NULL; +const char *phalcon_interned_delete = NULL; +const char *phalcon_interned_distinct = NULL; +const char *phalcon_interned_domain = NULL; +const char *phalcon_interned_expr = NULL; +const char *phalcon_interned_fields = NULL; +const char *phalcon_interned_functionCall = NULL; +const char *phalcon_interned_group = NULL; +const char *phalcon_interned_groupBy = NULL; +const char *phalcon_interned_having = NULL; +const char *phalcon_interned_joins = NULL; +const char *phalcon_interned_left = NULL; +const char *phalcon_interned_limit = NULL; +const char *phalcon_interned_model = NULL; +const char *phalcon_interned_models = NULL; +const char *phalcon_interned_modelsCache = NULL; +const char *phalcon_interned_modelsManager = NULL; +const char *phalcon_interned_modelsMetadata = NULL; +const char *phalcon_interned_name = NULL; +const char *phalcon_interned_ns_alias = NULL; +const char *phalcon_interned_number = NULL; +const char *phalcon_interned_offset = NULL; +const char *phalcon_interned_op = NULL; +const char *phalcon_interned_order = NULL; +const char *phalcon_interned_orderBy = NULL; +const char *phalcon_interned_qualified = NULL; +const char *phalcon_interned_qualifiedName = NULL; +const char *phalcon_interned_right = NULL; +const char *phalcon_interned_select = NULL; +const char *phalcon_interned_sort = NULL; +const char *phalcon_interned_source = NULL; +const char *phalcon_interned_sqlAlias = NULL; +const char *phalcon_interned_table = NULL; +const char *phalcon_interned_tables = NULL; +const char *phalcon_interned_type = NULL; +const char *phalcon_interned_update = NULL; +const char *phalcon_interned_value = NULL; +const char *phalcon_interned_values = NULL; +const char *phalcon_interned_where = NULL; + +void phalcon_init_interned_strings(TSRMLS_D) +{ + phalcon_interned_alias = zend_new_interned_string(SS("alias"), 0 TSRMLS_CC); + phalcon_interned_all = zend_new_interned_string(SS("all"), 0 TSRMLS_CC); + phalcon_interned_arguments = zend_new_interned_string(SS("arguments"), 0 TSRMLS_CC); + phalcon_interned_balias = zend_new_interned_string(SS("balias"), 0 TSRMLS_CC); + phalcon_interned_binary_op = zend_new_interned_string(SS("binary-op"), 0 TSRMLS_CC); + phalcon_interned_column = zend_new_interned_string(SS("column"), 0 TSRMLS_CC); + phalcon_interned_columns = zend_new_interned_string(SS("columns"), 0 TSRMLS_CC); + phalcon_interned_conditions = zend_new_interned_string(SS("conditions"), 0 TSRMLS_CC); + phalcon_interned_delete = zend_new_interned_string(SS("delete"), 0 TSRMLS_CC); + phalcon_interned_distinct = zend_new_interned_string(SS("distinct"), 0 TSRMLS_CC); + phalcon_interned_domain = zend_new_interned_string(SS("domain"), 0 TSRMLS_CC); + phalcon_interned_expr = zend_new_interned_string(SS("expr"), 0 TSRMLS_CC); + phalcon_interned_fields = zend_new_interned_string(SS("fields"), 0 TSRMLS_CC); + phalcon_interned_functionCall = zend_new_interned_string(SS("functionCall"), 0 TSRMLS_CC); + phalcon_interned_group = zend_new_interned_string(SS("group"), 0 TSRMLS_CC); + phalcon_interned_groupBy = zend_new_interned_string(SS("groupBy"), 0 TSRMLS_CC); + phalcon_interned_having = zend_new_interned_string(SS("having"), 0 TSRMLS_CC); + phalcon_interned_joins = zend_new_interned_string(SS("joins"), 0 TSRMLS_CC); + phalcon_interned_left = zend_new_interned_string(SS("left"), 0 TSRMLS_CC); + phalcon_interned_limit = zend_new_interned_string(SS("limit"), 0 TSRMLS_CC); + phalcon_interned_model = zend_new_interned_string(SS("model"), 0 TSRMLS_CC); + phalcon_interned_models = zend_new_interned_string(SS("models"), 0 TSRMLS_CC); + phalcon_interned_modelsCache = zend_new_interned_string(SS("modelsCache"), 0 TSRMLS_CC); + phalcon_interned_modelsManager = zend_new_interned_string(SS("modelsManager"), 0 TSRMLS_CC); + phalcon_interned_modelsMetadata = zend_new_interned_string(SS("modelsMetadata"), 0 TSRMLS_CC); + phalcon_interned_name = zend_new_interned_string(SS("name"), 0 TSRMLS_CC); + phalcon_interned_ns_alias = zend_new_interned_string(SS("ns-alias"), 0 TSRMLS_CC); + phalcon_interned_number = zend_new_interned_string(SS("number"), 0 TSRMLS_CC); + phalcon_interned_offset = zend_new_interned_string(SS("offset"), 0 TSRMLS_CC); + phalcon_interned_op = zend_new_interned_string(SS("op"), 0 TSRMLS_CC); + phalcon_interned_order = zend_new_interned_string(SS("order"), 0 TSRMLS_CC); + phalcon_interned_orderBy = zend_new_interned_string(SS("orderBy"), 0 TSRMLS_CC); + phalcon_interned_qualified = zend_new_interned_string(SS("qualified"), 0 TSRMLS_CC); + phalcon_interned_qualifiedName = zend_new_interned_string(SS("qualifiedName"), 0 TSRMLS_CC); + phalcon_interned_right = zend_new_interned_string(SS("right"), 0 TSRMLS_CC); + phalcon_interned_select = zend_new_interned_string(SS("select"), 0 TSRMLS_CC); + phalcon_interned_sort = zend_new_interned_string(SS("sort"), 0 TSRMLS_CC); + phalcon_interned_source = zend_new_interned_string(SS("source"), 0 TSRMLS_CC); + phalcon_interned_sqlAlias = zend_new_interned_string(SS("sqlAlias"), 0 TSRMLS_CC); + phalcon_interned_table = zend_new_interned_string(SS("table"), 0 TSRMLS_CC); + phalcon_interned_tables = zend_new_interned_string(SS("tables"), 0 TSRMLS_CC); + phalcon_interned_type = zend_new_interned_string(SS("type"), 0 TSRMLS_CC); + phalcon_interned_update = zend_new_interned_string(SS("update"), 0 TSRMLS_CC); + phalcon_interned_value = zend_new_interned_string(SS("value"), 0 TSRMLS_CC); + phalcon_interned_values = zend_new_interned_string(SS("values"), 0 TSRMLS_CC); + phalcon_interned_where = zend_new_interned_string(SS("where"), 0 TSRMLS_CC); +} diff --git a/ext/interned-strings.h b/ext/interned-strings.h new file mode 100644 index 00000000000..ca2d0b307d4 --- /dev/null +++ b/ext/interned-strings.h @@ -0,0 +1,74 @@ +/* + +------------------------------------------------------------------------+ + | Phalcon Framework | + +------------------------------------------------------------------------+ + | Copyright (c) 2011-2013 Phalcon Team (http://www.phalconphp.com) | + +------------------------------------------------------------------------+ + | This source file is subject to the New BSD License that is bundled | + | with this package in the file docs/LICENSE.txt. | + | | + | If you did not receive a copy of the license and are unable to | + | obtain it through the world-wide-web, please send an email | + | to license@phalconphp.com so we can send you a copy immediately. | + +------------------------------------------------------------------------+ + | Authors: Andres Gutierrez | + | Eduar Carvajal | + | Vladimir Kolesnikov | + +------------------------------------------------------------------------+ +*/ + +#ifndef PHALCON_INTERNED_STRINGS_H +#define PHALCON_INTERNED_STRINGS_H + +#include "main/php.h" + +extern const char *phalcon_interned_alias; +extern const char *phalcon_interned_all; +extern const char *phalcon_interned_arguments; +extern const char *phalcon_interned_balias; +extern const char *phalcon_interned_binary_op; +extern const char *phalcon_interned_column; +extern const char *phalcon_interned_columns; +extern const char *phalcon_interned_conditions; +extern const char *phalcon_interned_delete; +extern const char *phalcon_interned_distinct; +extern const char *phalcon_interned_domain; +extern const char *phalcon_interned_expr; +extern const char *phalcon_interned_fields; +extern const char *phalcon_interned_functionCall; +extern const char *phalcon_interned_group; +extern const char *phalcon_interned_groupBy; +extern const char *phalcon_interned_having; +extern const char *phalcon_interned_joins; +extern const char *phalcon_interned_left; +extern const char *phalcon_interned_limit; +extern const char *phalcon_interned_model; +extern const char *phalcon_interned_models; +extern const char *phalcon_interned_modelsCache; +extern const char *phalcon_interned_modelsManager; +extern const char *phalcon_interned_modelsMetadata; +extern const char *phalcon_interned_name; +extern const char *phalcon_interned_ns_alias; +extern const char *phalcon_interned_number; +extern const char *phalcon_interned_offset; +extern const char *phalcon_interned_op; +extern const char *phalcon_interned_order; +extern const char *phalcon_interned_orderBy; +extern const char *phalcon_interned_qualified; +extern const char *phalcon_interned_qualifiedName; +extern const char *phalcon_interned_right; +extern const char *phalcon_interned_select; +extern const char *phalcon_interned_sort; +extern const char *phalcon_interned_source; +extern const char *phalcon_interned_sqlAlias; +extern const char *phalcon_interned_table; +extern const char *phalcon_interned_tables; +extern const char *phalcon_interned_type; +extern const char *phalcon_interned_update; +extern const char *phalcon_interned_value; +extern const char *phalcon_interned_values; +extern const char *phalcon_interned_where; + +void phalcon_init_interned_strings(TSRMLS_D); + +#endif /* PHALCON_INTERNED_STRINGS_H */ diff --git a/ext/kernel/array.c b/ext/kernel/array.c index 29faf06cba0..1a870e0f1d4 100644 --- a/ext/kernel/array.c +++ b/ext/kernel/array.c @@ -172,7 +172,7 @@ int PHALCON_FASTCALL phalcon_array_isset(const zval *arr, zval *index) { * @note The function is a wrapper around phalcon_array_isset_quick_string() * @see phalcon_array_isset_quick_string() */ -int PHALCON_FASTCALL phalcon_array_isset_string(const zval *arr, char *index, uint index_length) { +int PHALCON_FASTCALL phalcon_array_isset_string(const zval *arr, const char *index, uint index_length) { return phalcon_array_isset_quick_string(arr, index, index_length, zend_inline_hash_func(index, index_length)); } @@ -187,7 +187,7 @@ int PHALCON_FASTCALL phalcon_array_isset_string(const zval *arr, char *index, ui * @retval 0 Not exists or @a arr is not an array * @retval 1 Exists */ -int PHALCON_FASTCALL phalcon_array_isset_quick_string(const zval *arr, char *index, uint index_length, unsigned long key) { +int PHALCON_FASTCALL phalcon_array_isset_quick_string(const zval *arr, const char *index, uint index_length, unsigned long key) { if (likely(Z_TYPE_P(arr) == IS_ARRAY)) { return zend_hash_quick_exists(Z_ARRVAL_P(arr), index, index_length, key); @@ -269,7 +269,7 @@ int PHALCON_FASTCALL phalcon_array_unset(zval **arr, zval *index, int flags) { * @retval @c FAILURE Failure or @a arr is not an array * @retval @c SUCCESS Success */ -int PHALCON_FASTCALL phalcon_array_unset_string(zval **arr, char *index, uint index_length, int flags) { +int PHALCON_FASTCALL phalcon_array_unset_string(zval **arr, const char *index, uint index_length, int flags) { if (Z_TYPE_PP(arr) != IS_ARRAY) { return 0; @@ -556,7 +556,7 @@ int phalcon_array_update_zval_long(zval **arr, zval *index, long value, int flag * @arg @c PH_SEPARATE: separate @a arr if its reference count is greater than 1; @c *arr will contain the separated version * @arg @c PH_COPY: increment the reference count on @c **value */ -int phalcon_array_update_quick_string(zval **arr, char *index, uint index_length, unsigned long key, zval **value, int flags){ +int phalcon_array_update_quick_string(zval **arr, const char *index, uint index_length, unsigned long key, zval **value, int flags){ if (Z_TYPE_PP(arr) != IS_ARRAY) { zend_error(E_WARNING, "Cannot use a scalar value as an array"); @@ -603,7 +603,7 @@ int phalcon_array_update_quick_string(zval **arr, char *index, uint index_length * @arg @c PH_SEPARATE: separate @a arr if its reference count is greater than 1; @c *arr will contain the separated version * @arg @c PH_COPY: increment the reference count on @c **value */ -int phalcon_array_update_string(zval **arr, char *index, uint index_length, zval **value, int flags) { +int phalcon_array_update_string(zval **arr, const char *index, uint index_length, zval **value, int flags) { return phalcon_array_update_quick_string(arr, index, index_length + 1, zend_inline_hash_func(index, index_length + 1), value, flags); } @@ -630,7 +630,7 @@ int phalcon_array_update_string(zval **arr, char *index, uint index_length, zval * * Only @c PH_SEPARATE is meaningful with this function. */ -int phalcon_array_update_string_bool(zval **arr, char *index, uint index_length, int value, int flags){ +int phalcon_array_update_string_bool(zval **arr, const char *index, uint index_length, int value, int flags){ zval *zvalue; @@ -662,7 +662,7 @@ int phalcon_array_update_string_bool(zval **arr, char *index, uint index_length, * * Only @c PH_SEPARATE is meaningful with this function. */ -int phalcon_array_update_string_long(zval **arr, char *index, uint index_length, long value, int flags){ +int phalcon_array_update_string_long(zval **arr, const char *index, uint index_length, long value, int flags){ zval *zvalue; @@ -695,7 +695,7 @@ int phalcon_array_update_string_long(zval **arr, char *index, uint index_length, * * Only @c PH_SEPARATE is meaningful with this function. */ -int phalcon_array_update_string_string(zval **arr, char *index, uint index_length, char *value, uint value_length, int flags){ +int phalcon_array_update_string_string(zval **arr, const char *index, uint index_length, char *value, uint value_length, int flags){ zval *zvalue; @@ -931,7 +931,7 @@ int phalcon_array_fetch(zval **return_value, zval *arr, zval *index, int silent) * @throw @c E_NOTICE if @c index does not exist and @c silent = @c PH_NOISY * @warning @c *return_value should be either @c NULL (preferred) or point to not initialized memory; if @c *return_value points to a valid variable, mmemory leak is possible */ -int phalcon_array_fetch_quick_string(zval **return_value, zval *arr, char *index, uint index_length, unsigned long key, int silent){ +int phalcon_array_fetch_quick_string(zval **return_value, zval *arr, const char *index, uint index_length, unsigned long key, int silent){ zval **zv; @@ -973,7 +973,7 @@ int phalcon_array_fetch_quick_string(zval **return_value, zval *arr, char *index * * The function is a wrapper over @c phalcon_array_fetch_quick_string() */ -int phalcon_array_fetch_string(zval **return_value, zval *arr, char *index, uint index_length, int silent){ +int phalcon_array_fetch_string(zval **return_value, zval *arr, const char *index, uint index_length, int silent){ return phalcon_array_fetch_quick_string(return_value, arr, index, index_length + 1, zend_inline_hash_func(index, index_length + 1), silent); } diff --git a/ext/kernel/array.h b/ext/kernel/array.h index 33b332b078b..76bce2292a5 100644 --- a/ext/kernel/array.h +++ b/ext/kernel/array.h @@ -32,15 +32,15 @@ int phalcon_array_isset_long_fetch(zval **fetched, zval *arr, unsigned long inde /** Check for index existence */ int PHALCON_FASTCALL phalcon_array_isset(const zval *arr, zval *index); int PHALCON_FASTCALL phalcon_array_isset_long(const zval *arr, unsigned long index); -int PHALCON_FASTCALL phalcon_array_isset_string(const zval *arr, char *index, uint index_length); +int PHALCON_FASTCALL phalcon_array_isset_string(const zval *arr, const char *index, uint index_length); /** Fast index existence checking */ -int PHALCON_FASTCALL phalcon_array_isset_quick_string(const zval *arr, char *index, uint index_length, unsigned long key); +int PHALCON_FASTCALL phalcon_array_isset_quick_string(const zval *arr, const char *index, uint index_length, unsigned long key); /** Unset existing indexes */ int PHALCON_FASTCALL phalcon_array_unset(zval **arr, zval *index, int flags); int PHALCON_FASTCALL phalcon_array_unset_long(zval **arr, unsigned long index, int flags); -int PHALCON_FASTCALL phalcon_array_unset_string(zval **arr, char *index, uint index_length, int flags); +int PHALCON_FASTCALL phalcon_array_unset_string(zval **arr, const char *index, uint index_length, int flags); /** Append elements to arrays */ int phalcon_array_append(zval **arr, zval *value, int separate); @@ -53,10 +53,10 @@ int phalcon_array_update_zval_bool(zval **arr, zval *index, int value, int flags int phalcon_array_update_zval_long(zval **arr, zval *index, long value, int flags); int phalcon_array_update_zval_string(zval **arr, zval *index, char *value, uint value_length, int flags); -int phalcon_array_update_string(zval **arr, char *index, uint index_length, zval **value, int flags); -int phalcon_array_update_string_bool(zval **arr, char *index, uint index_length, int value, int flags); -int phalcon_array_update_string_long(zval **arr, char *index, uint index_length, long value, int flags); -int phalcon_array_update_string_string(zval **arr, char *index, uint index_length, char *value, uint value_length, int flags); +int phalcon_array_update_string(zval **arr, const char *index, uint index_length, zval **value, int flags); +int phalcon_array_update_string_bool(zval **arr, const char *index, uint index_length, int value, int flags); +int phalcon_array_update_string_long(zval **arr, const char *index, uint index_length, long value, int flags); +int phalcon_array_update_string_string(zval **arr, const char *index, uint index_length, char *value, uint value_length, int flags); int phalcon_array_update_long(zval **arr, unsigned long index, zval **value, int flags); int phalcon_array_update_long_string(zval **arr, unsigned long index, char *value, uint value_length, int flags); @@ -78,7 +78,7 @@ void phalcon_array_update_zval_string_string_multi_3(zval **arr, zval *index1, c /** Fetch items from arrays */ int phalcon_array_fetch(zval **return_value, zval *arr, zval *index, int silent); -int phalcon_array_fetch_string(zval **return_value, zval *arr, char *index, uint index_length, int silent); +int phalcon_array_fetch_string(zval **return_value, zval *arr, const char *index, uint index_length, int silent); int phalcon_array_fetch_long(zval **return_value, zval *arr, unsigned long index, int silent); /** Merge+Append */ diff --git a/ext/kernel/main.h b/ext/kernel/main.h index 06a8b852e3f..c1599148ac6 100644 --- a/ext/kernel/main.h +++ b/ext/kernel/main.h @@ -36,6 +36,9 @@ #define SL(str) ZEND_STRL(str) #define SS(str) ZEND_STRS(str) +#define ISL(str) (phalcon_interned_##str), (sizeof(#str)-1) +#define ISS(str) (phalcon_interned_##str), (sizeof(#str)) + /* Startup functions */ extern void php_phalcon_init_globals(zend_phalcon_globals *phalcon_globals TSRMLS_DC); diff --git a/ext/kernel/string.c b/ext/kernel/string.c index ce7f5e4b10a..2b849aed125 100644 --- a/ext/kernel/string.c +++ b/ext/kernel/string.c @@ -1390,3 +1390,12 @@ void phalcon_addslashes(zval *return_value, zval *str TSRMLS_DC) zval_dtor(©); } } + +#if PHP_VERSION_ID < 50400 + +const char* zend_new_interned_string(const char *arKey, int nKeyLength, int free_src TSRMLS_DC) +{ + return arKey; +} + +#endif diff --git a/ext/kernel/string.h b/ext/kernel/string.h index fa9b7b5f4e6..d026ed0559c 100644 --- a/ext/kernel/string.h +++ b/ext/kernel/string.h @@ -98,4 +98,18 @@ void phalcon_strval(zval *return_value, zval *v); void phalcon_date(zval *return_value, zval *format, zval *timestamp TSRMLS_DC); void phalcon_addslashes(zval *return_value, zval *str TSRMLS_DC); +#if PHP_VERSION_ID < 50400 +const char* zend_new_interned_string(const char *arKey, int nKeyLength, int free_src TSRMLS_DC); +#endif + +#define PHALCON_ZVAL_MAYBE_INTERNED_STRING(pz, string) \ + do { \ + if (IS_INTERNED(string)) { \ + ZVAL_STRINGL(pz, string, INTERNED_LEN(string)-1, 0); \ + } \ + else { \ + ZVAL_STRING(pz, string, 1); \ + } \ + } while (0) + #endif /* PHALCON_KERNEL_STRING_H */ diff --git a/ext/mvc/model/query.c b/ext/mvc/model/query.c index 0ab7576cdab..57260e62b58 100644 --- a/ext/mvc/model/query.c +++ b/ext/mvc/model/query.c @@ -46,6 +46,8 @@ #include "mvc/model/query/scanner.h" #include "mvc/model/query/phql.h" +#include "interned-strings.h" + /** * Phalcon\Mvc\Model\Query * @@ -157,7 +159,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setDI){ PHALCON_VERIFY_INTERFACE(dependency_injector, phalcon_diinterface_ce); PHALCON_INIT_VAR(service); - ZVAL_STRING(service, "modelsManager", 1); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_modelsManager); PHALCON_INIT_VAR(manager); phalcon_call_method_p1(manager, dependency_injector, "getshared", service); @@ -169,7 +171,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, setDI){ PHALCON_VERIFY_INTERFACE(manager, phalcon_mvc_model_managerinterface_ce); PHALCON_INIT_NVAR(service); - ZVAL_STRING(service, "modelsMetadata", 1); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_modelsMetadata); PHALCON_INIT_VAR(meta_data); phalcon_call_method_p1(meta_data, dependency_injector, "getshared", service); @@ -243,12 +245,14 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getQualified){ HashPosition hp0; zval **hd; + zval *s_qualified; + PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &expr); PHALCON_OBS_VAR(column_name); - phalcon_array_fetch_string(&column_name, expr, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&column_name, expr, ISL(name), PH_NOISY); sql_column_aliases = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlColumnAliases"), PH_NOISY_CC); @@ -257,8 +261,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getQualified){ */ if (phalcon_array_isset(sql_column_aliases, column_name)) { array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("qualified"), 1); - phalcon_array_update_string(&return_value, SL("name"), &column_name, PH_COPY); + MAKE_STD_ZVAL(s_qualified); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(s_qualified, phalcon_interned_qualified); + add_assoc_zval_ex(return_value, ISS(type), s_qualified); + phalcon_array_update_string(&return_value, ISL(name), &column_name, PH_COPY); RETURN_MM(); } @@ -271,7 +277,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getQualified){ zval *sql_aliases; PHALCON_OBS_VAR(column_domain); - phalcon_array_fetch_string(&column_domain, expr, SL("domain"), PH_NOISY); + phalcon_array_fetch_string(&column_domain, expr, ISL(domain), PH_NOISY); sql_aliases = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlAliases"), PH_NOISY_CC); @@ -444,11 +450,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getQualified){ /** * Create an array with the qualified info */ + MAKE_STD_ZVAL(s_qualified); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(s_qualified, phalcon_interned_qualified); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("qualified"), 1); - phalcon_array_update_string(&return_value, SL("domain"), &source, PH_COPY); - phalcon_array_update_string(&return_value, SL("name"), &real_column_name, PH_COPY); - phalcon_array_update_string(&return_value, SL("balias"), &column_name, PH_COPY); + add_assoc_zval_ex(return_value, ISS(type), s_qualified); + phalcon_array_update_string(&return_value, ISL(domain), &source, PH_COPY); + phalcon_array_update_string(&return_value, ISL(name), &real_column_name, PH_COPY); + phalcon_array_update_string(&return_value, ISL(balias), &column_name, PH_COPY); RETURN_MM(); } @@ -468,10 +476,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getCallArgument){ phalcon_fetch_params(1, 1, 0, &argument); PHALCON_OBS_VAR(argument_type); - phalcon_array_fetch_string(&argument_type, argument, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&argument_type, argument, ISL(type), PH_NOISY); if (PHALCON_IS_LONG(argument_type, PHQL_T_STARALL)) { + zval *s_all; + MAKE_STD_ZVAL(s_all); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(s_all, phalcon_interned_all); array_init_size(return_value, 1); - add_assoc_stringl_ex(return_value, SS("type"), SL("all"), 1); + add_assoc_zval_ex(return_value, ISS(type), s_all); RETURN_MM(); } @@ -494,6 +505,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getFunctionCall){ zval **hd; int distinct; + zval *s_functionCall; + PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &expr); @@ -501,7 +514,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getFunctionCall){ array_init_size(return_value, 4); PHALCON_OBS_VAR(name); - phalcon_array_fetch_string(&name, expr, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&name, expr, ISL(name), PH_NOISY); if (phalcon_array_isset_string_fetch(&arguments, expr, SS("arguments"))) { distinct = phalcon_array_isset_string(expr, SS("distinct")) ? 1 : 0; @@ -539,16 +552,20 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getFunctionCall){ phalcon_array_append(&function_args, argument_expr, 0); } - add_assoc_stringl_ex(return_value, SS("type"), SL("functionCall"), 1); - phalcon_array_update_string(&return_value, SL("name"), &name, PH_COPY); - phalcon_array_update_string(&return_value, SL("arguments"), &function_args, PH_COPY); + MAKE_STD_ZVAL(s_functionCall); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(s_functionCall, phalcon_interned_functionCall); + add_assoc_zval_ex(return_value, ISS(type), s_functionCall); + phalcon_array_update_string(&return_value, ISL(name), &name, PH_COPY); + phalcon_array_update_string(&return_value, ISL(arguments), &function_args, PH_COPY); if (distinct) { - add_assoc_bool_ex(return_value, SS("distinct"), distinct); + add_assoc_bool_ex(return_value, ISS(distinct), distinct); } } else { - add_assoc_stringl_ex(return_value, SS("type"), SL("functionCall"), 1); - phalcon_array_update_string(&return_value, SL("name"), &name, PH_COPY); + MAKE_STD_ZVAL(s_functionCall); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(s_functionCall, phalcon_interned_functionCall); + add_assoc_zval_ex(return_value, ISS(type), s_functionCall); + phalcon_array_update_string(&return_value, ISL(name), &name, PH_COPY); } PHALCON_MM_RESTORE(); @@ -582,7 +599,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ ZVAL_TRUE(quoting); } - if (phalcon_array_isset_string(expr, SS("type"))) { + if (phalcon_array_isset_string(expr, ISS(type))) { zval *expr_left, *expr_right; PHALCON_INIT_VAR(temp_not_quoting); @@ -608,80 +625,80 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ * Every node in the AST has a unique integer type */ PHALCON_OBS_VAR(expr_type); - phalcon_array_fetch_string(&expr_type, expr, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&expr_type, expr, ISL(type), PH_NOISY); switch (phalcon_get_intval(expr_type)) { case PHQL_T_LESS: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("<"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("<"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_EQUALS: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("="), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("="), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_GREATER: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL(">"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL(">"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_NOTEQUALS: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("<>"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("<>"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_LESSEQUAL: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("<="), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("<="), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_GREATEREQUAL: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL(">="), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL(">="), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_AND: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("AND"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("AND"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_OR: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("OR"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("OR"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_QUALIFIED: @@ -695,79 +712,79 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ case PHQL_T_ADD: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("+"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("+"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_SUB: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("-"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("-"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_MUL: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("*"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("*"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_DIV: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("/"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("/"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_MOD: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("%"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("%"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_BITWISE_AND: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("&"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("&"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_BITWISE_OR: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("|"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("|"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_ENCLOSED: assert(left != NULL); array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("parentheses"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("parentheses"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); break; case PHQL_T_MINUS: assert(right != NULL); array_init_size(return_value, 3); - add_assoc_stringl_ex(return_value, SS("type"), SL("unary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("-"), 1); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("unary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("-"), 1); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_INTEGER: @@ -777,20 +794,20 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ phalcon_array_fetch_string(&value, expr, SL("value"), PH_NOISY); array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("literal"), 1); - phalcon_array_update_string(&return_value, SL("value"), &value, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("literal"), 1); + phalcon_array_update_string(&return_value, ISL(value), &value, PH_COPY); break; case PHQL_T_TRUE: array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("literal"), 1); - add_assoc_stringl_ex(return_value, SS("value"), SL("TRUE"), 1); + add_assoc_stringl_ex(return_value, ISS(type), SL("literal"), 1); + add_assoc_stringl_ex(return_value, ISS(value), SL("TRUE"), 1); break; case PHQL_T_FALSE: array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("literal"), 1); - add_assoc_stringl_ex(return_value, SS("value"), SL("FALSE"), 1); + add_assoc_stringl_ex(return_value, ISS(type), SL("literal"), 1); + add_assoc_stringl_ex(return_value, ISS(value), SL("FALSE"), 1); break; case PHQL_T_STRING: @@ -815,8 +832,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ } array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("literal"), 1); - phalcon_array_update_string(&return_value, SL("value"), &expr_value, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("literal"), 1); + phalcon_array_update_string(&return_value, ISL(value), &expr_value, PH_COPY); break; case PHQL_T_NPLACEHOLDER: { @@ -835,8 +852,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ phalcon_fast_str_replace(placeholder, &question_mark, &colon, value); array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("placeholder"), 1); - phalcon_array_update_string(&return_value, SL("value"), &placeholder, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("placeholder"), 1); + phalcon_array_update_string(&return_value, ISL(value), &placeholder, PH_COPY); break; } @@ -848,92 +865,92 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ PHALCON_CONCAT_SV(placeholder, ":", value); array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("placeholder"), 1); - phalcon_array_update_string(&return_value, SL("value"), &placeholder, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("placeholder"), 1); + phalcon_array_update_string(&return_value, ISL(value), &placeholder, PH_COPY); break; case PHQL_T_NULL: array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("literal"), 1); - add_assoc_stringl_ex(return_value, SS("value"), SL("NULL"), 1); + add_assoc_stringl_ex(return_value, ISS(type), SL("literal"), 1); + add_assoc_stringl_ex(return_value, ISS(value), SL("NULL"), 1); break; case PHQL_T_LIKE: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("LIKE"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("LIKE"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_NLIKE: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("NOT LIKE"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("NOT LIKE"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_ILIKE: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("ILIKE"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("ILIKE"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_NILIKE: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("NOT ILIKE"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("NOT ILIKE"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_NOT: assert(right != NULL); array_init_size(return_value, 3); - add_assoc_stringl_ex(return_value, SS("type"), SL("unary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("NOT "), 1); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("unary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("NOT "), 1); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_ISNULL: assert(left != NULL); array_init_size(return_value, 3); - add_assoc_stringl_ex(return_value, SS("type"), SL("unary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL(" IS NULL"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("unary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL(" IS NULL"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); break; case PHQL_T_ISNOTNULL: assert(left != NULL); array_init_size(return_value, 3); - add_assoc_stringl_ex(return_value, SS("type"), SL("unary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL(" IS NOT NULL"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("unary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL(" IS NOT NULL"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); break; case PHQL_T_IN: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("IN"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("IN"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_NOTIN: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("NOT IN"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("NOT IN"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_DISTINCT: @@ -943,44 +960,44 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ /* assert(right != NULL); array_init_size(return_value, 3); - add_assoc_stringl_ex(return_value, SS("type"), SL("unary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("DISTINCT "), 1); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("unary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("DISTINCT "), 1); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; */ case PHQL_T_BETWEEN: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("BETWEEN"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("BETWEEN"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_AGAINST: assert(left != NULL && right != NULL); array_init_size(return_value, 4); - add_assoc_stringl_ex(return_value, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(return_value, SS("op"), SL("AGAINST"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(return_value, ISS(op), SL("AGAINST"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_CAST: assert(left != NULL && right != NULL); array_init_size(return_value, 3); - add_assoc_stringl_ex(return_value, SS("type"), SL("cast"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("cast"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_CONVERT: assert(left != NULL && right != NULL); array_init_size(return_value, 3); - add_assoc_stringl_ex(return_value, SS("type"), SL("convert"), 1); - phalcon_array_update_string(&return_value, SL("left"), &left, PH_COPY); - phalcon_array_update_string(&return_value, SL("right"), &right, PH_COPY); + add_assoc_stringl_ex(return_value, ISS(type), SL("convert"), 1); + phalcon_array_update_string(&return_value, ISL(left), &left, PH_COPY); + phalcon_array_update_string(&return_value, ISL(right), &right, PH_COPY); break; case PHQL_T_FCALL: @@ -1028,7 +1045,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression){ } array_init_size(return_value, 2); - add_assoc_stringl_ex(return_value, SS("type"), SL("list"), 1); + add_assoc_stringl_ex(return_value, ISS(type), SL("list"), 1); phalcon_array_append(&return_value, list_items, 0); RETURN_MM(); @@ -1061,7 +1078,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSelectColumn){ phalcon_fetch_params(1, 1, 0, &column); - if (!phalcon_array_isset_string(column, SS("type"))) { + if (!phalcon_array_isset_string(column, ISS(type))) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST"); return; } @@ -1070,7 +1087,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSelectColumn){ * Check for select * (all) */ PHALCON_OBS_VAR(column_type); - phalcon_array_fetch_string(&column_type, column, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&column_type, column, ISL(type), PH_NOISY); if (PHALCON_IS_LONG(column_type, PHQL_T_STARALL)) { zval *models = phalcon_fetch_nproperty_this(this_ptr, SL("_models"), PH_NOISY_CC); @@ -1085,9 +1102,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSelectColumn){ PHALCON_INIT_NVAR(sql_column); array_init_size(sql_column, 3); - add_assoc_stringl_ex(sql_column, SS("type"), SL("object"), 1); - phalcon_array_update_string(&sql_column, SL("model"), &model_name, PH_COPY); - phalcon_array_update_string(&sql_column, SL("column"), &source, PH_COPY); + add_assoc_stringl_ex(sql_column, ISS(type), SL("object"), 1); + phalcon_array_update_string(&sql_column, ISL(model), &model_name, PH_COPY); + phalcon_array_update_string(&sql_column, ISL(column), &source, PH_COPY); phalcon_array_append(&return_value, sql_column, 0); @@ -1159,10 +1176,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSelectColumn){ */ PHALCON_INIT_VAR(sql_column); array_init_size(sql_column, 4); - add_assoc_stringl_ex(sql_column, SS("type"), SL("object"), 1); - phalcon_array_update_string(&sql_column, SL("model"), &model_name, PH_COPY); - phalcon_array_update_string(&sql_column, SL("column"), &sql_column_alias, PH_COPY); - phalcon_array_update_string(&sql_column, SL("balias"), &prepared_alias, PH_COPY); + add_assoc_stringl_ex(sql_column, ISS(type), SL("object"), 1); + phalcon_array_update_string(&sql_column, ISL(model), &model_name, PH_COPY); + phalcon_array_update_string(&sql_column, ISL(column), &sql_column_alias, PH_COPY); + phalcon_array_update_string(&sql_column, ISL(balias), &prepared_alias, PH_COPY); array_init_size(return_value, 1); phalcon_array_append(&return_value, sql_column, 0); @@ -1181,7 +1198,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSelectColumn){ */ PHALCON_INIT_NVAR(sql_column); array_init_size(sql_column, 4); - add_assoc_stringl_ex(sql_column, SS("type"), SL("scalar"), 1); + add_assoc_stringl_ex(sql_column, ISS(type), SL("scalar"), 1); PHALCON_OBS_VAR(column_data); phalcon_array_fetch_string(&column_data, column, SL("column"), PH_NOISY); @@ -1193,11 +1210,11 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSelectColumn){ * Create balias and sqlAlias */ if (phalcon_array_isset_string_fetch(&balias, sql_expr_column, SS("balias"))) { - phalcon_array_update_string(&sql_column, SL("balias"), &balias, PH_COPY); - phalcon_array_update_string(&sql_column, SL("sqlAlias"), &balias, PH_COPY); + phalcon_array_update_string(&sql_column, ISL(balias), &balias, PH_COPY); + phalcon_array_update_string(&sql_column, ISL(sqlAlias), &balias, PH_COPY); } - phalcon_array_update_string(&sql_column, SL("column"), &sql_expr_column, PH_COPY); + phalcon_array_update_string(&sql_column, ISL(column), &sql_expr_column, PH_COPY); array_init_size(return_value, 1); phalcon_array_append(&return_value, sql_column, 0); @@ -1269,10 +1286,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoin){ if (phalcon_array_isset_string_fetch(&qualified, join, SS("qualified"))) { PHALCON_OBS_VAR(qualified_type); - phalcon_array_fetch_string(&qualified_type, qualified, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&qualified_type, qualified, ISL(type), PH_NOISY); if (PHALCON_IS_LONG(qualified_type, PHQL_T_QUALIFIED)) { PHALCON_OBS_VAR(model_name); - phalcon_array_fetch_string(&model_name, qualified, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&model_name, qualified, ISL(name), PH_NOISY); PHALCON_OBS_VAR(model); phalcon_call_method_p1_ex(model, &model, manager, "load", model_name); @@ -1309,13 +1326,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoinType){ phalcon_fetch_params(1, 1, 0, &join); - if (!phalcon_array_isset_string(join, SS("type"))) { + if (!phalcon_array_isset_string(join, ISS(type))) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST"); return; } PHALCON_OBS_VAR(type); - phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, join, ISL(type), PH_NOISY); switch (phalcon_get_intval(type)) { @@ -1396,9 +1413,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin){ */ PHALCON_INIT_VAR(left); array_init_size(left, 3); - add_assoc_long_ex(left, SS("type"), PHQL_T_QUALIFIED); - phalcon_array_update_string(&left, SL("domain"), &model_alias, PH_COPY); - phalcon_array_update_string(&left, SL("name"), &fields, PH_COPY); + add_assoc_long_ex(left, ISS(type), PHQL_T_QUALIFIED); + phalcon_array_update_string(&left, ISL(domain), &model_alias, PH_COPY); + phalcon_array_update_string(&left, ISL(name), &fields, PH_COPY); PHALCON_OBS_VAR(left_expr); phalcon_call_method_p1_ex(left_expr, &left_expr, this_ptr, "_getqualified", left); @@ -1408,9 +1425,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin){ */ PHALCON_INIT_VAR(right); array_init_size(right, 3); - add_assoc_stringl_ex(right, SS("type"), SL("qualified"), 1); - phalcon_array_update_string(&right, SL("domain"), &join_alias, PH_COPY); - phalcon_array_update_string(&right, SL("name"), &referenced_fields, PH_COPY); + add_assoc_stringl_ex(right, ISS(type), SL("qualified"), 1); + phalcon_array_update_string(&right, ISL(domain), &join_alias, PH_COPY); + phalcon_array_update_string(&right, ISL(name), &referenced_fields, PH_COPY); PHALCON_OBS_VAR(right_expr); phalcon_call_method_p1_ex(right_expr, &right_expr, this_ptr, "_getqualified", right); @@ -1420,10 +1437,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin){ */ PHALCON_INIT_VAR(sql_join_condition); array_init_size(sql_join_condition, 4); - add_assoc_stringl_ex(sql_join_condition, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(sql_join_condition, SS("op"), SL("="), 1); - phalcon_array_update_string(&sql_join_condition, SL("left"), &left_expr, PH_COPY); - phalcon_array_update_string(&sql_join_condition, SL("right"), &right_expr, PH_COPY); + add_assoc_stringl_ex(sql_join_condition, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(sql_join_condition, ISS(op), SL("="), 1); + phalcon_array_update_string(&sql_join_condition, ISL(left), &left_expr, PH_COPY); + phalcon_array_update_string(&sql_join_condition, ISL(right), &right_expr, PH_COPY); PHALCON_INIT_VAR(sql_join_conditions); array_init_size(sql_join_conditions, 1); @@ -1457,9 +1474,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin){ */ PHALCON_INIT_NVAR(left); array_init_size(left, 3); - add_assoc_long_ex(left, SS("type"), 355); - phalcon_array_update_string(&left, SL("domain"), &model_alias, PH_COPY); - phalcon_array_update_string(&left, SL("name"), &field, PH_COPY); + add_assoc_long_ex(left, ISS(type), PHQL_T_QUALIFIED); + phalcon_array_update_string(&left, ISL(domain), &model_alias, PH_COPY); + phalcon_array_update_string(&left, ISL(name), &field, PH_COPY); PHALCON_INIT_NVAR(left_expr); phalcon_call_method_p1(left_expr, this_ptr, "_getqualified", left); @@ -1469,9 +1486,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin){ */ PHALCON_INIT_NVAR(right); array_init_size(right, 3); - add_assoc_stringl_ex(right, SS("type"), SL("qualified"), 1); - phalcon_array_update_string(&right, SL("domain"), &join_alias, PH_COPY); - phalcon_array_update_string(&right, SL("name"), &referenced_field, PH_COPY); + add_assoc_stringl_ex(right, ISS(type), SL("qualified"), 1); + phalcon_array_update_string(&right, ISL(domain), &join_alias, PH_COPY); + phalcon_array_update_string(&right, ISL(name), &referenced_field, PH_COPY); PHALCON_INIT_NVAR(right_expr); phalcon_call_method_p1(right_expr, this_ptr, "_getqualified", right); @@ -1481,10 +1498,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin){ */ PHALCON_INIT_NVAR(sql_equals_join_condition); array_init_size(sql_equals_join_condition, 4); - add_assoc_stringl_ex(sql_equals_join_condition, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(sql_equals_join_condition, SS("op"), SL("="), 1); - phalcon_array_update_string(&sql_equals_join_condition, SL("left"), &left_expr, PH_COPY); - phalcon_array_update_string(&sql_equals_join_condition, SL("right"), &right_expr, PH_COPY); + add_assoc_stringl_ex(sql_equals_join_condition, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(sql_equals_join_condition, ISS(op), SL("="), 1); + phalcon_array_update_string(&sql_equals_join_condition, ISL(left), &left_expr, PH_COPY); + phalcon_array_update_string(&sql_equals_join_condition, ISL(right), &right_expr, PH_COPY); phalcon_array_append(&sql_join_partial_conditions, sql_equals_join_condition, 0); zend_hash_move_forward_ex(ah0, &hp0); @@ -1496,9 +1513,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin){ * A single join */ array_init_size(return_value, 3); - phalcon_array_update_string(&return_value, SL("type"), &join_type, PH_COPY); - phalcon_array_update_string(&return_value, SL("source"), &join_source, PH_COPY); - phalcon_array_update_string(&return_value, SL("conditions"), &sql_join_conditions, PH_COPY); + phalcon_array_update_string(&return_value, ISL(type), &join_type, PH_COPY); + phalcon_array_update_string(&return_value, ISL(source), &join_source, PH_COPY); + phalcon_array_update_string(&return_value, ISL(conditions), &sql_join_conditions, PH_COPY); RETURN_MM(); } @@ -1630,9 +1647,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_NVAR(left); array_init_size(left, 3); - add_assoc_long_ex(left, SS("type"), PHQL_T_QUALIFIED); - phalcon_array_update_string(&left, SL("domain"), &model_alias, PH_COPY); - phalcon_array_update_string(&left, SL("name"), &field, PH_COPY); + add_assoc_long_ex(left, ISS(type), PHQL_T_QUALIFIED); + phalcon_array_update_string(&left, ISL(domain), &model_alias, PH_COPY); + phalcon_array_update_string(&left, ISL(name), &field, PH_COPY); PHALCON_INIT_NVAR(left_expr); phalcon_call_method_p1(left_expr, this_ptr, "_getqualified", left); @@ -1642,9 +1659,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_NVAR(right); array_init_size(right, 3); - add_assoc_stringl_ex(right, SS("type"), SL("qualified"), 1); - phalcon_array_update_string(&right, SL("domain"), &join_alias, PH_COPY); - phalcon_array_update_string(&right, SL("name"), &referenced_fields, PH_COPY); + add_assoc_stringl_ex(right, ISS(type), SL("qualified"), 1); + phalcon_array_update_string(&right, ISL(domain), &join_alias, PH_COPY); + phalcon_array_update_string(&right, ISL(name), &referenced_fields, PH_COPY); PHALCON_INIT_NVAR(right_expr); phalcon_call_method_p1(right_expr, this_ptr, "_getqualified", right); @@ -1654,10 +1671,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_NVAR(sql_equals_join_condition); array_init_size(sql_equals_join_condition, 4); - add_assoc_stringl_ex(sql_equals_join_condition, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(sql_equals_join_condition, SS("op"), SL("="), 1); - phalcon_array_update_string(&sql_equals_join_condition, SL("left"), &left_expr, PH_COPY); - phalcon_array_update_string(&sql_equals_join_condition, SL("right"), &right_expr, PH_COPY); + add_assoc_stringl_ex(sql_equals_join_condition, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(sql_equals_join_condition, ISS(op), SL("="), 1); + phalcon_array_update_string(&sql_equals_join_condition, ISL(left), &left_expr, PH_COPY); + phalcon_array_update_string(&sql_equals_join_condition, ISL(right), &right_expr, PH_COPY); zend_hash_move_forward_ex(ah0, &hp0); } @@ -1668,9 +1685,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_NVAR(left); array_init_size(left, 3); - add_assoc_long_ex(left, SS("type"), PHQL_T_QUALIFIED); - phalcon_array_update_string(&left, SL("domain"), &model_alias, PH_COPY); - phalcon_array_update_string(&left, SL("name"), &fields, PH_COPY); + add_assoc_long_ex(left, ISS(type), PHQL_T_QUALIFIED); + phalcon_array_update_string(&left, ISL(domain), &model_alias, PH_COPY); + phalcon_array_update_string(&left, ISL(name), &fields, PH_COPY); PHALCON_INIT_NVAR(left_expr); phalcon_call_method_p1(left_expr, this_ptr, "_getqualified", left); @@ -1680,9 +1697,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_NVAR(right); array_init_size(right, 3); - add_assoc_stringl_ex(right, SS("type"), SL("qualified"), 1); - phalcon_array_update_string(&right, SL("domain"), &intermediate_model_name, PH_COPY); - phalcon_array_update_string(&right, SL("name"), &intermediate_fields, PH_COPY); + add_assoc_stringl_ex(right, ISS(type), SL("qualified"), 1); + phalcon_array_update_string(&right, ISL(domain), &intermediate_model_name, PH_COPY); + phalcon_array_update_string(&right, ISL(name), &intermediate_fields, PH_COPY); PHALCON_INIT_NVAR(right_expr); phalcon_call_method_p1(right_expr, this_ptr, "_getqualified", right); @@ -1692,10 +1709,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_VAR(sql_join_condition_first); array_init_size(sql_join_condition_first, 4); - add_assoc_stringl_ex(sql_join_condition_first, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(sql_join_condition_first, SS("op"), SL("="), 1); - phalcon_array_update_string(&sql_join_condition_first, SL("left"), &left_expr, PH_COPY); - phalcon_array_update_string(&sql_join_condition_first, SL("right"), &right_expr, PH_COPY); + add_assoc_stringl_ex(sql_join_condition_first, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(sql_join_condition_first, ISS(op), SL("="), 1); + phalcon_array_update_string(&sql_join_condition_first, ISL(left), &left_expr, PH_COPY); + phalcon_array_update_string(&sql_join_condition_first, ISL(right), &right_expr, PH_COPY); PHALCON_INIT_VAR(sql_join_conditions_first); array_init_size(sql_join_conditions_first, 1); @@ -1706,18 +1723,18 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_VAR(sql_join_first); array_init_size(sql_join_first, 3); - phalcon_array_update_string(&sql_join_first, SL("type"), &join_type, PH_COPY); - phalcon_array_update_string(&sql_join_first, SL("source"), &intermediate_source, PH_COPY); - phalcon_array_update_string(&sql_join_first, SL("conditions"), &sql_join_conditions_first, PH_COPY); + phalcon_array_update_string(&sql_join_first, ISL(type), &join_type, PH_COPY); + phalcon_array_update_string(&sql_join_first, ISL(source), &intermediate_source, PH_COPY); + phalcon_array_update_string(&sql_join_first, ISL(conditions), &sql_join_conditions_first, PH_COPY); /** * Create the left part of the expression */ PHALCON_INIT_NVAR(left); array_init_size(left, 3); - add_assoc_long_ex(left, SS("type"), PHQL_T_QUALIFIED); - phalcon_array_update_string(&left, SL("domain"), &intermediate_model_name, PH_COPY); - phalcon_array_update_string(&left, SL("name"), &intermediate_referenced_fields, PH_COPY); + add_assoc_long_ex(left, ISS(type), PHQL_T_QUALIFIED); + phalcon_array_update_string(&left, ISL(domain), &intermediate_model_name, PH_COPY); + phalcon_array_update_string(&left, ISL(name), &intermediate_referenced_fields, PH_COPY); PHALCON_INIT_NVAR(left_expr); phalcon_call_method_p1(left_expr, this_ptr, "_getqualified", left); @@ -1727,9 +1744,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_NVAR(right); array_init_size(right, 3); - add_assoc_stringl_ex(right, SS("type"), SL("qualified"), 1); - phalcon_array_update_string(&right, SL("domain"), &referenced_model_name, PH_COPY); - phalcon_array_update_string(&right, SL("name"), &referenced_fields, PH_COPY); + add_assoc_stringl_ex(right, ISS(type), SL("qualified"), 1); + phalcon_array_update_string(&right, ISL(domain), &referenced_model_name, PH_COPY); + phalcon_array_update_string(&right, ISL(name), &referenced_fields, PH_COPY); PHALCON_INIT_NVAR(right_expr); phalcon_call_method_p1(right_expr, this_ptr, "_getqualified", right); @@ -1739,10 +1756,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_VAR(sql_join_condition_second); array_init_size(sql_join_condition_second, 4); - add_assoc_stringl_ex(sql_join_condition_second, SS("type"), SL("binary-op"), 1); - add_assoc_stringl_ex(sql_join_condition_second, SS("op"), SL("="), 1); - phalcon_array_update_string(&sql_join_condition_second, SL("left"), &left_expr, PH_COPY); - phalcon_array_update_string(&sql_join_condition_second, SL("right"), &right_expr, PH_COPY); + add_assoc_stringl_ex(sql_join_condition_second, ISS(type), SL("binary-op"), 1); + add_assoc_stringl_ex(sql_join_condition_second, ISS(op), SL("="), 1); + phalcon_array_update_string(&sql_join_condition_second, ISL(left), &left_expr, PH_COPY); + phalcon_array_update_string(&sql_join_condition_second, ISL(right), &right_expr, PH_COPY); PHALCON_INIT_VAR(sql_join_conditions_second); array_init_size(sql_join_conditions_second, 1); @@ -1753,9 +1770,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin){ */ PHALCON_INIT_VAR(sql_join_second); array_init_size(sql_join_second, 3); - phalcon_array_update_string(&sql_join_second, SL("type"), &join_type, PH_COPY); - phalcon_array_update_string(&sql_join_second, SL("source"), &join_source, PH_COPY); - phalcon_array_update_string(&sql_join_second, SL("conditions"), &sql_join_conditions_second, PH_COPY); + phalcon_array_update_string(&sql_join_second, ISL(type), &join_type, PH_COPY); + phalcon_array_update_string(&sql_join_second, ISL(source), &join_source, PH_COPY); + phalcon_array_update_string(&sql_join_second, ISL(conditions), &sql_join_conditions_second, PH_COPY); phalcon_array_update_long(&return_value, 0, &sql_join_first, PH_COPY); phalcon_array_update_long(&return_value, 1, &sql_join_second, PH_COPY); @@ -1884,7 +1901,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoins){ if (phalcon_array_isset_string_fetch(&alias_expr, join_item, SS("alias"))) { PHALCON_OBS_NVAR(alias); - phalcon_array_fetch_string(&alias, alias_expr, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&alias, alias_expr, ISL(name), PH_NOISY); /** * Check if alias is unique @@ -2157,9 +2174,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoins){ */ PHALCON_INIT_NVAR(sql_join); array_init_size(sql_join, 3); - phalcon_array_update_string(&sql_join, SL("type"), &join_type, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_join, SL("source"), &join_source, PH_COPY); - phalcon_array_update_string(&sql_join, SL("conditions"), &sql_join_conditions, PH_COPY); + phalcon_array_update_string(&sql_join, ISL(type), &join_type, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_join, ISL(source), &join_source, PH_COPY); + phalcon_array_update_string(&sql_join, ISL(conditions), &sql_join_conditions, PH_COPY); phalcon_array_append(&sql_joins, sql_join, PH_SEPARATE); } } else { @@ -2178,9 +2195,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoins){ */ PHALCON_INIT_NVAR(sql_join); array_init_size(sql_join, 3); - phalcon_array_update_string(&sql_join, SL("type"), &join_type, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_join, SL("source"), &join_source, PH_COPY); - phalcon_array_update_string(&sql_join, SL("conditions"), &sql_join_conditions, PH_COPY); + phalcon_array_update_string(&sql_join, ISL(type), &join_type, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_join, ISL(source), &join_source, PH_COPY); + phalcon_array_update_string(&sql_join, ISL(conditions), &sql_join_conditions, PH_COPY); phalcon_array_append(&sql_joins, sql_join, PH_SEPARATE); } @@ -2324,13 +2341,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getLimitClause) { if (likely(phalcon_array_isset_string_fetch(&limit, limit_clause, SS("number")))) { PHALCON_INIT_NVAR(tmp); phalcon_call_method_p1(tmp, getThis(), "_getexpression", limit); - phalcon_array_update_string(&return_value, SL("number"), &tmp, PH_COPY); + phalcon_array_update_string(&return_value, ISL(number), &tmp, PH_COPY); } if (phalcon_array_isset_string_fetch(&offset, limit_clause, SS("offset"))) { PHALCON_INIT_NVAR(tmp); phalcon_call_method_p1(tmp, getThis(), "_getexpression", offset); - phalcon_array_update_string(&return_value, SL("offset"), &tmp, PH_COPY); + phalcon_array_update_string(&return_value, ISL(offset), &tmp, PH_COPY); } PHALCON_MM_RESTORE(); @@ -2455,7 +2472,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareSelect){ phalcon_array_fetch_string(&qualified_name, selected_model, SL("qualifiedName"), PH_NOISY); PHALCON_OBS_NVAR(model_name); - phalcon_array_fetch_string(&model_name, qualified_name, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&model_name, qualified_name, ISL(name), PH_NOISY); /** * Check if the table have a namespace alias @@ -2626,8 +2643,8 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareSelect){ /** * The best alias is the one provided by the user */ - phalcon_array_update_string(&sql_column, SL("balias"), &alias, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_column, SL("sqlAlias"), &alias, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_column, ISL(balias), &alias, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_column, ISL(sqlAlias), &alias, PH_COPY | PH_SEPARATE); phalcon_array_update_zval(&sql_columns, alias, &sql_column, PH_COPY | PH_SEPARATE); phalcon_array_update_zval_bool(&sql_column_aliases, alias, 1, PH_SEPARATE); } else { @@ -2639,7 +2656,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareSelect){ phalcon_array_update_zval(&sql_columns, alias, &sql_column, PH_COPY | PH_SEPARATE); } else { PHALCON_OBS_NVAR(type); - phalcon_array_fetch_string(&type, sql_column, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, sql_column, ISL(type), PH_NOISY); if (PHALCON_IS_STRING(type, "scalar")) { PHALCON_INIT_VAR(alias); PHALCON_CONCAT_SV(alias, "_", position); @@ -2670,47 +2687,38 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareSelect){ phalcon_array_update_string(&sql_select, SL("distinct"), &distinct, PH_COPY); } - phalcon_array_update_string(&sql_select, SL("models"), &sql_models, PH_COPY); - phalcon_array_update_string(&sql_select, SL("tables"), &sql_tables, PH_COPY); - phalcon_array_update_string(&sql_select, SL("columns"), &sql_columns, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(models), &sql_models, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(tables), &sql_tables, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(columns), &sql_columns, PH_COPY); if (phalcon_fast_count_ev(sql_joins TSRMLS_CC)) { - phalcon_array_update_string(&sql_select, SL("joins"), &sql_joins, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(joins), &sql_joins, PH_COPY); } /** * Process WHERE clause if any */ - if (phalcon_array_isset_string(ast, SS("where"))) { - PHALCON_OBS_VAR(where); - phalcon_array_fetch_string(&where, ast, SL("where"), PH_NOISY); - + if (phalcon_array_isset_string_fetch(&where, ast, SS("where"))) { PHALCON_INIT_VAR(where_expr); phalcon_call_method_p1(where_expr, this_ptr, "_getexpression", where); - phalcon_array_update_string(&sql_select, SL("where"), &where_expr, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(where), &where_expr, PH_COPY); } /** * Process GROUP BY clause if any */ - if (phalcon_array_isset_string(ast, SS("groupBy"))) { - PHALCON_OBS_VAR(group_by); - phalcon_array_fetch_string(&group_by, ast, SL("groupBy"), PH_NOISY); - + if (phalcon_array_isset_string_fetch(&group_by, ast, SS("groupBy"))) { PHALCON_INIT_VAR(sql_group); phalcon_call_method_p1(sql_group, this_ptr, "_getgroupclause", group_by); - phalcon_array_update_string(&sql_select, SL("group"), &sql_group, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(group), &sql_group, PH_COPY); } /** * Process HAVING clause if any */ - if (phalcon_array_isset_string(ast, SS("having"))) { - PHALCON_OBS_VAR(having); - phalcon_array_fetch_string(&having, ast, SL("having"), PH_NOISY); - + if (phalcon_array_isset_string_fetch(&having, ast, SS("having"))) { PHALCON_INIT_VAR(having_expr); phalcon_call_method_p1(having_expr, this_ptr, "_getexpression", having); - phalcon_array_update_string(&sql_select, SL("having"), &having_expr, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(having), &having_expr, PH_COPY); } /** @@ -2722,7 +2730,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareSelect){ PHALCON_INIT_VAR(sql_order); phalcon_call_method_p1(sql_order, this_ptr, "_getorderclause", order); - phalcon_array_update_string(&sql_select, SL("order"), &sql_order, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(order), &sql_order, PH_COPY); } /** @@ -2731,7 +2739,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareSelect){ if (phalcon_array_isset_string_fetch(&limit, ast, SS("limit"))) { PHALCON_INIT_VAR(sql_limit); phalcon_call_method_p1(sql_limit, this_ptr, "_getlimitclause", limit); - phalcon_array_update_string(&sql_select, SL("limit"), &sql_limit, PH_COPY); + phalcon_array_update_string(&sql_select, ISL(limit), &sql_limit, PH_COPY); } RETURN_CTOR(sql_select); @@ -2783,7 +2791,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareInsert){ phalcon_read_property_this(&manager, this_ptr, SL("_manager"), PH_NOISY_CC); PHALCON_OBS_VAR(model_name); - phalcon_array_fetch_string(&model_name, qualified_name, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&model_name, qualified_name, ISL(name), PH_NOISY); PHALCON_INIT_VAR(model); phalcon_call_method_p1(model, manager, "load", model_name); @@ -2825,12 +2833,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareInsert){ phalcon_call_method_p2(expr_insert, this_ptr, "_getexpression", expr_value, not_quoting); PHALCON_OBS_NVAR(expr_type); - phalcon_array_fetch_string(&expr_type, expr_value, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&expr_type, expr_value, ISL(type), PH_NOISY); PHALCON_INIT_NVAR(value); array_init_size(value, 2); - phalcon_array_update_string(&value, SL("type"), &expr_type, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&value, SL("value"), &expr_insert, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&value, ISL(type), &expr_type, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&value, ISL(value), &expr_insert, PH_COPY | PH_SEPARATE); phalcon_array_append(&expr_values, value, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); @@ -2838,19 +2846,16 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareInsert){ PHALCON_INIT_VAR(sql_insert); array_init(sql_insert); - phalcon_array_update_string(&sql_insert, SL("model"), &model_name, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_insert, SL("table"), &source, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_insert, ISL(model), &model_name, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_insert, ISL(table), &source, PH_COPY | PH_SEPARATE); PHALCON_OBS_VAR(meta_data); phalcon_read_property_this(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC); - if (phalcon_array_isset_string(ast, SS("fields"))) { + if (phalcon_array_isset_string_fetch(&fields, ast, SS("fields"))) { PHALCON_INIT_VAR(sql_fields); array_init(sql_fields); - PHALCON_OBS_VAR(fields); - phalcon_array_fetch_string(&fields, ast, SL("fields"), PH_NOISY); - phalcon_is_iterable(fields, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { @@ -2858,7 +2863,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareInsert){ PHALCON_GET_HVALUE(field); PHALCON_OBS_NVAR(name); - phalcon_array_fetch_string(&name, field, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&name, field, ISL(name), PH_NOISY); /** * Check that inserted fields are part of the model @@ -2884,10 +2889,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareInsert){ zend_hash_move_forward_ex(ah1, &hp1); } - phalcon_array_update_string(&sql_insert, SL("fields"), &sql_fields, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_insert, ISL(fields), &sql_fields, PH_COPY | PH_SEPARATE); } - phalcon_array_update_string(&sql_insert, SL("values"), &expr_values, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&sql_insert, ISL(values), &expr_values, PH_COPY | PH_SEPARATE); RETURN_CTOR(sql_insert); } @@ -2908,7 +2913,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareUpdate){ zval *complete_source = NULL, *alias = NULL, *sql_fields, *sql_values; zval *values, *update_values = NULL, *not_quoting = NULL, *update_value = NULL; zval *column = NULL, *sql_column = NULL, *expr_column = NULL, *expr_value = NULL; - zval *type = NULL, *value = NULL, *sql_update, *where, *where_expr; + zval *type = NULL, *value = NULL, *where, *where_expr; zval *limit, *sql_limit; HashTable *ah0, *ah1; HashPosition hp0, hp1; @@ -2967,8 +2972,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareUpdate){ PHALCON_CPY_WRT(update_tables, tables); } - PHALCON_OBS_VAR(manager); - phalcon_read_property_this(&manager, this_ptr, SL("_manager"), PH_NOISY_CC); + manager = phalcon_fetch_nproperty_this(this_ptr, SL("_manager"), PH_NOISY_CC); phalcon_is_iterable(update_tables, &ah0, &hp0, 0, 0); @@ -2980,7 +2984,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareUpdate){ phalcon_array_fetch_string(&qualified_name, table, SL("qualifiedName"), PH_NOISY); PHALCON_OBS_NVAR(model_name); - phalcon_array_fetch_string(&model_name, qualified_name, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&model_name, qualified_name, ISL(name), PH_NOISY); /** * Check if the table have a namespace alias @@ -3102,41 +3106,37 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareUpdate){ phalcon_call_method_p2(expr_value, this_ptr, "_getexpression", expr_column, not_quoting); PHALCON_OBS_NVAR(type); - phalcon_array_fetch_string(&type, expr_column, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, expr_column, ISL(type), PH_NOISY); PHALCON_INIT_NVAR(value); array_init_size(value, 2); - phalcon_array_update_string(&value, SL("type"), &type, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&value, ISL(type), &type, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&value, SL("value"), &expr_value, PH_COPY | PH_SEPARATE); phalcon_array_append(&sql_values, value, PH_SEPARATE); zend_hash_move_forward_ex(ah1, &hp1); } - PHALCON_INIT_VAR(sql_update); - array_init(sql_update); - phalcon_array_update_string(&sql_update, SL("tables"), &sql_tables, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_update, SL("models"), &sql_models, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_update, SL("fields"), &sql_fields, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_update, SL("values"), &sql_values, PH_COPY | PH_SEPARATE); - if (phalcon_array_isset_string(ast, SS("where"))) { - ZVAL_BOOL(not_quoting, 1); - - PHALCON_OBS_VAR(where); - phalcon_array_fetch_string(&where, ast, SL("where"), PH_NOISY); + array_init_size(return_value, 7); + phalcon_array_update_string(&return_value, ISL(tables), &sql_tables, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&return_value, ISL(models), &sql_models, PH_COPY); + phalcon_array_update_string(&return_value, ISL(fields), &sql_fields, PH_COPY); + phalcon_array_update_string(&return_value, ISL(values), &sql_values, PH_COPY); + if (phalcon_array_isset_string_fetch(&where, ast, SS("where"))) { + ZVAL_TRUE(not_quoting); PHALCON_INIT_VAR(where_expr); phalcon_call_method_p2(where_expr, this_ptr, "_getexpression", where, not_quoting); - phalcon_array_update_string(&sql_update, SL("where"), &where_expr, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&return_value, ISL(where), &where_expr, PH_COPY); } if (phalcon_array_isset_string_fetch(&limit, ast, SS("limit"))) { PHALCON_INIT_VAR(sql_limit); phalcon_call_method_p1(sql_limit, this_ptr, "_getlimitclause", limit); - phalcon_array_update_string(&sql_update, SL("limit"), &sql_limit, PH_COPY); + phalcon_array_update_string(&return_value, ISL(limit), &sql_limit, PH_COPY); } - RETURN_CTOR(sql_update); + RETURN_MM(); } /** @@ -3152,7 +3152,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareDelete){ zval *delete_tables = NULL, *manager, *table = NULL, *qualified_name = NULL; zval *model_name = NULL, *ns_alias = NULL, *real_namespace = NULL; zval *real_model_name = NULL, *model = NULL, *source = NULL, *schema = NULL; - zval *complete_source = NULL, *alias = NULL, *sql_delete, *not_quoting; + zval *complete_source = NULL, *alias = NULL, *not_quoting; zval *where, *where_expr; zval *limit, *sql_limit; HashTable *ah0; @@ -3207,8 +3207,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareDelete){ PHALCON_CPY_WRT(delete_tables, tables); } - PHALCON_OBS_VAR(manager); - phalcon_read_property_this(&manager, this_ptr, SL("_manager"), PH_NOISY_CC); + manager = phalcon_fetch_nproperty_this(this_ptr, SL("_manager"), PH_NOISY_CC); phalcon_is_iterable(delete_tables, &ah0, &hp0, 0, 0); @@ -3220,7 +3219,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareDelete){ phalcon_array_fetch_string(&qualified_name, table, SL("qualifiedName"), PH_NOISY); PHALCON_OBS_NVAR(model_name); - phalcon_array_fetch_string(&model_name, qualified_name, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&model_name, qualified_name, ISL(name), PH_NOISY); /** * Check if the table have a namespace alias @@ -3258,12 +3257,12 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareDelete){ if (zend_is_true(schema)) { PHALCON_INIT_NVAR(complete_source); array_init_size(complete_source, 2); - phalcon_array_append(&complete_source, source, PH_SEPARATE); - phalcon_array_append(&complete_source, schema, PH_SEPARATE); + phalcon_array_append(&complete_source, source, 0); + phalcon_array_append(&complete_source, schema, 0); } else { PHALCON_INIT_NVAR(complete_source); array_init_size(complete_source, 2); - phalcon_array_append(&complete_source, source, PH_SEPARATE); + phalcon_array_append(&complete_source, source, 0); add_next_index_null(complete_source); } @@ -3296,29 +3295,25 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareDelete){ phalcon_update_property_this(this_ptr, SL("_sqlAliases"), sql_aliases TSRMLS_CC); phalcon_update_property_this(this_ptr, SL("_sqlAliasesModelsInstances"), sql_aliases_models_instances TSRMLS_CC); - PHALCON_INIT_VAR(sql_delete); - array_init(sql_delete); - phalcon_array_update_string(&sql_delete, SL("tables"), &sql_tables, PH_COPY | PH_SEPARATE); - phalcon_array_update_string(&sql_delete, SL("models"), &sql_models, PH_COPY | PH_SEPARATE); - if (phalcon_array_isset_string(ast, SS("where"))) { + array_init_size(return_value, 4); + phalcon_array_update_string(&return_value, ISL(tables), &sql_tables, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&return_value, ISL(models), &sql_models, PH_COPY | PH_SEPARATE); + if (phalcon_array_isset_string_fetch(&where, ast, SS("where"))) { PHALCON_INIT_VAR(not_quoting); - ZVAL_BOOL(not_quoting, 1); - - PHALCON_OBS_VAR(where); - phalcon_array_fetch_string(&where, ast, SL("where"), PH_NOISY); + ZVAL_TRUE(not_quoting); PHALCON_INIT_VAR(where_expr); phalcon_call_method_p2(where_expr, this_ptr, "_getexpression", where, not_quoting); - phalcon_array_update_string(&sql_delete, SL("where"), &where_expr, PH_COPY | PH_SEPARATE); + phalcon_array_update_string(&return_value, ISL(where), &where_expr, PH_COPY); } if (phalcon_array_isset_string_fetch(&limit, ast, SS("limit"))) { PHALCON_INIT_VAR(sql_limit); phalcon_call_method_p1(sql_limit, this_ptr, "_getlimitclause", limit); - phalcon_array_update_string(&sql_delete, SL("limit"), &sql_limit, PH_COPY); + phalcon_array_update_string(&return_value, ISL(limit), &sql_limit, PH_COPY); } - RETURN_CTOR(sql_delete); + RETURN_MM(); } /** @@ -3381,7 +3376,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, parse){ * Assign the type to the query */ PHALCON_OBS_VAR(type); - phalcon_array_fetch_string(&type, ast, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, ast, ISL(type), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC); RETURN_CCTOR(ir_phql); } @@ -3391,14 +3386,14 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, parse){ /** * A valid AST must have a type */ - if (phalcon_array_isset_string(ast, SS("type"))) { + if (phalcon_array_isset_string(ast, ISS(type))) { phalcon_update_property_this(this_ptr, SL("_ast"), ast TSRMLS_CC); /** * Produce an independent database system representation */ PHALCON_OBS_NVAR(type); - phalcon_array_fetch_string(&type, ast, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, ast, ISL(type), PH_NOISY); phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC); switch (phalcon_get_intval(type)) { @@ -3516,7 +3511,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect){ zval *sql_alias = NULL, *dialect, *sql_select, *processed = NULL; zval *value = NULL, *wildcard = NULL, *string_wildcard = NULL, *processed_types = NULL; zval *type_wildcard = NULL, *result, *count, *result_data = NULL; - zval *cache, *result_object = NULL, *resultset = NULL; + zval *cache, *result_object = NULL; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5, *ah6; HashPosition hp0, hp1, hp2, hp3, hp4, hp5, hp6; zval **hd; @@ -3659,7 +3654,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect){ PHALCON_GET_HVALUE(column); PHALCON_OBS_NVAR(column_type); - phalcon_array_fetch_string(&column_type, column, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&column_type, column, ISL(type), PH_NOISY); if (PHALCON_IS_STRING(column_type, "scalar")) { if (!phalcon_array_isset_string(column, SS("balias"))) { PHALCON_INIT_NVAR(is_complex); @@ -3723,7 +3718,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect){ PHALCON_GET_HVALUE(column); PHALCON_OBS_NVAR(type); - phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, column, ISL(type), PH_NOISY); PHALCON_OBS_NVAR(sql_column); phalcon_array_fetch_string(&sql_column, column, SL("column"), PH_NOISY); @@ -3776,9 +3771,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect){ PHALCON_INIT_NVAR(column_alias); array_init_size(column_alias, 3); - phalcon_array_append(&column_alias, attribute, PH_SEPARATE); - phalcon_array_append(&column_alias, sql_column, PH_SEPARATE); - phalcon_array_append(&column_alias, hidden_alias, PH_SEPARATE); + phalcon_array_append(&column_alias, attribute, 0); + phalcon_array_append(&column_alias, sql_column, 0); + phalcon_array_append(&column_alias, hidden_alias, 0); phalcon_array_append(&select_columns, column_alias, PH_SEPARATE); zend_hash_move_forward_ex(ah3, &hp3); @@ -3826,14 +3821,14 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect){ if (Z_TYPE_P(alias_copy) == IS_LONG) { PHALCON_INIT_NVAR(column_alias); array_init_size(column_alias, 2); - phalcon_array_append(&column_alias, sql_column, PH_SEPARATE); - phalcon_array_append(&column_alias, znull, PH_SEPARATE); + phalcon_array_append(&column_alias, sql_column, 0); + phalcon_array_append(&column_alias, znull, 0); } else { PHALCON_INIT_NVAR(column_alias); array_init_size(column_alias, 3); - phalcon_array_append(&column_alias, sql_column, PH_SEPARATE); - phalcon_array_append(&column_alias, znull, PH_SEPARATE); - phalcon_array_append(&column_alias, alias_copy, PH_SEPARATE); + phalcon_array_append(&column_alias, sql_column, 0); + phalcon_array_append(&column_alias, znull, 0); + phalcon_array_append(&column_alias, alias_copy, 0); } phalcon_array_append(&select_columns, column_alias, PH_SEPARATE); } @@ -3843,9 +3838,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect){ */ if (PHALCON_IS_FALSE(is_complex)) { if (PHALCON_IS_TRUE(is_simple_std)) { - if (phalcon_array_isset_string(column, SS("sqlAlias"))) { - PHALCON_OBS_NVAR(sql_alias); - phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY); + if (phalcon_array_isset_string_fetch(&sql_alias, column, SS("sqlAlias"))) { phalcon_array_update_zval(&simple_column_map, sql_alias, &alias_copy, PH_COPY | PH_SEPARATE); } else { phalcon_array_update_zval(&simple_column_map, alias_copy, &alias_copy, PH_COPY | PH_SEPARATE); @@ -3989,21 +3982,19 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect){ /** * Simple resultsets contains only complete objects */ - PHALCON_INIT_VAR(resultset); - object_init_ex(resultset, phalcon_mvc_model_resultset_simple_ce); - phalcon_call_method_p5_noret(resultset, "__construct", simple_column_map, result_object, result_data, cache, is_keeping_snapshots); + object_init_ex(return_value, phalcon_mvc_model_resultset_simple_ce); + phalcon_call_method_p5_noret(return_value, "__construct", simple_column_map, result_object, result_data, cache, is_keeping_snapshots); - RETURN_CTOR(resultset); + RETURN_MM(); } /** * Complex resultsets may contain complete objects and scalars */ - PHALCON_INIT_NVAR(resultset); - object_init_ex(resultset, phalcon_mvc_model_resultset_complex_ce); - phalcon_call_method_p3_noret(resultset, "__construct", columns, result_data, cache); + object_init_ex(return_value, phalcon_mvc_model_resultset_complex_ce); + phalcon_call_method_p3_noret(return_value, "__construct", columns, result_data, cache); - RETURN_CTOR(resultset); + RETURN_MM(); } /** @@ -4111,7 +4102,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeInsert){ ZVAL_STRING(double_colon, ":", 1); PHALCON_INIT_VAR(empty_string); - ZVAL_STRING(empty_string, "", 1); + ZVAL_EMPTY_STRING(empty_string); PHALCON_INIT_VAR(null_value); @@ -4129,7 +4120,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeInsert){ PHALCON_GET_HVALUE(value); PHALCON_OBS_NVAR(type); - phalcon_array_fetch_string(&type, value, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, value, ISL(type), PH_NOISY); PHALCON_OBS_NVAR(expr_value); phalcon_array_fetch_string(&expr_value, value, SL("value"), PH_NOISY); @@ -4282,7 +4273,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _getRelatedRecords){ PHALCON_INIT_VAR(a0); array_init_size(a0, 3); - add_assoc_stringl_ex(a0, SS("type"), SL("object"), 1); + add_assoc_stringl_ex(a0, ISS(type), SL("object"), 1); phalcon_array_update_string(&a0, SL("model"), &model_name, PH_COPY | PH_SEPARATE); phalcon_array_update_string(&a0, SL("column"), &source, PH_COPY | PH_SEPARATE); phalcon_array_append(&select_column, a0, PH_SEPARATE); @@ -4406,7 +4397,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeUpdate){ ZVAL_STRING(double_colon, ":", 1); PHALCON_INIT_VAR(empty_string); - ZVAL_STRING(empty_string, "", 1); + ZVAL_EMPTY_STRING(empty_string); PHALCON_OBS_VAR(fields); phalcon_array_fetch_string(&fields, intermediate, SL("fields"), PH_NOISY); @@ -4437,13 +4428,13 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeUpdate){ PHALCON_GET_HVALUE(field); PHALCON_OBS_NVAR(field_name); - phalcon_array_fetch_string(&field_name, field, SL("name"), PH_NOISY); + phalcon_array_fetch_string(&field_name, field, ISL(name), PH_NOISY); PHALCON_OBS_NVAR(value); phalcon_array_fetch(&value, values, number, PH_NOISY); PHALCON_OBS_NVAR(type); - phalcon_array_fetch_string(&type, value, SL("type"), PH_NOISY); + phalcon_array_fetch_string(&type, value, ISL(type), PH_NOISY); PHALCON_OBS_NVAR(expr_value); phalcon_array_fetch_string(&expr_value, value, SL("value"), PH_NOISY); @@ -4637,7 +4628,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeDelete){ */ if (!phalcon_fast_count_ev(records TSRMLS_CC)) { PHALCON_INIT_VAR(success); - ZVAL_BOOL(success, 1); + ZVAL_TRUE(success); PHALCON_INIT_VAR(null_value); object_init_ex(return_value, phalcon_mvc_model_query_status_ce); @@ -4695,10 +4686,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, _executeDelete){ phalcon_call_method_noret(connection, "commit"); PHALCON_INIT_NVAR(success); - ZVAL_BOOL(success, 1); + ZVAL_TRUE(success); PHALCON_INIT_NVAR(null_value); - ZVAL_BOOL(null_value, 1); + ZVAL_TRUE(null_value); /** * Create a status to report the deletion status @@ -4778,7 +4769,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query, execute){ phalcon_array_fetch_string(&cache_service, cache_options, SL("service"), PH_NOISY); } else { PHALCON_INIT_NVAR(cache_service); - ZVAL_STRING(cache_service, "modelsCache", 1); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(cache_service, phalcon_interned_modelsCache); } PHALCON_OBS_VAR(dependency_injector); diff --git a/ext/mvc/model/query/builder.c b/ext/mvc/model/query/builder.c index 0d782688977..febc03cd822 100644 --- a/ext/mvc/model/query/builder.c +++ b/ext/mvc/model/query/builder.c @@ -42,6 +42,8 @@ #include "kernel/file.h" #include "kernel/hash.h" +#include "interned-strings.h" + /** * Phalcon\Mvc\Model\Query\Builder * @@ -101,95 +103,65 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct){ zval *order_clause, *limit_clause, *for_update; zval *shared_lock; - PHALCON_MM_GROW(); - - phalcon_fetch_params(1, 0, 2, ¶ms, &dependency_injector); + phalcon_fetch_params(0, 0, 2, ¶ms, &dependency_injector); - if (!params) { - PHALCON_INIT_VAR(params); - } - - if (!dependency_injector) { - PHALCON_INIT_VAR(dependency_injector); - } - - if (Z_TYPE_P(params) == IS_ARRAY) { + if (params && 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); + if (phalcon_array_isset_long_fetch(&conditions, params, 0)) { + phalcon_update_property_this(this_ptr, SL("_conditions"), conditions TSRMLS_CC); + } else if (phalcon_array_isset_string_fetch(&conditions, params, SS("conditions"))) { phalcon_update_property_this(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); - phalcon_update_property_this(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); + if (phalcon_array_isset_string_fetch(&columns, params, SS("columns"))) { phalcon_update_property_this(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); + if (phalcon_array_isset_string_fetch(&group_clause, params, SS("group"))) { phalcon_update_property_this(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); - phalcon_update_property_this(this_ptr, SL("_group"), having_clause TSRMLS_CC); + if (phalcon_array_isset_string_fetch(&having_clause, params, SS("having"))) { + phalcon_update_property_this(this_ptr, SL("_having"), 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); + if (phalcon_array_isset_string_fetch(&order_clause, params, SS("order"))) { phalcon_update_property_this(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); + if (phalcon_array_isset_string_fetch(&limit_clause, params, SS("limit"))) { phalcon_update_property_this(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); + if (phalcon_array_isset_string_fetch(&for_update, params, SS("for_update"))) { phalcon_update_property_this(this_ptr, SL("_forUpdate"), for_update 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); + if (phalcon_array_isset_string_fetch(&shared_lock, params, SS("shared_lock"))) { phalcon_update_property_this(this_ptr, SL("_sharedLock"), shared_lock TSRMLS_CC); } } @@ -197,11 +169,9 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct){ /** * Update the dependency injector if any */ - if (Z_TYPE_P(dependency_injector) == IS_OBJECT) { + if (dependency_injector && Z_TYPE_P(dependency_injector) == IS_OBJECT) { phalcon_update_property_this(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC); } - - PHALCON_MM_RESTORE(); } /** @@ -420,10 +390,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, join){ PHALCON_INIT_VAR(join); array_init_size(join, 4); - phalcon_array_append(&join, model, PH_SEPARATE); - phalcon_array_append(&join, conditions, PH_SEPARATE); - phalcon_array_append(&join, alias, PH_SEPARATE); - phalcon_array_append(&join, type, PH_SEPARATE); + phalcon_array_append(&join, model, 0); + phalcon_array_append(&join, conditions, 0); + phalcon_array_append(&join, alias, 0); + phalcon_array_append(&join, type, 0); phalcon_update_property_array_append(this_ptr, SL("_joins"), join TSRMLS_CC); RETURN_THIS(); } @@ -465,10 +435,10 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, innerJoin){ PHALCON_INIT_VAR(join); array_init_size(join, 4); - phalcon_array_append(&join, model, PH_SEPARATE); - phalcon_array_append(&join, conditions, PH_SEPARATE); - phalcon_array_append(&join, alias, PH_SEPARATE); - phalcon_array_append(&join, type, PH_SEPARATE); + phalcon_array_append(&join, model, 0); + phalcon_array_append(&join, conditions, 0); + phalcon_array_append(&join, alias, 0); + phalcon_array_append(&join, type, 0); phalcon_update_property_array_append(this_ptr, SL("_joins"), join TSRMLS_CC); RETURN_THIS(); } @@ -1342,7 +1312,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){ } PHALCON_INIT_VAR(service_name); - ZVAL_STRING(service_name, "modelsMetadata", 1); + PHALCON_ZVAL_MAYBE_INTERNED_STRING(service_name, phalcon_interned_modelsMetadata); /** * Get the models metadata service to obtain the column names, column map and @@ -1752,7 +1722,7 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){ */ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getQuery){ - zval *phql, *dependency_injector, *query, *bind_params; + zval *phql, *dependency_injector, *bind_params; zval *bind_types; PHALCON_MM_GROW(); @@ -1760,36 +1730,32 @@ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getQuery){ /** * Process the PHQL */ - PHALCON_INIT_VAR(phql); - phalcon_call_method(phql, this_ptr, "getphql"); + PHALCON_OBS_VAR(phql); + phalcon_call_method_p0_ex(phql, &phql, this_ptr, "getphql"); - PHALCON_OBS_VAR(dependency_injector); - phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); + dependency_injector = phalcon_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); - PHALCON_INIT_VAR(query); - object_init_ex(query, phalcon_mvc_model_query_ce); - phalcon_call_method_p2_noret(query, "__construct", phql, dependency_injector); + object_init_ex(return_value, phalcon_mvc_model_query_ce); + phalcon_call_method_p2_noret(return_value, "__construct", phql, dependency_injector); - PHALCON_OBS_VAR(bind_params); - phalcon_read_property_this(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY_CC); + bind_params = phalcon_fetch_nproperty_this(this_ptr, SL("_bindParams"), PH_NOISY_CC); /** * Set default bind params */ if (Z_TYPE_P(bind_params) == IS_ARRAY) { - phalcon_call_method_p1_noret(query, "setbindparams", bind_params); + phalcon_call_method_p1_noret(return_value, "setbindparams", bind_params); } - PHALCON_OBS_VAR(bind_types); - phalcon_read_property_this(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY_CC); + bind_types = phalcon_fetch_nproperty_this(this_ptr, SL("_bindTypes"), PH_NOISY_CC); /** * Set default bind params */ if (Z_TYPE_P(bind_types) == IS_ARRAY) { - phalcon_call_method_p1_noret(query, "setbindtypes", bind_types); + phalcon_call_method_p1_noret(return_value, "setbindtypes", bind_types); } - RETURN_CTOR(query); + RETURN_MM(); } diff --git a/ext/mvc/model/query/parser.c b/ext/mvc/model/query/parser.c index 3cae285320e..66601c9a240 100644 --- a/ext/mvc/model/query/parser.c +++ b/ext/mvc/model/query/parser.c @@ -24,15 +24,17 @@ #include "kernel/fcall.h" #include "kernel/exception.h" +#include "interned-strings.h" + static zval *phql_ret_literal_zval(int type, phql_parser_token *T) { zval *ret; MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", type); + add_assoc_long(ret, phalcon_interned_type, type); if (T) { - add_assoc_stringl(ret, "value", T->token, T->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_value, T->token, T->token_len, 0); efree(T); } @@ -45,8 +47,8 @@ static zval *phql_ret_placeholder_zval(int type, phql_parser_token *T) MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_long(ret, "type", type); - add_assoc_stringl(ret, "value", T->token, T->token_len, 0); + add_assoc_long(ret, phalcon_interned_type, type); + add_assoc_stringl(ret, phalcon_interned_value, T->token, T->token_len, 0); efree(T); return ret; @@ -59,19 +61,19 @@ static zval *phql_ret_qualified_name(phql_parser_token *A, phql_parser_token *B, MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_QUALIFIED); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_QUALIFIED); if (A != NULL) { - add_assoc_stringl(ret, "ns-alias", A->token, A->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_ns_alias, A->token, A->token_len, 0); efree(A); } if (B != NULL) { - add_assoc_stringl(ret, "domain", B->token, B->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_domain, B->token, B->token_len, 0); efree(B); } - add_assoc_stringl(ret, "name", C->token, C->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_name, C->token, C->token_len, 0); efree(C); return ret; @@ -84,13 +86,13 @@ static zval *phql_ret_raw_qualified_name(phql_parser_token *A, phql_parser_token MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_RAW_QUALIFIED); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_RAW_QUALIFIED); if (B != NULL) { - add_assoc_stringl(ret, "domain", A->token, A->token_len, 0); - add_assoc_stringl(ret, "name", B->token, B->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_domain, A->token, A->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_name, B->token, B->token_len, 0); efree(B); } else { - add_assoc_stringl(ret, "name", A->token, A->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_name, A->token, A->token_len, 0); } efree(A); @@ -104,23 +106,23 @@ static zval *phql_ret_select_statement(zval *S, zval *W, zval *O, zval *G, zval MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_SELECT); - add_assoc_zval(ret, "select", S); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_SELECT); + add_assoc_zval(ret, phalcon_interned_select, S); if (W != NULL) { - add_assoc_zval(ret, "where", W); + add_assoc_zval(ret, phalcon_interned_where, W); } if (O != NULL) { - add_assoc_zval(ret, "orderBy", O); + add_assoc_zval(ret, phalcon_interned_orderBy, O); } if (G != NULL) { - add_assoc_zval(ret, "groupBy", G); + add_assoc_zval(ret, phalcon_interned_groupBy, G); } if (H != NULL) { - add_assoc_zval(ret, "having", H); + add_assoc_zval(ret, phalcon_interned_having, H); } if (L != NULL) { - add_assoc_zval(ret, "limit", L); + add_assoc_zval(ret, phalcon_interned_limit, L); } return ret; @@ -131,16 +133,16 @@ static zval *phql_ret_select_clause(zval *distinct, zval *columns, zval *tables, zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); + array_init_size(ret, 4); if (distinct) { - add_assoc_zval(ret, "distinct", distinct); + add_assoc_zval(ret, phalcon_interned_distinct, distinct); } - add_assoc_zval(ret, "columns", columns); - add_assoc_zval(ret, "tables", tables); + add_assoc_zval(ret, phalcon_interned_columns, columns); + add_assoc_zval(ret, phalcon_interned_tables, tables); if (join_list) { - add_assoc_zval(ret, "joins", join_list); + add_assoc_zval(ret, phalcon_interned_joins, join_list); } return ret; @@ -172,9 +174,9 @@ static zval *phql_ret_order_item(zval *column, int sort){ MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_zval(ret, "column", column); + add_assoc_zval(ret, phalcon_interned_column, column); if (sort != 0 ) { - add_assoc_long(ret, "sort", sort); + add_assoc_long(ret, phalcon_interned_sort, sort); } return ret; @@ -187,10 +189,10 @@ static zval *phql_ret_limit_clause(zval *L, zval *O) MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_zval(ret, "number", L); + add_assoc_zval(ret, phalcon_interned_number, L); if (O != NULL) { - add_assoc_zval(ret, "offset", O); + add_assoc_zval(ret, phalcon_interned_offset, O); } return ret; @@ -201,14 +203,14 @@ static zval *phql_ret_insert_statement(zval *Q, zval *F, zval *V) zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); + array_init_size(ret, 4); - add_assoc_long(ret, "type", PHQL_T_INSERT); - add_assoc_zval(ret, "qualifiedName", Q); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_INSERT); + add_assoc_zval(ret, phalcon_interned_qualifiedName, Q); if (F != NULL) { - add_assoc_zval(ret, "fields", F); + add_assoc_zval(ret, phalcon_interned_fields, F); } - add_assoc_zval(ret, "values", V); + add_assoc_zval(ret, phalcon_interned_values, V); return ret; } @@ -220,13 +222,13 @@ static zval *phql_ret_update_statement(zval *U, zval *W, zval *L) MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_UPDATE); - add_assoc_zval(ret, "update", U); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_UPDATE); + add_assoc_zval(ret, phalcon_interned_update, U); if (W != NULL) { - add_assoc_zval(ret, "where", W); + add_assoc_zval(ret, phalcon_interned_where, W); } if (L != NULL) { - add_assoc_zval(ret, "limit", L); + add_assoc_zval(ret, phalcon_interned_limit, L); } return ret; @@ -238,21 +240,20 @@ static zval *phql_ret_update_clause(zval *tables, zval *values) MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_zval(ret, "tables", tables); - add_assoc_zval(ret, "values", values); + add_assoc_zval(ret, phalcon_interned_tables, tables); + add_assoc_zval(ret, phalcon_interned_values, values); return ret; } static zval *phql_ret_update_item(zval *column, zval *expr) { - zval *ret; MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_zval(ret, "column", column); - add_assoc_zval(ret, "expr", expr); + add_assoc_zval(ret, phalcon_interned_column, column); + add_assoc_zval(ret, phalcon_interned_expr, expr); return ret; } @@ -264,13 +265,13 @@ static zval *phql_ret_delete_statement(zval *D, zval *W, zval *L) MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_DELETE); - add_assoc_zval(ret, "delete", D); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_DELETE); + add_assoc_zval(ret, phalcon_interned_delete, D); if (W != NULL) { - add_assoc_zval(ret, "where", W); + add_assoc_zval(ret, phalcon_interned_where, W); } if (L != NULL) { - add_assoc_zval(ret, "limit", L); + add_assoc_zval(ret, phalcon_interned_limit, L); } return ret; @@ -282,16 +283,14 @@ static zval *phql_ret_delete_clause(zval *tables) MAKE_STD_ZVAL(ret); array_init_size(ret, 1); - add_assoc_zval(ret, "tables", tables); + add_assoc_zval(ret, phalcon_interned_tables, tables); return ret; } static zval *phql_ret_zval_list(zval *list_left, zval *right_list) { - zval *ret; - HashPosition pos; HashTable *list; MAKE_STD_ZVAL(ret); @@ -299,19 +298,18 @@ static zval *phql_ret_zval_list(zval *list_left, zval *right_list) list = Z_ARRVAL_P(list_left); if (zend_hash_index_exists(list, 0)) { - zend_hash_internal_pointer_reset_ex(list, &pos); - for (;; zend_hash_move_forward_ex(list, &pos)) { - - zval ** item; - - if (zend_hash_get_current_data_ex(list, (void**)&item, &pos) == FAILURE) { - break; - } - + HashPosition pos; + zval **item; + + for ( + zend_hash_internal_pointer_reset_ex(list, &pos); + zend_hash_get_current_data_ex(list, (void**)&item, &pos) != FAILURE; + zend_hash_move_forward_ex(list, &pos) + ) { Z_ADDREF_PP(item); add_next_index_zval(ret, *item); - } + zval_ptr_dtor(&list_left); } else { add_next_index_zval(ret, list_left); @@ -326,21 +324,20 @@ static zval *phql_ret_zval_list(zval *list_left, zval *right_list) static zval *phql_ret_column_item(int type, zval *column, phql_parser_token *identifier_column, phql_parser_token *alias) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_long(ret, "type", type); + array_init_size(ret, 4); + add_assoc_long(ret, phalcon_interned_type, type); if (column) { - add_assoc_zval(ret, "column", column); + add_assoc_zval(ret, phalcon_interned_column, column); } if (identifier_column) { - add_assoc_stringl(ret, "column", identifier_column->token, identifier_column->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_column, identifier_column->token, identifier_column->token_len, 0); efree(identifier_column); } if (alias) { - add_assoc_stringl(ret, "alias", alias->token, alias->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_alias, alias->token, alias->token_len, 0); efree(alias); } @@ -349,19 +346,17 @@ static zval *phql_ret_column_item(int type, zval *column, phql_parser_token *ide static zval *phql_ret_assoc_name(zval *qualified_name, phql_parser_token *alias) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_zval(ret, "qualifiedName", qualified_name); + array_init_size(ret, 2); + add_assoc_zval(ret, phalcon_interned_qualifiedName, qualified_name); if (alias) { - add_assoc_stringl(ret, "alias", alias->token, alias->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_alias, alias->token, alias->token_len, 0); efree(alias); } return ret; - } static zval *phql_ret_join_type(int type) @@ -376,27 +371,25 @@ static zval *phql_ret_join_type(int type) static zval *phql_ret_join_item(zval *type, zval *qualified, zval *alias, zval *conditions) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_zval(ret, "type", type); + array_init_size(ret, 4); + add_assoc_zval(ret, phalcon_interned_type, type); if (qualified) { - add_assoc_zval(ret, "qualified", qualified); + add_assoc_zval(ret, phalcon_interned_qualified, qualified); } if (alias) { - add_assoc_zval(ret, "alias", alias); + add_assoc_zval(ret, phalcon_interned_alias, alias); } if (conditions) { - add_assoc_zval(ret, "conditions", conditions); + add_assoc_zval(ret, phalcon_interned_conditions, conditions); } return ret; - } static zval *phql_ret_expr(int type, zval *left, zval *right) @@ -404,13 +397,13 @@ static zval *phql_ret_expr(int type, zval *left, zval *right) zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_long(ret, "type", type); + array_init_size(ret, 2); + add_assoc_long(ret, phalcon_interned_type, type); if (left) { - add_assoc_zval(ret, "left", left); + add_assoc_zval(ret, phalcon_interned_left, left); } if (right) { - add_assoc_zval(ret, "right", right); + add_assoc_zval(ret, phalcon_interned_right, right); } return ret; @@ -418,28 +411,27 @@ static zval *phql_ret_expr(int type, zval *left, zval *right) static zval *phql_ret_func_call(phql_parser_token *name, zval *arguments, zval *distinct) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_long(ret, "type", PHQL_T_FCALL); - add_assoc_stringl(ret, "name", name->token, name->token_len, 0); + array_init_size(ret, 4); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_FCALL); + add_assoc_stringl(ret, phalcon_interned_name, name->token, name->token_len, 0); efree(name); if (arguments) { - add_assoc_zval(ret, "arguments", arguments); + add_assoc_zval(ret, phalcon_interned_arguments, arguments); } if (distinct) { - add_assoc_zval(ret, "distinct", distinct); + add_assoc_zval(ret, phalcon_interned_distinct, distinct); } return ret; } -/* #line 443 "parser.c" */ +/* #line 435 "parser.c" */ /* Next is all token values, in a form suitable for use by makeheaders. ** This section will be null unless lemon is run with the -m switch. */ @@ -1158,7 +1150,7 @@ static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ case 67: case 68: case 69: -/* #line 541 "parser.y" */ +/* #line 533 "parser.y" */ { if ((yypminor->yy0)) { if ((yypminor->yy0)->free_flag) { @@ -1167,7 +1159,7 @@ static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ efree((yypminor->yy0)); } } -/* #line 1171 "parser.c" */ +/* #line 1163 "parser.c" */ break; case 72: case 73: @@ -1200,9 +1192,9 @@ static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ case 114: case 115: case 118: -/* #line 554 "parser.y" */ +/* #line 546 "parser.y" */ { zval_ptr_dtor(&(yypminor->yy92)); } -/* #line 1206 "parser.c" */ +/* #line 1198 "parser.c" */ break; case 78: case 79: @@ -1215,9 +1207,9 @@ static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ case 103: case 116: case 117: -/* #line 842 "parser.y" */ +/* #line 834 "parser.y" */ { phalcon_safe_zval_ptr_dtor((yypminor->yy92)); } -/* #line 1221 "parser.c" */ +/* #line 1213 "parser.c" */ break; default: break; /* If no destructor action specified: do nothing */ } @@ -1569,11 +1561,11 @@ static void yy_reduce( ** break; */ case 0: -/* #line 550 "parser.y" */ +/* #line 542 "parser.y" */ { status->ret = yymsp[0].minor.yy92; } -/* #line 1577 "parser.c" */ +/* #line 1569 "parser.c" */ break; case 1: case 2: @@ -1597,43 +1589,43 @@ static void yy_reduce( case 114: case 119: case 126: -/* #line 556 "parser.y" */ +/* #line 548 "parser.y" */ { yygotominor.yy92 = yymsp[0].minor.yy92; } -/* #line 1605 "parser.c" */ +/* #line 1597 "parser.c" */ break; case 5: -/* #line 574 "parser.y" */ +/* #line 566 "parser.y" */ { yygotominor.yy92 = phql_ret_select_statement(yymsp[-5].minor.yy92, yymsp[-4].minor.yy92, yymsp[-1].minor.yy92, yymsp[-3].minor.yy92, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); } -/* #line 1612 "parser.c" */ +/* #line 1604 "parser.c" */ break; case 6: -/* #line 580 "parser.y" */ +/* #line 572 "parser.y" */ { yygotominor.yy92 = phql_ret_select_clause(yymsp[-4].minor.yy92, yymsp[-3].minor.yy92, yymsp[-1].minor.yy92, yymsp[0].minor.yy92); yy_destructor(26,&yymsp[-5].minor); yy_destructor(27,&yymsp[-2].minor); } -/* #line 1621 "parser.c" */ +/* #line 1613 "parser.c" */ break; case 7: -/* #line 586 "parser.y" */ +/* #line 578 "parser.y" */ { yygotominor.yy92 = phql_ret_distinct_all(1); yy_destructor(28,&yymsp[0].minor); } -/* #line 1629 "parser.c" */ +/* #line 1621 "parser.c" */ break; case 8: -/* #line 590 "parser.y" */ +/* #line 582 "parser.y" */ { yygotominor.yy92 = phql_ret_distinct_all(0); yy_destructor(29,&yymsp[0].minor); } -/* #line 1637 "parser.c" */ +/* #line 1629 "parser.c" */ break; case 9: case 20: @@ -1647,11 +1639,11 @@ static void yy_reduce( case 80: case 113: case 115: -/* #line 594 "parser.y" */ +/* #line 586 "parser.y" */ { yygotominor.yy92 = NULL; } -/* #line 1655 "parser.c" */ +/* #line 1647 "parser.c" */ break; case 10: case 17: @@ -1661,177 +1653,177 @@ static void yy_reduce( case 63: case 70: case 116: -/* #line 600 "parser.y" */ +/* #line 592 "parser.y" */ { yygotominor.yy92 = phql_ret_zval_list(yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(25,&yymsp[-1].minor); } -/* #line 1670 "parser.c" */ +/* #line 1662 "parser.c" */ break; case 12: case 118: -/* #line 610 "parser.y" */ +/* #line 602 "parser.y" */ { yygotominor.yy92 = phql_ret_column_item(PHQL_T_STARALL, NULL, NULL, NULL); yy_destructor(17,&yymsp[0].minor); } -/* #line 1679 "parser.c" */ +/* #line 1671 "parser.c" */ break; case 13: -/* #line 614 "parser.y" */ +/* #line 606 "parser.y" */ { yygotominor.yy92 = phql_ret_column_item(PHQL_T_DOMAINALL, NULL, yymsp[-2].minor.yy0, NULL); yy_destructor(31,&yymsp[-1].minor); yy_destructor(17,&yymsp[0].minor); } -/* #line 1688 "parser.c" */ +/* #line 1680 "parser.c" */ break; case 14: -/* #line 618 "parser.y" */ +/* #line 610 "parser.y" */ { yygotominor.yy92 = phql_ret_column_item(PHQL_T_EXPR, yymsp[-2].minor.yy92, NULL, yymsp[0].minor.yy0); yy_destructor(32,&yymsp[-1].minor); } -/* #line 1696 "parser.c" */ +/* #line 1688 "parser.c" */ break; case 15: -/* #line 622 "parser.y" */ +/* #line 614 "parser.y" */ { yygotominor.yy92 = phql_ret_column_item(PHQL_T_EXPR, yymsp[-1].minor.yy92, NULL, yymsp[0].minor.yy0); } -/* #line 1703 "parser.c" */ +/* #line 1695 "parser.c" */ break; case 16: -/* #line 626 "parser.y" */ +/* #line 618 "parser.y" */ { yygotominor.yy92 = phql_ret_column_item(PHQL_T_EXPR, yymsp[0].minor.yy92, NULL, NULL); } -/* #line 1710 "parser.c" */ +/* #line 1702 "parser.c" */ break; case 21: -/* #line 650 "parser.y" */ +/* #line 642 "parser.y" */ { yygotominor.yy92 = phql_ret_zval_list(yymsp[-1].minor.yy92, yymsp[0].minor.yy92); } -/* #line 1717 "parser.c" */ +/* #line 1709 "parser.c" */ break; case 24: -/* #line 667 "parser.y" */ +/* #line 659 "parser.y" */ { yygotominor.yy92 = phql_ret_join_item(yymsp[-3].minor.yy92, yymsp[-2].minor.yy92, yymsp[-1].minor.yy92, yymsp[0].minor.yy92); } -/* #line 1724 "parser.c" */ +/* #line 1716 "parser.c" */ break; case 25: -/* #line 673 "parser.y" */ +/* #line 665 "parser.y" */ { yygotominor.yy92 = phql_ret_qualified_name(NULL, NULL, yymsp[0].minor.yy0); yy_destructor(32,&yymsp[-1].minor); } -/* #line 1732 "parser.c" */ +/* #line 1724 "parser.c" */ break; case 26: case 46: case 138: -/* #line 677 "parser.y" */ +/* #line 669 "parser.y" */ { yygotominor.yy92 = phql_ret_qualified_name(NULL, NULL, yymsp[0].minor.yy0); } -/* #line 1741 "parser.c" */ +/* #line 1733 "parser.c" */ break; case 28: -/* #line 687 "parser.y" */ +/* #line 679 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_INNERJOIN); yy_destructor(33,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1750 "parser.c" */ +/* #line 1742 "parser.c" */ break; case 29: -/* #line 691 "parser.y" */ +/* #line 683 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_CROSSJOIN); yy_destructor(35,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1759 "parser.c" */ +/* #line 1751 "parser.c" */ break; case 30: -/* #line 695 "parser.y" */ +/* #line 687 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_LEFTJOIN); yy_destructor(36,&yymsp[-2].minor); yy_destructor(37,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1769 "parser.c" */ +/* #line 1761 "parser.c" */ break; case 31: -/* #line 699 "parser.y" */ +/* #line 691 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_LEFTJOIN); yy_destructor(36,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1778 "parser.c" */ +/* #line 1770 "parser.c" */ break; case 32: -/* #line 703 "parser.y" */ +/* #line 695 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_RIGHTJOIN); yy_destructor(38,&yymsp[-2].minor); yy_destructor(37,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1788 "parser.c" */ +/* #line 1780 "parser.c" */ break; case 33: -/* #line 707 "parser.y" */ +/* #line 699 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_RIGHTJOIN); yy_destructor(38,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1797 "parser.c" */ +/* #line 1789 "parser.c" */ break; case 34: -/* #line 711 "parser.y" */ +/* #line 703 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_FULLJOIN); yy_destructor(39,&yymsp[-2].minor); yy_destructor(37,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1807 "parser.c" */ +/* #line 1799 "parser.c" */ break; case 35: -/* #line 715 "parser.y" */ +/* #line 707 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_FULLJOIN); yy_destructor(39,&yymsp[-1].minor); yy_destructor(34,&yymsp[0].minor); } -/* #line 1816 "parser.c" */ +/* #line 1808 "parser.c" */ break; case 36: -/* #line 719 "parser.y" */ +/* #line 711 "parser.y" */ { yygotominor.yy92 = phql_ret_join_type(PHQL_T_INNERJOIN); yy_destructor(34,&yymsp[0].minor); } -/* #line 1824 "parser.c" */ +/* #line 1816 "parser.c" */ break; case 37: -/* #line 725 "parser.y" */ +/* #line 717 "parser.y" */ { yygotominor.yy92 = yymsp[0].minor.yy92; yy_destructor(40,&yymsp[-1].minor); } -/* #line 1832 "parser.c" */ +/* #line 1824 "parser.c" */ break; case 39: -/* #line 736 "parser.y" */ +/* #line 728 "parser.y" */ { yygotominor.yy92 = phql_ret_insert_statement(yymsp[-4].minor.yy92, NULL, yymsp[-1].minor.yy92); yy_destructor(41,&yymsp[-6].minor); @@ -1840,10 +1832,10 @@ static void yy_reduce( yy_destructor(44,&yymsp[-2].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 1844 "parser.c" */ +/* #line 1836 "parser.c" */ break; case 40: -/* #line 740 "parser.y" */ +/* #line 732 "parser.y" */ { yygotominor.yy92 = phql_ret_insert_statement(yymsp[-7].minor.yy92, yymsp[-5].minor.yy92, yymsp[-1].minor.yy92); yy_destructor(41,&yymsp[-9].minor); @@ -1854,360 +1846,360 @@ static void yy_reduce( yy_destructor(44,&yymsp[-2].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 1858 "parser.c" */ +/* #line 1850 "parser.c" */ break; case 47: -/* #line 778 "parser.y" */ +/* #line 770 "parser.y" */ { yygotominor.yy92 = phql_ret_update_statement(yymsp[-2].minor.yy92, yymsp[-1].minor.yy92, yymsp[0].minor.yy92); } -/* #line 1865 "parser.c" */ +/* #line 1857 "parser.c" */ break; case 48: -/* #line 784 "parser.y" */ +/* #line 776 "parser.y" */ { yygotominor.yy92 = phql_ret_update_clause(yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(46,&yymsp[-3].minor); yy_destructor(47,&yymsp[-1].minor); } -/* #line 1874 "parser.c" */ +/* #line 1866 "parser.c" */ break; case 51: -/* #line 800 "parser.y" */ +/* #line 792 "parser.y" */ { yygotominor.yy92 = phql_ret_update_item(yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(3,&yymsp[-1].minor); } -/* #line 1882 "parser.c" */ +/* #line 1874 "parser.c" */ break; case 53: -/* #line 812 "parser.y" */ +/* #line 804 "parser.y" */ { yygotominor.yy92 = phql_ret_delete_statement(yymsp[-2].minor.yy92, yymsp[-1].minor.yy92, yymsp[0].minor.yy92); } -/* #line 1889 "parser.c" */ +/* #line 1881 "parser.c" */ break; case 54: -/* #line 818 "parser.y" */ +/* #line 810 "parser.y" */ { yygotominor.yy92 = phql_ret_delete_clause(yymsp[0].minor.yy92); yy_destructor(48,&yymsp[-2].minor); yy_destructor(27,&yymsp[-1].minor); } -/* #line 1898 "parser.c" */ +/* #line 1890 "parser.c" */ break; case 55: -/* #line 824 "parser.y" */ +/* #line 816 "parser.y" */ { yygotominor.yy92 = phql_ret_assoc_name(yymsp[-2].minor.yy92, yymsp[0].minor.yy0); yy_destructor(32,&yymsp[-1].minor); } -/* #line 1906 "parser.c" */ +/* #line 1898 "parser.c" */ break; case 56: -/* #line 828 "parser.y" */ +/* #line 820 "parser.y" */ { yygotominor.yy92 = phql_ret_assoc_name(yymsp[-1].minor.yy92, yymsp[0].minor.yy0); } -/* #line 1913 "parser.c" */ +/* #line 1905 "parser.c" */ break; case 57: -/* #line 832 "parser.y" */ +/* #line 824 "parser.y" */ { yygotominor.yy92 = phql_ret_assoc_name(yymsp[0].minor.yy92, NULL); } -/* #line 1920 "parser.c" */ +/* #line 1912 "parser.c" */ break; case 59: -/* #line 844 "parser.y" */ +/* #line 836 "parser.y" */ { yygotominor.yy92 = yymsp[0].minor.yy92; yy_destructor(49,&yymsp[-1].minor); } -/* #line 1928 "parser.c" */ +/* #line 1920 "parser.c" */ break; case 61: -/* #line 854 "parser.y" */ +/* #line 846 "parser.y" */ { yygotominor.yy92 = yymsp[0].minor.yy92; yy_destructor(50,&yymsp[-2].minor); yy_destructor(51,&yymsp[-1].minor); } -/* #line 1937 "parser.c" */ +/* #line 1929 "parser.c" */ break; case 65: -/* #line 874 "parser.y" */ +/* #line 866 "parser.y" */ { yygotominor.yy92 = phql_ret_order_item(yymsp[0].minor.yy92, 0); } -/* #line 1944 "parser.c" */ +/* #line 1936 "parser.c" */ break; case 66: -/* #line 878 "parser.y" */ +/* #line 870 "parser.y" */ { yygotominor.yy92 = phql_ret_order_item(yymsp[-1].minor.yy92, PHQL_T_ASC); yy_destructor(52,&yymsp[0].minor); } -/* #line 1952 "parser.c" */ +/* #line 1944 "parser.c" */ break; case 67: -/* #line 882 "parser.y" */ +/* #line 874 "parser.y" */ { yygotominor.yy92 = phql_ret_order_item(yymsp[-1].minor.yy92, PHQL_T_DESC); yy_destructor(53,&yymsp[0].minor); } -/* #line 1960 "parser.c" */ +/* #line 1952 "parser.c" */ break; case 68: -/* #line 888 "parser.y" */ +/* #line 880 "parser.y" */ { yygotominor.yy92 = yymsp[0].minor.yy92; yy_destructor(54,&yymsp[-2].minor); yy_destructor(51,&yymsp[-1].minor); } -/* #line 1969 "parser.c" */ +/* #line 1961 "parser.c" */ break; case 73: -/* #line 914 "parser.y" */ +/* #line 906 "parser.y" */ { yygotominor.yy92 = yymsp[0].minor.yy92; yy_destructor(55,&yymsp[-1].minor); } -/* #line 1977 "parser.c" */ +/* #line 1969 "parser.c" */ break; case 75: case 79: -/* #line 924 "parser.y" */ +/* #line 916 "parser.y" */ { yygotominor.yy92 = phql_ret_limit_clause(yymsp[0].minor.yy92, NULL); yy_destructor(56,&yymsp[-1].minor); } -/* #line 1986 "parser.c" */ +/* #line 1978 "parser.c" */ break; case 76: -/* #line 928 "parser.y" */ +/* #line 920 "parser.y" */ { yygotominor.yy92 = phql_ret_limit_clause(yymsp[0].minor.yy92, yymsp[-2].minor.yy92); yy_destructor(56,&yymsp[-3].minor); yy_destructor(25,&yymsp[-1].minor); } -/* #line 1995 "parser.c" */ +/* #line 1987 "parser.c" */ break; case 77: -/* #line 932 "parser.y" */ +/* #line 924 "parser.y" */ { yygotominor.yy92 = phql_ret_limit_clause(yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(56,&yymsp[-3].minor); yy_destructor(57,&yymsp[-1].minor); } -/* #line 2004 "parser.c" */ +/* #line 1996 "parser.c" */ break; case 81: case 127: -/* #line 950 "parser.y" */ +/* #line 942 "parser.y" */ { yygotominor.yy92 = phql_ret_literal_zval(PHQL_T_INTEGER, yymsp[0].minor.yy0); } -/* #line 2012 "parser.c" */ +/* #line 2004 "parser.c" */ break; case 82: case 133: -/* #line 954 "parser.y" */ +/* #line 946 "parser.y" */ { yygotominor.yy92 = phql_ret_placeholder_zval(PHQL_T_NPLACEHOLDER, yymsp[0].minor.yy0); } -/* #line 2020 "parser.c" */ +/* #line 2012 "parser.c" */ break; case 83: case 134: -/* #line 958 "parser.y" */ +/* #line 950 "parser.y" */ { yygotominor.yy92 = phql_ret_placeholder_zval(PHQL_T_SPLACEHOLDER, yymsp[0].minor.yy0); } -/* #line 2028 "parser.c" */ +/* #line 2020 "parser.c" */ break; case 84: -/* #line 964 "parser.y" */ +/* #line 956 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_MINUS, NULL, yymsp[0].minor.yy92); yy_destructor(20,&yymsp[-1].minor); } -/* #line 2036 "parser.c" */ +/* #line 2028 "parser.c" */ break; case 85: -/* #line 968 "parser.y" */ +/* #line 960 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_SUB, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(20,&yymsp[-1].minor); } -/* #line 2044 "parser.c" */ +/* #line 2036 "parser.c" */ break; case 86: -/* #line 972 "parser.y" */ +/* #line 964 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_ADD, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(19,&yymsp[-1].minor); } -/* #line 2052 "parser.c" */ +/* #line 2044 "parser.c" */ break; case 87: -/* #line 976 "parser.y" */ +/* #line 968 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_MUL, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(17,&yymsp[-1].minor); } -/* #line 2060 "parser.c" */ +/* #line 2052 "parser.c" */ break; case 88: -/* #line 980 "parser.y" */ +/* #line 972 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_DIV, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(16,&yymsp[-1].minor); } -/* #line 2068 "parser.c" */ +/* #line 2060 "parser.c" */ break; case 89: -/* #line 984 "parser.y" */ +/* #line 976 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_MOD, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(18,&yymsp[-1].minor); } -/* #line 2076 "parser.c" */ +/* #line 2068 "parser.c" */ break; case 90: -/* #line 988 "parser.y" */ +/* #line 980 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_AND, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(9,&yymsp[-1].minor); } -/* #line 2084 "parser.c" */ +/* #line 2076 "parser.c" */ break; case 91: -/* #line 992 "parser.y" */ +/* #line 984 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_OR, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(10,&yymsp[-1].minor); } -/* #line 2092 "parser.c" */ +/* #line 2084 "parser.c" */ break; case 92: -/* #line 996 "parser.y" */ +/* #line 988 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_BITWISE_AND, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(13,&yymsp[-1].minor); } -/* #line 2100 "parser.c" */ +/* #line 2092 "parser.c" */ break; case 93: -/* #line 1000 "parser.y" */ +/* #line 992 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_BITWISE_OR, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(14,&yymsp[-1].minor); } -/* #line 2108 "parser.c" */ +/* #line 2100 "parser.c" */ break; case 94: -/* #line 1004 "parser.y" */ +/* #line 996 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_BITWISE_XOR, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(15,&yymsp[-1].minor); } -/* #line 2116 "parser.c" */ +/* #line 2108 "parser.c" */ break; case 95: -/* #line 1008 "parser.y" */ +/* #line 1000 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_EQUALS, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(3,&yymsp[-1].minor); } -/* #line 2124 "parser.c" */ +/* #line 2116 "parser.c" */ break; case 96: -/* #line 1012 "parser.y" */ +/* #line 1004 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_NOTEQUALS, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(4,&yymsp[-1].minor); } -/* #line 2132 "parser.c" */ +/* #line 2124 "parser.c" */ break; case 97: -/* #line 1016 "parser.y" */ +/* #line 1008 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_LESS, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(5,&yymsp[-1].minor); } -/* #line 2140 "parser.c" */ +/* #line 2132 "parser.c" */ break; case 98: -/* #line 1020 "parser.y" */ +/* #line 1012 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_GREATER, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(6,&yymsp[-1].minor); } -/* #line 2148 "parser.c" */ +/* #line 2140 "parser.c" */ break; case 99: -/* #line 1024 "parser.y" */ +/* #line 1016 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_GREATEREQUAL, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(7,&yymsp[-1].minor); } -/* #line 2156 "parser.c" */ +/* #line 2148 "parser.c" */ break; case 100: -/* #line 1028 "parser.y" */ +/* #line 1020 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_LESSEQUAL, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(8,&yymsp[-1].minor); } -/* #line 2164 "parser.c" */ +/* #line 2156 "parser.c" */ break; case 101: -/* #line 1032 "parser.y" */ +/* #line 1024 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_LIKE, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(11,&yymsp[-1].minor); } -/* #line 2172 "parser.c" */ +/* #line 2164 "parser.c" */ break; case 102: -/* #line 1036 "parser.y" */ +/* #line 1028 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_NLIKE, yymsp[-3].minor.yy92, yymsp[0].minor.yy92); yy_destructor(23,&yymsp[-2].minor); yy_destructor(11,&yymsp[-1].minor); } -/* #line 2181 "parser.c" */ +/* #line 2173 "parser.c" */ break; case 103: -/* #line 1040 "parser.y" */ +/* #line 1032 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_ILIKE, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(12,&yymsp[-1].minor); } -/* #line 2189 "parser.c" */ +/* #line 2181 "parser.c" */ break; case 104: -/* #line 1044 "parser.y" */ +/* #line 1036 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_NILIKE, yymsp[-3].minor.yy92, yymsp[0].minor.yy92); yy_destructor(23,&yymsp[-2].minor); yy_destructor(12,&yymsp[-1].minor); } -/* #line 2198 "parser.c" */ +/* #line 2190 "parser.c" */ break; case 105: -/* #line 1048 "parser.y" */ +/* #line 1040 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_IN, yymsp[-4].minor.yy92, yymsp[-1].minor.yy92); yy_destructor(22,&yymsp[-3].minor); yy_destructor(44,&yymsp[-2].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 2208 "parser.c" */ +/* #line 2200 "parser.c" */ break; case 106: -/* #line 1052 "parser.y" */ +/* #line 1044 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_NOTIN, yymsp[-5].minor.yy92, yymsp[-1].minor.yy92); yy_destructor(23,&yymsp[-4].minor); @@ -2215,18 +2207,18 @@ static void yy_reduce( yy_destructor(44,&yymsp[-2].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 2219 "parser.c" */ +/* #line 2211 "parser.c" */ break; case 107: -/* #line 1056 "parser.y" */ +/* #line 1048 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_AGAINST, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(1,&yymsp[-1].minor); } -/* #line 2227 "parser.c" */ +/* #line 2219 "parser.c" */ break; case 108: -/* #line 1060 "parser.y" */ +/* #line 1052 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_CAST, yymsp[-3].minor.yy92, phql_ret_raw_qualified_name(yymsp[-1].minor.yy0, NULL)); yy_destructor(61,&yymsp[-5].minor); @@ -2234,10 +2226,10 @@ static void yy_reduce( yy_destructor(32,&yymsp[-2].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 2238 "parser.c" */ +/* #line 2230 "parser.c" */ break; case 109: -/* #line 1064 "parser.y" */ +/* #line 1056 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_CONVERT, yymsp[-3].minor.yy92, phql_ret_raw_qualified_name(yymsp[-1].minor.yy0, NULL)); yy_destructor(62,&yymsp[-5].minor); @@ -2245,146 +2237,146 @@ static void yy_reduce( yy_destructor(63,&yymsp[-2].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 2249 "parser.c" */ +/* #line 2241 "parser.c" */ break; case 111: -/* #line 1074 "parser.y" */ +/* #line 1066 "parser.y" */ { yygotominor.yy92 = phql_ret_func_call(yymsp[-4].minor.yy0, yymsp[-1].minor.yy92, yymsp[-2].minor.yy92); yy_destructor(44,&yymsp[-3].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 2258 "parser.c" */ +/* #line 2250 "parser.c" */ break; case 112: -/* #line 1080 "parser.y" */ +/* #line 1072 "parser.y" */ { yygotominor.yy92 = phql_ret_distinct(); yy_destructor(28,&yymsp[0].minor); } -/* #line 2266 "parser.c" */ +/* #line 2258 "parser.c" */ break; case 117: -/* #line 1104 "parser.y" */ +/* #line 1096 "parser.y" */ { yygotominor.yy92 = phql_ret_zval_list(yymsp[0].minor.yy92, NULL); } -/* #line 2273 "parser.c" */ +/* #line 2265 "parser.c" */ break; case 120: -/* #line 1118 "parser.y" */ +/* #line 1110 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_ISNULL, yymsp[-2].minor.yy92, NULL); yy_destructor(21,&yymsp[-1].minor); yy_destructor(64,&yymsp[0].minor); } -/* #line 2282 "parser.c" */ +/* #line 2274 "parser.c" */ break; case 121: -/* #line 1122 "parser.y" */ +/* #line 1114 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_ISNOTNULL, yymsp[-3].minor.yy92, NULL); yy_destructor(21,&yymsp[-2].minor); yy_destructor(23,&yymsp[-1].minor); yy_destructor(64,&yymsp[0].minor); } -/* #line 2292 "parser.c" */ +/* #line 2284 "parser.c" */ break; case 122: -/* #line 1126 "parser.y" */ +/* #line 1118 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_BETWEEN, yymsp[-2].minor.yy92, yymsp[0].minor.yy92); yy_destructor(2,&yymsp[-1].minor); } -/* #line 2300 "parser.c" */ +/* #line 2292 "parser.c" */ break; case 123: -/* #line 1130 "parser.y" */ +/* #line 1122 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_NOT, NULL, yymsp[0].minor.yy92); yy_destructor(23,&yymsp[-1].minor); } -/* #line 2308 "parser.c" */ +/* #line 2300 "parser.c" */ break; case 124: -/* #line 1134 "parser.y" */ +/* #line 1126 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_BITWISE_NOT, NULL, yymsp[0].minor.yy92); yy_destructor(24,&yymsp[-1].minor); } -/* #line 2316 "parser.c" */ +/* #line 2308 "parser.c" */ break; case 125: -/* #line 1138 "parser.y" */ +/* #line 1130 "parser.y" */ { yygotominor.yy92 = phql_ret_expr(PHQL_T_ENCLOSED, yymsp[-1].minor.yy92, NULL); yy_destructor(44,&yymsp[-2].minor); yy_destructor(45,&yymsp[0].minor); } -/* #line 2325 "parser.c" */ +/* #line 2317 "parser.c" */ break; case 128: -/* #line 1150 "parser.y" */ +/* #line 1142 "parser.y" */ { yygotominor.yy92 = phql_ret_literal_zval(PHQL_T_STRING, yymsp[0].minor.yy0); } -/* #line 2332 "parser.c" */ +/* #line 2324 "parser.c" */ break; case 129: -/* #line 1154 "parser.y" */ +/* #line 1146 "parser.y" */ { yygotominor.yy92 = phql_ret_literal_zval(PHQL_T_DOUBLE, yymsp[0].minor.yy0); } -/* #line 2339 "parser.c" */ +/* #line 2331 "parser.c" */ break; case 130: -/* #line 1158 "parser.y" */ +/* #line 1150 "parser.y" */ { yygotominor.yy92 = phql_ret_literal_zval(PHQL_T_NULL, NULL); yy_destructor(64,&yymsp[0].minor); } -/* #line 2347 "parser.c" */ +/* #line 2339 "parser.c" */ break; case 131: -/* #line 1162 "parser.y" */ +/* #line 1154 "parser.y" */ { yygotominor.yy92 = phql_ret_literal_zval(PHQL_T_TRUE, NULL); yy_destructor(67,&yymsp[0].minor); } -/* #line 2355 "parser.c" */ +/* #line 2347 "parser.c" */ break; case 132: -/* #line 1166 "parser.y" */ +/* #line 1158 "parser.y" */ { yygotominor.yy92 = phql_ret_literal_zval(PHQL_T_FALSE, NULL); yy_destructor(68,&yymsp[0].minor); } -/* #line 2363 "parser.c" */ +/* #line 2355 "parser.c" */ break; case 135: -/* #line 1180 "parser.y" */ +/* #line 1172 "parser.y" */ { yygotominor.yy92 = phql_ret_qualified_name(yymsp[-4].minor.yy0, yymsp[-2].minor.yy0, yymsp[0].minor.yy0); yy_destructor(69,&yymsp[-3].minor); yy_destructor(31,&yymsp[-1].minor); } -/* #line 2372 "parser.c" */ +/* #line 2364 "parser.c" */ break; case 136: -/* #line 1184 "parser.y" */ +/* #line 1176 "parser.y" */ { yygotominor.yy92 = phql_ret_qualified_name(yymsp[-2].minor.yy0, NULL, yymsp[0].minor.yy0); yy_destructor(69,&yymsp[-1].minor); } -/* #line 2380 "parser.c" */ +/* #line 2372 "parser.c" */ break; case 137: -/* #line 1188 "parser.y" */ +/* #line 1180 "parser.y" */ { yygotominor.yy92 = phql_ret_qualified_name(NULL, yymsp[-2].minor.yy0, yymsp[0].minor.yy0); yy_destructor(31,&yymsp[-1].minor); } -/* #line 2388 "parser.c" */ +/* #line 2380 "parser.c" */ break; }; yygoto = yyRuleInfo[yyruleno].lhs; @@ -2426,7 +2418,7 @@ static void yy_syntax_error( ){ phql_ARG_FETCH; #define TOKEN (yyminor.yy0) -/* #line 474 "parser.y" */ +/* #line 466 "parser.y" */ if (status->scanner_state->start_length) { { @@ -2493,7 +2485,7 @@ static void yy_syntax_error( status->status = PHQL_PARSING_FAILED; -/* #line 2497 "parser.c" */ +/* #line 2489 "parser.c" */ phql_ARG_STORE; /* Suppress warning about unused %extra_argument variable */ } diff --git a/ext/mvc/model/query/parser.y b/ext/mvc/model/query/parser.y index 4eb37510c89..e0a28f54853 100644 --- a/ext/mvc/model/query/parser.y +++ b/ext/mvc/model/query/parser.y @@ -55,15 +55,17 @@ #include "kernel/fcall.h" #include "kernel/exception.h" +#include "interned-strings.h" + static zval *phql_ret_literal_zval(int type, phql_parser_token *T) { zval *ret; MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", type); + add_assoc_long(ret, phalcon_interned_type, type); if (T) { - add_assoc_stringl(ret, "value", T->token, T->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_value, T->token, T->token_len, 0); efree(T); } @@ -76,8 +78,8 @@ static zval *phql_ret_placeholder_zval(int type, phql_parser_token *T) MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_long(ret, "type", type); - add_assoc_stringl(ret, "value", T->token, T->token_len, 0); + add_assoc_long(ret, phalcon_interned_type, type); + add_assoc_stringl(ret, phalcon_interned_value, T->token, T->token_len, 0); efree(T); return ret; @@ -90,19 +92,19 @@ static zval *phql_ret_qualified_name(phql_parser_token *A, phql_parser_token *B, MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_QUALIFIED); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_QUALIFIED); if (A != NULL) { - add_assoc_stringl(ret, "ns-alias", A->token, A->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_ns_alias, A->token, A->token_len, 0); efree(A); } if (B != NULL) { - add_assoc_stringl(ret, "domain", B->token, B->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_domain, B->token, B->token_len, 0); efree(B); } - add_assoc_stringl(ret, "name", C->token, C->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_name, C->token, C->token_len, 0); efree(C); return ret; @@ -115,13 +117,13 @@ static zval *phql_ret_raw_qualified_name(phql_parser_token *A, phql_parser_token MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_RAW_QUALIFIED); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_RAW_QUALIFIED); if (B != NULL) { - add_assoc_stringl(ret, "domain", A->token, A->token_len, 0); - add_assoc_stringl(ret, "name", B->token, B->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_domain, A->token, A->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_name, B->token, B->token_len, 0); efree(B); } else { - add_assoc_stringl(ret, "name", A->token, A->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_name, A->token, A->token_len, 0); } efree(A); @@ -135,23 +137,23 @@ static zval *phql_ret_select_statement(zval *S, zval *W, zval *O, zval *G, zval MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_SELECT); - add_assoc_zval(ret, "select", S); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_SELECT); + add_assoc_zval(ret, phalcon_interned_select, S); if (W != NULL) { - add_assoc_zval(ret, "where", W); + add_assoc_zval(ret, phalcon_interned_where, W); } if (O != NULL) { - add_assoc_zval(ret, "orderBy", O); + add_assoc_zval(ret, phalcon_interned_orderBy, O); } if (G != NULL) { - add_assoc_zval(ret, "groupBy", G); + add_assoc_zval(ret, phalcon_interned_groupBy, G); } if (H != NULL) { - add_assoc_zval(ret, "having", H); + add_assoc_zval(ret, phalcon_interned_having, H); } if (L != NULL) { - add_assoc_zval(ret, "limit", L); + add_assoc_zval(ret, phalcon_interned_limit, L); } return ret; @@ -162,16 +164,16 @@ static zval *phql_ret_select_clause(zval *distinct, zval *columns, zval *tables, zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); + array_init_size(ret, 4); if (distinct) { - add_assoc_zval(ret, "distinct", distinct); + add_assoc_zval(ret, phalcon_interned_distinct, distinct); } - add_assoc_zval(ret, "columns", columns); - add_assoc_zval(ret, "tables", tables); + add_assoc_zval(ret, phalcon_interned_columns, columns); + add_assoc_zval(ret, phalcon_interned_tables, tables); if (join_list) { - add_assoc_zval(ret, "joins", join_list); + add_assoc_zval(ret, phalcon_interned_joins, join_list); } return ret; @@ -203,9 +205,9 @@ static zval *phql_ret_order_item(zval *column, int sort){ MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_zval(ret, "column", column); + add_assoc_zval(ret, phalcon_interned_column, column); if (sort != 0 ) { - add_assoc_long(ret, "sort", sort); + add_assoc_long(ret, phalcon_interned_sort, sort); } return ret; @@ -218,10 +220,10 @@ static zval *phql_ret_limit_clause(zval *L, zval *O) MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_zval(ret, "number", L); + add_assoc_zval(ret, phalcon_interned_number, L); if (O != NULL) { - add_assoc_zval(ret, "offset", O); + add_assoc_zval(ret, phalcon_interned_offset, O); } return ret; @@ -232,14 +234,14 @@ static zval *phql_ret_insert_statement(zval *Q, zval *F, zval *V) zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); + array_init_size(ret, 4); - add_assoc_long(ret, "type", PHQL_T_INSERT); - add_assoc_zval(ret, "qualifiedName", Q); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_INSERT); + add_assoc_zval(ret, phalcon_interned_qualifiedName, Q); if (F != NULL) { - add_assoc_zval(ret, "fields", F); + add_assoc_zval(ret, phalcon_interned_fields, F); } - add_assoc_zval(ret, "values", V); + add_assoc_zval(ret, phalcon_interned_values, V); return ret; } @@ -251,13 +253,13 @@ static zval *phql_ret_update_statement(zval *U, zval *W, zval *L) MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_UPDATE); - add_assoc_zval(ret, "update", U); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_UPDATE); + add_assoc_zval(ret, phalcon_interned_update, U); if (W != NULL) { - add_assoc_zval(ret, "where", W); + add_assoc_zval(ret, phalcon_interned_where, W); } if (L != NULL) { - add_assoc_zval(ret, "limit", L); + add_assoc_zval(ret, phalcon_interned_limit, L); } return ret; @@ -269,21 +271,20 @@ static zval *phql_ret_update_clause(zval *tables, zval *values) MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_zval(ret, "tables", tables); - add_assoc_zval(ret, "values", values); + add_assoc_zval(ret, phalcon_interned_tables, tables); + add_assoc_zval(ret, phalcon_interned_values, values); return ret; } static zval *phql_ret_update_item(zval *column, zval *expr) { - zval *ret; MAKE_STD_ZVAL(ret); array_init_size(ret, 2); - add_assoc_zval(ret, "column", column); - add_assoc_zval(ret, "expr", expr); + add_assoc_zval(ret, phalcon_interned_column, column); + add_assoc_zval(ret, phalcon_interned_expr, expr); return ret; } @@ -295,13 +296,13 @@ static zval *phql_ret_delete_statement(zval *D, zval *W, zval *L) MAKE_STD_ZVAL(ret); array_init(ret); - add_assoc_long(ret, "type", PHQL_T_DELETE); - add_assoc_zval(ret, "delete", D); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_DELETE); + add_assoc_zval(ret, phalcon_interned_delete, D); if (W != NULL) { - add_assoc_zval(ret, "where", W); + add_assoc_zval(ret, phalcon_interned_where, W); } if (L != NULL) { - add_assoc_zval(ret, "limit", L); + add_assoc_zval(ret, phalcon_interned_limit, L); } return ret; @@ -313,16 +314,14 @@ static zval *phql_ret_delete_clause(zval *tables) MAKE_STD_ZVAL(ret); array_init_size(ret, 1); - add_assoc_zval(ret, "tables", tables); + add_assoc_zval(ret, phalcon_interned_tables, tables); return ret; } static zval *phql_ret_zval_list(zval *list_left, zval *right_list) { - zval *ret; - HashPosition pos; HashTable *list; MAKE_STD_ZVAL(ret); @@ -330,19 +329,18 @@ static zval *phql_ret_zval_list(zval *list_left, zval *right_list) list = Z_ARRVAL_P(list_left); if (zend_hash_index_exists(list, 0)) { - zend_hash_internal_pointer_reset_ex(list, &pos); - for (;; zend_hash_move_forward_ex(list, &pos)) { - - zval ** item; - - if (zend_hash_get_current_data_ex(list, (void**)&item, &pos) == FAILURE) { - break; - } - + HashPosition pos; + zval **item; + + for ( + zend_hash_internal_pointer_reset_ex(list, &pos); + zend_hash_get_current_data_ex(list, (void**)&item, &pos) != FAILURE; + zend_hash_move_forward_ex(list, &pos) + ) { Z_ADDREF_PP(item); add_next_index_zval(ret, *item); - } + zval_ptr_dtor(&list_left); } else { add_next_index_zval(ret, list_left); @@ -357,21 +355,20 @@ static zval *phql_ret_zval_list(zval *list_left, zval *right_list) static zval *phql_ret_column_item(int type, zval *column, phql_parser_token *identifier_column, phql_parser_token *alias) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_long(ret, "type", type); + array_init_size(ret, 4); + add_assoc_long(ret, phalcon_interned_type, type); if (column) { - add_assoc_zval(ret, "column", column); + add_assoc_zval(ret, phalcon_interned_column, column); } if (identifier_column) { - add_assoc_stringl(ret, "column", identifier_column->token, identifier_column->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_column, identifier_column->token, identifier_column->token_len, 0); efree(identifier_column); } if (alias) { - add_assoc_stringl(ret, "alias", alias->token, alias->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_alias, alias->token, alias->token_len, 0); efree(alias); } @@ -380,19 +377,17 @@ static zval *phql_ret_column_item(int type, zval *column, phql_parser_token *ide static zval *phql_ret_assoc_name(zval *qualified_name, phql_parser_token *alias) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_zval(ret, "qualifiedName", qualified_name); + array_init_size(ret, 2); + add_assoc_zval(ret, phalcon_interned_qualifiedName, qualified_name); if (alias) { - add_assoc_stringl(ret, "alias", alias->token, alias->token_len, 0); + add_assoc_stringl(ret, phalcon_interned_alias, alias->token, alias->token_len, 0); efree(alias); } return ret; - } static zval *phql_ret_join_type(int type) @@ -407,27 +402,25 @@ static zval *phql_ret_join_type(int type) static zval *phql_ret_join_item(zval *type, zval *qualified, zval *alias, zval *conditions) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_zval(ret, "type", type); + array_init_size(ret, 4); + add_assoc_zval(ret, phalcon_interned_type, type); if (qualified) { - add_assoc_zval(ret, "qualified", qualified); + add_assoc_zval(ret, phalcon_interned_qualified, qualified); } if (alias) { - add_assoc_zval(ret, "alias", alias); + add_assoc_zval(ret, phalcon_interned_alias, alias); } if (conditions) { - add_assoc_zval(ret, "conditions", conditions); + add_assoc_zval(ret, phalcon_interned_conditions, conditions); } return ret; - } static zval *phql_ret_expr(int type, zval *left, zval *right) @@ -435,13 +428,13 @@ static zval *phql_ret_expr(int type, zval *left, zval *right) zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_long(ret, "type", type); + array_init_size(ret, 2); + add_assoc_long(ret, phalcon_interned_type, type); if (left) { - add_assoc_zval(ret, "left", left); + add_assoc_zval(ret, phalcon_interned_left, left); } if (right) { - add_assoc_zval(ret, "right", right); + add_assoc_zval(ret, phalcon_interned_right, right); } return ret; @@ -449,21 +442,20 @@ static zval *phql_ret_expr(int type, zval *left, zval *right) static zval *phql_ret_func_call(phql_parser_token *name, zval *arguments, zval *distinct) { - zval *ret; MAKE_STD_ZVAL(ret); - array_init(ret); - add_assoc_long(ret, "type", PHQL_T_FCALL); - add_assoc_stringl(ret, "name", name->token, name->token_len, 0); + array_init_size(ret, 4); + add_assoc_long(ret, phalcon_interned_type, PHQL_T_FCALL); + add_assoc_stringl(ret, phalcon_interned_name, name->token, name->token_len, 0); efree(name); if (arguments) { - add_assoc_zval(ret, "arguments", arguments); + add_assoc_zval(ret, phalcon_interned_arguments, arguments); } if (distinct) { - add_assoc_zval(ret, "distinct", distinct); + add_assoc_zval(ret, phalcon_interned_distinct, distinct); } return ret; @@ -1192,4 +1184,3 @@ qualified_name(R) ::= IDENTIFIER(A) DOT IDENTIFIER(B) . { qualified_name(R) ::= IDENTIFIER(A) . { R = phql_ret_qualified_name(NULL, NULL, A); } - diff --git a/ext/phalcon.c b/ext/phalcon.c index ff2870da0a4..c5bb222e8ab 100644 --- a/ext/phalcon.c +++ b/ext/phalcon.c @@ -725,6 +725,7 @@ static PHP_MSHUTDOWN_FUNCTION(phalcon){ static PHP_RINIT_FUNCTION(phalcon){ php_phalcon_init_globals(PHALCON_VGLOBAL TSRMLS_CC); + phalcon_init_interned_strings(TSRMLS_C); return SUCCESS; } diff --git a/ext/phalcon.h b/ext/phalcon.h index 17daa23aad5..0a9a3ba64d5 100644 --- a/ext/phalcon.h +++ b/ext/phalcon.h @@ -17,6 +17,7 @@ +------------------------------------------------------------------------+ */ +#include "interned-strings.h" #include "di/injectionawareinterface.h" #include "forms/elementinterface.h" #include "mvc/model/validatorinterface.h"