1
2 #ifdef HAVE_CONFIG_H
3 #include "../../../ext_config.h"
4 #endif
5
6 #include <php.h>
7 #include "../../../php_ext.h"
8 #include "../../../ext.h"
9
10 #include <Zend/zend_operators.h>
11 #include <Zend/zend_exceptions.h>
12 #include <Zend/zend_interfaces.h>
13
14 #include "kernel/main.h"
15 #include "kernel/object.h"
16 #include "kernel/fcall.h"
17 #include "kernel/array.h"
18 #include "kernel/memory.h"
19 #include "kernel/operators.h"
20 #include "kernel/exception.h"
21 #include "kernel/concat.h"
22 #include "ext/spl/spl_exceptions.h"
23 #include "kernel/string.h"
24 #include "phalcon/mvc/model/orm.h"
25
26
27 /**
28 * This file is part of the Phalcon Framework.
29 *
30 * (c) Phalcon Team <team@phalcon.io>
31 *
32 * For the full copyright and license information, please view the LICENSE.txt
33 * file that was distributed with this source code.
34 */
35 /**
36 * Phalcon\Mvc\Model\Query
37 *
38 * This class takes a PHQL intermediate representation and executes it.
39 *
40 *```php
41 * $phql = "SELECT c.price*0.16 AS taxes, c.* FROM Cars AS c JOIN Brands AS b
42 * WHERE b.name = :name: ORDER BY c.name";
43 *
44 * $result = $manager->executeQuery(
45 * $phql,
46 * [
47 * "name" => "Lamborghini",
48 * ]
49 * );
50 *
51 * foreach ($result as $row) {
52 * echo "Name: ", $row->cars->name, "\n";
53 * echo "Price: ", $row->cars->price, "\n";
54 * echo "Taxes: ", $row->taxes, "\n";
55 * }
56 *
57 * // with transaction
58 * use Phalcon\Mvc\Model\Query;
59 * use Phalcon\Mvc\Model\Transaction;
60 *
61 * // $di needs to have the service "db" registered for this to work
62 * $di = Phalcon\Di\FactoryDefault::getDefault();
63 *
64 * $phql = 'SELECT * FROM robot';
65 *
66 * $myTransaction = new Transaction($di);
67 * $myTransaction->begin();
68 *
69 * $newRobot = new Robot();
70 * $newRobot->setTransaction($myTransaction);
71 * $newRobot->type = "mechanical";
72 * $newRobot->name = "Astro Boy";
73 * $newRobot->year = 1952;
74 * $newRobot->save();
75 *
76 * $queryWithTransaction = new Query($phql, $di);
77 * $queryWithTransaction->setTransaction($myTransaction);
78 *
79 * $resultWithEntries = $queryWithTransaction->execute();
80 *
81 * $queryWithOutTransaction = new Query($phql, $di);
82 * $resultWithOutEntries = $queryWithTransaction->execute();
83 *```
84 */
ZEPHIR_INIT_CLASS(Phalcon_Mvc_Model_Query)85 ZEPHIR_INIT_CLASS(Phalcon_Mvc_Model_Query) {
86
87 ZEPHIR_REGISTER_CLASS(Phalcon\\Mvc\\Model, Query, phalcon, mvc_model_query, phalcon_mvc_model_query_method_entry, 0);
88
89 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("ast"), ZEND_ACC_PROTECTED);
90
91 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("bindParams"), ZEND_ACC_PROTECTED);
92
93 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("bindTypes"), ZEND_ACC_PROTECTED);
94
95 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("cache"), ZEND_ACC_PROTECTED);
96
97 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("cacheOptions"), ZEND_ACC_PROTECTED);
98
99 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("container"), ZEND_ACC_PROTECTED);
100
101 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("enableImplicitJoins"), ZEND_ACC_PROTECTED);
102
103 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("intermediate"), ZEND_ACC_PROTECTED);
104
105 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("manager"), ZEND_ACC_PROTECTED);
106
107 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("metaData"), ZEND_ACC_PROTECTED);
108
109 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("models"), ZEND_ACC_PROTECTED);
110
111 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("modelsInstances"), ZEND_ACC_PROTECTED);
112
113 zend_declare_property_long(phalcon_mvc_model_query_ce, SL("nestingLevel"), -1, ZEND_ACC_PROTECTED);
114
115 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("phql"), ZEND_ACC_PROTECTED);
116
117 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("sharedLock"), ZEND_ACC_PROTECTED);
118
119 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("sqlAliases"), ZEND_ACC_PROTECTED);
120
121 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("sqlAliasesModels"), ZEND_ACC_PROTECTED);
122
123 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("sqlAliasesModelsInstances"), ZEND_ACC_PROTECTED);
124
125 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("sqlColumnAliases"), ZEND_ACC_PROTECTED);
126
127 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("sqlModelsAliases"), ZEND_ACC_PROTECTED);
128
129 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("type"), ZEND_ACC_PROTECTED);
130
131 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("uniqueRow"), ZEND_ACC_PROTECTED);
132
133 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("_irPhqlCache"), ZEND_ACC_STATIC|ZEND_ACC_PROTECTED);
134
135 /**
136 * TransactionInterface so that the query can wrap a transaction
137 * around batch updates and intermediate selects within the transaction.
138 * however if a model got a transaction set inside it will use the local
139 * transaction instead of this one
140 */
141 zend_declare_property_null(phalcon_mvc_model_query_ce, SL("_transaction"), ZEND_ACC_PROTECTED);
142
143 phalcon_mvc_model_query_ce->create_object = zephir_init_properties_Phalcon_Mvc_Model_Query;
144 zephir_declare_class_constant_long(phalcon_mvc_model_query_ce, SL("TYPE_DELETE"), 303);
145
146 zephir_declare_class_constant_long(phalcon_mvc_model_query_ce, SL("TYPE_INSERT"), 306);
147
148 zephir_declare_class_constant_long(phalcon_mvc_model_query_ce, SL("TYPE_SELECT"), 309);
149
150 zephir_declare_class_constant_long(phalcon_mvc_model_query_ce, SL("TYPE_UPDATE"), 300);
151
152 zend_class_implements(phalcon_mvc_model_query_ce, 1, phalcon_mvc_model_queryinterface_ce);
153 zend_class_implements(phalcon_mvc_model_query_ce, 1, phalcon_di_injectionawareinterface_ce);
154 return SUCCESS;
155
156 }
157
158 /**
159 * TransactionInterface so that the query can wrap a transaction
160 *
161 *
162 * around batch updates and intermediate selects within the transaction.
163 * however if a model got a transaction set inside it will use the local
164 * transaction instead of this one
165 *
166 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getTransaction)167 PHP_METHOD(Phalcon_Mvc_Model_Query, getTransaction) {
168
169 zval *this_ptr = getThis();
170
171
172 RETURN_MEMBER(getThis(), "_transaction");
173
174 }
175
176 /**
177 * Phalcon\Mvc\Model\Query constructor
178 */
PHP_METHOD(Phalcon_Mvc_Model_Query,__construct)179 PHP_METHOD(Phalcon_Mvc_Model_Query, __construct) {
180
181 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
182 zend_long ZEPHIR_LAST_CALL_STATUS;
183 zval options;
184 zval *phql_param = NULL, *container = NULL, container_sub, *options_param = NULL, __$true, __$false, __$null, enableImplicitJoins;
185 zval phql;
186 zval *this_ptr = getThis();
187
188 ZVAL_UNDEF(&phql);
189 ZVAL_UNDEF(&container_sub);
190 ZVAL_BOOL(&__$true, 1);
191 ZVAL_BOOL(&__$false, 0);
192 ZVAL_NULL(&__$null);
193 ZVAL_UNDEF(&enableImplicitJoins);
194 ZVAL_UNDEF(&options);
195
196 ZEPHIR_MM_GROW();
197 zephir_fetch_params(1, 0, 3, &phql_param, &container, &options_param);
198
199 if (!phql_param) {
200 ZEPHIR_INIT_VAR(&phql);
201 ZVAL_STRING(&phql, "");
202 } else {
203 zephir_get_strval(&phql, phql_param);
204 }
205 if (!container) {
206 container = &container_sub;
207 container = &__$null;
208 }
209 if (!options_param) {
210 ZEPHIR_INIT_VAR(&options);
211 array_init(&options);
212 } else {
213 zephir_get_arrval(&options, options_param);
214 }
215
216
217 zephir_update_property_zval(this_ptr, ZEND_STRL("phql"), &phql);
218 if (Z_TYPE_P(container) == IS_OBJECT) {
219 ZEPHIR_CALL_METHOD(NULL, this_ptr, "setdi", NULL, 0, container);
220 zephir_check_call_status();
221 }
222 ZEPHIR_OBS_VAR(&enableImplicitJoins);
223 if (zephir_array_isset_string_fetch(&enableImplicitJoins, &options, SL("enable_implicit_joins"), 0)) {
224 if (ZEPHIR_IS_TRUE(&enableImplicitJoins)) {
225 zephir_update_property_zval(this_ptr, ZEND_STRL("enableImplicitJoins"), &__$true);
226 } else {
227 zephir_update_property_zval(this_ptr, ZEND_STRL("enableImplicitJoins"), &__$false);
228 }
229 } else {
230 if (ZEPHIR_GLOBAL(orm).enable_implicit_joins) {
231 zephir_update_property_zval(this_ptr, ZEND_STRL("enableImplicitJoins"), &__$true);
232 } else {
233 zephir_update_property_zval(this_ptr, ZEND_STRL("enableImplicitJoins"), &__$false);
234 }
235 }
236 ZEPHIR_MM_RESTORE();
237
238 }
239
240 /**
241 * Sets the dependency injection container
242 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setDI)243 PHP_METHOD(Phalcon_Mvc_Model_Query, setDI) {
244
245 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
246 zend_long ZEPHIR_LAST_CALL_STATUS;
247 zval *container, container_sub, manager, metaData, _0;
248 zval *this_ptr = getThis();
249
250 ZVAL_UNDEF(&container_sub);
251 ZVAL_UNDEF(&manager);
252 ZVAL_UNDEF(&metaData);
253 ZVAL_UNDEF(&_0);
254
255 ZEPHIR_MM_GROW();
256 zephir_fetch_params(1, 1, 0, &container);
257
258
259
260 ZEPHIR_INIT_VAR(&_0);
261 ZVAL_STRING(&_0, "modelsManager");
262 ZEPHIR_CALL_METHOD(&manager, container, "getshared", NULL, 0, &_0);
263 zephir_check_call_status();
264 if (UNEXPECTED(Z_TYPE_P(&manager) != IS_OBJECT)) {
265 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Injected service 'modelsManager' is invalid", "phalcon/Mvc/Model/Query.zep", 150);
266 return;
267 }
268 ZEPHIR_INIT_NVAR(&_0);
269 ZVAL_STRING(&_0, "modelsMetadata");
270 ZEPHIR_CALL_METHOD(&metaData, container, "getshared", NULL, 0, &_0);
271 zephir_check_call_status();
272 if (UNEXPECTED(Z_TYPE_P(&metaData) != IS_OBJECT)) {
273 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Injected service 'modelsMetaData' is invalid", "phalcon/Mvc/Model/Query.zep", 156);
274 return;
275 }
276 zephir_update_property_zval(this_ptr, ZEND_STRL("manager"), &manager);
277 zephir_update_property_zval(this_ptr, ZEND_STRL("metaData"), &metaData);
278 zephir_update_property_zval(this_ptr, ZEND_STRL("container"), container);
279 ZEPHIR_MM_RESTORE();
280
281 }
282
283 /**
284 * Returns the dependency injection container
285 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getDI)286 PHP_METHOD(Phalcon_Mvc_Model_Query, getDI) {
287
288 zval *this_ptr = getThis();
289
290
291 RETURN_MEMBER(getThis(), "container");
292
293 }
294
295 /**
296 * Tells to the query if only the first row in the resultset must be
297 * returned
298 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setUniqueRow)299 PHP_METHOD(Phalcon_Mvc_Model_Query, setUniqueRow) {
300
301 zval *uniqueRow_param = NULL, __$true, __$false;
302 zend_bool uniqueRow;
303 zval *this_ptr = getThis();
304
305 ZVAL_BOOL(&__$true, 1);
306 ZVAL_BOOL(&__$false, 0);
307
308 zephir_fetch_params_without_memory_grow(1, 0, &uniqueRow_param);
309
310 uniqueRow = zephir_get_boolval(uniqueRow_param);
311
312
313 if (uniqueRow) {
314 zephir_update_property_zval(this_ptr, ZEND_STRL("uniqueRow"), &__$true);
315 } else {
316 zephir_update_property_zval(this_ptr, ZEND_STRL("uniqueRow"), &__$false);
317 }
318 RETURN_THISW();
319
320 }
321
322 /**
323 * Check if the query is programmed to get only the first row in the
324 * resultset
325 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getUniqueRow)326 PHP_METHOD(Phalcon_Mvc_Model_Query, getUniqueRow) {
327
328 zval *this_ptr = getThis();
329
330
331 RETURN_MEMBER(getThis(), "uniqueRow");
332
333 }
334
335 /**
336 * Replaces the model's name to its source name in a qualified-name
337 * expression
338 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getQualified)339 PHP_METHOD(Phalcon_Mvc_Model_Query, _getQualified) {
340
341 zend_bool _3, _4;
342 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
343 zephir_fcall_cache_entry *_22 = NULL, *_27 = NULL;
344 zend_long ZEPHIR_LAST_CALL_STATUS, number = 0;
345 zval *expr_param = NULL, columnName, nestingLevel, sqlColumnAliases, metaData, sqlAliases, source, sqlAliasesModelsInstances, realColumnName, columnDomain, model, models, columnMap, hasModel, className, _0, _5, _6, _1$$3, _2$$3, _7$$6, _8$$7, _9$$7, _10$$7, _11$$8, _12$$9, _13$$9, _14$$9, _15$$12, _16$$12, _17$$12, _18$$14, *_19$$14, _20$$14, _34$$14, _21$$15, _23$$17, _24$$17, _25$$17, _26$$18, _28$$20, _29$$20, _30$$20, _31$$21, _32$$21, _33$$21, _35$$23, _36$$23, _37$$23, _38$$27, _39$$27, _40$$27;
346 zval expr;
347 zval *this_ptr = getThis();
348
349 ZVAL_UNDEF(&expr);
350 ZVAL_UNDEF(&columnName);
351 ZVAL_UNDEF(&nestingLevel);
352 ZVAL_UNDEF(&sqlColumnAliases);
353 ZVAL_UNDEF(&metaData);
354 ZVAL_UNDEF(&sqlAliases);
355 ZVAL_UNDEF(&source);
356 ZVAL_UNDEF(&sqlAliasesModelsInstances);
357 ZVAL_UNDEF(&realColumnName);
358 ZVAL_UNDEF(&columnDomain);
359 ZVAL_UNDEF(&model);
360 ZVAL_UNDEF(&models);
361 ZVAL_UNDEF(&columnMap);
362 ZVAL_UNDEF(&hasModel);
363 ZVAL_UNDEF(&className);
364 ZVAL_UNDEF(&_0);
365 ZVAL_UNDEF(&_5);
366 ZVAL_UNDEF(&_6);
367 ZVAL_UNDEF(&_1$$3);
368 ZVAL_UNDEF(&_2$$3);
369 ZVAL_UNDEF(&_7$$6);
370 ZVAL_UNDEF(&_8$$7);
371 ZVAL_UNDEF(&_9$$7);
372 ZVAL_UNDEF(&_10$$7);
373 ZVAL_UNDEF(&_11$$8);
374 ZVAL_UNDEF(&_12$$9);
375 ZVAL_UNDEF(&_13$$9);
376 ZVAL_UNDEF(&_14$$9);
377 ZVAL_UNDEF(&_15$$12);
378 ZVAL_UNDEF(&_16$$12);
379 ZVAL_UNDEF(&_17$$12);
380 ZVAL_UNDEF(&_18$$14);
381 ZVAL_UNDEF(&_20$$14);
382 ZVAL_UNDEF(&_34$$14);
383 ZVAL_UNDEF(&_21$$15);
384 ZVAL_UNDEF(&_23$$17);
385 ZVAL_UNDEF(&_24$$17);
386 ZVAL_UNDEF(&_25$$17);
387 ZVAL_UNDEF(&_26$$18);
388 ZVAL_UNDEF(&_28$$20);
389 ZVAL_UNDEF(&_29$$20);
390 ZVAL_UNDEF(&_30$$20);
391 ZVAL_UNDEF(&_31$$21);
392 ZVAL_UNDEF(&_32$$21);
393 ZVAL_UNDEF(&_33$$21);
394 ZVAL_UNDEF(&_35$$23);
395 ZVAL_UNDEF(&_36$$23);
396 ZVAL_UNDEF(&_37$$23);
397 ZVAL_UNDEF(&_38$$27);
398 ZVAL_UNDEF(&_39$$27);
399 ZVAL_UNDEF(&_40$$27);
400
401 ZEPHIR_MM_GROW();
402 zephir_fetch_params(1, 1, 0, &expr_param);
403
404 ZEPHIR_OBS_COPY_OR_DUP(&expr, expr_param);
405
406
407 ZEPHIR_OBS_VAR(&columnName);
408 zephir_array_fetch_string(&columnName, &expr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 204);
409 zephir_read_property(&_0, this_ptr, ZEND_STRL("nestingLevel"), PH_NOISY_CC | PH_READONLY);
410 ZEPHIR_CPY_WRT(&nestingLevel, &_0);
411 zephir_read_property(&_0, this_ptr, ZEND_STRL("sqlColumnAliases"), PH_NOISY_CC | PH_READONLY);
412 if (zephir_array_isset(&_0, &nestingLevel)) {
413 zephir_read_property(&_1$$3, this_ptr, ZEND_STRL("sqlColumnAliases"), PH_NOISY_CC | PH_READONLY);
414 zephir_array_fetch(&_2$$3, &_1$$3, &nestingLevel, PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 212);
415 ZEPHIR_CPY_WRT(&sqlColumnAliases, &_2$$3);
416 } else {
417 ZEPHIR_INIT_NVAR(&sqlColumnAliases);
418 array_init(&sqlColumnAliases);
419 }
420 _3 = zephir_array_isset(&sqlColumnAliases, &columnName);
421 if (_3) {
422 _4 = !(zephir_array_isset_string(&expr, SL("domain")));
423 if (!(_4)) {
424 zephir_array_fetch_string(&_5, &expr, SL("domain"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 217);
425 _4 = ZEPHIR_IS_EMPTY(&_5);
426 }
427 _3 = _4;
428 }
429 if (_3) {
430 zephir_create_array(return_value, 2, 0);
431 add_assoc_stringl_ex(return_value, SL("type"), SL("qualified"));
432 zephir_array_update_string(return_value, SL("name"), &columnName, PH_COPY | PH_SEPARATE);
433 RETURN_MM();
434 }
435 zephir_read_property(&_6, this_ptr, ZEND_STRL("metaData"), PH_NOISY_CC | PH_READONLY);
436 ZEPHIR_CPY_WRT(&metaData, &_6);
437 ZEPHIR_OBS_VAR(&columnDomain);
438 if (zephir_array_isset_string_fetch(&columnDomain, &expr, SL("domain"), 0)) {
439 zephir_read_property(&_7$$6, this_ptr, ZEND_STRL("sqlAliases"), PH_NOISY_CC | PH_READONLY);
440 ZEPHIR_CPY_WRT(&sqlAliases, &_7$$6);
441 ZEPHIR_OBS_VAR(&source);
442 if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &sqlAliases, &columnDomain, 0)))) {
443 ZEPHIR_INIT_VAR(&_8$$7);
444 object_init_ex(&_8$$7, phalcon_mvc_model_exception_ce);
445 zephir_read_property(&_9$$7, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
446 ZEPHIR_INIT_VAR(&_10$$7);
447 ZEPHIR_CONCAT_SVSV(&_10$$7, "Unknown model or alias '", &columnDomain, "' (11), when preparing: ", &_9$$7);
448 ZEPHIR_CALL_METHOD(NULL, &_8$$7, "__construct", NULL, 8, &_10$$7);
449 zephir_check_call_status();
450 zephir_throw_exception_debug(&_8$$7, "phalcon/Mvc/Model/Query.zep", 238);
451 ZEPHIR_MM_RESTORE();
452 return;
453 }
454 if (ZEPHIR_GLOBAL(orm).column_renaming) {
455 zephir_read_property(&_11$$8, this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), PH_NOISY_CC | PH_READONLY);
456 ZEPHIR_CPY_WRT(&sqlAliasesModelsInstances, &_11$$8);
457 ZEPHIR_OBS_VAR(&model);
458 if (UNEXPECTED(!(zephir_array_isset_fetch(&model, &sqlAliasesModelsInstances, &columnDomain, 0)))) {
459 ZEPHIR_INIT_VAR(&_12$$9);
460 object_init_ex(&_12$$9, phalcon_mvc_model_exception_ce);
461 zephir_read_property(&_13$$9, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
462 ZEPHIR_INIT_VAR(&_14$$9);
463 ZEPHIR_CONCAT_SVSV(&_14$$9, "There is no model related to model or alias '", &columnDomain, "', when executing: ", &_13$$9);
464 ZEPHIR_CALL_METHOD(NULL, &_12$$9, "__construct", NULL, 8, &_14$$9);
465 zephir_check_call_status();
466 zephir_throw_exception_debug(&_12$$9, "phalcon/Mvc/Model/Query.zep", 257);
467 ZEPHIR_MM_RESTORE();
468 return;
469 }
470 ZEPHIR_CALL_METHOD(&columnMap, &metaData, "getreversecolumnmap", NULL, 0, &model);
471 zephir_check_call_status();
472 } else {
473 ZEPHIR_INIT_NVAR(&columnMap);
474 ZVAL_NULL(&columnMap);
475 }
476 if (Z_TYPE_P(&columnMap) == IS_ARRAY) {
477 ZEPHIR_OBS_VAR(&realColumnName);
478 if (UNEXPECTED(!(zephir_array_isset_fetch(&realColumnName, &columnMap, &columnName, 0)))) {
479 ZEPHIR_INIT_VAR(&_15$$12);
480 object_init_ex(&_15$$12, phalcon_mvc_model_exception_ce);
481 zephir_read_property(&_16$$12, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
482 ZEPHIR_INIT_VAR(&_17$$12);
483 ZEPHIR_CONCAT_SVSVSV(&_17$$12, "Column '", &columnName, "' doesn't belong to the model or alias '", &columnDomain, "', when executing: ", &_16$$12);
484 ZEPHIR_CALL_METHOD(NULL, &_15$$12, "__construct", NULL, 8, &_17$$12);
485 zephir_check_call_status();
486 zephir_throw_exception_debug(&_15$$12, "phalcon/Mvc/Model/Query.zep", 269);
487 ZEPHIR_MM_RESTORE();
488 return;
489 }
490 } else {
491 ZEPHIR_CPY_WRT(&realColumnName, &columnName);
492 }
493 } else {
494 number = 0;
495 ZEPHIR_INIT_VAR(&hasModel);
496 ZVAL_BOOL(&hasModel, 0);
497 zephir_read_property(&_18$$14, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
498 zephir_is_iterable(&_18$$14, 0, "phalcon/Mvc/Model/Query.zep", 303);
499 if (Z_TYPE_P(&_18$$14) == IS_ARRAY) {
500 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_18$$14), _19$$14)
501 {
502 ZEPHIR_INIT_NVAR(&model);
503 ZVAL_COPY(&model, _19$$14);
504 ZEPHIR_CALL_METHOD(&_21$$15, &metaData, "hasattribute", &_22, 0, &model, &columnName);
505 zephir_check_call_status();
506 if (zephir_is_true(&_21$$15)) {
507 number++;
508 if (UNEXPECTED(number > 1)) {
509 ZEPHIR_INIT_NVAR(&_23$$17);
510 object_init_ex(&_23$$17, phalcon_mvc_model_exception_ce);
511 zephir_read_property(&_24$$17, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
512 ZEPHIR_INIT_NVAR(&_25$$17);
513 ZEPHIR_CONCAT_SVSV(&_25$$17, "The column '", &columnName, "' is ambiguous, when preparing: ", &_24$$17);
514 ZEPHIR_CALL_METHOD(NULL, &_23$$17, "__construct", NULL, 8, &_25$$17);
515 zephir_check_call_status();
516 zephir_throw_exception_debug(&_23$$17, "phalcon/Mvc/Model/Query.zep", 292);
517 ZEPHIR_MM_RESTORE();
518 return;
519 }
520 ZEPHIR_CPY_WRT(&hasModel, &model);
521 }
522 } ZEND_HASH_FOREACH_END();
523 } else {
524 ZEPHIR_CALL_METHOD(NULL, &_18$$14, "rewind", NULL, 0);
525 zephir_check_call_status();
526 while (1) {
527 ZEPHIR_CALL_METHOD(&_20$$14, &_18$$14, "valid", NULL, 0);
528 zephir_check_call_status();
529 if (!zend_is_true(&_20$$14)) {
530 break;
531 }
532 ZEPHIR_CALL_METHOD(&model, &_18$$14, "current", NULL, 0);
533 zephir_check_call_status();
534 ZEPHIR_CALL_METHOD(&_26$$18, &metaData, "hasattribute", &_27, 0, &model, &columnName);
535 zephir_check_call_status();
536 if (zephir_is_true(&_26$$18)) {
537 number++;
538 if (UNEXPECTED(number > 1)) {
539 ZEPHIR_INIT_NVAR(&_28$$20);
540 object_init_ex(&_28$$20, phalcon_mvc_model_exception_ce);
541 zephir_read_property(&_29$$20, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
542 ZEPHIR_INIT_NVAR(&_30$$20);
543 ZEPHIR_CONCAT_SVSV(&_30$$20, "The column '", &columnName, "' is ambiguous, when preparing: ", &_29$$20);
544 ZEPHIR_CALL_METHOD(NULL, &_28$$20, "__construct", NULL, 8, &_30$$20);
545 zephir_check_call_status();
546 zephir_throw_exception_debug(&_28$$20, "phalcon/Mvc/Model/Query.zep", 292);
547 ZEPHIR_MM_RESTORE();
548 return;
549 }
550 ZEPHIR_CPY_WRT(&hasModel, &model);
551 }
552 ZEPHIR_CALL_METHOD(NULL, &_18$$14, "next", NULL, 0);
553 zephir_check_call_status();
554 }
555 }
556 ZEPHIR_INIT_NVAR(&model);
557 if (UNEXPECTED(ZEPHIR_IS_FALSE_IDENTICAL(&hasModel))) {
558 ZEPHIR_INIT_VAR(&_31$$21);
559 object_init_ex(&_31$$21, phalcon_mvc_model_exception_ce);
560 zephir_read_property(&_32$$21, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
561 ZEPHIR_INIT_VAR(&_33$$21);
562 ZEPHIR_CONCAT_SVSV(&_33$$21, "Column '", &columnName, "' doesn't belong to any of the selected models (1), when preparing: ", &_32$$21);
563 ZEPHIR_CALL_METHOD(NULL, &_31$$21, "__construct", NULL, 8, &_33$$21);
564 zephir_check_call_status();
565 zephir_throw_exception_debug(&_31$$21, "phalcon/Mvc/Model/Query.zep", 306);
566 ZEPHIR_MM_RESTORE();
567 return;
568 }
569 zephir_read_property(&_34$$14, this_ptr, ZEND_STRL("models"), PH_NOISY_CC | PH_READONLY);
570 ZEPHIR_CPY_WRT(&models, &_34$$14);
571 if (UNEXPECTED(Z_TYPE_P(&models) != IS_ARRAY)) {
572 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The models list was not loaded correctly", "phalcon/Mvc/Model/Query.zep", 317);
573 return;
574 }
575 ZEPHIR_INIT_VAR(&className);
576 zephir_get_class(&className, &hasModel, 0);
577 ZEPHIR_OBS_NVAR(&source);
578 if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &models, &className, 0)))) {
579 ZEPHIR_INIT_VAR(&_35$$23);
580 object_init_ex(&_35$$23, phalcon_mvc_model_exception_ce);
581 zephir_read_property(&_36$$23, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
582 ZEPHIR_INIT_VAR(&_37$$23);
583 ZEPHIR_CONCAT_SVSV(&_37$$23, "Can't obtain model's source from models list: '", &className, "', when preparing: ", &_36$$23);
584 ZEPHIR_CALL_METHOD(NULL, &_35$$23, "__construct", NULL, 8, &_37$$23);
585 zephir_check_call_status();
586 zephir_throw_exception_debug(&_35$$23, "phalcon/Mvc/Model/Query.zep", 328);
587 ZEPHIR_MM_RESTORE();
588 return;
589 }
590 if (ZEPHIR_GLOBAL(orm).column_renaming) {
591 ZEPHIR_CALL_METHOD(&columnMap, &metaData, "getreversecolumnmap", NULL, 0, &hasModel);
592 zephir_check_call_status();
593 } else {
594 ZEPHIR_INIT_NVAR(&columnMap);
595 ZVAL_NULL(&columnMap);
596 }
597 if (Z_TYPE_P(&columnMap) == IS_ARRAY) {
598 ZEPHIR_OBS_NVAR(&realColumnName);
599 if (UNEXPECTED(!(zephir_array_isset_fetch(&realColumnName, &columnMap, &columnName, 0)))) {
600 ZEPHIR_INIT_VAR(&_38$$27);
601 object_init_ex(&_38$$27, phalcon_mvc_model_exception_ce);
602 zephir_read_property(&_39$$27, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
603 ZEPHIR_INIT_VAR(&_40$$27);
604 ZEPHIR_CONCAT_SVSV(&_40$$27, "Column '", &columnName, "' doesn't belong to any of the selected models (3), when preparing: ", &_39$$27);
605 ZEPHIR_CALL_METHOD(NULL, &_38$$27, "__construct", NULL, 8, &_40$$27);
606 zephir_check_call_status();
607 zephir_throw_exception_debug(&_38$$27, "phalcon/Mvc/Model/Query.zep", 347);
608 ZEPHIR_MM_RESTORE();
609 return;
610 }
611 } else {
612 ZEPHIR_CPY_WRT(&realColumnName, &columnName);
613 }
614 }
615 zephir_create_array(return_value, 4, 0);
616 add_assoc_stringl_ex(return_value, SL("type"), SL("qualified"));
617 zephir_array_update_string(return_value, SL("domain"), &source, PH_COPY | PH_SEPARATE);
618 zephir_array_update_string(return_value, SL("name"), &realColumnName, PH_COPY | PH_SEPARATE);
619 zephir_array_update_string(return_value, SL("balias"), &columnName, PH_COPY | PH_SEPARATE);
620 RETURN_MM();
621
622 }
623
624 /**
625 * Resolves an expression in a single call argument
626 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getCallArgument)627 PHP_METHOD(Phalcon_Mvc_Model_Query, _getCallArgument) {
628
629 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
630 zend_long ZEPHIR_LAST_CALL_STATUS;
631 zval *argument_param = NULL, _0;
632 zval argument;
633 zval *this_ptr = getThis();
634
635 ZVAL_UNDEF(&argument);
636 ZVAL_UNDEF(&_0);
637
638 ZEPHIR_MM_GROW();
639 zephir_fetch_params(1, 1, 0, &argument_param);
640
641 ZEPHIR_OBS_COPY_OR_DUP(&argument, argument_param);
642
643
644 zephir_array_fetch_string(&_0, &argument, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 370);
645 if (ZEPHIR_IS_LONG(&_0, 352)) {
646 zephir_create_array(return_value, 1, 0);
647 add_assoc_stringl_ex(return_value, SL("type"), SL("all"));
648 RETURN_MM();
649 }
650 ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_getexpression", NULL, 474, &argument);
651 zephir_check_call_status();
652 RETURN_MM();
653
654 }
655
656 /**
657 * Resolves an expression in a single call argument
658 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getCaseExpression)659 PHP_METHOD(Phalcon_Mvc_Model_Query, _getCaseExpression) {
660
661 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
662 zephir_fcall_cache_entry *_6 = NULL;
663 zend_long ZEPHIR_LAST_CALL_STATUS;
664 zval *expr_param = NULL, whenClauses, whenExpr, _0, *_1, _2, _18, _19, _4$$4, _5$$4, _7$$4, _9$$5, _10$$5, _12$$7, _13$$7, _14$$7, _16$$8, _17$$8;
665 zval expr, _3$$4, _8$$5, _11$$7, _15$$8;
666 zval *this_ptr = getThis();
667
668 ZVAL_UNDEF(&expr);
669 ZVAL_UNDEF(&_3$$4);
670 ZVAL_UNDEF(&_8$$5);
671 ZVAL_UNDEF(&_11$$7);
672 ZVAL_UNDEF(&_15$$8);
673 ZVAL_UNDEF(&whenClauses);
674 ZVAL_UNDEF(&whenExpr);
675 ZVAL_UNDEF(&_0);
676 ZVAL_UNDEF(&_2);
677 ZVAL_UNDEF(&_18);
678 ZVAL_UNDEF(&_19);
679 ZVAL_UNDEF(&_4$$4);
680 ZVAL_UNDEF(&_5$$4);
681 ZVAL_UNDEF(&_7$$4);
682 ZVAL_UNDEF(&_9$$5);
683 ZVAL_UNDEF(&_10$$5);
684 ZVAL_UNDEF(&_12$$7);
685 ZVAL_UNDEF(&_13$$7);
686 ZVAL_UNDEF(&_14$$7);
687 ZVAL_UNDEF(&_16$$8);
688 ZVAL_UNDEF(&_17$$8);
689
690 ZEPHIR_MM_GROW();
691 zephir_fetch_params(1, 1, 0, &expr_param);
692
693 ZEPHIR_OBS_COPY_OR_DUP(&expr, expr_param);
694
695
696 ZEPHIR_INIT_VAR(&whenClauses);
697 array_init(&whenClauses);
698 zephir_array_fetch_string(&_0, &expr, SL("right"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 388);
699 zephir_is_iterable(&_0, 0, "phalcon/Mvc/Model/Query.zep", 403);
700 if (Z_TYPE_P(&_0) == IS_ARRAY) {
701 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_0), _1)
702 {
703 ZEPHIR_INIT_NVAR(&whenExpr);
704 ZVAL_COPY(&whenExpr, _1);
705 if (zephir_array_isset_string(&whenExpr, SL("right"))) {
706 ZEPHIR_INIT_NVAR(&_3$$4);
707 zephir_create_array(&_3$$4, 3, 0);
708 add_assoc_stringl_ex(&_3$$4, SL("type"), SL("when"));
709 zephir_array_fetch_string(&_5$$4, &whenExpr, SL("left"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 392);
710 ZEPHIR_CALL_METHOD(&_4$$4, this_ptr, "_getexpression", &_6, 474, &_5$$4);
711 zephir_check_call_status();
712 zephir_array_update_string(&_3$$4, SL("expr"), &_4$$4, PH_COPY | PH_SEPARATE);
713 zephir_array_fetch_string(&_7$$4, &whenExpr, SL("right"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 393);
714 ZEPHIR_CALL_METHOD(&_4$$4, this_ptr, "_getexpression", &_6, 474, &_7$$4);
715 zephir_check_call_status();
716 zephir_array_update_string(&_3$$4, SL("then"), &_4$$4, PH_COPY | PH_SEPARATE);
717 zephir_array_append(&whenClauses, &_3$$4, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 394);
718 } else {
719 ZEPHIR_INIT_NVAR(&_8$$5);
720 zephir_create_array(&_8$$5, 2, 0);
721 add_assoc_stringl_ex(&_8$$5, SL("type"), SL("else"));
722 zephir_array_fetch_string(&_10$$5, &whenExpr, SL("left"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 398);
723 ZEPHIR_CALL_METHOD(&_9$$5, this_ptr, "_getexpression", &_6, 474, &_10$$5);
724 zephir_check_call_status();
725 zephir_array_update_string(&_8$$5, SL("expr"), &_9$$5, PH_COPY | PH_SEPARATE);
726 zephir_array_append(&whenClauses, &_8$$5, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 399);
727 }
728 } ZEND_HASH_FOREACH_END();
729 } else {
730 ZEPHIR_CALL_METHOD(NULL, &_0, "rewind", NULL, 0);
731 zephir_check_call_status();
732 while (1) {
733 ZEPHIR_CALL_METHOD(&_2, &_0, "valid", NULL, 0);
734 zephir_check_call_status();
735 if (!zend_is_true(&_2)) {
736 break;
737 }
738 ZEPHIR_CALL_METHOD(&whenExpr, &_0, "current", NULL, 0);
739 zephir_check_call_status();
740 if (zephir_array_isset_string(&whenExpr, SL("right"))) {
741 ZEPHIR_INIT_NVAR(&_11$$7);
742 zephir_create_array(&_11$$7, 3, 0);
743 add_assoc_stringl_ex(&_11$$7, SL("type"), SL("when"));
744 zephir_array_fetch_string(&_13$$7, &whenExpr, SL("left"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 392);
745 ZEPHIR_CALL_METHOD(&_12$$7, this_ptr, "_getexpression", &_6, 474, &_13$$7);
746 zephir_check_call_status();
747 zephir_array_update_string(&_11$$7, SL("expr"), &_12$$7, PH_COPY | PH_SEPARATE);
748 zephir_array_fetch_string(&_14$$7, &whenExpr, SL("right"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 393);
749 ZEPHIR_CALL_METHOD(&_12$$7, this_ptr, "_getexpression", &_6, 474, &_14$$7);
750 zephir_check_call_status();
751 zephir_array_update_string(&_11$$7, SL("then"), &_12$$7, PH_COPY | PH_SEPARATE);
752 zephir_array_append(&whenClauses, &_11$$7, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 394);
753 } else {
754 ZEPHIR_INIT_NVAR(&_15$$8);
755 zephir_create_array(&_15$$8, 2, 0);
756 add_assoc_stringl_ex(&_15$$8, SL("type"), SL("else"));
757 zephir_array_fetch_string(&_17$$8, &whenExpr, SL("left"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 398);
758 ZEPHIR_CALL_METHOD(&_16$$8, this_ptr, "_getexpression", &_6, 474, &_17$$8);
759 zephir_check_call_status();
760 zephir_array_update_string(&_15$$8, SL("expr"), &_16$$8, PH_COPY | PH_SEPARATE);
761 zephir_array_append(&whenClauses, &_15$$8, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 399);
762 }
763 ZEPHIR_CALL_METHOD(NULL, &_0, "next", NULL, 0);
764 zephir_check_call_status();
765 }
766 }
767 ZEPHIR_INIT_NVAR(&whenExpr);
768 zephir_create_array(return_value, 3, 0);
769 add_assoc_stringl_ex(return_value, SL("type"), SL("case"));
770 zephir_array_fetch_string(&_19, &expr, SL("left"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 405);
771 ZEPHIR_CALL_METHOD(&_18, this_ptr, "_getexpression", &_6, 474, &_19);
772 zephir_check_call_status();
773 zephir_array_update_string(return_value, SL("expr"), &_18, PH_COPY | PH_SEPARATE);
774 zephir_array_update_string(return_value, SL("when-clauses"), &whenClauses, PH_COPY | PH_SEPARATE);
775 RETURN_MM();
776
777 }
778
779 /**
780 * Resolves an expression in a single call argument
781 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getFunctionCall)782 PHP_METHOD(Phalcon_Mvc_Model_Query, _getFunctionCall) {
783
784 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
785 zephir_fcall_cache_entry *_3 = NULL;
786 zend_long ZEPHIR_LAST_CALL_STATUS, distinct = 0;
787 zval *expr_param = NULL, arguments, argument, _10, *_0$$6, _1$$6, _2$$7, _4$$8, _5$$9, _6$$9, _7$$10, _8$$10, _9$$11;
788 zval expr, functionArgs;
789 zval *this_ptr = getThis();
790
791 ZVAL_UNDEF(&expr);
792 ZVAL_UNDEF(&functionArgs);
793 ZVAL_UNDEF(&arguments);
794 ZVAL_UNDEF(&argument);
795 ZVAL_UNDEF(&_10);
796 ZVAL_UNDEF(&_1$$6);
797 ZVAL_UNDEF(&_2$$7);
798 ZVAL_UNDEF(&_4$$8);
799 ZVAL_UNDEF(&_5$$9);
800 ZVAL_UNDEF(&_6$$9);
801 ZVAL_UNDEF(&_7$$10);
802 ZVAL_UNDEF(&_8$$10);
803 ZVAL_UNDEF(&_9$$11);
804
805 ZEPHIR_MM_GROW();
806 zephir_fetch_params(1, 1, 0, &expr_param);
807
808 ZEPHIR_OBS_COPY_OR_DUP(&expr, expr_param);
809
810
811 ZEPHIR_OBS_VAR(&arguments);
812 if (zephir_array_isset_string_fetch(&arguments, &expr, SL("arguments"), 0)) {
813 if (zephir_array_isset_string(&expr, SL("distinct"))) {
814 distinct = 1;
815 } else {
816 distinct = 0;
817 }
818 if (zephir_array_isset_long(&arguments, 0)) {
819 ZEPHIR_INIT_VAR(&functionArgs);
820 array_init(&functionArgs);
821 zephir_is_iterable(&arguments, 0, "phalcon/Mvc/Model/Query.zep", 433);
822 if (Z_TYPE_P(&arguments) == IS_ARRAY) {
823 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&arguments), _0$$6)
824 {
825 ZEPHIR_INIT_NVAR(&argument);
826 ZVAL_COPY(&argument, _0$$6);
827 ZEPHIR_CALL_METHOD(&_2$$7, this_ptr, "_getcallargument", &_3, 475, &argument);
828 zephir_check_call_status();
829 zephir_array_append(&functionArgs, &_2$$7, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 431);
830 } ZEND_HASH_FOREACH_END();
831 } else {
832 ZEPHIR_CALL_METHOD(NULL, &arguments, "rewind", NULL, 0);
833 zephir_check_call_status();
834 while (1) {
835 ZEPHIR_CALL_METHOD(&_1$$6, &arguments, "valid", NULL, 0);
836 zephir_check_call_status();
837 if (!zend_is_true(&_1$$6)) {
838 break;
839 }
840 ZEPHIR_CALL_METHOD(&argument, &arguments, "current", NULL, 0);
841 zephir_check_call_status();
842 ZEPHIR_CALL_METHOD(&_4$$8, this_ptr, "_getcallargument", &_3, 475, &argument);
843 zephir_check_call_status();
844 zephir_array_append(&functionArgs, &_4$$8, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 431);
845 ZEPHIR_CALL_METHOD(NULL, &arguments, "next", NULL, 0);
846 zephir_check_call_status();
847 }
848 }
849 ZEPHIR_INIT_NVAR(&argument);
850 } else {
851 ZEPHIR_INIT_VAR(&_5$$9);
852 zephir_create_array(&_5$$9, 1, 0);
853 ZEPHIR_CALL_METHOD(&_6$$9, this_ptr, "_getcallargument", &_3, 475, &arguments);
854 zephir_check_call_status();
855 zephir_array_fast_append(&_5$$9, &_6$$9);
856 ZEPHIR_CPY_WRT(&functionArgs, &_5$$9);
857 }
858 if (distinct) {
859 zephir_create_array(return_value, 4, 0);
860 add_assoc_stringl_ex(return_value, SL("type"), SL("functionCall"));
861 ZEPHIR_OBS_VAR(&_7$$10);
862 zephir_array_fetch_string(&_7$$10, &expr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 443);
863 zephir_array_update_string(return_value, SL("name"), &_7$$10, PH_COPY | PH_SEPARATE);
864 zephir_array_update_string(return_value, SL("arguments"), &functionArgs, PH_COPY | PH_SEPARATE);
865 ZEPHIR_INIT_VAR(&_8$$10);
866 ZVAL_LONG(&_8$$10, distinct);
867 zephir_array_update_string(return_value, SL("distinct"), &_8$$10, PH_COPY | PH_SEPARATE);
868 RETURN_MM();
869 } else {
870 zephir_create_array(return_value, 3, 0);
871 add_assoc_stringl_ex(return_value, SL("type"), SL("functionCall"));
872 ZEPHIR_OBS_VAR(&_9$$11);
873 zephir_array_fetch_string(&_9$$11, &expr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 450);
874 zephir_array_update_string(return_value, SL("name"), &_9$$11, PH_COPY | PH_SEPARATE);
875 zephir_array_update_string(return_value, SL("arguments"), &functionArgs, PH_COPY | PH_SEPARATE);
876 RETURN_MM();
877 }
878 }
879 zephir_create_array(return_value, 2, 0);
880 add_assoc_stringl_ex(return_value, SL("type"), SL("functionCall"));
881 ZEPHIR_OBS_VAR(&_10);
882 zephir_array_fetch_string(&_10, &expr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 459);
883 zephir_array_update_string(return_value, SL("name"), &_10, PH_COPY | PH_SEPARATE);
884 RETURN_MM();
885
886 }
887
888 /**
889 * Resolves an expression from its intermediate code into a string
890 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getExpression)891 PHP_METHOD(Phalcon_Mvc_Model_Query, _getExpression) {
892
893 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
894 zend_long ZEPHIR_LAST_CALL_STATUS;
895 zend_bool quoting, tempNotQuoting = 0;
896 zval *expr_param = NULL, *quoting_param = NULL, exprType, exprLeft, exprRight, left, right, listItems, exprListItem, exprReturn, value, escapedValue, exprValue, valueParts, name, bindType, bind, _0$$5, _1$$6, _2$$8, _3$$9, _4$$10, _5$$11, _6$$12, _7$$13, _8$$14, _9$$16, _10$$17, _11$$18, _12$$19, _13$$20, _14$$21, _15$$22, _16$$23, _17$$24, _18$$25, _19$$25, _20$$26, _21$$27, _22$$28, _23$$33, _24$$33, _25$$33, _26$$33, _27$$33, _28$$34, _29$$34, _30$$34, _31$$37, _32$$37, _33$$37, _34$$38, _35$$38, _36$$38, _37$$39, _38$$39, _39$$39, _40$$40, _41$$40, _42$$40, _43$$41, _44$$41, _45$$41, _46$$42, _47$$42, _48$$42, _49$$43, _56$$43, _57$$43, _50$$44, _51$$44, _52$$45, _53$$45, _54$$46, _55$$46, _58$$47, _59$$47, _60$$48, _61$$48, _62$$49, _63$$50, _64$$51, _65$$52, _66$$53, _67$$54, _68$$55, _69$$56, _70$$57, _71$$58, _72$$59, _73$$60, _74$$61, _75$$62, _76$$63, _77$$64, _78$$65, _79$$66, _80$$66, _81$$69, _82$$69, _83$$69, _84$$70, _85$$70, *_86$$72, _87$$72, _88$$73, _89$$74;
897 zval expr;
898 zval *this_ptr = getThis();
899
900 ZVAL_UNDEF(&expr);
901 ZVAL_UNDEF(&exprType);
902 ZVAL_UNDEF(&exprLeft);
903 ZVAL_UNDEF(&exprRight);
904 ZVAL_UNDEF(&left);
905 ZVAL_UNDEF(&right);
906 ZVAL_UNDEF(&listItems);
907 ZVAL_UNDEF(&exprListItem);
908 ZVAL_UNDEF(&exprReturn);
909 ZVAL_UNDEF(&value);
910 ZVAL_UNDEF(&escapedValue);
911 ZVAL_UNDEF(&exprValue);
912 ZVAL_UNDEF(&valueParts);
913 ZVAL_UNDEF(&name);
914 ZVAL_UNDEF(&bindType);
915 ZVAL_UNDEF(&bind);
916 ZVAL_UNDEF(&_0$$5);
917 ZVAL_UNDEF(&_1$$6);
918 ZVAL_UNDEF(&_2$$8);
919 ZVAL_UNDEF(&_3$$9);
920 ZVAL_UNDEF(&_4$$10);
921 ZVAL_UNDEF(&_5$$11);
922 ZVAL_UNDEF(&_6$$12);
923 ZVAL_UNDEF(&_7$$13);
924 ZVAL_UNDEF(&_8$$14);
925 ZVAL_UNDEF(&_9$$16);
926 ZVAL_UNDEF(&_10$$17);
927 ZVAL_UNDEF(&_11$$18);
928 ZVAL_UNDEF(&_12$$19);
929 ZVAL_UNDEF(&_13$$20);
930 ZVAL_UNDEF(&_14$$21);
931 ZVAL_UNDEF(&_15$$22);
932 ZVAL_UNDEF(&_16$$23);
933 ZVAL_UNDEF(&_17$$24);
934 ZVAL_UNDEF(&_18$$25);
935 ZVAL_UNDEF(&_19$$25);
936 ZVAL_UNDEF(&_20$$26);
937 ZVAL_UNDEF(&_21$$27);
938 ZVAL_UNDEF(&_22$$28);
939 ZVAL_UNDEF(&_23$$33);
940 ZVAL_UNDEF(&_24$$33);
941 ZVAL_UNDEF(&_25$$33);
942 ZVAL_UNDEF(&_26$$33);
943 ZVAL_UNDEF(&_27$$33);
944 ZVAL_UNDEF(&_28$$34);
945 ZVAL_UNDEF(&_29$$34);
946 ZVAL_UNDEF(&_30$$34);
947 ZVAL_UNDEF(&_31$$37);
948 ZVAL_UNDEF(&_32$$37);
949 ZVAL_UNDEF(&_33$$37);
950 ZVAL_UNDEF(&_34$$38);
951 ZVAL_UNDEF(&_35$$38);
952 ZVAL_UNDEF(&_36$$38);
953 ZVAL_UNDEF(&_37$$39);
954 ZVAL_UNDEF(&_38$$39);
955 ZVAL_UNDEF(&_39$$39);
956 ZVAL_UNDEF(&_40$$40);
957 ZVAL_UNDEF(&_41$$40);
958 ZVAL_UNDEF(&_42$$40);
959 ZVAL_UNDEF(&_43$$41);
960 ZVAL_UNDEF(&_44$$41);
961 ZVAL_UNDEF(&_45$$41);
962 ZVAL_UNDEF(&_46$$42);
963 ZVAL_UNDEF(&_47$$42);
964 ZVAL_UNDEF(&_48$$42);
965 ZVAL_UNDEF(&_49$$43);
966 ZVAL_UNDEF(&_56$$43);
967 ZVAL_UNDEF(&_57$$43);
968 ZVAL_UNDEF(&_50$$44);
969 ZVAL_UNDEF(&_51$$44);
970 ZVAL_UNDEF(&_52$$45);
971 ZVAL_UNDEF(&_53$$45);
972 ZVAL_UNDEF(&_54$$46);
973 ZVAL_UNDEF(&_55$$46);
974 ZVAL_UNDEF(&_58$$47);
975 ZVAL_UNDEF(&_59$$47);
976 ZVAL_UNDEF(&_60$$48);
977 ZVAL_UNDEF(&_61$$48);
978 ZVAL_UNDEF(&_62$$49);
979 ZVAL_UNDEF(&_63$$50);
980 ZVAL_UNDEF(&_64$$51);
981 ZVAL_UNDEF(&_65$$52);
982 ZVAL_UNDEF(&_66$$53);
983 ZVAL_UNDEF(&_67$$54);
984 ZVAL_UNDEF(&_68$$55);
985 ZVAL_UNDEF(&_69$$56);
986 ZVAL_UNDEF(&_70$$57);
987 ZVAL_UNDEF(&_71$$58);
988 ZVAL_UNDEF(&_72$$59);
989 ZVAL_UNDEF(&_73$$60);
990 ZVAL_UNDEF(&_74$$61);
991 ZVAL_UNDEF(&_75$$62);
992 ZVAL_UNDEF(&_76$$63);
993 ZVAL_UNDEF(&_77$$64);
994 ZVAL_UNDEF(&_78$$65);
995 ZVAL_UNDEF(&_79$$66);
996 ZVAL_UNDEF(&_80$$66);
997 ZVAL_UNDEF(&_81$$69);
998 ZVAL_UNDEF(&_82$$69);
999 ZVAL_UNDEF(&_83$$69);
1000 ZVAL_UNDEF(&_84$$70);
1001 ZVAL_UNDEF(&_85$$70);
1002 ZVAL_UNDEF(&_87$$72);
1003 ZVAL_UNDEF(&_88$$73);
1004 ZVAL_UNDEF(&_89$$74);
1005
1006 ZEPHIR_MM_GROW();
1007 zephir_fetch_params(1, 1, 1, &expr_param, "ing_param);
1008
1009 zephir_get_arrval(&expr, expr_param);
1010 if (!quoting_param) {
1011 quoting = 1;
1012 } else {
1013 quoting = zephir_get_boolval(quoting_param);
1014 }
1015
1016
1017 ZEPHIR_INIT_VAR(&left);
1018 ZVAL_NULL(&left);
1019 ZEPHIR_INIT_VAR(&right);
1020 ZVAL_NULL(&right);
1021 ZEPHIR_OBS_VAR(&exprType);
1022 if (zephir_array_isset_string_fetch(&exprType, &expr, SL("type"), 0)) {
1023 tempNotQuoting = 1;
1024 if (!ZEPHIR_IS_LONG(&exprType, 409)) {
1025 ZEPHIR_OBS_VAR(&exprLeft);
1026 if (zephir_array_isset_string_fetch(&exprLeft, &expr, SL("left"), 0)) {
1027 if (tempNotQuoting) {
1028 ZVAL_BOOL(&_0$$5, 1);
1029 } else {
1030 ZVAL_BOOL(&_0$$5, 0);
1031 }
1032 ZEPHIR_CALL_METHOD(&left, this_ptr, "_getexpression", NULL, 474, &exprLeft, &_0$$5);
1033 zephir_check_call_status();
1034 }
1035 ZEPHIR_OBS_VAR(&exprRight);
1036 if (zephir_array_isset_string_fetch(&exprRight, &expr, SL("right"), 0)) {
1037 if (tempNotQuoting) {
1038 ZVAL_BOOL(&_1$$6, 1);
1039 } else {
1040 ZVAL_BOOL(&_1$$6, 0);
1041 }
1042 ZEPHIR_CALL_METHOD(&right, this_ptr, "_getexpression", NULL, 474, &exprRight, &_1$$6);
1043 zephir_check_call_status();
1044 }
1045 }
1046 do {
1047 if (ZEPHIR_IS_LONG(&exprType, '<')) {
1048 ZEPHIR_INIT_VAR(&exprReturn);
1049 zephir_create_array(&exprReturn, 4, 0);
1050 add_assoc_stringl_ex(&exprReturn, SL("type"), SL("binary-op"));
1051 add_assoc_stringl_ex(&exprReturn, SL("op"), SL("<"));
1052 zephir_array_update_string(&exprReturn, SL("left"), &left, PH_COPY | PH_SEPARATE);
1053 zephir_array_update_string(&exprReturn, SL("right"), &right, PH_COPY | PH_SEPARATE);
1054 break;
1055 }
1056 if (ZEPHIR_IS_LONG(&exprType, '=')) {
1057 ZEPHIR_INIT_VAR(&_2$$8);
1058 zephir_create_array(&_2$$8, 4, 0);
1059 add_assoc_stringl_ex(&_2$$8, SL("type"), SL("binary-op"));
1060 add_assoc_stringl_ex(&_2$$8, SL("op"), SL("="));
1061 zephir_array_update_string(&_2$$8, SL("left"), &left, PH_COPY | PH_SEPARATE);
1062 zephir_array_update_string(&_2$$8, SL("right"), &right, PH_COPY | PH_SEPARATE);
1063 ZEPHIR_CPY_WRT(&exprReturn, &_2$$8);
1064 break;
1065 }
1066 if (ZEPHIR_IS_LONG(&exprType, '>')) {
1067 ZEPHIR_INIT_VAR(&_3$$9);
1068 zephir_create_array(&_3$$9, 4, 0);
1069 add_assoc_stringl_ex(&_3$$9, SL("type"), SL("binary-op"));
1070 add_assoc_stringl_ex(&_3$$9, SL("op"), SL(">"));
1071 zephir_array_update_string(&_3$$9, SL("left"), &left, PH_COPY | PH_SEPARATE);
1072 zephir_array_update_string(&_3$$9, SL("right"), &right, PH_COPY | PH_SEPARATE);
1073 ZEPHIR_CPY_WRT(&exprReturn, &_3$$9);
1074 break;
1075 }
1076 if (ZEPHIR_IS_LONG(&exprType, 270)) {
1077 ZEPHIR_INIT_VAR(&_4$$10);
1078 zephir_create_array(&_4$$10, 4, 0);
1079 add_assoc_stringl_ex(&_4$$10, SL("type"), SL("binary-op"));
1080 add_assoc_stringl_ex(&_4$$10, SL("op"), SL("<>"));
1081 zephir_array_update_string(&_4$$10, SL("left"), &left, PH_COPY | PH_SEPARATE);
1082 zephir_array_update_string(&_4$$10, SL("right"), &right, PH_COPY | PH_SEPARATE);
1083 ZEPHIR_CPY_WRT(&exprReturn, &_4$$10);
1084 break;
1085 }
1086 if (ZEPHIR_IS_LONG(&exprType, 271)) {
1087 ZEPHIR_INIT_VAR(&_5$$11);
1088 zephir_create_array(&_5$$11, 4, 0);
1089 add_assoc_stringl_ex(&_5$$11, SL("type"), SL("binary-op"));
1090 add_assoc_stringl_ex(&_5$$11, SL("op"), SL("<="));
1091 zephir_array_update_string(&_5$$11, SL("left"), &left, PH_COPY | PH_SEPARATE);
1092 zephir_array_update_string(&_5$$11, SL("right"), &right, PH_COPY | PH_SEPARATE);
1093 ZEPHIR_CPY_WRT(&exprReturn, &_5$$11);
1094 break;
1095 }
1096 if (ZEPHIR_IS_LONG(&exprType, 272)) {
1097 ZEPHIR_INIT_VAR(&_6$$12);
1098 zephir_create_array(&_6$$12, 4, 0);
1099 add_assoc_stringl_ex(&_6$$12, SL("type"), SL("binary-op"));
1100 add_assoc_stringl_ex(&_6$$12, SL("op"), SL(">="));
1101 zephir_array_update_string(&_6$$12, SL("left"), &left, PH_COPY | PH_SEPARATE);
1102 zephir_array_update_string(&_6$$12, SL("right"), &right, PH_COPY | PH_SEPARATE);
1103 ZEPHIR_CPY_WRT(&exprReturn, &_6$$12);
1104 break;
1105 }
1106 if (ZEPHIR_IS_LONG(&exprType, 266)) {
1107 ZEPHIR_INIT_VAR(&_7$$13);
1108 zephir_create_array(&_7$$13, 4, 0);
1109 add_assoc_stringl_ex(&_7$$13, SL("type"), SL("binary-op"));
1110 add_assoc_stringl_ex(&_7$$13, SL("op"), SL("AND"));
1111 zephir_array_update_string(&_7$$13, SL("left"), &left, PH_COPY | PH_SEPARATE);
1112 zephir_array_update_string(&_7$$13, SL("right"), &right, PH_COPY | PH_SEPARATE);
1113 ZEPHIR_CPY_WRT(&exprReturn, &_7$$13);
1114 break;
1115 }
1116 if (ZEPHIR_IS_LONG(&exprType, 267)) {
1117 ZEPHIR_INIT_VAR(&_8$$14);
1118 zephir_create_array(&_8$$14, 4, 0);
1119 add_assoc_stringl_ex(&_8$$14, SL("type"), SL("binary-op"));
1120 add_assoc_stringl_ex(&_8$$14, SL("op"), SL("OR"));
1121 zephir_array_update_string(&_8$$14, SL("left"), &left, PH_COPY | PH_SEPARATE);
1122 zephir_array_update_string(&_8$$14, SL("right"), &right, PH_COPY | PH_SEPARATE);
1123 ZEPHIR_CPY_WRT(&exprReturn, &_8$$14);
1124 break;
1125 }
1126 if (ZEPHIR_IS_LONG(&exprType, 355)) {
1127 ZEPHIR_CALL_METHOD(&exprReturn, this_ptr, "_getqualified", NULL, 476, &expr);
1128 zephir_check_call_status();
1129 break;
1130 }
1131 if (ZEPHIR_IS_LONG(&exprType, '+')) {
1132 ZEPHIR_INIT_VAR(&_9$$16);
1133 zephir_create_array(&_9$$16, 4, 0);
1134 add_assoc_stringl_ex(&_9$$16, SL("type"), SL("binary-op"));
1135 add_assoc_stringl_ex(&_9$$16, SL("op"), SL("+"));
1136 zephir_array_update_string(&_9$$16, SL("left"), &left, PH_COPY | PH_SEPARATE);
1137 zephir_array_update_string(&_9$$16, SL("right"), &right, PH_COPY | PH_SEPARATE);
1138 ZEPHIR_CPY_WRT(&exprReturn, &_9$$16);
1139 break;
1140 }
1141 if (ZEPHIR_IS_LONG(&exprType, '-')) {
1142 ZEPHIR_INIT_VAR(&_10$$17);
1143 zephir_create_array(&_10$$17, 4, 0);
1144 add_assoc_stringl_ex(&_10$$17, SL("type"), SL("binary-op"));
1145 add_assoc_stringl_ex(&_10$$17, SL("op"), SL("-"));
1146 zephir_array_update_string(&_10$$17, SL("left"), &left, PH_COPY | PH_SEPARATE);
1147 zephir_array_update_string(&_10$$17, SL("right"), &right, PH_COPY | PH_SEPARATE);
1148 ZEPHIR_CPY_WRT(&exprReturn, &_10$$17);
1149 break;
1150 }
1151 if (ZEPHIR_IS_LONG(&exprType, '*')) {
1152 ZEPHIR_INIT_VAR(&_11$$18);
1153 zephir_create_array(&_11$$18, 4, 0);
1154 add_assoc_stringl_ex(&_11$$18, SL("type"), SL("binary-op"));
1155 add_assoc_stringl_ex(&_11$$18, SL("op"), SL("*"));
1156 zephir_array_update_string(&_11$$18, SL("left"), &left, PH_COPY | PH_SEPARATE);
1157 zephir_array_update_string(&_11$$18, SL("right"), &right, PH_COPY | PH_SEPARATE);
1158 ZEPHIR_CPY_WRT(&exprReturn, &_11$$18);
1159 break;
1160 }
1161 if (ZEPHIR_IS_LONG(&exprType, '/')) {
1162 ZEPHIR_INIT_VAR(&_12$$19);
1163 zephir_create_array(&_12$$19, 4, 0);
1164 add_assoc_stringl_ex(&_12$$19, SL("type"), SL("binary-op"));
1165 add_assoc_stringl_ex(&_12$$19, SL("op"), SL("/"));
1166 zephir_array_update_string(&_12$$19, SL("left"), &left, PH_COPY | PH_SEPARATE);
1167 zephir_array_update_string(&_12$$19, SL("right"), &right, PH_COPY | PH_SEPARATE);
1168 ZEPHIR_CPY_WRT(&exprReturn, &_12$$19);
1169 break;
1170 }
1171 if (ZEPHIR_IS_LONG(&exprType, '%')) {
1172 ZEPHIR_INIT_VAR(&_13$$20);
1173 zephir_create_array(&_13$$20, 4, 0);
1174 add_assoc_stringl_ex(&_13$$20, SL("type"), SL("binary-op"));
1175 add_assoc_stringl_ex(&_13$$20, SL("op"), SL("%"));
1176 zephir_array_update_string(&_13$$20, SL("left"), &left, PH_COPY | PH_SEPARATE);
1177 zephir_array_update_string(&_13$$20, SL("right"), &right, PH_COPY | PH_SEPARATE);
1178 ZEPHIR_CPY_WRT(&exprReturn, &_13$$20);
1179 break;
1180 }
1181 if (ZEPHIR_IS_LONG(&exprType, '&')) {
1182 ZEPHIR_INIT_VAR(&_14$$21);
1183 zephir_create_array(&_14$$21, 4, 0);
1184 add_assoc_stringl_ex(&_14$$21, SL("type"), SL("binary-op"));
1185 add_assoc_stringl_ex(&_14$$21, SL("op"), SL("&"));
1186 zephir_array_update_string(&_14$$21, SL("left"), &left, PH_COPY | PH_SEPARATE);
1187 zephir_array_update_string(&_14$$21, SL("right"), &right, PH_COPY | PH_SEPARATE);
1188 ZEPHIR_CPY_WRT(&exprReturn, &_14$$21);
1189 break;
1190 }
1191 if (ZEPHIR_IS_LONG(&exprType, '|')) {
1192 ZEPHIR_INIT_VAR(&_15$$22);
1193 zephir_create_array(&_15$$22, 4, 0);
1194 add_assoc_stringl_ex(&_15$$22, SL("type"), SL("binary-op"));
1195 add_assoc_stringl_ex(&_15$$22, SL("op"), SL("|"));
1196 zephir_array_update_string(&_15$$22, SL("left"), &left, PH_COPY | PH_SEPARATE);
1197 zephir_array_update_string(&_15$$22, SL("right"), &right, PH_COPY | PH_SEPARATE);
1198 ZEPHIR_CPY_WRT(&exprReturn, &_15$$22);
1199 break;
1200 }
1201 if (ZEPHIR_IS_LONG(&exprType, 356) || ZEPHIR_IS_LONG(&exprType, 407)) {
1202 ZEPHIR_INIT_VAR(&_16$$23);
1203 zephir_create_array(&_16$$23, 2, 0);
1204 add_assoc_stringl_ex(&_16$$23, SL("type"), SL("parentheses"));
1205 zephir_array_update_string(&_16$$23, SL("left"), &left, PH_COPY | PH_SEPARATE);
1206 ZEPHIR_CPY_WRT(&exprReturn, &_16$$23);
1207 break;
1208 }
1209 if (ZEPHIR_IS_LONG(&exprType, 367)) {
1210 ZEPHIR_INIT_VAR(&_17$$24);
1211 zephir_create_array(&_17$$24, 3, 0);
1212 add_assoc_stringl_ex(&_17$$24, SL("type"), SL("unary-op"));
1213 add_assoc_stringl_ex(&_17$$24, SL("op"), SL("-"));
1214 zephir_array_update_string(&_17$$24, SL("right"), &right, PH_COPY | PH_SEPARATE);
1215 ZEPHIR_CPY_WRT(&exprReturn, &_17$$24);
1216 break;
1217 }
1218 if (ZEPHIR_IS_LONG(&exprType, 258) || ZEPHIR_IS_LONG(&exprType, 259) || ZEPHIR_IS_LONG(&exprType, 414)) {
1219 ZEPHIR_INIT_VAR(&_18$$25);
1220 zephir_create_array(&_18$$25, 2, 0);
1221 add_assoc_stringl_ex(&_18$$25, SL("type"), SL("literal"));
1222 ZEPHIR_OBS_VAR(&_19$$25);
1223 zephir_array_fetch_string(&_19$$25, &expr, SL("value"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 673);
1224 zephir_array_update_string(&_18$$25, SL("value"), &_19$$25, PH_COPY | PH_SEPARATE);
1225 ZEPHIR_CPY_WRT(&exprReturn, &_18$$25);
1226 break;
1227 }
1228 if (ZEPHIR_IS_LONG(&exprType, 334)) {
1229 ZEPHIR_INIT_VAR(&_20$$26);
1230 zephir_create_array(&_20$$26, 2, 0);
1231 add_assoc_stringl_ex(&_20$$26, SL("type"), SL("literal"));
1232 add_assoc_stringl_ex(&_20$$26, SL("value"), SL("TRUE"));
1233 ZEPHIR_CPY_WRT(&exprReturn, &_20$$26);
1234 break;
1235 }
1236 if (ZEPHIR_IS_LONG(&exprType, 335)) {
1237 ZEPHIR_INIT_VAR(&_21$$27);
1238 zephir_create_array(&_21$$27, 2, 0);
1239 add_assoc_stringl_ex(&_21$$27, SL("type"), SL("literal"));
1240 add_assoc_stringl_ex(&_21$$27, SL("value"), SL("FALSE"));
1241 ZEPHIR_CPY_WRT(&exprReturn, &_21$$27);
1242 break;
1243 }
1244 if (ZEPHIR_IS_LONG(&exprType, 260)) {
1245 ZEPHIR_OBS_VAR(&value);
1246 zephir_array_fetch_string(&value, &expr, SL("value"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 694);
1247 if (quoting) {
1248 if (zephir_memnstr_str(&value, SL("'"), "phalcon/Mvc/Model/Query.zep", 701)) {
1249 ZEPHIR_INIT_VAR(&escapedValue);
1250 phalcon_orm_singlequotes(&escapedValue, &value TSRMLS_CC);
1251 } else {
1252 ZEPHIR_CPY_WRT(&escapedValue, &value);
1253 }
1254 ZEPHIR_INIT_VAR(&exprValue);
1255 ZEPHIR_CONCAT_SVS(&exprValue, "'", &escapedValue, "'");
1256 } else {
1257 ZEPHIR_CPY_WRT(&exprValue, &value);
1258 }
1259 ZEPHIR_INIT_VAR(&_22$$28);
1260 zephir_create_array(&_22$$28, 2, 0);
1261 add_assoc_stringl_ex(&_22$$28, SL("type"), SL("literal"));
1262 zephir_array_update_string(&_22$$28, SL("value"), &exprValue, PH_COPY | PH_SEPARATE);
1263 ZEPHIR_CPY_WRT(&exprReturn, &_22$$28);
1264 break;
1265 }
1266 if (ZEPHIR_IS_LONG(&exprType, 273)) {
1267 ZEPHIR_INIT_VAR(&_23$$33);
1268 zephir_create_array(&_23$$33, 2, 0);
1269 add_assoc_stringl_ex(&_23$$33, SL("type"), SL("placeholder"));
1270 ZEPHIR_INIT_VAR(&_24$$33);
1271 zephir_array_fetch_string(&_25$$33, &expr, SL("value"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 722);
1272 ZEPHIR_INIT_VAR(&_26$$33);
1273 ZVAL_STRING(&_26$$33, "?");
1274 ZEPHIR_INIT_VAR(&_27$$33);
1275 ZVAL_STRING(&_27$$33, ":");
1276 zephir_fast_str_replace(&_24$$33, &_26$$33, &_27$$33, &_25$$33);
1277 zephir_array_update_string(&_23$$33, SL("value"), &_24$$33, PH_COPY | PH_SEPARATE);
1278 ZEPHIR_CPY_WRT(&exprReturn, &_23$$33);
1279 break;
1280 }
1281 if (ZEPHIR_IS_LONG(&exprType, 274)) {
1282 ZEPHIR_INIT_VAR(&_28$$34);
1283 zephir_create_array(&_28$$34, 2, 0);
1284 add_assoc_stringl_ex(&_28$$34, SL("type"), SL("placeholder"));
1285 zephir_array_fetch_string(&_29$$34, &expr, SL("value"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 731);
1286 ZEPHIR_INIT_VAR(&_30$$34);
1287 ZEPHIR_CONCAT_SV(&_30$$34, ":", &_29$$34);
1288 zephir_array_update_string(&_28$$34, SL("value"), &_30$$34, PH_COPY | PH_SEPARATE);
1289 ZEPHIR_CPY_WRT(&exprReturn, &_28$$34);
1290 break;
1291 }
1292 if (ZEPHIR_IS_LONG(&exprType, 277)) {
1293 ZEPHIR_OBS_NVAR(&value);
1294 zephir_array_fetch_string(&value, &expr, SL("value"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 736);
1295 if (zephir_memnstr_str(&value, SL(":"), "phalcon/Mvc/Model/Query.zep", 738)) {
1296 ZEPHIR_INIT_VAR(&valueParts);
1297 zephir_fast_explode_str(&valueParts, SL(":"), &value, LONG_MAX);
1298 ZEPHIR_OBS_VAR(&name);
1299 zephir_array_fetch_long(&name, &valueParts, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 740);
1300 ZEPHIR_OBS_VAR(&bindType);
1301 zephir_array_fetch_long(&bindType, &valueParts, 1, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 741);
1302 do {
1303 if (ZEPHIR_IS_STRING(&bindType, "str")) {
1304 ZEPHIR_INIT_VAR(&_31$$37);
1305 ZVAL_LONG(&_31$$37, 2);
1306 zephir_update_property_array(this_ptr, SL("bindTypes"), &name, &_31$$37);
1307 ZEPHIR_INIT_VAR(&_32$$37);
1308 zephir_create_array(&_32$$37, 2, 0);
1309 add_assoc_stringl_ex(&_32$$37, SL("type"), SL("placeholder"));
1310 ZEPHIR_INIT_VAR(&_33$$37);
1311 ZEPHIR_CONCAT_SV(&_33$$37, ":", &name);
1312 zephir_array_update_string(&_32$$37, SL("value"), &_33$$37, PH_COPY | PH_SEPARATE);
1313 ZEPHIR_CPY_WRT(&exprReturn, &_32$$37);
1314 break;
1315 }
1316 if (ZEPHIR_IS_STRING(&bindType, "int")) {
1317 ZEPHIR_INIT_VAR(&_34$$38);
1318 ZVAL_LONG(&_34$$38, 1);
1319 zephir_update_property_array(this_ptr, SL("bindTypes"), &name, &_34$$38);
1320 ZEPHIR_INIT_VAR(&_35$$38);
1321 zephir_create_array(&_35$$38, 2, 0);
1322 add_assoc_stringl_ex(&_35$$38, SL("type"), SL("placeholder"));
1323 ZEPHIR_INIT_VAR(&_36$$38);
1324 ZEPHIR_CONCAT_SV(&_36$$38, ":", &name);
1325 zephir_array_update_string(&_35$$38, SL("value"), &_36$$38, PH_COPY | PH_SEPARATE);
1326 ZEPHIR_CPY_WRT(&exprReturn, &_35$$38);
1327 break;
1328 }
1329 if (ZEPHIR_IS_STRING(&bindType, "double")) {
1330 ZEPHIR_INIT_VAR(&_37$$39);
1331 ZVAL_LONG(&_37$$39, 32);
1332 zephir_update_property_array(this_ptr, SL("bindTypes"), &name, &_37$$39);
1333 ZEPHIR_INIT_VAR(&_38$$39);
1334 zephir_create_array(&_38$$39, 2, 0);
1335 add_assoc_stringl_ex(&_38$$39, SL("type"), SL("placeholder"));
1336 ZEPHIR_INIT_VAR(&_39$$39);
1337 ZEPHIR_CONCAT_SV(&_39$$39, ":", &name);
1338 zephir_array_update_string(&_38$$39, SL("value"), &_39$$39, PH_COPY | PH_SEPARATE);
1339 ZEPHIR_CPY_WRT(&exprReturn, &_38$$39);
1340 break;
1341 }
1342 if (ZEPHIR_IS_STRING(&bindType, "bool")) {
1343 ZEPHIR_INIT_VAR(&_40$$40);
1344 ZVAL_LONG(&_40$$40, 5);
1345 zephir_update_property_array(this_ptr, SL("bindTypes"), &name, &_40$$40);
1346 ZEPHIR_INIT_VAR(&_41$$40);
1347 zephir_create_array(&_41$$40, 2, 0);
1348 add_assoc_stringl_ex(&_41$$40, SL("type"), SL("placeholder"));
1349 ZEPHIR_INIT_VAR(&_42$$40);
1350 ZEPHIR_CONCAT_SV(&_42$$40, ":", &name);
1351 zephir_array_update_string(&_41$$40, SL("value"), &_42$$40, PH_COPY | PH_SEPARATE);
1352 ZEPHIR_CPY_WRT(&exprReturn, &_41$$40);
1353 break;
1354 }
1355 if (ZEPHIR_IS_STRING(&bindType, "blob")) {
1356 ZEPHIR_INIT_VAR(&_43$$41);
1357 ZVAL_LONG(&_43$$41, 3);
1358 zephir_update_property_array(this_ptr, SL("bindTypes"), &name, &_43$$41);
1359 ZEPHIR_INIT_VAR(&_44$$41);
1360 zephir_create_array(&_44$$41, 2, 0);
1361 add_assoc_stringl_ex(&_44$$41, SL("type"), SL("placeholder"));
1362 ZEPHIR_INIT_VAR(&_45$$41);
1363 ZEPHIR_CONCAT_SV(&_45$$41, ":", &name);
1364 zephir_array_update_string(&_44$$41, SL("value"), &_45$$41, PH_COPY | PH_SEPARATE);
1365 ZEPHIR_CPY_WRT(&exprReturn, &_44$$41);
1366 break;
1367 }
1368 if (ZEPHIR_IS_STRING(&bindType, "null")) {
1369 ZEPHIR_INIT_VAR(&_46$$42);
1370 ZVAL_LONG(&_46$$42, 0);
1371 zephir_update_property_array(this_ptr, SL("bindTypes"), &name, &_46$$42);
1372 ZEPHIR_INIT_VAR(&_47$$42);
1373 zephir_create_array(&_47$$42, 2, 0);
1374 add_assoc_stringl_ex(&_47$$42, SL("type"), SL("placeholder"));
1375 ZEPHIR_INIT_VAR(&_48$$42);
1376 ZEPHIR_CONCAT_SV(&_48$$42, ":", &name);
1377 zephir_array_update_string(&_47$$42, SL("value"), &_48$$42, PH_COPY | PH_SEPARATE);
1378 ZEPHIR_CPY_WRT(&exprReturn, &_47$$42);
1379 break;
1380 }
1381 if (ZEPHIR_IS_STRING(&bindType, "array") || ZEPHIR_IS_STRING(&bindType, "array-str") || ZEPHIR_IS_STRING(&bindType, "array-int")) {
1382 ZEPHIR_OBS_VAR(&bind);
1383 zephir_read_property(&_49$$43, this_ptr, ZEND_STRL("bindParams"), PH_NOISY_CC | PH_READONLY);
1384 if (UNEXPECTED(!(zephir_array_isset_fetch(&bind, &_49$$43, &name, 0)))) {
1385 ZEPHIR_INIT_VAR(&_50$$44);
1386 object_init_ex(&_50$$44, phalcon_mvc_model_exception_ce);
1387 ZEPHIR_INIT_VAR(&_51$$44);
1388 ZEPHIR_CONCAT_SV(&_51$$44, "Bind value is required for array type placeholder: ", &name);
1389 ZEPHIR_CALL_METHOD(NULL, &_50$$44, "__construct", NULL, 8, &_51$$44);
1390 zephir_check_call_status();
1391 zephir_throw_exception_debug(&_50$$44, "phalcon/Mvc/Model/Query.zep", 811);
1392 ZEPHIR_MM_RESTORE();
1393 return;
1394 }
1395 if (UNEXPECTED(Z_TYPE_P(&bind) != IS_ARRAY)) {
1396 ZEPHIR_INIT_VAR(&_52$$45);
1397 object_init_ex(&_52$$45, phalcon_mvc_model_exception_ce);
1398 ZEPHIR_INIT_VAR(&_53$$45);
1399 ZEPHIR_CONCAT_SV(&_53$$45, "Bind type requires an array in placeholder: ", &name);
1400 ZEPHIR_CALL_METHOD(NULL, &_52$$45, "__construct", NULL, 8, &_53$$45);
1401 zephir_check_call_status();
1402 zephir_throw_exception_debug(&_52$$45, "phalcon/Mvc/Model/Query.zep", 817);
1403 ZEPHIR_MM_RESTORE();
1404 return;
1405 }
1406 if (UNEXPECTED(zephir_fast_count_int(&bind) < 1)) {
1407 ZEPHIR_INIT_VAR(&_54$$46);
1408 object_init_ex(&_54$$46, phalcon_mvc_model_exception_ce);
1409 ZEPHIR_INIT_VAR(&_55$$46);
1410 ZEPHIR_CONCAT_SV(&_55$$46, "At least one value must be bound in placeholder: ", &name);
1411 ZEPHIR_CALL_METHOD(NULL, &_54$$46, "__construct", NULL, 8, &_55$$46);
1412 zephir_check_call_status();
1413 zephir_throw_exception_debug(&_54$$46, "phalcon/Mvc/Model/Query.zep", 823);
1414 ZEPHIR_MM_RESTORE();
1415 return;
1416 }
1417 ZEPHIR_INIT_VAR(&_56$$43);
1418 zephir_create_array(&_56$$43, 4, 0);
1419 add_assoc_stringl_ex(&_56$$43, SL("type"), SL("placeholder"));
1420 ZEPHIR_INIT_VAR(&_57$$43);
1421 ZEPHIR_CONCAT_SV(&_57$$43, ":", &name);
1422 zephir_array_update_string(&_56$$43, SL("value"), &_57$$43, PH_COPY | PH_SEPARATE);
1423 zephir_array_update_string(&_56$$43, SL("rawValue"), &name, PH_COPY | PH_SEPARATE);
1424 add_assoc_long_ex(&_56$$43, SL("times"), zephir_fast_count_int(&bind));
1425 ZEPHIR_CPY_WRT(&exprReturn, &_56$$43);
1426 break;
1427 }
1428 ZEPHIR_INIT_VAR(&_58$$47);
1429 object_init_ex(&_58$$47, phalcon_mvc_model_exception_ce);
1430 ZEPHIR_INIT_VAR(&_59$$47);
1431 ZEPHIR_CONCAT_SV(&_59$$47, "Unknown bind type: ", &bindType);
1432 ZEPHIR_CALL_METHOD(NULL, &_58$$47, "__construct", NULL, 8, &_59$$47);
1433 zephir_check_call_status();
1434 zephir_throw_exception_debug(&_58$$47, "phalcon/Mvc/Model/Query.zep", 838);
1435 ZEPHIR_MM_RESTORE();
1436 return;
1437 } while(0);
1438
1439 } else {
1440 ZEPHIR_INIT_VAR(&_60$$48);
1441 zephir_create_array(&_60$$48, 2, 0);
1442 add_assoc_stringl_ex(&_60$$48, SL("type"), SL("placeholder"));
1443 ZEPHIR_INIT_VAR(&_61$$48);
1444 ZEPHIR_CONCAT_SV(&_61$$48, ":", &value);
1445 zephir_array_update_string(&_60$$48, SL("value"), &_61$$48, PH_COPY | PH_SEPARATE);
1446 ZEPHIR_CPY_WRT(&exprReturn, &_60$$48);
1447 }
1448 break;
1449 }
1450 if (ZEPHIR_IS_LONG(&exprType, 322)) {
1451 ZEPHIR_INIT_VAR(&_62$$49);
1452 zephir_create_array(&_62$$49, 2, 0);
1453 add_assoc_stringl_ex(&_62$$49, SL("type"), SL("literal"));
1454 add_assoc_stringl_ex(&_62$$49, SL("value"), SL("NULL"));
1455 ZEPHIR_CPY_WRT(&exprReturn, &_62$$49);
1456 break;
1457 }
1458 if (ZEPHIR_IS_LONG(&exprType, 268)) {
1459 ZEPHIR_INIT_VAR(&_63$$50);
1460 zephir_create_array(&_63$$50, 4, 0);
1461 add_assoc_stringl_ex(&_63$$50, SL("type"), SL("binary-op"));
1462 add_assoc_stringl_ex(&_63$$50, SL("op"), SL("LIKE"));
1463 zephir_array_update_string(&_63$$50, SL("left"), &left, PH_COPY | PH_SEPARATE);
1464 zephir_array_update_string(&_63$$50, SL("right"), &right, PH_COPY | PH_SEPARATE);
1465 ZEPHIR_CPY_WRT(&exprReturn, &_63$$50);
1466 break;
1467 }
1468 if (ZEPHIR_IS_LONG(&exprType, 351)) {
1469 ZEPHIR_INIT_VAR(&_64$$51);
1470 zephir_create_array(&_64$$51, 4, 0);
1471 add_assoc_stringl_ex(&_64$$51, SL("type"), SL("binary-op"));
1472 add_assoc_stringl_ex(&_64$$51, SL("op"), SL("NOT LIKE"));
1473 zephir_array_update_string(&_64$$51, SL("left"), &left, PH_COPY | PH_SEPARATE);
1474 zephir_array_update_string(&_64$$51, SL("right"), &right, PH_COPY | PH_SEPARATE);
1475 ZEPHIR_CPY_WRT(&exprReturn, &_64$$51);
1476 break;
1477 }
1478 if (ZEPHIR_IS_LONG(&exprType, 275)) {
1479 ZEPHIR_INIT_VAR(&_65$$52);
1480 zephir_create_array(&_65$$52, 4, 0);
1481 add_assoc_stringl_ex(&_65$$52, SL("type"), SL("binary-op"));
1482 add_assoc_stringl_ex(&_65$$52, SL("op"), SL("ILIKE"));
1483 zephir_array_update_string(&_65$$52, SL("left"), &left, PH_COPY | PH_SEPARATE);
1484 zephir_array_update_string(&_65$$52, SL("right"), &right, PH_COPY | PH_SEPARATE);
1485 ZEPHIR_CPY_WRT(&exprReturn, &_65$$52);
1486 break;
1487 }
1488 if (ZEPHIR_IS_LONG(&exprType, 357)) {
1489 ZEPHIR_INIT_VAR(&_66$$53);
1490 zephir_create_array(&_66$$53, 4, 0);
1491 add_assoc_stringl_ex(&_66$$53, SL("type"), SL("binary-op"));
1492 add_assoc_stringl_ex(&_66$$53, SL("op"), SL("NOT ILIKE"));
1493 zephir_array_update_string(&_66$$53, SL("left"), &left, PH_COPY | PH_SEPARATE);
1494 zephir_array_update_string(&_66$$53, SL("right"), &right, PH_COPY | PH_SEPARATE);
1495 ZEPHIR_CPY_WRT(&exprReturn, &_66$$53);
1496 break;
1497 }
1498 if (ZEPHIR_IS_LONG(&exprType, '!')) {
1499 ZEPHIR_INIT_VAR(&_67$$54);
1500 zephir_create_array(&_67$$54, 3, 0);
1501 add_assoc_stringl_ex(&_67$$54, SL("type"), SL("unary-op"));
1502 add_assoc_stringl_ex(&_67$$54, SL("op"), SL("NOT "));
1503 zephir_array_update_string(&_67$$54, SL("right"), &right, PH_COPY | PH_SEPARATE);
1504 ZEPHIR_CPY_WRT(&exprReturn, &_67$$54);
1505 break;
1506 }
1507 if (ZEPHIR_IS_LONG(&exprType, 365)) {
1508 ZEPHIR_INIT_VAR(&_68$$55);
1509 zephir_create_array(&_68$$55, 3, 0);
1510 add_assoc_stringl_ex(&_68$$55, SL("type"), SL("unary-op"));
1511 add_assoc_stringl_ex(&_68$$55, SL("op"), SL(" IS NULL"));
1512 zephir_array_update_string(&_68$$55, SL("left"), &left, PH_COPY | PH_SEPARATE);
1513 ZEPHIR_CPY_WRT(&exprReturn, &_68$$55);
1514 break;
1515 }
1516 if (ZEPHIR_IS_LONG(&exprType, 366)) {
1517 ZEPHIR_INIT_VAR(&_69$$56);
1518 zephir_create_array(&_69$$56, 3, 0);
1519 add_assoc_stringl_ex(&_69$$56, SL("type"), SL("unary-op"));
1520 add_assoc_stringl_ex(&_69$$56, SL("op"), SL(" IS NOT NULL"));
1521 zephir_array_update_string(&_69$$56, SL("left"), &left, PH_COPY | PH_SEPARATE);
1522 ZEPHIR_CPY_WRT(&exprReturn, &_69$$56);
1523 break;
1524 }
1525 if (ZEPHIR_IS_LONG(&exprType, 315)) {
1526 ZEPHIR_INIT_VAR(&_70$$57);
1527 zephir_create_array(&_70$$57, 4, 0);
1528 add_assoc_stringl_ex(&_70$$57, SL("type"), SL("binary-op"));
1529 add_assoc_stringl_ex(&_70$$57, SL("op"), SL("IN"));
1530 zephir_array_update_string(&_70$$57, SL("left"), &left, PH_COPY | PH_SEPARATE);
1531 zephir_array_update_string(&_70$$57, SL("right"), &right, PH_COPY | PH_SEPARATE);
1532 ZEPHIR_CPY_WRT(&exprReturn, &_70$$57);
1533 break;
1534 }
1535 if (ZEPHIR_IS_LONG(&exprType, 323)) {
1536 ZEPHIR_INIT_VAR(&_71$$58);
1537 zephir_create_array(&_71$$58, 4, 0);
1538 add_assoc_stringl_ex(&_71$$58, SL("type"), SL("binary-op"));
1539 add_assoc_stringl_ex(&_71$$58, SL("op"), SL("NOT IN"));
1540 zephir_array_update_string(&_71$$58, SL("left"), &left, PH_COPY | PH_SEPARATE);
1541 zephir_array_update_string(&_71$$58, SL("right"), &right, PH_COPY | PH_SEPARATE);
1542 ZEPHIR_CPY_WRT(&exprReturn, &_71$$58);
1543 break;
1544 }
1545 if (ZEPHIR_IS_LONG(&exprType, 408)) {
1546 ZEPHIR_INIT_VAR(&_72$$59);
1547 zephir_create_array(&_72$$59, 3, 0);
1548 add_assoc_stringl_ex(&_72$$59, SL("type"), SL("unary-op"));
1549 add_assoc_stringl_ex(&_72$$59, SL("op"), SL("EXISTS"));
1550 zephir_array_update_string(&_72$$59, SL("right"), &right, PH_COPY | PH_SEPARATE);
1551 ZEPHIR_CPY_WRT(&exprReturn, &_72$$59);
1552 break;
1553 }
1554 if (ZEPHIR_IS_LONG(&exprType, 330)) {
1555 ZEPHIR_INIT_VAR(&_73$$60);
1556 zephir_create_array(&_73$$60, 3, 0);
1557 add_assoc_stringl_ex(&_73$$60, SL("type"), SL("unary-op"));
1558 add_assoc_stringl_ex(&_73$$60, SL("op"), SL("DISTINCT "));
1559 zephir_array_update_string(&_73$$60, SL("right"), &right, PH_COPY | PH_SEPARATE);
1560 ZEPHIR_CPY_WRT(&exprReturn, &_73$$60);
1561 break;
1562 }
1563 if (ZEPHIR_IS_LONG(&exprType, 332)) {
1564 ZEPHIR_INIT_VAR(&_74$$61);
1565 zephir_create_array(&_74$$61, 4, 0);
1566 add_assoc_stringl_ex(&_74$$61, SL("type"), SL("binary-op"));
1567 add_assoc_stringl_ex(&_74$$61, SL("op"), SL("BETWEEN NOT"));
1568 zephir_array_update_string(&_74$$61, SL("left"), &left, PH_COPY | PH_SEPARATE);
1569 zephir_array_update_string(&_74$$61, SL("right"), &right, PH_COPY | PH_SEPARATE);
1570 ZEPHIR_CPY_WRT(&exprReturn, &_74$$61);
1571 break;
1572 }
1573 if (ZEPHIR_IS_LONG(&exprType, 331)) {
1574 ZEPHIR_INIT_VAR(&_75$$62);
1575 zephir_create_array(&_75$$62, 4, 0);
1576 add_assoc_stringl_ex(&_75$$62, SL("type"), SL("binary-op"));
1577 add_assoc_stringl_ex(&_75$$62, SL("op"), SL("BETWEEN"));
1578 zephir_array_update_string(&_75$$62, SL("left"), &left, PH_COPY | PH_SEPARATE);
1579 zephir_array_update_string(&_75$$62, SL("right"), &right, PH_COPY | PH_SEPARATE);
1580 ZEPHIR_CPY_WRT(&exprReturn, &_75$$62);
1581 break;
1582 }
1583 if (ZEPHIR_IS_LONG(&exprType, 276)) {
1584 ZEPHIR_INIT_VAR(&_76$$63);
1585 zephir_create_array(&_76$$63, 4, 0);
1586 add_assoc_stringl_ex(&_76$$63, SL("type"), SL("binary-op"));
1587 add_assoc_stringl_ex(&_76$$63, SL("op"), SL("AGAINST"));
1588 zephir_array_update_string(&_76$$63, SL("left"), &left, PH_COPY | PH_SEPARATE);
1589 zephir_array_update_string(&_76$$63, SL("right"), &right, PH_COPY | PH_SEPARATE);
1590 ZEPHIR_CPY_WRT(&exprReturn, &_76$$63);
1591 break;
1592 }
1593 if (ZEPHIR_IS_LONG(&exprType, 333)) {
1594 ZEPHIR_INIT_VAR(&_77$$64);
1595 zephir_create_array(&_77$$64, 3, 0);
1596 add_assoc_stringl_ex(&_77$$64, SL("type"), SL("cast"));
1597 zephir_array_update_string(&_77$$64, SL("left"), &left, PH_COPY | PH_SEPARATE);
1598 zephir_array_update_string(&_77$$64, SL("right"), &right, PH_COPY | PH_SEPARATE);
1599 ZEPHIR_CPY_WRT(&exprReturn, &_77$$64);
1600 break;
1601 }
1602 if (ZEPHIR_IS_LONG(&exprType, 336)) {
1603 ZEPHIR_INIT_VAR(&_78$$65);
1604 zephir_create_array(&_78$$65, 3, 0);
1605 add_assoc_stringl_ex(&_78$$65, SL("type"), SL("convert"));
1606 zephir_array_update_string(&_78$$65, SL("left"), &left, PH_COPY | PH_SEPARATE);
1607 zephir_array_update_string(&_78$$65, SL("right"), &right, PH_COPY | PH_SEPARATE);
1608 ZEPHIR_CPY_WRT(&exprReturn, &_78$$65);
1609 break;
1610 }
1611 if (ZEPHIR_IS_LONG(&exprType, 358)) {
1612 ZEPHIR_INIT_VAR(&_79$$66);
1613 zephir_create_array(&_79$$66, 2, 0);
1614 add_assoc_stringl_ex(&_79$$66, SL("type"), SL("literal"));
1615 ZEPHIR_OBS_VAR(&_80$$66);
1616 zephir_array_fetch_string(&_80$$66, &expr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1014);
1617 zephir_array_update_string(&_79$$66, SL("value"), &_80$$66, PH_COPY | PH_SEPARATE);
1618 ZEPHIR_CPY_WRT(&exprReturn, &_79$$66);
1619 break;
1620 }
1621 if (ZEPHIR_IS_LONG(&exprType, 350)) {
1622 ZEPHIR_CALL_METHOD(&exprReturn, this_ptr, "_getfunctioncall", NULL, 477, &expr);
1623 zephir_check_call_status();
1624 break;
1625 }
1626 if (ZEPHIR_IS_LONG(&exprType, 409)) {
1627 ZEPHIR_CALL_METHOD(&exprReturn, this_ptr, "_getcaseexpression", NULL, 478, &expr);
1628 zephir_check_call_status();
1629 break;
1630 }
1631 if (ZEPHIR_IS_LONG(&exprType, 309)) {
1632 ZEPHIR_INIT_VAR(&_81$$69);
1633 zephir_create_array(&_81$$69, 2, 0);
1634 add_assoc_stringl_ex(&_81$$69, SL("type"), SL("select"));
1635 ZVAL_BOOL(&_83$$69, 1);
1636 ZEPHIR_CALL_METHOD(&_82$$69, this_ptr, "_prepareselect", NULL, 479, &expr, &_83$$69);
1637 zephir_check_call_status();
1638 zephir_array_update_string(&_81$$69, SL("value"), &_82$$69, PH_COPY | PH_SEPARATE);
1639 ZEPHIR_CPY_WRT(&exprReturn, &_81$$69);
1640 break;
1641 }
1642 ZEPHIR_INIT_VAR(&_84$$70);
1643 object_init_ex(&_84$$70, phalcon_mvc_model_exception_ce);
1644 ZEPHIR_INIT_VAR(&_85$$70);
1645 ZEPHIR_CONCAT_SV(&_85$$70, "Unknown expression type ", &exprType);
1646 ZEPHIR_CALL_METHOD(NULL, &_84$$70, "__construct", NULL, 8, &_85$$70);
1647 zephir_check_call_status();
1648 zephir_throw_exception_debug(&_84$$70, "phalcon/Mvc/Model/Query.zep", 1037);
1649 ZEPHIR_MM_RESTORE();
1650 return;
1651 } while(0);
1652
1653 RETURN_CCTOR(&exprReturn);
1654 }
1655 if (zephir_array_isset_string(&expr, SL("domain"))) {
1656 ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_getqualified", NULL, 476, &expr);
1657 zephir_check_call_status();
1658 RETURN_MM();
1659 }
1660 if (zephir_array_isset_long(&expr, 0)) {
1661 ZEPHIR_INIT_VAR(&listItems);
1662 array_init(&listItems);
1663 zephir_is_iterable(&expr, 0, "phalcon/Mvc/Model/Query.zep", 1060);
1664 if (Z_TYPE_P(&expr) == IS_ARRAY) {
1665 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&expr), _86$$72)
1666 {
1667 ZEPHIR_INIT_NVAR(&exprListItem);
1668 ZVAL_COPY(&exprListItem, _86$$72);
1669 ZEPHIR_CALL_METHOD(&_88$$73, this_ptr, "_getexpression", NULL, 474, &exprListItem);
1670 zephir_check_call_status();
1671 zephir_array_append(&listItems, &_88$$73, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1057);
1672 } ZEND_HASH_FOREACH_END();
1673 } else {
1674 ZEPHIR_CALL_METHOD(NULL, &expr, "rewind", NULL, 0);
1675 zephir_check_call_status();
1676 while (1) {
1677 ZEPHIR_CALL_METHOD(&_87$$72, &expr, "valid", NULL, 0);
1678 zephir_check_call_status();
1679 if (!zend_is_true(&_87$$72)) {
1680 break;
1681 }
1682 ZEPHIR_CALL_METHOD(&exprListItem, &expr, "current", NULL, 0);
1683 zephir_check_call_status();
1684 ZEPHIR_CALL_METHOD(&_89$$74, this_ptr, "_getexpression", NULL, 474, &exprListItem);
1685 zephir_check_call_status();
1686 zephir_array_append(&listItems, &_89$$74, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1057);
1687 ZEPHIR_CALL_METHOD(NULL, &expr, "next", NULL, 0);
1688 zephir_check_call_status();
1689 }
1690 }
1691 ZEPHIR_INIT_NVAR(&exprListItem);
1692 zephir_create_array(return_value, 2, 0);
1693 add_assoc_stringl_ex(return_value, SL("type"), SL("list"));
1694 zephir_array_fast_append(return_value, &listItems);
1695 RETURN_MM();
1696 }
1697 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Unknown expression", "phalcon/Mvc/Model/Query.zep", 1066);
1698 return;
1699
1700 }
1701
1702 /**
1703 * Resolves a column from its intermediate representation into an array
1704 * used to determine if the resultset produced is simple or complex
1705 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getSelectColumn)1706 PHP_METHOD(Phalcon_Mvc_Model_Query, _getSelectColumn) {
1707
1708 zend_string *_4$$4;
1709 zend_ulong _3$$4;
1710 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1711 zephir_fcall_cache_entry *_6 = NULL;
1712 zend_long ZEPHIR_LAST_CALL_STATUS;
1713 zval *column_param = NULL, columnType, sqlAliases, modelName, source, columnDomain, sqlColumnAlias, preparedAlias, sqlExprColumn, sqlAliasesModels, columnData, balias, eager, _19, _20, _0$$4, *_1$$4, _2$$4, _5$$5, _7$$6, _8$$7, _9$$7, _10$$8, _11$$10, _15$$10, _12$$11, _13$$11, _14$$11, _16$$15, _17$$16, _18$$18;
1714 zval column, sqlColumns, sqlColumn;
1715 zval *this_ptr = getThis();
1716
1717 ZVAL_UNDEF(&column);
1718 ZVAL_UNDEF(&sqlColumns);
1719 ZVAL_UNDEF(&sqlColumn);
1720 ZVAL_UNDEF(&columnType);
1721 ZVAL_UNDEF(&sqlAliases);
1722 ZVAL_UNDEF(&modelName);
1723 ZVAL_UNDEF(&source);
1724 ZVAL_UNDEF(&columnDomain);
1725 ZVAL_UNDEF(&sqlColumnAlias);
1726 ZVAL_UNDEF(&preparedAlias);
1727 ZVAL_UNDEF(&sqlExprColumn);
1728 ZVAL_UNDEF(&sqlAliasesModels);
1729 ZVAL_UNDEF(&columnData);
1730 ZVAL_UNDEF(&balias);
1731 ZVAL_UNDEF(&eager);
1732 ZVAL_UNDEF(&_19);
1733 ZVAL_UNDEF(&_20);
1734 ZVAL_UNDEF(&_0$$4);
1735 ZVAL_UNDEF(&_2$$4);
1736 ZVAL_UNDEF(&_5$$5);
1737 ZVAL_UNDEF(&_7$$6);
1738 ZVAL_UNDEF(&_8$$7);
1739 ZVAL_UNDEF(&_9$$7);
1740 ZVAL_UNDEF(&_10$$8);
1741 ZVAL_UNDEF(&_11$$10);
1742 ZVAL_UNDEF(&_15$$10);
1743 ZVAL_UNDEF(&_12$$11);
1744 ZVAL_UNDEF(&_13$$11);
1745 ZVAL_UNDEF(&_14$$11);
1746 ZVAL_UNDEF(&_16$$15);
1747 ZVAL_UNDEF(&_17$$16);
1748 ZVAL_UNDEF(&_18$$18);
1749
1750 ZEPHIR_MM_GROW();
1751 zephir_fetch_params(1, 1, 0, &column_param);
1752
1753 ZEPHIR_OBS_COPY_OR_DUP(&column, column_param);
1754
1755
1756 ZEPHIR_OBS_VAR(&columnType);
1757 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&columnType, &column, SL("type"), 0)))) {
1758 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST", "phalcon/Mvc/Model/Query.zep", 1081);
1759 return;
1760 }
1761 ZEPHIR_INIT_VAR(&sqlColumns);
1762 array_init(&sqlColumns);
1763 ZEPHIR_OBS_VAR(&eager);
1764 zephir_array_isset_string_fetch(&eager, &column, SL("eager"), 0);
1765 if (ZEPHIR_IS_LONG(&columnType, 352)) {
1766 zephir_read_property(&_0$$4, this_ptr, ZEND_STRL("models"), PH_NOISY_CC | PH_READONLY);
1767 zephir_is_iterable(&_0$$4, 0, "phalcon/Mvc/Model/Query.zep", 1111);
1768 if (Z_TYPE_P(&_0$$4) == IS_ARRAY) {
1769 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&_0$$4), _3$$4, _4$$4, _1$$4)
1770 {
1771 ZEPHIR_INIT_NVAR(&modelName);
1772 if (_4$$4 != NULL) {
1773 ZVAL_STR_COPY(&modelName, _4$$4);
1774 } else {
1775 ZVAL_LONG(&modelName, _3$$4);
1776 }
1777 ZEPHIR_INIT_NVAR(&source);
1778 ZVAL_COPY(&source, _1$$4);
1779 ZEPHIR_INIT_NVAR(&sqlColumn);
1780 zephir_create_array(&sqlColumn, 4, 0);
1781 add_assoc_stringl_ex(&sqlColumn, SL("type"), SL("object"));
1782 zephir_array_update_string(&sqlColumn, SL("model"), &modelName, PH_COPY | PH_SEPARATE);
1783 zephir_array_update_string(&sqlColumn, SL("column"), &source, PH_COPY | PH_SEPARATE);
1784 ZEPHIR_CALL_FUNCTION(&_5$$5, "lcfirst", &_6, 94, &modelName);
1785 zephir_check_call_status();
1786 zephir_array_update_string(&sqlColumn, SL("balias"), &_5$$5, PH_COPY | PH_SEPARATE);
1787 if (Z_TYPE_P(&eager) != IS_NULL) {
1788 zephir_array_update_string(&sqlColumn, SL("eager"), &eager, PH_COPY | PH_SEPARATE);
1789 zephir_array_fetch_string(&_7$$6, &column, SL("eagerType"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1105);
1790 zephir_array_update_string(&sqlColumn, SL("eagerType"), &_7$$6, PH_COPY | PH_SEPARATE);
1791 }
1792 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1108);
1793 } ZEND_HASH_FOREACH_END();
1794 } else {
1795 ZEPHIR_CALL_METHOD(NULL, &_0$$4, "rewind", NULL, 0);
1796 zephir_check_call_status();
1797 while (1) {
1798 ZEPHIR_CALL_METHOD(&_2$$4, &_0$$4, "valid", NULL, 0);
1799 zephir_check_call_status();
1800 if (!zend_is_true(&_2$$4)) {
1801 break;
1802 }
1803 ZEPHIR_CALL_METHOD(&modelName, &_0$$4, "key", NULL, 0);
1804 zephir_check_call_status();
1805 ZEPHIR_CALL_METHOD(&source, &_0$$4, "current", NULL, 0);
1806 zephir_check_call_status();
1807 ZEPHIR_INIT_NVAR(&_8$$7);
1808 zephir_create_array(&_8$$7, 4, 0);
1809 add_assoc_stringl_ex(&_8$$7, SL("type"), SL("object"));
1810 zephir_array_update_string(&_8$$7, SL("model"), &modelName, PH_COPY | PH_SEPARATE);
1811 zephir_array_update_string(&_8$$7, SL("column"), &source, PH_COPY | PH_SEPARATE);
1812 ZEPHIR_CALL_FUNCTION(&_9$$7, "lcfirst", &_6, 94, &modelName);
1813 zephir_check_call_status();
1814 zephir_array_update_string(&_8$$7, SL("balias"), &_9$$7, PH_COPY | PH_SEPARATE);
1815 ZEPHIR_CPY_WRT(&sqlColumn, &_8$$7);
1816 if (Z_TYPE_P(&eager) != IS_NULL) {
1817 zephir_array_update_string(&sqlColumn, SL("eager"), &eager, PH_COPY | PH_SEPARATE);
1818 zephir_array_fetch_string(&_10$$8, &column, SL("eagerType"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1105);
1819 zephir_array_update_string(&sqlColumn, SL("eagerType"), &_10$$8, PH_COPY | PH_SEPARATE);
1820 }
1821 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1108);
1822 ZEPHIR_CALL_METHOD(NULL, &_0$$4, "next", NULL, 0);
1823 zephir_check_call_status();
1824 }
1825 }
1826 ZEPHIR_INIT_NVAR(&source);
1827 ZEPHIR_INIT_NVAR(&modelName);
1828 RETURN_CTOR(&sqlColumns);
1829 }
1830 if (UNEXPECTED(!(zephir_array_isset_string(&column, SL("column"))))) {
1831 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST", "phalcon/Mvc/Model/Query.zep", 1115);
1832 return;
1833 }
1834 if (ZEPHIR_IS_LONG(&columnType, 353)) {
1835 zephir_read_property(&_11$$10, this_ptr, ZEND_STRL("sqlAliases"), PH_NOISY_CC | PH_READONLY);
1836 ZEPHIR_CPY_WRT(&sqlAliases, &_11$$10);
1837 ZEPHIR_OBS_VAR(&columnDomain);
1838 zephir_array_fetch_string(&columnDomain, &column, SL("column"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1127);
1839 ZEPHIR_OBS_NVAR(&source);
1840 if (UNEXPECTED(!(zephir_array_isset_fetch(&source, &sqlAliases, &columnDomain, 0)))) {
1841 ZEPHIR_INIT_VAR(&_12$$11);
1842 object_init_ex(&_12$$11, phalcon_mvc_model_exception_ce);
1843 zephir_read_property(&_13$$11, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
1844 ZEPHIR_INIT_VAR(&_14$$11);
1845 ZEPHIR_CONCAT_SVSV(&_14$$11, "Unknown model or alias '", &columnDomain, "' (2), when preparing: ", &_13$$11);
1846 ZEPHIR_CALL_METHOD(NULL, &_12$$11, "__construct", NULL, 8, &_14$$11);
1847 zephir_check_call_status();
1848 zephir_throw_exception_debug(&_12$$11, "phalcon/Mvc/Model/Query.zep", 1132);
1849 ZEPHIR_MM_RESTORE();
1850 return;
1851 }
1852 ZEPHIR_CPY_WRT(&sqlColumnAlias, &source);
1853 ZEPHIR_OBS_VAR(&preparedAlias);
1854 zephir_array_isset_string_fetch(&preparedAlias, &column, SL("balias"), 0);
1855 zephir_read_property(&_11$$10, this_ptr, ZEND_STRL("sqlAliasesModels"), PH_NOISY_CC | PH_READONLY);
1856 ZEPHIR_CPY_WRT(&sqlAliasesModels, &_11$$10);
1857 ZEPHIR_OBS_NVAR(&modelName);
1858 zephir_array_fetch(&modelName, &sqlAliasesModels, &columnDomain, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1146);
1859 if (Z_TYPE_P(&preparedAlias) != IS_STRING) {
1860 if (ZEPHIR_IS_EQUAL(&columnDomain, &modelName)) {
1861 ZEPHIR_CALL_FUNCTION(&preparedAlias, "lcfirst", &_6, 94, &modelName);
1862 zephir_check_call_status();
1863 } else {
1864 ZEPHIR_CPY_WRT(&preparedAlias, &columnDomain);
1865 }
1866 }
1867 ZEPHIR_INIT_VAR(&_15$$10);
1868 zephir_create_array(&_15$$10, 4, 0);
1869 add_assoc_stringl_ex(&_15$$10, SL("type"), SL("object"));
1870 zephir_array_update_string(&_15$$10, SL("model"), &modelName, PH_COPY | PH_SEPARATE);
1871 zephir_array_update_string(&_15$$10, SL("column"), &sqlColumnAlias, PH_COPY | PH_SEPARATE);
1872 zephir_array_update_string(&_15$$10, SL("balias"), &preparedAlias, PH_COPY | PH_SEPARATE);
1873 ZEPHIR_CPY_WRT(&sqlColumn, &_15$$10);
1874 if (Z_TYPE_P(&eager) != IS_NULL) {
1875 zephir_array_update_string(&sqlColumn, SL("eager"), &eager, PH_COPY | PH_SEPARATE);
1876 zephir_array_fetch_string(&_16$$15, &column, SL("eagerType"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1173);
1877 zephir_array_update_string(&sqlColumn, SL("eagerType"), &_16$$15, PH_COPY | PH_SEPARATE);
1878 }
1879 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1176);
1880 RETURN_CTOR(&sqlColumns);
1881 }
1882 if (ZEPHIR_IS_LONG(&columnType, 354)) {
1883 ZEPHIR_INIT_VAR(&_17$$16);
1884 zephir_create_array(&_17$$16, 1, 0);
1885 add_assoc_stringl_ex(&_17$$16, SL("type"), SL("scalar"));
1886 ZEPHIR_CPY_WRT(&sqlColumn, &_17$$16);
1887 ZEPHIR_OBS_VAR(&columnData);
1888 zephir_array_fetch_string(&columnData, &column, SL("column"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1190);
1889 ZEPHIR_CALL_METHOD(&sqlExprColumn, this_ptr, "_getexpression", NULL, 474, &columnData);
1890 zephir_check_call_status();
1891 ZEPHIR_OBS_VAR(&balias);
1892 if (zephir_array_isset_string_fetch(&balias, &sqlExprColumn, SL("balias"), 0)) {
1893 zephir_array_update_string(&sqlColumn, SL("balias"), &balias, PH_COPY | PH_SEPARATE);
1894 zephir_array_update_string(&sqlColumn, SL("sqlAlias"), &balias, PH_COPY | PH_SEPARATE);
1895 }
1896 if (Z_TYPE_P(&eager) != IS_NULL) {
1897 zephir_array_update_string(&sqlColumn, SL("eager"), &eager, PH_COPY | PH_SEPARATE);
1898 zephir_array_fetch_string(&_18$$18, &column, SL("eagerType"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1203);
1899 zephir_array_update_string(&sqlColumn, SL("eagerType"), &_18$$18, PH_COPY | PH_SEPARATE);
1900 }
1901 zephir_array_update_string(&sqlColumn, SL("column"), &sqlExprColumn, PH_COPY | PH_SEPARATE);
1902 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1207);
1903 RETURN_CTOR(&sqlColumns);
1904 }
1905 ZEPHIR_INIT_VAR(&_19);
1906 object_init_ex(&_19, phalcon_mvc_model_exception_ce);
1907 ZEPHIR_INIT_VAR(&_20);
1908 ZEPHIR_CONCAT_SV(&_20, "Unknown type of column ", &columnType);
1909 ZEPHIR_CALL_METHOD(NULL, &_19, "__construct", NULL, 8, &_20);
1910 zephir_check_call_status();
1911 zephir_throw_exception_debug(&_19, "phalcon/Mvc/Model/Query.zep", 1212);
1912 ZEPHIR_MM_RESTORE();
1913 return;
1914
1915 }
1916
1917 /**
1918 * Resolves a table in a SELECT statement checking if the model exists
1919 *
1920 * @return string
1921 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getTable)1922 PHP_METHOD(Phalcon_Mvc_Model_Query, _getTable) {
1923
1924 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1925 zend_long ZEPHIR_LAST_CALL_STATUS;
1926 zval qualifiedName;
1927 zval *manager, manager_sub, *qualifiedName_param = NULL, modelName, model, source, schema;
1928 zval *this_ptr = getThis();
1929
1930 ZVAL_UNDEF(&manager_sub);
1931 ZVAL_UNDEF(&modelName);
1932 ZVAL_UNDEF(&model);
1933 ZVAL_UNDEF(&source);
1934 ZVAL_UNDEF(&schema);
1935 ZVAL_UNDEF(&qualifiedName);
1936
1937 ZEPHIR_MM_GROW();
1938 zephir_fetch_params(1, 2, 0, &manager, &qualifiedName_param);
1939
1940 zephir_get_arrval(&qualifiedName, qualifiedName_param);
1941
1942
1943 ZEPHIR_OBS_VAR(&modelName);
1944 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&modelName, &qualifiedName, SL("name"), 0)))) {
1945 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST", "phalcon/Mvc/Model/Query.zep", 1225);
1946 return;
1947 }
1948 ZEPHIR_CALL_METHOD(&model, manager, "load", NULL, 0, &modelName);
1949 zephir_check_call_status();
1950 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
1951 zephir_check_call_status();
1952 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
1953 zephir_check_call_status();
1954 if (zephir_is_true(&schema)) {
1955 zephir_create_array(return_value, 2, 0);
1956 zephir_array_fast_append(return_value, &schema);
1957 zephir_array_fast_append(return_value, &source);
1958 RETURN_MM();
1959 }
1960 RETURN_CCTOR(&source);
1961
1962 }
1963
1964 /**
1965 * Resolves a JOIN clause checking if the associated models exist
1966 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getJoin)1967 PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoin) {
1968
1969 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
1970 zend_long ZEPHIR_LAST_CALL_STATUS;
1971 zval join;
1972 zval *manager, manager_sub, *join_param = NULL, qualified, modelName, source, model, schema, _0$$3;
1973 zval *this_ptr = getThis();
1974
1975 ZVAL_UNDEF(&manager_sub);
1976 ZVAL_UNDEF(&qualified);
1977 ZVAL_UNDEF(&modelName);
1978 ZVAL_UNDEF(&source);
1979 ZVAL_UNDEF(&model);
1980 ZVAL_UNDEF(&schema);
1981 ZVAL_UNDEF(&_0$$3);
1982 ZVAL_UNDEF(&join);
1983
1984 ZEPHIR_MM_GROW();
1985 zephir_fetch_params(1, 2, 0, &manager, &join_param);
1986
1987 zephir_get_arrval(&join, join_param);
1988
1989
1990 ZEPHIR_OBS_VAR(&qualified);
1991 if (zephir_array_isset_string_fetch(&qualified, &join, SL("qualified"), 0)) {
1992 zephir_array_fetch_string(&_0$$3, &qualified, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1247);
1993 if (ZEPHIR_IS_LONG(&_0$$3, 355)) {
1994 ZEPHIR_OBS_VAR(&modelName);
1995 zephir_array_fetch_string(&modelName, &qualified, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1248);
1996 ZEPHIR_CALL_METHOD(&model, manager, "load", NULL, 0, &modelName);
1997 zephir_check_call_status();
1998 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
1999 zephir_check_call_status();
2000 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
2001 zephir_check_call_status();
2002 zephir_create_array(return_value, 4, 0);
2003 zephir_array_update_string(return_value, SL("schema"), &schema, PH_COPY | PH_SEPARATE);
2004 zephir_array_update_string(return_value, SL("source"), &source, PH_COPY | PH_SEPARATE);
2005 zephir_array_update_string(return_value, SL("modelName"), &modelName, PH_COPY | PH_SEPARATE);
2006 zephir_array_update_string(return_value, SL("model"), &model, PH_COPY | PH_SEPARATE);
2007 RETURN_MM();
2008 }
2009 }
2010 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST", "phalcon/Mvc/Model/Query.zep", 1263);
2011 return;
2012
2013 }
2014
2015 /**
2016 * Resolves a JOIN type
2017 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getJoinType)2018 PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoinType) {
2019
2020 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2021 zend_long ZEPHIR_LAST_CALL_STATUS;
2022 zval *join_param = NULL, type, _0, _1, _2;
2023 zval join;
2024 zval *this_ptr = getThis();
2025
2026 ZVAL_UNDEF(&join);
2027 ZVAL_UNDEF(&type);
2028 ZVAL_UNDEF(&_0);
2029 ZVAL_UNDEF(&_1);
2030 ZVAL_UNDEF(&_2);
2031
2032 ZEPHIR_MM_GROW();
2033 zephir_fetch_params(1, 1, 0, &join_param);
2034
2035 zephir_get_arrval(&join, join_param);
2036
2037
2038 ZEPHIR_OBS_VAR(&type);
2039 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&type, &join, SL("type"), 0)))) {
2040 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST", "phalcon/Mvc/Model/Query.zep", 1274);
2041 return;
2042 }
2043 do {
2044 if (ZEPHIR_IS_LONG(&type, 360)) {
2045 RETURN_MM_STRING("INNER");
2046 }
2047 if (ZEPHIR_IS_LONG(&type, 361)) {
2048 RETURN_MM_STRING("LEFT");
2049 }
2050 if (ZEPHIR_IS_LONG(&type, 362)) {
2051 RETURN_MM_STRING("RIGHT");
2052 }
2053 if (ZEPHIR_IS_LONG(&type, 363)) {
2054 RETURN_MM_STRING("CROSS");
2055 }
2056 if (ZEPHIR_IS_LONG(&type, 364)) {
2057 RETURN_MM_STRING("FULL OUTER");
2058 }
2059 } while(0);
2060
2061 ZEPHIR_INIT_VAR(&_0);
2062 object_init_ex(&_0, phalcon_mvc_model_exception_ce);
2063 zephir_read_property(&_1, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2064 ZEPHIR_INIT_VAR(&_2);
2065 ZEPHIR_CONCAT_SVSV(&_2, "Unknown join type ", &type, ", when preparing: ", &_1);
2066 ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 8, &_2);
2067 zephir_check_call_status();
2068 zephir_throw_exception_debug(&_0, "phalcon/Mvc/Model/Query.zep", 1296);
2069 ZEPHIR_MM_RESTORE();
2070 return;
2071
2072 }
2073
2074 /**
2075 * Resolves joins involving has-one/belongs-to/has-many relations
2076 *
2077 * @param string joinSource
2078 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getSingleJoin)2079 PHP_METHOD(Phalcon_Mvc_Model_Query, _getSingleJoin) {
2080
2081 zend_string *_8$$4;
2082 zend_ulong _7$$4;
2083 zval _1$$3, _3$$3, _4$$3, _13$$5, _15$$5, _16$$5, _20$$7, _22$$7, _23$$7;
2084 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2085 zephir_fcall_cache_entry *_12 = NULL;
2086 zend_long ZEPHIR_LAST_CALL_STATUS;
2087 zval *joinType_param = NULL, *joinSource, joinSource_sub, *modelAlias_param = NULL, *joinAlias_param = NULL, *relation, relation_sub, fields, referencedFields, sqlJoinConditions, sqlJoinPartialConditions, position, field, referencedField, _0$$3, _2$$3, *_5$$4, _6$$4, _9$$6, _10$$6, _11$$6, _14$$5, _17$$8, _18$$8, _19$$8, _21$$7;
2088 zval joinType, modelAlias, joinAlias;
2089 zval *this_ptr = getThis();
2090
2091 ZVAL_UNDEF(&joinType);
2092 ZVAL_UNDEF(&modelAlias);
2093 ZVAL_UNDEF(&joinAlias);
2094 ZVAL_UNDEF(&joinSource_sub);
2095 ZVAL_UNDEF(&relation_sub);
2096 ZVAL_UNDEF(&fields);
2097 ZVAL_UNDEF(&referencedFields);
2098 ZVAL_UNDEF(&sqlJoinConditions);
2099 ZVAL_UNDEF(&sqlJoinPartialConditions);
2100 ZVAL_UNDEF(&position);
2101 ZVAL_UNDEF(&field);
2102 ZVAL_UNDEF(&referencedField);
2103 ZVAL_UNDEF(&_0$$3);
2104 ZVAL_UNDEF(&_2$$3);
2105 ZVAL_UNDEF(&_6$$4);
2106 ZVAL_UNDEF(&_9$$6);
2107 ZVAL_UNDEF(&_10$$6);
2108 ZVAL_UNDEF(&_11$$6);
2109 ZVAL_UNDEF(&_14$$5);
2110 ZVAL_UNDEF(&_17$$8);
2111 ZVAL_UNDEF(&_18$$8);
2112 ZVAL_UNDEF(&_19$$8);
2113 ZVAL_UNDEF(&_21$$7);
2114 ZVAL_UNDEF(&_1$$3);
2115 ZVAL_UNDEF(&_3$$3);
2116 ZVAL_UNDEF(&_4$$3);
2117 ZVAL_UNDEF(&_13$$5);
2118 ZVAL_UNDEF(&_15$$5);
2119 ZVAL_UNDEF(&_16$$5);
2120 ZVAL_UNDEF(&_20$$7);
2121 ZVAL_UNDEF(&_22$$7);
2122 ZVAL_UNDEF(&_23$$7);
2123
2124 ZEPHIR_MM_GROW();
2125 zephir_fetch_params(1, 5, 0, &joinType_param, &joinSource, &modelAlias_param, &joinAlias_param, &relation);
2126
2127 if (UNEXPECTED(Z_TYPE_P(joinType_param) != IS_STRING && Z_TYPE_P(joinType_param) != IS_NULL)) {
2128 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'joinType' must be of the type string"));
2129 RETURN_MM_NULL();
2130 }
2131 if (EXPECTED(Z_TYPE_P(joinType_param) == IS_STRING)) {
2132 zephir_get_strval(&joinType, joinType_param);
2133 } else {
2134 ZEPHIR_INIT_VAR(&joinType);
2135 ZVAL_EMPTY_STRING(&joinType);
2136 }
2137 zephir_get_strval(&modelAlias, modelAlias_param);
2138 zephir_get_strval(&joinAlias, joinAlias_param);
2139
2140
2141 ZEPHIR_INIT_VAR(&sqlJoinConditions);
2142 ZVAL_NULL(&sqlJoinConditions);
2143 ZEPHIR_CALL_METHOD(&fields, relation, "getfields", NULL, 0);
2144 zephir_check_call_status();
2145 ZEPHIR_CALL_METHOD(&referencedFields, relation, "getreferencedfields", NULL, 0);
2146 zephir_check_call_status();
2147 if (Z_TYPE_P(&fields) != IS_ARRAY) {
2148 ZEPHIR_INIT_VAR(&_0$$3);
2149 zephir_create_array(&_0$$3, 1, 0);
2150 ZEPHIR_INIT_VAR(&_1$$3);
2151 zephir_create_array(&_1$$3, 4, 0);
2152 add_assoc_stringl_ex(&_1$$3, SL("type"), SL("binary-op"));
2153 add_assoc_stringl_ex(&_1$$3, SL("op"), SL("="));
2154 ZEPHIR_INIT_VAR(&_3$$3);
2155 zephir_create_array(&_3$$3, 3, 0);
2156 add_assoc_long_ex(&_3$$3, SL("type"), 355);
2157 zephir_array_update_string(&_3$$3, SL("domain"), &modelAlias, PH_COPY | PH_SEPARATE);
2158 zephir_array_update_string(&_3$$3, SL("name"), &fields, PH_COPY | PH_SEPARATE);
2159 ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "_getqualified", NULL, 476, &_3$$3);
2160 zephir_check_call_status();
2161 zephir_array_update_string(&_1$$3, SL("left"), &_2$$3, PH_COPY | PH_SEPARATE);
2162 ZEPHIR_INIT_VAR(&_4$$3);
2163 zephir_create_array(&_4$$3, 3, 0);
2164 add_assoc_stringl_ex(&_4$$3, SL("type"), SL("qualified"));
2165 zephir_array_update_string(&_4$$3, SL("domain"), &joinAlias, PH_COPY | PH_SEPARATE);
2166 zephir_array_update_string(&_4$$3, SL("name"), &referencedFields, PH_COPY | PH_SEPARATE);
2167 ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "_getqualified", NULL, 476, &_4$$3);
2168 zephir_check_call_status();
2169 zephir_array_update_string(&_1$$3, SL("right"), &_2$$3, PH_COPY | PH_SEPARATE);
2170 zephir_array_fast_append(&_0$$3, &_1$$3);
2171 ZEPHIR_CPY_WRT(&sqlJoinConditions, &_0$$3);
2172 } else {
2173 ZEPHIR_INIT_VAR(&sqlJoinPartialConditions);
2174 array_init(&sqlJoinPartialConditions);
2175 zephir_is_iterable(&fields, 0, "phalcon/Mvc/Model/Query.zep", 1386);
2176 if (Z_TYPE_P(&fields) == IS_ARRAY) {
2177 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&fields), _7$$4, _8$$4, _5$$4)
2178 {
2179 ZEPHIR_INIT_NVAR(&position);
2180 if (_8$$4 != NULL) {
2181 ZVAL_STR_COPY(&position, _8$$4);
2182 } else {
2183 ZVAL_LONG(&position, _7$$4);
2184 }
2185 ZEPHIR_INIT_NVAR(&field);
2186 ZVAL_COPY(&field, _5$$4);
2187 ZEPHIR_OBS_NVAR(&referencedField);
2188 if (UNEXPECTED(!(zephir_array_isset_fetch(&referencedField, &referencedFields, &position, 0)))) {
2189 ZEPHIR_INIT_NVAR(&_9$$6);
2190 object_init_ex(&_9$$6, phalcon_mvc_model_exception_ce);
2191 zephir_read_property(&_10$$6, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2192 ZEPHIR_INIT_NVAR(&_11$$6);
2193 ZEPHIR_CONCAT_SVSVSV(&_11$$6, "The number of fields must be equal to the number of referenced fields in join ", &modelAlias, "-", &joinAlias, ", when preparing: ", &_10$$6);
2194 ZEPHIR_CALL_METHOD(NULL, &_9$$6, "__construct", &_12, 8, &_11$$6);
2195 zephir_check_call_status();
2196 zephir_throw_exception_debug(&_9$$6, "phalcon/Mvc/Model/Query.zep", 1358);
2197 ZEPHIR_MM_RESTORE();
2198 return;
2199 }
2200 ZEPHIR_INIT_NVAR(&_13$$5);
2201 zephir_create_array(&_13$$5, 4, 0);
2202 add_assoc_stringl_ex(&_13$$5, SL("type"), SL("binary-op"));
2203 add_assoc_stringl_ex(&_13$$5, SL("op"), SL("="));
2204 ZEPHIR_INIT_NVAR(&_15$$5);
2205 zephir_create_array(&_15$$5, 3, 0);
2206 add_assoc_long_ex(&_15$$5, SL("type"), 355);
2207 zephir_array_update_string(&_15$$5, SL("domain"), &modelAlias, PH_COPY | PH_SEPARATE);
2208 zephir_array_update_string(&_15$$5, SL("name"), &field, PH_COPY | PH_SEPARATE);
2209 ZEPHIR_CALL_METHOD(&_14$$5, this_ptr, "_getqualified", NULL, 476, &_15$$5);
2210 zephir_check_call_status();
2211 zephir_array_update_string(&_13$$5, SL("left"), &_14$$5, PH_COPY | PH_SEPARATE);
2212 ZEPHIR_INIT_NVAR(&_16$$5);
2213 zephir_create_array(&_16$$5, 3, 0);
2214 add_assoc_stringl_ex(&_16$$5, SL("type"), SL("qualified"));
2215 zephir_array_update_string(&_16$$5, SL("domain"), &joinAlias, PH_COPY | PH_SEPARATE);
2216 zephir_array_update_string(&_16$$5, SL("name"), &referencedField, PH_COPY | PH_SEPARATE);
2217 ZEPHIR_CALL_METHOD(&_14$$5, this_ptr, "_getqualified", NULL, 476, &_16$$5);
2218 zephir_check_call_status();
2219 zephir_array_update_string(&_13$$5, SL("right"), &_14$$5, PH_COPY | PH_SEPARATE);
2220 zephir_array_append(&sqlJoinPartialConditions, &_13$$5, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1383);
2221 } ZEND_HASH_FOREACH_END();
2222 } else {
2223 ZEPHIR_CALL_METHOD(NULL, &fields, "rewind", NULL, 0);
2224 zephir_check_call_status();
2225 while (1) {
2226 ZEPHIR_CALL_METHOD(&_6$$4, &fields, "valid", NULL, 0);
2227 zephir_check_call_status();
2228 if (!zend_is_true(&_6$$4)) {
2229 break;
2230 }
2231 ZEPHIR_CALL_METHOD(&position, &fields, "key", NULL, 0);
2232 zephir_check_call_status();
2233 ZEPHIR_CALL_METHOD(&field, &fields, "current", NULL, 0);
2234 zephir_check_call_status();
2235 ZEPHIR_OBS_NVAR(&referencedField);
2236 if (UNEXPECTED(!(zephir_array_isset_fetch(&referencedField, &referencedFields, &position, 0)))) {
2237 ZEPHIR_INIT_NVAR(&_17$$8);
2238 object_init_ex(&_17$$8, phalcon_mvc_model_exception_ce);
2239 zephir_read_property(&_18$$8, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2240 ZEPHIR_INIT_NVAR(&_19$$8);
2241 ZEPHIR_CONCAT_SVSVSV(&_19$$8, "The number of fields must be equal to the number of referenced fields in join ", &modelAlias, "-", &joinAlias, ", when preparing: ", &_18$$8);
2242 ZEPHIR_CALL_METHOD(NULL, &_17$$8, "__construct", &_12, 8, &_19$$8);
2243 zephir_check_call_status();
2244 zephir_throw_exception_debug(&_17$$8, "phalcon/Mvc/Model/Query.zep", 1358);
2245 ZEPHIR_MM_RESTORE();
2246 return;
2247 }
2248 ZEPHIR_INIT_NVAR(&_20$$7);
2249 zephir_create_array(&_20$$7, 4, 0);
2250 add_assoc_stringl_ex(&_20$$7, SL("type"), SL("binary-op"));
2251 add_assoc_stringl_ex(&_20$$7, SL("op"), SL("="));
2252 ZEPHIR_INIT_NVAR(&_22$$7);
2253 zephir_create_array(&_22$$7, 3, 0);
2254 add_assoc_long_ex(&_22$$7, SL("type"), 355);
2255 zephir_array_update_string(&_22$$7, SL("domain"), &modelAlias, PH_COPY | PH_SEPARATE);
2256 zephir_array_update_string(&_22$$7, SL("name"), &field, PH_COPY | PH_SEPARATE);
2257 ZEPHIR_CALL_METHOD(&_21$$7, this_ptr, "_getqualified", NULL, 476, &_22$$7);
2258 zephir_check_call_status();
2259 zephir_array_update_string(&_20$$7, SL("left"), &_21$$7, PH_COPY | PH_SEPARATE);
2260 ZEPHIR_INIT_NVAR(&_23$$7);
2261 zephir_create_array(&_23$$7, 3, 0);
2262 add_assoc_stringl_ex(&_23$$7, SL("type"), SL("qualified"));
2263 zephir_array_update_string(&_23$$7, SL("domain"), &joinAlias, PH_COPY | PH_SEPARATE);
2264 zephir_array_update_string(&_23$$7, SL("name"), &referencedField, PH_COPY | PH_SEPARATE);
2265 ZEPHIR_CALL_METHOD(&_21$$7, this_ptr, "_getqualified", NULL, 476, &_23$$7);
2266 zephir_check_call_status();
2267 zephir_array_update_string(&_20$$7, SL("right"), &_21$$7, PH_COPY | PH_SEPARATE);
2268 zephir_array_append(&sqlJoinPartialConditions, &_20$$7, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1383);
2269 ZEPHIR_CALL_METHOD(NULL, &fields, "next", NULL, 0);
2270 zephir_check_call_status();
2271 }
2272 }
2273 ZEPHIR_INIT_NVAR(&field);
2274 ZEPHIR_INIT_NVAR(&position);
2275 }
2276 zephir_create_array(return_value, 3, 0);
2277 zephir_array_update_string(return_value, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
2278 zephir_array_update_string(return_value, SL("source"), joinSource, PH_COPY | PH_SEPARATE);
2279 zephir_array_update_string(return_value, SL("conditions"), &sqlJoinConditions, PH_COPY | PH_SEPARATE);
2280 RETURN_MM();
2281
2282 }
2283
2284 /**
2285 * Resolves joins involving many-to-many relations
2286 *
2287 * @param string joinSource
2288 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getMultiJoin)2289 PHP_METHOD(Phalcon_Mvc_Model_Query, _getMultiJoin) {
2290
2291 zend_string *_4$$3;
2292 zend_ulong _3$$3;
2293 zval sqlJoins, _10$$4, _12$$4, _18$$6, _19$$6, _21$$8, _22$$8, _23$$8, _25$$8, _26$$8, _27$$8, _28$$8;
2294 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2295 zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL;
2296 zend_long ZEPHIR_LAST_CALL_STATUS;
2297 zval *joinType_param = NULL, *joinSource, joinSource_sub, *modelAlias_param = NULL, *joinAlias_param = NULL, *relation, relation_sub, fields, referencedFields, intermediateModelName, intermediateModel, intermediateSource, intermediateSchema, intermediateFields, intermediateReferencedFields, referencedModelName, manager, field, position, intermediateField, sqlEqualsJoinCondition, _0, *_1$$3, _2$$3, _5$$5, _6$$5, _7$$5, _9$$4, _13$$7, _14$$7, _15$$7, _16$$6, _17$$6, _20$$8, _24$$8;
2298 zval joinType, modelAlias, joinAlias;
2299 zval *this_ptr = getThis();
2300
2301 ZVAL_UNDEF(&joinType);
2302 ZVAL_UNDEF(&modelAlias);
2303 ZVAL_UNDEF(&joinAlias);
2304 ZVAL_UNDEF(&joinSource_sub);
2305 ZVAL_UNDEF(&relation_sub);
2306 ZVAL_UNDEF(&fields);
2307 ZVAL_UNDEF(&referencedFields);
2308 ZVAL_UNDEF(&intermediateModelName);
2309 ZVAL_UNDEF(&intermediateModel);
2310 ZVAL_UNDEF(&intermediateSource);
2311 ZVAL_UNDEF(&intermediateSchema);
2312 ZVAL_UNDEF(&intermediateFields);
2313 ZVAL_UNDEF(&intermediateReferencedFields);
2314 ZVAL_UNDEF(&referencedModelName);
2315 ZVAL_UNDEF(&manager);
2316 ZVAL_UNDEF(&field);
2317 ZVAL_UNDEF(&position);
2318 ZVAL_UNDEF(&intermediateField);
2319 ZVAL_UNDEF(&sqlEqualsJoinCondition);
2320 ZVAL_UNDEF(&_0);
2321 ZVAL_UNDEF(&_2$$3);
2322 ZVAL_UNDEF(&_5$$5);
2323 ZVAL_UNDEF(&_6$$5);
2324 ZVAL_UNDEF(&_7$$5);
2325 ZVAL_UNDEF(&_9$$4);
2326 ZVAL_UNDEF(&_13$$7);
2327 ZVAL_UNDEF(&_14$$7);
2328 ZVAL_UNDEF(&_15$$7);
2329 ZVAL_UNDEF(&_16$$6);
2330 ZVAL_UNDEF(&_17$$6);
2331 ZVAL_UNDEF(&_20$$8);
2332 ZVAL_UNDEF(&_24$$8);
2333 ZVAL_UNDEF(&sqlJoins);
2334 ZVAL_UNDEF(&_10$$4);
2335 ZVAL_UNDEF(&_12$$4);
2336 ZVAL_UNDEF(&_18$$6);
2337 ZVAL_UNDEF(&_19$$6);
2338 ZVAL_UNDEF(&_21$$8);
2339 ZVAL_UNDEF(&_22$$8);
2340 ZVAL_UNDEF(&_23$$8);
2341 ZVAL_UNDEF(&_25$$8);
2342 ZVAL_UNDEF(&_26$$8);
2343 ZVAL_UNDEF(&_27$$8);
2344 ZVAL_UNDEF(&_28$$8);
2345
2346 ZEPHIR_MM_GROW();
2347 zephir_fetch_params(1, 5, 0, &joinType_param, &joinSource, &modelAlias_param, &joinAlias_param, &relation);
2348
2349 if (UNEXPECTED(Z_TYPE_P(joinType_param) != IS_STRING && Z_TYPE_P(joinType_param) != IS_NULL)) {
2350 zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'joinType' must be of the type string"));
2351 RETURN_MM_NULL();
2352 }
2353 if (EXPECTED(Z_TYPE_P(joinType_param) == IS_STRING)) {
2354 zephir_get_strval(&joinType, joinType_param);
2355 } else {
2356 ZEPHIR_INIT_VAR(&joinType);
2357 ZVAL_EMPTY_STRING(&joinType);
2358 }
2359 zephir_get_strval(&modelAlias, modelAlias_param);
2360 zephir_get_strval(&joinAlias, joinAlias_param);
2361
2362
2363 ZEPHIR_INIT_VAR(&sqlJoins);
2364 array_init(&sqlJoins);
2365 ZEPHIR_CALL_METHOD(&fields, relation, "getfields", NULL, 0);
2366 zephir_check_call_status();
2367 ZEPHIR_CALL_METHOD(&referencedFields, relation, "getreferencedfields", NULL, 0);
2368 zephir_check_call_status();
2369 ZEPHIR_CALL_METHOD(&intermediateModelName, relation, "getintermediatemodel", NULL, 0);
2370 zephir_check_call_status();
2371 zephir_read_property(&_0, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
2372 ZEPHIR_CPY_WRT(&manager, &_0);
2373 ZEPHIR_CALL_METHOD(&intermediateModel, &manager, "load", NULL, 0, &intermediateModelName);
2374 zephir_check_call_status();
2375 ZEPHIR_CALL_METHOD(&intermediateSource, &intermediateModel, "getsource", NULL, 0);
2376 zephir_check_call_status();
2377 ZEPHIR_CALL_METHOD(&intermediateSchema, &intermediateModel, "getschema", NULL, 0);
2378 zephir_check_call_status();
2379 zephir_update_property_array(this_ptr, SL("sqlAliases"), &intermediateModelName, &intermediateSource);
2380 zephir_update_property_array(this_ptr, SL("sqlAliasesModelsInstances"), &intermediateModelName, &intermediateModel);
2381 ZEPHIR_CALL_METHOD(&intermediateFields, relation, "getintermediatefields", NULL, 0);
2382 zephir_check_call_status();
2383 ZEPHIR_CALL_METHOD(&intermediateReferencedFields, relation, "getintermediatereferencedfields", NULL, 0);
2384 zephir_check_call_status();
2385 ZEPHIR_CALL_METHOD(&referencedModelName, relation, "getreferencedmodel", NULL, 0);
2386 zephir_check_call_status();
2387 if (Z_TYPE_P(&fields) == IS_ARRAY) {
2388 zephir_is_iterable(&fields, 0, "phalcon/Mvc/Model/Query.zep", 1512);
2389 if (Z_TYPE_P(&fields) == IS_ARRAY) {
2390 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&fields), _3$$3, _4$$3, _1$$3)
2391 {
2392 ZEPHIR_INIT_NVAR(&field);
2393 if (_4$$3 != NULL) {
2394 ZVAL_STR_COPY(&field, _4$$3);
2395 } else {
2396 ZVAL_LONG(&field, _3$$3);
2397 }
2398 ZEPHIR_INIT_NVAR(&position);
2399 ZVAL_COPY(&position, _1$$3);
2400 if (UNEXPECTED(!(zephir_array_isset(&referencedFields, &position)))) {
2401 ZEPHIR_INIT_NVAR(&_5$$5);
2402 object_init_ex(&_5$$5, phalcon_mvc_model_exception_ce);
2403 zephir_read_property(&_6$$5, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2404 ZEPHIR_INIT_NVAR(&_7$$5);
2405 ZEPHIR_CONCAT_SVSVSV(&_7$$5, "The number of fields must be equal to the number of referenced fields in join ", &modelAlias, "-", &joinAlias, ", when preparing: ", &_6$$5);
2406 ZEPHIR_CALL_METHOD(NULL, &_5$$5, "__construct", &_8, 8, &_7$$5);
2407 zephir_check_call_status();
2408 zephir_throw_exception_debug(&_5$$5, "phalcon/Mvc/Model/Query.zep", 1479);
2409 ZEPHIR_MM_RESTORE();
2410 return;
2411 }
2412 ZEPHIR_OBS_NVAR(&intermediateField);
2413 zephir_array_fetch(&intermediateField, &intermediateFields, &position, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1485);
2414 ZEPHIR_INIT_NVAR(&sqlEqualsJoinCondition);
2415 zephir_create_array(&sqlEqualsJoinCondition, 4, 0);
2416 add_assoc_stringl_ex(&sqlEqualsJoinCondition, SL("type"), SL("binary-op"));
2417 add_assoc_stringl_ex(&sqlEqualsJoinCondition, SL("op"), SL("="));
2418 ZEPHIR_INIT_NVAR(&_10$$4);
2419 zephir_create_array(&_10$$4, 3, 0);
2420 add_assoc_long_ex(&_10$$4, SL("type"), 355);
2421 zephir_array_update_string(&_10$$4, SL("domain"), &modelAlias, PH_COPY | PH_SEPARATE);
2422 zephir_array_update_string(&_10$$4, SL("name"), &field, PH_COPY | PH_SEPARATE);
2423 ZEPHIR_CALL_METHOD(&_9$$4, this_ptr, "_getqualified", &_11, 476, &_10$$4);
2424 zephir_check_call_status();
2425 zephir_array_update_string(&sqlEqualsJoinCondition, SL("left"), &_9$$4, PH_COPY | PH_SEPARATE);
2426 ZEPHIR_INIT_NVAR(&_12$$4);
2427 zephir_create_array(&_12$$4, 3, 0);
2428 add_assoc_stringl_ex(&_12$$4, SL("type"), SL("qualified"));
2429 zephir_array_update_string(&_12$$4, SL("domain"), &joinAlias, PH_COPY | PH_SEPARATE);
2430 zephir_array_update_string(&_12$$4, SL("name"), &referencedFields, PH_COPY | PH_SEPARATE);
2431 ZEPHIR_CALL_METHOD(&_9$$4, this_ptr, "_getqualified", &_11, 476, &_12$$4);
2432 zephir_check_call_status();
2433 zephir_array_update_string(&sqlEqualsJoinCondition, SL("right"), &_9$$4, PH_COPY | PH_SEPARATE);
2434 } ZEND_HASH_FOREACH_END();
2435 } else {
2436 ZEPHIR_CALL_METHOD(NULL, &fields, "rewind", NULL, 0);
2437 zephir_check_call_status();
2438 while (1) {
2439 ZEPHIR_CALL_METHOD(&_2$$3, &fields, "valid", NULL, 0);
2440 zephir_check_call_status();
2441 if (!zend_is_true(&_2$$3)) {
2442 break;
2443 }
2444 ZEPHIR_CALL_METHOD(&field, &fields, "key", NULL, 0);
2445 zephir_check_call_status();
2446 ZEPHIR_CALL_METHOD(&position, &fields, "current", NULL, 0);
2447 zephir_check_call_status();
2448 if (UNEXPECTED(!(zephir_array_isset(&referencedFields, &position)))) {
2449 ZEPHIR_INIT_NVAR(&_13$$7);
2450 object_init_ex(&_13$$7, phalcon_mvc_model_exception_ce);
2451 zephir_read_property(&_14$$7, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2452 ZEPHIR_INIT_NVAR(&_15$$7);
2453 ZEPHIR_CONCAT_SVSVSV(&_15$$7, "The number of fields must be equal to the number of referenced fields in join ", &modelAlias, "-", &joinAlias, ", when preparing: ", &_14$$7);
2454 ZEPHIR_CALL_METHOD(NULL, &_13$$7, "__construct", &_8, 8, &_15$$7);
2455 zephir_check_call_status();
2456 zephir_throw_exception_debug(&_13$$7, "phalcon/Mvc/Model/Query.zep", 1479);
2457 ZEPHIR_MM_RESTORE();
2458 return;
2459 }
2460 ZEPHIR_OBS_NVAR(&intermediateField);
2461 zephir_array_fetch(&intermediateField, &intermediateFields, &position, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1485);
2462 ZEPHIR_INIT_NVAR(&_16$$6);
2463 zephir_create_array(&_16$$6, 4, 0);
2464 add_assoc_stringl_ex(&_16$$6, SL("type"), SL("binary-op"));
2465 add_assoc_stringl_ex(&_16$$6, SL("op"), SL("="));
2466 ZEPHIR_INIT_NVAR(&_18$$6);
2467 zephir_create_array(&_18$$6, 3, 0);
2468 add_assoc_long_ex(&_18$$6, SL("type"), 355);
2469 zephir_array_update_string(&_18$$6, SL("domain"), &modelAlias, PH_COPY | PH_SEPARATE);
2470 zephir_array_update_string(&_18$$6, SL("name"), &field, PH_COPY | PH_SEPARATE);
2471 ZEPHIR_CALL_METHOD(&_17$$6, this_ptr, "_getqualified", &_11, 476, &_18$$6);
2472 zephir_check_call_status();
2473 zephir_array_update_string(&_16$$6, SL("left"), &_17$$6, PH_COPY | PH_SEPARATE);
2474 ZEPHIR_INIT_NVAR(&_19$$6);
2475 zephir_create_array(&_19$$6, 3, 0);
2476 add_assoc_stringl_ex(&_19$$6, SL("type"), SL("qualified"));
2477 zephir_array_update_string(&_19$$6, SL("domain"), &joinAlias, PH_COPY | PH_SEPARATE);
2478 zephir_array_update_string(&_19$$6, SL("name"), &referencedFields, PH_COPY | PH_SEPARATE);
2479 ZEPHIR_CALL_METHOD(&_17$$6, this_ptr, "_getqualified", &_11, 476, &_19$$6);
2480 zephir_check_call_status();
2481 zephir_array_update_string(&_16$$6, SL("right"), &_17$$6, PH_COPY | PH_SEPARATE);
2482 ZEPHIR_CPY_WRT(&sqlEqualsJoinCondition, &_16$$6);
2483 ZEPHIR_CALL_METHOD(NULL, &fields, "next", NULL, 0);
2484 zephir_check_call_status();
2485 }
2486 }
2487 ZEPHIR_INIT_NVAR(&position);
2488 ZEPHIR_INIT_NVAR(&field);
2489 } else {
2490 ZEPHIR_INIT_VAR(&_20$$8);
2491 zephir_create_array(&_20$$8, 2, 0);
2492 ZEPHIR_INIT_VAR(&_21$$8);
2493 zephir_create_array(&_21$$8, 3, 0);
2494 zephir_array_update_string(&_21$$8, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
2495 ZEPHIR_INIT_VAR(&_22$$8);
2496 zephir_create_array(&_22$$8, 2, 0);
2497 zephir_array_fast_append(&_22$$8, &intermediateSource);
2498 zephir_array_fast_append(&_22$$8, &intermediateSchema);
2499 zephir_array_update_string(&_21$$8, SL("source"), &_22$$8, PH_COPY | PH_SEPARATE);
2500 ZEPHIR_INIT_NVAR(&_22$$8);
2501 zephir_create_array(&_22$$8, 1, 0);
2502 ZEPHIR_INIT_VAR(&_23$$8);
2503 zephir_create_array(&_23$$8, 4, 0);
2504 add_assoc_stringl_ex(&_23$$8, SL("type"), SL("binary-op"));
2505 add_assoc_stringl_ex(&_23$$8, SL("op"), SL("="));
2506 ZEPHIR_INIT_VAR(&_25$$8);
2507 zephir_create_array(&_25$$8, 3, 0);
2508 add_assoc_long_ex(&_25$$8, SL("type"), 355);
2509 zephir_array_update_string(&_25$$8, SL("domain"), &modelAlias, PH_COPY | PH_SEPARATE);
2510 zephir_array_update_string(&_25$$8, SL("name"), &fields, PH_COPY | PH_SEPARATE);
2511 ZEPHIR_CALL_METHOD(&_24$$8, this_ptr, "_getqualified", &_11, 476, &_25$$8);
2512 zephir_check_call_status();
2513 zephir_array_update_string(&_23$$8, SL("left"), &_24$$8, PH_COPY | PH_SEPARATE);
2514 ZEPHIR_INIT_VAR(&_26$$8);
2515 zephir_create_array(&_26$$8, 3, 0);
2516 add_assoc_stringl_ex(&_26$$8, SL("type"), SL("qualified"));
2517 zephir_array_update_string(&_26$$8, SL("domain"), &intermediateModelName, PH_COPY | PH_SEPARATE);
2518 zephir_array_update_string(&_26$$8, SL("name"), &intermediateFields, PH_COPY | PH_SEPARATE);
2519 ZEPHIR_CALL_METHOD(&_24$$8, this_ptr, "_getqualified", &_11, 476, &_26$$8);
2520 zephir_check_call_status();
2521 zephir_array_update_string(&_23$$8, SL("right"), &_24$$8, PH_COPY | PH_SEPARATE);
2522 zephir_array_fast_append(&_22$$8, &_23$$8);
2523 zephir_array_update_string(&_21$$8, SL("conditions"), &_22$$8, PH_COPY | PH_SEPARATE);
2524 zephir_array_fast_append(&_20$$8, &_21$$8);
2525 ZEPHIR_INIT_NVAR(&_21$$8);
2526 zephir_create_array(&_21$$8, 3, 0);
2527 zephir_array_update_string(&_21$$8, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
2528 zephir_array_update_string(&_21$$8, SL("source"), joinSource, PH_COPY | PH_SEPARATE);
2529 ZEPHIR_INIT_NVAR(&_22$$8);
2530 zephir_create_array(&_22$$8, 1, 0);
2531 ZEPHIR_INIT_NVAR(&_23$$8);
2532 zephir_create_array(&_23$$8, 4, 0);
2533 add_assoc_stringl_ex(&_23$$8, SL("type"), SL("binary-op"));
2534 add_assoc_stringl_ex(&_23$$8, SL("op"), SL("="));
2535 ZEPHIR_INIT_VAR(&_27$$8);
2536 zephir_create_array(&_27$$8, 3, 0);
2537 add_assoc_long_ex(&_27$$8, SL("type"), 355);
2538 zephir_array_update_string(&_27$$8, SL("domain"), &intermediateModelName, PH_COPY | PH_SEPARATE);
2539 zephir_array_update_string(&_27$$8, SL("name"), &intermediateReferencedFields, PH_COPY | PH_SEPARATE);
2540 ZEPHIR_CALL_METHOD(&_24$$8, this_ptr, "_getqualified", &_11, 476, &_27$$8);
2541 zephir_check_call_status();
2542 zephir_array_update_string(&_23$$8, SL("left"), &_24$$8, PH_COPY | PH_SEPARATE);
2543 ZEPHIR_INIT_VAR(&_28$$8);
2544 zephir_create_array(&_28$$8, 3, 0);
2545 add_assoc_stringl_ex(&_28$$8, SL("type"), SL("qualified"));
2546 zephir_array_update_string(&_28$$8, SL("domain"), &referencedModelName, PH_COPY | PH_SEPARATE);
2547 zephir_array_update_string(&_28$$8, SL("name"), &referencedFields, PH_COPY | PH_SEPARATE);
2548 ZEPHIR_CALL_METHOD(&_24$$8, this_ptr, "_getqualified", &_11, 476, &_28$$8);
2549 zephir_check_call_status();
2550 zephir_array_update_string(&_23$$8, SL("right"), &_24$$8, PH_COPY | PH_SEPARATE);
2551 zephir_array_fast_append(&_22$$8, &_23$$8);
2552 zephir_array_update_string(&_21$$8, SL("conditions"), &_22$$8, PH_COPY | PH_SEPARATE);
2553 zephir_array_fast_append(&_20$$8, &_21$$8);
2554 ZEPHIR_CPY_WRT(&sqlJoins, &_20$$8);
2555 }
2556 RETURN_CTOR(&sqlJoins);
2557
2558 }
2559
2560 /**
2561 * Processes the JOINs in the query returning an internal representation for
2562 * the database dialect
2563 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getJoins)2564 PHP_METHOD(Phalcon_Mvc_Model_Query, _getJoins) {
2565
2566 zend_string *_22, *_45, *_30$$21, *_49$$26, *_79$$55;
2567 zend_ulong _21, _44, _29$$21, _48$$26, _78$$55;
2568 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
2569 zephir_fcall_cache_entry *_3 = NULL, *_4 = NULL, *_8 = NULL, *_24 = NULL, *_50 = NULL, *_51 = NULL, *_56 = NULL, *_57 = NULL, *_64 = NULL, *_65 = NULL, *_80 = NULL, *_81 = NULL, *_92 = NULL, *_93 = NULL;
2570 zend_long ZEPHIR_LAST_CALL_STATUS;
2571 zval *select_param = NULL, __$true, models, sqlAliases, sqlAliasesModels, sqlModelsAliases, sqlAliasesModelsInstances, modelsInstances, fromModels, manager, selectJoins, joinItem, joins, joinData, schema, source, model, realModelName, completeSource, joinType, aliasExpr, alias, joinAliasName, joinExpr, fromModelName, joinAlias, joinModel, joinSource, preCondition, modelNameAlias, relation, relations, modelAlias, sqlJoin, sqlJoinItem, selectTables, tables, tableItem, _0, *_1, _2, *_19, _20, *_35, _36, _41, *_42, _43, _5$$9, _6$$9, _7$$9, _9$$11, _10$$11, _11$$11, _12$$12, _13$$14, _14$$14, _15$$14, _16$$16, _17$$16, _18$$16, _23$$18, _25$$20, _26$$21, *_27$$21, _28$$21, _37$$24, _38$$24, _39$$25, _40$$25, *_46$$26, _47$$26, _52$$31, _53$$31, _54$$31, _55$$32, *_58$$35, _59$$35, _61$$39, _66$$45, _67$$45, _68$$45, _69$$46, *_70$$49, _71$$49, _73$$53, *_76$$55, _77$$55, _82$$60, _83$$60, _84$$60, _85$$61, *_86$$64, _87$$64, _89$$68, _94$$74, _95$$74, _96$$74, _97$$75, *_98$$78, _99$$78, _101$$82;
2572 zval select, sqlJoins, joinModels, joinSources, joinTypes, joinPreCondition, joinPrepared, _31$$22, _32$$22, _33$$23, _34$$23, _60$$39, _62$$40, _63$$40, _72$$53, _74$$54, _75$$54, _88$$68, _90$$69, _91$$69, _100$$82, _102$$83, _103$$83;
2573 zval *this_ptr = getThis();
2574
2575 ZVAL_UNDEF(&select);
2576 ZVAL_UNDEF(&sqlJoins);
2577 ZVAL_UNDEF(&joinModels);
2578 ZVAL_UNDEF(&joinSources);
2579 ZVAL_UNDEF(&joinTypes);
2580 ZVAL_UNDEF(&joinPreCondition);
2581 ZVAL_UNDEF(&joinPrepared);
2582 ZVAL_UNDEF(&_31$$22);
2583 ZVAL_UNDEF(&_32$$22);
2584 ZVAL_UNDEF(&_33$$23);
2585 ZVAL_UNDEF(&_34$$23);
2586 ZVAL_UNDEF(&_60$$39);
2587 ZVAL_UNDEF(&_62$$40);
2588 ZVAL_UNDEF(&_63$$40);
2589 ZVAL_UNDEF(&_72$$53);
2590 ZVAL_UNDEF(&_74$$54);
2591 ZVAL_UNDEF(&_75$$54);
2592 ZVAL_UNDEF(&_88$$68);
2593 ZVAL_UNDEF(&_90$$69);
2594 ZVAL_UNDEF(&_91$$69);
2595 ZVAL_UNDEF(&_100$$82);
2596 ZVAL_UNDEF(&_102$$83);
2597 ZVAL_UNDEF(&_103$$83);
2598 ZVAL_BOOL(&__$true, 1);
2599 ZVAL_UNDEF(&models);
2600 ZVAL_UNDEF(&sqlAliases);
2601 ZVAL_UNDEF(&sqlAliasesModels);
2602 ZVAL_UNDEF(&sqlModelsAliases);
2603 ZVAL_UNDEF(&sqlAliasesModelsInstances);
2604 ZVAL_UNDEF(&modelsInstances);
2605 ZVAL_UNDEF(&fromModels);
2606 ZVAL_UNDEF(&manager);
2607 ZVAL_UNDEF(&selectJoins);
2608 ZVAL_UNDEF(&joinItem);
2609 ZVAL_UNDEF(&joins);
2610 ZVAL_UNDEF(&joinData);
2611 ZVAL_UNDEF(&schema);
2612 ZVAL_UNDEF(&source);
2613 ZVAL_UNDEF(&model);
2614 ZVAL_UNDEF(&realModelName);
2615 ZVAL_UNDEF(&completeSource);
2616 ZVAL_UNDEF(&joinType);
2617 ZVAL_UNDEF(&aliasExpr);
2618 ZVAL_UNDEF(&alias);
2619 ZVAL_UNDEF(&joinAliasName);
2620 ZVAL_UNDEF(&joinExpr);
2621 ZVAL_UNDEF(&fromModelName);
2622 ZVAL_UNDEF(&joinAlias);
2623 ZVAL_UNDEF(&joinModel);
2624 ZVAL_UNDEF(&joinSource);
2625 ZVAL_UNDEF(&preCondition);
2626 ZVAL_UNDEF(&modelNameAlias);
2627 ZVAL_UNDEF(&relation);
2628 ZVAL_UNDEF(&relations);
2629 ZVAL_UNDEF(&modelAlias);
2630 ZVAL_UNDEF(&sqlJoin);
2631 ZVAL_UNDEF(&sqlJoinItem);
2632 ZVAL_UNDEF(&selectTables);
2633 ZVAL_UNDEF(&tables);
2634 ZVAL_UNDEF(&tableItem);
2635 ZVAL_UNDEF(&_0);
2636 ZVAL_UNDEF(&_2);
2637 ZVAL_UNDEF(&_20);
2638 ZVAL_UNDEF(&_36);
2639 ZVAL_UNDEF(&_41);
2640 ZVAL_UNDEF(&_43);
2641 ZVAL_UNDEF(&_5$$9);
2642 ZVAL_UNDEF(&_6$$9);
2643 ZVAL_UNDEF(&_7$$9);
2644 ZVAL_UNDEF(&_9$$11);
2645 ZVAL_UNDEF(&_10$$11);
2646 ZVAL_UNDEF(&_11$$11);
2647 ZVAL_UNDEF(&_12$$12);
2648 ZVAL_UNDEF(&_13$$14);
2649 ZVAL_UNDEF(&_14$$14);
2650 ZVAL_UNDEF(&_15$$14);
2651 ZVAL_UNDEF(&_16$$16);
2652 ZVAL_UNDEF(&_17$$16);
2653 ZVAL_UNDEF(&_18$$16);
2654 ZVAL_UNDEF(&_23$$18);
2655 ZVAL_UNDEF(&_25$$20);
2656 ZVAL_UNDEF(&_26$$21);
2657 ZVAL_UNDEF(&_28$$21);
2658 ZVAL_UNDEF(&_37$$24);
2659 ZVAL_UNDEF(&_38$$24);
2660 ZVAL_UNDEF(&_39$$25);
2661 ZVAL_UNDEF(&_40$$25);
2662 ZVAL_UNDEF(&_47$$26);
2663 ZVAL_UNDEF(&_52$$31);
2664 ZVAL_UNDEF(&_53$$31);
2665 ZVAL_UNDEF(&_54$$31);
2666 ZVAL_UNDEF(&_55$$32);
2667 ZVAL_UNDEF(&_59$$35);
2668 ZVAL_UNDEF(&_61$$39);
2669 ZVAL_UNDEF(&_66$$45);
2670 ZVAL_UNDEF(&_67$$45);
2671 ZVAL_UNDEF(&_68$$45);
2672 ZVAL_UNDEF(&_69$$46);
2673 ZVAL_UNDEF(&_71$$49);
2674 ZVAL_UNDEF(&_73$$53);
2675 ZVAL_UNDEF(&_77$$55);
2676 ZVAL_UNDEF(&_82$$60);
2677 ZVAL_UNDEF(&_83$$60);
2678 ZVAL_UNDEF(&_84$$60);
2679 ZVAL_UNDEF(&_85$$61);
2680 ZVAL_UNDEF(&_87$$64);
2681 ZVAL_UNDEF(&_89$$68);
2682 ZVAL_UNDEF(&_94$$74);
2683 ZVAL_UNDEF(&_95$$74);
2684 ZVAL_UNDEF(&_96$$74);
2685 ZVAL_UNDEF(&_97$$75);
2686 ZVAL_UNDEF(&_99$$78);
2687 ZVAL_UNDEF(&_101$$82);
2688
2689 ZEPHIR_MM_GROW();
2690 zephir_fetch_params(1, 1, 0, &select_param);
2691
2692 zephir_get_arrval(&select, select_param);
2693
2694
2695 zephir_read_property(&_0, this_ptr, ZEND_STRL("models"), PH_NOISY_CC | PH_READONLY);
2696 ZEPHIR_CPY_WRT(&models, &_0);
2697 zephir_read_property(&_0, this_ptr, ZEND_STRL("sqlAliases"), PH_NOISY_CC | PH_READONLY);
2698 ZEPHIR_CPY_WRT(&sqlAliases, &_0);
2699 zephir_read_property(&_0, this_ptr, ZEND_STRL("sqlAliasesModels"), PH_NOISY_CC | PH_READONLY);
2700 ZEPHIR_CPY_WRT(&sqlAliasesModels, &_0);
2701 zephir_read_property(&_0, this_ptr, ZEND_STRL("sqlModelsAliases"), PH_NOISY_CC | PH_READONLY);
2702 ZEPHIR_CPY_WRT(&sqlModelsAliases, &_0);
2703 zephir_read_property(&_0, this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), PH_NOISY_CC | PH_READONLY);
2704 ZEPHIR_CPY_WRT(&sqlAliasesModelsInstances, &_0);
2705 zephir_read_property(&_0, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
2706 ZEPHIR_CPY_WRT(&modelsInstances, &_0);
2707 ZEPHIR_CPY_WRT(&fromModels, &models);
2708 ZEPHIR_INIT_VAR(&sqlJoins);
2709 array_init(&sqlJoins);
2710 ZEPHIR_INIT_VAR(&joinModels);
2711 array_init(&joinModels);
2712 ZEPHIR_INIT_VAR(&joinSources);
2713 array_init(&joinSources);
2714 ZEPHIR_INIT_VAR(&joinTypes);
2715 array_init(&joinTypes);
2716 ZEPHIR_INIT_VAR(&joinPreCondition);
2717 array_init(&joinPreCondition);
2718 ZEPHIR_INIT_VAR(&joinPrepared);
2719 array_init(&joinPrepared);
2720 zephir_read_property(&_0, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
2721 ZEPHIR_CPY_WRT(&manager, &_0);
2722 ZEPHIR_OBS_VAR(&tables);
2723 zephir_array_fetch_string(&tables, &select, SL("tables"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1615);
2724 if (!(zephir_array_isset_long(&tables, 0))) {
2725 ZEPHIR_INIT_VAR(&selectTables);
2726 zephir_create_array(&selectTables, 1, 0);
2727 zephir_array_fast_append(&selectTables, &tables);
2728 } else {
2729 ZEPHIR_CPY_WRT(&selectTables, &tables);
2730 }
2731 ZEPHIR_OBS_VAR(&joins);
2732 zephir_array_fetch_string(&joins, &select, SL("joins"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1623);
2733 if (!(zephir_array_isset_long(&joins, 0))) {
2734 ZEPHIR_INIT_VAR(&selectJoins);
2735 zephir_create_array(&selectJoins, 1, 0);
2736 zephir_array_fast_append(&selectJoins, &joins);
2737 } else {
2738 ZEPHIR_CPY_WRT(&selectJoins, &joins);
2739 }
2740 zephir_is_iterable(&selectJoins, 0, "phalcon/Mvc/Model/Query.zep", 1774);
2741 if (Z_TYPE_P(&selectJoins) == IS_ARRAY) {
2742 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&selectJoins), _1)
2743 {
2744 ZEPHIR_INIT_NVAR(&joinItem);
2745 ZVAL_COPY(&joinItem, _1);
2746 ZEPHIR_CALL_METHOD(&joinData, this_ptr, "_getjoin", &_3, 480, &manager, &joinItem);
2747 zephir_check_call_status();
2748 ZEPHIR_OBS_NVAR(&source);
2749 zephir_array_fetch_string(&source, &joinData, SL("source"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1637);
2750 ZEPHIR_OBS_NVAR(&schema);
2751 zephir_array_fetch_string(&schema, &joinData, SL("schema"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1638);
2752 ZEPHIR_OBS_NVAR(&model);
2753 zephir_array_fetch_string(&model, &joinData, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1639);
2754 ZEPHIR_OBS_NVAR(&realModelName);
2755 zephir_array_fetch_string(&realModelName, &joinData, SL("modelName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1640);
2756 ZEPHIR_INIT_NVAR(&completeSource);
2757 zephir_create_array(&completeSource, 2, 0);
2758 zephir_array_fast_append(&completeSource, &source);
2759 zephir_array_fast_append(&completeSource, &schema);
2760 ZEPHIR_CALL_METHOD(&joinType, this_ptr, "_getjointype", &_4, 481, &joinItem);
2761 zephir_check_call_status();
2762 ZEPHIR_OBS_NVAR(&aliasExpr);
2763 if (zephir_array_isset_string_fetch(&aliasExpr, &joinItem, SL("alias"), 0)) {
2764 ZEPHIR_OBS_NVAR(&alias);
2765 zephir_array_fetch_string(&alias, &aliasExpr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1652);
2766 if (UNEXPECTED(zephir_array_isset(&joinModels, &alias))) {
2767 ZEPHIR_INIT_NVAR(&_5$$9);
2768 object_init_ex(&_5$$9, phalcon_mvc_model_exception_ce);
2769 zephir_read_property(&_6$$9, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2770 ZEPHIR_INIT_NVAR(&_7$$9);
2771 ZEPHIR_CONCAT_SVSV(&_7$$9, "Cannot use '", &alias, "' as join alias because it was already used, when preparing: ", &_6$$9);
2772 ZEPHIR_CALL_METHOD(NULL, &_5$$9, "__construct", &_8, 8, &_7$$9);
2773 zephir_check_call_status();
2774 zephir_throw_exception_debug(&_5$$9, "phalcon/Mvc/Model/Query.zep", 1660);
2775 ZEPHIR_MM_RESTORE();
2776 return;
2777 }
2778 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1666);
2779 zephir_array_update_zval(&joinTypes, &alias, &joinType, PH_COPY | PH_SEPARATE);
2780 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
2781 zephir_array_update_zval(&joinModels, &alias, &realModelName, PH_COPY | PH_SEPARATE);
2782 zephir_array_update_zval(&sqlModelsAliases, &realModelName, &alias, PH_COPY | PH_SEPARATE);
2783 zephir_array_update_zval(&sqlAliasesModels, &alias, &realModelName, PH_COPY | PH_SEPARATE);
2784 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
2785 zephir_array_update_zval(&models, &realModelName, &alias, PH_COPY | PH_SEPARATE);
2786 zephir_array_update_zval(&joinSources, &alias, &completeSource, PH_COPY | PH_SEPARATE);
2787 zephir_array_update_zval(&joinPrepared, &alias, &joinItem, PH_COPY | PH_SEPARATE);
2788 } else {
2789 if (UNEXPECTED(zephir_array_isset(&joinModels, &realModelName))) {
2790 ZEPHIR_INIT_NVAR(&_9$$11);
2791 object_init_ex(&_9$$11, phalcon_mvc_model_exception_ce);
2792 zephir_read_property(&_10$$11, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2793 ZEPHIR_INIT_NVAR(&_11$$11);
2794 ZEPHIR_CONCAT_SVSV(&_11$$11, "Cannot use '", &realModelName, "' as join alias because it was already used, when preparing: ", &_10$$11);
2795 ZEPHIR_CALL_METHOD(NULL, &_9$$11, "__construct", &_8, 8, &_11$$11);
2796 zephir_check_call_status();
2797 zephir_throw_exception_debug(&_9$$11, "phalcon/Mvc/Model/Query.zep", 1719);
2798 ZEPHIR_MM_RESTORE();
2799 return;
2800 }
2801 zephir_array_update_zval(&joinTypes, &realModelName, &joinType, PH_COPY | PH_SEPARATE);
2802 zephir_array_update_zval(&sqlAliases, &realModelName, &source, PH_COPY | PH_SEPARATE);
2803 zephir_array_update_zval(&joinModels, &realModelName, &source, PH_COPY | PH_SEPARATE);
2804 zephir_array_update_zval(&sqlModelsAliases, &realModelName, &realModelName, PH_COPY | PH_SEPARATE);
2805 zephir_array_update_zval(&sqlAliasesModels, &realModelName, &realModelName, PH_COPY | PH_SEPARATE);
2806 zephir_array_update_zval(&sqlAliasesModelsInstances, &realModelName, &model, PH_COPY | PH_SEPARATE);
2807 zephir_array_update_zval(&models, &realModelName, &source, PH_COPY | PH_SEPARATE);
2808 zephir_array_update_zval(&joinSources, &realModelName, &completeSource, PH_COPY | PH_SEPARATE);
2809 zephir_array_update_zval(&joinPrepared, &realModelName, &joinItem, PH_COPY | PH_SEPARATE);
2810 }
2811 zephir_array_update_zval(&modelsInstances, &realModelName, &model, PH_COPY | PH_SEPARATE);
2812 } ZEND_HASH_FOREACH_END();
2813 } else {
2814 ZEPHIR_CALL_METHOD(NULL, &selectJoins, "rewind", NULL, 0);
2815 zephir_check_call_status();
2816 while (1) {
2817 ZEPHIR_CALL_METHOD(&_2, &selectJoins, "valid", NULL, 0);
2818 zephir_check_call_status();
2819 if (!zend_is_true(&_2)) {
2820 break;
2821 }
2822 ZEPHIR_CALL_METHOD(&joinItem, &selectJoins, "current", NULL, 0);
2823 zephir_check_call_status();
2824 ZEPHIR_CALL_METHOD(&joinData, this_ptr, "_getjoin", &_3, 480, &manager, &joinItem);
2825 zephir_check_call_status();
2826 ZEPHIR_OBS_NVAR(&source);
2827 zephir_array_fetch_string(&source, &joinData, SL("source"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1637);
2828 ZEPHIR_OBS_NVAR(&schema);
2829 zephir_array_fetch_string(&schema, &joinData, SL("schema"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1638);
2830 ZEPHIR_OBS_NVAR(&model);
2831 zephir_array_fetch_string(&model, &joinData, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1639);
2832 ZEPHIR_OBS_NVAR(&realModelName);
2833 zephir_array_fetch_string(&realModelName, &joinData, SL("modelName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1640);
2834 ZEPHIR_INIT_NVAR(&_12$$12);
2835 zephir_create_array(&_12$$12, 2, 0);
2836 zephir_array_fast_append(&_12$$12, &source);
2837 zephir_array_fast_append(&_12$$12, &schema);
2838 ZEPHIR_CPY_WRT(&completeSource, &_12$$12);
2839 ZEPHIR_CALL_METHOD(&joinType, this_ptr, "_getjointype", &_4, 481, &joinItem);
2840 zephir_check_call_status();
2841 ZEPHIR_OBS_NVAR(&aliasExpr);
2842 if (zephir_array_isset_string_fetch(&aliasExpr, &joinItem, SL("alias"), 0)) {
2843 ZEPHIR_OBS_NVAR(&alias);
2844 zephir_array_fetch_string(&alias, &aliasExpr, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1652);
2845 if (UNEXPECTED(zephir_array_isset(&joinModels, &alias))) {
2846 ZEPHIR_INIT_NVAR(&_13$$14);
2847 object_init_ex(&_13$$14, phalcon_mvc_model_exception_ce);
2848 zephir_read_property(&_14$$14, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2849 ZEPHIR_INIT_NVAR(&_15$$14);
2850 ZEPHIR_CONCAT_SVSV(&_15$$14, "Cannot use '", &alias, "' as join alias because it was already used, when preparing: ", &_14$$14);
2851 ZEPHIR_CALL_METHOD(NULL, &_13$$14, "__construct", &_8, 8, &_15$$14);
2852 zephir_check_call_status();
2853 zephir_throw_exception_debug(&_13$$14, "phalcon/Mvc/Model/Query.zep", 1660);
2854 ZEPHIR_MM_RESTORE();
2855 return;
2856 }
2857 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1666);
2858 zephir_array_update_zval(&joinTypes, &alias, &joinType, PH_COPY | PH_SEPARATE);
2859 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
2860 zephir_array_update_zval(&joinModels, &alias, &realModelName, PH_COPY | PH_SEPARATE);
2861 zephir_array_update_zval(&sqlModelsAliases, &realModelName, &alias, PH_COPY | PH_SEPARATE);
2862 zephir_array_update_zval(&sqlAliasesModels, &alias, &realModelName, PH_COPY | PH_SEPARATE);
2863 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
2864 zephir_array_update_zval(&models, &realModelName, &alias, PH_COPY | PH_SEPARATE);
2865 zephir_array_update_zval(&joinSources, &alias, &completeSource, PH_COPY | PH_SEPARATE);
2866 zephir_array_update_zval(&joinPrepared, &alias, &joinItem, PH_COPY | PH_SEPARATE);
2867 } else {
2868 if (UNEXPECTED(zephir_array_isset(&joinModels, &realModelName))) {
2869 ZEPHIR_INIT_NVAR(&_16$$16);
2870 object_init_ex(&_16$$16, phalcon_mvc_model_exception_ce);
2871 zephir_read_property(&_17$$16, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
2872 ZEPHIR_INIT_NVAR(&_18$$16);
2873 ZEPHIR_CONCAT_SVSV(&_18$$16, "Cannot use '", &realModelName, "' as join alias because it was already used, when preparing: ", &_17$$16);
2874 ZEPHIR_CALL_METHOD(NULL, &_16$$16, "__construct", &_8, 8, &_18$$16);
2875 zephir_check_call_status();
2876 zephir_throw_exception_debug(&_16$$16, "phalcon/Mvc/Model/Query.zep", 1719);
2877 ZEPHIR_MM_RESTORE();
2878 return;
2879 }
2880 zephir_array_update_zval(&joinTypes, &realModelName, &joinType, PH_COPY | PH_SEPARATE);
2881 zephir_array_update_zval(&sqlAliases, &realModelName, &source, PH_COPY | PH_SEPARATE);
2882 zephir_array_update_zval(&joinModels, &realModelName, &source, PH_COPY | PH_SEPARATE);
2883 zephir_array_update_zval(&sqlModelsAliases, &realModelName, &realModelName, PH_COPY | PH_SEPARATE);
2884 zephir_array_update_zval(&sqlAliasesModels, &realModelName, &realModelName, PH_COPY | PH_SEPARATE);
2885 zephir_array_update_zval(&sqlAliasesModelsInstances, &realModelName, &model, PH_COPY | PH_SEPARATE);
2886 zephir_array_update_zval(&models, &realModelName, &source, PH_COPY | PH_SEPARATE);
2887 zephir_array_update_zval(&joinSources, &realModelName, &completeSource, PH_COPY | PH_SEPARATE);
2888 zephir_array_update_zval(&joinPrepared, &realModelName, &joinItem, PH_COPY | PH_SEPARATE);
2889 }
2890 zephir_array_update_zval(&modelsInstances, &realModelName, &model, PH_COPY | PH_SEPARATE);
2891 ZEPHIR_CALL_METHOD(NULL, &selectJoins, "next", NULL, 0);
2892 zephir_check_call_status();
2893 }
2894 }
2895 ZEPHIR_INIT_NVAR(&joinItem);
2896 zephir_update_property_zval(this_ptr, ZEND_STRL("models"), &models);
2897 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliases"), &sqlAliases);
2898 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModels"), &sqlAliasesModels);
2899 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlModelsAliases"), &sqlModelsAliases);
2900 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), &sqlAliasesModelsInstances);
2901 zephir_update_property_zval(this_ptr, ZEND_STRL("modelsInstances"), &modelsInstances);
2902 zephir_is_iterable(&joinPrepared, 0, "phalcon/Mvc/Model/Query.zep", 1794);
2903 if (Z_TYPE_P(&joinPrepared) == IS_ARRAY) {
2904 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&joinPrepared), _21, _22, _19)
2905 {
2906 ZEPHIR_INIT_NVAR(&joinAliasName);
2907 if (_22 != NULL) {
2908 ZVAL_STR_COPY(&joinAliasName, _22);
2909 } else {
2910 ZVAL_LONG(&joinAliasName, _21);
2911 }
2912 ZEPHIR_INIT_NVAR(&joinItem);
2913 ZVAL_COPY(&joinItem, _19);
2914 ZEPHIR_OBS_NVAR(&joinExpr);
2915 if (zephir_array_isset_string_fetch(&joinExpr, &joinItem, SL("conditions"), 0)) {
2916 ZEPHIR_CALL_METHOD(&_23$$18, this_ptr, "_getexpression", &_24, 474, &joinExpr);
2917 zephir_check_call_status();
2918 zephir_array_update_zval(&joinPreCondition, &joinAliasName, &_23$$18, PH_COPY | PH_SEPARATE);
2919 }
2920 } ZEND_HASH_FOREACH_END();
2921 } else {
2922 ZEPHIR_CALL_METHOD(NULL, &joinPrepared, "rewind", NULL, 0);
2923 zephir_check_call_status();
2924 while (1) {
2925 ZEPHIR_CALL_METHOD(&_20, &joinPrepared, "valid", NULL, 0);
2926 zephir_check_call_status();
2927 if (!zend_is_true(&_20)) {
2928 break;
2929 }
2930 ZEPHIR_CALL_METHOD(&joinAliasName, &joinPrepared, "key", NULL, 0);
2931 zephir_check_call_status();
2932 ZEPHIR_CALL_METHOD(&joinItem, &joinPrepared, "current", NULL, 0);
2933 zephir_check_call_status();
2934 ZEPHIR_OBS_NVAR(&joinExpr);
2935 if (zephir_array_isset_string_fetch(&joinExpr, &joinItem, SL("conditions"), 0)) {
2936 ZEPHIR_CALL_METHOD(&_25$$20, this_ptr, "_getexpression", &_24, 474, &joinExpr);
2937 zephir_check_call_status();
2938 zephir_array_update_zval(&joinPreCondition, &joinAliasName, &_25$$20, PH_COPY | PH_SEPARATE);
2939 }
2940 ZEPHIR_CALL_METHOD(NULL, &joinPrepared, "next", NULL, 0);
2941 zephir_check_call_status();
2942 }
2943 }
2944 ZEPHIR_INIT_NVAR(&joinItem);
2945 ZEPHIR_INIT_NVAR(&joinAliasName);
2946 zephir_read_property(&_0, this_ptr, ZEND_STRL("enableImplicitJoins"), PH_NOISY_CC | PH_READONLY);
2947 if (!(zephir_is_true(&_0))) {
2948 ZEPHIR_INIT_VAR(&_26$$21);
2949 zephir_is_iterable(&joinPrepared, 0, "phalcon/Mvc/Model/Query.zep", 1806);
2950 if (Z_TYPE_P(&joinPrepared) == IS_ARRAY) {
2951 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&joinPrepared), _29$$21, _30$$21, _27$$21)
2952 {
2953 ZEPHIR_INIT_NVAR(&joinAliasName);
2954 if (_30$$21 != NULL) {
2955 ZVAL_STR_COPY(&joinAliasName, _30$$21);
2956 } else {
2957 ZVAL_LONG(&joinAliasName, _29$$21);
2958 }
2959 ZEPHIR_INIT_NVAR(&_26$$21);
2960 ZVAL_COPY(&_26$$21, _27$$21);
2961 ZEPHIR_OBS_NVAR(&joinType);
2962 zephir_array_fetch(&joinType, &joinTypes, &joinAliasName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1796);
2963 ZEPHIR_OBS_NVAR(&joinSource);
2964 zephir_array_fetch(&joinSource, &joinSources, &joinAliasName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1797);
2965 ZEPHIR_OBS_NVAR(&preCondition);
2966 zephir_array_fetch(&preCondition, &joinPreCondition, &joinAliasName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1798);
2967 ZEPHIR_INIT_NVAR(&_31$$22);
2968 zephir_create_array(&_31$$22, 3, 0);
2969 zephir_array_update_string(&_31$$22, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
2970 zephir_array_update_string(&_31$$22, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
2971 ZEPHIR_INIT_NVAR(&_32$$22);
2972 zephir_create_array(&_32$$22, 1, 0);
2973 zephir_array_fast_append(&_32$$22, &preCondition);
2974 zephir_array_update_string(&_31$$22, SL("conditions"), &_32$$22, PH_COPY | PH_SEPARATE);
2975 zephir_array_append(&sqlJoins, &_31$$22, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1803);
2976 } ZEND_HASH_FOREACH_END();
2977 } else {
2978 ZEPHIR_CALL_METHOD(NULL, &joinPrepared, "rewind", NULL, 0);
2979 zephir_check_call_status();
2980 while (1) {
2981 ZEPHIR_CALL_METHOD(&_28$$21, &joinPrepared, "valid", NULL, 0);
2982 zephir_check_call_status();
2983 if (!zend_is_true(&_28$$21)) {
2984 break;
2985 }
2986 ZEPHIR_CALL_METHOD(&joinAliasName, &joinPrepared, "key", NULL, 0);
2987 zephir_check_call_status();
2988 ZEPHIR_CALL_METHOD(&_26$$21, &joinPrepared, "current", NULL, 0);
2989 zephir_check_call_status();
2990 ZEPHIR_OBS_NVAR(&joinType);
2991 zephir_array_fetch(&joinType, &joinTypes, &joinAliasName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1796);
2992 ZEPHIR_OBS_NVAR(&joinSource);
2993 zephir_array_fetch(&joinSource, &joinSources, &joinAliasName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1797);
2994 ZEPHIR_OBS_NVAR(&preCondition);
2995 zephir_array_fetch(&preCondition, &joinPreCondition, &joinAliasName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1798);
2996 ZEPHIR_INIT_NVAR(&_33$$23);
2997 zephir_create_array(&_33$$23, 3, 0);
2998 zephir_array_update_string(&_33$$23, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
2999 zephir_array_update_string(&_33$$23, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3000 ZEPHIR_INIT_NVAR(&_34$$23);
3001 zephir_create_array(&_34$$23, 1, 0);
3002 zephir_array_fast_append(&_34$$23, &preCondition);
3003 zephir_array_update_string(&_33$$23, SL("conditions"), &_34$$23, PH_COPY | PH_SEPARATE);
3004 zephir_array_append(&sqlJoins, &_33$$23, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1803);
3005 ZEPHIR_CALL_METHOD(NULL, &joinPrepared, "next", NULL, 0);
3006 zephir_check_call_status();
3007 }
3008 }
3009 ZEPHIR_INIT_NVAR(&_26$$21);
3010 ZEPHIR_INIT_NVAR(&joinAliasName);
3011 RETURN_CTOR(&sqlJoins);
3012 }
3013 ZEPHIR_INIT_NVAR(&fromModels);
3014 array_init(&fromModels);
3015 zephir_is_iterable(&selectTables, 0, "phalcon/Mvc/Model/Query.zep", 1821);
3016 if (Z_TYPE_P(&selectTables) == IS_ARRAY) {
3017 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&selectTables), _35)
3018 {
3019 ZEPHIR_INIT_NVAR(&tableItem);
3020 ZVAL_COPY(&tableItem, _35);
3021 zephir_array_fetch_string(&_37$$24, &tableItem, SL("qualifiedName"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1815);
3022 ZEPHIR_OBS_NVAR(&_38$$24);
3023 zephir_array_fetch_string(&_38$$24, &_37$$24, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1815);
3024 zephir_array_update_zval(&fromModels, &_38$$24, &__$true, PH_COPY | PH_SEPARATE);
3025 } ZEND_HASH_FOREACH_END();
3026 } else {
3027 ZEPHIR_CALL_METHOD(NULL, &selectTables, "rewind", NULL, 0);
3028 zephir_check_call_status();
3029 while (1) {
3030 ZEPHIR_CALL_METHOD(&_36, &selectTables, "valid", NULL, 0);
3031 zephir_check_call_status();
3032 if (!zend_is_true(&_36)) {
3033 break;
3034 }
3035 ZEPHIR_CALL_METHOD(&tableItem, &selectTables, "current", NULL, 0);
3036 zephir_check_call_status();
3037 zephir_array_fetch_string(&_39$$25, &tableItem, SL("qualifiedName"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1815);
3038 ZEPHIR_OBS_NVAR(&_40$$25);
3039 zephir_array_fetch_string(&_40$$25, &_39$$25, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1815);
3040 zephir_array_update_zval(&fromModels, &_40$$25, &__$true, PH_COPY | PH_SEPARATE);
3041 ZEPHIR_CALL_METHOD(NULL, &selectTables, "next", NULL, 0);
3042 zephir_check_call_status();
3043 }
3044 }
3045 ZEPHIR_INIT_NVAR(&tableItem);
3046 ZEPHIR_INIT_VAR(&_41);
3047 zephir_is_iterable(&fromModels, 0, "phalcon/Mvc/Model/Query.zep", 1941);
3048 if (Z_TYPE_P(&fromModels) == IS_ARRAY) {
3049 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&fromModels), _44, _45, _42)
3050 {
3051 ZEPHIR_INIT_NVAR(&fromModelName);
3052 if (_45 != NULL) {
3053 ZVAL_STR_COPY(&fromModelName, _45);
3054 } else {
3055 ZVAL_LONG(&fromModelName, _44);
3056 }
3057 ZEPHIR_INIT_NVAR(&_41);
3058 ZVAL_COPY(&_41, _42);
3059 zephir_is_iterable(&joinModels, 0, "phalcon/Mvc/Model/Query.zep", 1939);
3060 if (Z_TYPE_P(&joinModels) == IS_ARRAY) {
3061 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&joinModels), _48$$26, _49$$26, _46$$26)
3062 {
3063 ZEPHIR_INIT_NVAR(&joinAlias);
3064 if (_49$$26 != NULL) {
3065 ZVAL_STR_COPY(&joinAlias, _49$$26);
3066 } else {
3067 ZVAL_LONG(&joinAlias, _48$$26);
3068 }
3069 ZEPHIR_INIT_NVAR(&joinModel);
3070 ZVAL_COPY(&joinModel, _46$$26);
3071 ZEPHIR_OBS_NVAR(&joinSource);
3072 zephir_array_fetch(&joinSource, &joinSources, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1826);
3073 ZEPHIR_OBS_NVAR(&joinType);
3074 zephir_array_fetch(&joinType, &joinTypes, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1831);
3075 ZEPHIR_OBS_NVAR(&preCondition);
3076 if (!(zephir_array_isset_fetch(&preCondition, &joinPreCondition, &joinAlias, 0))) {
3077 ZEPHIR_OBS_NVAR(&modelNameAlias);
3078 zephir_array_fetch(&modelNameAlias, &sqlAliasesModels, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1840);
3079 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_50, 0, &fromModelName, &modelNameAlias);
3080 zephir_check_call_status();
3081 if (ZEPHIR_IS_FALSE_IDENTICAL(&relation)) {
3082 ZEPHIR_CALL_METHOD(&relations, &manager, "getrelationsbetween", &_51, 0, &fromModelName, &modelNameAlias);
3083 zephir_check_call_status();
3084 if (Z_TYPE_P(&relations) == IS_ARRAY) {
3085 if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) {
3086 ZEPHIR_INIT_NVAR(&_52$$31);
3087 object_init_ex(&_52$$31, phalcon_mvc_model_exception_ce);
3088 zephir_read_property(&_53$$31, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
3089 ZEPHIR_INIT_NVAR(&_54$$31);
3090 ZEPHIR_CONCAT_SVSVSV(&_54$$31, "There is more than one relation between models '", &fromModelName, "' and '", &joinModel, "', the join must be done using an alias, when preparing: ", &_53$$31);
3091 ZEPHIR_CALL_METHOD(NULL, &_52$$31, "__construct", &_8, 8, &_54$$31);
3092 zephir_check_call_status();
3093 zephir_throw_exception_debug(&_52$$31, "phalcon/Mvc/Model/Query.zep", 1866);
3094 ZEPHIR_MM_RESTORE();
3095 return;
3096 }
3097 ZEPHIR_OBS_NVAR(&relation);
3098 zephir_array_fetch_long(&relation, &relations, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1872);
3099 }
3100 }
3101 if (Z_TYPE_P(&relation) == IS_OBJECT) {
3102 ZEPHIR_OBS_NVAR(&modelAlias);
3103 zephir_array_fetch(&modelAlias, &sqlModelsAliases, &fromModelName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1883);
3104 ZEPHIR_CALL_METHOD(&_55$$32, &relation, "isthrough", NULL, 0);
3105 zephir_check_call_status();
3106 if (!(zephir_is_true(&_55$$32))) {
3107 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getsinglejoin", &_56, 482, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3108 zephir_check_call_status();
3109 } else {
3110 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getmultijoin", &_57, 483, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3111 zephir_check_call_status();
3112 }
3113 if (zephir_array_isset_long(&sqlJoin, 0)) {
3114 zephir_is_iterable(&sqlJoin, 0, "phalcon/Mvc/Model/Query.zep", 1913);
3115 if (Z_TYPE_P(&sqlJoin) == IS_ARRAY) {
3116 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&sqlJoin), _58$$35)
3117 {
3118 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3119 ZVAL_COPY(&sqlJoinItem, _58$$35);
3120 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3121 } ZEND_HASH_FOREACH_END();
3122 } else {
3123 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "rewind", NULL, 0);
3124 zephir_check_call_status();
3125 while (1) {
3126 ZEPHIR_CALL_METHOD(&_59$$35, &sqlJoin, "valid", NULL, 0);
3127 zephir_check_call_status();
3128 if (!zend_is_true(&_59$$35)) {
3129 break;
3130 }
3131 ZEPHIR_CALL_METHOD(&sqlJoinItem, &sqlJoin, "current", NULL, 0);
3132 zephir_check_call_status();
3133 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3134 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "next", NULL, 0);
3135 zephir_check_call_status();
3136 }
3137 }
3138 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3139 } else {
3140 zephir_array_append(&sqlJoins, &sqlJoin, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1914);
3141 }
3142 } else {
3143 ZEPHIR_INIT_NVAR(&_60$$39);
3144 zephir_create_array(&_60$$39, 3, 0);
3145 zephir_array_update_string(&_60$$39, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3146 zephir_array_update_string(&_60$$39, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3147 ZEPHIR_INIT_NVAR(&_61$$39);
3148 array_init(&_61$$39);
3149 zephir_array_update_string(&_60$$39, SL("conditions"), &_61$$39, PH_COPY | PH_SEPARATE);
3150 zephir_array_append(&sqlJoins, &_60$$39, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1925);
3151 }
3152 } else {
3153 ZEPHIR_INIT_NVAR(&_62$$40);
3154 zephir_create_array(&_62$$40, 3, 0);
3155 zephir_array_update_string(&_62$$40, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3156 zephir_array_update_string(&_62$$40, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3157 ZEPHIR_INIT_NVAR(&_63$$40);
3158 zephir_create_array(&_63$$40, 1, 0);
3159 zephir_array_fast_append(&_63$$40, &preCondition);
3160 zephir_array_update_string(&_62$$40, SL("conditions"), &_63$$40, PH_COPY | PH_SEPARATE);
3161 zephir_array_append(&sqlJoins, &_62$$40, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1936);
3162 }
3163 } ZEND_HASH_FOREACH_END();
3164 } else {
3165 ZEPHIR_CALL_METHOD(NULL, &joinModels, "rewind", NULL, 0);
3166 zephir_check_call_status();
3167 while (1) {
3168 ZEPHIR_CALL_METHOD(&_47$$26, &joinModels, "valid", NULL, 0);
3169 zephir_check_call_status();
3170 if (!zend_is_true(&_47$$26)) {
3171 break;
3172 }
3173 ZEPHIR_CALL_METHOD(&joinAlias, &joinModels, "key", NULL, 0);
3174 zephir_check_call_status();
3175 ZEPHIR_CALL_METHOD(&joinModel, &joinModels, "current", NULL, 0);
3176 zephir_check_call_status();
3177 ZEPHIR_OBS_NVAR(&joinSource);
3178 zephir_array_fetch(&joinSource, &joinSources, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1826);
3179 ZEPHIR_OBS_NVAR(&joinType);
3180 zephir_array_fetch(&joinType, &joinTypes, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1831);
3181 ZEPHIR_OBS_NVAR(&preCondition);
3182 if (!(zephir_array_isset_fetch(&preCondition, &joinPreCondition, &joinAlias, 0))) {
3183 ZEPHIR_OBS_NVAR(&modelNameAlias);
3184 zephir_array_fetch(&modelNameAlias, &sqlAliasesModels, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1840);
3185 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_64, 0, &fromModelName, &modelNameAlias);
3186 zephir_check_call_status();
3187 if (ZEPHIR_IS_FALSE_IDENTICAL(&relation)) {
3188 ZEPHIR_CALL_METHOD(&relations, &manager, "getrelationsbetween", &_65, 0, &fromModelName, &modelNameAlias);
3189 zephir_check_call_status();
3190 if (Z_TYPE_P(&relations) == IS_ARRAY) {
3191 if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) {
3192 ZEPHIR_INIT_NVAR(&_66$$45);
3193 object_init_ex(&_66$$45, phalcon_mvc_model_exception_ce);
3194 zephir_read_property(&_67$$45, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
3195 ZEPHIR_INIT_NVAR(&_68$$45);
3196 ZEPHIR_CONCAT_SVSVSV(&_68$$45, "There is more than one relation between models '", &fromModelName, "' and '", &joinModel, "', the join must be done using an alias, when preparing: ", &_67$$45);
3197 ZEPHIR_CALL_METHOD(NULL, &_66$$45, "__construct", &_8, 8, &_68$$45);
3198 zephir_check_call_status();
3199 zephir_throw_exception_debug(&_66$$45, "phalcon/Mvc/Model/Query.zep", 1866);
3200 ZEPHIR_MM_RESTORE();
3201 return;
3202 }
3203 ZEPHIR_OBS_NVAR(&relation);
3204 zephir_array_fetch_long(&relation, &relations, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1872);
3205 }
3206 }
3207 if (Z_TYPE_P(&relation) == IS_OBJECT) {
3208 ZEPHIR_OBS_NVAR(&modelAlias);
3209 zephir_array_fetch(&modelAlias, &sqlModelsAliases, &fromModelName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1883);
3210 ZEPHIR_CALL_METHOD(&_69$$46, &relation, "isthrough", NULL, 0);
3211 zephir_check_call_status();
3212 if (!(zephir_is_true(&_69$$46))) {
3213 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getsinglejoin", &_56, 482, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3214 zephir_check_call_status();
3215 } else {
3216 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getmultijoin", &_57, 483, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3217 zephir_check_call_status();
3218 }
3219 if (zephir_array_isset_long(&sqlJoin, 0)) {
3220 zephir_is_iterable(&sqlJoin, 0, "phalcon/Mvc/Model/Query.zep", 1913);
3221 if (Z_TYPE_P(&sqlJoin) == IS_ARRAY) {
3222 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&sqlJoin), _70$$49)
3223 {
3224 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3225 ZVAL_COPY(&sqlJoinItem, _70$$49);
3226 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3227 } ZEND_HASH_FOREACH_END();
3228 } else {
3229 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "rewind", NULL, 0);
3230 zephir_check_call_status();
3231 while (1) {
3232 ZEPHIR_CALL_METHOD(&_71$$49, &sqlJoin, "valid", NULL, 0);
3233 zephir_check_call_status();
3234 if (!zend_is_true(&_71$$49)) {
3235 break;
3236 }
3237 ZEPHIR_CALL_METHOD(&sqlJoinItem, &sqlJoin, "current", NULL, 0);
3238 zephir_check_call_status();
3239 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3240 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "next", NULL, 0);
3241 zephir_check_call_status();
3242 }
3243 }
3244 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3245 } else {
3246 zephir_array_append(&sqlJoins, &sqlJoin, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1914);
3247 }
3248 } else {
3249 ZEPHIR_INIT_NVAR(&_72$$53);
3250 zephir_create_array(&_72$$53, 3, 0);
3251 zephir_array_update_string(&_72$$53, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3252 zephir_array_update_string(&_72$$53, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3253 ZEPHIR_INIT_NVAR(&_73$$53);
3254 array_init(&_73$$53);
3255 zephir_array_update_string(&_72$$53, SL("conditions"), &_73$$53, PH_COPY | PH_SEPARATE);
3256 zephir_array_append(&sqlJoins, &_72$$53, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1925);
3257 }
3258 } else {
3259 ZEPHIR_INIT_NVAR(&_74$$54);
3260 zephir_create_array(&_74$$54, 3, 0);
3261 zephir_array_update_string(&_74$$54, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3262 zephir_array_update_string(&_74$$54, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3263 ZEPHIR_INIT_NVAR(&_75$$54);
3264 zephir_create_array(&_75$$54, 1, 0);
3265 zephir_array_fast_append(&_75$$54, &preCondition);
3266 zephir_array_update_string(&_74$$54, SL("conditions"), &_75$$54, PH_COPY | PH_SEPARATE);
3267 zephir_array_append(&sqlJoins, &_74$$54, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1936);
3268 }
3269 ZEPHIR_CALL_METHOD(NULL, &joinModels, "next", NULL, 0);
3270 zephir_check_call_status();
3271 }
3272 }
3273 ZEPHIR_INIT_NVAR(&joinModel);
3274 ZEPHIR_INIT_NVAR(&joinAlias);
3275 } ZEND_HASH_FOREACH_END();
3276 } else {
3277 ZEPHIR_CALL_METHOD(NULL, &fromModels, "rewind", NULL, 0);
3278 zephir_check_call_status();
3279 while (1) {
3280 ZEPHIR_CALL_METHOD(&_43, &fromModels, "valid", NULL, 0);
3281 zephir_check_call_status();
3282 if (!zend_is_true(&_43)) {
3283 break;
3284 }
3285 ZEPHIR_CALL_METHOD(&fromModelName, &fromModels, "key", NULL, 0);
3286 zephir_check_call_status();
3287 ZEPHIR_CALL_METHOD(&_41, &fromModels, "current", NULL, 0);
3288 zephir_check_call_status();
3289 zephir_is_iterable(&joinModels, 0, "phalcon/Mvc/Model/Query.zep", 1939);
3290 if (Z_TYPE_P(&joinModels) == IS_ARRAY) {
3291 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&joinModels), _78$$55, _79$$55, _76$$55)
3292 {
3293 ZEPHIR_INIT_NVAR(&joinAlias);
3294 if (_79$$55 != NULL) {
3295 ZVAL_STR_COPY(&joinAlias, _79$$55);
3296 } else {
3297 ZVAL_LONG(&joinAlias, _78$$55);
3298 }
3299 ZEPHIR_INIT_NVAR(&joinModel);
3300 ZVAL_COPY(&joinModel, _76$$55);
3301 ZEPHIR_OBS_NVAR(&joinSource);
3302 zephir_array_fetch(&joinSource, &joinSources, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1826);
3303 ZEPHIR_OBS_NVAR(&joinType);
3304 zephir_array_fetch(&joinType, &joinTypes, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1831);
3305 ZEPHIR_OBS_NVAR(&preCondition);
3306 if (!(zephir_array_isset_fetch(&preCondition, &joinPreCondition, &joinAlias, 0))) {
3307 ZEPHIR_OBS_NVAR(&modelNameAlias);
3308 zephir_array_fetch(&modelNameAlias, &sqlAliasesModels, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1840);
3309 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_80, 0, &fromModelName, &modelNameAlias);
3310 zephir_check_call_status();
3311 if (ZEPHIR_IS_FALSE_IDENTICAL(&relation)) {
3312 ZEPHIR_CALL_METHOD(&relations, &manager, "getrelationsbetween", &_81, 0, &fromModelName, &modelNameAlias);
3313 zephir_check_call_status();
3314 if (Z_TYPE_P(&relations) == IS_ARRAY) {
3315 if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) {
3316 ZEPHIR_INIT_NVAR(&_82$$60);
3317 object_init_ex(&_82$$60, phalcon_mvc_model_exception_ce);
3318 zephir_read_property(&_83$$60, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
3319 ZEPHIR_INIT_NVAR(&_84$$60);
3320 ZEPHIR_CONCAT_SVSVSV(&_84$$60, "There is more than one relation between models '", &fromModelName, "' and '", &joinModel, "', the join must be done using an alias, when preparing: ", &_83$$60);
3321 ZEPHIR_CALL_METHOD(NULL, &_82$$60, "__construct", &_8, 8, &_84$$60);
3322 zephir_check_call_status();
3323 zephir_throw_exception_debug(&_82$$60, "phalcon/Mvc/Model/Query.zep", 1866);
3324 ZEPHIR_MM_RESTORE();
3325 return;
3326 }
3327 ZEPHIR_OBS_NVAR(&relation);
3328 zephir_array_fetch_long(&relation, &relations, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1872);
3329 }
3330 }
3331 if (Z_TYPE_P(&relation) == IS_OBJECT) {
3332 ZEPHIR_OBS_NVAR(&modelAlias);
3333 zephir_array_fetch(&modelAlias, &sqlModelsAliases, &fromModelName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1883);
3334 ZEPHIR_CALL_METHOD(&_85$$61, &relation, "isthrough", NULL, 0);
3335 zephir_check_call_status();
3336 if (!(zephir_is_true(&_85$$61))) {
3337 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getsinglejoin", &_56, 482, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3338 zephir_check_call_status();
3339 } else {
3340 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getmultijoin", &_57, 483, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3341 zephir_check_call_status();
3342 }
3343 if (zephir_array_isset_long(&sqlJoin, 0)) {
3344 zephir_is_iterable(&sqlJoin, 0, "phalcon/Mvc/Model/Query.zep", 1913);
3345 if (Z_TYPE_P(&sqlJoin) == IS_ARRAY) {
3346 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&sqlJoin), _86$$64)
3347 {
3348 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3349 ZVAL_COPY(&sqlJoinItem, _86$$64);
3350 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3351 } ZEND_HASH_FOREACH_END();
3352 } else {
3353 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "rewind", NULL, 0);
3354 zephir_check_call_status();
3355 while (1) {
3356 ZEPHIR_CALL_METHOD(&_87$$64, &sqlJoin, "valid", NULL, 0);
3357 zephir_check_call_status();
3358 if (!zend_is_true(&_87$$64)) {
3359 break;
3360 }
3361 ZEPHIR_CALL_METHOD(&sqlJoinItem, &sqlJoin, "current", NULL, 0);
3362 zephir_check_call_status();
3363 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3364 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "next", NULL, 0);
3365 zephir_check_call_status();
3366 }
3367 }
3368 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3369 } else {
3370 zephir_array_append(&sqlJoins, &sqlJoin, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1914);
3371 }
3372 } else {
3373 ZEPHIR_INIT_NVAR(&_88$$68);
3374 zephir_create_array(&_88$$68, 3, 0);
3375 zephir_array_update_string(&_88$$68, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3376 zephir_array_update_string(&_88$$68, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3377 ZEPHIR_INIT_NVAR(&_89$$68);
3378 array_init(&_89$$68);
3379 zephir_array_update_string(&_88$$68, SL("conditions"), &_89$$68, PH_COPY | PH_SEPARATE);
3380 zephir_array_append(&sqlJoins, &_88$$68, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1925);
3381 }
3382 } else {
3383 ZEPHIR_INIT_NVAR(&_90$$69);
3384 zephir_create_array(&_90$$69, 3, 0);
3385 zephir_array_update_string(&_90$$69, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3386 zephir_array_update_string(&_90$$69, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3387 ZEPHIR_INIT_NVAR(&_91$$69);
3388 zephir_create_array(&_91$$69, 1, 0);
3389 zephir_array_fast_append(&_91$$69, &preCondition);
3390 zephir_array_update_string(&_90$$69, SL("conditions"), &_91$$69, PH_COPY | PH_SEPARATE);
3391 zephir_array_append(&sqlJoins, &_90$$69, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1936);
3392 }
3393 } ZEND_HASH_FOREACH_END();
3394 } else {
3395 ZEPHIR_CALL_METHOD(NULL, &joinModels, "rewind", NULL, 0);
3396 zephir_check_call_status();
3397 while (1) {
3398 ZEPHIR_CALL_METHOD(&_77$$55, &joinModels, "valid", NULL, 0);
3399 zephir_check_call_status();
3400 if (!zend_is_true(&_77$$55)) {
3401 break;
3402 }
3403 ZEPHIR_CALL_METHOD(&joinAlias, &joinModels, "key", NULL, 0);
3404 zephir_check_call_status();
3405 ZEPHIR_CALL_METHOD(&joinModel, &joinModels, "current", NULL, 0);
3406 zephir_check_call_status();
3407 ZEPHIR_OBS_NVAR(&joinSource);
3408 zephir_array_fetch(&joinSource, &joinSources, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1826);
3409 ZEPHIR_OBS_NVAR(&joinType);
3410 zephir_array_fetch(&joinType, &joinTypes, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1831);
3411 ZEPHIR_OBS_NVAR(&preCondition);
3412 if (!(zephir_array_isset_fetch(&preCondition, &joinPreCondition, &joinAlias, 0))) {
3413 ZEPHIR_OBS_NVAR(&modelNameAlias);
3414 zephir_array_fetch(&modelNameAlias, &sqlAliasesModels, &joinAlias, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1840);
3415 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_92, 0, &fromModelName, &modelNameAlias);
3416 zephir_check_call_status();
3417 if (ZEPHIR_IS_FALSE_IDENTICAL(&relation)) {
3418 ZEPHIR_CALL_METHOD(&relations, &manager, "getrelationsbetween", &_93, 0, &fromModelName, &modelNameAlias);
3419 zephir_check_call_status();
3420 if (Z_TYPE_P(&relations) == IS_ARRAY) {
3421 if (UNEXPECTED(zephir_fast_count_int(&relations) != 1)) {
3422 ZEPHIR_INIT_NVAR(&_94$$74);
3423 object_init_ex(&_94$$74, phalcon_mvc_model_exception_ce);
3424 zephir_read_property(&_95$$74, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
3425 ZEPHIR_INIT_NVAR(&_96$$74);
3426 ZEPHIR_CONCAT_SVSVSV(&_96$$74, "There is more than one relation between models '", &fromModelName, "' and '", &joinModel, "', the join must be done using an alias, when preparing: ", &_95$$74);
3427 ZEPHIR_CALL_METHOD(NULL, &_94$$74, "__construct", &_8, 8, &_96$$74);
3428 zephir_check_call_status();
3429 zephir_throw_exception_debug(&_94$$74, "phalcon/Mvc/Model/Query.zep", 1866);
3430 ZEPHIR_MM_RESTORE();
3431 return;
3432 }
3433 ZEPHIR_OBS_NVAR(&relation);
3434 zephir_array_fetch_long(&relation, &relations, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1872);
3435 }
3436 }
3437 if (Z_TYPE_P(&relation) == IS_OBJECT) {
3438 ZEPHIR_OBS_NVAR(&modelAlias);
3439 zephir_array_fetch(&modelAlias, &sqlModelsAliases, &fromModelName, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 1883);
3440 ZEPHIR_CALL_METHOD(&_97$$75, &relation, "isthrough", NULL, 0);
3441 zephir_check_call_status();
3442 if (!(zephir_is_true(&_97$$75))) {
3443 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getsinglejoin", &_56, 482, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3444 zephir_check_call_status();
3445 } else {
3446 ZEPHIR_CALL_METHOD(&sqlJoin, this_ptr, "_getmultijoin", &_57, 483, &joinType, &joinSource, &modelAlias, &joinAlias, &relation);
3447 zephir_check_call_status();
3448 }
3449 if (zephir_array_isset_long(&sqlJoin, 0)) {
3450 zephir_is_iterable(&sqlJoin, 0, "phalcon/Mvc/Model/Query.zep", 1913);
3451 if (Z_TYPE_P(&sqlJoin) == IS_ARRAY) {
3452 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&sqlJoin), _98$$78)
3453 {
3454 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3455 ZVAL_COPY(&sqlJoinItem, _98$$78);
3456 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3457 } ZEND_HASH_FOREACH_END();
3458 } else {
3459 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "rewind", NULL, 0);
3460 zephir_check_call_status();
3461 while (1) {
3462 ZEPHIR_CALL_METHOD(&_99$$78, &sqlJoin, "valid", NULL, 0);
3463 zephir_check_call_status();
3464 if (!zend_is_true(&_99$$78)) {
3465 break;
3466 }
3467 ZEPHIR_CALL_METHOD(&sqlJoinItem, &sqlJoin, "current", NULL, 0);
3468 zephir_check_call_status();
3469 zephir_array_append(&sqlJoins, &sqlJoinItem, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1911);
3470 ZEPHIR_CALL_METHOD(NULL, &sqlJoin, "next", NULL, 0);
3471 zephir_check_call_status();
3472 }
3473 }
3474 ZEPHIR_INIT_NVAR(&sqlJoinItem);
3475 } else {
3476 zephir_array_append(&sqlJoins, &sqlJoin, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1914);
3477 }
3478 } else {
3479 ZEPHIR_INIT_NVAR(&_100$$82);
3480 zephir_create_array(&_100$$82, 3, 0);
3481 zephir_array_update_string(&_100$$82, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3482 zephir_array_update_string(&_100$$82, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3483 ZEPHIR_INIT_NVAR(&_101$$82);
3484 array_init(&_101$$82);
3485 zephir_array_update_string(&_100$$82, SL("conditions"), &_101$$82, PH_COPY | PH_SEPARATE);
3486 zephir_array_append(&sqlJoins, &_100$$82, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1925);
3487 }
3488 } else {
3489 ZEPHIR_INIT_NVAR(&_102$$83);
3490 zephir_create_array(&_102$$83, 3, 0);
3491 zephir_array_update_string(&_102$$83, SL("type"), &joinType, PH_COPY | PH_SEPARATE);
3492 zephir_array_update_string(&_102$$83, SL("source"), &joinSource, PH_COPY | PH_SEPARATE);
3493 ZEPHIR_INIT_NVAR(&_103$$83);
3494 zephir_create_array(&_103$$83, 1, 0);
3495 zephir_array_fast_append(&_103$$83, &preCondition);
3496 zephir_array_update_string(&_102$$83, SL("conditions"), &_103$$83, PH_COPY | PH_SEPARATE);
3497 zephir_array_append(&sqlJoins, &_102$$83, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1936);
3498 }
3499 ZEPHIR_CALL_METHOD(NULL, &joinModels, "next", NULL, 0);
3500 zephir_check_call_status();
3501 }
3502 }
3503 ZEPHIR_INIT_NVAR(&joinModel);
3504 ZEPHIR_INIT_NVAR(&joinAlias);
3505 ZEPHIR_CALL_METHOD(NULL, &fromModels, "next", NULL, 0);
3506 zephir_check_call_status();
3507 }
3508 }
3509 ZEPHIR_INIT_NVAR(&_41);
3510 ZEPHIR_INIT_NVAR(&fromModelName);
3511 RETURN_CTOR(&sqlJoins);
3512
3513 }
3514
3515 /**
3516 * Returns a processed order clause for a SELECT statement
3517 *
3518 * @param array|string order
3519 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getOrderClause)3520 PHP_METHOD(Phalcon_Mvc_Model_Query, _getOrderClause) {
3521
3522 zval orderParts, orderPartSort;
3523 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
3524 zephir_fcall_cache_entry *_3 = NULL;
3525 zend_long ZEPHIR_LAST_CALL_STATUS;
3526 zval *order, order_sub, orderColumns, orderItem, orderPartExpr, orderSort, *_0, _1, _2$$5, _4$$7, _5$$8, _6$$8, _7$$9, _8$$10, _9$$12, _10$$12, _11$$13, _12$$13, _13$$14;
3527 zval *this_ptr = getThis();
3528
3529 ZVAL_UNDEF(&order_sub);
3530 ZVAL_UNDEF(&orderColumns);
3531 ZVAL_UNDEF(&orderItem);
3532 ZVAL_UNDEF(&orderPartExpr);
3533 ZVAL_UNDEF(&orderSort);
3534 ZVAL_UNDEF(&_1);
3535 ZVAL_UNDEF(&_2$$5);
3536 ZVAL_UNDEF(&_4$$7);
3537 ZVAL_UNDEF(&_5$$8);
3538 ZVAL_UNDEF(&_6$$8);
3539 ZVAL_UNDEF(&_7$$9);
3540 ZVAL_UNDEF(&_8$$10);
3541 ZVAL_UNDEF(&_9$$12);
3542 ZVAL_UNDEF(&_10$$12);
3543 ZVAL_UNDEF(&_11$$13);
3544 ZVAL_UNDEF(&_12$$13);
3545 ZVAL_UNDEF(&_13$$14);
3546 ZVAL_UNDEF(&orderParts);
3547 ZVAL_UNDEF(&orderPartSort);
3548
3549 ZEPHIR_MM_GROW();
3550 zephir_fetch_params(1, 1, 0, &order);
3551
3552
3553
3554 if (!(zephir_array_isset_long(order, 0))) {
3555 ZEPHIR_INIT_VAR(&orderColumns);
3556 zephir_create_array(&orderColumns, 1, 0);
3557 zephir_array_fast_append(&orderColumns, order);
3558 } else {
3559 ZEPHIR_CPY_WRT(&orderColumns, order);
3560 }
3561 ZEPHIR_INIT_VAR(&orderParts);
3562 array_init(&orderParts);
3563 zephir_is_iterable(&orderColumns, 0, "phalcon/Mvc/Model/Query.zep", 1983);
3564 if (Z_TYPE_P(&orderColumns) == IS_ARRAY) {
3565 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&orderColumns), _0)
3566 {
3567 ZEPHIR_INIT_NVAR(&orderItem);
3568 ZVAL_COPY(&orderItem, _0);
3569 zephir_array_fetch_string(&_2$$5, &orderItem, SL("column"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1965);
3570 ZEPHIR_CALL_METHOD(&orderPartExpr, this_ptr, "_getexpression", &_3, 474, &_2$$5);
3571 zephir_check_call_status();
3572 if (zephir_array_isset_string_fetch(&orderSort, &orderItem, SL("sort"), 1)) {
3573 if (ZEPHIR_IS_LONG(&orderSort, 327)) {
3574 ZEPHIR_INIT_NVAR(&orderPartSort);
3575 zephir_create_array(&orderPartSort, 2, 0);
3576 zephir_array_fast_append(&orderPartSort, &orderPartExpr);
3577 ZEPHIR_INIT_NVAR(&_4$$7);
3578 ZVAL_STRING(&_4$$7, "ASC");
3579 zephir_array_fast_append(&orderPartSort, &_4$$7);
3580 } else {
3581 ZEPHIR_INIT_NVAR(&_5$$8);
3582 zephir_create_array(&_5$$8, 2, 0);
3583 zephir_array_fast_append(&_5$$8, &orderPartExpr);
3584 ZEPHIR_INIT_NVAR(&_6$$8);
3585 ZVAL_STRING(&_6$$8, "DESC");
3586 zephir_array_fast_append(&_5$$8, &_6$$8);
3587 ZEPHIR_CPY_WRT(&orderPartSort, &_5$$8);
3588 }
3589 } else {
3590 ZEPHIR_INIT_NVAR(&_7$$9);
3591 zephir_create_array(&_7$$9, 1, 0);
3592 zephir_array_fast_append(&_7$$9, &orderPartExpr);
3593 ZEPHIR_CPY_WRT(&orderPartSort, &_7$$9);
3594 }
3595 zephir_array_append(&orderParts, &orderPartSort, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1980);
3596 } ZEND_HASH_FOREACH_END();
3597 } else {
3598 ZEPHIR_CALL_METHOD(NULL, &orderColumns, "rewind", NULL, 0);
3599 zephir_check_call_status();
3600 while (1) {
3601 ZEPHIR_CALL_METHOD(&_1, &orderColumns, "valid", NULL, 0);
3602 zephir_check_call_status();
3603 if (!zend_is_true(&_1)) {
3604 break;
3605 }
3606 ZEPHIR_CALL_METHOD(&orderItem, &orderColumns, "current", NULL, 0);
3607 zephir_check_call_status();
3608 zephir_array_fetch_string(&_8$$10, &orderItem, SL("column"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 1965);
3609 ZEPHIR_CALL_METHOD(&orderPartExpr, this_ptr, "_getexpression", &_3, 474, &_8$$10);
3610 zephir_check_call_status();
3611 ZEPHIR_OBS_NVAR(&orderSort);
3612 if (zephir_array_isset_string_fetch(&orderSort, &orderItem, SL("sort"), 0)) {
3613 if (ZEPHIR_IS_LONG(&orderSort, 327)) {
3614 ZEPHIR_INIT_NVAR(&_9$$12);
3615 zephir_create_array(&_9$$12, 2, 0);
3616 zephir_array_fast_append(&_9$$12, &orderPartExpr);
3617 ZEPHIR_INIT_NVAR(&_10$$12);
3618 ZVAL_STRING(&_10$$12, "ASC");
3619 zephir_array_fast_append(&_9$$12, &_10$$12);
3620 ZEPHIR_CPY_WRT(&orderPartSort, &_9$$12);
3621 } else {
3622 ZEPHIR_INIT_NVAR(&_11$$13);
3623 zephir_create_array(&_11$$13, 2, 0);
3624 zephir_array_fast_append(&_11$$13, &orderPartExpr);
3625 ZEPHIR_INIT_NVAR(&_12$$13);
3626 ZVAL_STRING(&_12$$13, "DESC");
3627 zephir_array_fast_append(&_11$$13, &_12$$13);
3628 ZEPHIR_CPY_WRT(&orderPartSort, &_11$$13);
3629 }
3630 } else {
3631 ZEPHIR_INIT_NVAR(&_13$$14);
3632 zephir_create_array(&_13$$14, 1, 0);
3633 zephir_array_fast_append(&_13$$14, &orderPartExpr);
3634 ZEPHIR_CPY_WRT(&orderPartSort, &_13$$14);
3635 }
3636 zephir_array_append(&orderParts, &orderPartSort, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 1980);
3637 ZEPHIR_CALL_METHOD(NULL, &orderColumns, "next", NULL, 0);
3638 zephir_check_call_status();
3639 }
3640 }
3641 ZEPHIR_INIT_NVAR(&orderItem);
3642 RETURN_CTOR(&orderParts);
3643
3644 }
3645
3646 /**
3647 * Returns a processed group clause for a SELECT statement
3648 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getGroupClause)3649 PHP_METHOD(Phalcon_Mvc_Model_Query, _getGroupClause) {
3650
3651 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
3652 zephir_fcall_cache_entry *_3 = NULL;
3653 zend_long ZEPHIR_LAST_CALL_STATUS;
3654 zval *group_param = NULL, groupItem, *_0$$3, _1$$3, _2$$4, _4$$5, _5$$6, _6$$6;
3655 zval group, groupParts;
3656 zval *this_ptr = getThis();
3657
3658 ZVAL_UNDEF(&group);
3659 ZVAL_UNDEF(&groupParts);
3660 ZVAL_UNDEF(&groupItem);
3661 ZVAL_UNDEF(&_1$$3);
3662 ZVAL_UNDEF(&_2$$4);
3663 ZVAL_UNDEF(&_4$$5);
3664 ZVAL_UNDEF(&_5$$6);
3665 ZVAL_UNDEF(&_6$$6);
3666
3667 ZEPHIR_MM_GROW();
3668 zephir_fetch_params(1, 1, 0, &group_param);
3669
3670 ZEPHIR_OBS_COPY_OR_DUP(&group, group_param);
3671
3672
3673 if (zephir_array_isset_long(&group, 0)) {
3674 ZEPHIR_INIT_VAR(&groupParts);
3675 array_init(&groupParts);
3676 zephir_is_iterable(&group, 0, "phalcon/Mvc/Model/Query.zep", 2003);
3677 if (Z_TYPE_P(&group) == IS_ARRAY) {
3678 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&group), _0$$3)
3679 {
3680 ZEPHIR_INIT_NVAR(&groupItem);
3681 ZVAL_COPY(&groupItem, _0$$3);
3682 ZEPHIR_CALL_METHOD(&_2$$4, this_ptr, "_getexpression", &_3, 474, &groupItem);
3683 zephir_check_call_status();
3684 zephir_array_append(&groupParts, &_2$$4, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2001);
3685 } ZEND_HASH_FOREACH_END();
3686 } else {
3687 ZEPHIR_CALL_METHOD(NULL, &group, "rewind", NULL, 0);
3688 zephir_check_call_status();
3689 while (1) {
3690 ZEPHIR_CALL_METHOD(&_1$$3, &group, "valid", NULL, 0);
3691 zephir_check_call_status();
3692 if (!zend_is_true(&_1$$3)) {
3693 break;
3694 }
3695 ZEPHIR_CALL_METHOD(&groupItem, &group, "current", NULL, 0);
3696 zephir_check_call_status();
3697 ZEPHIR_CALL_METHOD(&_4$$5, this_ptr, "_getexpression", &_3, 474, &groupItem);
3698 zephir_check_call_status();
3699 zephir_array_append(&groupParts, &_4$$5, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2001);
3700 ZEPHIR_CALL_METHOD(NULL, &group, "next", NULL, 0);
3701 zephir_check_call_status();
3702 }
3703 }
3704 ZEPHIR_INIT_NVAR(&groupItem);
3705 } else {
3706 ZEPHIR_INIT_VAR(&_5$$6);
3707 zephir_create_array(&_5$$6, 1, 0);
3708 ZEPHIR_CALL_METHOD(&_6$$6, this_ptr, "_getexpression", &_3, 474, &group);
3709 zephir_check_call_status();
3710 zephir_array_fast_append(&_5$$6, &_6$$6);
3711 ZEPHIR_CPY_WRT(&groupParts, &_5$$6);
3712 }
3713 RETURN_CTOR(&groupParts);
3714
3715 }
3716
3717 /**
3718 * Returns a processed limit clause for a SELECT statement
3719 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getLimitClause)3720 PHP_METHOD(Phalcon_Mvc_Model_Query, _getLimitClause) {
3721
3722 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
3723 zend_long ZEPHIR_LAST_CALL_STATUS;
3724 zval *limitClause_param = NULL, number, offset, _0$$3, _1$$4;
3725 zval limitClause, limit;
3726 zval *this_ptr = getThis();
3727
3728 ZVAL_UNDEF(&limitClause);
3729 ZVAL_UNDEF(&limit);
3730 ZVAL_UNDEF(&number);
3731 ZVAL_UNDEF(&offset);
3732 ZVAL_UNDEF(&_0$$3);
3733 ZVAL_UNDEF(&_1$$4);
3734
3735 ZEPHIR_MM_GROW();
3736 zephir_fetch_params(1, 1, 0, &limitClause_param);
3737
3738 ZEPHIR_OBS_COPY_OR_DUP(&limitClause, limitClause_param);
3739
3740
3741 ZEPHIR_INIT_VAR(&limit);
3742 array_init(&limit);
3743 ZEPHIR_OBS_VAR(&number);
3744 if (zephir_array_isset_string_fetch(&number, &limitClause, SL("number"), 0)) {
3745 ZEPHIR_CALL_METHOD(&_0$$3, this_ptr, "_getexpression", NULL, 474, &number);
3746 zephir_check_call_status();
3747 zephir_array_update_string(&limit, SL("number"), &_0$$3, PH_COPY | PH_SEPARATE);
3748 }
3749 ZEPHIR_OBS_VAR(&offset);
3750 if (zephir_array_isset_string_fetch(&offset, &limitClause, SL("offset"), 0)) {
3751 ZEPHIR_CALL_METHOD(&_1$$4, this_ptr, "_getexpression", NULL, 474, &offset);
3752 zephir_check_call_status();
3753 zephir_array_update_string(&limit, SL("offset"), &_1$$4, PH_COPY | PH_SEPARATE);
3754 }
3755 RETURN_CTOR(&limit);
3756
3757 }
3758
3759 /**
3760 * Analyzes a SELECT intermediate code and produces an array to be executed later
3761 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_prepareSelect)3762 PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareSelect) {
3763
3764 zval _13$$24, _25$$28, _46$$43, _58$$47, _90$$66, _93$$73, _99$$81, _102$$88;
3765 zval sqlModels, sqlTables, sqlAliases, sqlColumns, sqlAliasesModels, sqlModelsAliases, sqlAliasesModelsInstances, models, modelsInstances, _21$$24, _22$$24, _23$$24, _33$$28, _34$$28, _35$$28, _54$$43, _55$$43, _56$$43, _66$$47, _67$$47, _68$$47;
3766 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
3767 zephir_fcall_cache_entry *_4 = NULL, *_8 = NULL, *_14 = NULL, *_16 = NULL, *_26 = NULL, *_28 = NULL, *_36 = NULL, *_47 = NULL, *_49 = NULL, *_59 = NULL, *_61 = NULL, *_85 = NULL;
3768 zend_long ZEPHIR_LAST_CALL_STATUS, position = 0, number = 0;
3769 zend_bool merge;
3770 zval *ast = NULL, ast_sub, *merge_param = NULL, __$null, __$true, select, tables, columns, selectedModels, manager, metaData, selectedModel, qualifiedName, modelName, model, schema, source, completeSource, alias, joins, sqlJoins, selectColumns, sqlColumnAliases, column, sqlColumn, sqlSelect, distinct, having, where, groupBy, order, limit, tempModels, tempModelsInstances, tempSqlAliases, tempSqlModelsAliases, tempSqlAliasesModelsInstances, tempSqlAliasesModels, with, withs, withItem, automaticJoins, relation, joinAlias, relationModel, bestAlias, eagerType, _1, *_2, _3, *_82, _83, _103, _0$$3, _5$$17, _6$$17, _7$$17, _9$$19, *_10$$21, _11$$21, _12$$24, _15$$25, _17$$27, _18$$27, _19$$27, _20$$26, _24$$28, _27$$29, _29$$31, _30$$31, _31$$31, _32$$30, _37$$33, _38$$36, _39$$36, _40$$36, _41$$38, _42$$41, *_43$$40, _44$$40, _45$$43, _48$$44, _50$$46, _51$$46, _52$$46, _53$$45, _57$$47, _60$$48, _62$$50, _63$$50, _64$$50, _65$$49, _69$$52, _70$$52, _71$$52, _72$$52, _73$$52, _74$$52, _75$$52, _76$$52, _77$$52, _78$$52, _79$$52, _80$$52, _81$$55, _84$$60, *_86$$60, _87$$60, _88$$65, _89$$66, _91$$72, _92$$73, _94$$75, *_95$$75, _96$$75, _97$$80, _98$$81, _100$$87, _101$$88, _104$$92, _105$$93, _106$$94, _107$$95, _108$$96;
3771 zval *this_ptr = getThis();
3772
3773 ZVAL_UNDEF(&ast_sub);
3774 ZVAL_NULL(&__$null);
3775 ZVAL_BOOL(&__$true, 1);
3776 ZVAL_UNDEF(&select);
3777 ZVAL_UNDEF(&tables);
3778 ZVAL_UNDEF(&columns);
3779 ZVAL_UNDEF(&selectedModels);
3780 ZVAL_UNDEF(&manager);
3781 ZVAL_UNDEF(&metaData);
3782 ZVAL_UNDEF(&selectedModel);
3783 ZVAL_UNDEF(&qualifiedName);
3784 ZVAL_UNDEF(&modelName);
3785 ZVAL_UNDEF(&model);
3786 ZVAL_UNDEF(&schema);
3787 ZVAL_UNDEF(&source);
3788 ZVAL_UNDEF(&completeSource);
3789 ZVAL_UNDEF(&alias);
3790 ZVAL_UNDEF(&joins);
3791 ZVAL_UNDEF(&sqlJoins);
3792 ZVAL_UNDEF(&selectColumns);
3793 ZVAL_UNDEF(&sqlColumnAliases);
3794 ZVAL_UNDEF(&column);
3795 ZVAL_UNDEF(&sqlColumn);
3796 ZVAL_UNDEF(&sqlSelect);
3797 ZVAL_UNDEF(&distinct);
3798 ZVAL_UNDEF(&having);
3799 ZVAL_UNDEF(&where);
3800 ZVAL_UNDEF(&groupBy);
3801 ZVAL_UNDEF(&order);
3802 ZVAL_UNDEF(&limit);
3803 ZVAL_UNDEF(&tempModels);
3804 ZVAL_UNDEF(&tempModelsInstances);
3805 ZVAL_UNDEF(&tempSqlAliases);
3806 ZVAL_UNDEF(&tempSqlModelsAliases);
3807 ZVAL_UNDEF(&tempSqlAliasesModelsInstances);
3808 ZVAL_UNDEF(&tempSqlAliasesModels);
3809 ZVAL_UNDEF(&with);
3810 ZVAL_UNDEF(&withs);
3811 ZVAL_UNDEF(&withItem);
3812 ZVAL_UNDEF(&automaticJoins);
3813 ZVAL_UNDEF(&relation);
3814 ZVAL_UNDEF(&joinAlias);
3815 ZVAL_UNDEF(&relationModel);
3816 ZVAL_UNDEF(&bestAlias);
3817 ZVAL_UNDEF(&eagerType);
3818 ZVAL_UNDEF(&_1);
3819 ZVAL_UNDEF(&_3);
3820 ZVAL_UNDEF(&_83);
3821 ZVAL_UNDEF(&_103);
3822 ZVAL_UNDEF(&_0$$3);
3823 ZVAL_UNDEF(&_5$$17);
3824 ZVAL_UNDEF(&_6$$17);
3825 ZVAL_UNDEF(&_7$$17);
3826 ZVAL_UNDEF(&_9$$19);
3827 ZVAL_UNDEF(&_11$$21);
3828 ZVAL_UNDEF(&_12$$24);
3829 ZVAL_UNDEF(&_15$$25);
3830 ZVAL_UNDEF(&_17$$27);
3831 ZVAL_UNDEF(&_18$$27);
3832 ZVAL_UNDEF(&_19$$27);
3833 ZVAL_UNDEF(&_20$$26);
3834 ZVAL_UNDEF(&_24$$28);
3835 ZVAL_UNDEF(&_27$$29);
3836 ZVAL_UNDEF(&_29$$31);
3837 ZVAL_UNDEF(&_30$$31);
3838 ZVAL_UNDEF(&_31$$31);
3839 ZVAL_UNDEF(&_32$$30);
3840 ZVAL_UNDEF(&_37$$33);
3841 ZVAL_UNDEF(&_38$$36);
3842 ZVAL_UNDEF(&_39$$36);
3843 ZVAL_UNDEF(&_40$$36);
3844 ZVAL_UNDEF(&_41$$38);
3845 ZVAL_UNDEF(&_42$$41);
3846 ZVAL_UNDEF(&_44$$40);
3847 ZVAL_UNDEF(&_45$$43);
3848 ZVAL_UNDEF(&_48$$44);
3849 ZVAL_UNDEF(&_50$$46);
3850 ZVAL_UNDEF(&_51$$46);
3851 ZVAL_UNDEF(&_52$$46);
3852 ZVAL_UNDEF(&_53$$45);
3853 ZVAL_UNDEF(&_57$$47);
3854 ZVAL_UNDEF(&_60$$48);
3855 ZVAL_UNDEF(&_62$$50);
3856 ZVAL_UNDEF(&_63$$50);
3857 ZVAL_UNDEF(&_64$$50);
3858 ZVAL_UNDEF(&_65$$49);
3859 ZVAL_UNDEF(&_69$$52);
3860 ZVAL_UNDEF(&_70$$52);
3861 ZVAL_UNDEF(&_71$$52);
3862 ZVAL_UNDEF(&_72$$52);
3863 ZVAL_UNDEF(&_73$$52);
3864 ZVAL_UNDEF(&_74$$52);
3865 ZVAL_UNDEF(&_75$$52);
3866 ZVAL_UNDEF(&_76$$52);
3867 ZVAL_UNDEF(&_77$$52);
3868 ZVAL_UNDEF(&_78$$52);
3869 ZVAL_UNDEF(&_79$$52);
3870 ZVAL_UNDEF(&_80$$52);
3871 ZVAL_UNDEF(&_81$$55);
3872 ZVAL_UNDEF(&_84$$60);
3873 ZVAL_UNDEF(&_87$$60);
3874 ZVAL_UNDEF(&_88$$65);
3875 ZVAL_UNDEF(&_89$$66);
3876 ZVAL_UNDEF(&_91$$72);
3877 ZVAL_UNDEF(&_92$$73);
3878 ZVAL_UNDEF(&_94$$75);
3879 ZVAL_UNDEF(&_96$$75);
3880 ZVAL_UNDEF(&_97$$80);
3881 ZVAL_UNDEF(&_98$$81);
3882 ZVAL_UNDEF(&_100$$87);
3883 ZVAL_UNDEF(&_101$$88);
3884 ZVAL_UNDEF(&_104$$92);
3885 ZVAL_UNDEF(&_105$$93);
3886 ZVAL_UNDEF(&_106$$94);
3887 ZVAL_UNDEF(&_107$$95);
3888 ZVAL_UNDEF(&_108$$96);
3889 ZVAL_UNDEF(&sqlModels);
3890 ZVAL_UNDEF(&sqlTables);
3891 ZVAL_UNDEF(&sqlAliases);
3892 ZVAL_UNDEF(&sqlColumns);
3893 ZVAL_UNDEF(&sqlAliasesModels);
3894 ZVAL_UNDEF(&sqlModelsAliases);
3895 ZVAL_UNDEF(&sqlAliasesModelsInstances);
3896 ZVAL_UNDEF(&models);
3897 ZVAL_UNDEF(&modelsInstances);
3898 ZVAL_UNDEF(&_21$$24);
3899 ZVAL_UNDEF(&_22$$24);
3900 ZVAL_UNDEF(&_23$$24);
3901 ZVAL_UNDEF(&_33$$28);
3902 ZVAL_UNDEF(&_34$$28);
3903 ZVAL_UNDEF(&_35$$28);
3904 ZVAL_UNDEF(&_54$$43);
3905 ZVAL_UNDEF(&_55$$43);
3906 ZVAL_UNDEF(&_56$$43);
3907 ZVAL_UNDEF(&_66$$47);
3908 ZVAL_UNDEF(&_67$$47);
3909 ZVAL_UNDEF(&_68$$47);
3910 ZVAL_UNDEF(&_13$$24);
3911 ZVAL_UNDEF(&_25$$28);
3912 ZVAL_UNDEF(&_46$$43);
3913 ZVAL_UNDEF(&_58$$47);
3914 ZVAL_UNDEF(&_90$$66);
3915 ZVAL_UNDEF(&_93$$73);
3916 ZVAL_UNDEF(&_99$$81);
3917 ZVAL_UNDEF(&_102$$88);
3918
3919 ZEPHIR_MM_GROW();
3920 zephir_fetch_params(1, 0, 2, &ast, &merge_param);
3921
3922 if (!ast) {
3923 ast = &ast_sub;
3924 ZEPHIR_CPY_WRT(ast, &__$null);
3925 } else {
3926 ZEPHIR_SEPARATE_PARAM(ast);
3927 }
3928 if (!merge_param) {
3929 merge = 0;
3930 } else {
3931 merge = zephir_get_boolval(merge_param);
3932 }
3933
3934
3935 if (ZEPHIR_IS_EMPTY(ast)) {
3936 zephir_read_property(&_0$$3, this_ptr, ZEND_STRL("ast"), PH_NOISY_CC | PH_READONLY);
3937 ZEPHIR_CPY_WRT(ast, &_0$$3);
3938 }
3939 ZEPHIR_OBS_VAR(&select);
3940 if (!(zephir_array_isset_string_fetch(&select, ast, SL("select"), 0))) {
3941 ZEPHIR_CPY_WRT(&select, ast);
3942 }
3943 ZEPHIR_OBS_VAR(&tables);
3944 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&tables, &select, SL("tables"), 0)))) {
3945 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST", "phalcon/Mvc/Model/Query.zep", 2059);
3946 return;
3947 }
3948 ZEPHIR_OBS_VAR(&columns);
3949 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&columns, &select, SL("columns"), 0)))) {
3950 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted SELECT AST", "phalcon/Mvc/Model/Query.zep", 2063);
3951 return;
3952 }
3953 RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("nestingLevel")));
3954 ZEPHIR_INIT_VAR(&sqlModels);
3955 array_init(&sqlModels);
3956 ZEPHIR_INIT_VAR(&sqlTables);
3957 array_init(&sqlTables);
3958 ZEPHIR_INIT_VAR(&sqlColumns);
3959 array_init(&sqlColumns);
3960 ZEPHIR_INIT_VAR(&sqlAliases);
3961 array_init(&sqlAliases);
3962 ZEPHIR_INIT_VAR(&sqlAliasesModels);
3963 array_init(&sqlAliasesModels);
3964 ZEPHIR_INIT_VAR(&sqlModelsAliases);
3965 array_init(&sqlModelsAliases);
3966 ZEPHIR_INIT_VAR(&sqlAliasesModelsInstances);
3967 array_init(&sqlAliasesModelsInstances);
3968 ZEPHIR_INIT_VAR(&models);
3969 array_init(&models);
3970 ZEPHIR_INIT_VAR(&modelsInstances);
3971 array_init(&modelsInstances);
3972 if (!(zephir_array_isset_long(&tables, 0))) {
3973 ZEPHIR_INIT_VAR(&selectedModels);
3974 zephir_create_array(&selectedModels, 1, 0);
3975 zephir_array_fast_append(&selectedModels, &tables);
3976 } else {
3977 ZEPHIR_CPY_WRT(&selectedModels, &tables);
3978 }
3979 if (!(zephir_array_isset_long(&columns, 0))) {
3980 ZEPHIR_INIT_VAR(&selectColumns);
3981 zephir_create_array(&selectColumns, 1, 0);
3982 zephir_array_fast_append(&selectColumns, &columns);
3983 } else {
3984 ZEPHIR_CPY_WRT(&selectColumns, &columns);
3985 }
3986 zephir_read_property(&_1, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
3987 ZEPHIR_CPY_WRT(&manager, &_1);
3988 zephir_read_property(&_1, this_ptr, ZEND_STRL("metaData"), PH_NOISY_CC | PH_READONLY);
3989 ZEPHIR_CPY_WRT(&metaData, &_1);
3990 if (UNEXPECTED(Z_TYPE_P(&manager) != IS_OBJECT)) {
3991 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "A models-manager is required to execute the query", "phalcon/Mvc/Model/Query.zep", 2130);
3992 return;
3993 }
3994 if (UNEXPECTED(Z_TYPE_P(&metaData) != IS_OBJECT)) {
3995 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "A meta-data is required to execute the query", "phalcon/Mvc/Model/Query.zep", 2136);
3996 return;
3997 }
3998 number = 0;
3999 ZEPHIR_INIT_VAR(&automaticJoins);
4000 array_init(&automaticJoins);
4001 zephir_is_iterable(&selectedModels, 0, "phalcon/Mvc/Model/Query.zep", 2266);
4002 if (Z_TYPE_P(&selectedModels) == IS_ARRAY) {
4003 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&selectedModels), _2)
4004 {
4005 ZEPHIR_INIT_NVAR(&selectedModel);
4006 ZVAL_COPY(&selectedModel, _2);
4007 ZEPHIR_OBS_NVAR(&qualifiedName);
4008 zephir_array_fetch_string(&qualifiedName, &selectedModel, SL("qualifiedName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2144);
4009 ZEPHIR_OBS_NVAR(&modelName);
4010 zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2145);
4011 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_4, 0, &modelName);
4012 zephir_check_call_status();
4013 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
4014 zephir_check_call_status();
4015 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
4016 zephir_check_call_status();
4017 if (zephir_is_true(&schema)) {
4018 ZEPHIR_INIT_NVAR(&completeSource);
4019 zephir_create_array(&completeSource, 2, 0);
4020 zephir_array_fast_append(&completeSource, &source);
4021 zephir_array_fast_append(&completeSource, &schema);
4022 } else {
4023 ZEPHIR_CPY_WRT(&completeSource, &source);
4024 }
4025 ZEPHIR_OBS_NVAR(&alias);
4026 if (zephir_array_isset_string_fetch(&alias, &selectedModel, SL("alias"), 0)) {
4027 if (UNEXPECTED(zephir_array_isset(&sqlAliases, &alias))) {
4028 ZEPHIR_INIT_NVAR(&_5$$17);
4029 object_init_ex(&_5$$17, phalcon_mvc_model_exception_ce);
4030 zephir_read_property(&_6$$17, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4031 ZEPHIR_INIT_NVAR(&_7$$17);
4032 ZEPHIR_CONCAT_SVSV(&_7$$17, "Alias '", &alias, "' is used more than once, when preparing: ", &_6$$17);
4033 ZEPHIR_CALL_METHOD(NULL, &_5$$17, "__construct", &_8, 8, &_7$$17);
4034 zephir_check_call_status();
4035 zephir_throw_exception_debug(&_5$$17, "phalcon/Mvc/Model/Query.zep", 2170);
4036 ZEPHIR_MM_RESTORE();
4037 return;
4038 }
4039 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
4040 zephir_array_update_zval(&sqlAliasesModels, &alias, &modelName, PH_COPY | PH_SEPARATE);
4041 zephir_array_update_zval(&sqlModelsAliases, &modelName, &alias, PH_COPY | PH_SEPARATE);
4042 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
4043 if (Z_TYPE_P(&completeSource) == IS_ARRAY) {
4044 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2182);
4045 } else {
4046 ZEPHIR_INIT_NVAR(&_9$$19);
4047 zephir_create_array(&_9$$19, 3, 0);
4048 zephir_array_fast_append(&_9$$19, &source);
4049 zephir_array_fast_append(&_9$$19, &__$null);
4050 zephir_array_fast_append(&_9$$19, &alias);
4051 ZEPHIR_CPY_WRT(&completeSource, &_9$$19);
4052 }
4053 zephir_array_update_zval(&models, &modelName, &alias, PH_COPY | PH_SEPARATE);
4054 } else {
4055 ZEPHIR_CPY_WRT(&alias, &source);
4056 zephir_array_update_zval(&sqlAliases, &modelName, &source, PH_COPY | PH_SEPARATE);
4057 zephir_array_update_zval(&sqlAliasesModels, &modelName, &modelName, PH_COPY | PH_SEPARATE);
4058 zephir_array_update_zval(&sqlModelsAliases, &modelName, &modelName, PH_COPY | PH_SEPARATE);
4059 zephir_array_update_zval(&sqlAliasesModelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
4060 zephir_array_update_zval(&models, &modelName, &source, PH_COPY | PH_SEPARATE);
4061 }
4062 ZEPHIR_OBS_NVAR(&with);
4063 if (zephir_array_isset_string_fetch(&with, &selectedModel, SL("with"), 0)) {
4064 if (!(zephir_array_isset_long(&with, 0))) {
4065 ZEPHIR_INIT_NVAR(&withs);
4066 zephir_create_array(&withs, 1, 0);
4067 zephir_array_fast_append(&withs, &with);
4068 } else {
4069 ZEPHIR_CPY_WRT(&withs, &with);
4070 }
4071 zephir_is_iterable(&withs, 0, "phalcon/Mvc/Model/Query.zep", 2258);
4072 if (Z_TYPE_P(&withs) == IS_ARRAY) {
4073 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&withs), _10$$21)
4074 {
4075 ZEPHIR_INIT_NVAR(&withItem);
4076 ZVAL_COPY(&withItem, _10$$21);
4077 ZEPHIR_INIT_NVAR(&_12$$24);
4078 ZVAL_LONG(&_12$$24, number);
4079 ZEPHIR_INIT_NVAR(&_13$$24);
4080 ZEPHIR_CONCAT_SV(&_13$$24, "AA", &_12$$24);
4081 ZEPHIR_CPY_WRT(&joinAlias, &_13$$24);
4082 ZEPHIR_OBS_NVAR(&relationModel);
4083 zephir_array_fetch_string(&relationModel, &withItem, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2208);
4084 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_14, 0, &modelName, &relationModel);
4085 zephir_check_call_status();
4086 if (Z_TYPE_P(&relation) == IS_OBJECT) {
4087 ZEPHIR_INIT_NVAR(&_15$$25);
4088 ZVAL_STRING(&_15$$25, "alias");
4089 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_15$$25);
4090 zephir_check_call_status();
4091 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4092 zephir_check_call_status();
4093 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4094 zephir_check_call_status();
4095 } else {
4096 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationsbetween", &_16, 0, &modelName, &relationModel);
4097 zephir_check_call_status();
4098 if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) {
4099 ZEPHIR_INIT_NVAR(&_17$$27);
4100 object_init_ex(&_17$$27, phalcon_mvc_model_exception_ce);
4101 zephir_read_property(&_18$$27, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4102 ZEPHIR_INIT_NVAR(&_19$$27);
4103 ZEPHIR_CONCAT_SVSVSV(&_19$$27, "Can't find a relationship between '", &modelName, "' and '", &relationModel, "' when preparing: ", &_18$$27);
4104 ZEPHIR_CALL_METHOD(NULL, &_17$$27, "__construct", &_8, 8, &_19$$27);
4105 zephir_check_call_status();
4106 zephir_throw_exception_debug(&_17$$27, "phalcon/Mvc/Model/Query.zep", 2228);
4107 ZEPHIR_MM_RESTORE();
4108 return;
4109 }
4110 ZEPHIR_INIT_NVAR(&_20$$26);
4111 ZVAL_STRING(&_20$$26, "alias");
4112 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_20$$26);
4113 zephir_check_call_status();
4114 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4115 zephir_check_call_status();
4116 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4117 zephir_check_call_status();
4118 }
4119 ZEPHIR_INIT_NVAR(&_21$$24);
4120 zephir_create_array(&_21$$24, 5, 0);
4121 add_assoc_long_ex(&_21$$24, SL("type"), 353);
4122 zephir_array_update_string(&_21$$24, SL("column"), &joinAlias, PH_COPY | PH_SEPARATE);
4123 zephir_array_update_string(&_21$$24, SL("eager"), &alias, PH_COPY | PH_SEPARATE);
4124 zephir_array_update_string(&_21$$24, SL("eagerType"), &eagerType, PH_COPY | PH_SEPARATE);
4125 zephir_array_update_string(&_21$$24, SL("balias"), &bestAlias, PH_COPY | PH_SEPARATE);
4126 zephir_array_append(&selectColumns, &_21$$24, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2242);
4127 ZEPHIR_INIT_NVAR(&_22$$24);
4128 zephir_create_array(&_22$$24, 3, 0);
4129 add_assoc_long_ex(&_22$$24, SL("type"), 360);
4130 ZEPHIR_INIT_NVAR(&_23$$24);
4131 zephir_create_array(&_23$$24, 2, 0);
4132 add_assoc_long_ex(&_23$$24, SL("type"), 355);
4133 zephir_array_update_string(&_23$$24, SL("name"), &relationModel, PH_COPY | PH_SEPARATE);
4134 zephir_array_update_string(&_22$$24, SL("qualified"), &_23$$24, PH_COPY | PH_SEPARATE);
4135 ZEPHIR_INIT_NVAR(&_23$$24);
4136 zephir_create_array(&_23$$24, 2, 0);
4137 add_assoc_long_ex(&_23$$24, SL("type"), 355);
4138 zephir_array_update_string(&_23$$24, SL("name"), &joinAlias, PH_COPY | PH_SEPARATE);
4139 zephir_array_update_string(&_22$$24, SL("alias"), &_23$$24, PH_COPY | PH_SEPARATE);
4140 zephir_array_append(&automaticJoins, &_22$$24, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2254);
4141 number++;
4142 } ZEND_HASH_FOREACH_END();
4143 } else {
4144 ZEPHIR_CALL_METHOD(NULL, &withs, "rewind", NULL, 0);
4145 zephir_check_call_status();
4146 while (1) {
4147 ZEPHIR_CALL_METHOD(&_11$$21, &withs, "valid", NULL, 0);
4148 zephir_check_call_status();
4149 if (!zend_is_true(&_11$$21)) {
4150 break;
4151 }
4152 ZEPHIR_CALL_METHOD(&withItem, &withs, "current", NULL, 0);
4153 zephir_check_call_status();
4154 ZEPHIR_INIT_NVAR(&_24$$28);
4155 ZVAL_LONG(&_24$$28, number);
4156 ZEPHIR_INIT_NVAR(&_25$$28);
4157 ZEPHIR_CONCAT_SV(&_25$$28, "AA", &_24$$28);
4158 ZEPHIR_CPY_WRT(&joinAlias, &_25$$28);
4159 ZEPHIR_OBS_NVAR(&relationModel);
4160 zephir_array_fetch_string(&relationModel, &withItem, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2208);
4161 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_26, 0, &modelName, &relationModel);
4162 zephir_check_call_status();
4163 if (Z_TYPE_P(&relation) == IS_OBJECT) {
4164 ZEPHIR_INIT_NVAR(&_27$$29);
4165 ZVAL_STRING(&_27$$29, "alias");
4166 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_27$$29);
4167 zephir_check_call_status();
4168 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4169 zephir_check_call_status();
4170 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4171 zephir_check_call_status();
4172 } else {
4173 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationsbetween", &_28, 0, &modelName, &relationModel);
4174 zephir_check_call_status();
4175 if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) {
4176 ZEPHIR_INIT_NVAR(&_29$$31);
4177 object_init_ex(&_29$$31, phalcon_mvc_model_exception_ce);
4178 zephir_read_property(&_30$$31, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4179 ZEPHIR_INIT_NVAR(&_31$$31);
4180 ZEPHIR_CONCAT_SVSVSV(&_31$$31, "Can't find a relationship between '", &modelName, "' and '", &relationModel, "' when preparing: ", &_30$$31);
4181 ZEPHIR_CALL_METHOD(NULL, &_29$$31, "__construct", &_8, 8, &_31$$31);
4182 zephir_check_call_status();
4183 zephir_throw_exception_debug(&_29$$31, "phalcon/Mvc/Model/Query.zep", 2228);
4184 ZEPHIR_MM_RESTORE();
4185 return;
4186 }
4187 ZEPHIR_INIT_NVAR(&_32$$30);
4188 ZVAL_STRING(&_32$$30, "alias");
4189 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_32$$30);
4190 zephir_check_call_status();
4191 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4192 zephir_check_call_status();
4193 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4194 zephir_check_call_status();
4195 }
4196 ZEPHIR_INIT_NVAR(&_33$$28);
4197 zephir_create_array(&_33$$28, 5, 0);
4198 add_assoc_long_ex(&_33$$28, SL("type"), 353);
4199 zephir_array_update_string(&_33$$28, SL("column"), &joinAlias, PH_COPY | PH_SEPARATE);
4200 zephir_array_update_string(&_33$$28, SL("eager"), &alias, PH_COPY | PH_SEPARATE);
4201 zephir_array_update_string(&_33$$28, SL("eagerType"), &eagerType, PH_COPY | PH_SEPARATE);
4202 zephir_array_update_string(&_33$$28, SL("balias"), &bestAlias, PH_COPY | PH_SEPARATE);
4203 zephir_array_append(&selectColumns, &_33$$28, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2242);
4204 ZEPHIR_INIT_NVAR(&_34$$28);
4205 zephir_create_array(&_34$$28, 3, 0);
4206 add_assoc_long_ex(&_34$$28, SL("type"), 360);
4207 ZEPHIR_INIT_NVAR(&_35$$28);
4208 zephir_create_array(&_35$$28, 2, 0);
4209 add_assoc_long_ex(&_35$$28, SL("type"), 355);
4210 zephir_array_update_string(&_35$$28, SL("name"), &relationModel, PH_COPY | PH_SEPARATE);
4211 zephir_array_update_string(&_34$$28, SL("qualified"), &_35$$28, PH_COPY | PH_SEPARATE);
4212 ZEPHIR_INIT_NVAR(&_35$$28);
4213 zephir_create_array(&_35$$28, 2, 0);
4214 add_assoc_long_ex(&_35$$28, SL("type"), 355);
4215 zephir_array_update_string(&_35$$28, SL("name"), &joinAlias, PH_COPY | PH_SEPARATE);
4216 zephir_array_update_string(&_34$$28, SL("alias"), &_35$$28, PH_COPY | PH_SEPARATE);
4217 zephir_array_append(&automaticJoins, &_34$$28, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2254);
4218 number++;
4219 ZEPHIR_CALL_METHOD(NULL, &withs, "next", NULL, 0);
4220 zephir_check_call_status();
4221 }
4222 }
4223 ZEPHIR_INIT_NVAR(&withItem);
4224 }
4225 zephir_array_append(&sqlModels, &modelName, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2260);
4226 zephir_array_append(&sqlTables, &completeSource, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2261);
4227 zephir_array_update_zval(&modelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
4228 } ZEND_HASH_FOREACH_END();
4229 } else {
4230 ZEPHIR_CALL_METHOD(NULL, &selectedModels, "rewind", NULL, 0);
4231 zephir_check_call_status();
4232 while (1) {
4233 ZEPHIR_CALL_METHOD(&_3, &selectedModels, "valid", NULL, 0);
4234 zephir_check_call_status();
4235 if (!zend_is_true(&_3)) {
4236 break;
4237 }
4238 ZEPHIR_CALL_METHOD(&selectedModel, &selectedModels, "current", NULL, 0);
4239 zephir_check_call_status();
4240 ZEPHIR_OBS_NVAR(&qualifiedName);
4241 zephir_array_fetch_string(&qualifiedName, &selectedModel, SL("qualifiedName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2144);
4242 ZEPHIR_OBS_NVAR(&modelName);
4243 zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2145);
4244 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_36, 0, &modelName);
4245 zephir_check_call_status();
4246 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
4247 zephir_check_call_status();
4248 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
4249 zephir_check_call_status();
4250 if (zephir_is_true(&schema)) {
4251 ZEPHIR_INIT_NVAR(&_37$$33);
4252 zephir_create_array(&_37$$33, 2, 0);
4253 zephir_array_fast_append(&_37$$33, &source);
4254 zephir_array_fast_append(&_37$$33, &schema);
4255 ZEPHIR_CPY_WRT(&completeSource, &_37$$33);
4256 } else {
4257 ZEPHIR_CPY_WRT(&completeSource, &source);
4258 }
4259 ZEPHIR_OBS_NVAR(&alias);
4260 if (zephir_array_isset_string_fetch(&alias, &selectedModel, SL("alias"), 0)) {
4261 if (UNEXPECTED(zephir_array_isset(&sqlAliases, &alias))) {
4262 ZEPHIR_INIT_NVAR(&_38$$36);
4263 object_init_ex(&_38$$36, phalcon_mvc_model_exception_ce);
4264 zephir_read_property(&_39$$36, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4265 ZEPHIR_INIT_NVAR(&_40$$36);
4266 ZEPHIR_CONCAT_SVSV(&_40$$36, "Alias '", &alias, "' is used more than once, when preparing: ", &_39$$36);
4267 ZEPHIR_CALL_METHOD(NULL, &_38$$36, "__construct", &_8, 8, &_40$$36);
4268 zephir_check_call_status();
4269 zephir_throw_exception_debug(&_38$$36, "phalcon/Mvc/Model/Query.zep", 2170);
4270 ZEPHIR_MM_RESTORE();
4271 return;
4272 }
4273 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
4274 zephir_array_update_zval(&sqlAliasesModels, &alias, &modelName, PH_COPY | PH_SEPARATE);
4275 zephir_array_update_zval(&sqlModelsAliases, &modelName, &alias, PH_COPY | PH_SEPARATE);
4276 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
4277 if (Z_TYPE_P(&completeSource) == IS_ARRAY) {
4278 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2182);
4279 } else {
4280 ZEPHIR_INIT_NVAR(&_41$$38);
4281 zephir_create_array(&_41$$38, 3, 0);
4282 zephir_array_fast_append(&_41$$38, &source);
4283 zephir_array_fast_append(&_41$$38, &__$null);
4284 zephir_array_fast_append(&_41$$38, &alias);
4285 ZEPHIR_CPY_WRT(&completeSource, &_41$$38);
4286 }
4287 zephir_array_update_zval(&models, &modelName, &alias, PH_COPY | PH_SEPARATE);
4288 } else {
4289 ZEPHIR_CPY_WRT(&alias, &source);
4290 zephir_array_update_zval(&sqlAliases, &modelName, &source, PH_COPY | PH_SEPARATE);
4291 zephir_array_update_zval(&sqlAliasesModels, &modelName, &modelName, PH_COPY | PH_SEPARATE);
4292 zephir_array_update_zval(&sqlModelsAliases, &modelName, &modelName, PH_COPY | PH_SEPARATE);
4293 zephir_array_update_zval(&sqlAliasesModelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
4294 zephir_array_update_zval(&models, &modelName, &source, PH_COPY | PH_SEPARATE);
4295 }
4296 ZEPHIR_OBS_NVAR(&with);
4297 if (zephir_array_isset_string_fetch(&with, &selectedModel, SL("with"), 0)) {
4298 if (!(zephir_array_isset_long(&with, 0))) {
4299 ZEPHIR_INIT_NVAR(&_42$$41);
4300 zephir_create_array(&_42$$41, 1, 0);
4301 zephir_array_fast_append(&_42$$41, &with);
4302 ZEPHIR_CPY_WRT(&withs, &_42$$41);
4303 } else {
4304 ZEPHIR_CPY_WRT(&withs, &with);
4305 }
4306 zephir_is_iterable(&withs, 0, "phalcon/Mvc/Model/Query.zep", 2258);
4307 if (Z_TYPE_P(&withs) == IS_ARRAY) {
4308 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&withs), _43$$40)
4309 {
4310 ZEPHIR_INIT_NVAR(&withItem);
4311 ZVAL_COPY(&withItem, _43$$40);
4312 ZEPHIR_INIT_NVAR(&_45$$43);
4313 ZVAL_LONG(&_45$$43, number);
4314 ZEPHIR_INIT_NVAR(&_46$$43);
4315 ZEPHIR_CONCAT_SV(&_46$$43, "AA", &_45$$43);
4316 ZEPHIR_CPY_WRT(&joinAlias, &_46$$43);
4317 ZEPHIR_OBS_NVAR(&relationModel);
4318 zephir_array_fetch_string(&relationModel, &withItem, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2208);
4319 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_47, 0, &modelName, &relationModel);
4320 zephir_check_call_status();
4321 if (Z_TYPE_P(&relation) == IS_OBJECT) {
4322 ZEPHIR_INIT_NVAR(&_48$$44);
4323 ZVAL_STRING(&_48$$44, "alias");
4324 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_48$$44);
4325 zephir_check_call_status();
4326 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4327 zephir_check_call_status();
4328 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4329 zephir_check_call_status();
4330 } else {
4331 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationsbetween", &_49, 0, &modelName, &relationModel);
4332 zephir_check_call_status();
4333 if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) {
4334 ZEPHIR_INIT_NVAR(&_50$$46);
4335 object_init_ex(&_50$$46, phalcon_mvc_model_exception_ce);
4336 zephir_read_property(&_51$$46, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4337 ZEPHIR_INIT_NVAR(&_52$$46);
4338 ZEPHIR_CONCAT_SVSVSV(&_52$$46, "Can't find a relationship between '", &modelName, "' and '", &relationModel, "' when preparing: ", &_51$$46);
4339 ZEPHIR_CALL_METHOD(NULL, &_50$$46, "__construct", &_8, 8, &_52$$46);
4340 zephir_check_call_status();
4341 zephir_throw_exception_debug(&_50$$46, "phalcon/Mvc/Model/Query.zep", 2228);
4342 ZEPHIR_MM_RESTORE();
4343 return;
4344 }
4345 ZEPHIR_INIT_NVAR(&_53$$45);
4346 ZVAL_STRING(&_53$$45, "alias");
4347 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_53$$45);
4348 zephir_check_call_status();
4349 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4350 zephir_check_call_status();
4351 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4352 zephir_check_call_status();
4353 }
4354 ZEPHIR_INIT_NVAR(&_54$$43);
4355 zephir_create_array(&_54$$43, 5, 0);
4356 add_assoc_long_ex(&_54$$43, SL("type"), 353);
4357 zephir_array_update_string(&_54$$43, SL("column"), &joinAlias, PH_COPY | PH_SEPARATE);
4358 zephir_array_update_string(&_54$$43, SL("eager"), &alias, PH_COPY | PH_SEPARATE);
4359 zephir_array_update_string(&_54$$43, SL("eagerType"), &eagerType, PH_COPY | PH_SEPARATE);
4360 zephir_array_update_string(&_54$$43, SL("balias"), &bestAlias, PH_COPY | PH_SEPARATE);
4361 zephir_array_append(&selectColumns, &_54$$43, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2242);
4362 ZEPHIR_INIT_NVAR(&_55$$43);
4363 zephir_create_array(&_55$$43, 3, 0);
4364 add_assoc_long_ex(&_55$$43, SL("type"), 360);
4365 ZEPHIR_INIT_NVAR(&_56$$43);
4366 zephir_create_array(&_56$$43, 2, 0);
4367 add_assoc_long_ex(&_56$$43, SL("type"), 355);
4368 zephir_array_update_string(&_56$$43, SL("name"), &relationModel, PH_COPY | PH_SEPARATE);
4369 zephir_array_update_string(&_55$$43, SL("qualified"), &_56$$43, PH_COPY | PH_SEPARATE);
4370 ZEPHIR_INIT_NVAR(&_56$$43);
4371 zephir_create_array(&_56$$43, 2, 0);
4372 add_assoc_long_ex(&_56$$43, SL("type"), 355);
4373 zephir_array_update_string(&_56$$43, SL("name"), &joinAlias, PH_COPY | PH_SEPARATE);
4374 zephir_array_update_string(&_55$$43, SL("alias"), &_56$$43, PH_COPY | PH_SEPARATE);
4375 zephir_array_append(&automaticJoins, &_55$$43, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2254);
4376 number++;
4377 } ZEND_HASH_FOREACH_END();
4378 } else {
4379 ZEPHIR_CALL_METHOD(NULL, &withs, "rewind", NULL, 0);
4380 zephir_check_call_status();
4381 while (1) {
4382 ZEPHIR_CALL_METHOD(&_44$$40, &withs, "valid", NULL, 0);
4383 zephir_check_call_status();
4384 if (!zend_is_true(&_44$$40)) {
4385 break;
4386 }
4387 ZEPHIR_CALL_METHOD(&withItem, &withs, "current", NULL, 0);
4388 zephir_check_call_status();
4389 ZEPHIR_INIT_NVAR(&_57$$47);
4390 ZVAL_LONG(&_57$$47, number);
4391 ZEPHIR_INIT_NVAR(&_58$$47);
4392 ZEPHIR_CONCAT_SV(&_58$$47, "AA", &_57$$47);
4393 ZEPHIR_CPY_WRT(&joinAlias, &_58$$47);
4394 ZEPHIR_OBS_NVAR(&relationModel);
4395 zephir_array_fetch_string(&relationModel, &withItem, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2208);
4396 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationbyalias", &_59, 0, &modelName, &relationModel);
4397 zephir_check_call_status();
4398 if (Z_TYPE_P(&relation) == IS_OBJECT) {
4399 ZEPHIR_INIT_NVAR(&_60$$48);
4400 ZVAL_STRING(&_60$$48, "alias");
4401 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_60$$48);
4402 zephir_check_call_status();
4403 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4404 zephir_check_call_status();
4405 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4406 zephir_check_call_status();
4407 } else {
4408 ZEPHIR_CALL_METHOD(&relation, &manager, "getrelationsbetween", &_61, 0, &modelName, &relationModel);
4409 zephir_check_call_status();
4410 if (UNEXPECTED(Z_TYPE_P(&relation) != IS_OBJECT)) {
4411 ZEPHIR_INIT_NVAR(&_62$$50);
4412 object_init_ex(&_62$$50, phalcon_mvc_model_exception_ce);
4413 zephir_read_property(&_63$$50, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4414 ZEPHIR_INIT_NVAR(&_64$$50);
4415 ZEPHIR_CONCAT_SVSVSV(&_64$$50, "Can't find a relationship between '", &modelName, "' and '", &relationModel, "' when preparing: ", &_63$$50);
4416 ZEPHIR_CALL_METHOD(NULL, &_62$$50, "__construct", &_8, 8, &_64$$50);
4417 zephir_check_call_status();
4418 zephir_throw_exception_debug(&_62$$50, "phalcon/Mvc/Model/Query.zep", 2228);
4419 ZEPHIR_MM_RESTORE();
4420 return;
4421 }
4422 ZEPHIR_INIT_NVAR(&_65$$49);
4423 ZVAL_STRING(&_65$$49, "alias");
4424 ZEPHIR_CALL_METHOD(&bestAlias, &relation, "getoption", NULL, 0, &_65$$49);
4425 zephir_check_call_status();
4426 ZEPHIR_CALL_METHOD(&relationModel, &relation, "getreferencedmodel", NULL, 0);
4427 zephir_check_call_status();
4428 ZEPHIR_CALL_METHOD(&eagerType, &relation, "gettype", NULL, 0);
4429 zephir_check_call_status();
4430 }
4431 ZEPHIR_INIT_NVAR(&_66$$47);
4432 zephir_create_array(&_66$$47, 5, 0);
4433 add_assoc_long_ex(&_66$$47, SL("type"), 353);
4434 zephir_array_update_string(&_66$$47, SL("column"), &joinAlias, PH_COPY | PH_SEPARATE);
4435 zephir_array_update_string(&_66$$47, SL("eager"), &alias, PH_COPY | PH_SEPARATE);
4436 zephir_array_update_string(&_66$$47, SL("eagerType"), &eagerType, PH_COPY | PH_SEPARATE);
4437 zephir_array_update_string(&_66$$47, SL("balias"), &bestAlias, PH_COPY | PH_SEPARATE);
4438 zephir_array_append(&selectColumns, &_66$$47, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2242);
4439 ZEPHIR_INIT_NVAR(&_67$$47);
4440 zephir_create_array(&_67$$47, 3, 0);
4441 add_assoc_long_ex(&_67$$47, SL("type"), 360);
4442 ZEPHIR_INIT_NVAR(&_68$$47);
4443 zephir_create_array(&_68$$47, 2, 0);
4444 add_assoc_long_ex(&_68$$47, SL("type"), 355);
4445 zephir_array_update_string(&_68$$47, SL("name"), &relationModel, PH_COPY | PH_SEPARATE);
4446 zephir_array_update_string(&_67$$47, SL("qualified"), &_68$$47, PH_COPY | PH_SEPARATE);
4447 ZEPHIR_INIT_NVAR(&_68$$47);
4448 zephir_create_array(&_68$$47, 2, 0);
4449 add_assoc_long_ex(&_68$$47, SL("type"), 355);
4450 zephir_array_update_string(&_68$$47, SL("name"), &joinAlias, PH_COPY | PH_SEPARATE);
4451 zephir_array_update_string(&_67$$47, SL("alias"), &_68$$47, PH_COPY | PH_SEPARATE);
4452 zephir_array_append(&automaticJoins, &_67$$47, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2254);
4453 number++;
4454 ZEPHIR_CALL_METHOD(NULL, &withs, "next", NULL, 0);
4455 zephir_check_call_status();
4456 }
4457 }
4458 ZEPHIR_INIT_NVAR(&withItem);
4459 }
4460 zephir_array_append(&sqlModels, &modelName, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2260);
4461 zephir_array_append(&sqlTables, &completeSource, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2261);
4462 zephir_array_update_zval(&modelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
4463 ZEPHIR_CALL_METHOD(NULL, &selectedModels, "next", NULL, 0);
4464 zephir_check_call_status();
4465 }
4466 }
4467 ZEPHIR_INIT_NVAR(&selectedModel);
4468 if (!(merge)) {
4469 zephir_update_property_zval(this_ptr, ZEND_STRL("models"), &models);
4470 zephir_update_property_zval(this_ptr, ZEND_STRL("modelsInstances"), &modelsInstances);
4471 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliases"), &sqlAliases);
4472 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModels"), &sqlAliasesModels);
4473 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlModelsAliases"), &sqlModelsAliases);
4474 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), &sqlAliasesModelsInstances);
4475 } else {
4476 ZEPHIR_OBS_VAR(&tempModels);
4477 zephir_read_property(&tempModels, this_ptr, ZEND_STRL("models"), PH_NOISY_CC);
4478 ZEPHIR_OBS_VAR(&tempModelsInstances);
4479 zephir_read_property(&tempModelsInstances, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC);
4480 ZEPHIR_OBS_VAR(&tempSqlAliases);
4481 zephir_read_property(&tempSqlAliases, this_ptr, ZEND_STRL("sqlAliases"), PH_NOISY_CC);
4482 ZEPHIR_OBS_VAR(&tempSqlAliasesModels);
4483 zephir_read_property(&tempSqlAliasesModels, this_ptr, ZEND_STRL("sqlAliasesModels"), PH_NOISY_CC);
4484 ZEPHIR_OBS_VAR(&tempSqlModelsAliases);
4485 zephir_read_property(&tempSqlModelsAliases, this_ptr, ZEND_STRL("sqlModelsAliases"), PH_NOISY_CC);
4486 ZEPHIR_OBS_VAR(&tempSqlAliasesModelsInstances);
4487 zephir_read_property(&tempSqlAliasesModelsInstances, this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), PH_NOISY_CC);
4488 ZEPHIR_INIT_VAR(&_69$$52);
4489 zephir_read_property(&_70$$52, this_ptr, ZEND_STRL("models"), PH_NOISY_CC | PH_READONLY);
4490 zephir_fast_array_merge(&_69$$52, &_70$$52, &models);
4491 zephir_update_property_zval(this_ptr, ZEND_STRL("models"), &_69$$52);
4492 ZEPHIR_INIT_VAR(&_71$$52);
4493 zephir_read_property(&_72$$52, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
4494 zephir_fast_array_merge(&_71$$52, &_72$$52, &modelsInstances);
4495 zephir_update_property_zval(this_ptr, ZEND_STRL("modelsInstances"), &_71$$52);
4496 ZEPHIR_INIT_VAR(&_73$$52);
4497 zephir_read_property(&_74$$52, this_ptr, ZEND_STRL("sqlAliases"), PH_NOISY_CC | PH_READONLY);
4498 zephir_fast_array_merge(&_73$$52, &_74$$52, &sqlAliases);
4499 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliases"), &_73$$52);
4500 ZEPHIR_INIT_VAR(&_75$$52);
4501 zephir_read_property(&_76$$52, this_ptr, ZEND_STRL("sqlAliasesModels"), PH_NOISY_CC | PH_READONLY);
4502 zephir_fast_array_merge(&_75$$52, &_76$$52, &sqlAliasesModels);
4503 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModels"), &_75$$52);
4504 ZEPHIR_INIT_VAR(&_77$$52);
4505 zephir_read_property(&_78$$52, this_ptr, ZEND_STRL("sqlModelsAliases"), PH_NOISY_CC | PH_READONLY);
4506 zephir_fast_array_merge(&_77$$52, &_78$$52, &sqlModelsAliases);
4507 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlModelsAliases"), &_77$$52);
4508 ZEPHIR_INIT_VAR(&_79$$52);
4509 zephir_read_property(&_80$$52, this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), PH_NOISY_CC | PH_READONLY);
4510 zephir_fast_array_merge(&_79$$52, &_80$$52, &sqlAliasesModelsInstances);
4511 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), &_79$$52);
4512 }
4513 ZEPHIR_OBS_VAR(&joins);
4514 zephir_array_isset_string_fetch(&joins, &select, SL("joins"), 0);
4515 if (zephir_fast_count_int(&joins)) {
4516 if (zephir_fast_count_int(&automaticJoins)) {
4517 if (zephir_array_isset_long(&joins, 0)) {
4518 ZEPHIR_INIT_VAR(&_81$$55);
4519 zephir_fast_array_merge(&_81$$55, &joins, &automaticJoins);
4520 zephir_array_update_string(&select, SL("joins"), &_81$$55, PH_COPY | PH_SEPARATE);
4521 } else {
4522 zephir_array_append(&automaticJoins, &joins, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2297);
4523 zephir_array_update_string(&select, SL("joins"), &automaticJoins, PH_COPY | PH_SEPARATE);
4524 }
4525 }
4526 ZEPHIR_CALL_METHOD(&sqlJoins, this_ptr, "_getjoins", NULL, 484, &select);
4527 zephir_check_call_status();
4528 } else {
4529 if (zephir_fast_count_int(&automaticJoins)) {
4530 zephir_array_update_string(&select, SL("joins"), &automaticJoins, PH_COPY | PH_SEPARATE);
4531 ZEPHIR_CALL_METHOD(&sqlJoins, this_ptr, "_getjoins", NULL, 484, &select);
4532 zephir_check_call_status();
4533 } else {
4534 ZEPHIR_INIT_NVAR(&sqlJoins);
4535 array_init(&sqlJoins);
4536 }
4537 }
4538 position = 0;
4539 ZEPHIR_INIT_VAR(&sqlColumnAliases);
4540 array_init(&sqlColumnAliases);
4541 zephir_is_iterable(&selectColumns, 0, "phalcon/Mvc/Model/Query.zep", 2348);
4542 if (Z_TYPE_P(&selectColumns) == IS_ARRAY) {
4543 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&selectColumns), _82)
4544 {
4545 ZEPHIR_INIT_NVAR(&column);
4546 ZVAL_COPY(&column, _82);
4547 ZEPHIR_CALL_METHOD(&_84$$60, this_ptr, "_getselectcolumn", &_85, 485, &column);
4548 zephir_check_call_status();
4549 zephir_is_iterable(&_84$$60, 0, "phalcon/Mvc/Model/Query.zep", 2346);
4550 if (Z_TYPE_P(&_84$$60) == IS_ARRAY) {
4551 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_84$$60), _86$$60)
4552 {
4553 ZEPHIR_INIT_NVAR(&sqlColumn);
4554 ZVAL_COPY(&sqlColumn, _86$$60);
4555 ZEPHIR_OBS_NVAR(&alias);
4556 if (zephir_array_isset_string_fetch(&alias, &column, SL("alias"), 0)) {
4557 zephir_array_update_string(&sqlColumn, SL("balias"), &alias, PH_COPY | PH_SEPARATE);
4558 zephir_array_update_string(&sqlColumn, SL("sqlAlias"), &alias, PH_COPY | PH_SEPARATE);
4559 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4560 zephir_array_update_zval(&sqlColumnAliases, &alias, &__$true, PH_COPY | PH_SEPARATE);
4561 } else {
4562 ZEPHIR_OBS_NVAR(&alias);
4563 if (zephir_array_isset_string_fetch(&alias, &sqlColumn, SL("balias"), 0)) {
4564 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4565 } else {
4566 zephir_array_fetch_string(&_88$$65, &sqlColumn, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2336);
4567 if (ZEPHIR_IS_STRING(&_88$$65, "scalar")) {
4568 ZEPHIR_INIT_NVAR(&_89$$66);
4569 ZVAL_LONG(&_89$$66, position);
4570 ZEPHIR_INIT_NVAR(&_90$$66);
4571 ZEPHIR_CONCAT_SV(&_90$$66, "_", &_89$$66);
4572 zephir_array_update_zval(&sqlColumns, &_90$$66, &sqlColumn, PH_COPY | PH_SEPARATE);
4573 } else {
4574 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2339);
4575 }
4576 }
4577 }
4578 position++;
4579 } ZEND_HASH_FOREACH_END();
4580 } else {
4581 ZEPHIR_CALL_METHOD(NULL, &_84$$60, "rewind", NULL, 0);
4582 zephir_check_call_status();
4583 while (1) {
4584 ZEPHIR_CALL_METHOD(&_87$$60, &_84$$60, "valid", NULL, 0);
4585 zephir_check_call_status();
4586 if (!zend_is_true(&_87$$60)) {
4587 break;
4588 }
4589 ZEPHIR_CALL_METHOD(&sqlColumn, &_84$$60, "current", NULL, 0);
4590 zephir_check_call_status();
4591 ZEPHIR_OBS_NVAR(&alias);
4592 if (zephir_array_isset_string_fetch(&alias, &column, SL("alias"), 0)) {
4593 zephir_array_update_string(&sqlColumn, SL("balias"), &alias, PH_COPY | PH_SEPARATE);
4594 zephir_array_update_string(&sqlColumn, SL("sqlAlias"), &alias, PH_COPY | PH_SEPARATE);
4595 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4596 zephir_array_update_zval(&sqlColumnAliases, &alias, &__$true, PH_COPY | PH_SEPARATE);
4597 } else {
4598 ZEPHIR_OBS_NVAR(&alias);
4599 if (zephir_array_isset_string_fetch(&alias, &sqlColumn, SL("balias"), 0)) {
4600 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4601 } else {
4602 zephir_array_fetch_string(&_91$$72, &sqlColumn, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2336);
4603 if (ZEPHIR_IS_STRING(&_91$$72, "scalar")) {
4604 ZEPHIR_INIT_NVAR(&_92$$73);
4605 ZVAL_LONG(&_92$$73, position);
4606 ZEPHIR_INIT_NVAR(&_93$$73);
4607 ZEPHIR_CONCAT_SV(&_93$$73, "_", &_92$$73);
4608 zephir_array_update_zval(&sqlColumns, &_93$$73, &sqlColumn, PH_COPY | PH_SEPARATE);
4609 } else {
4610 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2339);
4611 }
4612 }
4613 }
4614 position++;
4615 ZEPHIR_CALL_METHOD(NULL, &_84$$60, "next", NULL, 0);
4616 zephir_check_call_status();
4617 }
4618 }
4619 ZEPHIR_INIT_NVAR(&sqlColumn);
4620 } ZEND_HASH_FOREACH_END();
4621 } else {
4622 ZEPHIR_CALL_METHOD(NULL, &selectColumns, "rewind", NULL, 0);
4623 zephir_check_call_status();
4624 while (1) {
4625 ZEPHIR_CALL_METHOD(&_83, &selectColumns, "valid", NULL, 0);
4626 zephir_check_call_status();
4627 if (!zend_is_true(&_83)) {
4628 break;
4629 }
4630 ZEPHIR_CALL_METHOD(&column, &selectColumns, "current", NULL, 0);
4631 zephir_check_call_status();
4632 ZEPHIR_CALL_METHOD(&_94$$75, this_ptr, "_getselectcolumn", &_85, 485, &column);
4633 zephir_check_call_status();
4634 zephir_is_iterable(&_94$$75, 0, "phalcon/Mvc/Model/Query.zep", 2346);
4635 if (Z_TYPE_P(&_94$$75) == IS_ARRAY) {
4636 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_94$$75), _95$$75)
4637 {
4638 ZEPHIR_INIT_NVAR(&sqlColumn);
4639 ZVAL_COPY(&sqlColumn, _95$$75);
4640 ZEPHIR_OBS_NVAR(&alias);
4641 if (zephir_array_isset_string_fetch(&alias, &column, SL("alias"), 0)) {
4642 zephir_array_update_string(&sqlColumn, SL("balias"), &alias, PH_COPY | PH_SEPARATE);
4643 zephir_array_update_string(&sqlColumn, SL("sqlAlias"), &alias, PH_COPY | PH_SEPARATE);
4644 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4645 zephir_array_update_zval(&sqlColumnAliases, &alias, &__$true, PH_COPY | PH_SEPARATE);
4646 } else {
4647 ZEPHIR_OBS_NVAR(&alias);
4648 if (zephir_array_isset_string_fetch(&alias, &sqlColumn, SL("balias"), 0)) {
4649 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4650 } else {
4651 zephir_array_fetch_string(&_97$$80, &sqlColumn, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2336);
4652 if (ZEPHIR_IS_STRING(&_97$$80, "scalar")) {
4653 ZEPHIR_INIT_NVAR(&_98$$81);
4654 ZVAL_LONG(&_98$$81, position);
4655 ZEPHIR_INIT_NVAR(&_99$$81);
4656 ZEPHIR_CONCAT_SV(&_99$$81, "_", &_98$$81);
4657 zephir_array_update_zval(&sqlColumns, &_99$$81, &sqlColumn, PH_COPY | PH_SEPARATE);
4658 } else {
4659 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2339);
4660 }
4661 }
4662 }
4663 position++;
4664 } ZEND_HASH_FOREACH_END();
4665 } else {
4666 ZEPHIR_CALL_METHOD(NULL, &_94$$75, "rewind", NULL, 0);
4667 zephir_check_call_status();
4668 while (1) {
4669 ZEPHIR_CALL_METHOD(&_96$$75, &_94$$75, "valid", NULL, 0);
4670 zephir_check_call_status();
4671 if (!zend_is_true(&_96$$75)) {
4672 break;
4673 }
4674 ZEPHIR_CALL_METHOD(&sqlColumn, &_94$$75, "current", NULL, 0);
4675 zephir_check_call_status();
4676 ZEPHIR_OBS_NVAR(&alias);
4677 if (zephir_array_isset_string_fetch(&alias, &column, SL("alias"), 0)) {
4678 zephir_array_update_string(&sqlColumn, SL("balias"), &alias, PH_COPY | PH_SEPARATE);
4679 zephir_array_update_string(&sqlColumn, SL("sqlAlias"), &alias, PH_COPY | PH_SEPARATE);
4680 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4681 zephir_array_update_zval(&sqlColumnAliases, &alias, &__$true, PH_COPY | PH_SEPARATE);
4682 } else {
4683 ZEPHIR_OBS_NVAR(&alias);
4684 if (zephir_array_isset_string_fetch(&alias, &sqlColumn, SL("balias"), 0)) {
4685 zephir_array_update_zval(&sqlColumns, &alias, &sqlColumn, PH_COPY | PH_SEPARATE);
4686 } else {
4687 zephir_array_fetch_string(&_100$$87, &sqlColumn, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2336);
4688 if (ZEPHIR_IS_STRING(&_100$$87, "scalar")) {
4689 ZEPHIR_INIT_NVAR(&_101$$88);
4690 ZVAL_LONG(&_101$$88, position);
4691 ZEPHIR_INIT_NVAR(&_102$$88);
4692 ZEPHIR_CONCAT_SV(&_102$$88, "_", &_101$$88);
4693 zephir_array_update_zval(&sqlColumns, &_102$$88, &sqlColumn, PH_COPY | PH_SEPARATE);
4694 } else {
4695 zephir_array_append(&sqlColumns, &sqlColumn, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2339);
4696 }
4697 }
4698 }
4699 position++;
4700 ZEPHIR_CALL_METHOD(NULL, &_94$$75, "next", NULL, 0);
4701 zephir_check_call_status();
4702 }
4703 }
4704 ZEPHIR_INIT_NVAR(&sqlColumn);
4705 ZEPHIR_CALL_METHOD(NULL, &selectColumns, "next", NULL, 0);
4706 zephir_check_call_status();
4707 }
4708 }
4709 ZEPHIR_INIT_NVAR(&column);
4710 ZEPHIR_OBS_VAR(&_103);
4711 zephir_read_property(&_103, this_ptr, ZEND_STRL("nestingLevel"), PH_NOISY_CC);
4712 zephir_update_property_array(this_ptr, SL("sqlColumnAliases"), &_103, &sqlColumnAliases);
4713 ZEPHIR_INIT_VAR(&sqlSelect);
4714 zephir_create_array(&sqlSelect, 3, 0);
4715 zephir_array_update_string(&sqlSelect, SL("models"), &sqlModels, PH_COPY | PH_SEPARATE);
4716 zephir_array_update_string(&sqlSelect, SL("tables"), &sqlTables, PH_COPY | PH_SEPARATE);
4717 zephir_array_update_string(&sqlSelect, SL("columns"), &sqlColumns, PH_COPY | PH_SEPARATE);
4718 ZEPHIR_OBS_VAR(&distinct);
4719 if (zephir_array_isset_string_fetch(&distinct, &select, SL("distinct"), 0)) {
4720 zephir_array_update_string(&sqlSelect, SL("distinct"), &distinct, PH_COPY | PH_SEPARATE);
4721 }
4722 if (zephir_fast_count_int(&sqlJoins)) {
4723 zephir_array_update_string(&sqlSelect, SL("joins"), &sqlJoins, PH_COPY | PH_SEPARATE);
4724 }
4725 ZEPHIR_OBS_VAR(&where);
4726 if (zephir_array_isset_string_fetch(&where, ast, SL("where"), 0)) {
4727 ZEPHIR_CALL_METHOD(&_104$$92, this_ptr, "_getexpression", NULL, 474, &where);
4728 zephir_check_call_status();
4729 zephir_array_update_string(&sqlSelect, SL("where"), &_104$$92, PH_COPY | PH_SEPARATE);
4730 }
4731 ZEPHIR_OBS_VAR(&groupBy);
4732 if (zephir_array_isset_string_fetch(&groupBy, ast, SL("groupBy"), 0)) {
4733 ZEPHIR_CALL_METHOD(&_105$$93, this_ptr, "_getgroupclause", NULL, 486, &groupBy);
4734 zephir_check_call_status();
4735 zephir_array_update_string(&sqlSelect, SL("group"), &_105$$93, PH_COPY | PH_SEPARATE);
4736 }
4737 ZEPHIR_OBS_VAR(&having);
4738 if (zephir_array_isset_string_fetch(&having, ast, SL("having"), 0)) {
4739 ZEPHIR_CALL_METHOD(&_106$$94, this_ptr, "_getexpression", NULL, 474, &having);
4740 zephir_check_call_status();
4741 zephir_array_update_string(&sqlSelect, SL("having"), &_106$$94, PH_COPY | PH_SEPARATE);
4742 }
4743 ZEPHIR_OBS_VAR(&order);
4744 if (zephir_array_isset_string_fetch(&order, ast, SL("orderBy"), 0)) {
4745 ZEPHIR_CALL_METHOD(&_107$$95, this_ptr, "_getorderclause", NULL, 487, &order);
4746 zephir_check_call_status();
4747 zephir_array_update_string(&sqlSelect, SL("order"), &_107$$95, PH_COPY | PH_SEPARATE);
4748 }
4749 ZEPHIR_OBS_VAR(&limit);
4750 if (zephir_array_isset_string_fetch(&limit, ast, SL("limit"), 0)) {
4751 ZEPHIR_CALL_METHOD(&_108$$96, this_ptr, "_getlimitclause", NULL, 488, &limit);
4752 zephir_check_call_status();
4753 zephir_array_update_string(&sqlSelect, SL("limit"), &_108$$96, PH_COPY | PH_SEPARATE);
4754 }
4755 if (zephir_array_isset_string(ast, SL("forUpdate"))) {
4756 zephir_array_update_string(&sqlSelect, SL("forUpdate"), &__$true, PH_COPY | PH_SEPARATE);
4757 }
4758 if (merge) {
4759 zephir_update_property_zval(this_ptr, ZEND_STRL("models"), &tempModels);
4760 zephir_update_property_zval(this_ptr, ZEND_STRL("modelsInstances"), &tempModelsInstances);
4761 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliases"), &tempSqlAliases);
4762 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModels"), &tempSqlAliasesModels);
4763 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlModelsAliases"), &tempSqlModelsAliases);
4764 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), &tempSqlAliasesModelsInstances);
4765 }
4766 RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("nestingLevel")));
4767 RETURN_CCTOR(&sqlSelect);
4768
4769 }
4770
4771 /**
4772 * Analyzes an INSERT intermediate code and produces an array to be executed
4773 * later
4774 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_prepareInsert)4775 PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareInsert) {
4776
4777 zval _5$$7, _10$$8;
4778 zend_bool notQuoting = 0;
4779 zval ast, qualifiedName, manager, modelName, model, source, schema, exprValues, exprValue, sqlInsert, metaData, fields, sqlFields, field, name, _0, _2, *_3, _4, _1$$6, _6$$7, _7$$7, _8$$7, _11$$8, _12$$8, _13$$8, *_14$$9, _15$$9, _16$$10, _18$$11, _19$$11, _20$$11, _22$$12, _24$$13, _25$$13, _26$$13;
4780 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
4781 zephir_fcall_cache_entry *_9 = NULL, *_17 = NULL, *_21 = NULL, *_23 = NULL;
4782 zend_long ZEPHIR_LAST_CALL_STATUS;
4783 zval *this_ptr = getThis();
4784
4785 ZVAL_UNDEF(&ast);
4786 ZVAL_UNDEF(&qualifiedName);
4787 ZVAL_UNDEF(&manager);
4788 ZVAL_UNDEF(&modelName);
4789 ZVAL_UNDEF(&model);
4790 ZVAL_UNDEF(&source);
4791 ZVAL_UNDEF(&schema);
4792 ZVAL_UNDEF(&exprValues);
4793 ZVAL_UNDEF(&exprValue);
4794 ZVAL_UNDEF(&sqlInsert);
4795 ZVAL_UNDEF(&metaData);
4796 ZVAL_UNDEF(&fields);
4797 ZVAL_UNDEF(&sqlFields);
4798 ZVAL_UNDEF(&field);
4799 ZVAL_UNDEF(&name);
4800 ZVAL_UNDEF(&_0);
4801 ZVAL_UNDEF(&_2);
4802 ZVAL_UNDEF(&_4);
4803 ZVAL_UNDEF(&_1$$6);
4804 ZVAL_UNDEF(&_6$$7);
4805 ZVAL_UNDEF(&_7$$7);
4806 ZVAL_UNDEF(&_8$$7);
4807 ZVAL_UNDEF(&_11$$8);
4808 ZVAL_UNDEF(&_12$$8);
4809 ZVAL_UNDEF(&_13$$8);
4810 ZVAL_UNDEF(&_15$$9);
4811 ZVAL_UNDEF(&_16$$10);
4812 ZVAL_UNDEF(&_18$$11);
4813 ZVAL_UNDEF(&_19$$11);
4814 ZVAL_UNDEF(&_20$$11);
4815 ZVAL_UNDEF(&_22$$12);
4816 ZVAL_UNDEF(&_24$$13);
4817 ZVAL_UNDEF(&_25$$13);
4818 ZVAL_UNDEF(&_26$$13);
4819 ZVAL_UNDEF(&_5$$7);
4820 ZVAL_UNDEF(&_10$$8);
4821
4822 ZEPHIR_MM_GROW();
4823
4824 zephir_read_property(&_0, this_ptr, ZEND_STRL("ast"), PH_NOISY_CC | PH_READONLY);
4825 ZEPHIR_CPY_WRT(&ast, &_0);
4826 if (UNEXPECTED(!(zephir_array_isset_string(&ast, SL("qualifiedName"))))) {
4827 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted INSERT AST", "phalcon/Mvc/Model/Query.zep", 2423);
4828 return;
4829 }
4830 if (UNEXPECTED(!(zephir_array_isset_string(&ast, SL("values"))))) {
4831 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted INSERT AST", "phalcon/Mvc/Model/Query.zep", 2427);
4832 return;
4833 }
4834 ZEPHIR_OBS_VAR(&qualifiedName);
4835 zephir_array_fetch_string(&qualifiedName, &ast, SL("qualifiedName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2430);
4836 if (UNEXPECTED(!(zephir_array_isset_string(&qualifiedName, SL("name"))))) {
4837 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted INSERT AST", "phalcon/Mvc/Model/Query.zep", 2434);
4838 return;
4839 }
4840 zephir_read_property(&_0, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
4841 ZEPHIR_CPY_WRT(&manager, &_0);
4842 ZEPHIR_OBS_VAR(&modelName);
4843 zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2438);
4844 ZEPHIR_CALL_METHOD(&model, &manager, "load", NULL, 0, &modelName);
4845 zephir_check_call_status();
4846 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
4847 zephir_check_call_status();
4848 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
4849 zephir_check_call_status();
4850 if (zephir_is_true(&schema)) {
4851 ZEPHIR_INIT_VAR(&_1$$6);
4852 zephir_create_array(&_1$$6, 2, 0);
4853 zephir_array_fast_append(&_1$$6, &schema);
4854 zephir_array_fast_append(&_1$$6, &source);
4855 ZEPHIR_CPY_WRT(&source, &_1$$6);
4856 }
4857 notQuoting = 0;
4858 ZEPHIR_INIT_VAR(&exprValues);
4859 array_init(&exprValues);
4860 zephir_array_fetch_string(&_2, &ast, SL("values"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2451);
4861 zephir_is_iterable(&_2, 0, "phalcon/Mvc/Model/Query.zep", 2459);
4862 if (Z_TYPE_P(&_2) == IS_ARRAY) {
4863 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_2), _3)
4864 {
4865 ZEPHIR_INIT_NVAR(&exprValue);
4866 ZVAL_COPY(&exprValue, _3);
4867 ZEPHIR_INIT_NVAR(&_5$$7);
4868 zephir_create_array(&_5$$7, 2, 0);
4869 ZEPHIR_OBS_NVAR(&_6$$7);
4870 zephir_array_fetch_string(&_6$$7, &exprValue, SL("type"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2454);
4871 zephir_array_update_string(&_5$$7, SL("type"), &_6$$7, PH_COPY | PH_SEPARATE);
4872 if (notQuoting) {
4873 ZVAL_BOOL(&_8$$7, 1);
4874 } else {
4875 ZVAL_BOOL(&_8$$7, 0);
4876 }
4877 ZEPHIR_CALL_METHOD(&_7$$7, this_ptr, "_getexpression", &_9, 474, &exprValue, &_8$$7);
4878 zephir_check_call_status();
4879 zephir_array_update_string(&_5$$7, SL("value"), &_7$$7, PH_COPY | PH_SEPARATE);
4880 zephir_array_append(&exprValues, &_5$$7, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2456);
4881 } ZEND_HASH_FOREACH_END();
4882 } else {
4883 ZEPHIR_CALL_METHOD(NULL, &_2, "rewind", NULL, 0);
4884 zephir_check_call_status();
4885 while (1) {
4886 ZEPHIR_CALL_METHOD(&_4, &_2, "valid", NULL, 0);
4887 zephir_check_call_status();
4888 if (!zend_is_true(&_4)) {
4889 break;
4890 }
4891 ZEPHIR_CALL_METHOD(&exprValue, &_2, "current", NULL, 0);
4892 zephir_check_call_status();
4893 ZEPHIR_INIT_NVAR(&_10$$8);
4894 zephir_create_array(&_10$$8, 2, 0);
4895 ZEPHIR_OBS_NVAR(&_11$$8);
4896 zephir_array_fetch_string(&_11$$8, &exprValue, SL("type"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2454);
4897 zephir_array_update_string(&_10$$8, SL("type"), &_11$$8, PH_COPY | PH_SEPARATE);
4898 if (notQuoting) {
4899 ZVAL_BOOL(&_13$$8, 1);
4900 } else {
4901 ZVAL_BOOL(&_13$$8, 0);
4902 }
4903 ZEPHIR_CALL_METHOD(&_12$$8, this_ptr, "_getexpression", &_9, 474, &exprValue, &_13$$8);
4904 zephir_check_call_status();
4905 zephir_array_update_string(&_10$$8, SL("value"), &_12$$8, PH_COPY | PH_SEPARATE);
4906 zephir_array_append(&exprValues, &_10$$8, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2456);
4907 ZEPHIR_CALL_METHOD(NULL, &_2, "next", NULL, 0);
4908 zephir_check_call_status();
4909 }
4910 }
4911 ZEPHIR_INIT_NVAR(&exprValue);
4912 ZEPHIR_INIT_VAR(&sqlInsert);
4913 zephir_create_array(&sqlInsert, 2, 0);
4914 zephir_array_update_string(&sqlInsert, SL("model"), &modelName, PH_COPY | PH_SEPARATE);
4915 zephir_array_update_string(&sqlInsert, SL("table"), &source, PH_COPY | PH_SEPARATE);
4916 zephir_read_property(&_0, this_ptr, ZEND_STRL("metaData"), PH_NOISY_CC | PH_READONLY);
4917 ZEPHIR_CPY_WRT(&metaData, &_0);
4918 ZEPHIR_OBS_VAR(&fields);
4919 if (zephir_array_isset_string_fetch(&fields, &ast, SL("fields"), 0)) {
4920 ZEPHIR_INIT_VAR(&sqlFields);
4921 array_init(&sqlFields);
4922 zephir_is_iterable(&fields, 0, "phalcon/Mvc/Model/Query.zep", 2483);
4923 if (Z_TYPE_P(&fields) == IS_ARRAY) {
4924 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&fields), _14$$9)
4925 {
4926 ZEPHIR_INIT_NVAR(&field);
4927 ZVAL_COPY(&field, _14$$9);
4928 ZEPHIR_OBS_NVAR(&name);
4929 zephir_array_fetch_string(&name, &field, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2470);
4930 ZEPHIR_CALL_METHOD(&_16$$10, &metaData, "hasattribute", &_17, 0, &model, &name);
4931 zephir_check_call_status();
4932 if (UNEXPECTED(!zephir_is_true(&_16$$10))) {
4933 ZEPHIR_INIT_NVAR(&_18$$11);
4934 object_init_ex(&_18$$11, phalcon_mvc_model_exception_ce);
4935 zephir_read_property(&_19$$11, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4936 ZEPHIR_INIT_NVAR(&_20$$11);
4937 ZEPHIR_CONCAT_SVSVSV(&_20$$11, "The model '", &modelName, "' doesn't have the attribute '", &name, "', when preparing: ", &_19$$11);
4938 ZEPHIR_CALL_METHOD(NULL, &_18$$11, "__construct", &_21, 8, &_20$$11);
4939 zephir_check_call_status();
4940 zephir_throw_exception_debug(&_18$$11, "phalcon/Mvc/Model/Query.zep", 2476);
4941 ZEPHIR_MM_RESTORE();
4942 return;
4943 }
4944 zephir_array_append(&sqlFields, &name, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2480);
4945 } ZEND_HASH_FOREACH_END();
4946 } else {
4947 ZEPHIR_CALL_METHOD(NULL, &fields, "rewind", NULL, 0);
4948 zephir_check_call_status();
4949 while (1) {
4950 ZEPHIR_CALL_METHOD(&_15$$9, &fields, "valid", NULL, 0);
4951 zephir_check_call_status();
4952 if (!zend_is_true(&_15$$9)) {
4953 break;
4954 }
4955 ZEPHIR_CALL_METHOD(&field, &fields, "current", NULL, 0);
4956 zephir_check_call_status();
4957 ZEPHIR_OBS_NVAR(&name);
4958 zephir_array_fetch_string(&name, &field, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2470);
4959 ZEPHIR_CALL_METHOD(&_22$$12, &metaData, "hasattribute", &_23, 0, &model, &name);
4960 zephir_check_call_status();
4961 if (UNEXPECTED(!zephir_is_true(&_22$$12))) {
4962 ZEPHIR_INIT_NVAR(&_24$$13);
4963 object_init_ex(&_24$$13, phalcon_mvc_model_exception_ce);
4964 zephir_read_property(&_25$$13, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
4965 ZEPHIR_INIT_NVAR(&_26$$13);
4966 ZEPHIR_CONCAT_SVSVSV(&_26$$13, "The model '", &modelName, "' doesn't have the attribute '", &name, "', when preparing: ", &_25$$13);
4967 ZEPHIR_CALL_METHOD(NULL, &_24$$13, "__construct", &_21, 8, &_26$$13);
4968 zephir_check_call_status();
4969 zephir_throw_exception_debug(&_24$$13, "phalcon/Mvc/Model/Query.zep", 2476);
4970 ZEPHIR_MM_RESTORE();
4971 return;
4972 }
4973 zephir_array_append(&sqlFields, &name, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2480);
4974 ZEPHIR_CALL_METHOD(NULL, &fields, "next", NULL, 0);
4975 zephir_check_call_status();
4976 }
4977 }
4978 ZEPHIR_INIT_NVAR(&field);
4979 zephir_array_update_string(&sqlInsert, SL("fields"), &sqlFields, PH_COPY | PH_SEPARATE);
4980 }
4981 zephir_array_update_string(&sqlInsert, SL("values"), &exprValues, PH_COPY | PH_SEPARATE);
4982 RETURN_CCTOR(&sqlInsert);
4983
4984 }
4985
4986 /**
4987 * Analyzes an UPDATE intermediate code and produces an array to be executed
4988 * later
4989 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_prepareUpdate)4990 PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareUpdate) {
4991
4992 zval _15$$20, _22$$21;
4993 zend_bool notQuoting = 0;
4994 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
4995 zval __$null, ast, update, tables, values, modelsInstances, models, sqlTables, sqlAliases, sqlAliasesModelsInstances, updateTables, completeSource, sqlModels, manager, table, qualifiedName, modelName, model, source, schema, alias, sqlFields, sqlValues, updateValues, updateValue, exprColumn, sqlUpdate, where, limit, _0, *_1, _2, *_9, _10, _4$$9, _5$$10, _7$$14, _8$$15, _11$$20, _12$$20, _13$$20, _16$$20, _17$$20, _18$$20, _19$$21, _20$$21, _21$$21, _23$$21, _24$$21, _25$$21, _26$$22, _27$$22, _28$$23;
4996 zephir_fcall_cache_entry *_3 = NULL, *_6 = NULL, *_14 = NULL;
4997 zend_long ZEPHIR_LAST_CALL_STATUS;
4998 zval *this_ptr = getThis();
4999
5000 ZVAL_NULL(&__$null);
5001 ZVAL_UNDEF(&ast);
5002 ZVAL_UNDEF(&update);
5003 ZVAL_UNDEF(&tables);
5004 ZVAL_UNDEF(&values);
5005 ZVAL_UNDEF(&modelsInstances);
5006 ZVAL_UNDEF(&models);
5007 ZVAL_UNDEF(&sqlTables);
5008 ZVAL_UNDEF(&sqlAliases);
5009 ZVAL_UNDEF(&sqlAliasesModelsInstances);
5010 ZVAL_UNDEF(&updateTables);
5011 ZVAL_UNDEF(&completeSource);
5012 ZVAL_UNDEF(&sqlModels);
5013 ZVAL_UNDEF(&manager);
5014 ZVAL_UNDEF(&table);
5015 ZVAL_UNDEF(&qualifiedName);
5016 ZVAL_UNDEF(&modelName);
5017 ZVAL_UNDEF(&model);
5018 ZVAL_UNDEF(&source);
5019 ZVAL_UNDEF(&schema);
5020 ZVAL_UNDEF(&alias);
5021 ZVAL_UNDEF(&sqlFields);
5022 ZVAL_UNDEF(&sqlValues);
5023 ZVAL_UNDEF(&updateValues);
5024 ZVAL_UNDEF(&updateValue);
5025 ZVAL_UNDEF(&exprColumn);
5026 ZVAL_UNDEF(&sqlUpdate);
5027 ZVAL_UNDEF(&where);
5028 ZVAL_UNDEF(&limit);
5029 ZVAL_UNDEF(&_0);
5030 ZVAL_UNDEF(&_2);
5031 ZVAL_UNDEF(&_10);
5032 ZVAL_UNDEF(&_4$$9);
5033 ZVAL_UNDEF(&_5$$10);
5034 ZVAL_UNDEF(&_7$$14);
5035 ZVAL_UNDEF(&_8$$15);
5036 ZVAL_UNDEF(&_11$$20);
5037 ZVAL_UNDEF(&_12$$20);
5038 ZVAL_UNDEF(&_13$$20);
5039 ZVAL_UNDEF(&_16$$20);
5040 ZVAL_UNDEF(&_17$$20);
5041 ZVAL_UNDEF(&_18$$20);
5042 ZVAL_UNDEF(&_19$$21);
5043 ZVAL_UNDEF(&_20$$21);
5044 ZVAL_UNDEF(&_21$$21);
5045 ZVAL_UNDEF(&_23$$21);
5046 ZVAL_UNDEF(&_24$$21);
5047 ZVAL_UNDEF(&_25$$21);
5048 ZVAL_UNDEF(&_26$$22);
5049 ZVAL_UNDEF(&_27$$22);
5050 ZVAL_UNDEF(&_28$$23);
5051 ZVAL_UNDEF(&_15$$20);
5052 ZVAL_UNDEF(&_22$$21);
5053
5054 ZEPHIR_MM_GROW();
5055
5056 zephir_read_property(&_0, this_ptr, ZEND_STRL("ast"), PH_NOISY_CC | PH_READONLY);
5057 ZEPHIR_CPY_WRT(&ast, &_0);
5058 ZEPHIR_OBS_VAR(&update);
5059 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&update, &ast, SL("update"), 0)))) {
5060 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted UPDATE AST", "phalcon/Mvc/Model/Query.zep", 2507);
5061 return;
5062 }
5063 ZEPHIR_OBS_VAR(&tables);
5064 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&tables, &update, SL("tables"), 0)))) {
5065 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted UPDATE AST", "phalcon/Mvc/Model/Query.zep", 2511);
5066 return;
5067 }
5068 ZEPHIR_OBS_VAR(&values);
5069 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&values, &update, SL("values"), 0)))) {
5070 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted UPDATE AST", "phalcon/Mvc/Model/Query.zep", 2515);
5071 return;
5072 }
5073 ZEPHIR_INIT_VAR(&models);
5074 array_init(&models);
5075 ZEPHIR_INIT_VAR(&modelsInstances);
5076 array_init(&modelsInstances);
5077 ZEPHIR_INIT_VAR(&sqlTables);
5078 array_init(&sqlTables);
5079 ZEPHIR_INIT_VAR(&sqlModels);
5080 array_init(&sqlModels);
5081 ZEPHIR_INIT_VAR(&sqlAliases);
5082 array_init(&sqlAliases);
5083 ZEPHIR_INIT_VAR(&sqlAliasesModelsInstances);
5084 array_init(&sqlAliasesModelsInstances);
5085 if (!(zephir_array_isset_long(&tables, 0))) {
5086 ZEPHIR_INIT_VAR(&updateTables);
5087 zephir_create_array(&updateTables, 1, 0);
5088 zephir_array_fast_append(&updateTables, &tables);
5089 } else {
5090 ZEPHIR_CPY_WRT(&updateTables, &tables);
5091 }
5092 zephir_read_property(&_0, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
5093 ZEPHIR_CPY_WRT(&manager, &_0);
5094 zephir_is_iterable(&updateTables, 0, "phalcon/Mvc/Model/Query.zep", 2581);
5095 if (Z_TYPE_P(&updateTables) == IS_ARRAY) {
5096 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&updateTables), _1)
5097 {
5098 ZEPHIR_INIT_NVAR(&table);
5099 ZVAL_COPY(&table, _1);
5100 ZEPHIR_OBS_NVAR(&qualifiedName);
5101 zephir_array_fetch_string(&qualifiedName, &table, SL("qualifiedName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2539);
5102 ZEPHIR_OBS_NVAR(&modelName);
5103 zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2540);
5104 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_3, 0, &modelName);
5105 zephir_check_call_status();
5106 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
5107 zephir_check_call_status();
5108 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
5109 zephir_check_call_status();
5110 ZEPHIR_INIT_NVAR(&completeSource);
5111 if (zephir_is_true(&schema)) {
5112 ZEPHIR_INIT_NVAR(&_4$$9);
5113 zephir_create_array(&_4$$9, 2, 0);
5114 zephir_array_fast_append(&_4$$9, &source);
5115 zephir_array_fast_append(&_4$$9, &schema);
5116 ZEPHIR_CPY_WRT(&completeSource, &_4$$9);
5117 } else {
5118 ZEPHIR_INIT_NVAR(&_5$$10);
5119 zephir_create_array(&_5$$10, 2, 0);
5120 zephir_array_fast_append(&_5$$10, &source);
5121 zephir_array_fast_append(&_5$$10, &__$null);
5122 ZEPHIR_CPY_WRT(&completeSource, &_5$$10);
5123 }
5124 ZEPHIR_OBS_NVAR(&alias);
5125 if (zephir_array_isset_string_fetch(&alias, &table, SL("alias"), 0)) {
5126 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
5127 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2563);
5128 zephir_array_append(&sqlTables, &completeSource, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2564);
5129 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
5130 zephir_array_update_zval(&models, &alias, &modelName, PH_COPY | PH_SEPARATE);
5131 } else {
5132 zephir_array_update_zval(&sqlAliases, &modelName, &source, PH_COPY | PH_SEPARATE);
5133 zephir_array_update_zval(&sqlAliasesModelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5134 zephir_array_append(&sqlTables, &source, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2570);
5135 zephir_array_update_zval(&models, &modelName, &source, PH_COPY | PH_SEPARATE);
5136 }
5137 zephir_array_append(&sqlModels, &modelName, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2574);
5138 zephir_array_update_zval(&modelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5139 } ZEND_HASH_FOREACH_END();
5140 } else {
5141 ZEPHIR_CALL_METHOD(NULL, &updateTables, "rewind", NULL, 0);
5142 zephir_check_call_status();
5143 while (1) {
5144 ZEPHIR_CALL_METHOD(&_2, &updateTables, "valid", NULL, 0);
5145 zephir_check_call_status();
5146 if (!zend_is_true(&_2)) {
5147 break;
5148 }
5149 ZEPHIR_CALL_METHOD(&table, &updateTables, "current", NULL, 0);
5150 zephir_check_call_status();
5151 ZEPHIR_OBS_NVAR(&qualifiedName);
5152 zephir_array_fetch_string(&qualifiedName, &table, SL("qualifiedName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2539);
5153 ZEPHIR_OBS_NVAR(&modelName);
5154 zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2540);
5155 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_6, 0, &modelName);
5156 zephir_check_call_status();
5157 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
5158 zephir_check_call_status();
5159 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
5160 zephir_check_call_status();
5161 if (zephir_is_true(&schema)) {
5162 ZEPHIR_INIT_NVAR(&_7$$14);
5163 zephir_create_array(&_7$$14, 2, 0);
5164 zephir_array_fast_append(&_7$$14, &source);
5165 zephir_array_fast_append(&_7$$14, &schema);
5166 ZEPHIR_CPY_WRT(&completeSource, &_7$$14);
5167 } else {
5168 ZEPHIR_INIT_NVAR(&_8$$15);
5169 zephir_create_array(&_8$$15, 2, 0);
5170 zephir_array_fast_append(&_8$$15, &source);
5171 zephir_array_fast_append(&_8$$15, &__$null);
5172 ZEPHIR_CPY_WRT(&completeSource, &_8$$15);
5173 }
5174 ZEPHIR_OBS_NVAR(&alias);
5175 if (zephir_array_isset_string_fetch(&alias, &table, SL("alias"), 0)) {
5176 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
5177 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2563);
5178 zephir_array_append(&sqlTables, &completeSource, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2564);
5179 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
5180 zephir_array_update_zval(&models, &alias, &modelName, PH_COPY | PH_SEPARATE);
5181 } else {
5182 zephir_array_update_zval(&sqlAliases, &modelName, &source, PH_COPY | PH_SEPARATE);
5183 zephir_array_update_zval(&sqlAliasesModelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5184 zephir_array_append(&sqlTables, &source, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2570);
5185 zephir_array_update_zval(&models, &modelName, &source, PH_COPY | PH_SEPARATE);
5186 }
5187 zephir_array_append(&sqlModels, &modelName, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2574);
5188 zephir_array_update_zval(&modelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5189 ZEPHIR_CALL_METHOD(NULL, &updateTables, "next", NULL, 0);
5190 zephir_check_call_status();
5191 }
5192 }
5193 ZEPHIR_INIT_NVAR(&table);
5194 zephir_update_property_zval(this_ptr, ZEND_STRL("models"), &models);
5195 zephir_update_property_zval(this_ptr, ZEND_STRL("modelsInstances"), &modelsInstances);
5196 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliases"), &sqlAliases);
5197 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), &sqlAliasesModelsInstances);
5198 ZEPHIR_INIT_VAR(&sqlFields);
5199 array_init(&sqlFields);
5200 ZEPHIR_INIT_VAR(&sqlValues);
5201 array_init(&sqlValues);
5202 if (!(zephir_array_isset_long(&values, 0))) {
5203 ZEPHIR_INIT_VAR(&updateValues);
5204 zephir_create_array(&updateValues, 1, 0);
5205 zephir_array_fast_append(&updateValues, &values);
5206 } else {
5207 ZEPHIR_CPY_WRT(&updateValues, &values);
5208 }
5209 notQuoting = 0;
5210 zephir_is_iterable(&updateValues, 0, "phalcon/Mvc/Model/Query.zep", 2605);
5211 if (Z_TYPE_P(&updateValues) == IS_ARRAY) {
5212 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&updateValues), _9)
5213 {
5214 ZEPHIR_INIT_NVAR(&updateValue);
5215 ZVAL_COPY(&updateValue, _9);
5216 zephir_array_fetch_string(&_12$$20, &updateValue, SL("column"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2597);
5217 if (notQuoting) {
5218 ZVAL_BOOL(&_13$$20, 1);
5219 } else {
5220 ZVAL_BOOL(&_13$$20, 0);
5221 }
5222 ZEPHIR_CALL_METHOD(&_11$$20, this_ptr, "_getexpression", &_14, 474, &_12$$20, &_13$$20);
5223 zephir_check_call_status();
5224 zephir_array_append(&sqlFields, &_11$$20, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2597);
5225 ZEPHIR_OBS_NVAR(&exprColumn);
5226 zephir_array_fetch_string(&exprColumn, &updateValue, SL("expr"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2598);
5227 ZEPHIR_INIT_NVAR(&_15$$20);
5228 zephir_create_array(&_15$$20, 2, 0);
5229 ZEPHIR_OBS_NVAR(&_16$$20);
5230 zephir_array_fetch_string(&_16$$20, &exprColumn, SL("type"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2600);
5231 zephir_array_update_string(&_15$$20, SL("type"), &_16$$20, PH_COPY | PH_SEPARATE);
5232 if (notQuoting) {
5233 ZVAL_BOOL(&_18$$20, 1);
5234 } else {
5235 ZVAL_BOOL(&_18$$20, 0);
5236 }
5237 ZEPHIR_CALL_METHOD(&_17$$20, this_ptr, "_getexpression", &_14, 474, &exprColumn, &_18$$20);
5238 zephir_check_call_status();
5239 zephir_array_update_string(&_15$$20, SL("value"), &_17$$20, PH_COPY | PH_SEPARATE);
5240 zephir_array_append(&sqlValues, &_15$$20, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2602);
5241 } ZEND_HASH_FOREACH_END();
5242 } else {
5243 ZEPHIR_CALL_METHOD(NULL, &updateValues, "rewind", NULL, 0);
5244 zephir_check_call_status();
5245 while (1) {
5246 ZEPHIR_CALL_METHOD(&_10, &updateValues, "valid", NULL, 0);
5247 zephir_check_call_status();
5248 if (!zend_is_true(&_10)) {
5249 break;
5250 }
5251 ZEPHIR_CALL_METHOD(&updateValue, &updateValues, "current", NULL, 0);
5252 zephir_check_call_status();
5253 zephir_array_fetch_string(&_20$$21, &updateValue, SL("column"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2597);
5254 if (notQuoting) {
5255 ZVAL_BOOL(&_21$$21, 1);
5256 } else {
5257 ZVAL_BOOL(&_21$$21, 0);
5258 }
5259 ZEPHIR_CALL_METHOD(&_19$$21, this_ptr, "_getexpression", &_14, 474, &_20$$21, &_21$$21);
5260 zephir_check_call_status();
5261 zephir_array_append(&sqlFields, &_19$$21, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2597);
5262 ZEPHIR_OBS_NVAR(&exprColumn);
5263 zephir_array_fetch_string(&exprColumn, &updateValue, SL("expr"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2598);
5264 ZEPHIR_INIT_NVAR(&_22$$21);
5265 zephir_create_array(&_22$$21, 2, 0);
5266 ZEPHIR_OBS_NVAR(&_23$$21);
5267 zephir_array_fetch_string(&_23$$21, &exprColumn, SL("type"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2600);
5268 zephir_array_update_string(&_22$$21, SL("type"), &_23$$21, PH_COPY | PH_SEPARATE);
5269 if (notQuoting) {
5270 ZVAL_BOOL(&_25$$21, 1);
5271 } else {
5272 ZVAL_BOOL(&_25$$21, 0);
5273 }
5274 ZEPHIR_CALL_METHOD(&_24$$21, this_ptr, "_getexpression", &_14, 474, &exprColumn, &_25$$21);
5275 zephir_check_call_status();
5276 zephir_array_update_string(&_22$$21, SL("value"), &_24$$21, PH_COPY | PH_SEPARATE);
5277 zephir_array_append(&sqlValues, &_22$$21, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2602);
5278 ZEPHIR_CALL_METHOD(NULL, &updateValues, "next", NULL, 0);
5279 zephir_check_call_status();
5280 }
5281 }
5282 ZEPHIR_INIT_NVAR(&updateValue);
5283 ZEPHIR_INIT_VAR(&sqlUpdate);
5284 zephir_create_array(&sqlUpdate, 4, 0);
5285 zephir_array_update_string(&sqlUpdate, SL("tables"), &sqlTables, PH_COPY | PH_SEPARATE);
5286 zephir_array_update_string(&sqlUpdate, SL("models"), &sqlModels, PH_COPY | PH_SEPARATE);
5287 zephir_array_update_string(&sqlUpdate, SL("fields"), &sqlFields, PH_COPY | PH_SEPARATE);
5288 zephir_array_update_string(&sqlUpdate, SL("values"), &sqlValues, PH_COPY | PH_SEPARATE);
5289 ZEPHIR_OBS_VAR(&where);
5290 if (zephir_array_isset_string_fetch(&where, &ast, SL("where"), 0)) {
5291 ZVAL_BOOL(&_27$$22, 1);
5292 ZEPHIR_CALL_METHOD(&_26$$22, this_ptr, "_getexpression", &_14, 474, &where, &_27$$22);
5293 zephir_check_call_status();
5294 zephir_array_update_string(&sqlUpdate, SL("where"), &_26$$22, PH_COPY | PH_SEPARATE);
5295 }
5296 ZEPHIR_OBS_VAR(&limit);
5297 if (zephir_array_isset_string_fetch(&limit, &ast, SL("limit"), 0)) {
5298 ZEPHIR_CALL_METHOD(&_28$$23, this_ptr, "_getlimitclause", NULL, 488, &limit);
5299 zephir_check_call_status();
5300 zephir_array_update_string(&sqlUpdate, SL("limit"), &_28$$23, PH_COPY | PH_SEPARATE);
5301 }
5302 RETURN_CCTOR(&sqlUpdate);
5303
5304 }
5305
5306 /**
5307 * Analyzes a DELETE intermediate code and produces an array to be executed
5308 * later
5309 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_prepareDelete)5310 PHP_METHOD(Phalcon_Mvc_Model_Query, _prepareDelete) {
5311
5312 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
5313 zval __$null, ast, delete, tables, models, modelsInstances, sqlTables, sqlModels, sqlAliases, sqlAliasesModelsInstances, deleteTables, manager, table, qualifiedName, modelName, model, source, schema, completeSource, alias, sqlDelete, where, limit, _0, *_1, _2, _4$$8, _5$$9, _7$$13, _8$$14, _9$$17, _10$$17, _11$$18;
5314 zephir_fcall_cache_entry *_3 = NULL, *_6 = NULL;
5315 zend_long ZEPHIR_LAST_CALL_STATUS;
5316 zval *this_ptr = getThis();
5317
5318 ZVAL_NULL(&__$null);
5319 ZVAL_UNDEF(&ast);
5320 ZVAL_UNDEF(&delete);
5321 ZVAL_UNDEF(&tables);
5322 ZVAL_UNDEF(&models);
5323 ZVAL_UNDEF(&modelsInstances);
5324 ZVAL_UNDEF(&sqlTables);
5325 ZVAL_UNDEF(&sqlModels);
5326 ZVAL_UNDEF(&sqlAliases);
5327 ZVAL_UNDEF(&sqlAliasesModelsInstances);
5328 ZVAL_UNDEF(&deleteTables);
5329 ZVAL_UNDEF(&manager);
5330 ZVAL_UNDEF(&table);
5331 ZVAL_UNDEF(&qualifiedName);
5332 ZVAL_UNDEF(&modelName);
5333 ZVAL_UNDEF(&model);
5334 ZVAL_UNDEF(&source);
5335 ZVAL_UNDEF(&schema);
5336 ZVAL_UNDEF(&completeSource);
5337 ZVAL_UNDEF(&alias);
5338 ZVAL_UNDEF(&sqlDelete);
5339 ZVAL_UNDEF(&where);
5340 ZVAL_UNDEF(&limit);
5341 ZVAL_UNDEF(&_0);
5342 ZVAL_UNDEF(&_2);
5343 ZVAL_UNDEF(&_4$$8);
5344 ZVAL_UNDEF(&_5$$9);
5345 ZVAL_UNDEF(&_7$$13);
5346 ZVAL_UNDEF(&_8$$14);
5347 ZVAL_UNDEF(&_9$$17);
5348 ZVAL_UNDEF(&_10$$17);
5349 ZVAL_UNDEF(&_11$$18);
5350
5351 ZEPHIR_MM_GROW();
5352
5353 zephir_read_property(&_0, this_ptr, ZEND_STRL("ast"), PH_NOISY_CC | PH_READONLY);
5354 ZEPHIR_CPY_WRT(&ast, &_0);
5355 ZEPHIR_OBS_VAR(&delete);
5356 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&delete, &ast, SL("delete"), 0)))) {
5357 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted DELETE AST", "phalcon/Mvc/Model/Query.zep", 2637);
5358 return;
5359 }
5360 ZEPHIR_OBS_VAR(&tables);
5361 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&tables, &delete, SL("tables"), 0)))) {
5362 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted DELETE AST", "phalcon/Mvc/Model/Query.zep", 2641);
5363 return;
5364 }
5365 ZEPHIR_INIT_VAR(&models);
5366 array_init(&models);
5367 ZEPHIR_INIT_VAR(&modelsInstances);
5368 array_init(&modelsInstances);
5369 ZEPHIR_INIT_VAR(&sqlTables);
5370 array_init(&sqlTables);
5371 ZEPHIR_INIT_VAR(&sqlModels);
5372 array_init(&sqlModels);
5373 ZEPHIR_INIT_VAR(&sqlAliases);
5374 array_init(&sqlAliases);
5375 ZEPHIR_INIT_VAR(&sqlAliasesModelsInstances);
5376 array_init(&sqlAliasesModelsInstances);
5377 if (!(zephir_array_isset_long(&tables, 0))) {
5378 ZEPHIR_INIT_VAR(&deleteTables);
5379 zephir_create_array(&deleteTables, 1, 0);
5380 zephir_array_fast_append(&deleteTables, &tables);
5381 } else {
5382 ZEPHIR_CPY_WRT(&deleteTables, &tables);
5383 }
5384 zephir_read_property(&_0, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
5385 ZEPHIR_CPY_WRT(&manager, &_0);
5386 zephir_is_iterable(&deleteTables, 0, "phalcon/Mvc/Model/Query.zep", 2701);
5387 if (Z_TYPE_P(&deleteTables) == IS_ARRAY) {
5388 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&deleteTables), _1)
5389 {
5390 ZEPHIR_INIT_NVAR(&table);
5391 ZVAL_COPY(&table, _1);
5392 ZEPHIR_OBS_NVAR(&qualifiedName);
5393 zephir_array_fetch_string(&qualifiedName, &table, SL("qualifiedName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2665);
5394 ZEPHIR_OBS_NVAR(&modelName);
5395 zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2666);
5396 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_3, 0, &modelName);
5397 zephir_check_call_status();
5398 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
5399 zephir_check_call_status();
5400 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
5401 zephir_check_call_status();
5402 ZEPHIR_INIT_NVAR(&completeSource);
5403 if (zephir_is_true(&schema)) {
5404 ZEPHIR_INIT_NVAR(&_4$$8);
5405 zephir_create_array(&_4$$8, 2, 0);
5406 zephir_array_fast_append(&_4$$8, &source);
5407 zephir_array_fast_append(&_4$$8, &schema);
5408 ZEPHIR_CPY_WRT(&completeSource, &_4$$8);
5409 } else {
5410 ZEPHIR_INIT_NVAR(&_5$$9);
5411 zephir_create_array(&_5$$9, 2, 0);
5412 zephir_array_fast_append(&_5$$9, &source);
5413 zephir_array_fast_append(&_5$$9, &__$null);
5414 ZEPHIR_CPY_WRT(&completeSource, &_5$$9);
5415 }
5416 ZEPHIR_OBS_NVAR(&alias);
5417 if (zephir_array_isset_string_fetch(&alias, &table, SL("alias"), 0)) {
5418 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
5419 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2683);
5420 zephir_array_append(&sqlTables, &completeSource, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2684);
5421 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
5422 zephir_array_update_zval(&models, &alias, &modelName, PH_COPY | PH_SEPARATE);
5423 } else {
5424 zephir_array_update_zval(&sqlAliases, &modelName, &source, PH_COPY | PH_SEPARATE);
5425 zephir_array_update_zval(&sqlAliasesModelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5426 zephir_array_append(&sqlTables, &source, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2690);
5427 zephir_array_update_zval(&models, &modelName, &source, PH_COPY | PH_SEPARATE);
5428 }
5429 zephir_array_append(&sqlModels, &modelName, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2694);
5430 zephir_array_update_zval(&modelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5431 } ZEND_HASH_FOREACH_END();
5432 } else {
5433 ZEPHIR_CALL_METHOD(NULL, &deleteTables, "rewind", NULL, 0);
5434 zephir_check_call_status();
5435 while (1) {
5436 ZEPHIR_CALL_METHOD(&_2, &deleteTables, "valid", NULL, 0);
5437 zephir_check_call_status();
5438 if (!zend_is_true(&_2)) {
5439 break;
5440 }
5441 ZEPHIR_CALL_METHOD(&table, &deleteTables, "current", NULL, 0);
5442 zephir_check_call_status();
5443 ZEPHIR_OBS_NVAR(&qualifiedName);
5444 zephir_array_fetch_string(&qualifiedName, &table, SL("qualifiedName"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2665);
5445 ZEPHIR_OBS_NVAR(&modelName);
5446 zephir_array_fetch_string(&modelName, &qualifiedName, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2666);
5447 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_6, 0, &modelName);
5448 zephir_check_call_status();
5449 ZEPHIR_CALL_METHOD(&source, &model, "getsource", NULL, 0);
5450 zephir_check_call_status();
5451 ZEPHIR_CALL_METHOD(&schema, &model, "getschema", NULL, 0);
5452 zephir_check_call_status();
5453 if (zephir_is_true(&schema)) {
5454 ZEPHIR_INIT_NVAR(&_7$$13);
5455 zephir_create_array(&_7$$13, 2, 0);
5456 zephir_array_fast_append(&_7$$13, &source);
5457 zephir_array_fast_append(&_7$$13, &schema);
5458 ZEPHIR_CPY_WRT(&completeSource, &_7$$13);
5459 } else {
5460 ZEPHIR_INIT_NVAR(&_8$$14);
5461 zephir_create_array(&_8$$14, 2, 0);
5462 zephir_array_fast_append(&_8$$14, &source);
5463 zephir_array_fast_append(&_8$$14, &__$null);
5464 ZEPHIR_CPY_WRT(&completeSource, &_8$$14);
5465 }
5466 ZEPHIR_OBS_NVAR(&alias);
5467 if (zephir_array_isset_string_fetch(&alias, &table, SL("alias"), 0)) {
5468 zephir_array_update_zval(&sqlAliases, &alias, &alias, PH_COPY | PH_SEPARATE);
5469 zephir_array_append(&completeSource, &alias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2683);
5470 zephir_array_append(&sqlTables, &completeSource, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2684);
5471 zephir_array_update_zval(&sqlAliasesModelsInstances, &alias, &model, PH_COPY | PH_SEPARATE);
5472 zephir_array_update_zval(&models, &alias, &modelName, PH_COPY | PH_SEPARATE);
5473 } else {
5474 zephir_array_update_zval(&sqlAliases, &modelName, &source, PH_COPY | PH_SEPARATE);
5475 zephir_array_update_zval(&sqlAliasesModelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5476 zephir_array_append(&sqlTables, &source, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2690);
5477 zephir_array_update_zval(&models, &modelName, &source, PH_COPY | PH_SEPARATE);
5478 }
5479 zephir_array_append(&sqlModels, &modelName, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2694);
5480 zephir_array_update_zval(&modelsInstances, &modelName, &model, PH_COPY | PH_SEPARATE);
5481 ZEPHIR_CALL_METHOD(NULL, &deleteTables, "next", NULL, 0);
5482 zephir_check_call_status();
5483 }
5484 }
5485 ZEPHIR_INIT_NVAR(&table);
5486 zephir_update_property_zval(this_ptr, ZEND_STRL("models"), &models);
5487 zephir_update_property_zval(this_ptr, ZEND_STRL("modelsInstances"), &modelsInstances);
5488 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliases"), &sqlAliases);
5489 zephir_update_property_zval(this_ptr, ZEND_STRL("sqlAliasesModelsInstances"), &sqlAliasesModelsInstances);
5490 ZEPHIR_INIT_VAR(&sqlDelete);
5491 array_init(&sqlDelete);
5492 zephir_array_update_string(&sqlDelete, SL("tables"), &sqlTables, PH_COPY | PH_SEPARATE);
5493 zephir_array_update_string(&sqlDelete, SL("models"), &sqlModels, PH_COPY | PH_SEPARATE);
5494 ZEPHIR_OBS_VAR(&where);
5495 if (zephir_array_isset_string_fetch(&where, &ast, SL("where"), 0)) {
5496 ZVAL_BOOL(&_10$$17, 1);
5497 ZEPHIR_CALL_METHOD(&_9$$17, this_ptr, "_getexpression", NULL, 474, &where, &_10$$17);
5498 zephir_check_call_status();
5499 zephir_array_update_string(&sqlDelete, SL("where"), &_9$$17, PH_COPY | PH_SEPARATE);
5500 }
5501 ZEPHIR_OBS_VAR(&limit);
5502 if (zephir_array_isset_string_fetch(&limit, &ast, SL("limit"), 0)) {
5503 ZEPHIR_CALL_METHOD(&_11$$18, this_ptr, "_getlimitclause", NULL, 488, &limit);
5504 zephir_check_call_status();
5505 zephir_array_update_string(&sqlDelete, SL("limit"), &_11$$18, PH_COPY | PH_SEPARATE);
5506 }
5507 RETURN_CCTOR(&sqlDelete);
5508
5509 }
5510
5511 /**
5512 * Parses the intermediate code produced by Phalcon\Mvc\Model\Query\Lang
5513 * generating another intermediate representation that could be executed by
5514 * Phalcon\Mvc\Model\Query
5515 */
PHP_METHOD(Phalcon_Mvc_Model_Query,parse)5516 PHP_METHOD(Phalcon_Mvc_Model_Query, parse) {
5517
5518 zval intermediate, phql, ast, irPhql, uniqueId, type, _0, _2$$5, _3$$7, _4$$13, _5$$13;
5519 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
5520 zend_long ZEPHIR_LAST_CALL_STATUS;
5521 zephir_fcall_cache_entry *_1 = NULL;
5522 zval *this_ptr = getThis();
5523
5524 ZVAL_UNDEF(&intermediate);
5525 ZVAL_UNDEF(&phql);
5526 ZVAL_UNDEF(&ast);
5527 ZVAL_UNDEF(&irPhql);
5528 ZVAL_UNDEF(&uniqueId);
5529 ZVAL_UNDEF(&type);
5530 ZVAL_UNDEF(&_0);
5531 ZVAL_UNDEF(&_2$$5);
5532 ZVAL_UNDEF(&_3$$7);
5533 ZVAL_UNDEF(&_4$$13);
5534 ZVAL_UNDEF(&_5$$13);
5535
5536 ZEPHIR_MM_GROW();
5537
5538 zephir_read_property(&_0, this_ptr, ZEND_STRL("intermediate"), PH_NOISY_CC | PH_READONLY);
5539 ZEPHIR_CPY_WRT(&intermediate, &_0);
5540 if (Z_TYPE_P(&intermediate) == IS_ARRAY) {
5541 RETURN_CCTOR(&intermediate);
5542 }
5543 zephir_read_property(&_0, this_ptr, ZEND_STRL("phql"), PH_NOISY_CC | PH_READONLY);
5544 ZEPHIR_CPY_WRT(&phql, &_0);
5545 ZEPHIR_CALL_CE_STATIC(&ast, phalcon_mvc_model_query_lang_ce, "parsephql", &_1, 0, &phql);
5546 zephir_check_call_status();
5547 ZEPHIR_INIT_VAR(&irPhql);
5548 ZVAL_NULL(&irPhql);
5549 ZEPHIR_INIT_VAR(&uniqueId);
5550 ZVAL_NULL(&uniqueId);
5551 if (Z_TYPE_P(&ast) == IS_ARRAY) {
5552 ZEPHIR_OBS_NVAR(&uniqueId);
5553 if (zephir_array_isset_string_fetch(&uniqueId, &ast, SL("id"), 0)) {
5554 ZEPHIR_OBS_NVAR(&irPhql);
5555 zephir_read_static_property_ce(&_2$$5, phalcon_mvc_model_query_ce, SL("_irPhqlCache"), PH_NOISY_CC | PH_READONLY);
5556 if (zephir_array_isset_fetch(&irPhql, &_2$$5, &uniqueId, 0)) {
5557 if (Z_TYPE_P(&irPhql) == IS_ARRAY) {
5558 zephir_array_fetch_string(&_3$$7, &ast, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2754);
5559 zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_3$$7);
5560 RETURN_CCTOR(&irPhql);
5561 }
5562 }
5563 }
5564 ZEPHIR_OBS_VAR(&type);
5565 if (zephir_array_isset_string_fetch(&type, &ast, SL("type"), 0)) {
5566 zephir_update_property_zval(this_ptr, ZEND_STRL("ast"), &ast);
5567 zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &type);
5568 do {
5569 if (ZEPHIR_IS_LONG(&type, 309)) {
5570 ZEPHIR_CALL_METHOD(&irPhql, this_ptr, "_prepareselect", NULL, 479);
5571 zephir_check_call_status();
5572 break;
5573 }
5574 if (ZEPHIR_IS_LONG(&type, 306)) {
5575 ZEPHIR_CALL_METHOD(&irPhql, this_ptr, "_prepareinsert", NULL, 489);
5576 zephir_check_call_status();
5577 break;
5578 }
5579 if (ZEPHIR_IS_LONG(&type, 300)) {
5580 ZEPHIR_CALL_METHOD(&irPhql, this_ptr, "_prepareupdate", NULL, 490);
5581 zephir_check_call_status();
5582 break;
5583 }
5584 if (ZEPHIR_IS_LONG(&type, 303)) {
5585 ZEPHIR_CALL_METHOD(&irPhql, this_ptr, "_preparedelete", NULL, 491);
5586 zephir_check_call_status();
5587 break;
5588 }
5589 ZEPHIR_INIT_VAR(&_4$$13);
5590 object_init_ex(&_4$$13, phalcon_mvc_model_exception_ce);
5591 ZEPHIR_INIT_VAR(&_5$$13);
5592 ZEPHIR_CONCAT_SVSV(&_5$$13, "Unknown statement ", &type, ", when preparing: ", &phql);
5593 ZEPHIR_CALL_METHOD(NULL, &_4$$13, "__construct", NULL, 8, &_5$$13);
5594 zephir_check_call_status();
5595 zephir_throw_exception_debug(&_4$$13, "phalcon/Mvc/Model/Query.zep", 2788);
5596 ZEPHIR_MM_RESTORE();
5597 return;
5598 } while(0);
5599
5600 }
5601 }
5602 if (UNEXPECTED(Z_TYPE_P(&irPhql) != IS_ARRAY)) {
5603 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Corrupted AST", "phalcon/Mvc/Model/Query.zep", 2794);
5604 return;
5605 }
5606 if (Z_TYPE_P(&uniqueId) == IS_LONG) {
5607 zephir_update_static_property_array_multi_ce(phalcon_mvc_model_query_ce, SL("_irPhqlCache"), &irPhql, SL("z"), 1, &uniqueId);
5608 }
5609 zephir_update_property_zval(this_ptr, ZEND_STRL("intermediate"), &irPhql);
5610 RETURN_CCTOR(&irPhql);
5611
5612 }
5613
5614 /**
5615 * Returns the current cache backend instance
5616 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getCache)5617 PHP_METHOD(Phalcon_Mvc_Model_Query, getCache) {
5618
5619 zval *this_ptr = getThis();
5620
5621
5622 RETURN_MEMBER(getThis(), "cache");
5623
5624 }
5625
5626 /**
5627 * Executes the SELECT intermediate representation producing a
5628 * Phalcon\Mvc\Model\Resultset
5629 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_executeSelect)5630 PHP_METHOD(Phalcon_Mvc_Model_Query, _executeSelect) {
5631
5632 zend_string *_17, *_63, *_69, *_84$$93;
5633 zend_ulong _16, _62, _68, _83$$93;
5634 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
5635 zephir_fcall_cache_entry *_4 = NULL, *_5 = NULL, *_8 = NULL, *_20 = NULL, *_21 = NULL, *_22 = NULL, *_30 = NULL, *_41 = NULL, *_42 = NULL, *_43 = NULL, *_51 = NULL;
5636 zend_long ZEPHIR_LAST_CALL_STATUS, numberObjects = 0;
5637 zend_bool simulate, haveObjects = 0, haveScalars = 0, isComplex = 0, isSimpleStd = 0, isKeepingSnapshots = 0, _38$$28, _59$$46, _90$$83;
5638 zval *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL, *simulate_param = NULL, __$true, __$null, manager, modelName, models, model, connection, connectionTypes, columns, column, selectColumns, simpleColumnMap, metaData, aliasCopy, sqlColumn, attributes, instance, columnMap, attribute, columnAlias, sqlAlias, dialect, sqlSelect, bindCounts, processed, wildcard, value, processedTypes, typeWildcard, result, resultData, cache, resultObject, columns1, typesColumnMap, wildcardValue, resultsetClassName, _0, *_1, _2, *_10, _11, *_14, _15, *_60, _61, *_66, _67, _73, _3$$3, _6$$5, _7$$7, _9$$9, _12$$11, _13$$16, _18$$28, _19$$29, *_23$$31, _24$$31, _29$$31, _26$$34, _28$$35, _31$$36, *_32$$37, _33$$37, _36$$41, _37$$42, _39$$46, _40$$47, *_44$$49, _45$$49, _50$$49, _47$$52, _49$$53, _52$$54, *_53$$55, _54$$55, _57$$59, _58$$60, _64$$67, _65$$71, _70$$73, _71$$76, _72$$79, _74$$90, *_75$$90, _76$$90, _78$$91, _80$$92, *_81$$93, _82$$93, _86$$94, _88$$95, _89$$85, _98$$83, _91$$98, _92$$98, _93$$97, _94$$97, _95$$99, _96$$99;
5639 zval intermediate, bindParams, bindTypes, _25$$34, _27$$35, _34$$38, _35$$39, _46$$52, _48$$53, _55$$56, _56$$57, _77$$91, _79$$92, _85$$94, _87$$95, _97$$97;
5640 zval *this_ptr = getThis();
5641
5642 ZVAL_UNDEF(&intermediate);
5643 ZVAL_UNDEF(&bindParams);
5644 ZVAL_UNDEF(&bindTypes);
5645 ZVAL_UNDEF(&_25$$34);
5646 ZVAL_UNDEF(&_27$$35);
5647 ZVAL_UNDEF(&_34$$38);
5648 ZVAL_UNDEF(&_35$$39);
5649 ZVAL_UNDEF(&_46$$52);
5650 ZVAL_UNDEF(&_48$$53);
5651 ZVAL_UNDEF(&_55$$56);
5652 ZVAL_UNDEF(&_56$$57);
5653 ZVAL_UNDEF(&_77$$91);
5654 ZVAL_UNDEF(&_79$$92);
5655 ZVAL_UNDEF(&_85$$94);
5656 ZVAL_UNDEF(&_87$$95);
5657 ZVAL_UNDEF(&_97$$97);
5658 ZVAL_BOOL(&__$true, 1);
5659 ZVAL_NULL(&__$null);
5660 ZVAL_UNDEF(&manager);
5661 ZVAL_UNDEF(&modelName);
5662 ZVAL_UNDEF(&models);
5663 ZVAL_UNDEF(&model);
5664 ZVAL_UNDEF(&connection);
5665 ZVAL_UNDEF(&connectionTypes);
5666 ZVAL_UNDEF(&columns);
5667 ZVAL_UNDEF(&column);
5668 ZVAL_UNDEF(&selectColumns);
5669 ZVAL_UNDEF(&simpleColumnMap);
5670 ZVAL_UNDEF(&metaData);
5671 ZVAL_UNDEF(&aliasCopy);
5672 ZVAL_UNDEF(&sqlColumn);
5673 ZVAL_UNDEF(&attributes);
5674 ZVAL_UNDEF(&instance);
5675 ZVAL_UNDEF(&columnMap);
5676 ZVAL_UNDEF(&attribute);
5677 ZVAL_UNDEF(&columnAlias);
5678 ZVAL_UNDEF(&sqlAlias);
5679 ZVAL_UNDEF(&dialect);
5680 ZVAL_UNDEF(&sqlSelect);
5681 ZVAL_UNDEF(&bindCounts);
5682 ZVAL_UNDEF(&processed);
5683 ZVAL_UNDEF(&wildcard);
5684 ZVAL_UNDEF(&value);
5685 ZVAL_UNDEF(&processedTypes);
5686 ZVAL_UNDEF(&typeWildcard);
5687 ZVAL_UNDEF(&result);
5688 ZVAL_UNDEF(&resultData);
5689 ZVAL_UNDEF(&cache);
5690 ZVAL_UNDEF(&resultObject);
5691 ZVAL_UNDEF(&columns1);
5692 ZVAL_UNDEF(&typesColumnMap);
5693 ZVAL_UNDEF(&wildcardValue);
5694 ZVAL_UNDEF(&resultsetClassName);
5695 ZVAL_UNDEF(&_0);
5696 ZVAL_UNDEF(&_2);
5697 ZVAL_UNDEF(&_11);
5698 ZVAL_UNDEF(&_15);
5699 ZVAL_UNDEF(&_61);
5700 ZVAL_UNDEF(&_67);
5701 ZVAL_UNDEF(&_73);
5702 ZVAL_UNDEF(&_3$$3);
5703 ZVAL_UNDEF(&_6$$5);
5704 ZVAL_UNDEF(&_7$$7);
5705 ZVAL_UNDEF(&_9$$9);
5706 ZVAL_UNDEF(&_12$$11);
5707 ZVAL_UNDEF(&_13$$16);
5708 ZVAL_UNDEF(&_18$$28);
5709 ZVAL_UNDEF(&_19$$29);
5710 ZVAL_UNDEF(&_24$$31);
5711 ZVAL_UNDEF(&_29$$31);
5712 ZVAL_UNDEF(&_26$$34);
5713 ZVAL_UNDEF(&_28$$35);
5714 ZVAL_UNDEF(&_31$$36);
5715 ZVAL_UNDEF(&_33$$37);
5716 ZVAL_UNDEF(&_36$$41);
5717 ZVAL_UNDEF(&_37$$42);
5718 ZVAL_UNDEF(&_39$$46);
5719 ZVAL_UNDEF(&_40$$47);
5720 ZVAL_UNDEF(&_45$$49);
5721 ZVAL_UNDEF(&_50$$49);
5722 ZVAL_UNDEF(&_47$$52);
5723 ZVAL_UNDEF(&_49$$53);
5724 ZVAL_UNDEF(&_52$$54);
5725 ZVAL_UNDEF(&_54$$55);
5726 ZVAL_UNDEF(&_57$$59);
5727 ZVAL_UNDEF(&_58$$60);
5728 ZVAL_UNDEF(&_64$$67);
5729 ZVAL_UNDEF(&_65$$71);
5730 ZVAL_UNDEF(&_70$$73);
5731 ZVAL_UNDEF(&_71$$76);
5732 ZVAL_UNDEF(&_72$$79);
5733 ZVAL_UNDEF(&_74$$90);
5734 ZVAL_UNDEF(&_76$$90);
5735 ZVAL_UNDEF(&_78$$91);
5736 ZVAL_UNDEF(&_80$$92);
5737 ZVAL_UNDEF(&_82$$93);
5738 ZVAL_UNDEF(&_86$$94);
5739 ZVAL_UNDEF(&_88$$95);
5740 ZVAL_UNDEF(&_89$$85);
5741 ZVAL_UNDEF(&_98$$83);
5742 ZVAL_UNDEF(&_91$$98);
5743 ZVAL_UNDEF(&_92$$98);
5744 ZVAL_UNDEF(&_93$$97);
5745 ZVAL_UNDEF(&_94$$97);
5746 ZVAL_UNDEF(&_95$$99);
5747 ZVAL_UNDEF(&_96$$99);
5748
5749 ZEPHIR_MM_GROW();
5750 zephir_fetch_params(1, 3, 1, &intermediate_param, &bindParams_param, &bindTypes_param, &simulate_param);
5751
5752 zephir_get_arrval(&intermediate, intermediate_param);
5753 zephir_get_arrval(&bindParams, bindParams_param);
5754 zephir_get_arrval(&bindTypes, bindTypes_param);
5755 if (!simulate_param) {
5756 simulate = 0;
5757 } else {
5758 simulate = zephir_get_boolval(simulate_param);
5759 }
5760
5761
5762 zephir_read_property(&_0, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
5763 ZEPHIR_CPY_WRT(&manager, &_0);
5764 ZEPHIR_INIT_VAR(&connectionTypes);
5765 array_init(&connectionTypes);
5766 ZEPHIR_OBS_VAR(&models);
5767 zephir_array_fetch_string(&models, &intermediate, SL("models"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2840);
5768 zephir_is_iterable(&models, 0, "phalcon/Mvc/Model/Query.zep", 2868);
5769 if (Z_TYPE_P(&models) == IS_ARRAY) {
5770 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&models), _1)
5771 {
5772 ZEPHIR_INIT_NVAR(&modelName);
5773 ZVAL_COPY(&modelName, _1);
5774 ZEPHIR_OBS_NVAR(&model);
5775 zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
5776 if (!(zephir_array_isset_fetch(&model, &_3$$3, &modelName, 0))) {
5777 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_4, 0, &modelName);
5778 zephir_check_call_status();
5779 zephir_update_property_array(this_ptr, SL("modelsInstances"), &modelName, &model);
5780 }
5781 ZEPHIR_CALL_METHOD(&connection, this_ptr, "getreadconnection", &_5, 0, &model, &intermediate, &bindParams, &bindTypes);
5782 zephir_check_call_status();
5783 if (Z_TYPE_P(&connection) == IS_OBJECT) {
5784 ZEPHIR_CALL_METHOD(&_6$$5, &connection, "gettype", NULL, 0);
5785 zephir_check_call_status();
5786 zephir_array_update_zval(&connectionTypes, &_6$$5, &__$true, PH_COPY | PH_SEPARATE);
5787 if (UNEXPECTED(zephir_fast_count_int(&connectionTypes) == 2)) {
5788 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Cannot use models of different database systems in the same query", "phalcon/Mvc/Model/Query.zep", 2863);
5789 return;
5790 }
5791 }
5792 } ZEND_HASH_FOREACH_END();
5793 } else {
5794 ZEPHIR_CALL_METHOD(NULL, &models, "rewind", NULL, 0);
5795 zephir_check_call_status();
5796 while (1) {
5797 ZEPHIR_CALL_METHOD(&_2, &models, "valid", NULL, 0);
5798 zephir_check_call_status();
5799 if (!zend_is_true(&_2)) {
5800 break;
5801 }
5802 ZEPHIR_CALL_METHOD(&modelName, &models, "current", NULL, 0);
5803 zephir_check_call_status();
5804 ZEPHIR_OBS_NVAR(&model);
5805 zephir_read_property(&_7$$7, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
5806 if (!(zephir_array_isset_fetch(&model, &_7$$7, &modelName, 0))) {
5807 ZEPHIR_CALL_METHOD(&model, &manager, "load", &_8, 0, &modelName);
5808 zephir_check_call_status();
5809 zephir_update_property_array(this_ptr, SL("modelsInstances"), &modelName, &model);
5810 }
5811 ZEPHIR_CALL_METHOD(&connection, this_ptr, "getreadconnection", &_5, 0, &model, &intermediate, &bindParams, &bindTypes);
5812 zephir_check_call_status();
5813 if (Z_TYPE_P(&connection) == IS_OBJECT) {
5814 ZEPHIR_CALL_METHOD(&_9$$9, &connection, "gettype", NULL, 0);
5815 zephir_check_call_status();
5816 zephir_array_update_zval(&connectionTypes, &_9$$9, &__$true, PH_COPY | PH_SEPARATE);
5817 if (UNEXPECTED(zephir_fast_count_int(&connectionTypes) == 2)) {
5818 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Cannot use models of different database systems in the same query", "phalcon/Mvc/Model/Query.zep", 2863);
5819 return;
5820 }
5821 }
5822 ZEPHIR_CALL_METHOD(NULL, &models, "next", NULL, 0);
5823 zephir_check_call_status();
5824 }
5825 }
5826 ZEPHIR_INIT_NVAR(&modelName);
5827 ZEPHIR_OBS_VAR(&columns);
5828 zephir_array_fetch_string(&columns, &intermediate, SL("columns"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2868);
5829 haveObjects = 0;
5830 haveScalars = 0;
5831 isComplex = 0;
5832 numberObjects = 0;
5833 ZEPHIR_CPY_WRT(&columns1, &columns);
5834 zephir_is_iterable(&columns, 0, "phalcon/Mvc/Model/Query.zep", 2896);
5835 if (Z_TYPE_P(&columns) == IS_ARRAY) {
5836 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&columns), _10)
5837 {
5838 ZEPHIR_INIT_NVAR(&column);
5839 ZVAL_COPY(&column, _10);
5840 if (UNEXPECTED(Z_TYPE_P(&column) != IS_ARRAY)) {
5841 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Invalid column definition", "phalcon/Mvc/Model/Query.zep", 2880);
5842 return;
5843 }
5844 zephir_array_fetch_string(&_12$$11, &column, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2883);
5845 if (ZEPHIR_IS_STRING(&_12$$11, "scalar")) {
5846 if (!(zephir_array_isset_string(&column, SL("balias")))) {
5847 isComplex = 1;
5848 }
5849 haveScalars = 1;
5850 } else {
5851 haveObjects = 1;
5852 numberObjects++;
5853 }
5854 } ZEND_HASH_FOREACH_END();
5855 } else {
5856 ZEPHIR_CALL_METHOD(NULL, &columns, "rewind", NULL, 0);
5857 zephir_check_call_status();
5858 while (1) {
5859 ZEPHIR_CALL_METHOD(&_11, &columns, "valid", NULL, 0);
5860 zephir_check_call_status();
5861 if (!zend_is_true(&_11)) {
5862 break;
5863 }
5864 ZEPHIR_CALL_METHOD(&column, &columns, "current", NULL, 0);
5865 zephir_check_call_status();
5866 if (UNEXPECTED(Z_TYPE_P(&column) != IS_ARRAY)) {
5867 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Invalid column definition", "phalcon/Mvc/Model/Query.zep", 2880);
5868 return;
5869 }
5870 zephir_array_fetch_string(&_13$$16, &column, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2883);
5871 if (ZEPHIR_IS_STRING(&_13$$16, "scalar")) {
5872 if (!(zephir_array_isset_string(&column, SL("balias")))) {
5873 isComplex = 1;
5874 }
5875 haveScalars = 1;
5876 } else {
5877 haveObjects = 1;
5878 numberObjects++;
5879 }
5880 ZEPHIR_CALL_METHOD(NULL, &columns, "next", NULL, 0);
5881 zephir_check_call_status();
5882 }
5883 }
5884 ZEPHIR_INIT_NVAR(&column);
5885 if (!(isComplex)) {
5886 if (haveObjects) {
5887 if (haveScalars) {
5888 isComplex = 1;
5889 } else {
5890 if (numberObjects == 1) {
5891 isSimpleStd = 0;
5892 } else {
5893 isComplex = 1;
5894 }
5895 }
5896 } else {
5897 isSimpleStd = 1;
5898 }
5899 }
5900 ZEPHIR_INIT_VAR(&instance);
5901 ZVAL_NULL(&instance);
5902 ZEPHIR_INIT_VAR(&selectColumns);
5903 array_init(&selectColumns);
5904 ZEPHIR_INIT_VAR(&simpleColumnMap);
5905 array_init(&simpleColumnMap);
5906 zephir_read_property(&_0, this_ptr, ZEND_STRL("metaData"), PH_NOISY_CC | PH_READONLY);
5907 ZEPHIR_CPY_WRT(&metaData, &_0);
5908 zephir_is_iterable(&columns, 0, "phalcon/Mvc/Model/Query.zep", 3002);
5909 if (Z_TYPE_P(&columns) == IS_ARRAY) {
5910 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&columns), _16, _17, _14)
5911 {
5912 ZEPHIR_INIT_NVAR(&aliasCopy);
5913 if (_17 != NULL) {
5914 ZVAL_STR_COPY(&aliasCopy, _17);
5915 } else {
5916 ZVAL_LONG(&aliasCopy, _16);
5917 }
5918 ZEPHIR_INIT_NVAR(&column);
5919 ZVAL_COPY(&column, _14);
5920 ZEPHIR_OBS_NVAR(&sqlColumn);
5921 zephir_array_fetch_string(&sqlColumn, &column, SL("column"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2919);
5922 zephir_array_fetch_string(&_18$$28, &column, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2922);
5923 if (ZEPHIR_IS_STRING(&_18$$28, "object")) {
5924 ZEPHIR_OBS_NVAR(&modelName);
5925 zephir_array_fetch_string(&modelName, &column, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2923);
5926 ZEPHIR_OBS_NVAR(&instance);
5927 zephir_read_property(&_19$$29, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
5928 if (!(zephir_array_isset_fetch(&instance, &_19$$29, &modelName, 0))) {
5929 ZEPHIR_CALL_METHOD(&instance, &manager, "load", &_20, 0, &modelName);
5930 zephir_check_call_status();
5931 zephir_update_property_array(this_ptr, SL("modelsInstances"), &modelName, &instance);
5932 }
5933 ZEPHIR_CALL_METHOD(&attributes, &metaData, "getattributes", &_21, 0, &instance);
5934 zephir_check_call_status();
5935 if (isComplex) {
5936 if (ZEPHIR_GLOBAL(orm).column_renaming) {
5937 ZEPHIR_CALL_METHOD(&columnMap, &metaData, "getcolumnmap", &_22, 0, &instance);
5938 zephir_check_call_status();
5939 } else {
5940 ZEPHIR_INIT_NVAR(&columnMap);
5941 ZVAL_NULL(&columnMap);
5942 }
5943 zephir_is_iterable(&attributes, 0, "phalcon/Mvc/Model/Query.zep", 2959);
5944 if (Z_TYPE_P(&attributes) == IS_ARRAY) {
5945 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&attributes), _23$$31)
5946 {
5947 ZEPHIR_INIT_NVAR(&attribute);
5948 ZVAL_COPY(&attribute, _23$$31);
5949 ZEPHIR_INIT_NVAR(&_25$$34);
5950 zephir_create_array(&_25$$34, 3, 0);
5951 zephir_array_fast_append(&_25$$34, &attribute);
5952 zephir_array_fast_append(&_25$$34, &sqlColumn);
5953 ZEPHIR_INIT_NVAR(&_26$$34);
5954 ZEPHIR_CONCAT_SVSV(&_26$$34, "_", &sqlColumn, "_", &attribute);
5955 zephir_array_fast_append(&_25$$34, &_26$$34);
5956 zephir_array_append(&selectColumns, &_25$$34, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2952);
5957 } ZEND_HASH_FOREACH_END();
5958 } else {
5959 ZEPHIR_CALL_METHOD(NULL, &attributes, "rewind", NULL, 0);
5960 zephir_check_call_status();
5961 while (1) {
5962 ZEPHIR_CALL_METHOD(&_24$$31, &attributes, "valid", NULL, 0);
5963 zephir_check_call_status();
5964 if (!zend_is_true(&_24$$31)) {
5965 break;
5966 }
5967 ZEPHIR_CALL_METHOD(&attribute, &attributes, "current", NULL, 0);
5968 zephir_check_call_status();
5969 ZEPHIR_INIT_NVAR(&_27$$35);
5970 zephir_create_array(&_27$$35, 3, 0);
5971 zephir_array_fast_append(&_27$$35, &attribute);
5972 zephir_array_fast_append(&_27$$35, &sqlColumn);
5973 ZEPHIR_INIT_NVAR(&_28$$35);
5974 ZEPHIR_CONCAT_SVSV(&_28$$35, "_", &sqlColumn, "_", &attribute);
5975 zephir_array_fast_append(&_27$$35, &_28$$35);
5976 zephir_array_append(&selectColumns, &_27$$35, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2952);
5977 ZEPHIR_CALL_METHOD(NULL, &attributes, "next", NULL, 0);
5978 zephir_check_call_status();
5979 }
5980 }
5981 ZEPHIR_INIT_NVAR(&attribute);
5982 zephir_array_update_multi(&columns1, &instance, SL("zs"), 3, &aliasCopy, SL("instance"));
5983 zephir_array_update_multi(&columns1, &attributes, SL("zs"), 3, &aliasCopy, SL("attributes"));
5984 zephir_array_update_multi(&columns1, &columnMap, SL("zs"), 3, &aliasCopy, SL("columnMap"));
5985 ZEPHIR_CALL_METHOD(&_29$$31, &manager, "iskeepingsnapshots", &_30, 0, &instance);
5986 zephir_check_call_status();
5987 isKeepingSnapshots = zephir_get_boolval(&_29$$31);
5988 if (isKeepingSnapshots) {
5989 ZEPHIR_INIT_NVAR(&_31$$36);
5990 ZVAL_BOOL(&_31$$36, isKeepingSnapshots);
5991 zephir_array_update_multi(&columns1, &_31$$36, SL("zs"), 3, &aliasCopy, SL("keepSnapshots"));
5992 }
5993 } else {
5994 zephir_is_iterable(&attributes, 0, "phalcon/Mvc/Model/Query.zep", 2976);
5995 if (Z_TYPE_P(&attributes) == IS_ARRAY) {
5996 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&attributes), _32$$37)
5997 {
5998 ZEPHIR_INIT_NVAR(&attribute);
5999 ZVAL_COPY(&attribute, _32$$37);
6000 ZEPHIR_INIT_NVAR(&_34$$38);
6001 zephir_create_array(&_34$$38, 2, 0);
6002 zephir_array_fast_append(&_34$$38, &attribute);
6003 zephir_array_fast_append(&_34$$38, &sqlColumn);
6004 zephir_array_append(&selectColumns, &_34$$38, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2974);
6005 } ZEND_HASH_FOREACH_END();
6006 } else {
6007 ZEPHIR_CALL_METHOD(NULL, &attributes, "rewind", NULL, 0);
6008 zephir_check_call_status();
6009 while (1) {
6010 ZEPHIR_CALL_METHOD(&_33$$37, &attributes, "valid", NULL, 0);
6011 zephir_check_call_status();
6012 if (!zend_is_true(&_33$$37)) {
6013 break;
6014 }
6015 ZEPHIR_CALL_METHOD(&attribute, &attributes, "current", NULL, 0);
6016 zephir_check_call_status();
6017 ZEPHIR_INIT_NVAR(&_35$$39);
6018 zephir_create_array(&_35$$39, 2, 0);
6019 zephir_array_fast_append(&_35$$39, &attribute);
6020 zephir_array_fast_append(&_35$$39, &sqlColumn);
6021 zephir_array_append(&selectColumns, &_35$$39, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2974);
6022 ZEPHIR_CALL_METHOD(NULL, &attributes, "next", NULL, 0);
6023 zephir_check_call_status();
6024 }
6025 }
6026 ZEPHIR_INIT_NVAR(&attribute);
6027 }
6028 } else {
6029 ZEPHIR_INIT_NVAR(&columnAlias);
6030 if (Z_TYPE_P(&aliasCopy) == IS_LONG) {
6031 ZEPHIR_INIT_NVAR(&_36$$41);
6032 zephir_create_array(&_36$$41, 2, 0);
6033 zephir_array_fast_append(&_36$$41, &sqlColumn);
6034 zephir_array_fast_append(&_36$$41, &__$null);
6035 ZEPHIR_CPY_WRT(&columnAlias, &_36$$41);
6036 } else {
6037 ZEPHIR_INIT_NVAR(&_37$$42);
6038 zephir_create_array(&_37$$42, 3, 0);
6039 zephir_array_fast_append(&_37$$42, &sqlColumn);
6040 zephir_array_fast_append(&_37$$42, &__$null);
6041 zephir_array_fast_append(&_37$$42, &aliasCopy);
6042 ZEPHIR_CPY_WRT(&columnAlias, &_37$$42);
6043 }
6044 zephir_array_append(&selectColumns, &columnAlias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2987);
6045 }
6046 _38$$28 = !isComplex;
6047 if (_38$$28) {
6048 _38$$28 = isSimpleStd;
6049 }
6050 if (_38$$28) {
6051 ZEPHIR_OBS_NVAR(&sqlAlias);
6052 if (zephir_array_isset_string_fetch(&sqlAlias, &column, SL("sqlAlias"), 0)) {
6053 zephir_array_update_zval(&simpleColumnMap, &sqlAlias, &aliasCopy, PH_COPY | PH_SEPARATE);
6054 } else {
6055 zephir_array_update_zval(&simpleColumnMap, &aliasCopy, &aliasCopy, PH_COPY | PH_SEPARATE);
6056 }
6057 }
6058 } ZEND_HASH_FOREACH_END();
6059 } else {
6060 ZEPHIR_CALL_METHOD(NULL, &columns, "rewind", NULL, 0);
6061 zephir_check_call_status();
6062 while (1) {
6063 ZEPHIR_CALL_METHOD(&_15, &columns, "valid", NULL, 0);
6064 zephir_check_call_status();
6065 if (!zend_is_true(&_15)) {
6066 break;
6067 }
6068 ZEPHIR_CALL_METHOD(&aliasCopy, &columns, "key", NULL, 0);
6069 zephir_check_call_status();
6070 ZEPHIR_CALL_METHOD(&column, &columns, "current", NULL, 0);
6071 zephir_check_call_status();
6072 ZEPHIR_OBS_NVAR(&sqlColumn);
6073 zephir_array_fetch_string(&sqlColumn, &column, SL("column"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2919);
6074 zephir_array_fetch_string(&_39$$46, &column, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 2922);
6075 if (ZEPHIR_IS_STRING(&_39$$46, "object")) {
6076 ZEPHIR_OBS_NVAR(&modelName);
6077 zephir_array_fetch_string(&modelName, &column, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 2923);
6078 ZEPHIR_OBS_NVAR(&instance);
6079 zephir_read_property(&_40$$47, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
6080 if (!(zephir_array_isset_fetch(&instance, &_40$$47, &modelName, 0))) {
6081 ZEPHIR_CALL_METHOD(&instance, &manager, "load", &_41, 0, &modelName);
6082 zephir_check_call_status();
6083 zephir_update_property_array(this_ptr, SL("modelsInstances"), &modelName, &instance);
6084 }
6085 ZEPHIR_CALL_METHOD(&attributes, &metaData, "getattributes", &_42, 0, &instance);
6086 zephir_check_call_status();
6087 if (isComplex) {
6088 if (ZEPHIR_GLOBAL(orm).column_renaming) {
6089 ZEPHIR_CALL_METHOD(&columnMap, &metaData, "getcolumnmap", &_43, 0, &instance);
6090 zephir_check_call_status();
6091 } else {
6092 ZEPHIR_INIT_NVAR(&columnMap);
6093 ZVAL_NULL(&columnMap);
6094 }
6095 zephir_is_iterable(&attributes, 0, "phalcon/Mvc/Model/Query.zep", 2959);
6096 if (Z_TYPE_P(&attributes) == IS_ARRAY) {
6097 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&attributes), _44$$49)
6098 {
6099 ZEPHIR_INIT_NVAR(&attribute);
6100 ZVAL_COPY(&attribute, _44$$49);
6101 ZEPHIR_INIT_NVAR(&_46$$52);
6102 zephir_create_array(&_46$$52, 3, 0);
6103 zephir_array_fast_append(&_46$$52, &attribute);
6104 zephir_array_fast_append(&_46$$52, &sqlColumn);
6105 ZEPHIR_INIT_NVAR(&_47$$52);
6106 ZEPHIR_CONCAT_SVSV(&_47$$52, "_", &sqlColumn, "_", &attribute);
6107 zephir_array_fast_append(&_46$$52, &_47$$52);
6108 zephir_array_append(&selectColumns, &_46$$52, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2952);
6109 } ZEND_HASH_FOREACH_END();
6110 } else {
6111 ZEPHIR_CALL_METHOD(NULL, &attributes, "rewind", NULL, 0);
6112 zephir_check_call_status();
6113 while (1) {
6114 ZEPHIR_CALL_METHOD(&_45$$49, &attributes, "valid", NULL, 0);
6115 zephir_check_call_status();
6116 if (!zend_is_true(&_45$$49)) {
6117 break;
6118 }
6119 ZEPHIR_CALL_METHOD(&attribute, &attributes, "current", NULL, 0);
6120 zephir_check_call_status();
6121 ZEPHIR_INIT_NVAR(&_48$$53);
6122 zephir_create_array(&_48$$53, 3, 0);
6123 zephir_array_fast_append(&_48$$53, &attribute);
6124 zephir_array_fast_append(&_48$$53, &sqlColumn);
6125 ZEPHIR_INIT_NVAR(&_49$$53);
6126 ZEPHIR_CONCAT_SVSV(&_49$$53, "_", &sqlColumn, "_", &attribute);
6127 zephir_array_fast_append(&_48$$53, &_49$$53);
6128 zephir_array_append(&selectColumns, &_48$$53, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2952);
6129 ZEPHIR_CALL_METHOD(NULL, &attributes, "next", NULL, 0);
6130 zephir_check_call_status();
6131 }
6132 }
6133 ZEPHIR_INIT_NVAR(&attribute);
6134 zephir_array_update_multi(&columns1, &instance, SL("zs"), 3, &aliasCopy, SL("instance"));
6135 zephir_array_update_multi(&columns1, &attributes, SL("zs"), 3, &aliasCopy, SL("attributes"));
6136 zephir_array_update_multi(&columns1, &columnMap, SL("zs"), 3, &aliasCopy, SL("columnMap"));
6137 ZEPHIR_CALL_METHOD(&_50$$49, &manager, "iskeepingsnapshots", &_51, 0, &instance);
6138 zephir_check_call_status();
6139 isKeepingSnapshots = zephir_get_boolval(&_50$$49);
6140 if (isKeepingSnapshots) {
6141 ZEPHIR_INIT_NVAR(&_52$$54);
6142 ZVAL_BOOL(&_52$$54, isKeepingSnapshots);
6143 zephir_array_update_multi(&columns1, &_52$$54, SL("zs"), 3, &aliasCopy, SL("keepSnapshots"));
6144 }
6145 } else {
6146 zephir_is_iterable(&attributes, 0, "phalcon/Mvc/Model/Query.zep", 2976);
6147 if (Z_TYPE_P(&attributes) == IS_ARRAY) {
6148 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&attributes), _53$$55)
6149 {
6150 ZEPHIR_INIT_NVAR(&attribute);
6151 ZVAL_COPY(&attribute, _53$$55);
6152 ZEPHIR_INIT_NVAR(&_55$$56);
6153 zephir_create_array(&_55$$56, 2, 0);
6154 zephir_array_fast_append(&_55$$56, &attribute);
6155 zephir_array_fast_append(&_55$$56, &sqlColumn);
6156 zephir_array_append(&selectColumns, &_55$$56, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2974);
6157 } ZEND_HASH_FOREACH_END();
6158 } else {
6159 ZEPHIR_CALL_METHOD(NULL, &attributes, "rewind", NULL, 0);
6160 zephir_check_call_status();
6161 while (1) {
6162 ZEPHIR_CALL_METHOD(&_54$$55, &attributes, "valid", NULL, 0);
6163 zephir_check_call_status();
6164 if (!zend_is_true(&_54$$55)) {
6165 break;
6166 }
6167 ZEPHIR_CALL_METHOD(&attribute, &attributes, "current", NULL, 0);
6168 zephir_check_call_status();
6169 ZEPHIR_INIT_NVAR(&_56$$57);
6170 zephir_create_array(&_56$$57, 2, 0);
6171 zephir_array_fast_append(&_56$$57, &attribute);
6172 zephir_array_fast_append(&_56$$57, &sqlColumn);
6173 zephir_array_append(&selectColumns, &_56$$57, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2974);
6174 ZEPHIR_CALL_METHOD(NULL, &attributes, "next", NULL, 0);
6175 zephir_check_call_status();
6176 }
6177 }
6178 ZEPHIR_INIT_NVAR(&attribute);
6179 }
6180 } else {
6181 if (Z_TYPE_P(&aliasCopy) == IS_LONG) {
6182 ZEPHIR_INIT_NVAR(&_57$$59);
6183 zephir_create_array(&_57$$59, 2, 0);
6184 zephir_array_fast_append(&_57$$59, &sqlColumn);
6185 zephir_array_fast_append(&_57$$59, &__$null);
6186 ZEPHIR_CPY_WRT(&columnAlias, &_57$$59);
6187 } else {
6188 ZEPHIR_INIT_NVAR(&_58$$60);
6189 zephir_create_array(&_58$$60, 3, 0);
6190 zephir_array_fast_append(&_58$$60, &sqlColumn);
6191 zephir_array_fast_append(&_58$$60, &__$null);
6192 zephir_array_fast_append(&_58$$60, &aliasCopy);
6193 ZEPHIR_CPY_WRT(&columnAlias, &_58$$60);
6194 }
6195 zephir_array_append(&selectColumns, &columnAlias, PH_SEPARATE, "phalcon/Mvc/Model/Query.zep", 2987);
6196 }
6197 _59$$46 = !isComplex;
6198 if (_59$$46) {
6199 _59$$46 = isSimpleStd;
6200 }
6201 if (_59$$46) {
6202 ZEPHIR_OBS_NVAR(&sqlAlias);
6203 if (zephir_array_isset_string_fetch(&sqlAlias, &column, SL("sqlAlias"), 0)) {
6204 zephir_array_update_zval(&simpleColumnMap, &sqlAlias, &aliasCopy, PH_COPY | PH_SEPARATE);
6205 } else {
6206 zephir_array_update_zval(&simpleColumnMap, &aliasCopy, &aliasCopy, PH_COPY | PH_SEPARATE);
6207 }
6208 }
6209 ZEPHIR_CALL_METHOD(NULL, &columns, "next", NULL, 0);
6210 zephir_check_call_status();
6211 }
6212 }
6213 ZEPHIR_INIT_NVAR(&column);
6214 ZEPHIR_INIT_NVAR(&aliasCopy);
6215 ZEPHIR_INIT_VAR(&processed);
6216 array_init(&processed);
6217 ZEPHIR_INIT_VAR(&bindCounts);
6218 array_init(&bindCounts);
6219 zephir_array_update_string(&intermediate, SL("columns"), &selectColumns, PH_COPY | PH_SEPARATE);
6220 zephir_is_iterable(&bindParams, 0, "phalcon/Mvc/Model/Query.zep", 3023);
6221 if (Z_TYPE_P(&bindParams) == IS_ARRAY) {
6222 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bindParams), _62, _63, _60)
6223 {
6224 ZEPHIR_INIT_NVAR(&wildcard);
6225 if (_63 != NULL) {
6226 ZVAL_STR_COPY(&wildcard, _63);
6227 } else {
6228 ZVAL_LONG(&wildcard, _62);
6229 }
6230 ZEPHIR_INIT_NVAR(&value);
6231 ZVAL_COPY(&value, _60);
6232 if (Z_TYPE_P(&wildcard) == IS_LONG) {
6233 ZEPHIR_INIT_NVAR(&wildcardValue);
6234 ZEPHIR_CONCAT_SV(&wildcardValue, ":", &wildcard);
6235 } else {
6236 ZEPHIR_CPY_WRT(&wildcardValue, &wildcard);
6237 }
6238 zephir_array_update_zval(&processed, &wildcardValue, &value, PH_COPY | PH_SEPARATE);
6239 if (Z_TYPE_P(&value) == IS_ARRAY) {
6240 ZEPHIR_INIT_NVAR(&_64$$67);
6241 ZVAL_LONG(&_64$$67, zephir_fast_count_int(&value));
6242 zephir_array_update_zval(&bindCounts, &wildcardValue, &_64$$67, PH_COPY | PH_SEPARATE);
6243 }
6244 } ZEND_HASH_FOREACH_END();
6245 } else {
6246 ZEPHIR_CALL_METHOD(NULL, &bindParams, "rewind", NULL, 0);
6247 zephir_check_call_status();
6248 while (1) {
6249 ZEPHIR_CALL_METHOD(&_61, &bindParams, "valid", NULL, 0);
6250 zephir_check_call_status();
6251 if (!zend_is_true(&_61)) {
6252 break;
6253 }
6254 ZEPHIR_CALL_METHOD(&wildcard, &bindParams, "key", NULL, 0);
6255 zephir_check_call_status();
6256 ZEPHIR_CALL_METHOD(&value, &bindParams, "current", NULL, 0);
6257 zephir_check_call_status();
6258 if (Z_TYPE_P(&wildcard) == IS_LONG) {
6259 ZEPHIR_INIT_NVAR(&wildcardValue);
6260 ZEPHIR_CONCAT_SV(&wildcardValue, ":", &wildcard);
6261 } else {
6262 ZEPHIR_CPY_WRT(&wildcardValue, &wildcard);
6263 }
6264 zephir_array_update_zval(&processed, &wildcardValue, &value, PH_COPY | PH_SEPARATE);
6265 if (Z_TYPE_P(&value) == IS_ARRAY) {
6266 ZEPHIR_INIT_NVAR(&_65$$71);
6267 ZVAL_LONG(&_65$$71, zephir_fast_count_int(&value));
6268 zephir_array_update_zval(&bindCounts, &wildcardValue, &_65$$71, PH_COPY | PH_SEPARATE);
6269 }
6270 ZEPHIR_CALL_METHOD(NULL, &bindParams, "next", NULL, 0);
6271 zephir_check_call_status();
6272 }
6273 }
6274 ZEPHIR_INIT_NVAR(&value);
6275 ZEPHIR_INIT_NVAR(&wildcard);
6276 ZEPHIR_INIT_VAR(&processedTypes);
6277 array_init(&processedTypes);
6278 zephir_is_iterable(&bindTypes, 0, "phalcon/Mvc/Model/Query.zep", 3036);
6279 if (Z_TYPE_P(&bindTypes) == IS_ARRAY) {
6280 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&bindTypes), _68, _69, _66)
6281 {
6282 ZEPHIR_INIT_NVAR(&typeWildcard);
6283 if (_69 != NULL) {
6284 ZVAL_STR_COPY(&typeWildcard, _69);
6285 } else {
6286 ZVAL_LONG(&typeWildcard, _68);
6287 }
6288 ZEPHIR_INIT_NVAR(&value);
6289 ZVAL_COPY(&value, _66);
6290 if (Z_TYPE_P(&typeWildcard) == IS_LONG) {
6291 ZEPHIR_INIT_NVAR(&_70$$73);
6292 ZEPHIR_CONCAT_SV(&_70$$73, ":", &typeWildcard);
6293 zephir_array_update_zval(&processedTypes, &_70$$73, &value, PH_COPY | PH_SEPARATE);
6294 } else {
6295 zephir_array_update_zval(&processedTypes, &typeWildcard, &value, PH_COPY | PH_SEPARATE);
6296 }
6297 } ZEND_HASH_FOREACH_END();
6298 } else {
6299 ZEPHIR_CALL_METHOD(NULL, &bindTypes, "rewind", NULL, 0);
6300 zephir_check_call_status();
6301 while (1) {
6302 ZEPHIR_CALL_METHOD(&_67, &bindTypes, "valid", NULL, 0);
6303 zephir_check_call_status();
6304 if (!zend_is_true(&_67)) {
6305 break;
6306 }
6307 ZEPHIR_CALL_METHOD(&typeWildcard, &bindTypes, "key", NULL, 0);
6308 zephir_check_call_status();
6309 ZEPHIR_CALL_METHOD(&value, &bindTypes, "current", NULL, 0);
6310 zephir_check_call_status();
6311 if (Z_TYPE_P(&typeWildcard) == IS_LONG) {
6312 ZEPHIR_INIT_NVAR(&_71$$76);
6313 ZEPHIR_CONCAT_SV(&_71$$76, ":", &typeWildcard);
6314 zephir_array_update_zval(&processedTypes, &_71$$76, &value, PH_COPY | PH_SEPARATE);
6315 } else {
6316 zephir_array_update_zval(&processedTypes, &typeWildcard, &value, PH_COPY | PH_SEPARATE);
6317 }
6318 ZEPHIR_CALL_METHOD(NULL, &bindTypes, "next", NULL, 0);
6319 zephir_check_call_status();
6320 }
6321 }
6322 ZEPHIR_INIT_NVAR(&value);
6323 ZEPHIR_INIT_NVAR(&typeWildcard);
6324 if (zephir_fast_count_int(&bindCounts)) {
6325 zephir_array_update_string(&intermediate, SL("bindCounts"), &bindCounts, PH_COPY | PH_SEPARATE);
6326 }
6327 ZEPHIR_CALL_METHOD(&dialect, &connection, "getdialect", NULL, 0);
6328 zephir_check_call_status();
6329 ZEPHIR_CALL_METHOD(&sqlSelect, &dialect, "select", NULL, 0, &intermediate);
6330 zephir_check_call_status();
6331 zephir_read_property(&_0, this_ptr, ZEND_STRL("sharedLock"), PH_NOISY_CC | PH_READONLY);
6332 if (zephir_is_true(&_0)) {
6333 ZEPHIR_CALL_METHOD(&_72$$79, &dialect, "sharedlock", NULL, 0, &sqlSelect);
6334 zephir_check_call_status();
6335 ZEPHIR_CPY_WRT(&sqlSelect, &_72$$79);
6336 }
6337 if (simulate) {
6338 zephir_create_array(return_value, 3, 0);
6339 zephir_array_update_string(return_value, SL("sql"), &sqlSelect, PH_COPY | PH_SEPARATE);
6340 zephir_array_update_string(return_value, SL("bind"), &processed, PH_COPY | PH_SEPARATE);
6341 zephir_array_update_string(return_value, SL("bindTypes"), &processedTypes, PH_COPY | PH_SEPARATE);
6342 RETURN_MM();
6343 }
6344 ZEPHIR_CALL_METHOD(&result, &connection, "query", NULL, 0, &sqlSelect, &processed, &processedTypes);
6345 zephir_check_call_status();
6346 if (zephir_instance_of_ev(&result, phalcon_db_resultinterface_ce)) {
6347 ZEPHIR_CPY_WRT(&resultData, &result);
6348 } else {
6349 ZEPHIR_INIT_NVAR(&resultData);
6350 ZVAL_NULL(&resultData);
6351 }
6352 zephir_read_property(&_73, this_ptr, ZEND_STRL("cache"), PH_NOISY_CC | PH_READONLY);
6353 ZEPHIR_CPY_WRT(&cache, &_73);
6354 if (!(isComplex)) {
6355 if (isSimpleStd) {
6356 ZEPHIR_INIT_VAR(&resultObject);
6357 object_init_ex(&resultObject, phalcon_mvc_model_row_ce);
6358 if (zephir_has_constructor(&resultObject)) {
6359 ZEPHIR_CALL_METHOD(NULL, &resultObject, "__construct", NULL, 0);
6360 zephir_check_call_status();
6361 }
6362 isKeepingSnapshots = 0;
6363 } else {
6364 if (Z_TYPE_P(&instance) == IS_OBJECT) {
6365 ZEPHIR_CPY_WRT(&resultObject, &instance);
6366 } else {
6367 ZEPHIR_CPY_WRT(&resultObject, &model);
6368 }
6369 if (!(ZEPHIR_GLOBAL(orm).cast_on_hydrate)) {
6370 ZEPHIR_CALL_METHOD(&simpleColumnMap, &metaData, "getcolumnmap", NULL, 0, &resultObject);
6371 zephir_check_call_status();
6372 } else {
6373 ZEPHIR_CALL_METHOD(&columnMap, &metaData, "getcolumnmap", NULL, 0, &resultObject);
6374 zephir_check_call_status();
6375 ZEPHIR_CALL_METHOD(&typesColumnMap, &metaData, "getdatatypes", NULL, 0, &resultObject);
6376 zephir_check_call_status();
6377 ZEPHIR_INIT_NVAR(&simpleColumnMap);
6378 if (Z_TYPE_P(&columnMap) == IS_NULL) {
6379 array_init(&simpleColumnMap);
6380 ZEPHIR_CALL_METHOD(&_74$$90, &metaData, "getattributes", NULL, 0, &resultObject);
6381 zephir_check_call_status();
6382 zephir_is_iterable(&_74$$90, 0, "phalcon/Mvc/Model/Query.zep", 3124);
6383 if (Z_TYPE_P(&_74$$90) == IS_ARRAY) {
6384 ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&_74$$90), _75$$90)
6385 {
6386 ZEPHIR_INIT_NVAR(&attribute);
6387 ZVAL_COPY(&attribute, _75$$90);
6388 ZEPHIR_INIT_NVAR(&_77$$91);
6389 zephir_create_array(&_77$$91, 2, 0);
6390 zephir_array_fast_append(&_77$$91, &attribute);
6391 ZEPHIR_OBS_NVAR(&_78$$91);
6392 zephir_array_fetch(&_78$$91, &typesColumnMap, &attribute, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3122);
6393 zephir_array_fast_append(&_77$$91, &_78$$91);
6394 zephir_array_update_zval(&simpleColumnMap, &attribute, &_77$$91, PH_COPY | PH_SEPARATE);
6395 } ZEND_HASH_FOREACH_END();
6396 } else {
6397 ZEPHIR_CALL_METHOD(NULL, &_74$$90, "rewind", NULL, 0);
6398 zephir_check_call_status();
6399 while (1) {
6400 ZEPHIR_CALL_METHOD(&_76$$90, &_74$$90, "valid", NULL, 0);
6401 zephir_check_call_status();
6402 if (!zend_is_true(&_76$$90)) {
6403 break;
6404 }
6405 ZEPHIR_CALL_METHOD(&attribute, &_74$$90, "current", NULL, 0);
6406 zephir_check_call_status();
6407 ZEPHIR_INIT_NVAR(&_79$$92);
6408 zephir_create_array(&_79$$92, 2, 0);
6409 zephir_array_fast_append(&_79$$92, &attribute);
6410 ZEPHIR_OBS_NVAR(&_80$$92);
6411 zephir_array_fetch(&_80$$92, &typesColumnMap, &attribute, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3122);
6412 zephir_array_fast_append(&_79$$92, &_80$$92);
6413 zephir_array_update_zval(&simpleColumnMap, &attribute, &_79$$92, PH_COPY | PH_SEPARATE);
6414 ZEPHIR_CALL_METHOD(NULL, &_74$$90, "next", NULL, 0);
6415 zephir_check_call_status();
6416 }
6417 }
6418 ZEPHIR_INIT_NVAR(&attribute);
6419 } else {
6420 array_init(&simpleColumnMap);
6421 zephir_is_iterable(&columnMap, 0, "phalcon/Mvc/Model/Query.zep", 3133);
6422 if (Z_TYPE_P(&columnMap) == IS_ARRAY) {
6423 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&columnMap), _83$$93, _84$$93, _81$$93)
6424 {
6425 ZEPHIR_INIT_NVAR(&column);
6426 if (_84$$93 != NULL) {
6427 ZVAL_STR_COPY(&column, _84$$93);
6428 } else {
6429 ZVAL_LONG(&column, _83$$93);
6430 }
6431 ZEPHIR_INIT_NVAR(&attribute);
6432 ZVAL_COPY(&attribute, _81$$93);
6433 ZEPHIR_INIT_NVAR(&_85$$94);
6434 zephir_create_array(&_85$$94, 2, 0);
6435 zephir_array_fast_append(&_85$$94, &attribute);
6436 ZEPHIR_OBS_NVAR(&_86$$94);
6437 zephir_array_fetch(&_86$$94, &typesColumnMap, &column, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3131);
6438 zephir_array_fast_append(&_85$$94, &_86$$94);
6439 zephir_array_update_zval(&simpleColumnMap, &column, &_85$$94, PH_COPY | PH_SEPARATE);
6440 } ZEND_HASH_FOREACH_END();
6441 } else {
6442 ZEPHIR_CALL_METHOD(NULL, &columnMap, "rewind", NULL, 0);
6443 zephir_check_call_status();
6444 while (1) {
6445 ZEPHIR_CALL_METHOD(&_82$$93, &columnMap, "valid", NULL, 0);
6446 zephir_check_call_status();
6447 if (!zend_is_true(&_82$$93)) {
6448 break;
6449 }
6450 ZEPHIR_CALL_METHOD(&column, &columnMap, "key", NULL, 0);
6451 zephir_check_call_status();
6452 ZEPHIR_CALL_METHOD(&attribute, &columnMap, "current", NULL, 0);
6453 zephir_check_call_status();
6454 ZEPHIR_INIT_NVAR(&_87$$95);
6455 zephir_create_array(&_87$$95, 2, 0);
6456 zephir_array_fast_append(&_87$$95, &attribute);
6457 ZEPHIR_OBS_NVAR(&_88$$95);
6458 zephir_array_fetch(&_88$$95, &typesColumnMap, &column, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3131);
6459 zephir_array_fast_append(&_87$$95, &_88$$95);
6460 zephir_array_update_zval(&simpleColumnMap, &column, &_87$$95, PH_COPY | PH_SEPARATE);
6461 ZEPHIR_CALL_METHOD(NULL, &columnMap, "next", NULL, 0);
6462 zephir_check_call_status();
6463 }
6464 }
6465 ZEPHIR_INIT_NVAR(&attribute);
6466 ZEPHIR_INIT_NVAR(&column);
6467 }
6468 }
6469 ZEPHIR_CALL_METHOD(&_89$$85, &manager, "iskeepingsnapshots", NULL, 0, &resultObject);
6470 zephir_check_call_status();
6471 isKeepingSnapshots = zephir_get_boolval(&_89$$85);
6472 }
6473 _90$$83 = zephir_instance_of_ev(&resultObject, phalcon_mvc_modelinterface_ce);
6474 if (_90$$83) {
6475 _90$$83 = (zephir_method_exists_ex(&resultObject, ZEND_STRL("getresultsetclass")) == SUCCESS);
6476 }
6477 if (_90$$83) {
6478 ZEPHIR_CALL_METHOD(&resultsetClassName, &resultObject, "getresultsetclass", NULL, 0);
6479 zephir_check_call_status();
6480 if (zephir_is_true(&resultsetClassName)) {
6481 if (UNEXPECTED(!(zephir_class_exists(&resultsetClassName, 1)))) {
6482 ZEPHIR_INIT_VAR(&_91$$98);
6483 object_init_ex(&_91$$98, phalcon_mvc_model_exception_ce);
6484 ZEPHIR_INIT_VAR(&_92$$98);
6485 ZEPHIR_CONCAT_SVS(&_92$$98, "Resultset class \"", &resultsetClassName, "\" not found");
6486 ZEPHIR_CALL_METHOD(NULL, &_91$$98, "__construct", NULL, 8, &_92$$98);
6487 zephir_check_call_status();
6488 zephir_throw_exception_debug(&_91$$98, "phalcon/Mvc/Model/Query.zep", 3149);
6489 ZEPHIR_MM_RESTORE();
6490 return;
6491 }
6492 ZEPHIR_INIT_VAR(&_93$$97);
6493 ZVAL_STRING(&_93$$97, "Phalcon\\Mvc\\Model\\ResultsetInterface");
6494 ZEPHIR_CALL_FUNCTION(&_94$$97, "is_subclass_of", NULL, 467, &resultsetClassName, &_93$$97);
6495 zephir_check_call_status();
6496 if (UNEXPECTED(!zephir_is_true(&_94$$97))) {
6497 ZEPHIR_INIT_VAR(&_95$$99);
6498 object_init_ex(&_95$$99, phalcon_mvc_model_exception_ce);
6499 ZEPHIR_INIT_VAR(&_96$$99);
6500 ZEPHIR_CONCAT_SVS(&_96$$99, "Resultset class \"", &resultsetClassName, "\" must be an implementation of Phalcon\\Mvc\\Model\\ResultsetInterface");
6501 ZEPHIR_CALL_METHOD(NULL, &_95$$99, "__construct", NULL, 8, &_96$$99);
6502 zephir_check_call_status();
6503 zephir_throw_exception_debug(&_95$$99, "phalcon/Mvc/Model/Query.zep", 3155);
6504 ZEPHIR_MM_RESTORE();
6505 return;
6506 }
6507 ZEPHIR_INIT_VAR(&_97$$97);
6508 zephir_create_array(&_97$$97, 5, 0);
6509 zephir_array_fast_append(&_97$$97, &simpleColumnMap);
6510 zephir_array_fast_append(&_97$$97, &resultObject);
6511 zephir_array_fast_append(&_97$$97, &resultData);
6512 zephir_array_fast_append(&_97$$97, &cache);
6513 ZEPHIR_INIT_NVAR(&_93$$97);
6514 ZVAL_BOOL(&_93$$97, isKeepingSnapshots);
6515 zephir_array_fast_append(&_97$$97, &_93$$97);
6516 ZEPHIR_LAST_CALL_STATUS = zephir_create_instance_params(return_value, &resultsetClassName, &_97$$97);
6517 zephir_check_call_status();
6518 RETURN_MM();
6519 }
6520 }
6521 object_init_ex(return_value, phalcon_mvc_model_resultset_simple_ce);
6522 if (isKeepingSnapshots) {
6523 ZVAL_BOOL(&_98$$83, 1);
6524 } else {
6525 ZVAL_BOOL(&_98$$83, 0);
6526 }
6527 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 492, &simpleColumnMap, &resultObject, &resultData, &cache, &_98$$83);
6528 zephir_check_call_status();
6529 RETURN_MM();
6530 }
6531 object_init_ex(return_value, phalcon_mvc_model_resultset_complex_ce);
6532 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 493, &columns1, &resultData, &cache);
6533 zephir_check_call_status();
6534 RETURN_MM();
6535
6536 }
6537
6538 /**
6539 * Executes the INSERT intermediate representation producing a
6540 * Phalcon\Mvc\Model\Query\Status
6541 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_executeInsert)6542 PHP_METHOD(Phalcon_Mvc_Model_Query, _executeInsert) {
6543
6544 zend_string *_5;
6545 zend_ulong _4;
6546 zend_bool automaticFields = 0, _18$$8, _31$$17;
6547 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
6548 zephir_fcall_cache_entry *_7 = NULL, *_9 = NULL, *_14 = NULL, *_16 = NULL, *_17 = NULL, *_22 = NULL, *_24 = NULL, *_30 = NULL;
6549 zend_long ZEPHIR_LAST_CALL_STATUS;
6550 zval *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL, modelName, manager, connection, metaData, attributes, fields, columnMap, dialect, insertValues, number, value, model, values, exprValue, insertValue, wildcard, fieldName, attributeName, insertModel, _0, _1, *_2, _3, _34, _6$$8, _8$$11, _10$$11, _11$$11, _12$$12, _13$$12, _15$$13, _19$$15, _20$$15, _21$$17, _23$$20, _25$$20, _26$$20, _27$$21, _28$$21, _29$$22, _32$$24, _33$$24;
6551 zval intermediate, bindParams, bindTypes;
6552 zval *this_ptr = getThis();
6553
6554 ZVAL_UNDEF(&intermediate);
6555 ZVAL_UNDEF(&bindParams);
6556 ZVAL_UNDEF(&bindTypes);
6557 ZVAL_UNDEF(&modelName);
6558 ZVAL_UNDEF(&manager);
6559 ZVAL_UNDEF(&connection);
6560 ZVAL_UNDEF(&metaData);
6561 ZVAL_UNDEF(&attributes);
6562 ZVAL_UNDEF(&fields);
6563 ZVAL_UNDEF(&columnMap);
6564 ZVAL_UNDEF(&dialect);
6565 ZVAL_UNDEF(&insertValues);
6566 ZVAL_UNDEF(&number);
6567 ZVAL_UNDEF(&value);
6568 ZVAL_UNDEF(&model);
6569 ZVAL_UNDEF(&values);
6570 ZVAL_UNDEF(&exprValue);
6571 ZVAL_UNDEF(&insertValue);
6572 ZVAL_UNDEF(&wildcard);
6573 ZVAL_UNDEF(&fieldName);
6574 ZVAL_UNDEF(&attributeName);
6575 ZVAL_UNDEF(&insertModel);
6576 ZVAL_UNDEF(&_0);
6577 ZVAL_UNDEF(&_1);
6578 ZVAL_UNDEF(&_3);
6579 ZVAL_UNDEF(&_34);
6580 ZVAL_UNDEF(&_6$$8);
6581 ZVAL_UNDEF(&_8$$11);
6582 ZVAL_UNDEF(&_10$$11);
6583 ZVAL_UNDEF(&_11$$11);
6584 ZVAL_UNDEF(&_12$$12);
6585 ZVAL_UNDEF(&_13$$12);
6586 ZVAL_UNDEF(&_15$$13);
6587 ZVAL_UNDEF(&_19$$15);
6588 ZVAL_UNDEF(&_20$$15);
6589 ZVAL_UNDEF(&_21$$17);
6590 ZVAL_UNDEF(&_23$$20);
6591 ZVAL_UNDEF(&_25$$20);
6592 ZVAL_UNDEF(&_26$$20);
6593 ZVAL_UNDEF(&_27$$21);
6594 ZVAL_UNDEF(&_28$$21);
6595 ZVAL_UNDEF(&_29$$22);
6596 ZVAL_UNDEF(&_32$$24);
6597 ZVAL_UNDEF(&_33$$24);
6598
6599 ZEPHIR_MM_GROW();
6600 zephir_fetch_params(1, 3, 0, &intermediate_param, &bindParams_param, &bindTypes_param);
6601
6602 zephir_get_arrval(&intermediate, intermediate_param);
6603 zephir_get_arrval(&bindParams, bindParams_param);
6604 zephir_get_arrval(&bindTypes, bindTypes_param);
6605
6606
6607 ZEPHIR_OBS_VAR(&modelName);
6608 zephir_array_fetch_string(&modelName, &intermediate, SL("model"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3205);
6609 zephir_read_property(&_0, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
6610 ZEPHIR_CPY_WRT(&manager, &_0);
6611 ZEPHIR_OBS_VAR(&model);
6612 zephir_read_property(&_0, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
6613 if (!(zephir_array_isset_fetch(&model, &_0, &modelName, 0))) {
6614 ZEPHIR_CALL_METHOD(&model, &manager, "load", NULL, 0, &modelName);
6615 zephir_check_call_status();
6616 }
6617 ZEPHIR_CALL_METHOD(&connection, this_ptr, "getwriteconnection", NULL, 0, &model, &intermediate, &bindParams, &bindTypes);
6618 zephir_check_call_status();
6619 zephir_read_property(&_1, this_ptr, ZEND_STRL("metaData"), PH_NOISY_CC | PH_READONLY);
6620 ZEPHIR_CPY_WRT(&metaData, &_1);
6621 ZEPHIR_CALL_METHOD(&attributes, &metaData, "getattributes", NULL, 0, &model);
6622 zephir_check_call_status();
6623 automaticFields = 0;
6624 ZEPHIR_OBS_VAR(&fields);
6625 if (!(zephir_array_isset_string_fetch(&fields, &intermediate, SL("fields"), 0))) {
6626 automaticFields = 1;
6627 ZEPHIR_CPY_WRT(&fields, &attributes);
6628 if (ZEPHIR_GLOBAL(orm).column_renaming) {
6629 ZEPHIR_CALL_METHOD(&columnMap, &metaData, "getcolumnmap", NULL, 0, &model);
6630 zephir_check_call_status();
6631 } else {
6632 ZEPHIR_INIT_NVAR(&columnMap);
6633 ZVAL_NULL(&columnMap);
6634 }
6635 }
6636 ZEPHIR_OBS_VAR(&values);
6637 zephir_array_fetch_string(&values, &intermediate, SL("values"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3240);
6638 if (UNEXPECTED(zephir_fast_count_int(&fields) != zephir_fast_count_int(&values))) {
6639 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The column count does not match the values count", "phalcon/Mvc/Model/Query.zep", 3249);
6640 return;
6641 }
6642 ZEPHIR_CALL_METHOD(&dialect, &connection, "getdialect", NULL, 0);
6643 zephir_check_call_status();
6644 ZEPHIR_INIT_VAR(&insertValues);
6645 array_init(&insertValues);
6646 zephir_is_iterable(&values, 0, "phalcon/Mvc/Model/Query.zep", 3320);
6647 if (Z_TYPE_P(&values) == IS_ARRAY) {
6648 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&values), _4, _5, _2)
6649 {
6650 ZEPHIR_INIT_NVAR(&number);
6651 if (_5 != NULL) {
6652 ZVAL_STR_COPY(&number, _5);
6653 } else {
6654 ZVAL_LONG(&number, _4);
6655 }
6656 ZEPHIR_INIT_NVAR(&value);
6657 ZVAL_COPY(&value, _2);
6658 ZEPHIR_OBS_NVAR(&exprValue);
6659 zephir_array_fetch_string(&exprValue, &value, SL("value"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3259);
6660 zephir_array_fetch_string(&_6$$8, &value, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 3261);
6661 do {
6662 if (ZEPHIR_IS_LONG(&_6$$8, 260) || ZEPHIR_IS_LONG(&_6$$8, 258) || ZEPHIR_IS_LONG(&_6$$8, 259)) {
6663 ZEPHIR_CALL_METHOD(&insertValue, &dialect, "getsqlexpression", &_7, 0, &exprValue);
6664 zephir_check_call_status();
6665 break;
6666 }
6667 if (ZEPHIR_IS_LONG(&_6$$8, 322)) {
6668 ZEPHIR_INIT_NVAR(&insertValue);
6669 ZVAL_NULL(&insertValue);
6670 break;
6671 }
6672 if (ZEPHIR_IS_LONG(&_6$$8, 273) || ZEPHIR_IS_LONG(&_6$$8, 274) || ZEPHIR_IS_LONG(&_6$$8, 277)) {
6673 ZEPHIR_CALL_METHOD(&_8$$11, &dialect, "getsqlexpression", &_9, 0, &exprValue);
6674 zephir_check_call_status();
6675 ZEPHIR_INIT_NVAR(&_10$$11);
6676 ZVAL_STRING(&_10$$11, ":");
6677 ZEPHIR_INIT_NVAR(&_11$$11);
6678 ZVAL_STRING(&_11$$11, "");
6679 ZEPHIR_INIT_NVAR(&wildcard);
6680 zephir_fast_str_replace(&wildcard, &_10$$11, &_11$$11, &_8$$11);
6681 ZEPHIR_OBS_NVAR(&insertValue);
6682 if (UNEXPECTED(!(zephir_array_isset_fetch(&insertValue, &bindParams, &wildcard, 0)))) {
6683 ZEPHIR_INIT_NVAR(&_12$$12);
6684 object_init_ex(&_12$$12, phalcon_mvc_model_exception_ce);
6685 ZEPHIR_INIT_NVAR(&_13$$12);
6686 ZEPHIR_CONCAT_SVS(&_13$$12, "Bound parameter '", &wildcard, "' cannot be replaced because it isn't in the placeholders list");
6687 ZEPHIR_CALL_METHOD(NULL, &_12$$12, "__construct", &_14, 8, &_13$$12);
6688 zephir_check_call_status();
6689 zephir_throw_exception_debug(&_12$$12, "phalcon/Mvc/Model/Query.zep", 3285);
6690 ZEPHIR_MM_RESTORE();
6691 return;
6692 }
6693 break;
6694 }
6695 ZEPHIR_INIT_NVAR(&insertValue);
6696 object_init_ex(&insertValue, phalcon_db_rawvalue_ce);
6697 ZEPHIR_CALL_METHOD(&_15$$13, &dialect, "getsqlexpression", &_16, 0, &exprValue);
6698 zephir_check_call_status();
6699 ZEPHIR_CALL_METHOD(NULL, &insertValue, "__construct", &_17, 34, &_15$$13);
6700 zephir_check_call_status();
6701 break;
6702 } while(0);
6703
6704 ZEPHIR_OBS_NVAR(&fieldName);
6705 zephir_array_fetch(&fieldName, &fields, &number, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3298);
6706 _18$$8 = automaticFields;
6707 if (_18$$8) {
6708 _18$$8 = Z_TYPE_P(&columnMap) == IS_ARRAY;
6709 }
6710 if (_18$$8) {
6711 ZEPHIR_OBS_NVAR(&attributeName);
6712 if (UNEXPECTED(!(zephir_array_isset_fetch(&attributeName, &columnMap, &fieldName, 0)))) {
6713 ZEPHIR_INIT_NVAR(&_19$$15);
6714 object_init_ex(&_19$$15, phalcon_mvc_model_exception_ce);
6715 ZEPHIR_INIT_NVAR(&_20$$15);
6716 ZEPHIR_CONCAT_SVS(&_20$$15, "Column '", &fieldName, "' isn't part of the column map");
6717 ZEPHIR_CALL_METHOD(NULL, &_19$$15, "__construct", &_14, 8, &_20$$15);
6718 zephir_check_call_status();
6719 zephir_throw_exception_debug(&_19$$15, "phalcon/Mvc/Model/Query.zep", 3308);
6720 ZEPHIR_MM_RESTORE();
6721 return;
6722 }
6723 } else {
6724 ZEPHIR_CPY_WRT(&attributeName, &fieldName);
6725 }
6726 zephir_array_update_zval(&insertValues, &attributeName, &insertValue, PH_COPY | PH_SEPARATE);
6727 } ZEND_HASH_FOREACH_END();
6728 } else {
6729 ZEPHIR_CALL_METHOD(NULL, &values, "rewind", NULL, 0);
6730 zephir_check_call_status();
6731 while (1) {
6732 ZEPHIR_CALL_METHOD(&_3, &values, "valid", NULL, 0);
6733 zephir_check_call_status();
6734 if (!zend_is_true(&_3)) {
6735 break;
6736 }
6737 ZEPHIR_CALL_METHOD(&number, &values, "key", NULL, 0);
6738 zephir_check_call_status();
6739 ZEPHIR_CALL_METHOD(&value, &values, "current", NULL, 0);
6740 zephir_check_call_status();
6741 ZEPHIR_OBS_NVAR(&exprValue);
6742 zephir_array_fetch_string(&exprValue, &value, SL("value"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3259);
6743 zephir_array_fetch_string(&_21$$17, &value, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 3261);
6744 do {
6745 if (ZEPHIR_IS_LONG(&_21$$17, 260) || ZEPHIR_IS_LONG(&_21$$17, 258) || ZEPHIR_IS_LONG(&_21$$17, 259)) {
6746 ZEPHIR_CALL_METHOD(&insertValue, &dialect, "getsqlexpression", &_22, 0, &exprValue);
6747 zephir_check_call_status();
6748 break;
6749 }
6750 if (ZEPHIR_IS_LONG(&_21$$17, 322)) {
6751 ZEPHIR_INIT_NVAR(&insertValue);
6752 ZVAL_NULL(&insertValue);
6753 break;
6754 }
6755 if (ZEPHIR_IS_LONG(&_21$$17, 273) || ZEPHIR_IS_LONG(&_21$$17, 274) || ZEPHIR_IS_LONG(&_21$$17, 277)) {
6756 ZEPHIR_CALL_METHOD(&_23$$20, &dialect, "getsqlexpression", &_24, 0, &exprValue);
6757 zephir_check_call_status();
6758 ZEPHIR_INIT_NVAR(&_25$$20);
6759 ZVAL_STRING(&_25$$20, ":");
6760 ZEPHIR_INIT_NVAR(&_26$$20);
6761 ZVAL_STRING(&_26$$20, "");
6762 ZEPHIR_INIT_NVAR(&wildcard);
6763 zephir_fast_str_replace(&wildcard, &_25$$20, &_26$$20, &_23$$20);
6764 ZEPHIR_OBS_NVAR(&insertValue);
6765 if (UNEXPECTED(!(zephir_array_isset_fetch(&insertValue, &bindParams, &wildcard, 0)))) {
6766 ZEPHIR_INIT_NVAR(&_27$$21);
6767 object_init_ex(&_27$$21, phalcon_mvc_model_exception_ce);
6768 ZEPHIR_INIT_NVAR(&_28$$21);
6769 ZEPHIR_CONCAT_SVS(&_28$$21, "Bound parameter '", &wildcard, "' cannot be replaced because it isn't in the placeholders list");
6770 ZEPHIR_CALL_METHOD(NULL, &_27$$21, "__construct", &_14, 8, &_28$$21);
6771 zephir_check_call_status();
6772 zephir_throw_exception_debug(&_27$$21, "phalcon/Mvc/Model/Query.zep", 3285);
6773 ZEPHIR_MM_RESTORE();
6774 return;
6775 }
6776 break;
6777 }
6778 ZEPHIR_INIT_NVAR(&insertValue);
6779 object_init_ex(&insertValue, phalcon_db_rawvalue_ce);
6780 ZEPHIR_CALL_METHOD(&_29$$22, &dialect, "getsqlexpression", &_30, 0, &exprValue);
6781 zephir_check_call_status();
6782 ZEPHIR_CALL_METHOD(NULL, &insertValue, "__construct", &_17, 34, &_29$$22);
6783 zephir_check_call_status();
6784 break;
6785 } while(0);
6786
6787 ZEPHIR_OBS_NVAR(&fieldName);
6788 zephir_array_fetch(&fieldName, &fields, &number, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3298);
6789 _31$$17 = automaticFields;
6790 if (_31$$17) {
6791 _31$$17 = Z_TYPE_P(&columnMap) == IS_ARRAY;
6792 }
6793 if (_31$$17) {
6794 ZEPHIR_OBS_NVAR(&attributeName);
6795 if (UNEXPECTED(!(zephir_array_isset_fetch(&attributeName, &columnMap, &fieldName, 0)))) {
6796 ZEPHIR_INIT_NVAR(&_32$$24);
6797 object_init_ex(&_32$$24, phalcon_mvc_model_exception_ce);
6798 ZEPHIR_INIT_NVAR(&_33$$24);
6799 ZEPHIR_CONCAT_SVS(&_33$$24, "Column '", &fieldName, "' isn't part of the column map");
6800 ZEPHIR_CALL_METHOD(NULL, &_32$$24, "__construct", &_14, 8, &_33$$24);
6801 zephir_check_call_status();
6802 zephir_throw_exception_debug(&_32$$24, "phalcon/Mvc/Model/Query.zep", 3308);
6803 ZEPHIR_MM_RESTORE();
6804 return;
6805 }
6806 } else {
6807 ZEPHIR_CPY_WRT(&attributeName, &fieldName);
6808 }
6809 zephir_array_update_zval(&insertValues, &attributeName, &insertValue, PH_COPY | PH_SEPARATE);
6810 ZEPHIR_CALL_METHOD(NULL, &values, "next", NULL, 0);
6811 zephir_check_call_status();
6812 }
6813 }
6814 ZEPHIR_INIT_NVAR(&value);
6815 ZEPHIR_INIT_NVAR(&number);
6816 ZEPHIR_CALL_METHOD(&insertModel, &manager, "load", NULL, 0, &modelName);
6817 zephir_check_call_status();
6818 ZEPHIR_CALL_METHOD(NULL, &insertModel, "assign", NULL, 0, &insertValues);
6819 zephir_check_call_status();
6820 object_init_ex(return_value, phalcon_mvc_model_query_status_ce);
6821 ZEPHIR_CALL_METHOD(&_34, &insertModel, "create", NULL, 0);
6822 zephir_check_call_status();
6823 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 494, &_34, &insertModel);
6824 zephir_check_call_status();
6825 RETURN_MM();
6826
6827 }
6828
6829 /**
6830 * Executes the UPDATE intermediate representation producing a
6831 * Phalcon\Mvc\Model\Query\Status
6832 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_executeUpdate)6833 PHP_METHOD(Phalcon_Mvc_Model_Query, _executeUpdate) {
6834
6835 zend_string *_5;
6836 zend_ulong _4;
6837 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
6838 zephir_fcall_cache_entry *_7 = NULL, *_9 = NULL, *_14 = NULL, *_16 = NULL, *_17 = NULL, *_19 = NULL, *_21 = NULL, *_27 = NULL, *_30 = NULL, *_32 = NULL, *_34 = NULL;
6839 zend_long ZEPHIR_LAST_CALL_STATUS;
6840 zval *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL, models, modelName, model, connection, dialect, fields, values, updateValues, fieldName, value, selectBindParams, selectBindTypes, number, field, records, exprValue, updateValue, wildcard, record, _0, *_2, _3, _29, _35, _1$$4, _6$$5, _8$$10, _10$$10, _11$$10, _12$$11, _13$$11, _15$$13, _18$$14, _20$$19, _22$$19, _23$$19, _24$$20, _25$$20, _26$$22, _28$$23, _31$$24, _33$$25;
6841 zval intermediate, bindParams, bindTypes;
6842 zval *this_ptr = getThis();
6843
6844 ZVAL_UNDEF(&intermediate);
6845 ZVAL_UNDEF(&bindParams);
6846 ZVAL_UNDEF(&bindTypes);
6847 ZVAL_UNDEF(&models);
6848 ZVAL_UNDEF(&modelName);
6849 ZVAL_UNDEF(&model);
6850 ZVAL_UNDEF(&connection);
6851 ZVAL_UNDEF(&dialect);
6852 ZVAL_UNDEF(&fields);
6853 ZVAL_UNDEF(&values);
6854 ZVAL_UNDEF(&updateValues);
6855 ZVAL_UNDEF(&fieldName);
6856 ZVAL_UNDEF(&value);
6857 ZVAL_UNDEF(&selectBindParams);
6858 ZVAL_UNDEF(&selectBindTypes);
6859 ZVAL_UNDEF(&number);
6860 ZVAL_UNDEF(&field);
6861 ZVAL_UNDEF(&records);
6862 ZVAL_UNDEF(&exprValue);
6863 ZVAL_UNDEF(&updateValue);
6864 ZVAL_UNDEF(&wildcard);
6865 ZVAL_UNDEF(&record);
6866 ZVAL_UNDEF(&_0);
6867 ZVAL_UNDEF(&_3);
6868 ZVAL_UNDEF(&_29);
6869 ZVAL_UNDEF(&_35);
6870 ZVAL_UNDEF(&_1$$4);
6871 ZVAL_UNDEF(&_6$$5);
6872 ZVAL_UNDEF(&_8$$10);
6873 ZVAL_UNDEF(&_10$$10);
6874 ZVAL_UNDEF(&_11$$10);
6875 ZVAL_UNDEF(&_12$$11);
6876 ZVAL_UNDEF(&_13$$11);
6877 ZVAL_UNDEF(&_15$$13);
6878 ZVAL_UNDEF(&_18$$14);
6879 ZVAL_UNDEF(&_20$$19);
6880 ZVAL_UNDEF(&_22$$19);
6881 ZVAL_UNDEF(&_23$$19);
6882 ZVAL_UNDEF(&_24$$20);
6883 ZVAL_UNDEF(&_25$$20);
6884 ZVAL_UNDEF(&_26$$22);
6885 ZVAL_UNDEF(&_28$$23);
6886 ZVAL_UNDEF(&_31$$24);
6887 ZVAL_UNDEF(&_33$$25);
6888
6889 ZEPHIR_MM_GROW();
6890 zephir_fetch_params(1, 3, 0, &intermediate_param, &bindParams_param, &bindTypes_param);
6891
6892 zephir_get_arrval(&intermediate, intermediate_param);
6893 zephir_get_arrval(&bindParams, bindParams_param);
6894 zephir_get_arrval(&bindTypes, bindTypes_param);
6895
6896
6897 ZEPHIR_OBS_VAR(&models);
6898 zephir_array_fetch_string(&models, &intermediate, SL("models"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3344);
6899 if (UNEXPECTED(zephir_array_isset_long(&models, 1))) {
6900 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Updating several models at the same time is still not supported", "phalcon/Mvc/Model/Query.zep", 3349);
6901 return;
6902 }
6903 ZEPHIR_OBS_VAR(&modelName);
6904 zephir_array_fetch_long(&modelName, &models, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3352);
6905 ZEPHIR_OBS_VAR(&model);
6906 zephir_read_property(&_0, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
6907 if (!(zephir_array_isset_fetch(&model, &_0, &modelName, 0))) {
6908 zephir_read_property(&_1$$4, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
6909 ZEPHIR_CALL_METHOD(&model, &_1$$4, "load", NULL, 0, &modelName);
6910 zephir_check_call_status();
6911 }
6912 ZEPHIR_CALL_METHOD(&connection, this_ptr, "getwriteconnection", NULL, 0, &model, &intermediate, &bindParams, &bindTypes);
6913 zephir_check_call_status();
6914 ZEPHIR_CALL_METHOD(&dialect, &connection, "getdialect", NULL, 0);
6915 zephir_check_call_status();
6916 ZEPHIR_OBS_VAR(&fields);
6917 zephir_array_fetch_string(&fields, &intermediate, SL("fields"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3371);
6918 ZEPHIR_OBS_VAR(&values);
6919 zephir_array_fetch_string(&values, &intermediate, SL("values"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3372);
6920 ZEPHIR_INIT_VAR(&updateValues);
6921 array_init(&updateValues);
6922 ZEPHIR_CPY_WRT(&selectBindParams, &bindParams);
6923 ZEPHIR_CPY_WRT(&selectBindTypes, &bindTypes);
6924 zephir_is_iterable(&fields, 0, "phalcon/Mvc/Model/Query.zep", 3444);
6925 if (Z_TYPE_P(&fields) == IS_ARRAY) {
6926 ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(&fields), _4, _5, _2)
6927 {
6928 ZEPHIR_INIT_NVAR(&number);
6929 if (_5 != NULL) {
6930 ZVAL_STR_COPY(&number, _5);
6931 } else {
6932 ZVAL_LONG(&number, _4);
6933 }
6934 ZEPHIR_INIT_NVAR(&field);
6935 ZVAL_COPY(&field, _2);
6936 ZEPHIR_OBS_NVAR(&value);
6937 zephir_array_fetch(&value, &values, &number, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3387);
6938 ZEPHIR_OBS_NVAR(&exprValue);
6939 zephir_array_fetch_string(&exprValue, &value, SL("value"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3388);
6940 if (zephir_array_isset_string(&field, SL("balias"))) {
6941 ZEPHIR_OBS_NVAR(&fieldName);
6942 zephir_array_fetch_string(&fieldName, &field, SL("balias"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3391);
6943 } else {
6944 ZEPHIR_OBS_NVAR(&fieldName);
6945 zephir_array_fetch_string(&fieldName, &field, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3393);
6946 }
6947 zephir_array_fetch_string(&_6$$5, &value, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 3396);
6948 do {
6949 if (ZEPHIR_IS_LONG(&_6$$5, 260) || ZEPHIR_IS_LONG(&_6$$5, 258) || ZEPHIR_IS_LONG(&_6$$5, 259)) {
6950 ZEPHIR_CALL_METHOD(&updateValue, &dialect, "getsqlexpression", &_7, 0, &exprValue);
6951 zephir_check_call_status();
6952 break;
6953 }
6954 if (ZEPHIR_IS_LONG(&_6$$5, 322)) {
6955 ZEPHIR_INIT_NVAR(&updateValue);
6956 ZVAL_NULL(&updateValue);
6957 break;
6958 }
6959 if (ZEPHIR_IS_LONG(&_6$$5, 273) || ZEPHIR_IS_LONG(&_6$$5, 274) || ZEPHIR_IS_LONG(&_6$$5, 277)) {
6960 ZEPHIR_CALL_METHOD(&_8$$10, &dialect, "getsqlexpression", &_9, 0, &exprValue);
6961 zephir_check_call_status();
6962 ZEPHIR_INIT_NVAR(&_10$$10);
6963 ZVAL_STRING(&_10$$10, ":");
6964 ZEPHIR_INIT_NVAR(&_11$$10);
6965 ZVAL_STRING(&_11$$10, "");
6966 ZEPHIR_INIT_NVAR(&wildcard);
6967 zephir_fast_str_replace(&wildcard, &_10$$10, &_11$$10, &_8$$10);
6968 ZEPHIR_OBS_NVAR(&updateValue);
6969 if (UNEXPECTED(!(zephir_array_isset_fetch(&updateValue, &bindParams, &wildcard, 0)))) {
6970 ZEPHIR_INIT_NVAR(&_12$$11);
6971 object_init_ex(&_12$$11, phalcon_mvc_model_exception_ce);
6972 ZEPHIR_INIT_NVAR(&_13$$11);
6973 ZEPHIR_CONCAT_SVS(&_13$$11, "Bound parameter '", &wildcard, "' cannot be replaced because it's not in the placeholders list");
6974 ZEPHIR_CALL_METHOD(NULL, &_12$$11, "__construct", &_14, 8, &_13$$11);
6975 zephir_check_call_status();
6976 zephir_throw_exception_debug(&_12$$11, "phalcon/Mvc/Model/Query.zep", 3419);
6977 ZEPHIR_MM_RESTORE();
6978 return;
6979 }
6980 zephir_array_unset(&selectBindParams, &wildcard, PH_SEPARATE);
6981 zephir_array_unset(&selectBindTypes, &wildcard, PH_SEPARATE);
6982 break;
6983 }
6984 if (ZEPHIR_IS_LONG(&_6$$5, 277)) {
6985 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Not supported", "phalcon/Mvc/Model/Query.zep", 3428);
6986 return;
6987 }
6988 ZEPHIR_INIT_NVAR(&updateValue);
6989 object_init_ex(&updateValue, phalcon_db_rawvalue_ce);
6990 ZEPHIR_CALL_METHOD(&_15$$13, &dialect, "getsqlexpression", &_16, 0, &exprValue);
6991 zephir_check_call_status();
6992 ZEPHIR_CALL_METHOD(NULL, &updateValue, "__construct", &_17, 34, &_15$$13);
6993 zephir_check_call_status();
6994 break;
6995 } while(0);
6996
6997 zephir_array_update_zval(&updateValues, &fieldName, &updateValue, PH_COPY | PH_SEPARATE);
6998 } ZEND_HASH_FOREACH_END();
6999 } else {
7000 ZEPHIR_CALL_METHOD(NULL, &fields, "rewind", NULL, 0);
7001 zephir_check_call_status();
7002 while (1) {
7003 ZEPHIR_CALL_METHOD(&_3, &fields, "valid", NULL, 0);
7004 zephir_check_call_status();
7005 if (!zend_is_true(&_3)) {
7006 break;
7007 }
7008 ZEPHIR_CALL_METHOD(&number, &fields, "key", NULL, 0);
7009 zephir_check_call_status();
7010 ZEPHIR_CALL_METHOD(&field, &fields, "current", NULL, 0);
7011 zephir_check_call_status();
7012 ZEPHIR_OBS_NVAR(&value);
7013 zephir_array_fetch(&value, &values, &number, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3387);
7014 ZEPHIR_OBS_NVAR(&exprValue);
7015 zephir_array_fetch_string(&exprValue, &value, SL("value"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3388);
7016 if (zephir_array_isset_string(&field, SL("balias"))) {
7017 ZEPHIR_OBS_NVAR(&fieldName);
7018 zephir_array_fetch_string(&fieldName, &field, SL("balias"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3391);
7019 } else {
7020 ZEPHIR_OBS_NVAR(&fieldName);
7021 zephir_array_fetch_string(&fieldName, &field, SL("name"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3393);
7022 }
7023 zephir_array_fetch_string(&_18$$14, &value, SL("type"), PH_NOISY | PH_READONLY, "phalcon/Mvc/Model/Query.zep", 3396);
7024 do {
7025 if (ZEPHIR_IS_LONG(&_18$$14, 260) || ZEPHIR_IS_LONG(&_18$$14, 258) || ZEPHIR_IS_LONG(&_18$$14, 259)) {
7026 ZEPHIR_CALL_METHOD(&updateValue, &dialect, "getsqlexpression", &_19, 0, &exprValue);
7027 zephir_check_call_status();
7028 break;
7029 }
7030 if (ZEPHIR_IS_LONG(&_18$$14, 322)) {
7031 ZEPHIR_INIT_NVAR(&updateValue);
7032 ZVAL_NULL(&updateValue);
7033 break;
7034 }
7035 if (ZEPHIR_IS_LONG(&_18$$14, 273) || ZEPHIR_IS_LONG(&_18$$14, 274) || ZEPHIR_IS_LONG(&_18$$14, 277)) {
7036 ZEPHIR_CALL_METHOD(&_20$$19, &dialect, "getsqlexpression", &_21, 0, &exprValue);
7037 zephir_check_call_status();
7038 ZEPHIR_INIT_NVAR(&_22$$19);
7039 ZVAL_STRING(&_22$$19, ":");
7040 ZEPHIR_INIT_NVAR(&_23$$19);
7041 ZVAL_STRING(&_23$$19, "");
7042 ZEPHIR_INIT_NVAR(&wildcard);
7043 zephir_fast_str_replace(&wildcard, &_22$$19, &_23$$19, &_20$$19);
7044 ZEPHIR_OBS_NVAR(&updateValue);
7045 if (UNEXPECTED(!(zephir_array_isset_fetch(&updateValue, &bindParams, &wildcard, 0)))) {
7046 ZEPHIR_INIT_NVAR(&_24$$20);
7047 object_init_ex(&_24$$20, phalcon_mvc_model_exception_ce);
7048 ZEPHIR_INIT_NVAR(&_25$$20);
7049 ZEPHIR_CONCAT_SVS(&_25$$20, "Bound parameter '", &wildcard, "' cannot be replaced because it's not in the placeholders list");
7050 ZEPHIR_CALL_METHOD(NULL, &_24$$20, "__construct", &_14, 8, &_25$$20);
7051 zephir_check_call_status();
7052 zephir_throw_exception_debug(&_24$$20, "phalcon/Mvc/Model/Query.zep", 3419);
7053 ZEPHIR_MM_RESTORE();
7054 return;
7055 }
7056 zephir_array_unset(&selectBindParams, &wildcard, PH_SEPARATE);
7057 zephir_array_unset(&selectBindTypes, &wildcard, PH_SEPARATE);
7058 break;
7059 }
7060 if (ZEPHIR_IS_LONG(&_18$$14, 277)) {
7061 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Not supported", "phalcon/Mvc/Model/Query.zep", 3428);
7062 return;
7063 }
7064 ZEPHIR_INIT_NVAR(&updateValue);
7065 object_init_ex(&updateValue, phalcon_db_rawvalue_ce);
7066 ZEPHIR_CALL_METHOD(&_26$$22, &dialect, "getsqlexpression", &_27, 0, &exprValue);
7067 zephir_check_call_status();
7068 ZEPHIR_CALL_METHOD(NULL, &updateValue, "__construct", &_17, 34, &_26$$22);
7069 zephir_check_call_status();
7070 break;
7071 } while(0);
7072
7073 zephir_array_update_zval(&updateValues, &fieldName, &updateValue, PH_COPY | PH_SEPARATE);
7074 ZEPHIR_CALL_METHOD(NULL, &fields, "next", NULL, 0);
7075 zephir_check_call_status();
7076 }
7077 }
7078 ZEPHIR_INIT_NVAR(&field);
7079 ZEPHIR_INIT_NVAR(&number);
7080 ZEPHIR_CALL_METHOD(&records, this_ptr, "getrelatedrecords", NULL, 495, &model, &intermediate, &selectBindParams, &selectBindTypes);
7081 zephir_check_call_status();
7082 if (!(zephir_fast_count_int(&records))) {
7083 object_init_ex(return_value, phalcon_mvc_model_query_status_ce);
7084 ZVAL_BOOL(&_28$$23, 1);
7085 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 494, &_28$$23);
7086 zephir_check_call_status();
7087 RETURN_MM();
7088 }
7089 ZEPHIR_CALL_METHOD(&connection, this_ptr, "getwriteconnection", NULL, 0, &model, &intermediate, &bindParams, &bindTypes);
7090 zephir_check_call_status();
7091 ZEPHIR_CALL_METHOD(NULL, &connection, "begin", NULL, 0);
7092 zephir_check_call_status();
7093 ZEPHIR_CALL_METHOD(NULL, &records, "rewind", NULL, 0);
7094 zephir_check_call_status();
7095 while (1) {
7096 ZEPHIR_CALL_METHOD(&_29, &records, "valid", NULL, 0);
7097 zephir_check_call_status();
7098 if (!(zephir_is_true(&_29))) {
7099 break;
7100 }
7101 ZEPHIR_CALL_METHOD(&record, &records, "current", &_30, 0);
7102 zephir_check_call_status();
7103 ZEPHIR_CALL_METHOD(NULL, &record, "assign", NULL, 0, &updateValues);
7104 zephir_check_call_status();
7105 ZEPHIR_CALL_METHOD(&_31$$24, &record, "update", NULL, 0);
7106 zephir_check_call_status();
7107 if (!(zephir_is_true(&_31$$24))) {
7108 ZEPHIR_CALL_METHOD(NULL, &connection, "rollback", &_32, 0);
7109 zephir_check_call_status();
7110 object_init_ex(return_value, phalcon_mvc_model_query_status_ce);
7111 ZVAL_BOOL(&_33$$25, 0);
7112 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 494, &_33$$25, &record);
7113 zephir_check_call_status();
7114 RETURN_MM();
7115 }
7116 ZEPHIR_CALL_METHOD(NULL, &records, "next", &_34, 0);
7117 zephir_check_call_status();
7118 }
7119 ZEPHIR_CALL_METHOD(NULL, &connection, "commit", NULL, 0);
7120 zephir_check_call_status();
7121 object_init_ex(return_value, phalcon_mvc_model_query_status_ce);
7122 ZVAL_BOOL(&_35, 1);
7123 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 494, &_35);
7124 zephir_check_call_status();
7125 RETURN_MM();
7126
7127 }
7128
7129 /**
7130 * Executes the DELETE intermediate representation producing a
7131 * Phalcon\Mvc\Model\Query\Status
7132 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_executeDelete)7133 PHP_METHOD(Phalcon_Mvc_Model_Query, _executeDelete) {
7134
7135 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7136 zephir_fcall_cache_entry *_4 = NULL, *_6 = NULL, *_8 = NULL;
7137 zend_long ZEPHIR_LAST_CALL_STATUS;
7138 zval *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL, models, modelName, model, records, connection, record, _0, _3, _9, _1$$4, _2$$5, _5$$6, _7$$7;
7139 zval intermediate, bindParams, bindTypes;
7140 zval *this_ptr = getThis();
7141
7142 ZVAL_UNDEF(&intermediate);
7143 ZVAL_UNDEF(&bindParams);
7144 ZVAL_UNDEF(&bindTypes);
7145 ZVAL_UNDEF(&models);
7146 ZVAL_UNDEF(&modelName);
7147 ZVAL_UNDEF(&model);
7148 ZVAL_UNDEF(&records);
7149 ZVAL_UNDEF(&connection);
7150 ZVAL_UNDEF(&record);
7151 ZVAL_UNDEF(&_0);
7152 ZVAL_UNDEF(&_3);
7153 ZVAL_UNDEF(&_9);
7154 ZVAL_UNDEF(&_1$$4);
7155 ZVAL_UNDEF(&_2$$5);
7156 ZVAL_UNDEF(&_5$$6);
7157 ZVAL_UNDEF(&_7$$7);
7158
7159 ZEPHIR_MM_GROW();
7160 zephir_fetch_params(1, 3, 0, &intermediate_param, &bindParams_param, &bindTypes_param);
7161
7162 zephir_get_arrval(&intermediate, intermediate_param);
7163 zephir_get_arrval(&bindParams, bindParams_param);
7164 zephir_get_arrval(&bindTypes, bindTypes_param);
7165
7166
7167 ZEPHIR_OBS_VAR(&models);
7168 zephir_array_fetch_string(&models, &intermediate, SL("models"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3509);
7169 if (UNEXPECTED(zephir_array_isset_long(&models, 1))) {
7170 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Delete from several models at the same time is still not supported", "phalcon/Mvc/Model/Query.zep", 3514);
7171 return;
7172 }
7173 ZEPHIR_OBS_VAR(&modelName);
7174 zephir_array_fetch_long(&modelName, &models, 0, PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3517);
7175 ZEPHIR_OBS_VAR(&model);
7176 zephir_read_property(&_0, this_ptr, ZEND_STRL("modelsInstances"), PH_NOISY_CC | PH_READONLY);
7177 if (!(zephir_array_isset_fetch(&model, &_0, &modelName, 0))) {
7178 zephir_read_property(&_1$$4, this_ptr, ZEND_STRL("manager"), PH_NOISY_CC | PH_READONLY);
7179 ZEPHIR_CALL_METHOD(&model, &_1$$4, "load", NULL, 0, &modelName);
7180 zephir_check_call_status();
7181 }
7182 ZEPHIR_CALL_METHOD(&records, this_ptr, "getrelatedrecords", NULL, 495, &model, &intermediate, &bindParams, &bindTypes);
7183 zephir_check_call_status();
7184 if (!(zephir_fast_count_int(&records))) {
7185 object_init_ex(return_value, phalcon_mvc_model_query_status_ce);
7186 ZVAL_BOOL(&_2$$5, 1);
7187 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 494, &_2$$5);
7188 zephir_check_call_status();
7189 RETURN_MM();
7190 }
7191 ZEPHIR_CALL_METHOD(&connection, this_ptr, "getwriteconnection", NULL, 0, &model, &intermediate, &bindParams, &bindTypes);
7192 zephir_check_call_status();
7193 ZEPHIR_CALL_METHOD(NULL, &connection, "begin", NULL, 0);
7194 zephir_check_call_status();
7195 ZEPHIR_CALL_METHOD(NULL, &records, "rewind", NULL, 0);
7196 zephir_check_call_status();
7197 while (1) {
7198 ZEPHIR_CALL_METHOD(&_3, &records, "valid", NULL, 0);
7199 zephir_check_call_status();
7200 if (!(zephir_is_true(&_3))) {
7201 break;
7202 }
7203 ZEPHIR_CALL_METHOD(&record, &records, "current", &_4, 0);
7204 zephir_check_call_status();
7205 ZEPHIR_CALL_METHOD(&_5$$6, &record, "delete", NULL, 0);
7206 zephir_check_call_status();
7207 if (!(zephir_is_true(&_5$$6))) {
7208 ZEPHIR_CALL_METHOD(NULL, &connection, "rollback", &_6, 0);
7209 zephir_check_call_status();
7210 object_init_ex(return_value, phalcon_mvc_model_query_status_ce);
7211 ZVAL_BOOL(&_7$$7, 0);
7212 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 494, &_7$$7, &record);
7213 zephir_check_call_status();
7214 RETURN_MM();
7215 }
7216 ZEPHIR_CALL_METHOD(NULL, &records, "next", &_8, 0);
7217 zephir_check_call_status();
7218 }
7219 ZEPHIR_CALL_METHOD(NULL, &connection, "commit", NULL, 0);
7220 zephir_check_call_status();
7221 object_init_ex(return_value, phalcon_mvc_model_query_status_ce);
7222 ZVAL_BOOL(&_9, 1);
7223 ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 494, &_9);
7224 zephir_check_call_status();
7225 RETURN_MM();
7226
7227 }
7228
7229 /**
7230 * Query the records on which the UPDATE/DELETE operation will be done
7231 *
7232 * @todo Remove in v5.0
7233 * @deprecated Use getRelatedRecords()
7234 *
7235 * @return ResultsetInterface
7236 */
PHP_METHOD(Phalcon_Mvc_Model_Query,_getRelatedRecords)7237 PHP_METHOD(Phalcon_Mvc_Model_Query, _getRelatedRecords) {
7238
7239 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7240 zend_long ZEPHIR_LAST_CALL_STATUS;
7241 zval intermediate, bindParams, bindTypes;
7242 zval *model, model_sub, *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL;
7243 zval *this_ptr = getThis();
7244
7245 ZVAL_UNDEF(&model_sub);
7246 ZVAL_UNDEF(&intermediate);
7247 ZVAL_UNDEF(&bindParams);
7248 ZVAL_UNDEF(&bindTypes);
7249
7250 ZEPHIR_MM_GROW();
7251 zephir_fetch_params(1, 4, 0, &model, &intermediate_param, &bindParams_param, &bindTypes_param);
7252
7253 zephir_get_arrval(&intermediate, intermediate_param);
7254 zephir_get_arrval(&bindParams, bindParams_param);
7255 zephir_get_arrval(&bindTypes, bindTypes_param);
7256
7257
7258 ZEPHIR_RETURN_CALL_METHOD(this_ptr, "getrelatedrecords", NULL, 495, model, &intermediate, &bindParams, &bindTypes);
7259 zephir_check_call_status();
7260 RETURN_MM();
7261
7262 }
7263
7264 /**
7265 * Query the records on which the UPDATE/DELETE operation will be done
7266 *
7267 * @return ResultsetInterface
7268 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getRelatedRecords)7269 PHP_METHOD(Phalcon_Mvc_Model_Query, getRelatedRecords) {
7270
7271 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7272 zend_long ZEPHIR_LAST_CALL_STATUS;
7273 zval intermediate, bindParams, bindTypes, _0, _1;
7274 zval *model, model_sub, *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL, selectIr, whereConditions, limitConditions, query, _2, _3, _4, _5, _6;
7275 zval *this_ptr = getThis();
7276
7277 ZVAL_UNDEF(&model_sub);
7278 ZVAL_UNDEF(&selectIr);
7279 ZVAL_UNDEF(&whereConditions);
7280 ZVAL_UNDEF(&limitConditions);
7281 ZVAL_UNDEF(&query);
7282 ZVAL_UNDEF(&_2);
7283 ZVAL_UNDEF(&_3);
7284 ZVAL_UNDEF(&_4);
7285 ZVAL_UNDEF(&_5);
7286 ZVAL_UNDEF(&_6);
7287 ZVAL_UNDEF(&intermediate);
7288 ZVAL_UNDEF(&bindParams);
7289 ZVAL_UNDEF(&bindTypes);
7290 ZVAL_UNDEF(&_0);
7291 ZVAL_UNDEF(&_1);
7292
7293 ZEPHIR_MM_GROW();
7294 zephir_fetch_params(1, 4, 0, &model, &intermediate_param, &bindParams_param, &bindTypes_param);
7295
7296 zephir_get_arrval(&intermediate, intermediate_param);
7297 zephir_get_arrval(&bindParams, bindParams_param);
7298 zephir_get_arrval(&bindTypes, bindTypes_param);
7299
7300
7301 ZEPHIR_INIT_VAR(&selectIr);
7302 zephir_create_array(&selectIr, 3, 0);
7303 ZEPHIR_INIT_VAR(&_0);
7304 zephir_create_array(&_0, 1, 0);
7305 ZEPHIR_INIT_VAR(&_1);
7306 zephir_create_array(&_1, 3, 0);
7307 add_assoc_stringl_ex(&_1, SL("type"), SL("object"));
7308 ZEPHIR_INIT_VAR(&_2);
7309 zephir_get_class(&_2, model, 0);
7310 zephir_array_update_string(&_1, SL("model"), &_2, PH_COPY | PH_SEPARATE);
7311 ZEPHIR_CALL_METHOD(&_3, model, "getsource", NULL, 0);
7312 zephir_check_call_status();
7313 zephir_array_update_string(&_1, SL("column"), &_3, PH_COPY | PH_SEPARATE);
7314 zephir_array_fast_append(&_0, &_1);
7315 zephir_array_update_string(&selectIr, SL("columns"), &_0, PH_COPY | PH_SEPARATE);
7316 ZEPHIR_OBS_VAR(&_4);
7317 zephir_array_fetch_string(&_4, &intermediate, SL("models"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3619);
7318 zephir_array_update_string(&selectIr, SL("models"), &_4, PH_COPY | PH_SEPARATE);
7319 ZEPHIR_OBS_NVAR(&_4);
7320 zephir_array_fetch_string(&_4, &intermediate, SL("tables"), PH_NOISY, "phalcon/Mvc/Model/Query.zep", 3621);
7321 zephir_array_update_string(&selectIr, SL("tables"), &_4, PH_COPY | PH_SEPARATE);
7322 ZEPHIR_OBS_VAR(&whereConditions);
7323 if (zephir_array_isset_string_fetch(&whereConditions, &intermediate, SL("where"), 0)) {
7324 zephir_array_update_string(&selectIr, SL("where"), &whereConditions, PH_COPY | PH_SEPARATE);
7325 }
7326 ZEPHIR_OBS_VAR(&limitConditions);
7327 if (zephir_array_isset_string_fetch(&limitConditions, &intermediate, SL("limit"), 0)) {
7328 zephir_array_update_string(&selectIr, SL("limit"), &limitConditions, PH_COPY | PH_SEPARATE);
7329 }
7330 ZEPHIR_INIT_VAR(&query);
7331 object_init_ex(&query, phalcon_mvc_model_query_ce);
7332 ZEPHIR_CALL_METHOD(NULL, &query, "__construct", NULL, 496);
7333 zephir_check_call_status();
7334 zephir_read_property(&_5, this_ptr, ZEND_STRL("container"), PH_NOISY_CC | PH_READONLY);
7335 ZEPHIR_CALL_METHOD(NULL, &query, "setdi", NULL, 497, &_5);
7336 zephir_check_call_status();
7337 ZVAL_LONG(&_6, 309);
7338 ZEPHIR_CALL_METHOD(NULL, &query, "settype", NULL, 498, &_6);
7339 zephir_check_call_status();
7340 ZEPHIR_CALL_METHOD(NULL, &query, "setintermediate", NULL, 499, &selectIr);
7341 zephir_check_call_status();
7342 ZEPHIR_RETURN_CALL_METHOD(&query, "execute", NULL, 500, &bindParams, &bindTypes);
7343 zephir_check_call_status();
7344 RETURN_MM();
7345
7346 }
7347
7348 /**
7349 * Executes a parsed PHQL statement
7350 *
7351 * @return mixed
7352 */
PHP_METHOD(Phalcon_Mvc_Model_Query,execute)7353 PHP_METHOD(Phalcon_Mvc_Model_Query, execute) {
7354
7355 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7356 zend_long ZEPHIR_LAST_CALL_STATUS;
7357 zephir_fcall_cache_entry *_1 = NULL;
7358 zval *bindParams_param = NULL, *bindTypes_param = NULL, uniqueRow, cacheOptions, key, cacheService, cache, result, preparedResult, defaultBindParams, mergedParams, defaultBindTypes, mergedTypes, type, lifetime, intermediate, _0, _2$$3, _3$$3, _4$$3, _5$$7, _6$$19, _7$$19;
7359 zval bindParams, bindTypes;
7360 zval *this_ptr = getThis();
7361
7362 ZVAL_UNDEF(&bindParams);
7363 ZVAL_UNDEF(&bindTypes);
7364 ZVAL_UNDEF(&uniqueRow);
7365 ZVAL_UNDEF(&cacheOptions);
7366 ZVAL_UNDEF(&key);
7367 ZVAL_UNDEF(&cacheService);
7368 ZVAL_UNDEF(&cache);
7369 ZVAL_UNDEF(&result);
7370 ZVAL_UNDEF(&preparedResult);
7371 ZVAL_UNDEF(&defaultBindParams);
7372 ZVAL_UNDEF(&mergedParams);
7373 ZVAL_UNDEF(&defaultBindTypes);
7374 ZVAL_UNDEF(&mergedTypes);
7375 ZVAL_UNDEF(&type);
7376 ZVAL_UNDEF(&lifetime);
7377 ZVAL_UNDEF(&intermediate);
7378 ZVAL_UNDEF(&_0);
7379 ZVAL_UNDEF(&_2$$3);
7380 ZVAL_UNDEF(&_3$$3);
7381 ZVAL_UNDEF(&_4$$3);
7382 ZVAL_UNDEF(&_5$$7);
7383 ZVAL_UNDEF(&_6$$19);
7384 ZVAL_UNDEF(&_7$$19);
7385
7386 ZEPHIR_MM_GROW();
7387 zephir_fetch_params(1, 0, 2, &bindParams_param, &bindTypes_param);
7388
7389 if (!bindParams_param) {
7390 ZEPHIR_INIT_VAR(&bindParams);
7391 array_init(&bindParams);
7392 } else {
7393 zephir_get_arrval(&bindParams, bindParams_param);
7394 }
7395 if (!bindTypes_param) {
7396 ZEPHIR_INIT_VAR(&bindTypes);
7397 array_init(&bindTypes);
7398 } else {
7399 zephir_get_arrval(&bindTypes, bindTypes_param);
7400 }
7401
7402
7403 zephir_read_property(&_0, this_ptr, ZEND_STRL("uniqueRow"), PH_NOISY_CC | PH_READONLY);
7404 ZEPHIR_CPY_WRT(&uniqueRow, &_0);
7405 zephir_read_property(&_0, this_ptr, ZEND_STRL("cacheOptions"), PH_NOISY_CC | PH_READONLY);
7406 ZEPHIR_CPY_WRT(&cacheOptions, &_0);
7407 if (Z_TYPE_P(&cacheOptions) != IS_NULL) {
7408 if (UNEXPECTED(Z_TYPE_P(&cacheOptions) != IS_ARRAY)) {
7409 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Invalid caching options", "phalcon/Mvc/Model/Query.zep", 3665);
7410 return;
7411 }
7412 ZEPHIR_OBS_VAR(&key);
7413 if (UNEXPECTED(!(zephir_array_isset_string_fetch(&key, &cacheOptions, SL("key"), 0)))) {
7414 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "A cache key must be provided to identify the cached resultset in the cache backend", "phalcon/Mvc/Model/Query.zep", 3674);
7415 return;
7416 }
7417 ZEPHIR_INIT_VAR(&_2$$3);
7418 ZVAL_STRING(&_2$$3, "lifetime");
7419 ZVAL_LONG(&_3$$3, 3600);
7420 ZEPHIR_CALL_CE_STATIC(&lifetime, phalcon_helper_arr_ce, "get", &_1, 16, &cacheOptions, &_2$$3, &_3$$3);
7421 zephir_check_call_status();
7422 ZEPHIR_INIT_NVAR(&_2$$3);
7423 ZVAL_STRING(&_2$$3, "service");
7424 ZEPHIR_INIT_VAR(&_4$$3);
7425 ZVAL_STRING(&_4$$3, "modelsCache");
7426 ZEPHIR_CALL_CE_STATIC(&cacheService, phalcon_helper_arr_ce, "get", &_1, 16, &cacheOptions, &_2$$3, &_4$$3);
7427 zephir_check_call_status();
7428 zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("container"), PH_NOISY_CC | PH_READONLY);
7429 ZEPHIR_CALL_METHOD(&cache, &_3$$3, "getshared", NULL, 0, &cacheService);
7430 zephir_check_call_status();
7431 if (UNEXPECTED(Z_TYPE_P(&cache) != IS_OBJECT)) {
7432 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Cache service must be an object", "phalcon/Mvc/Model/Query.zep", 3685);
7433 return;
7434 }
7435 ZEPHIR_CALL_METHOD(&result, &cache, "get", NULL, 0, &key);
7436 zephir_check_call_status();
7437 if (!(ZEPHIR_IS_EMPTY(&result))) {
7438 if (UNEXPECTED(Z_TYPE_P(&result) != IS_OBJECT)) {
7439 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Cache didn't return a valid resultset", "phalcon/Mvc/Model/Query.zep", 3694);
7440 return;
7441 }
7442 ZVAL_BOOL(&_5$$7, 0);
7443 ZEPHIR_CALL_METHOD(NULL, &result, "setisfresh", NULL, 0, &_5$$7);
7444 zephir_check_call_status();
7445 if (zephir_is_true(&uniqueRow)) {
7446 ZEPHIR_CALL_METHOD(&preparedResult, &result, "getfirst", NULL, 0);
7447 zephir_check_call_status();
7448 } else {
7449 ZEPHIR_CPY_WRT(&preparedResult, &result);
7450 }
7451 RETURN_CCTOR(&preparedResult);
7452 }
7453 zephir_update_property_zval(this_ptr, ZEND_STRL("cache"), &cache);
7454 }
7455 ZEPHIR_CALL_METHOD(&intermediate, this_ptr, "parse", NULL, 0);
7456 zephir_check_call_status();
7457 ZEPHIR_OBS_VAR(&defaultBindParams);
7458 zephir_read_property(&defaultBindParams, this_ptr, ZEND_STRL("bindParams"), PH_NOISY_CC);
7459 if (Z_TYPE_P(&defaultBindParams) == IS_ARRAY) {
7460 ZEPHIR_INIT_VAR(&mergedParams);
7461 zephir_add_function(&mergedParams, &defaultBindParams, &bindParams);
7462 } else {
7463 ZEPHIR_CPY_WRT(&mergedParams, &bindParams);
7464 }
7465 ZEPHIR_OBS_VAR(&defaultBindTypes);
7466 zephir_read_property(&defaultBindTypes, this_ptr, ZEND_STRL("bindTypes"), PH_NOISY_CC);
7467 if (Z_TYPE_P(&defaultBindTypes) == IS_ARRAY) {
7468 ZEPHIR_INIT_VAR(&mergedTypes);
7469 zephir_add_function(&mergedTypes, &defaultBindTypes, &bindTypes);
7470 } else {
7471 ZEPHIR_CPY_WRT(&mergedTypes, &bindTypes);
7472 }
7473 zephir_read_property(&_0, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY);
7474 ZEPHIR_CPY_WRT(&type, &_0);
7475 do {
7476 if (ZEPHIR_IS_LONG(&type, 309)) {
7477 ZEPHIR_CALL_METHOD(&result, this_ptr, "_executeselect", NULL, 501, &intermediate, &mergedParams, &mergedTypes);
7478 zephir_check_call_status();
7479 break;
7480 }
7481 if (ZEPHIR_IS_LONG(&type, 306)) {
7482 ZEPHIR_CALL_METHOD(&result, this_ptr, "_executeinsert", NULL, 502, &intermediate, &mergedParams, &mergedTypes);
7483 zephir_check_call_status();
7484 break;
7485 }
7486 if (ZEPHIR_IS_LONG(&type, 300)) {
7487 ZEPHIR_CALL_METHOD(&result, this_ptr, "_executeupdate", NULL, 503, &intermediate, &mergedParams, &mergedTypes);
7488 zephir_check_call_status();
7489 break;
7490 }
7491 if (ZEPHIR_IS_LONG(&type, 303)) {
7492 ZEPHIR_CALL_METHOD(&result, this_ptr, "_executedelete", NULL, 504, &intermediate, &mergedParams, &mergedTypes);
7493 zephir_check_call_status();
7494 break;
7495 }
7496 ZEPHIR_INIT_VAR(&_6$$19);
7497 object_init_ex(&_6$$19, phalcon_mvc_model_exception_ce);
7498 ZEPHIR_INIT_VAR(&_7$$19);
7499 ZEPHIR_CONCAT_SV(&_7$$19, "Unknown statement ", &type);
7500 ZEPHIR_CALL_METHOD(NULL, &_6$$19, "__construct", NULL, 8, &_7$$19);
7501 zephir_check_call_status();
7502 zephir_throw_exception_debug(&_6$$19, "phalcon/Mvc/Model/Query.zep", 3782);
7503 ZEPHIR_MM_RESTORE();
7504 return;
7505 } while(0);
7506
7507 if (Z_TYPE_P(&cacheOptions) != IS_NULL) {
7508 if (!ZEPHIR_IS_LONG(&type, 309)) {
7509 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Only PHQL statements that return resultsets can be cached", "phalcon/Mvc/Model/Query.zep", 3795);
7510 return;
7511 }
7512 ZEPHIR_CALL_METHOD(NULL, &cache, "set", NULL, 0, &key, &result, &lifetime);
7513 zephir_check_call_status();
7514 }
7515 if (zephir_is_true(&uniqueRow)) {
7516 ZEPHIR_CALL_METHOD(&preparedResult, &result, "getfirst", NULL, 0);
7517 zephir_check_call_status();
7518 } else {
7519 ZEPHIR_CPY_WRT(&preparedResult, &result);
7520 }
7521 RETURN_CCTOR(&preparedResult);
7522
7523 }
7524
7525 /**
7526 * Executes the query returning the first result
7527 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getSingleResult)7528 PHP_METHOD(Phalcon_Mvc_Model_Query, getSingleResult) {
7529
7530 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7531 zend_long ZEPHIR_LAST_CALL_STATUS;
7532 zval *bindParams_param = NULL, *bindTypes_param = NULL, _0, _1;
7533 zval bindParams, bindTypes;
7534 zval *this_ptr = getThis();
7535
7536 ZVAL_UNDEF(&bindParams);
7537 ZVAL_UNDEF(&bindTypes);
7538 ZVAL_UNDEF(&_0);
7539 ZVAL_UNDEF(&_1);
7540
7541 ZEPHIR_MM_GROW();
7542 zephir_fetch_params(1, 0, 2, &bindParams_param, &bindTypes_param);
7543
7544 if (!bindParams_param) {
7545 ZEPHIR_INIT_VAR(&bindParams);
7546 array_init(&bindParams);
7547 } else {
7548 zephir_get_arrval(&bindParams, bindParams_param);
7549 }
7550 if (!bindTypes_param) {
7551 ZEPHIR_INIT_VAR(&bindTypes);
7552 array_init(&bindTypes);
7553 } else {
7554 zephir_get_arrval(&bindTypes, bindTypes_param);
7555 }
7556
7557
7558 zephir_read_property(&_0, this_ptr, ZEND_STRL("uniqueRow"), PH_NOISY_CC | PH_READONLY);
7559 if (zephir_is_true(&_0)) {
7560 ZEPHIR_RETURN_CALL_METHOD(this_ptr, "execute", NULL, 0, &bindParams, &bindTypes);
7561 zephir_check_call_status();
7562 RETURN_MM();
7563 }
7564 ZEPHIR_CALL_METHOD(&_1, this_ptr, "execute", NULL, 500, &bindParams, &bindTypes);
7565 zephir_check_call_status();
7566 ZEPHIR_RETURN_CALL_METHOD(&_1, "getfirst", NULL, 0);
7567 zephir_check_call_status();
7568 RETURN_MM();
7569
7570 }
7571
7572 /**
7573 * Sets the type of PHQL statement to be executed
7574 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setType)7575 PHP_METHOD(Phalcon_Mvc_Model_Query, setType) {
7576
7577 zval *type_param = NULL, _0;
7578 zend_long type;
7579 zval *this_ptr = getThis();
7580
7581 ZVAL_UNDEF(&_0);
7582
7583 zephir_fetch_params_without_memory_grow(1, 0, &type_param);
7584
7585 type = zephir_get_intval(type_param);
7586
7587
7588 ZEPHIR_INIT_ZVAL_NREF(_0);
7589 ZVAL_LONG(&_0, type);
7590 zephir_update_property_zval(this_ptr, ZEND_STRL("type"), &_0);
7591 RETURN_THISW();
7592
7593 }
7594
7595 /**
7596 * Gets the type of PHQL statement executed
7597 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getType)7598 PHP_METHOD(Phalcon_Mvc_Model_Query, getType) {
7599
7600 zval *this_ptr = getThis();
7601
7602
7603 RETURN_MEMBER(getThis(), "type");
7604
7605 }
7606
7607 /**
7608 * Set default bind parameters
7609 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setBindParams)7610 PHP_METHOD(Phalcon_Mvc_Model_Query, setBindParams) {
7611
7612 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7613 zend_bool merge;
7614 zval *bindParams_param = NULL, *merge_param = NULL, currentBindParams, _0$$4;
7615 zval bindParams;
7616 zval *this_ptr = getThis();
7617
7618 ZVAL_UNDEF(&bindParams);
7619 ZVAL_UNDEF(¤tBindParams);
7620 ZVAL_UNDEF(&_0$$4);
7621
7622 ZEPHIR_MM_GROW();
7623 zephir_fetch_params(1, 1, 1, &bindParams_param, &merge_param);
7624
7625 ZEPHIR_OBS_COPY_OR_DUP(&bindParams, bindParams_param);
7626 if (!merge_param) {
7627 merge = 0;
7628 } else {
7629 merge = zephir_get_boolval(merge_param);
7630 }
7631
7632
7633 if (merge) {
7634 zephir_read_property(¤tBindParams, this_ptr, ZEND_STRL("bindParams"), PH_NOISY_CC | PH_READONLY);
7635 if (Z_TYPE_P(¤tBindParams) == IS_ARRAY) {
7636 ZEPHIR_INIT_VAR(&_0$$4);
7637 zephir_add_function(&_0$$4, ¤tBindParams, &bindParams);
7638 zephir_update_property_zval(this_ptr, ZEND_STRL("bindParams"), &_0$$4);
7639 } else {
7640 zephir_update_property_zval(this_ptr, ZEND_STRL("bindParams"), &bindParams);
7641 }
7642 } else {
7643 zephir_update_property_zval(this_ptr, ZEND_STRL("bindParams"), &bindParams);
7644 }
7645 RETURN_THIS();
7646
7647 }
7648
7649 /**
7650 * Returns default bind params
7651 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getBindParams)7652 PHP_METHOD(Phalcon_Mvc_Model_Query, getBindParams) {
7653
7654 zval *this_ptr = getThis();
7655
7656
7657 RETURN_MEMBER(getThis(), "bindParams");
7658
7659 }
7660
7661 /**
7662 * Set default bind parameters
7663 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setBindTypes)7664 PHP_METHOD(Phalcon_Mvc_Model_Query, setBindTypes) {
7665
7666 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7667 zend_bool merge;
7668 zval *bindTypes_param = NULL, *merge_param = NULL, currentBindTypes, _0$$4;
7669 zval bindTypes;
7670 zval *this_ptr = getThis();
7671
7672 ZVAL_UNDEF(&bindTypes);
7673 ZVAL_UNDEF(¤tBindTypes);
7674 ZVAL_UNDEF(&_0$$4);
7675
7676 ZEPHIR_MM_GROW();
7677 zephir_fetch_params(1, 1, 1, &bindTypes_param, &merge_param);
7678
7679 ZEPHIR_OBS_COPY_OR_DUP(&bindTypes, bindTypes_param);
7680 if (!merge_param) {
7681 merge = 0;
7682 } else {
7683 merge = zephir_get_boolval(merge_param);
7684 }
7685
7686
7687 if (UNEXPECTED(merge)) {
7688 zephir_read_property(¤tBindTypes, this_ptr, ZEND_STRL("bindTypes"), PH_NOISY_CC | PH_READONLY);
7689 if (Z_TYPE_P(¤tBindTypes) == IS_ARRAY) {
7690 ZEPHIR_INIT_VAR(&_0$$4);
7691 zephir_add_function(&_0$$4, ¤tBindTypes, &bindTypes);
7692 zephir_update_property_zval(this_ptr, ZEND_STRL("bindTypes"), &_0$$4);
7693 } else {
7694 zephir_update_property_zval(this_ptr, ZEND_STRL("bindTypes"), &bindTypes);
7695 }
7696 } else {
7697 zephir_update_property_zval(this_ptr, ZEND_STRL("bindTypes"), &bindTypes);
7698 }
7699 RETURN_THIS();
7700
7701 }
7702
7703 /**
7704 * Set SHARED LOCK clause
7705 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setSharedLock)7706 PHP_METHOD(Phalcon_Mvc_Model_Query, setSharedLock) {
7707
7708 zval *sharedLock_param = NULL, __$true, __$false;
7709 zend_bool sharedLock;
7710 zval *this_ptr = getThis();
7711
7712 ZVAL_BOOL(&__$true, 1);
7713 ZVAL_BOOL(&__$false, 0);
7714
7715 zephir_fetch_params_without_memory_grow(0, 1, &sharedLock_param);
7716
7717 if (!sharedLock_param) {
7718 sharedLock = 0;
7719 } else {
7720 sharedLock = zephir_get_boolval(sharedLock_param);
7721 }
7722
7723
7724 if (sharedLock) {
7725 zephir_update_property_zval(this_ptr, ZEND_STRL("sharedLock"), &__$true);
7726 } else {
7727 zephir_update_property_zval(this_ptr, ZEND_STRL("sharedLock"), &__$false);
7728 }
7729 RETURN_THISW();
7730
7731 }
7732
7733 /**
7734 * Returns default bind types
7735 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getBindTypes)7736 PHP_METHOD(Phalcon_Mvc_Model_Query, getBindTypes) {
7737
7738 zval *this_ptr = getThis();
7739
7740
7741 RETURN_MEMBER(getThis(), "bindTypes");
7742
7743 }
7744
7745 /**
7746 * Allows to set the IR to be executed
7747 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setIntermediate)7748 PHP_METHOD(Phalcon_Mvc_Model_Query, setIntermediate) {
7749
7750 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7751 zval *intermediate_param = NULL;
7752 zval intermediate;
7753 zval *this_ptr = getThis();
7754
7755 ZVAL_UNDEF(&intermediate);
7756
7757 ZEPHIR_MM_GROW();
7758 zephir_fetch_params(1, 1, 0, &intermediate_param);
7759
7760 ZEPHIR_OBS_COPY_OR_DUP(&intermediate, intermediate_param);
7761
7762
7763 zephir_update_property_zval(this_ptr, ZEND_STRL("intermediate"), &intermediate);
7764 RETURN_THIS();
7765
7766 }
7767
7768 /**
7769 * Returns the intermediate representation of the PHQL statement
7770 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getIntermediate)7771 PHP_METHOD(Phalcon_Mvc_Model_Query, getIntermediate) {
7772
7773 zval *this_ptr = getThis();
7774
7775
7776 RETURN_MEMBER(getThis(), "intermediate");
7777
7778 }
7779
7780 /**
7781 * Sets the cache parameters of the query
7782 */
PHP_METHOD(Phalcon_Mvc_Model_Query,cache)7783 PHP_METHOD(Phalcon_Mvc_Model_Query, cache) {
7784
7785 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7786 zval *cacheOptions_param = NULL;
7787 zval cacheOptions;
7788 zval *this_ptr = getThis();
7789
7790 ZVAL_UNDEF(&cacheOptions);
7791
7792 ZEPHIR_MM_GROW();
7793 zephir_fetch_params(1, 1, 0, &cacheOptions_param);
7794
7795 zephir_get_arrval(&cacheOptions, cacheOptions_param);
7796
7797
7798 zephir_update_property_zval(this_ptr, ZEND_STRL("cacheOptions"), &cacheOptions);
7799 RETURN_THIS();
7800
7801 }
7802
7803 /**
7804 * Returns the current cache options
7805 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getCacheOptions)7806 PHP_METHOD(Phalcon_Mvc_Model_Query, getCacheOptions) {
7807
7808 zval *this_ptr = getThis();
7809
7810
7811 RETURN_MEMBER(getThis(), "cacheOptions");
7812
7813 }
7814
7815 /**
7816 * Returns the SQL to be generated by the internal PHQL (only works in
7817 * SELECT statements)
7818 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getSql)7819 PHP_METHOD(Phalcon_Mvc_Model_Query, getSql) {
7820
7821 zval intermediate, _0, _1$$3, _2$$3, _3$$3;
7822 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7823 zend_long ZEPHIR_LAST_CALL_STATUS;
7824 zval *this_ptr = getThis();
7825
7826 ZVAL_UNDEF(&intermediate);
7827 ZVAL_UNDEF(&_0);
7828 ZVAL_UNDEF(&_1$$3);
7829 ZVAL_UNDEF(&_2$$3);
7830 ZVAL_UNDEF(&_3$$3);
7831
7832 ZEPHIR_MM_GROW();
7833
7834 ZEPHIR_CALL_METHOD(&intermediate, this_ptr, "parse", NULL, 0);
7835 zephir_check_call_status();
7836 zephir_read_property(&_0, this_ptr, ZEND_STRL("type"), PH_NOISY_CC | PH_READONLY);
7837 if (ZEPHIR_IS_LONG(&_0, 309)) {
7838 zephir_read_property(&_1$$3, this_ptr, ZEND_STRL("bindParams"), PH_NOISY_CC | PH_READONLY);
7839 zephir_read_property(&_2$$3, this_ptr, ZEND_STRL("bindTypes"), PH_NOISY_CC | PH_READONLY);
7840 ZVAL_BOOL(&_3$$3, 1);
7841 ZEPHIR_RETURN_CALL_METHOD(this_ptr, "_executeselect", NULL, 501, &intermediate, &_1$$3, &_2$$3, &_3$$3);
7842 zephir_check_call_status();
7843 RETURN_MM();
7844 }
7845 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "This type of statement generates multiple SQL statements", "phalcon/Mvc/Model/Query.zep", 3977);
7846 return;
7847
7848 }
7849
7850 /**
7851 * Destroys the internal PHQL cache
7852 */
PHP_METHOD(Phalcon_Mvc_Model_Query,clean)7853 PHP_METHOD(Phalcon_Mvc_Model_Query, clean) {
7854
7855 zval _0;
7856 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7857 zval *this_ptr = getThis();
7858
7859 ZVAL_UNDEF(&_0);
7860
7861 ZEPHIR_MM_GROW();
7862
7863 ZEPHIR_INIT_VAR(&_0);
7864 array_init(&_0);
7865 zephir_update_static_property_ce(phalcon_mvc_model_query_ce, ZEND_STRL("_irPhqlCache"), &_0);
7866 ZEPHIR_MM_RESTORE();
7867
7868 }
7869
7870 /**
7871 * Gets the read connection from the model if there is no transaction set
7872 * inside the query object
7873 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getReadConnection)7874 PHP_METHOD(Phalcon_Mvc_Model_Query, getReadConnection) {
7875
7876 zend_bool _0;
7877 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7878 zend_long ZEPHIR_LAST_CALL_STATUS;
7879 zval intermediate, bindParams, bindTypes;
7880 zval *model, model_sub, *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL, connection, transaction;
7881 zval *this_ptr = getThis();
7882
7883 ZVAL_UNDEF(&model_sub);
7884 ZVAL_UNDEF(&connection);
7885 ZVAL_UNDEF(&transaction);
7886 ZVAL_UNDEF(&intermediate);
7887 ZVAL_UNDEF(&bindParams);
7888 ZVAL_UNDEF(&bindTypes);
7889
7890 ZEPHIR_MM_GROW();
7891 zephir_fetch_params(1, 1, 3, &model, &intermediate_param, &bindParams_param, &bindTypes_param);
7892
7893 if (!intermediate_param) {
7894 ZEPHIR_INIT_VAR(&intermediate);
7895 array_init(&intermediate);
7896 } else {
7897 zephir_get_arrval(&intermediate, intermediate_param);
7898 }
7899 if (!bindParams_param) {
7900 ZEPHIR_INIT_VAR(&bindParams);
7901 array_init(&bindParams);
7902 } else {
7903 zephir_get_arrval(&bindParams, bindParams_param);
7904 }
7905 if (!bindTypes_param) {
7906 ZEPHIR_INIT_VAR(&bindTypes);
7907 array_init(&bindTypes);
7908 } else {
7909 zephir_get_arrval(&bindTypes, bindTypes_param);
7910 }
7911
7912
7913 ZEPHIR_INIT_VAR(&connection);
7914 ZVAL_NULL(&connection);
7915 ZEPHIR_OBS_VAR(&transaction);
7916 zephir_read_property(&transaction, this_ptr, ZEND_STRL("_transaction"), PH_NOISY_CC);
7917 _0 = Z_TYPE_P(&transaction) == IS_OBJECT;
7918 if (_0) {
7919 _0 = zephir_instance_of_ev(&transaction, phalcon_mvc_model_transactioninterface_ce);
7920 }
7921 if (_0) {
7922 ZEPHIR_RETURN_CALL_METHOD(&transaction, "getconnection", NULL, 0);
7923 zephir_check_call_status();
7924 RETURN_MM();
7925 }
7926 if ((zephir_method_exists_ex(model, ZEND_STRL("selectreadconnection")) == SUCCESS)) {
7927 ZEPHIR_CALL_METHOD(&connection, model, "selectreadconnection", NULL, 0, &intermediate, &bindParams, &bindTypes);
7928 zephir_check_call_status();
7929 if (UNEXPECTED(Z_TYPE_P(&connection) != IS_OBJECT)) {
7930 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "selectReadConnection did not return a connection", "phalcon/Mvc/Model/Query.zep", 4013);
7931 return;
7932 }
7933 RETURN_CCTOR(&connection);
7934 }
7935 ZEPHIR_RETURN_CALL_METHOD(model, "getreadconnection", NULL, 0);
7936 zephir_check_call_status();
7937 RETURN_MM();
7938
7939 }
7940
7941 /**
7942 * Gets the write connection from the model if there is no transaction
7943 * inside the query object
7944 */
PHP_METHOD(Phalcon_Mvc_Model_Query,getWriteConnection)7945 PHP_METHOD(Phalcon_Mvc_Model_Query, getWriteConnection) {
7946
7947 zend_bool _0;
7948 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
7949 zend_long ZEPHIR_LAST_CALL_STATUS;
7950 zval intermediate, bindParams, bindTypes;
7951 zval *model, model_sub, *intermediate_param = NULL, *bindParams_param = NULL, *bindTypes_param = NULL, connection, transaction;
7952 zval *this_ptr = getThis();
7953
7954 ZVAL_UNDEF(&model_sub);
7955 ZVAL_UNDEF(&connection);
7956 ZVAL_UNDEF(&transaction);
7957 ZVAL_UNDEF(&intermediate);
7958 ZVAL_UNDEF(&bindParams);
7959 ZVAL_UNDEF(&bindTypes);
7960
7961 ZEPHIR_MM_GROW();
7962 zephir_fetch_params(1, 1, 3, &model, &intermediate_param, &bindParams_param, &bindTypes_param);
7963
7964 if (!intermediate_param) {
7965 ZEPHIR_INIT_VAR(&intermediate);
7966 array_init(&intermediate);
7967 } else {
7968 zephir_get_arrval(&intermediate, intermediate_param);
7969 }
7970 if (!bindParams_param) {
7971 ZEPHIR_INIT_VAR(&bindParams);
7972 array_init(&bindParams);
7973 } else {
7974 zephir_get_arrval(&bindParams, bindParams_param);
7975 }
7976 if (!bindTypes_param) {
7977 ZEPHIR_INIT_VAR(&bindTypes);
7978 array_init(&bindTypes);
7979 } else {
7980 zephir_get_arrval(&bindTypes, bindTypes_param);
7981 }
7982
7983
7984 ZEPHIR_INIT_VAR(&connection);
7985 ZVAL_NULL(&connection);
7986 ZEPHIR_OBS_VAR(&transaction);
7987 zephir_read_property(&transaction, this_ptr, ZEND_STRL("_transaction"), PH_NOISY_CC);
7988 _0 = Z_TYPE_P(&transaction) == IS_OBJECT;
7989 if (_0) {
7990 _0 = zephir_instance_of_ev(&transaction, phalcon_mvc_model_transactioninterface_ce);
7991 }
7992 if (_0) {
7993 ZEPHIR_RETURN_CALL_METHOD(&transaction, "getconnection", NULL, 0);
7994 zephir_check_call_status();
7995 RETURN_MM();
7996 }
7997 if ((zephir_method_exists_ex(model, ZEND_STRL("selectwriteconnection")) == SUCCESS)) {
7998 ZEPHIR_CALL_METHOD(&connection, model, "selectwriteconnection", NULL, 0, &intermediate, &bindParams, &bindTypes);
7999 zephir_check_call_status();
8000 if (UNEXPECTED(Z_TYPE_P(&connection) != IS_OBJECT)) {
8001 ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "selectWriteConnection did not return a connection", "phalcon/Mvc/Model/Query.zep", 4047);
8002 return;
8003 }
8004 RETURN_CCTOR(&connection);
8005 }
8006 ZEPHIR_RETURN_CALL_METHOD(model, "getwriteconnection", NULL, 0);
8007 zephir_check_call_status();
8008 RETURN_MM();
8009
8010 }
8011
8012 /**
8013 * allows to wrap a transaction around all queries
8014 */
PHP_METHOD(Phalcon_Mvc_Model_Query,setTransaction)8015 PHP_METHOD(Phalcon_Mvc_Model_Query, setTransaction) {
8016
8017 zval *transaction, transaction_sub;
8018 zval *this_ptr = getThis();
8019
8020 ZVAL_UNDEF(&transaction_sub);
8021
8022 zephir_fetch_params_without_memory_grow(1, 0, &transaction);
8023
8024
8025
8026 zephir_update_property_zval(this_ptr, ZEND_STRL("_transaction"), transaction);
8027 RETURN_THISW();
8028
8029 }
8030
zephir_init_properties_Phalcon_Mvc_Model_Query(zend_class_entry * class_type TSRMLS_DC)8031 zend_object *zephir_init_properties_Phalcon_Mvc_Model_Query(zend_class_entry *class_type TSRMLS_DC) {
8032
8033 zval _0, _1$$3;
8034 zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL;
8035 ZVAL_UNDEF(&_0);
8036 ZVAL_UNDEF(&_1$$3);
8037
8038 ZEPHIR_MM_GROW();
8039
8040 {
8041 zval local_this_ptr, *this_ptr = &local_this_ptr;
8042 ZEPHIR_CREATE_OBJECT(this_ptr, class_type);
8043 zephir_read_property_ex(&_0, this_ptr, ZEND_STRL("sqlColumnAliases"), PH_NOISY_CC | PH_READONLY);
8044 if (Z_TYPE_P(&_0) == IS_NULL) {
8045 ZEPHIR_INIT_VAR(&_1$$3);
8046 array_init(&_1$$3);
8047 zephir_update_property_zval_ex(this_ptr, ZEND_STRL("sqlColumnAliases"), &_1$$3);
8048 }
8049 ZEPHIR_MM_RESTORE();
8050 return Z_OBJ_P(this_ptr);
8051 }
8052
8053 }
8054
8055