/**
* Initializes the internal handler, calling functions on it
*
* @param string method
* @param array arguments
* @return mixed
*/
PHP_METHOD(Phalcon_Mvc_Micro_LazyLoader, __call) {
zend_class_entry *_1$$3;
zval *_3;
int ZEPHIR_LAST_CALL_STATUS;
zval *method_param = NULL, *arguments = NULL, *handler = NULL, *definition = NULL, *modelBinder = NULL, *bindCacheKey = NULL, *_0$$3 = NULL, *_2$$4 = NULL;
zval *method = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &method_param, &arguments);
if (UNEXPECTED(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(method_param) == IS_STRING)) {
zephir_get_strval(method, method_param);
} else {
ZEPHIR_INIT_VAR(method);
ZVAL_EMPTY_STRING(method);
}
ZEPHIR_SEPARATE_PARAM(arguments);
ZEPHIR_OBS_VAR(handler);
zephir_read_property_this(&handler, this_ptr, SL("_handler"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(definition);
zephir_read_property_this(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);
if (Z_TYPE_P(handler) != IS_OBJECT) {
ZEPHIR_INIT_NVAR(handler);
zephir_fetch_safe_class(_0$$3, definition);
_1$$3 = zend_fetch_class(Z_STRVAL_P(_0$$3), Z_STRLEN_P(_0$$3), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(handler, _1$$3);
if (zephir_has_constructor(handler TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, handler, "__construct", NULL, 0);
zephir_check_call_status();
}
zephir_update_property_this(this_ptr, SL("_handler"), handler TSRMLS_CC);
}
ZEPHIR_OBS_VAR(modelBinder);
zephir_read_property_this(&modelBinder, this_ptr, SL("_modelBinder"), PH_NOISY_CC);
if (Z_TYPE_P(modelBinder) != IS_NULL) {
ZEPHIR_INIT_VAR(bindCacheKey);
ZEPHIR_CONCAT_SVSV(bindCacheKey, "_PHMB_", definition, "_", method);
ZEPHIR_CALL_METHOD(&_2$$4, modelBinder, "bindtohandler", NULL, 0, handler, arguments, bindCacheKey, method);
zephir_check_call_status();
ZEPHIR_CPY_WRT(arguments, _2$$4);
}
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_3, handler);
zephir_array_fast_append(_3, method);
ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, _3, arguments);
zephir_check_call_status();
RETURN_MM();
}
PHP_METHOD(Auryn_AbstractCachingReflector, getMethod) {
zend_class_entry *_3;
int ZEPHIR_LAST_CALL_STATUS;
zval *methodName = NULL;
zval *classNameOrInstance, *methodName_param = NULL, *className = NULL, *cacheKey, *reflectedMethod = NULL, *_0, *_1, *_2, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &classNameOrInstance, &methodName_param);
if (unlikely(Z_TYPE_P(methodName_param) != IS_STRING && Z_TYPE_P(methodName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'methodName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (unlikely(Z_TYPE_P(methodName_param) == IS_STRING)) {
methodName = methodName_param;
} else {
ZEPHIR_INIT_VAR(methodName);
ZVAL_EMPTY_STRING(methodName);
}
if (Z_TYPE_P(classNameOrInstance) == IS_STRING) {
ZEPHIR_CPY_WRT(className, classNameOrInstance);
} else {
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, classNameOrInstance, 0 TSRMLS_CC);
}
ZEPHIR_INIT_VAR(_0);
zephir_fast_strtolower(_0, className);
ZEPHIR_INIT_VAR(_1);
zephir_fast_strtolower(_1, methodName);
ZEPHIR_INIT_VAR(cacheKey);
ZEPHIR_CONCAT_SVSV(cacheKey, "auryn.refls.methods.", _0, ".", _1);
_2 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&reflectedMethod, _2, "fetch", NULL, cacheKey);
zephir_check_call_status();
if (!(zephir_is_true(reflectedMethod))) {
ZEPHIR_INIT_BNVAR(reflectedMethod);
_3 = zend_fetch_class(SL("ReflectionMethod"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(reflectedMethod, _3);
ZEPHIR_CALL_METHOD(NULL, reflectedMethod, "__construct", NULL, className, methodName);
zephir_check_call_status();
_4 = zephir_fetch_nproperty_this(this_ptr, SL("cache"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, _4, "store", NULL, cacheKey, reflectedMethod);
zephir_check_call_status();
}
RETURN_CCTOR(reflectedMethod);
}
/**
* Generates SQL to create a view
*
* @param string viewName
* @param array definition
* @param string schemaName
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, createView) {
zval *viewName_param = NULL, *definition, *schemaName_param = NULL, *view = NULL, *viewSql;
zval *viewName = NULL, *schemaName = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &viewName_param, &definition, &schemaName_param);
if (unlikely(Z_TYPE_P(viewName_param) != IS_STRING && Z_TYPE_P(viewName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'viewName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(viewName_param) == IS_STRING)) {
zephir_get_strval(viewName, viewName_param);
} else {
ZEPHIR_INIT_VAR(viewName);
ZVAL_EMPTY_STRING(viewName);
}
if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) {
zephir_get_strval(schemaName, schemaName_param);
} else {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
}
ZEPHIR_OBS_VAR(viewSql);
if (!(zephir_array_isset_string_fetch(&viewSql, definition, SS("sql"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "The index 'sql' is required in the definition array", "phalcon/db/dialect/sqlite.zep", 319);
return;
}
if (schemaName && Z_STRLEN_P(schemaName)) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_VSV(_0, schemaName, "\".\"", viewName);
ZEPHIR_CPY_WRT(view, _0);
} else {
ZEPHIR_CPY_WRT(view, viewName);
}
ZEPHIR_CONCAT_SVSV(return_value, "CREATE VIEW \"", view, "\" AS ", viewSql);
RETURN_MM();
}
PHP_METHOD(Test_Exceptions, testExceptionConcat) {
zval *framework_param = NULL, *language_param = NULL;
zval *framework = NULL, *language = NULL, *_0;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &framework_param, &language_param);
zephir_get_strval(framework, framework_param);
zephir_get_strval(language, language_param);
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SVSV(_0, "Framework ", framework, " written using ", language);
zephir_throw_exception_debug(_0, "test/exceptions.zep", 70 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Generates SQL to create a view
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, createView) {
int ZEPHIR_LAST_CALL_STATUS;
zval *definition = NULL;
zval *viewName_param = NULL, *definition_param = NULL, *schemaName_param = NULL, *viewSql, *_0 = NULL;
zval *viewName = NULL, *schemaName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 1, &viewName_param, &definition_param, &schemaName_param);
if (unlikely(Z_TYPE_P(viewName_param) != IS_STRING && Z_TYPE_P(viewName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'viewName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(viewName_param) == IS_STRING)) {
zephir_get_strval(viewName, viewName_param);
} else {
ZEPHIR_INIT_VAR(viewName);
ZVAL_EMPTY_STRING(viewName);
}
definition = definition_param;
if (!schemaName_param) {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
} else {
zephir_get_strval(schemaName, schemaName_param);
}
ZEPHIR_OBS_VAR(viewSql);
if (!(zephir_array_isset_string_fetch(&viewSql, definition, SS("sql"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "The index 'sql' is required in the definition array", "phalcon/db/dialect/oracle.zep", 236);
return;
}
ZEPHIR_CALL_METHOD(&_0, this_ptr, "preparetable", NULL, 0, viewName, schemaName);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSV(return_value, "CREATE VIEW ", _0, " AS ", viewSql);
RETURN_MM();
}
/**
* Can delay any new job being reserved for a given time.
*/
PHP_METHOD(Phalcon_Queue_Beanstalk, pauseTube) {
int delay, ZEPHIR_LAST_CALL_STATUS;
zval *tube_param = NULL, *delay_param = NULL, *response = NULL, _0, *_2;
zval *tube = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &tube_param, &delay_param);
if (UNEXPECTED(Z_TYPE_P(tube_param) != IS_STRING && Z_TYPE_P(tube_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tube' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(tube_param) == IS_STRING)) {
zephir_get_strval(tube, tube_param);
} else {
ZEPHIR_INIT_VAR(tube);
ZVAL_EMPTY_STRING(tube);
}
delay = zephir_get_intval(delay_param);
ZEPHIR_SINIT_VAR(_0);
ZVAL_LONG(&_0, delay);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVSV(_1, "pause-tube ", tube, " ", &_0);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "write", NULL, 0, _1);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&response, this_ptr, "readstatus", NULL, 409);
zephir_check_call_status();
zephir_array_fetch_long(&_2, response, 0, PH_NOISY | PH_READONLY, "phalcon/queue/beanstalk.zep", 289 TSRMLS_CC);
if (!ZEPHIR_IS_STRING(_2, "PAUSED")) {
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Generates SQL to create a view
*
* @param string viewName
* @param array definition
* @param string schemaName
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, createView) {
zval *viewName, *definition, *schemaName, *viewSql, *view = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &viewName, &definition, &schemaName);
ZEPHIR_OBS_VAR(viewSql);
if (!(zephir_array_isset_string_fetch(&viewSql, definition, SS("sql"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "The index 'sql' is required in the definition array", "phalcon/db/dialect/postgresql.zep", 315);
return;
}
if (zephir_is_true(schemaName)) {
ZEPHIR_INIT_VAR(view);
ZEPHIR_CONCAT_VSV(view, viewName, ".", schemaName);
} else {
ZEPHIR_CPY_WRT(view, viewName);
}
ZEPHIR_CONCAT_SVSV(return_value, "CREATE VIEW ", view, " AS ", viewSql);
RETURN_MM();
}
PHP_METHOD(Test_Exceptions, testExceptionConcat) {
zval *framework_param = NULL, *language_param = NULL;
zval framework, language, _0;
zval *this_ptr = getThis();
ZVAL_UNDEF(&framework);
ZVAL_UNDEF(&language);
ZVAL_UNDEF(&_0);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &framework_param, &language_param);
zephir_get_strval(&framework, framework_param);
zephir_get_strval(&language, language_param);
ZEPHIR_INIT_VAR(&_0);
ZEPHIR_CONCAT_SVSV(&_0, "Framework ", &framework, " written using ", &language);
zephir_throw_exception_debug(&_0, "test/exceptions.zep", 73 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Generates SQL to add a column to a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, addColumn) {
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *tableName_param = NULL, *schemaName_param = NULL, *column, *sql = NULL, *defaultValue = NULL, *_1 = NULL, *_2 = NULL, *_3, _4, *_5 = NULL, *_7;
zval *tableName = NULL, *schemaName = NULL, *_0 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &tableName_param, &schemaName_param, &column);
if (unlikely(Z_TYPE_P(tableName_param) != IS_STRING && Z_TYPE_P(tableName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tableName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tableName_param) == IS_STRING)) {
zephir_get_strval(tableName, tableName_param);
} else {
ZEPHIR_INIT_VAR(tableName);
ZVAL_EMPTY_STRING(tableName);
}
if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) {
zephir_get_strval(schemaName, schemaName_param);
} else {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
}
ZEPHIR_INIT_VAR(sql);
if (schemaName && Z_STRLEN_P(schemaName)) {
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SVSVS(_0, "ALTER TABLE \"", schemaName, "\".\"", tableName, "\" ADD COLUMN ");
ZEPHIR_CPY_WRT(sql, _0);
} else {
ZEPHIR_INIT_LNVAR(_0);
ZEPHIR_CONCAT_SVS(_0, "ALTER TABLE \"", tableName, "\" ADD COLUMN ");
ZEPHIR_CPY_WRT(sql, _0);
}
ZEPHIR_CALL_METHOD(&_1, column, "getname", NULL);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2, this_ptr, "getcolumndefinition", NULL, column);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SVSV(_3, "\"", _1, "\" ", _2);
zephir_concat_self(&sql, _3 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&defaultValue, column, "getdefault", NULL);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(defaultValue))) {
ZEPHIR_SINIT_VAR(_4);
ZVAL_STRING(&_4, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_5, "addcslashes", &_6, defaultValue, &_4);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7);
ZEPHIR_CONCAT_SVS(_7, " DEFAULT \"", _5, "\"");
zephir_concat_self(&sql, _7 TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_5, column, "isnotnull", NULL);
zephir_check_call_status();
if (zephir_is_true(_5)) {
zephir_concat_self_str(&sql, SL(" NOT NULL") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_5, column, "isautoincrement", NULL);
zephir_check_call_status();
if (zephir_is_true(_5)) {
zephir_concat_self_str(&sql, SL(" PRIMARY KEY AUTOINCREMENT") TSRMLS_CC);
}
RETURN_CCTOR(sql);
}
PHP_METHOD(PhalconPlus_RPC_Server_AbstractServer, callByParams) {
zend_class_entry *_10, *_17;
zephir_nts_static zephir_fcall_cache_entry *_5 = NULL, *_7 = NULL, *_13 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *_3 = NULL, *_18, *_19;
zend_bool _2;
zval *service_param = NULL, *method_param = NULL, *request = NULL, *rawData, *serviceClass = NULL, *_0 = NULL, *_1, *tmp = NULL, *param, *paramClass = NULL, *_4 = NULL, *_6 = NULL, *_8 = NULL, *_9 = NULL, *_11 = NULL, *_12 = NULL, *_14, *_15, *serviceObj, *response = NULL, *e = NULL, *_16 = NULL, *_20;
zval *service = NULL, *method = NULL, *_21;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &service_param, &method_param, &request, &rawData);
if (unlikely(Z_TYPE_P(service_param) != IS_STRING && Z_TYPE_P(service_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'service' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(service_param) == IS_STRING)) {
zephir_get_strval(service, service_param);
} else {
ZEPHIR_INIT_VAR(service);
ZVAL_EMPTY_STRING(service);
}
if (unlikely(Z_TYPE_P(method_param) != IS_STRING && Z_TYPE_P(method_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'method' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(method_param) == IS_STRING)) {
zephir_get_strval(method, method_param);
} else {
ZEPHIR_INIT_VAR(method);
ZVAL_EMPTY_STRING(method);
}
ZEPHIR_INIT_VAR(serviceClass);
ZVAL_STRING(serviceClass, "", 1);
ZEPHIR_INIT_VAR(tmp);
array_init(tmp);
ZEPHIR_INIT_VAR(_1);
zephir_ucfirst(_1, service);
ZEPHIR_INIT_NVAR(serviceClass);
ZEPHIR_CONCAT_VS(serviceClass, _1, "Service");
_2 = Z_TYPE_P(request) == IS_OBJECT;
if (_2) {
_2 = zephir_instance_of_ev(request, phalconplus_base_protobuffer_ce TSRMLS_CC);
}
if (_2) {
zephir_update_property_this(this_ptr, SL("phpOnly"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else if (Z_TYPE_P(request) == IS_ARRAY) {
ZEPHIR_CPY_WRT(tmp, request);
ZEPHIR_INIT_VAR(param);
object_init_ex(param, zephir_get_internal_ce(SS("reflectionparameter") TSRMLS_CC));
ZEPHIR_INIT_VAR(_3);
zephir_create_array(_3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_3, serviceClass);
zephir_array_fast_append(_3, method);
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, 0);
ZEPHIR_CALL_METHOD(NULL, param, "__construct", &_5, _3, _4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_6, param, "getclass", &_7);
zephir_check_call_status();
if (zephir_is_true(_6)) {
ZEPHIR_CALL_METHOD(&_8, param, "getclass", &_7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(¶mClass, _8, "getname", NULL);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(request);
zephir_fetch_safe_class(_9, paramClass);
_10 = zend_fetch_class(Z_STRVAL_P(_9), Z_STRLEN_P(_9), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(request, _10);
if (zephir_has_constructor(request TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, request, "__construct", NULL);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(NULL, request, "softclone", NULL, tmp);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(_4);
object_init_ex(_4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_VAR(_11);
zephir_json_encode(_11, &(_11), request, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_12);
ZEPHIR_CONCAT_SVSVSV(_12, "Service class:method definition is invalid. Detail: ", service, " : ", method, ". Request: ", _11);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _12);
zephir_check_call_status();
zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 36 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_INIT_NVAR(_4);
object_init_ex(_4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_NVAR(_11);
zephir_json_encode(_11, &(_11), request, 0 TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_12);
ZEPHIR_CONCAT_SV(_12, "Your input is not allowed. Request: ", _11);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _12);
zephir_check_call_status();
zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 39 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
_14 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "requestCheck", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_6, _14, "has", NULL, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
if (zephir_is_true(_6)) {
_15 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_3);
zephir_create_array(_3, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_3, serviceClass);
zephir_array_fast_append(_3, method);
zephir_array_fast_append(_3, rawData);
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "requestCheck", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _15, "get", NULL, _4, _3);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "requestcheck", NULL, serviceClass, method, request);
zephir_check_call_status();
}
ZEPHIR_INIT_VAR(serviceObj);
zephir_fetch_safe_class(_16, serviceClass);
_17 = zend_fetch_class(Z_STRVAL_P(_16), Z_STRLEN_P(_16), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(serviceObj, _17);
if (zephir_has_constructor(serviceObj TSRMLS_CC)) {
_15 = zephir_fetch_nproperty_this(this_ptr, SL("di"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, serviceObj, "__construct", NULL, _15);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_3);
zephir_create_array(_3, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_3, serviceObj);
zephir_array_fast_append(_3, method);
if (zephir_is_callable(_3 TSRMLS_CC)) {
/* try_start_1: */
ZEPHIR_INIT_NVAR(_4);
ZEPHIR_INIT_VAR(_18);
zephir_create_array(_18, 2, 0 TSRMLS_CC);
zephir_array_fast_append(_18, serviceObj);
zephir_array_fast_append(_18, method);
ZEPHIR_INIT_VAR(_19);
zephir_create_array(_19, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_19, request);
ZEPHIR_CALL_USER_FUNC_ARRAY(_4, _18, _19);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_CPY_WRT(response, _4);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
zephir_throw_exception_debug(e, "phalconplus/RPC/Server/AbstractServer.zep", 55 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
ZEPHIR_INIT_NVAR(_4);
_20 = zephir_fetch_nproperty_this(this_ptr, SL("phpOnly"), PH_NOISY_CC);
if (ZEPHIR_IS_TRUE(_20)) {
ZEPHIR_CPY_WRT(_4, response);
} else {
ZEPHIR_CALL_METHOD(&_4, response, "toarray", NULL);
zephir_check_call_status();
}
RETURN_CCTOR(_4);
} else {
object_init_ex(_4, zend_exception_get_default(TSRMLS_C));
ZEPHIR_INIT_VAR(_21);
ZEPHIR_CONCAT_SVSV(_21, "Service:method not found. Detail: ", service, " : ", method);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_13, _21);
zephir_check_call_status();
zephir_throw_exception_debug(_4, "phalconplus/RPC/Server/AbstractServer.zep", 59 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
/**
* Creates a password hash using bcrypt with a pseudo random salt
*/
PHP_METHOD(Phalcon_Security, hash) {
zephir_fcall_cache_entry *_3 = NULL, *_6 = NULL;
int workFactor, ZEPHIR_LAST_CALL_STATUS, hash = 0;
zval *password_param = NULL, *workFactor_param = NULL, *saltBytes = NULL, *_1, *_0$$3, *_2$$9, *_4$$11, *_5$$11, *_7$$13, _8$$13, _9$$13, *_10$$13 = NULL, *_11$$13;
zval *password = NULL, *variant = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &password_param, &workFactor_param);
zephir_get_strval(password, password_param);
if (!workFactor_param) {
workFactor = 0;
} else {
workFactor = zephir_get_intval(workFactor_param);
}
if (!(workFactor)) {
ZEPHIR_OBS_VAR(_0$$3);
zephir_read_property_this(&_0$$3, this_ptr, SL("_workFactor"), PH_NOISY_CC);
workFactor = zephir_get_intval(_0$$3);
}
ZEPHIR_OBS_VAR(_1);
zephir_read_property_this(&_1, this_ptr, SL("_defaultHash"), PH_NOISY_CC);
hash = zephir_get_intval(_1);
do {
if (hash == 5) {
ZEPHIR_INIT_VAR(variant);
ZVAL_STRING(variant, "x", 1);
break;
}
if (hash == 6) {
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "y", 1);
break;
}
if (hash == 7) {
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "5", 1);
break;
}
if (hash == 8) {
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "6", 1);
break;
}
ZEPHIR_INIT_NVAR(variant);
ZVAL_STRING(variant, "a", 1);
break;
} while(0);
do {
if (hash == 1) {
ZEPHIR_INIT_VAR(_2$$9);
ZVAL_LONG(_2$$9, 2);
ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_3, 0, _2$$9);
zephir_check_call_status();
if (Z_TYPE_P(saltBytes) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 195);
return;
}
break;
}
if (hash == 8) {
ZEPHIR_INIT_VAR(_4$$11);
ZVAL_LONG(_4$$11, 8);
ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_3, 0, _4$$11);
zephir_check_call_status();
if (Z_TYPE_P(saltBytes) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 203);
return;
}
ZEPHIR_INIT_VAR(_5$$11);
ZEPHIR_CONCAT_SVSV(_5$$11, "$", variant, "$", saltBytes);
ZEPHIR_RETURN_CALL_FUNCTION("crypt", &_6, 396, password, _5$$11);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_INIT_VAR(_7$$13);
ZVAL_LONG(_7$$13, 22);
ZEPHIR_CALL_METHOD(&saltBytes, this_ptr, "getsaltbytes", &_3, 0, _7$$13);
zephir_check_call_status();
if (Z_TYPE_P(saltBytes) != IS_STRING) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "Unable to get random bytes for the salt", "phalcon/security.zep", 225);
return;
}
if (workFactor < 4) {
workFactor = 4;
} else {
if (workFactor > 31) {
workFactor = 31;
}
}
ZEPHIR_SINIT_VAR(_8$$13);
ZVAL_STRING(&_8$$13, "%02s", 0);
ZEPHIR_SINIT_VAR(_9$$13);
ZVAL_LONG(&_9$$13, workFactor);
ZEPHIR_CALL_FUNCTION(&_10$$13, "sprintf", NULL, 184, &_8$$13, &_9$$13);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11$$13);
ZEPHIR_CONCAT_SVSVSV(_11$$13, "$2", variant, "$", _10$$13, "$", saltBytes);
ZEPHIR_RETURN_CALL_FUNCTION("crypt", &_6, 396, password, _11$$13);
zephir_check_call_status();
RETURN_MM();
} while(0);
RETURN_MM_STRING("", 1);
}
/**
* Produces a recursive representation of an array
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump) {
HashTable *_2;
HashPosition _1;
zend_bool _0;
zephir_fcall_cache_entry *_4 = NULL, *_7 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *argument_param = NULL, *n = NULL, *numberArguments = NULL, *dump = NULL, *varDump = NULL, *k = NULL, *v = NULL, **_3, *_5$$8 = NULL, *_6$$8 = NULL, *_8$$9 = NULL, *_9$$5 = NULL;
zval *argument = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &argument_param, &n);
argument = argument_param;
if (!n) {
ZEPHIR_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
ZEPHIR_INIT_VAR(numberArguments);
ZVAL_LONG(numberArguments, zephir_fast_count_int(argument TSRMLS_CC));
_0 = ZEPHIR_GE_LONG(n, 3);
if (!(_0)) {
_0 = ZEPHIR_IS_LONG(numberArguments, 0);
}
if (_0) {
RETURN_MM_NULL();
}
if (ZEPHIR_GE_LONG(numberArguments, 10)) {
RETURN_CCTOR(numberArguments);
}
ZEPHIR_INIT_VAR(dump);
array_init(dump);
zephir_is_iterable(argument, &_2, &_1, 0, 0, "phalcon/debug.zep", 189);
for (
; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zend_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(k, _2, _1);
ZEPHIR_GET_HVALUE(v, _3);
if (ZEPHIR_IS_STRING(v, "")) {
ZEPHIR_INIT_NVAR(varDump);
ZVAL_STRING(varDump, "(empty string)", 1);
} else if (zephir_is_scalar(v)) {
ZEPHIR_CALL_METHOD(&varDump, this_ptr, "_escapestring", &_4, 0, v);
zephir_check_call_status();
} else if (Z_TYPE_P(v) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(_6$$8);
ZVAL_LONG(_6$$8, (zephir_get_numberval(n) + 1));
ZEPHIR_CALL_METHOD(&_5$$8, this_ptr, "_getarraydump", &_7, 159, v, _6$$8);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(varDump);
ZEPHIR_CONCAT_SVS(varDump, "Array(", _5$$8, ")");
} else if (Z_TYPE_P(v) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_8$$9);
zephir_get_class(_8$$9, v, 0 TSRMLS_CC);
ZEPHIR_INIT_NVAR(varDump);
ZEPHIR_CONCAT_SVS(varDump, "Object(", _8$$9, ")");
} else if (Z_TYPE_P(v) == IS_NULL) {
ZEPHIR_INIT_NVAR(varDump);
ZVAL_STRING(varDump, "null", 1);
} else {
ZEPHIR_CPY_WRT(varDump, v);
}
ZEPHIR_INIT_LNVAR(_9$$5);
ZEPHIR_CONCAT_SVSV(_9$$5, "[", k, "] => ", varDump);
zephir_array_append(&dump, _9$$5, PH_SEPARATE, "phalcon/debug.zep", 186);
}
zephir_fast_join_str(return_value, SL(", "), dump TSRMLS_CC);
RETURN_MM();
}
/**
* Generates SQL to add a column to a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, addColumn) {
int ZEPHIR_LAST_CALL_STATUS;
zval *tableName_param = NULL, *schemaName_param = NULL, *column, *sql = NULL, *defaultValue = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_3, *_4 = NULL, *_9 = NULL, *_10 = NULL, *_5$$3, _6$$5, *_7$$5 = NULL, *_8$$5;
zval *tableName = NULL, *schemaName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &tableName_param, &schemaName_param, &column);
if (unlikely(Z_TYPE_P(tableName_param) != IS_STRING && Z_TYPE_P(tableName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tableName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tableName_param) == IS_STRING)) {
zephir_get_strval(tableName, tableName_param);
} else {
ZEPHIR_INIT_VAR(tableName);
ZVAL_EMPTY_STRING(tableName);
}
if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) {
zephir_get_strval(schemaName, schemaName_param);
} else {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
}
ZEPHIR_CALL_METHOD(&_0, this_ptr, "preparetable", NULL, 0, tableName, schemaName);
zephir_check_call_status();
ZEPHIR_INIT_VAR(sql);
ZEPHIR_CONCAT_SVS(sql, "ALTER TABLE ", _0, " ADD COLUMN ");
ZEPHIR_CALL_METHOD(&_1, column, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2, this_ptr, "getcolumndefinition", NULL, 0, column);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SVSV(_3, "\"", _1, "\" ", _2);
zephir_concat_self(&sql, _3 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&_4, column, "hasdefault", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_4)) {
ZEPHIR_CALL_METHOD(&defaultValue, column, "getdefault", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_5$$3);
zephir_fast_strtoupper(_5$$3, defaultValue);
if (zephir_memnstr_str(_5$$3, SL("CURRENT_TIMESTAMP"), "phalcon/db/dialect/sqlite.zep", 203)) {
zephir_concat_self_str(&sql, SL(" DEFAULT CURRENT_TIMESTAMP") TSRMLS_CC);
} else {
ZEPHIR_SINIT_VAR(_6$$5);
ZVAL_STRING(&_6$$5, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_7$$5, "addcslashes", NULL, 153, defaultValue, &_6$$5);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_8$$5);
ZEPHIR_CONCAT_SVS(_8$$5, " DEFAULT \"", _7$$5, "\"");
zephir_concat_self(&sql, _8$$5 TSRMLS_CC);
}
}
ZEPHIR_CALL_METHOD(&_9, column, "isnotnull", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_9)) {
zephir_concat_self_str(&sql, SL(" NOT NULL") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_10, column, "isautoincrement", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_10)) {
zephir_concat_self_str(&sql, SL(" PRIMARY KEY AUTOINCREMENT") TSRMLS_CC);
}
RETURN_CCTOR(sql);
}
/**
* Sets the HTTP response code
*
*<code>
* $response->setStatusCode(404, "Not Found");
*</code>
*/
PHP_METHOD(Phalcon_Http_Response, setStatusCode) {
zval *_10;
zephir_fcall_cache_entry *_7 = NULL, *_8 = NULL;
zend_bool _4;
HashTable *_2;
HashPosition _1;
zval *message = NULL, *_13, *_15;
zval *code_param = NULL, *message_param = NULL, *headers = NULL, *currentHeadersRaw = NULL, *key = NULL, *defaultMessage, *_0 = NULL, **_3, _5 = zval_used_for_init, *_6 = NULL, *_9, *_11, *_12, _14;
int code, ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &code_param, &message_param);
code = zephir_get_intval(code_param);
if (!message_param) {
ZEPHIR_INIT_VAR(message);
ZVAL_EMPTY_STRING(message);
} else {
zephir_get_strval(message, message_param);
}
ZEPHIR_CALL_METHOD(&headers, this_ptr, "getheaders", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(¤tHeadersRaw, headers, "toarray", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(currentHeadersRaw) == IS_ARRAY) {
ZEPHIR_INIT_VAR(_0);
zephir_is_iterable(currentHeadersRaw, &_2, &_1, 0, 0, "phalcon/http/response.zep", 130);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(key, _2, _1);
ZEPHIR_GET_HVALUE(_0, _3);
_4 = Z_TYPE_P(key) == IS_STRING;
if (_4) {
ZEPHIR_SINIT_NVAR(_5);
ZVAL_STRING(&_5, "HTTP/", 0);
ZEPHIR_CALL_FUNCTION(&_6, "strstr", &_7, 235, key, &_5);
zephir_check_call_status();
_4 = zephir_is_true(_6);
}
if (_4) {
ZEPHIR_CALL_METHOD(NULL, headers, "remove", &_8, 0, key);
zephir_check_call_status();
}
}
}
if (ZEPHIR_IS_STRING_IDENTICAL(message, "")) {
ZEPHIR_OBS_VAR(_9);
zephir_read_property_this(&_9, this_ptr, SL("_statusCodes"), PH_NOISY_CC);
if (Z_TYPE_P(_9) != IS_ARRAY) {
ZEPHIR_INIT_VAR(_10);
zephir_create_array(_10, 59, 0 TSRMLS_CC);
add_index_stringl(_10, 100, SL("Continue"), 1);
add_index_stringl(_10, 101, SL("Switching Protocols"), 1);
add_index_stringl(_10, 102, SL("Processing"), 1);
add_index_stringl(_10, 200, SL("OK"), 1);
add_index_stringl(_10, 201, SL("Created"), 1);
add_index_stringl(_10, 202, SL("Accepted"), 1);
add_index_stringl(_10, 203, SL("Non-Authoritative Information"), 1);
add_index_stringl(_10, 204, SL("No Content"), 1);
add_index_stringl(_10, 205, SL("Reset Content"), 1);
add_index_stringl(_10, 206, SL("Partial Content"), 1);
add_index_stringl(_10, 207, SL("Multi-status"), 1);
add_index_stringl(_10, 208, SL("Already Reported"), 1);
add_index_stringl(_10, 300, SL("Multiple Choices"), 1);
add_index_stringl(_10, 301, SL("Moved Permanently"), 1);
add_index_stringl(_10, 302, SL("Found"), 1);
add_index_stringl(_10, 303, SL("See Other"), 1);
add_index_stringl(_10, 304, SL("Not Modified"), 1);
add_index_stringl(_10, 305, SL("Use Proxy"), 1);
add_index_stringl(_10, 306, SL("Switch Proxy"), 1);
add_index_stringl(_10, 307, SL("Temporary Redirect"), 1);
add_index_stringl(_10, 400, SL("Bad Request"), 1);
add_index_stringl(_10, 401, SL("Unauthorized"), 1);
add_index_stringl(_10, 402, SL("Payment Required"), 1);
add_index_stringl(_10, 403, SL("Forbidden"), 1);
add_index_stringl(_10, 404, SL("Not Found"), 1);
add_index_stringl(_10, 405, SL("Method Not Allowed"), 1);
add_index_stringl(_10, 406, SL("Not Acceptable"), 1);
add_index_stringl(_10, 407, SL("Proxy Authentication Required"), 1);
add_index_stringl(_10, 408, SL("Request Time-out"), 1);
add_index_stringl(_10, 409, SL("Conflict"), 1);
add_index_stringl(_10, 410, SL("Gone"), 1);
add_index_stringl(_10, 411, SL("Length Required"), 1);
add_index_stringl(_10, 412, SL("Precondition Failed"), 1);
add_index_stringl(_10, 413, SL("Request Entity Too Large"), 1);
add_index_stringl(_10, 414, SL("Request-URI Too Large"), 1);
add_index_stringl(_10, 415, SL("Unsupported Media Type"), 1);
add_index_stringl(_10, 416, SL("Requested range not satisfiable"), 1);
add_index_stringl(_10, 417, SL("Expectation Failed"), 1);
add_index_stringl(_10, 418, SL("I'm a teapot"), 1);
add_index_stringl(_10, 422, SL("Unprocessable Entity"), 1);
add_index_stringl(_10, 423, SL("Locked"), 1);
add_index_stringl(_10, 424, SL("Failed Dependency"), 1);
add_index_stringl(_10, 425, SL("Unordered Collection"), 1);
add_index_stringl(_10, 426, SL("Upgrade Required"), 1);
add_index_stringl(_10, 428, SL("Precondition Required"), 1);
add_index_stringl(_10, 429, SL("Too Many Requests"), 1);
add_index_stringl(_10, 431, SL("Request Header Fields Too Large"), 1);
add_index_stringl(_10, 500, SL("Internal Server Error"), 1);
add_index_stringl(_10, 501, SL("Not Implemented"), 1);
add_index_stringl(_10, 502, SL("Bad Gateway"), 1);
add_index_stringl(_10, 503, SL("Service Unavailable"), 1);
add_index_stringl(_10, 504, SL("Gateway Time-out"), 1);
add_index_stringl(_10, 505, SL("HTTP Version not supported"), 1);
add_index_stringl(_10, 506, SL("Variant Also Negotiates"), 1);
add_index_stringl(_10, 507, SL("Insufficient Storage"), 1);
add_index_stringl(_10, 508, SL("Loop Detected"), 1);
add_index_stringl(_10, 511, SL("Network Authentication Required"), 1);
zephir_update_property_this(this_ptr, SL("_statusCodes"), _10 TSRMLS_CC);
}
_11 = zephir_fetch_nproperty_this(this_ptr, SL("_statusCodes"), PH_NOISY_CC);
if (!(zephir_array_isset_long(_11, code))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_http_response_exception_ce, "Non-standard statuscode given without a message", "phalcon/http/response.zep", 204);
return;
}
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_statusCodes"), PH_NOISY_CC);
ZEPHIR_OBS_VAR(defaultMessage);
zephir_array_fetch_long(&defaultMessage, _12, code, PH_NOISY, "phalcon/http/response.zep", 207 TSRMLS_CC);
zephir_get_strval(message, defaultMessage);
}
ZEPHIR_SINIT_NVAR(_5);
ZVAL_LONG(&_5, code);
ZEPHIR_INIT_VAR(_13);
ZEPHIR_CONCAT_SVSV(_13, "HTTP/1.1 ", &_5, " ", message);
ZEPHIR_CALL_METHOD(NULL, headers, "setraw", NULL, 0, _13);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_14);
ZVAL_LONG(&_14, code);
ZEPHIR_INIT_VAR(_15);
ZEPHIR_CONCAT_VSV(_15, &_14, " ", message);
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "Status", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, headers, "set", NULL, 0, _0, _15);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
RETURN_THIS();
}
/**
* Builds a SELECT statement
*
* @param array definition
* @return string
*/
PHP_METHOD(Pdm_Db_AbstractDialect, select) {
zephir_fcall_cache_entry *_4 = NULL, *_9 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2, *_6, *_11, *_16, *_22, *_26;
HashPosition _1, _5, _10, _15, _21, _25;
zval *definition, *tables, *columns = NULL, *escapeChar = NULL, *columnItem = NULL, *column = NULL, *selectedColumns, *columnSql = NULL, *columnDomainSql = NULL, *columnAlias = NULL, *selectedTables, *sqlJoin = NULL, *joinExpressions = NULL, *joinCondition = NULL, *joinConditionsArray = NULL, *tablesSql = NULL, *columnDomain = NULL, *columnAliasSql = NULL, *columnsSql = NULL, *table = NULL, *sql, *joins, *join = NULL, *sqlTable = NULL, *whereConditions, *groupFields, *groupField = NULL, *groupItems, *havingConditions, *orderFields, *orderItem = NULL, *orderItems, *orderSqlItem = NULL, *sqlOrderType = NULL, *orderSqlItemType = NULL, *limitValue, *number, *offset, *_0, **_3, **_7, *_8 = NULL, **_12, *_13, *_14, **_17, *_18 = NULL, *_19 = NULL, *_20 = NULL, **_23, *_24 = NULL, **_27, *_28, *_29;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &definition);
if (Z_TYPE_P(definition) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "Invalid SELECT definition", "pdm/db/abstractdialect.zep", 375);
return;
}
ZEPHIR_OBS_VAR(tables);
if (!(zephir_array_isset_string_fetch(&tables, definition, SS("tables"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "The index 'tables' is required in the definition array", "pdm/db/abstractdialect.zep", 379);
return;
}
ZEPHIR_OBS_VAR(columns);
if (!(zephir_array_isset_string_fetch(&columns, definition, SS("columns"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(pdm_db_exception_ce, "The index 'columns' is required in the definition array", "pdm/db/abstractdialect.zep", 383);
return;
}
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("escapeChar"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(escapeChar, _0);
} else {
ZEPHIR_INIT_VAR(escapeChar);
ZVAL_NULL(escapeChar);
}
ZEPHIR_OBS_NVAR(columns);
zephir_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(columns) == IS_ARRAY) {
ZEPHIR_INIT_VAR(selectedColumns);
array_init(selectedColumns);
zephir_is_iterable(columns, &_2, &_1, 0, 0);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(column, _3);
ZEPHIR_OBS_NVAR(columnItem);
zephir_array_fetch_long(&columnItem, column, 0, PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(columnItem) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&columnSql, this_ptr, "getsqlexpression", &_4, columnItem, escapeChar);
zephir_check_call_status();
} else {
if (ZEPHIR_IS_STRING(columnItem, "*")) {
ZEPHIR_CPY_WRT(columnSql, columnItem);
} else {
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_INIT_NVAR(columnSql);
ZEPHIR_CONCAT_VVV(columnSql, escapeChar, columnItem, escapeChar);
} else {
ZEPHIR_CPY_WRT(columnSql, columnItem);
}
}
}
ZEPHIR_OBS_NVAR(columnDomain);
if (zephir_array_isset_long_fetch(&columnDomain, column, 1, 0 TSRMLS_CC)) {
if (zephir_is_true(columnDomain)) {
ZEPHIR_INIT_NVAR(columnDomainSql);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VVVSV(columnDomainSql, escapeChar, columnDomain, escapeChar, ".", columnSql);
} else {
ZEPHIR_CONCAT_VSV(columnDomainSql, columnDomain, ".", columnSql);
}
} else {
ZEPHIR_CPY_WRT(columnDomainSql, columnSql);
}
} else {
ZEPHIR_CPY_WRT(columnDomainSql, columnSql);
}
ZEPHIR_OBS_NVAR(columnAlias);
if (zephir_array_isset_long_fetch(&columnAlias, column, 2, 0 TSRMLS_CC)) {
if (zephir_is_true(columnAlias)) {
ZEPHIR_INIT_NVAR(columnAliasSql);
if (ZEPHIR_GLOBAL(db).escape_identifiers) {
ZEPHIR_CONCAT_VSVVV(columnAliasSql, columnDomainSql, " AS ", escapeChar, columnAlias, escapeChar);
} else {
ZEPHIR_CONCAT_VSV(columnAliasSql, columnDomainSql, " AS ", columnAlias);
}
} else {
ZEPHIR_CPY_WRT(columnAliasSql, columnDomainSql);
}
} else {
ZEPHIR_CPY_WRT(columnAliasSql, columnDomainSql);
}
zephir_array_append(&selectedColumns, columnAliasSql, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(columnsSql);
zephir_fast_join_str(columnsSql, SL(", "), selectedColumns TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(columnsSql, columns);
}
if (Z_TYPE_P(tables) == IS_ARRAY) {
ZEPHIR_INIT_VAR(selectedTables);
array_init(selectedTables);
zephir_is_iterable(tables, &_6, &_5, 0, 0);
for (
; zephir_hash_get_current_data_ex(_6, (void**) &_7, &_5) == SUCCESS
; zephir_hash_move_forward_ex(_6, &_5)
) {
ZEPHIR_GET_HVALUE(table, _7);
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqltable", &_9, table, escapeChar);
zephir_check_call_status();
zephir_array_append(&selectedTables, _8, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(tablesSql);
zephir_fast_join_str(tablesSql, SL(", "), selectedTables TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(tablesSql, tables);
}
ZEPHIR_INIT_VAR(sql);
ZEPHIR_CONCAT_SVSV(sql, "SELECT ", columnsSql, " FROM ", tablesSql);
ZEPHIR_OBS_VAR(joins);
if (zephir_array_isset_string_fetch(&joins, definition, SS("joins"), 0 TSRMLS_CC)) {
zephir_is_iterable(joins, &_11, &_10, 0, 0);
for (
; zephir_hash_get_current_data_ex(_11, (void**) &_12, &_10) == SUCCESS
; zephir_hash_move_forward_ex(_11, &_10)
) {
ZEPHIR_GET_HVALUE(join, _12);
zephir_array_fetch_string(&_13, join, SL("source"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&sqlTable, this_ptr, "getsqltable", &_9, _13, escapeChar);
zephir_check_call_status();
zephir_array_append(&selectedTables, sqlTable, PH_SEPARATE);
zephir_array_fetch_string(&_14, join, SL("type"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_INIT_NVAR(sqlJoin);
ZEPHIR_CONCAT_SVSV(sqlJoin, " ", _14, " JOIN ", sqlTable);
ZEPHIR_OBS_NVAR(joinConditionsArray);
if (zephir_array_isset_string_fetch(&joinConditionsArray, join, SS("conditions"), 0 TSRMLS_CC)) {
if (zephir_fast_count_int(joinConditionsArray TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(joinExpressions);
array_init(joinExpressions);
zephir_is_iterable(joinConditionsArray, &_16, &_15, 0, 0);
for (
; zephir_hash_get_current_data_ex(_16, (void**) &_17, &_15) == SUCCESS
; zephir_hash_move_forward_ex(_16, &_15)
) {
ZEPHIR_GET_HVALUE(joinCondition, _17);
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, joinCondition, escapeChar);
zephir_check_call_status();
zephir_array_append(&joinExpressions, _8, PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_18);
zephir_fast_join_str(_18, SL(" AND "), joinExpressions TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_19);
ZEPHIR_CONCAT_SVS(_19, " ON ", _18, " ");
zephir_concat_self(&sqlJoin, _19 TSRMLS_CC);
}
}
zephir_concat_self(&sql, sqlJoin TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(whereConditions);
if (zephir_array_isset_string_fetch(&whereConditions, definition, SS("where"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(whereConditions) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, whereConditions, escapeChar);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_19);
ZEPHIR_CONCAT_SV(_19, " WHERE ", _8);
zephir_concat_self(&sql, _19 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_20);
ZEPHIR_CONCAT_SV(_20, " WHERE ", whereConditions);
zephir_concat_self(&sql, _20 TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(groupFields);
if (zephir_array_isset_string_fetch(&groupFields, definition, SS("group"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(groupItems);
array_init(groupItems);
zephir_is_iterable(groupFields, &_22, &_21, 0, 0);
for (
; zephir_hash_get_current_data_ex(_22, (void**) &_23, &_21) == SUCCESS
; zephir_hash_move_forward_ex(_22, &_21)
) {
ZEPHIR_GET_HVALUE(groupField, _23);
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, groupField, escapeChar);
zephir_check_call_status();
zephir_array_append(&groupItems, _8, PH_SEPARATE);
}
ZEPHIR_INIT_NVAR(_18);
zephir_fast_join_str(_18, SL(", "), groupItems TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_20);
ZEPHIR_CONCAT_SV(_20, " GROUP BY ", _18);
zephir_concat_self(&sql, _20 TSRMLS_CC);
ZEPHIR_OBS_VAR(havingConditions);
if (zephir_array_isset_string_fetch(&havingConditions, definition, SS("having"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&_8, this_ptr, "getsqlexpression", &_4, havingConditions, escapeChar);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_24);
ZEPHIR_CONCAT_SV(_24, " HAVING ", _8);
zephir_concat_self(&sql, _24 TSRMLS_CC);
}
}
ZEPHIR_OBS_VAR(orderFields);
if (zephir_array_isset_string_fetch(&orderFields, definition, SS("order"), 0 TSRMLS_CC)) {
ZEPHIR_INIT_VAR(orderItems);
array_init(orderItems);
zephir_is_iterable(orderFields, &_26, &_25, 0, 0);
for (
; zephir_hash_get_current_data_ex(_26, (void**) &_27, &_25) == SUCCESS
; zephir_hash_move_forward_ex(_26, &_25)
) {
ZEPHIR_GET_HVALUE(orderItem, _27);
zephir_array_fetch_long(&_13, orderItem, 0, PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_CALL_METHOD(&orderSqlItem, this_ptr, "getsqlexpression", &_4, _13, escapeChar);
zephir_check_call_status();
ZEPHIR_OBS_NVAR(sqlOrderType);
if (zephir_array_isset_long_fetch(&sqlOrderType, orderItem, 1, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(orderSqlItemType);
ZEPHIR_CONCAT_VSV(orderSqlItemType, orderSqlItem, " ", sqlOrderType);
} else {
ZEPHIR_CPY_WRT(orderSqlItemType, orderSqlItem);
}
zephir_array_append(&orderItems, orderSqlItemType, PH_SEPARATE);
}
ZEPHIR_INIT_VAR(_28);
zephir_fast_join_str(_28, SL(", "), orderItems TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_20);
ZEPHIR_CONCAT_SV(_20, " ORDER BY ", _28);
zephir_concat_self(&sql, _20 TSRMLS_CC);
}
if (zephir_array_isset_string_fetch(&limitValue, definition, SS("limit"), 1 TSRMLS_CC)) {
if (Z_TYPE_P(limitValue) == IS_ARRAY) {
zephir_array_fetch_string(&_13, limitValue, SL("number"), PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_array_fetch_string(&number, _13, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
if (zephir_array_isset_string_fetch(&offset, limitValue, SS("offset"), 1 TSRMLS_CC)) {
zephir_array_fetch_string(&_14, offset, SL("value"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_24);
ZEPHIR_CONCAT_SVSV(_24, " LIMIT ", number, " OFFSET ", _14);
zephir_concat_self(&sql, _24 TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(_29);
ZEPHIR_CONCAT_SV(_29, " LIMIT ", number);
zephir_concat_self(&sql, _29 TSRMLS_CC);
}
} else {
ZEPHIR_INIT_LNVAR(_20);
ZEPHIR_CONCAT_SV(_20, " LIMIT ", limitValue);
zephir_concat_self(&sql, _20 TSRMLS_CC);
}
}
RETURN_CCTOR(sql);
}
/**
* Executes the validator
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate) {
HashTable *_2$$5, *_22$$16;
HashPosition _1$$5, _21$$16;
zend_class_entry *_33;
zephir_fcall_cache_entry *_6 = NULL, *_12 = NULL, *_31 = NULL;
int ZEPHIR_LAST_CALL_STATUS, number = 0;
zval *record, *field = NULL, *dependencyInjector = NULL, *metaData = NULL, *message = NULL, *bindTypes = NULL, *bindDataTypes = NULL, *columnMap = NULL, *conditions = NULL, *bindParams = NULL, *composeField = NULL, *columnField = NULL, *bindType = NULL, *primaryField = NULL, *attributeField = NULL, *params = NULL, *className = NULL, *replacePairs = NULL, *_0 = NULL, *_19 = NULL, *_32 = NULL, **_3$$5, *_4$$8 = NULL, *_5$$8 = NULL, *_7$$10 = NULL, *_8$$10 = NULL, _9$$6 = zval_used_for_init, *_10$$6 = NULL, *_11$$6 = NULL, *_13$$13, *_14$$13, *_15$$15, *_16$$15, *_17$$11, *_18$$11 = NULL, *_20$$16 = NULL, **_23$$16, *_24$$20 = NULL, *_25$$20 = NULL, *_26$$22 = NULL, *_27$$22 = NULL, _28$$19 = zval_used_for_init, *_29$$19 = NULL, *_30$$19 = NULL, *_34$$24 = NULL, *_36$$24 = NULL, *_35$$25;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &record);
ZEPHIR_CALL_METHOD(&dependencyInjector, record, "getdi", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_0);
ZVAL_STRING(_0, "modelsMetadata", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&metaData, dependencyInjector, "getshared", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(bindTypes);
array_init(bindTypes);
ZEPHIR_CALL_METHOD(&bindDataTypes, metaData, "getbindtypes", NULL, 0, record);
zephir_check_call_status();
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getreversecolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_INIT_VAR(conditions);
array_init(conditions);
ZEPHIR_INIT_VAR(bindParams);
array_init(bindParams);
number = 0;
ZEPHIR_INIT_NVAR(_0);
ZVAL_STRING(_0, "field", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&field, this_ptr, "getoption", NULL, 0, _0);
zephir_check_temp_parameter(_0);
zephir_check_call_status();
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_is_iterable(field, &_2$$5, &_1$$5, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 127);
for (
; zephir_hash_get_current_data_ex(_2$$5, (void**) &_3$$5, &_1$$5) == SUCCESS
; zephir_hash_move_forward_ex(_2$$5, &_1$$5)
) {
ZEPHIR_GET_HVALUE(composeField, _3$$5);
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, composeField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_4$$8);
object_init_ex(_4$$8, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_5$$8);
ZEPHIR_CONCAT_SVS(_5$$8, "Column '", composeField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _4$$8, "__construct", &_6, 9, _5$$8);
zephir_check_call_status();
zephir_throw_exception_debug(_4$$8, "phalcon/mvc/model/validator/uniqueness.zep", 104 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, composeField);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_7$$10);
object_init_ex(_7$$10, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_8$$10);
ZEPHIR_CONCAT_SVS(_8$$10, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _7$$10, "__construct", &_6, 9, _8$$10);
zephir_check_call_status();
zephir_throw_exception_debug(_7$$10, "phalcon/mvc/model/validator/uniqueness.zep", 114 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_SINIT_NVAR(_9$$6);
ZVAL_LONG(&_9$$6, number);
ZEPHIR_INIT_LNVAR(_10$$6);
ZEPHIR_CONCAT_SVSV(_10$$6, "[", composeField, "] = ?", &_9$$6);
zephir_array_append(&conditions, _10$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 120);
ZEPHIR_CALL_METHOD(&_11$$6, record, "readattribute", &_12, 0, composeField);
zephir_check_call_status();
zephir_array_append(&bindParams, _11$$6, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 121);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 122);
number++;
}
} else {
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(columnField);
if (!(zephir_array_isset_fetch(&columnField, columnMap, field, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_13$$13);
object_init_ex(_13$$13, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_14$$13);
ZEPHIR_CONCAT_SVS(_14$$13, "Column '", field, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _13$$13, "__construct", &_6, 9, _14$$13);
zephir_check_call_status();
zephir_throw_exception_debug(_13$$13, "phalcon/mvc/model/validator/uniqueness.zep", 134 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(columnField, field);
}
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, columnField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_15$$15);
object_init_ex(_15$$15, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_16$$15);
ZEPHIR_CONCAT_SVS(_16$$15, "Column '", columnField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _15$$15, "__construct", &_6, 9, _16$$15);
zephir_check_call_status();
zephir_throw_exception_debug(_15$$15, "phalcon/mvc/model/validator/uniqueness.zep", 144 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(_17$$11);
ZEPHIR_CONCAT_SVS(_17$$11, "[", field, "] = ?0");
zephir_array_append(&conditions, _17$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 150);
ZEPHIR_CALL_METHOD(&_18$$11, record, "readattribute", NULL, 0, field);
zephir_check_call_status();
zephir_array_append(&bindParams, _18$$11, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 151);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 152);
number++;
}
ZEPHIR_CALL_METHOD(&_19, record, "getoperationmade", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_LONG(_19, 2)) {
if (ZEPHIR_GLOBAL(orm).column_renaming) {
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getcolumnmap", NULL, 0, record);
zephir_check_call_status();
} else {
ZEPHIR_INIT_NVAR(columnMap);
ZVAL_NULL(columnMap);
}
ZEPHIR_CALL_METHOD(&_20$$16, metaData, "getprimarykeyattributes", NULL, 0, record);
zephir_check_call_status();
zephir_is_iterable(_20$$16, &_22$$16, &_21$$16, 0, 0, "phalcon/mvc/model/validator/uniqueness.zep", 197);
for (
; zephir_hash_get_current_data_ex(_22$$16, (void**) &_23$$16, &_21$$16) == SUCCESS
; zephir_hash_move_forward_ex(_22$$16, &_21$$16)
) {
ZEPHIR_GET_HVALUE(primaryField, _23$$16);
ZEPHIR_OBS_NVAR(bindType);
if (!(zephir_array_isset_fetch(&bindType, bindDataTypes, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_24$$20);
object_init_ex(_24$$20, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_25$$20);
ZEPHIR_CONCAT_SVS(_25$$20, "Column '", primaryField, "' isn't part of the table columns");
ZEPHIR_CALL_METHOD(NULL, _24$$20, "__construct", &_6, 9, _25$$20);
zephir_check_call_status();
zephir_throw_exception_debug(_24$$20, "phalcon/mvc/model/validator/uniqueness.zep", 174 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(columnMap) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(attributeField);
if (!(zephir_array_isset_fetch(&attributeField, columnMap, primaryField, 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(_26$$22);
object_init_ex(_26$$22, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_LNVAR(_27$$22);
ZEPHIR_CONCAT_SVS(_27$$22, "Column '", primaryField, "' isn't part of the column map");
ZEPHIR_CALL_METHOD(NULL, _26$$22, "__construct", &_6, 9, _27$$22);
zephir_check_call_status();
zephir_throw_exception_debug(_26$$22, "phalcon/mvc/model/validator/uniqueness.zep", 182 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
} else {
ZEPHIR_CPY_WRT(attributeField, primaryField);
}
ZEPHIR_SINIT_NVAR(_28$$19);
ZVAL_LONG(&_28$$19, number);
ZEPHIR_INIT_LNVAR(_29$$19);
ZEPHIR_CONCAT_SVSV(_29$$19, "[", attributeField, "] <> ?", &_28$$19);
zephir_array_append(&conditions, _29$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 191);
ZEPHIR_CALL_METHOD(&_30$$19, record, "readattribute", &_31, 0, primaryField);
zephir_check_call_status();
zephir_array_append(&bindParams, _30$$19, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 192);
zephir_array_append(&bindTypes, bindType, PH_SEPARATE, "phalcon/mvc/model/validator/uniqueness.zep", 193);
number++;
}
}
ZEPHIR_INIT_VAR(params);
array_init(params);
zephir_array_update_string(¶ms, SL("di"), &dependencyInjector, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_0);
zephir_fast_join_str(_0, SL(" AND "), conditions TSRMLS_CC);
zephir_array_update_string(¶ms, SL("conditions"), &_0, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bind"), &bindParams, PH_COPY | PH_SEPARATE);
zephir_array_update_string(¶ms, SL("bindTypes"), &bindTypes, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_VAR(className);
zephir_get_class(className, record, 0 TSRMLS_CC);
_33 = zephir_fetch_class(className TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&_32, _33, "count", NULL, 0, params);
zephir_check_call_status();
if (!ZEPHIR_IS_LONG(_32, 0)) {
ZEPHIR_INIT_VAR(_34$$24);
ZVAL_STRING(_34$$24, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
if (Z_TYPE_P(field) == IS_ARRAY) {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_35$$25);
zephir_fast_join_str(_35$$25, SL(", "), field TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":fields"), &_35$$25, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of fields: :fields are already present in another record", 1);
}
} else {
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &field, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(message);
ZVAL_STRING(message, "Value of field: ':field' is already present in another record", 1);
}
}
ZEPHIR_CALL_FUNCTION(&_36$$24, "strtr", NULL, 26, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_34$$24);
ZVAL_STRING(_34$$24, "Unique", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "appendmessage", NULL, 0, _36$$24, field, _34$$24);
zephir_check_temp_parameter(_34$$24);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Produces a recursive representation of an array
*/
PHP_METHOD(Phalcon_Debug, _getArrayDump) {
zephir_fcall_cache_entry *_6 = NULL, *_8 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zephir_nts_static zephir_fcall_cache_entry *_4 = NULL;
HashTable *_1;
HashPosition _0;
zval *argument_param = NULL, *n = NULL, *numberArguments, *dump, *varDump = NULL, *k = NULL, *v = NULL, **_2, *_3 = NULL, *_5 = NULL, *_7 = NULL, *_9 = NULL;
zval *argument = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &argument_param, &n);
argument = argument_param;
if (!n) {
ZEPHIR_INIT_VAR(n);
ZVAL_LONG(n, 0);
}
ZEPHIR_INIT_VAR(numberArguments);
ZVAL_LONG(numberArguments, zephir_fast_count_int(argument TSRMLS_CC));
if (ZEPHIR_LT_LONG(n, 3)) {
if (ZEPHIR_GT_LONG(numberArguments, 0)) {
if (ZEPHIR_LT_LONG(numberArguments, 10)) {
ZEPHIR_INIT_VAR(dump);
array_init(dump);
zephir_is_iterable(argument, &_1, &_0, 0, 0, "phalcon/debug.zep", 193);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(k, _1, _0);
ZEPHIR_GET_HVALUE(v, _2);
ZEPHIR_CALL_FUNCTION(&_3, "is_scalar", &_4, v);
zephir_check_call_status();
if (zephir_is_true(_3)) {
ZEPHIR_INIT_NVAR(varDump);
if (ZEPHIR_IS_STRING(v, "")) {
ZEPHIR_CONCAT_SVS(varDump, "[", k, "] => (empty string)");
} else {
ZEPHIR_CALL_METHOD(&_5, this_ptr, "_escapestring", &_6, v);
zephir_check_call_status();
ZEPHIR_CONCAT_SVSV(varDump, "[", k, "] => ", _5);
}
zephir_array_append(&dump, varDump, PH_SEPARATE, "phalcon/debug.zep", 171);
} else {
if (Z_TYPE_P(v) == IS_ARRAY) {
ZEPHIR_INIT_NVAR(_7);
ZVAL_LONG(_7, (zephir_get_numberval(n) + 1));
ZEPHIR_CALL_METHOD(&_5, this_ptr, "_getarraydump", &_8, v, _7);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVSVS(_9, "[", k, "] => Array(", _5, ")");
zephir_array_append(&dump, _9, PH_SEPARATE, "phalcon/debug.zep", 175);
continue;
}
if (Z_TYPE_P(v) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_7);
zephir_get_class(_7, v, 0 TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVSVS(_9, "[", k, "] => Object(", _7, ")");
zephir_array_append(&dump, _9, PH_SEPARATE, "phalcon/debug.zep", 180);
continue;
}
if (Z_TYPE_P(v) == IS_NULL) {
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVS(_9, "[", k, "] => null");
zephir_array_append(&dump, _9, PH_SEPARATE, "phalcon/debug.zep", 185);
continue;
}
ZEPHIR_INIT_LNVAR(_9);
ZEPHIR_CONCAT_SVSV(_9, "[", k, "] => ", v);
zephir_array_append(&dump, _9, PH_SEPARATE, "phalcon/debug.zep", 189);
}
}
zephir_fast_join_str(return_value, SL(", "), dump TSRMLS_CC);
RETURN_MM();
}
RETURN_CCTOR(numberArguments);
}
}
RETURN_MM_NULL();
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) {
zend_class_entry *_13$$15;
HashTable *_3, *_6$$11;
HashPosition _2, _5$$11;
zval *row = NULL, *hydrateMode = NULL, *eager = NULL, *alias = NULL, *activeRow = NULL, *type = NULL, *column = NULL, *columnValue = NULL, *value = NULL, *attribute = NULL, *source = NULL, *attributes = NULL, *columnMap = NULL, *rowModel = NULL, *keepSnapshots = NULL, *sqlAlias = NULL, *modelName = NULL, *_0, *_1, **_4, **_7$$11, *_8$$12 = NULL, *_9$$15 = NULL, *_11$$15, *_12$$15 = NULL, *_10$$16, *_15$$18, *_16$$18 = NULL, _18$$24 = zval_used_for_init, _19$$24 = zval_used_for_init;
zephir_fcall_cache_entry *_14 = NULL, *_17 = NULL;
int ZEPHIR_LAST_CALL_STATUS, dirtyState = 0;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(activeRow);
zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(activeRow) != IS_NULL) {
RETURN_CCTOR(activeRow);
}
ZEPHIR_OBS_VAR(row);
zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_disableHydration"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
zephir_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC);
RETURN_CCTOR(row);
}
if (Z_TYPE_P(row) != IS_ARRAY) {
if (0) {
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_activeRow"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(hydrateMode);
zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_INIT_NVAR(activeRow);
object_init_ex(activeRow, phalcon_mvc_model_row_ce);
if (zephir_has_constructor(activeRow TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, activeRow, "__construct", NULL, 0);
zephir_check_call_status();
}
break;
}
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
ZEPHIR_INIT_NVAR(activeRow);
array_init(activeRow);
break;
}
ZEPHIR_INIT_NVAR(activeRow);
object_init(activeRow);
break;
} while(0);
dirtyState = 0;
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 246);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HMKEY(alias, _3, _2);
ZEPHIR_GET_HVALUE(column, _4);
if (Z_TYPE_P(column) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Column type is corrupt", "phalcon/mvc/model/resultset/complex.zep", 133);
return;
}
ZEPHIR_OBS_NVAR(type);
zephir_array_fetch_string(&type, column, SL("type"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 136 TSRMLS_CC);
if (ZEPHIR_IS_STRING(type, "object")) {
ZEPHIR_OBS_NVAR(source);
zephir_array_fetch_string(&source, column, SL("column"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 142 TSRMLS_CC);
ZEPHIR_OBS_NVAR(attributes);
zephir_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 143 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnMap);
zephir_array_fetch_string(&columnMap, column, SL("columnMap"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 144 TSRMLS_CC);
ZEPHIR_INIT_NVAR(rowModel);
array_init(rowModel);
zephir_is_iterable(attributes, &_6$$11, &_5$$11, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 162);
for (
; zephir_hash_get_current_data_ex(_6$$11, (void**) &_7$$11, &_5$$11) == SUCCESS
; zephir_hash_move_forward_ex(_6$$11, &_5$$11)
) {
ZEPHIR_GET_HVALUE(attribute, _7$$11);
ZEPHIR_OBS_NVAR(columnValue);
ZEPHIR_INIT_LNVAR(_8$$12);
ZEPHIR_CONCAT_SVSV(_8$$12, "_", source, "_", attribute);
zephir_array_fetch(&columnValue, row, _8$$12, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 155 TSRMLS_CC);
zephir_array_update_zval(&rowModel, attribute, &columnValue, PH_COPY | PH_SEPARATE);
}
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_OBS_NVAR(keepSnapshots);
if (!(zephir_array_isset_string_fetch(&keepSnapshots, column, SS("keepSnapshots"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(keepSnapshots);
ZVAL_BOOL(keepSnapshots, 0);
}
if (ZEPHIR_GLOBAL(orm).late_state_binding) {
ZEPHIR_OBS_NVAR(_9$$15);
zephir_array_fetch_string(&_9$$15, column, SL("instance"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 173 TSRMLS_CC);
if (zephir_instance_of_ev(_9$$15, phalcon_mvc_model_ce TSRMLS_CC)) {
zephir_array_fetch_string(&_10$$16, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 174 TSRMLS_CC);
ZEPHIR_INIT_NVAR(modelName);
zephir_get_class(modelName, _10$$16, 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(modelName);
ZVAL_STRING(modelName, "Phalcon\\Mvc\\Model", 1);
}
zephir_array_fetch_string(&_11$$15, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 180 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_12$$15);
ZVAL_LONG(_12$$15, dirtyState);
_13$$15 = zephir_fetch_class(modelName TSRMLS_CC);
ZEPHIR_CALL_CE_STATIC(&value, _13$$15, "cloneresultmap", NULL, 0, _11$$15, rowModel, columnMap, _12$$15, keepSnapshots);
zephir_check_call_status();
} else {
zephir_array_fetch_string(&_15$$18, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 188 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_16$$18);
ZVAL_LONG(_16$$18, dirtyState);
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", &_14, 0, _15$$18, rowModel, columnMap, _16$$18, keepSnapshots);
zephir_check_call_status();
}
break;
}
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_17, 0, rowModel, columnMap, hydrateMode);
zephir_check_call_status();
break;
} while(0);
ZEPHIR_OBS_NVAR(attribute);
zephir_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 202 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(sqlAlias);
if (zephir_array_isset_string_fetch(&sqlAlias, column, SS("sqlAlias"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, row, sqlAlias, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 210 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(value);
zephir_array_isset_fetch(&value, row, alias, 0 TSRMLS_CC);
}
if (zephir_array_isset_string(column, SS("balias"))) {
ZEPHIR_CPY_WRT(attribute, alias);
} else {
ZEPHIR_SINIT_NVAR(_18$$24);
ZVAL_STRING(&_18$$24, "_", 0);
ZEPHIR_SINIT_NVAR(_19$$24);
ZVAL_STRING(&_19$$24, "", 0);
ZEPHIR_INIT_NVAR(attribute);
zephir_fast_str_replace(&attribute, &_18$$24, &_19$$24, alias TSRMLS_CC);
}
}
if (!(zephir_array_isset_string_fetch(&eager, column, SS("eager"), 1 TSRMLS_CC))) {
do {
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
zephir_array_update_zval(&activeRow, attribute, &value, PH_COPY | PH_SEPARATE);
break;
}
zephir_update_property_zval_zval(activeRow, attribute, value TSRMLS_CC);
break;
} while(0);
}
}
zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}
/**
* Hendle the controller calling process.
*
* The steps is:
* - Does alias controller are defined in main config?
* - If not, is sub-controller exists?
* - If not, module with this name exists?
* - If all fault, then throw 404.
*
* @return void
*/
PHP_METHOD(Panada_Gear, controllerHandler) {
zend_class_entry *_8;
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL, *_12 = NULL, *_19 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *instance, *request = NULL, *method = NULL, *classFile, *controllerNamespace, *_0, *_1, *_2, *_4, *_5, *_6 = NULL, *_7 = NULL, *_9, *_10 = NULL, _11, *_13, *_14, *_15, *_16, *_17 = NULL, *_18;
ZEPHIR_MM_GROW();
_0 = zephir_fetch_nproperty_this(this_ptr, SL("firstUriPath"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(controllerNamespace);
ZEPHIR_CONCAT_SV(controllerNamespace, "Controllers\\", _0);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_GET_CONSTANT(_1, "APP");
_2 = zephir_fetch_nproperty_this(this_ptr, SL("firstUriPath"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(classFile);
ZEPHIR_CONCAT_VSVS(classFile, _1, "Controllers/", _2, ".php");
if (!((zephir_file_exists(classFile TSRMLS_CC) == SUCCESS))) {
ZEPHIR_CALL_METHOD(NULL, this_ptr, "subcontrollerhandler", &_3);
zephir_check_call_status();
RETURN_MM_NULL();
}
_4 = zephir_fetch_nproperty_this(this_ptr, SL("uriObj"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&method, _4, "getmethod", NULL);
zephir_check_call_status();
_5 = zephir_fetch_nproperty_this(this_ptr, SL("uriObj"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&request, _5, "getrequests", NULL);
zephir_check_call_status();
if (!(zephir_is_true(request))) {
ZEPHIR_INIT_VAR(request);
array_init(request);
}
if (!(zephir_class_exists(controllerNamespace, 1 TSRMLS_CC))) {
ZEPHIR_INIT_VAR(_6);
object_init_ex(_6, panada_resources_runexception_ce);
ZEPHIR_INIT_VAR(_7);
ZEPHIR_CONCAT_SVSV(_7, "Class ", controllerNamespace, " not found in ", classFile);
ZEPHIR_CALL_METHOD(NULL, _6, "__construct", NULL, _7);
zephir_check_call_status();
zephir_throw_exception(_6 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(instance);
_8 = zend_fetch_class(Z_STRVAL_P(controllerNamespace), Z_STRLEN_P(controllerNamespace), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
object_init_ex(instance, _8);
if (zephir_has_constructor(instance TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, instance, "__construct", NULL);
zephir_check_call_status();
}
if (!((zephir_method_exists(instance, method TSRMLS_CC) == SUCCESS))) {
_9 = zephir_fetch_nproperty_this(this_ptr, SL("uriObj"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_10, _9, "path", NULL);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, 1);
ZEPHIR_CALL_FUNCTION(&request, "array_slice", &_12, _10, &_11);
zephir_check_call_status();
_13 = zephir_fetch_nproperty_this(this_ptr, SL("config"), PH_NOISY_CC);
zephir_array_fetch_string(&_14, _13, SL("main"), PH_NOISY | PH_READONLY TSRMLS_CC);
zephir_array_fetch_string(&_15, _14, SL("alias"), PH_NOISY | PH_READONLY TSRMLS_CC);
ZEPHIR_OBS_VAR(method);
zephir_array_fetch_string(&method, _15, SL("method"), PH_NOISY TSRMLS_CC);
if (!((zephir_method_exists(instance, method TSRMLS_CC) == SUCCESS))) {
ZEPHIR_INIT_LNVAR(_6);
object_init_ex(_6, panada_resources_runexception_ce);
_16 = zephir_fetch_nproperty_this(this_ptr, SL("uriObj"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_17, _16, "getmethod", NULL);
zephir_check_call_status();
_18 = zephir_fetch_nproperty_this(this_ptr, SL("firstUriPath"), PH_NOISY_CC);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSV(_7, "Method ", _17, " does not exists in controller ", _18);
ZEPHIR_CALL_METHOD(NULL, _6, "__construct", NULL, _7);
zephir_check_call_status();
zephir_throw_exception(_6 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
}
ZEPHIR_CALL_METHOD(NULL, this_ptr, "run", &_19, instance, method, request);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
/**
* The meta-data is obtained by reading the column descriptions from the database information schema
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getMetaData) {
zend_bool _16$$9;
HashTable *_8;
HashPosition _7;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *model, *dependencyInjector, *schema = NULL, *table = NULL, *readConnection = NULL, *columns = NULL, *attributes = NULL, *primaryKeys = NULL, *nonPrimaryKeys = NULL, *completeTable = NULL, *numericTyped = NULL, *notNull = NULL, *fieldTypes = NULL, *automaticDefault = NULL, *identityField = NULL, *fieldBindTypes = NULL, *defaultValues = NULL, *column = NULL, *fieldName = NULL, *defaultValue = NULL, *emptyStringValues = NULL, *_0 = NULL, **_9, *_1$$3, *_2$$3, *_3$$3, *_4$$6, *_5$$6, *_6$$6, *_10$$9 = NULL, *_11$$9 = NULL, *_12$$9 = NULL, *_13$$9 = NULL, *_14$$9 = NULL, *_15$$9 = NULL, *_17$$9 = NULL, *_18$$15 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &model, &dependencyInjector);
ZEPHIR_CALL_METHOD(&schema, model, "getschema", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&table, model, "getsource", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&readConnection, model, "getreadconnection", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_0, readConnection, "tableexists", NULL, 0, table, schema);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
if (zephir_is_true(schema)) {
ZEPHIR_INIT_VAR(completeTable);
ZEPHIR_CONCAT_VSV(completeTable, schema, "'.'", table);
} else {
ZEPHIR_CPY_WRT(completeTable, table);
}
ZEPHIR_INIT_VAR(_1$$3);
object_init_ex(_1$$3, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_2$$3);
zephir_get_class(_2$$3, model, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_3$$3);
ZEPHIR_CONCAT_SVSV(_3$$3, "Table '", completeTable, "' doesn't exist in database when dumping meta-data for ", _2$$3);
ZEPHIR_CALL_METHOD(NULL, _1$$3, "__construct", NULL, 9, _3$$3);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$3, "phalcon/mvc/model/metadata/strategy/introspection.zep", 68 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_CALL_METHOD(&columns, readConnection, "describecolumns", NULL, 0, table, schema);
zephir_check_call_status();
if (!(zephir_fast_count_int(columns TSRMLS_CC))) {
if (zephir_is_true(schema)) {
ZEPHIR_INIT_NVAR(completeTable);
ZEPHIR_CONCAT_VSV(completeTable, schema, "'.'", table);
} else {
ZEPHIR_CPY_WRT(completeTable, table);
}
ZEPHIR_INIT_VAR(_4$$6);
object_init_ex(_4$$6, phalcon_mvc_model_exception_ce);
ZEPHIR_INIT_VAR(_5$$6);
zephir_get_class(_5$$6, model, 0 TSRMLS_CC);
ZEPHIR_INIT_VAR(_6$$6);
ZEPHIR_CONCAT_SVSV(_6$$6, "Cannot obtain table columns for the mapped source '", completeTable, "' used in model ", _5$$6);
ZEPHIR_CALL_METHOD(NULL, _4$$6, "__construct", NULL, 9, _6$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_4$$6, "phalcon/mvc/model/metadata/strategy/introspection.zep", 88 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_INIT_VAR(attributes);
array_init(attributes);
ZEPHIR_INIT_VAR(primaryKeys);
array_init(primaryKeys);
ZEPHIR_INIT_VAR(nonPrimaryKeys);
array_init(nonPrimaryKeys);
ZEPHIR_INIT_VAR(numericTyped);
array_init(numericTyped);
ZEPHIR_INIT_VAR(notNull);
array_init(notNull);
ZEPHIR_INIT_VAR(fieldTypes);
array_init(fieldTypes);
ZEPHIR_INIT_VAR(fieldBindTypes);
array_init(fieldBindTypes);
ZEPHIR_INIT_VAR(automaticDefault);
array_init(automaticDefault);
ZEPHIR_INIT_VAR(identityField);
ZVAL_BOOL(identityField, 0);
ZEPHIR_INIT_VAR(defaultValues);
array_init(defaultValues);
ZEPHIR_INIT_VAR(emptyStringValues);
array_init(emptyStringValues);
zephir_is_iterable(columns, &_8, &_7, 0, 0, "phalcon/mvc/model/metadata/strategy/introspection.zep", 165);
for (
; zend_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zend_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HVALUE(column, _9);
ZEPHIR_CALL_METHOD(&fieldName, column, "getname", NULL, 0);
zephir_check_call_status();
zephir_array_append(&attributes, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 109);
ZEPHIR_CALL_METHOD(&_10$$9, column, "isprimary", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_10$$9)) {
zephir_array_append(&primaryKeys, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 115);
} else {
zephir_array_append(&nonPrimaryKeys, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 117);
}
ZEPHIR_CALL_METHOD(&_11$$9, column, "isnumeric", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_11$$9)) {
zephir_array_update_zval(&numericTyped, fieldName, &ZEPHIR_GLOBAL(global_true), PH_COPY | PH_SEPARATE);
}
ZEPHIR_CALL_METHOD(&_12$$9, column, "isnotnull", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_12$$9)) {
zephir_array_append(¬Null, fieldName, PH_SEPARATE, "phalcon/mvc/model/metadata/strategy/introspection.zep", 131);
}
ZEPHIR_CALL_METHOD(&_13$$9, column, "isautoincrement", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_TRUE_IDENTICAL(_13$$9)) {
ZEPHIR_CPY_WRT(identityField, fieldName);
}
ZEPHIR_CALL_METHOD(&_14$$9, column, "gettype", NULL, 0);
zephir_check_call_status();
zephir_array_update_zval(&fieldTypes, fieldName, &_14$$9, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&_15$$9, column, "getbindtype", NULL, 0);
zephir_check_call_status();
zephir_array_update_zval(&fieldBindTypes, fieldName, &_15$$9, PH_COPY | PH_SEPARATE);
ZEPHIR_CALL_METHOD(&defaultValue, column, "getdefault", NULL, 0);
zephir_check_call_status();
_16$$9 = Z_TYPE_P(defaultValue) != IS_NULL;
if (!(_16$$9)) {
ZEPHIR_CALL_METHOD(&_17$$9, column, "isnotnull", NULL, 0);
zephir_check_call_status();
_16$$9 = ZEPHIR_IS_FALSE_IDENTICAL(_17$$9);
}
if (_16$$9) {
ZEPHIR_CALL_METHOD(&_18$$15, column, "isautoincrement", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(_18$$15))) {
zephir_array_update_zval(&defaultValues, fieldName, &defaultValue, PH_COPY | PH_SEPARATE);
}
}
}
zephir_create_array(return_value, 12, 0 TSRMLS_CC);
zephir_array_update_long(&return_value, 0, &attributes, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 1, &primaryKeys, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 2, &nonPrimaryKeys, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 3, ¬Null, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 4, &fieldTypes, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 5, &numericTyped, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 8, &identityField, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 9, &fieldBindTypes, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 10, &automaticDefault, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 11, &automaticDefault, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 12, &defaultValues, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
zephir_array_update_long(&return_value, 13, &emptyStringValues, PH_COPY ZEPHIR_DEBUG_PARAMS_DUMMY);
RETURN_MM();
}
/**
* Generates SQL to create a table
*/
PHP_METHOD(Phalcon_Db_Dialect_Sqlite, createTable) {
HashTable *_1, *_18$$14, *_31$$18;
HashPosition _0, _17$$14, _30$$18;
zend_bool hasPrimary = 0, _7$$7, _9$$7, _20$$15, _21$$15;
zephir_fcall_cache_entry *_5 = NULL, *_14 = NULL, *_25 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *definition = NULL;
zval *tableName_param = NULL, *schemaName_param = NULL, *definition_param = NULL, *columns = NULL, *table = NULL, *temporary = NULL, *options = NULL, *createLines = NULL, *columnLine = NULL, *column = NULL, *indexes = NULL, *index = NULL, *indexName = NULL, *indexType = NULL, *references = NULL, *reference = NULL, *defaultValue = NULL, *referenceSql = NULL, *onDelete = NULL, *onUpdate = NULL, *sql = NULL, **_2, *_41, *_42, *_3$$7 = NULL, *_4$$7 = NULL, *_6$$7 = NULL, *_8$$7 = NULL, *_10$$7 = NULL, *_16$$7 = NULL, *_11$$10 = NULL, _12$$12 = zval_used_for_init, *_13$$12 = NULL, *_15$$12 = NULL, **_19$$14, *_22$$15 = NULL, *_23$$16 = NULL, *_24$$16 = NULL, *_26$$16 = NULL, *_27$$17 = NULL, *_28$$17 = NULL, *_29$$17 = NULL, **_32$$18, *_33$$19 = NULL, *_34$$19 = NULL, *_35$$19 = NULL, *_36$$19 = NULL, *_37$$19 = NULL, *_38$$19 = NULL, *_39$$20 = NULL, *_40$$21 = NULL;
zval *tableName = NULL, *schemaName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 0, &tableName_param, &schemaName_param, &definition_param);
if (unlikely(Z_TYPE_P(tableName_param) != IS_STRING && Z_TYPE_P(tableName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'tableName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(tableName_param) == IS_STRING)) {
zephir_get_strval(tableName, tableName_param);
} else {
ZEPHIR_INIT_VAR(tableName);
ZVAL_EMPTY_STRING(tableName);
}
if (unlikely(Z_TYPE_P(schemaName_param) != IS_STRING && Z_TYPE_P(schemaName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'schemaName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(schemaName_param) == IS_STRING)) {
zephir_get_strval(schemaName, schemaName_param);
} else {
ZEPHIR_INIT_VAR(schemaName);
ZVAL_EMPTY_STRING(schemaName);
}
definition = definition_param;
ZEPHIR_CALL_METHOD(&table, this_ptr, "preparetable", NULL, 0, tableName, schemaName);
zephir_check_call_status();
ZEPHIR_INIT_VAR(temporary);
ZVAL_BOOL(temporary, 0);
ZEPHIR_OBS_VAR(options);
if (zephir_array_isset_string_fetch(&options, definition, SS("options"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_NVAR(temporary);
zephir_array_isset_string_fetch(&temporary, options, SS("temporary"), 0 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(columns);
if (!(zephir_array_isset_string_fetch(&columns, definition, SS("columns"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array", "phalcon/db/dialect/sqlite.zep", 322);
return;
}
ZEPHIR_INIT_VAR(sql);
if (zephir_is_true(temporary)) {
ZEPHIR_CONCAT_SVS(sql, "CREATE TEMPORARY TABLE ", table, " (\n\t");
} else {
ZEPHIR_CONCAT_SVS(sql, "CREATE TABLE ", table, " (\n\t");
}
hasPrimary = 0;
ZEPHIR_INIT_VAR(createLines);
array_init(createLines);
zephir_is_iterable(columns, &_1, &_0, 0, 0, "phalcon/db/dialect/sqlite.zep", 380);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(column, _2);
ZEPHIR_CALL_METHOD(&_3$$7, column, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_4$$7, this_ptr, "getcolumndefinition", &_5, 0, column);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(columnLine);
ZEPHIR_CONCAT_SVSV(columnLine, "`", _3$$7, "` ", _4$$7);
ZEPHIR_CALL_METHOD(&_6$$7, column, "isprimary", NULL, 0);
zephir_check_call_status();
_7$$7 = zephir_is_true(_6$$7);
if (_7$$7) {
_7$$7 = !hasPrimary;
}
if (_7$$7) {
zephir_concat_self_str(&columnLine, SL(" PRIMARY KEY") TSRMLS_CC);
hasPrimary = 1;
}
ZEPHIR_CALL_METHOD(&_8$$7, column, "isautoincrement", NULL, 0);
zephir_check_call_status();
_9$$7 = zephir_is_true(_8$$7);
if (_9$$7) {
_9$$7 = hasPrimary;
}
if (_9$$7) {
zephir_concat_self_str(&columnLine, SL(" AUTOINCREMENT") TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_10$$7, column, "hasdefault", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_10$$7)) {
ZEPHIR_CALL_METHOD(&defaultValue, column, "getdefault", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_11$$10);
zephir_fast_strtoupper(_11$$10, defaultValue);
if (zephir_memnstr_str(_11$$10, SL("CURRENT_TIMESTAMP"), "phalcon/db/dialect/sqlite.zep", 360)) {
zephir_concat_self_str(&columnLine, SL(" DEFAULT CURRENT_TIMESTAMP") TSRMLS_CC);
} else {
ZEPHIR_SINIT_NVAR(_12$$12);
ZVAL_STRING(&_12$$12, "\"", 0);
ZEPHIR_CALL_FUNCTION(&_13$$12, "addcslashes", &_14, 153, defaultValue, &_12$$12);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_15$$12);
ZEPHIR_CONCAT_SVS(_15$$12, " DEFAULT \"", _13$$12, "\"");
zephir_concat_self(&columnLine, _15$$12 TSRMLS_CC);
}
}
ZEPHIR_CALL_METHOD(&_16$$7, column, "isnotnull", NULL, 0);
zephir_check_call_status();
if (zephir_is_true(_16$$7)) {
zephir_concat_self_str(&columnLine, SL(" NOT NULL") TSRMLS_CC);
}
zephir_array_append(&createLines, columnLine, PH_SEPARATE, "phalcon/db/dialect/sqlite.zep", 374);
}
ZEPHIR_OBS_VAR(indexes);
if (zephir_array_isset_string_fetch(&indexes, definition, SS("indexes"), 0 TSRMLS_CC)) {
zephir_is_iterable(indexes, &_18$$14, &_17$$14, 0, 0, "phalcon/db/dialect/sqlite.zep", 396);
for (
; zephir_hash_get_current_data_ex(_18$$14, (void**) &_19$$14, &_17$$14) == SUCCESS
; zephir_hash_move_forward_ex(_18$$14, &_17$$14)
) {
ZEPHIR_GET_HVALUE(index, _19$$14);
ZEPHIR_CALL_METHOD(&indexName, index, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&indexType, index, "gettype", NULL, 0);
zephir_check_call_status();
_20$$15 = ZEPHIR_IS_STRING(indexName, "PRIMARY");
if (_20$$15) {
_20$$15 = !hasPrimary;
}
_21$$15 = !(ZEPHIR_IS_EMPTY(indexType));
if (_21$$15) {
ZEPHIR_INIT_NVAR(_22$$15);
zephir_fast_strtoupper(_22$$15, indexType);
_21$$15 = zephir_memnstr_str(_22$$15, SL("UNIQUE"), "phalcon/db/dialect/sqlite.zep", 392);
}
if (_20$$15) {
ZEPHIR_CALL_METHOD(&_24$$16, index, "getcolumns", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_23$$16, this_ptr, "getcolumnlist", &_25, 54, _24$$16);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_26$$16);
ZEPHIR_CONCAT_SVS(_26$$16, "PRIMARY KEY (", _23$$16, ")");
zephir_array_append(&createLines, _26$$16, PH_SEPARATE, "phalcon/db/dialect/sqlite.zep", 391);
} else if (_21$$15) {
ZEPHIR_CALL_METHOD(&_28$$17, index, "getcolumns", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_27$$17, this_ptr, "getcolumnlist", &_25, 54, _28$$17);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_29$$17);
ZEPHIR_CONCAT_SVS(_29$$17, "UNIQUE (", _27$$17, ")");
zephir_array_append(&createLines, _29$$17, PH_SEPARATE, "phalcon/db/dialect/sqlite.zep", 393);
}
}
}
ZEPHIR_OBS_VAR(references);
if (zephir_array_isset_string_fetch(&references, definition, SS("references"), 0 TSRMLS_CC)) {
zephir_is_iterable(references, &_31$$18, &_30$$18, 0, 0, "phalcon/db/dialect/sqlite.zep", 418);
for (
; zephir_hash_get_current_data_ex(_31$$18, (void**) &_32$$18, &_30$$18) == SUCCESS
; zephir_hash_move_forward_ex(_31$$18, &_30$$18)
) {
ZEPHIR_GET_HVALUE(reference, _32$$18);
ZEPHIR_CALL_METHOD(&_33$$19, reference, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_35$$19, reference, "getcolumns", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_34$$19, this_ptr, "getcolumnlist", &_25, 54, _35$$19);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_36$$19, reference, "getreferencedtable", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_38$$19, reference, "getreferencedcolumns", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_37$$19, this_ptr, "getcolumnlist", &_25, 54, _38$$19);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(referenceSql);
ZEPHIR_CONCAT_SVSVSSVSVS(referenceSql, "CONSTRAINT `", _33$$19, "` FOREIGN KEY (", _34$$19, ")", " REFERENCES `", _36$$19, "`(", _37$$19, ")");
ZEPHIR_CALL_METHOD(&onDelete, reference, "getondelete", NULL, 0);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(onDelete))) {
ZEPHIR_INIT_LNVAR(_39$$20);
ZEPHIR_CONCAT_SV(_39$$20, " ON DELETE ", onDelete);
zephir_concat_self(&referenceSql, _39$$20 TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&onUpdate, reference, "getonupdate", NULL, 0);
zephir_check_call_status();
if (!(ZEPHIR_IS_EMPTY(onUpdate))) {
ZEPHIR_INIT_LNVAR(_40$$21);
ZEPHIR_CONCAT_SV(_40$$21, " ON UPDATE ", onUpdate);
zephir_concat_self(&referenceSql, _40$$21 TSRMLS_CC);
}
zephir_array_append(&createLines, referenceSql, PH_SEPARATE, "phalcon/db/dialect/sqlite.zep", 416);
}
}
ZEPHIR_INIT_VAR(_41);
zephir_fast_join_str(_41, SL(",\n\t"), createLines TSRMLS_CC);
ZEPHIR_INIT_VAR(_42);
ZEPHIR_CONCAT_VS(_42, _41, "\n)");
zephir_concat_self(&sql, _42 TSRMLS_CC);
RETURN_CCTOR(sql);
}
/**
* Writes the log to the stream itself
*
* @link http://www.firephp.org/Wiki/Reference/Protocol
*/
PHP_METHOD(Phalcon_Logger_Adapter_Firephp, logInternal) {
HashTable *_10;
HashPosition _9;
zephir_fcall_cache_entry *_4 = NULL;
zval *context = NULL;
int type, time, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *time_param = NULL, *context_param = NULL, *chunk = NULL, *format = NULL, *chString = NULL, *content = NULL, *key = NULL, *_0, *_2, *_5 = NULL, *_6, *_7, _8, **_11, *_1$$3, _3$$4 = zval_used_for_init, *_12$$5 = NULL, *_13$$5, *_14$$5;
zval *message = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &message_param, &type_param, &time_param, &context_param);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
time = zephir_get_intval(time_param);
zephir_get_arrval(context, context_param);
_0 = zephir_fetch_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_index") TSRMLS_CC);
if (Z_TYPE_P(_0) == IS_NULL) {
ZEPHIR_INIT_ZVAL_NREF(_1$$3);
ZVAL_LONG(_1$$3, 1);
zephir_update_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_index"), &_1$$3 TSRMLS_CC);
}
_2 = zephir_fetch_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_initialized") TSRMLS_CC);
if (!ZEPHIR_IS_TRUE_IDENTICAL(_2)) {
ZEPHIR_SINIT_VAR(_3$$4);
ZVAL_STRING(&_3$$4, "X-Wf-Protocol-1: http://meta.wildfirehq.org/Protocol/JsonStream/0.2", 0);
ZEPHIR_CALL_FUNCTION(NULL, "header", &_4, 238, &_3$$4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_3$$4);
ZVAL_STRING(&_3$$4, "X-Wf-1-Plugin-1: http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.3", 0);
ZEPHIR_CALL_FUNCTION(NULL, "header", &_4, 238, &_3$$4);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_3$$4);
ZVAL_STRING(&_3$$4, "X-Wf-Structure-1: http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1", 0);
ZEPHIR_CALL_FUNCTION(NULL, "header", &_4, 238, &_3$$4);
zephir_check_call_status();
zephir_update_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_initialized"), &ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
}
ZEPHIR_CALL_METHOD(&_5, this_ptr, "getformatter", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_6);
ZVAL_LONG(_6, type);
ZEPHIR_INIT_VAR(_7);
ZVAL_LONG(_7, time);
ZEPHIR_CALL_METHOD(&format, _5, "format", NULL, 0, message, _6, _7, context);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_8);
ZVAL_LONG(&_8, 4500);
ZEPHIR_CALL_FUNCTION(&chunk, "str_split", NULL, 71, format, &_8);
zephir_check_call_status();
zephir_is_iterable(chunk, &_10, &_9, 0, 0, "phalcon/logger/adapter/firephp.zep", 96);
for (
; zephir_hash_get_current_data_ex(_10, (void**) &_11, &_9) == SUCCESS
; zephir_hash_move_forward_ex(_10, &_9)
) {
ZEPHIR_GET_HMKEY(key, _10, _9);
ZEPHIR_GET_HVALUE(chString, _11);
ZEPHIR_OBS_NVAR(_12$$5);
zephir_read_static_property_ce(&_12$$5, phalcon_logger_adapter_firephp_ce, SL("_index") TSRMLS_CC);
ZEPHIR_INIT_NVAR(content);
ZEPHIR_CONCAT_SVSV(content, "X-Wf-1-1-1-", _12$$5, ": ", chString);
if (zephir_array_isset_long(chunk, (zephir_get_numberval(key) + 1))) {
zephir_concat_self_str(&content, SL("|\\") TSRMLS_CC);
}
ZEPHIR_CALL_FUNCTION(NULL, "header", &_4, 238, content);
zephir_check_call_status();
_13$$5 = zephir_fetch_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_index") TSRMLS_CC);
ZEPHIR_INIT_ZVAL_NREF(_14$$5);
ZVAL_LONG(_14$$5, (zephir_get_numberval(_13$$5) + 1));
zephir_update_static_property_ce(phalcon_logger_adapter_firephp_ce, SL("_index"), &_14$$5 TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Writes the log to the stream itself
*/
PHP_METHOD(Phalcon_Logger_Adapter_Firephp, logInternal) {
HashTable *_8;
HashPosition _7;
zephir_fcall_cache_entry *_2 = NULL;
zval *context = NULL;
int type, time, ZEPHIR_LAST_CALL_STATUS;
zval *message_param = NULL, *type_param = NULL, *time_param = NULL, *context_param = NULL, *chunk = NULL, *format = NULL, *chString = NULL, *content = NULL, *key = NULL, *index = NULL, *_0, *_3 = NULL, *_4, *_5, _6, **_9, _1$$3 = zval_used_for_init;
zval *message = NULL, *_10$$4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &message_param, &type_param, &time_param, &context_param);
zephir_get_strval(message, message_param);
type = zephir_get_intval(type_param);
time = zephir_get_intval(time_param);
zephir_get_arrval(context, context_param);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY_CC);
if (!(zephir_is_true(_0))) {
ZEPHIR_SINIT_VAR(_1$$3);
ZVAL_STRING(&_1$$3, "X-Wf-Protocol-1: http://meta.wildfirehq.org/Protocol/JsonStream/0.2", 0);
ZEPHIR_CALL_FUNCTION(NULL, "header", &_2, 248, &_1$$3);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1$$3);
ZVAL_STRING(&_1$$3, "X-Wf-1-Plugin-1: http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.3", 0);
ZEPHIR_CALL_FUNCTION(NULL, "header", &_2, 248, &_1$$3);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_1$$3);
ZVAL_STRING(&_1$$3, "X-Wf-Structure-1: http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1", 0);
ZEPHIR_CALL_FUNCTION(NULL, "header", &_2, 248, &_1$$3);
zephir_check_call_status();
if (1) {
zephir_update_property_this(this_ptr, SL("_initialized"), ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_initialized"), ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
}
ZEPHIR_CALL_METHOD(&_3, this_ptr, "getformatter", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4);
ZVAL_LONG(_4, type);
ZEPHIR_INIT_VAR(_5);
ZVAL_LONG(_5, time);
ZEPHIR_CALL_METHOD(&format, _3, "format", NULL, 0, message, _4, _5, context);
zephir_check_call_status();
ZEPHIR_SINIT_VAR(_6);
ZVAL_LONG(&_6, 4500);
ZEPHIR_CALL_FUNCTION(&chunk, "str_split", NULL, 74, format, &_6);
zephir_check_call_status();
ZEPHIR_OBS_VAR(index);
zephir_read_property_this(&index, this_ptr, SL("_index"), PH_NOISY_CC);
zephir_is_iterable(chunk, &_8, &_7, 0, 0, "phalcon/logger/adapter/firephp.zep", 92);
for (
; zephir_hash_get_current_data_ex(_8, (void**) &_9, &_7) == SUCCESS
; zephir_hash_move_forward_ex(_8, &_7)
) {
ZEPHIR_GET_HMKEY(key, _8, _7);
ZEPHIR_GET_HVALUE(chString, _9);
zephir_get_strval(_10$$4, index);
ZEPHIR_INIT_NVAR(content);
ZEPHIR_CONCAT_SVSV(content, "X-Wf-1-1-1-", _10$$4, ": ", chString);
if (zephir_array_isset_long(chunk, (zephir_get_numberval(key) + 1))) {
zephir_concat_self_str(&content, SL("|\\") TSRMLS_CC);
}
ZEPHIR_CALL_FUNCTION(NULL, "header", &_2, 248, content);
zephir_check_call_status();
ZEPHIR_SEPARATE(index);
zephir_increment(index);
}
zephir_update_property_this(this_ptr, SL("_index"), index TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Returns current row in the resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, current) {
zephir_fcall_cache_entry *_8 = NULL, *_11 = NULL;
HashTable *_2, *_5;
HashPosition _1, _4;
int dirtyState, ZEPHIR_LAST_CALL_STATUS;
zval *row, *hydrateMode, *alias = NULL, *activeRow = NULL, *type = NULL, *columnTypes, *column = NULL, *columnValue = NULL, *value = NULL, *attribute = NULL, *source = NULL, *attributes = NULL, *columnMap = NULL, *rowModel = NULL, *keepSnapshots = NULL, *sqlAlias = NULL, *_0, **_3, **_6, *_7 = NULL, *_9, *_10 = NULL, _12 = zval_used_for_init, _13 = zval_used_for_init;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(activeRow);
zephir_read_property_this(&activeRow, this_ptr, SL("_activeRow"), PH_NOISY_CC);
if (Z_TYPE_P(activeRow) != IS_NULL) {
RETURN_CCTOR(activeRow);
}
ZEPHIR_OBS_VAR(row);
zephir_read_property_this(&row, this_ptr, SL("_row"), PH_NOISY_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_disableHydration"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
zephir_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC);
RETURN_CCTOR(row);
}
if (Z_TYPE_P(row) != IS_ARRAY) {
zephir_update_property_this(this_ptr, SL("_activeRow"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(hydrateMode);
zephir_read_property_this(&hydrateMode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_INIT_NVAR(activeRow);
object_init_ex(activeRow, phalcon_mvc_model_row_ce);
if (zephir_has_constructor(activeRow TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, activeRow, "__construct", NULL, 0);
zephir_check_call_status();
}
break;
}
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
ZEPHIR_INIT_NVAR(activeRow);
array_init(activeRow);
break;
}
ZEPHIR_INIT_NVAR(activeRow);
object_init(activeRow);
break;
} while(0);
ZEPHIR_OBS_VAR(columnTypes);
zephir_read_property_this(&columnTypes, this_ptr, SL("_columnTypes"), PH_NOISY_CC);
dirtyState = 0;
zephir_is_iterable(columnTypes, &_2, &_1, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 235);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HMKEY(alias, _2, _1);
ZEPHIR_GET_HVALUE(column, _3);
if (Z_TYPE_P(column) != IS_ARRAY) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "Column type is corrupt", "phalcon/mvc/model/resultset/complex.zep", 136);
return;
}
ZEPHIR_OBS_NVAR(type);
zephir_array_fetch_string(&type, column, SL("type"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 139 TSRMLS_CC);
if (ZEPHIR_IS_STRING(type, "object")) {
ZEPHIR_OBS_NVAR(source);
zephir_array_fetch_string(&source, column, SL("column"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 145 TSRMLS_CC);
ZEPHIR_OBS_NVAR(attributes);
zephir_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 146 TSRMLS_CC);
ZEPHIR_OBS_NVAR(columnMap);
zephir_array_fetch_string(&columnMap, column, SL("columnMap"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 147 TSRMLS_CC);
ZEPHIR_INIT_NVAR(rowModel);
array_init(rowModel);
zephir_is_iterable(attributes, &_5, &_4, 0, 0, "phalcon/mvc/model/resultset/complex.zep", 165);
for (
; zephir_hash_get_current_data_ex(_5, (void**) &_6, &_4) == SUCCESS
; zephir_hash_move_forward_ex(_5, &_4)
) {
ZEPHIR_GET_HVALUE(attribute, _6);
ZEPHIR_OBS_NVAR(columnValue);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSV(_7, "_", source, "_", attribute);
zephir_array_fetch(&columnValue, row, _7, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 158 TSRMLS_CC);
zephir_array_update_zval(&rowModel, attribute, &columnValue, PH_COPY | PH_SEPARATE);
}
do {
if (ZEPHIR_IS_LONG(hydrateMode, 0)) {
ZEPHIR_OBS_NVAR(keepSnapshots);
if (!(zephir_array_isset_string_fetch(&keepSnapshots, column, SS("keepSnapshots"), 0 TSRMLS_CC))) {
ZEPHIR_INIT_NVAR(keepSnapshots);
ZVAL_BOOL(keepSnapshots, 0);
}
zephir_array_fetch_string(&_9, column, SL("instance"), PH_NOISY | PH_READONLY, "phalcon/mvc/model/resultset/complex.zep", 180 TSRMLS_CC);
ZEPHIR_INIT_NVAR(_10);
ZVAL_LONG(_10, dirtyState);
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", &_8, 0, _9, rowModel, columnMap, _10, keepSnapshots);
zephir_check_call_status();
break;
}
ZEPHIR_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", &_11, 0, rowModel, columnMap, hydrateMode);
zephir_check_call_status();
break;
} while(0);
ZEPHIR_OBS_NVAR(attribute);
zephir_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 194 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(sqlAlias);
if (zephir_array_isset_string_fetch(&sqlAlias, column, SS("sqlAlias"), 0 TSRMLS_CC)) {
ZEPHIR_OBS_NVAR(value);
zephir_array_fetch(&value, row, sqlAlias, PH_NOISY, "phalcon/mvc/model/resultset/complex.zep", 202 TSRMLS_CC);
} else {
ZEPHIR_OBS_NVAR(value);
zephir_array_isset_fetch(&value, row, alias, 0 TSRMLS_CC);
}
if (zephir_array_isset_string(column, SS("balias"))) {
ZEPHIR_CPY_WRT(attribute, alias);
} else {
ZEPHIR_SINIT_NVAR(_12);
ZVAL_STRING(&_12, "_", 0);
ZEPHIR_SINIT_NVAR(_13);
ZVAL_STRING(&_13, "", 0);
ZEPHIR_INIT_NVAR(attribute);
zephir_fast_str_replace(&attribute, &_12, &_13, alias TSRMLS_CC);
}
}
do {
if (ZEPHIR_IS_LONG(hydrateMode, 1)) {
zephir_array_update_zval(&activeRow, attribute, &value, PH_COPY | PH_SEPARATE);
break;
}
zephir_update_property_zval_zval(activeRow, attribute, value TSRMLS_CC);
break;
} while(0);
}
zephir_update_property_this(this_ptr, SL("_activeRow"), activeRow TSRMLS_CC);
RETURN_CCTOR(activeRow);
}
/**
* Update row(s) of table and returns the number of updated rows
*/
PHP_METHOD(Lynx_DBAL_Connection, update) {
zephir_nts_static zephir_fcall_cache_entry *_12 = NULL, *_15 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_3;
HashPosition _2;
zval *data = NULL, *identifiers = NULL, *types = NULL;
zval *table_param = NULL, *data_param = NULL, *identifiers_param = NULL, *types_param = NULL, *set, *stmt = NULL, *columnName = NULL, *_0 = NULL, *_1, **_4, *_5, *_6 = NULL, *_7 = NULL, *_8, *cnt, *_9, *_10 = NULL, *_11 = NULL, *_13, *_14;
zval *table = NULL, *query = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 3, 1, &table_param, &data_param, &identifiers_param, &types_param);
if (unlikely(Z_TYPE_P(table_param) != IS_STRING && Z_TYPE_P(table_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'table' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(table_param) == IS_STRING)) {
zephir_get_strval(table, table_param);
} else {
ZEPHIR_INIT_VAR(table);
ZVAL_EMPTY_STRING(table);
}
data = data_param;
identifiers = identifiers_param;
if (!types_param) {
ZEPHIR_INIT_VAR(types);
array_init(types);
} else {
types = types_param;
}
ZEPHIR_INIT_VAR(set);
array_init(set);
ZEPHIR_INIT_VAR(_1);
zephir_array_keys(_1, data TSRMLS_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 0, "lynx/DBAL/Connection.zep", 88);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_forward_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(columnName, _4);
_5 = zephir_fetch_nproperty_this(this_ptr, SL("platform"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_6, _5, "wrap", NULL, columnName);
zephir_check_call_status();
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_VS(_7, _6, " = ?");
zephir_array_append(&set, _7, PH_SEPARATE, "lynx/DBAL/Connection.zep", 85);
}
_5 = zephir_fetch_nproperty_this(this_ptr, SL("platform"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_6, _5, "wrap", NULL, table);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_8);
zephir_fast_join_str(_8, SL(", "), set TSRMLS_CC);
ZEPHIR_INIT_LNVAR(_7);
ZEPHIR_CONCAT_SVSV(_7, "UPDATE ", _6, " SET ", _8);
zephir_get_strval(query, _7);
ZEPHIR_INIT_VAR(cnt);
ZVAL_LONG(cnt, zephir_fast_count_int(identifiers TSRMLS_CC));
if (ZEPHIR_GT_LONG(cnt, 0)) {
zephir_concat_self_str(&query, " WHERE ", sizeof(" WHERE ")-1 TSRMLS_CC);
if (ZEPHIR_IS_LONG(cnt, 1)) {
_9 = zephir_fetch_nproperty_this(this_ptr, SL("platform"), PH_NOISY_CC);
Z_SET_ISREF_P(identifiers);
ZEPHIR_CALL_FUNCTION(&_11, "key", &_12, identifiers);
Z_UNSET_ISREF_P(identifiers);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_10, _9, "wrap", NULL, _11);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_13);
ZEPHIR_CONCAT_VS(_13, _10, " = ?");
zephir_concat_self(&query, _13 TSRMLS_CC);
} else {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(TSRMLS_C), "It's not implemented", "lynx/DBAL/Connection.zep", 99);
return;
}
}
_5 = zephir_fetch_nproperty_this(this_ptr, SL("driver"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&stmt, _5, "prepare", NULL, query);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_14);
ZEPHIR_CALL_FUNCTION(&_6, "array_values", &_15, data);
zephir_check_call_status();
ZEPHIR_CALL_FUNCTION(&_10, "array_values", &_15, identifiers);
zephir_check_call_status();
zephir_fast_array_merge(_14, &(_6), &(_10) TSRMLS_CC);
ZEPHIR_RETURN_CALL_METHOD(stmt, "execute", NULL, _14);
zephir_check_call_status();
RETURN_MM();
}
/**
* Create internal connection to redis
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, _connect) {
zend_bool _0, _1, _2, _5, _7;
zval *options = NULL, *redis = NULL, *persistent = NULL, *success = NULL, *host = NULL, *port = NULL, *auth = NULL, *index = NULL, *timeout = NULL, *_6, *_3$$6, *_4$$6;
zend_long ZEPHIR_LAST_CALL_STATUS;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(redis);
object_init_ex(redis, zephir_get_internal_ce(SS("redis") TSRMLS_CC));
if (zephir_has_constructor(redis TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, redis, "__construct", NULL, 0);
zephir_check_call_status();
}
ZEPHIR_OBS_VAR(host);
_0 = !(zephir_array_isset_string_fetch(&host, options, SS("host"), 0 TSRMLS_CC));
if (!(_0)) {
ZEPHIR_OBS_VAR(port);
_0 = !(zephir_array_isset_string_fetch(&port, options, SS("port"), 0 TSRMLS_CC));
}
_1 = _0;
if (!(_1)) {
ZEPHIR_OBS_VAR(persistent);
_1 = !(zephir_array_isset_string_fetch(&persistent, options, SS("persistent"), 0 TSRMLS_CC));
}
_2 = _1;
if (!(_2)) {
ZEPHIR_OBS_VAR(timeout);
_2 = !(zephir_array_isset_string_fetch(&timeout, options, SS("timeout"), 0 TSRMLS_CC));
}
if (_2) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 120);
return;
}
if (zephir_is_true(persistent)) {
ZEPHIR_CALL_METHOD(&success, redis, "pconnect", NULL, 0, host, port, timeout);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&success, redis, "connect", NULL, 0, host, port, timeout);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_INIT_VAR(_3$$6);
object_init_ex(_3$$6, phalcon_cache_exception_ce);
ZEPHIR_INIT_VAR(_4$$6);
ZEPHIR_CONCAT_SVSV(_4$$6, "Could not connect to the Redisd server ", host, ":", port);
ZEPHIR_CALL_METHOD(NULL, _3$$6, "__construct", NULL, 9, _4$$6);
zephir_check_call_status();
zephir_throw_exception_debug(_3$$6, "phalcon/cache/backend/redis.zep", 130 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(auth);
_5 = zephir_array_isset_string_fetch(&auth, options, SS("auth"), 0 TSRMLS_CC);
if (_5) {
zephir_array_fetch_string(&_6, options, SL("auth"), PH_NOISY | PH_READONLY, "phalcon/cache/backend/redis.zep", 133 TSRMLS_CC);
_5 = !(ZEPHIR_IS_EMPTY(_6));
}
if (_5) {
ZEPHIR_CALL_METHOD(&success, redis, "auth", NULL, 0, auth);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed to authenticate with the Redisd server", "phalcon/cache/backend/redis.zep", 137);
return;
}
}
ZEPHIR_OBS_VAR(index);
_7 = zephir_array_isset_string_fetch(&index, options, SS("index"), 0 TSRMLS_CC);
if (_7) {
_7 = ZEPHIR_GT_LONG(index, 0);
}
if (_7) {
ZEPHIR_CALL_METHOD(&success, redis, "select", NULL, 0, index);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Redis server selected database failed", "phalcon/cache/backend/redis.zep", 145);
return;
}
}
zephir_update_property_this(getThis(), SL("_redis"), redis TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Create internal connection to redis
*/
PHP_METHOD(Phalcon_Cache_Backend_Redis, _connect) {
zend_bool _0, _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *options, *redis, *persistent, *success = NULL, *host, *port, *auth, *index, *_2, *_3;
ZEPHIR_MM_GROW();
ZEPHIR_OBS_VAR(options);
zephir_read_property_this(&options, this_ptr, SL("_options"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(redis);
object_init_ex(redis, zephir_get_internal_ce(SS("redis") TSRMLS_CC));
ZEPHIR_CALL_METHOD(NULL, redis, "__construct", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(host);
_0 = !(zephir_array_isset_string_fetch(&host, options, SS("host"), 0 TSRMLS_CC));
if (!(_0)) {
ZEPHIR_OBS_VAR(port);
_0 = !(zephir_array_isset_string_fetch(&port, options, SS("port"), 0 TSRMLS_CC));
}
_1 = _0;
if (!(_1)) {
ZEPHIR_OBS_VAR(persistent);
_1 = !(zephir_array_isset_string_fetch(&persistent, options, SS("persistent"), 0 TSRMLS_CC));
}
if (_1) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options", "phalcon/cache/backend/redis.zep", 108);
return;
}
if (zephir_is_true(persistent)) {
ZEPHIR_CALL_METHOD(&success, redis, "pconnect", NULL, 0, host, port);
zephir_check_call_status();
} else {
ZEPHIR_CALL_METHOD(&success, redis, "connect", NULL, 0, host, port);
zephir_check_call_status();
}
if (!(zephir_is_true(success))) {
ZEPHIR_INIT_VAR(_2);
object_init_ex(_2, phalcon_cache_exception_ce);
ZEPHIR_INIT_VAR(_3);
ZEPHIR_CONCAT_SVSV(_3, "Could not connect to the Redisd server ", host, ":", port);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 9, _3);
zephir_check_call_status();
zephir_throw_exception_debug(_2, "phalcon/cache/backend/redis.zep", 118 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(auth);
if (zephir_array_isset_string_fetch(&auth, options, SS("auth"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&success, redis, "auth", NULL, 0, auth);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Failed to authenticate with the Redisd server", "phalcon/cache/backend/redis.zep", 125);
return;
}
}
ZEPHIR_OBS_VAR(index);
if (zephir_array_isset_string_fetch(&index, options, SS("index"), 0 TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(&success, redis, "select", NULL, 0, index);
zephir_check_call_status();
if (!(zephir_is_true(success))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cache_exception_ce, "Redisd server selected database failed", "phalcon/cache/backend/redis.zep", 133);
return;
}
}
zephir_update_property_this(this_ptr, SL("_redis"), redis TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
