/** * Stores cached content into the file backend and stops the frontend * * @param int|string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_File, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *last_key = NULL, *prefix, *filtered, *front_end; zval *backend, *cache_dir, *cache_file, *cached_content = NULL; zval *prepared_content, *is_buffering; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!key_name) { PHALCON_INIT_NVAR(key_name); } if (!content) { PHALCON_INIT_NVAR(content); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } if (!stop_buffer) { PHALCON_INIT_NVAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (Z_TYPE_P(key_name) == IS_NULL) { PHALCON_INIT_VAR(last_key); phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_NVAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, filtered); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } PHALCON_INIT_VAR(front_end); phalcon_read_property(&front_end, this_ptr, SL("_frontendObject"), PH_NOISY_CC); PHALCON_INIT_VAR(backend); phalcon_read_property(&backend, this_ptr, SL("_backendOptions"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, backend, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, last_key); if (!zend_is_true(content)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_METHOD(cached_content, front_end, "getcontent", PH_NO_CHECK); } else { PHALCON_CPY_WRT(cached_content, content); } PHALCON_INIT_VAR(prepared_content); PHALCON_CALL_METHOD_PARAMS_1(prepared_content, front_end, "beforestore", cached_content, PH_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content); PHALCON_INIT_VAR(is_buffering); PHALCON_CALL_METHOD(is_buffering, front_end, "isbuffering", PH_NO_CHECK); if (PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD_NORETURN(front_end, "stop", PH_NO_CHECK); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 1); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Read the model's column map, this can't be infered * * @param Phalcon\Mvc\ModelInterface $model * @param Phalcon\DiInterface $dependencyInjector * @return array */ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getColumnMaps){ zval *model, *dependency_injector; zval *ordered_column_map = NULL, *columns = NULL, *column_name = NULL, *reversed_column_map = NULL; zval *user_name = NULL, *name = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &model, &dependency_injector); if (!PHALCON_GLOBAL(orm).column_renaming) { RETURN_MM_NULL(); } /** * Check for a columnMap() method on the model */ if (phalcon_method_exists_ex(model, SS("columnmap") TSRMLS_CC) == SUCCESS) { PHALCON_CALL_METHOD(&ordered_column_map, model, "columnmap"); if (Z_TYPE_P(ordered_column_map) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "columnMap() not returned an array"); return; } PHALCON_CALL_METHOD(&columns, model, "getcolumns"); if (Z_TYPE_P(columns) == IS_ARRAY) { phalcon_is_iterable(columns, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(column_name); if (!phalcon_array_isset(ordered_column_map, column_name)) { phalcon_array_update_zval(&ordered_column_map, column_name, column_name, PH_COPY); } zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_INIT_VAR(reversed_column_map); array_init(reversed_column_map); phalcon_is_iterable(ordered_column_map, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HKEY(name, ah1, hp1); PHALCON_GET_HVALUE(user_name); phalcon_array_update_zval(&reversed_column_map, user_name, name, PH_COPY); zend_hash_move_forward_ex(ah1, &hp1); } } else { PHALCON_INIT_NVAR(ordered_column_map); PHALCON_INIT_VAR(reversed_column_map); } /** * Store the column map */ array_init_size(return_value, 2); phalcon_array_update_long(&return_value, 0, ordered_column_map, PH_COPY); phalcon_array_update_long(&return_value, 1, reversed_column_map, PH_COPY); PHALCON_MM_RESTORE(); }
/** * Sets a cookie to be sent at the end of the request * This method overrides any cookie set before with the same name * * @param string $name * @param mixed $value * @param int $expire * @param string $path * @param boolean $secure * @param string $domain * @param boolean $httpOnly * @return Phalcon\Http\Response\Cookies */ PHP_METHOD(Phalcon_Http_Response_Cookies, set){ zval *name, *value = NULL, *expire = NULL, *path = NULL, *secure = NULL, *domain = NULL; zval *http_only = NULL, *cookies, *encryption, *dependency_injector = NULL; zval *cookie = NULL, *registered, *service, *response = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 6, &name, &value, &expire, &path, &secure, &domain, &http_only); if (Z_TYPE_P(name) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_http_cookie_exception_ce, "The cookie name must be string"); return; } if (!value) { value = PHALCON_GLOBAL(z_null); } if (!expire) { PHALCON_OBS_VAR(expire); phalcon_read_property_this(&expire, this_ptr, SL("_expire"), PH_NOISY TSRMLS_CC); } if (!path) { PHALCON_OBS_VAR(path); phalcon_read_property_this(&path, this_ptr, SL("_path"), PH_NOISY TSRMLS_CC); } if (!secure) { PHALCON_OBS_VAR(secure); phalcon_read_property_this(&secure, this_ptr, SL("_secure"), PH_NOISY TSRMLS_CC); } if (!domain) { PHALCON_OBS_VAR(domain); phalcon_read_property_this(&domain, this_ptr, SL("_domain"), PH_NOISY TSRMLS_CC); } if (!http_only) { PHALCON_OBS_VAR(http_only); phalcon_read_property_this(&http_only, this_ptr, SL("_httpOnly"), PH_NOISY TSRMLS_CC); } PHALCON_OBS_VAR(cookies); phalcon_read_property_this(&cookies, this_ptr, SL("_cookies"), PH_NOISY TSRMLS_CC); PHALCON_OBS_VAR(encryption); phalcon_read_property_this(&encryption, this_ptr, SL("_useEncryption"), PH_NOISY TSRMLS_CC); PHALCON_CALL_METHOD(&dependency_injector, this_ptr, "getdi"); /** * Check if the cookie needs to be updated or */ if (!phalcon_array_isset(cookies, name)) { PHALCON_INIT_VAR(cookie); object_init_ex(cookie, phalcon_http_cookie_ce); PHALCON_CALL_METHOD(NULL, cookie, "__construct", name, value, expire, path, secure, domain, http_only); /** * Pass the DI to created cookies */ PHALCON_CALL_METHOD(NULL, cookie, "setdi", dependency_injector); /** * Enable encryption in the cookie */ if (zend_is_true(encryption)) { PHALCON_CALL_METHOD(NULL, cookie, "useencryption", encryption); } phalcon_update_property_array(this_ptr, SL("_cookies"), name, cookie TSRMLS_CC); } else { PHALCON_OBS_NVAR(cookie); phalcon_array_fetch(&cookie, cookies, name, PH_NOISY); /** * Override any settings in the cookie */ PHALCON_CALL_METHOD(NULL, cookie, "setvalue", value); PHALCON_CALL_METHOD(NULL, cookie, "setexpiration", expire); PHALCON_CALL_METHOD(NULL, cookie, "setpath", path); PHALCON_CALL_METHOD(NULL, cookie, "setsecure", secure); PHALCON_CALL_METHOD(NULL, cookie, "setdomain", domain); PHALCON_CALL_METHOD(NULL, cookie, "sethttponly", http_only); } /** * Register the cookies bag in the response */ PHALCON_OBS_VAR(registered); phalcon_read_property_this(®istered, this_ptr, SL("_registered"), PH_NOISY TSRMLS_CC); if (PHALCON_IS_FALSE(registered)) { PHALCON_INIT_VAR(service); PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_response); PHALCON_CALL_METHOD(&response, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(response, phalcon_http_responseinterface_ce); /** * Pass the cookies bag to the response so it can send the headers at the of the * request */ PHALCON_CALL_METHOD(NULL, response, "setcookies", this_ptr); } RETURN_THIS(); }
/** * Handles a MVC request * * @param string $uri * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Mvc_JsonRpc, handle){ zval *uri = NULL, *dependency_injector, *events_manager; zval *status = NULL, *service = NULL, *request = NULL, *response = NULL; zval *json = NULL, *data = NULL, *jsonrpc_message, *jsonrpc_error, *jsonrpc_result = NULL; zval *jsonrpc_method, *jsonrpc_params, *jsonrpc_id; zval *url = NULL, *router = NULL, *module_name = NULL; zval *module_object = NULL, *modules; zval *module, *class_name = NULL, *module_params; zval *namespace_name = NULL; zval *controller_name = NULL, *action_name = NULL, *params = NULL, *exact = NULL; zval *dispatcher = NULL, *controller = NULL, *returned_response = NULL; zval *path; PHALCON_MM_GROW(); dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "A dependency injection object is required to access internal services"); return; } events_manager = phalcon_read_property(getThis(), SL("_eventsManager"), PH_NOISY); if (Z_TYPE_P(events_manager) != IS_OBJECT) { events_manager = NULL; } else { PHALCON_VERIFY_INTERFACE_EX(events_manager, phalcon_events_managerinterface_ce, phalcon_mvc_jsonrpc_exception_ce, 1); } /* Call boot event, this allows the developer to perform initialization actions */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:boot", getThis(), NULL)) { RETURN_MM_FALSE; } /* Deserializer Json */ PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(request)); PHALCON_CALL_METHOD(&request, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(request, phalcon_http_requestinterface_ce); PHALCON_CALL_METHOD(&json, request, "getrawbody"); PHALCON_CALL_FUNCTION(&data, "json_decode", json, &PHALCON_GLOBAL(z_true)); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(response)); PHALCON_CALL_METHOD(&response, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(response, phalcon_http_responseinterface_ce); PHALCON_INIT_VAR(jsonrpc_message); array_init(jsonrpc_message); PHALCON_INIT_VAR(jsonrpc_error); array_init(jsonrpc_error); if (PHALCON_IS_EMPTY(data)) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY); } else if (Z_TYPE_P(data) != IS_ARRAY) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY); } else if (!phalcon_array_isset_str(data, SL("jsonrpc"))) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY); } else if (!phalcon_array_isset_str(data, SL("method"))) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY); } else { PHALCON_OBS_VAR(jsonrpc_method); phalcon_array_fetch_str(&jsonrpc_method, data, SL("method"), PH_NOISY); if (phalcon_array_isset_str(data, SL("params"))) { PHALCON_OBS_VAR(jsonrpc_params); phalcon_array_fetch_str(&jsonrpc_params, data, SL("params"), PH_NOISY); } else { PHALCON_INIT_VAR(jsonrpc_params); array_init(jsonrpc_params); } PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(url)); PHALCON_CALL_METHOD(&url, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(url, phalcon_mvc_urlinterface_ce); PHALCON_CALL_METHOD(&uri, url, "get", jsonrpc_method); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(router)); PHALCON_CALL_METHOD(&router, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(router, phalcon_mvc_routerinterface_ce); /* Handle the URI pattern (if any) */ PHALCON_CALL_METHOD(NULL, router, "handle", uri); /* Load module config */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); /* Load module config */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); /* If the router doesn't return a valid module we use the default module */ if (!zend_is_true(module_name)) { module_name = phalcon_read_property(getThis(), SL("_defaultModule"), PH_NOISY); } /** * Process the module definition */ if (zend_is_true(module_name)) { if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeStartModule", getThis(), module_name)) { RETURN_MM_FALSE; } /** * Check if the module passed by the router is registered in the modules container */ modules = phalcon_read_property(getThis(), SL("_modules"), PH_NOISY); if (!phalcon_array_isset_fetch(&module, modules, module_name)) { convert_to_string(module_name); zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module %s is not registered in the jsonrpc container", Z_STRVAL_P(module_name)); RETURN_MM(); } /** * A module definition must be an array or an object */ if (Z_TYPE_P(module) != IS_ARRAY && Z_TYPE_P(module) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition"); return; } /* An array module definition contains a path to a module definition class */ if (Z_TYPE_P(module) == IS_ARRAY) { /* Class name used to load the module definition */ if (phalcon_array_isset_str(module, SL("className"))) { PHALCON_OBS_VAR(class_name); phalcon_array_fetch_str(&class_name, module, SL("className"), PH_NOISY); } else { PHALCON_INIT_NVAR(class_name); ZVAL_STRING(class_name, "Module"); } /* If the developer has specified a path, try to include the file */ if (phalcon_array_isset_str(module, SL("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_str(&path, module, SL("path"), PH_NOISY); convert_to_string_ex(path); if (Z_TYPE_P(class_name) != IS_STRING || phalcon_class_exists(class_name, 0) == NULL) { if (phalcon_file_exists(path) == SUCCESS) { RETURN_MM_ON_FAILURE(phalcon_require(Z_STRVAL_P(path))); } else { zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module definition path '%s' does not exist", Z_STRVAL_P(path)); RETURN_MM(); } } } PHALCON_CALL_METHOD(&module_object, dependency_injector, "get", class_name); /** * 'registerAutoloaders' and 'registerServices' are automatically called */ PHALCON_CALL_METHOD(NULL, module_object, "registerautoloaders", dependency_injector); PHALCON_CALL_METHOD(NULL, module_object, "registerservices", dependency_injector); } else if (Z_TYPE_P(module) == IS_OBJECT && instanceof_function(Z_OBJCE_P(module), zend_ce_closure)) { /* A module definition object, can be a Closure instance */ PHALCON_INIT_VAR(module_params); array_init_size(module_params, 1); phalcon_array_append(module_params, dependency_injector, PH_COPY); PHALCON_CALL_USER_FUNC_ARRAY(&status, module, module_params); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition"); return; } /* Calling afterStartModule event */ if (events_manager) { if (!module_object) { module_object = &PHALCON_GLOBAL(z_null); } phalcon_update_property_this(getThis(), SL("_moduleObject"), module_object); if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterStartModule", getThis(), module_name)) { RETURN_MM_FALSE; } } } /* We get the parameters from the router and assign them to the dispatcher */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); PHALCON_CALL_METHOD(&namespace_name, router, "getnamespacename"); PHALCON_CALL_METHOD(&controller_name, router, "getcontrollername"); PHALCON_CALL_METHOD(&action_name, router, "getactionname"); PHALCON_CALL_METHOD(¶ms, router, "getparams"); PHALCON_CALL_METHOD(&exact, router, "isexactcontrollername"); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(dispatcher)); PHALCON_CALL_METHOD(&dispatcher, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(dispatcher, phalcon_dispatcherinterface_ce); /* Assign the values passed from the router */ PHALCON_CALL_METHOD(NULL, dispatcher, "setmodulename", module_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setnamespacename", namespace_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setcontrollername", controller_name, exact); PHALCON_CALL_METHOD(NULL, dispatcher, "setactionname", action_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setparams", jsonrpc_params); /* Calling beforeHandleRequest */ RETURN_MM_ON_FAILURE(phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeHandleRequest", getThis(), dispatcher)); /* The dispatcher must return an object */ PHALCON_CALL_METHOD(&controller, dispatcher, "dispatch"); PHALCON_INIT_VAR(returned_response); /* Get the latest value returned by an action */ PHALCON_CALL_METHOD(&jsonrpc_result, dispatcher, "getreturnedvalue"); } /* Calling afterHandleRequest */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterHandleRequest", getThis(), controller) && EG(exception)) { RETURN_MM(); } phalcon_array_update_str_str(jsonrpc_message, SL("jsonrpc"), SL("2.0"), PH_COPY); if (PHALCON_IS_NOT_EMPTY(jsonrpc_error)) { phalcon_array_update_str(jsonrpc_message, SL("error"), jsonrpc_error, PH_COPY); } if (jsonrpc_result != NULL) { phalcon_array_update_str(jsonrpc_message, SL("result"), jsonrpc_result, PH_COPY); } if (phalcon_array_isset_str_fetch(&jsonrpc_id, data, SL("id"))) { phalcon_array_update_str(jsonrpc_message, SL("id"), jsonrpc_id, PH_COPY); } else { phalcon_array_update_str(jsonrpc_message, SL("id"), &PHALCON_GLOBAL(z_null), PH_COPY); } PHALCON_CALL_METHOD(NULL, response, "setjsoncontent", jsonrpc_message); /* Calling beforeSendResponse */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeSendResponse", getThis(), response) && EG(exception)) { RETURN_MM(); } /* Headers are automatically sent */ PHALCON_CALL_METHOD(NULL, response, "sendheaders"); /* Cookies are automatically sent */ PHALCON_CALL_METHOD(NULL, response, "sendcookies"); /* Return the response */ RETURN_CCTOR(response); }
/** * Stores cached content into the APC backend and stops the frontend * * @param string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Apc, save) { zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *last_key = NULL, *prefix, *frontend, *cached_content = NULL; zval *prepared_content, *ttl = NULL, *is_buffering; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) { RETURN_MM_NULL(); } if (!key_name) { PHALCON_INIT_VAR(key_name); } if (!content) { PHALCON_INIT_VAR(content); } if (!lifetime) { PHALCON_INIT_VAR(lifetime); } if (!stop_buffer) { PHALCON_INIT_VAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (Z_TYPE_P(key_name) == IS_NULL) { PHALCON_OBS_VAR(last_key); phalcon_read_property_this(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { PHALCON_OBS_VAR(prefix); phalcon_read_property_this(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_NVAR(last_key); PHALCON_CONCAT_SVV(last_key, "_PHCA", prefix, key_name); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } PHALCON_OBS_VAR(frontend); phalcon_read_property_this(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); if (Z_TYPE_P(content) == IS_NULL) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_METHOD(cached_content, frontend, "getcontent"); } else { PHALCON_CPY_WRT(cached_content, content); } PHALCON_INIT_VAR(prepared_content); PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content); if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_INIT_VAR(ttl); PHALCON_CALL_METHOD(ttl, frontend, "getlifetime"); } else { PHALCON_CPY_WRT(ttl, lifetime); } PHALCON_CALL_FUNC_PARAMS_3_NORETURN("apc_store", last_key, prepared_content, ttl); PHALCON_INIT_VAR(is_buffering); PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering"); if (PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD_NORETURN(frontend, "stop"); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Moves internal resulset cursor to another position letting us to fetch a certain row * *<code> * $result = $connection->query("SELECT * FROM robots ORDER BY name"); * $result->dataSeek(2); // Move to third row on result * $row = $result->fetch(); // Fetch third row *</code> * * @param int $number */ PHP_METHOD(Phalcon_Db_Result_Pdo, dataSeek){ long number = 0, n; zval *connection, *pdo = NULL, *sql_statement; zval *bind_params, *bind_types, *statement = NULL; zval *temp_statement = NULL; pdo_stmt_t *stmt; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &number) == FAILURE) { RETURN_MM_NULL(); } connection = phalcon_read_property(getThis(), SL("_connection"), PH_NOISY); PHALCON_CALL_METHOD(&pdo, connection, "getinternalhandler"); sql_statement = phalcon_read_property(getThis(), SL("_sqlStatement"), PH_NOISY); bind_params = phalcon_read_property(getThis(), SL("_bindParams"), PH_NOISY); /** * PDO doesn't support scrollable cursors, so we need to re-execute the statement again */ if (Z_TYPE_P(bind_params) == IS_ARRAY) { bind_types = phalcon_read_property(getThis(), SL("_bindTypes"), PH_NOISY); PHALCON_CALL_METHOD(&statement, pdo, "prepare", sql_statement); if (Z_TYPE_P(statement) == IS_OBJECT) { PHALCON_CALL_METHOD(&temp_statement, connection, "executeprepared", statement, bind_params, bind_types); PHALCON_CPY_WRT(statement, temp_statement); } } else { PHALCON_CALL_METHOD(&statement, pdo, "query", sql_statement); } phalcon_update_property_zval(getThis(), SL("_pdoStatement"), statement); /** * This a fetch scroll to reach the desired position, however with a big number of records * maybe it may be very slow */ stmt = Z_PDO_STMT_P(statement); if (!stmt->dbh) { PHALCON_MM_RESTORE(); RETURN_FALSE; } n = -1; number--; while (n != number) { if(!stmt->methods->fetcher(stmt, PDO_FETCH_ORI_NEXT, 0)) { PHALCON_MM_RESTORE(); RETURN_NULL(); } n++; } PHALCON_MM_RESTORE(); }
/** * Moves internal resulset cursor to another position letting us to fetch a certain row * *<code> * $result = $connection->query("SELECT * FROM robots ORDER BY name"); * $result->dataSeek(2); // Move to third row on result * $row = $result->fetch(); // Fetch third row *</code> * * @param int $number */ PHP_METHOD(Phalcon_Db_Result_Pdo, dataSeek){ long number = 0, n; zval *connection, *pdo, *sql_statement; zval *bind_params, *bind_types, *statement = NULL; zval *temp_statement = NULL; pdo_stmt_t *stmt; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &number) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(connection); phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC); PHALCON_INIT_VAR(pdo); PHALCON_CALL_METHOD(pdo, connection, "getinternalhandler", PH_NO_CHECK); PHALCON_INIT_VAR(sql_statement); phalcon_read_property(&sql_statement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC); PHALCON_INIT_VAR(bind_params); phalcon_read_property(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY_CC); /** * PDO doesn't support scrollable cursors, so we need to re-execute the statement again */ if (Z_TYPE_P(bind_params) == IS_ARRAY) { PHALCON_INIT_VAR(bind_types); phalcon_read_property(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY_CC); PHALCON_INIT_VAR(statement); PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK); if (Z_TYPE_P(statement) == IS_OBJECT) { PHALCON_INIT_VAR(temp_statement); PHALCON_CALL_METHOD_PARAMS_3(temp_statement, connection, "executeprepared", statement, bind_params, bind_types, PH_NO_CHECK); PHALCON_CPY_WRT(statement, temp_statement); } } else { PHALCON_INIT_NVAR(statement); PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "query", sql_statement, PH_NO_CHECK); } phalcon_update_property_zval(this_ptr, SL("_pdoStatement"), statement TSRMLS_CC); /** * This a fetch scroll to reach the desired position, however with a big number of records * maybe it may be very slow */ stmt = (pdo_stmt_t*) zend_object_store_get_object(statement TSRMLS_CC); if (!stmt->dbh) { PHALCON_MM_RESTORE(); RETURN_FALSE; } n = -1; number--; while (n != number) { if(!stmt->methods->fetcher(stmt, PDO_FETCH_ORI_NEXT, 0 TSRMLS_CC)) { PHALCON_MM_RESTORE(); RETURN_NULL(); } n++; } PHALCON_MM_RESTORE(); }
/** * Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST * * @param Phalcon\DiInterface $dependencyInjector * @param string $modelName * @param array $data * @return Phalcon\Mvc\Model\Criteria */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput){ zval *dependency_injector, *model_name, *data; zval *conditions, *service, *meta_data = NULL, *model; zval *data_types = NULL, *bind, *value = NULL, *field = NULL, *type, *condition = NULL; zval *value_pattern = NULL, *join_conditions; zval *column_map = NULL; HashTable *ah0; HashPosition hp0; zval **hd; zend_class_entry *ce0; PHALCON_MM_GROW(); phalcon_fetch_params(1, 3, 0, &dependency_injector, &model_name, &data); if (Z_TYPE_P(data) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Input data must be an Array"); return; } if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A dependency injector container is required to obtain the ORM services"); return; } object_init_ex(return_value, phalcon_mvc_model_criteria_ce); if (zend_hash_num_elements(Z_ARRVAL_P(data))) { PHALCON_INIT_VAR(service); PHALCON_ZVAL_MAYBE_INTERNED_STRING(service, phalcon_interned_modelsMetadata); PHALCON_CALL_METHOD(&meta_data, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(meta_data, phalcon_mvc_model_metadatainterface_ce); ce0 = phalcon_fetch_class(model_name TSRMLS_CC); PHALCON_INIT_VAR(model); object_init_ex(model, ce0); if (phalcon_has_constructor(model TSRMLS_CC)) { PHALCON_CALL_METHOD(NULL, model, "__construct"); } PHALCON_VERIFY_INTERFACE_EX(model, phalcon_mvc_modelinterface_ce, phalcon_mvc_model_exception_ce, 1); if (PHALCON_GLOBAL(orm).column_renaming) { PHALCON_CALL_METHOD(&column_map, meta_data, "getreversecolumnmap", model); if (Z_TYPE_P(column_map) != IS_ARRAY) { PHALCON_INIT_NVAR(column_map); } } else { column_map = PHALCON_GLOBAL(z_null); } PHALCON_CALL_METHOD(&data_types, meta_data, "getdatatypes", model); PHALCON_INIT_VAR(bind); array_init(bind); PHALCON_INIT_VAR(conditions); array_init(conditions); /** * We look for attributes in the array passed as data */ phalcon_is_iterable(data, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { zval *real_field; PHALCON_GET_HKEY(field, ah0, hp0); PHALCON_GET_HVALUE(value); if (Z_TYPE_P(column_map) != IS_ARRAY || !phalcon_array_isset_fetch(&real_field, column_map, field)) { real_field = field; } if (phalcon_array_isset_fetch(&type, data_types, real_field)) { if (Z_TYPE_P(value) != IS_NULL && !PHALCON_IS_STRING(value, "")) { if (PHALCON_IS_LONG(type, 2)) { /** * For varchar types we use LIKE operator */ PHALCON_INIT_NVAR(condition); PHALCON_CONCAT_VSVS(condition, field, " LIKE :", field, ":"); PHALCON_INIT_NVAR(value_pattern); PHALCON_CONCAT_SVS(value_pattern, "%", value, "%"); phalcon_array_update_zval(&bind, field, value_pattern, PH_COPY); } else { /** * For the rest of data types we use a plain = operator */ PHALCON_INIT_NVAR(condition); PHALCON_CONCAT_VSVS(condition, field, "=:", field, ":"); phalcon_array_update_zval(&bind, field, value, PH_COPY); } phalcon_array_append(&conditions, condition, 0); } } zend_hash_move_forward_ex(ah0, &hp0); } if (zend_hash_num_elements(Z_ARRVAL_P(conditions))) { PHALCON_INIT_VAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), conditions TSRMLS_CC); PHALCON_CALL_METHOD(NULL, return_value, "where", join_conditions, bind); } } PHALCON_CALL_METHOD(NULL, return_value, "setmodelname", model_name); RETURN_MM(); }
/** * Appends an IN condition to the current conditions * *<code> * $criteria->inWhere('id', [1, 2, 3]); *</code> * * @param string $expr * @param array $values * @return Phalcon\Mvc\Model\CriteriaInterface */ PHP_METHOD(Phalcon_Mvc_Model_Criteria, inWhere){ zval *expr, *values, *hidden_param, *bind_params; zval *bind_keys, *value = NULL, *key = NULL, *query_key = NULL, *joined_keys; zval *conditions; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &expr, &values); if (Z_TYPE_P(values) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Values must be an array"); return; } PHALCON_OBS_VAR(hidden_param); phalcon_read_property_this(&hidden_param, this_ptr, SL("_hiddenParamNumber"), PH_NOISY TSRMLS_CC); SEPARATE_ZVAL(&hidden_param); PHALCON_INIT_VAR(bind_params); array_init(bind_params); PHALCON_INIT_VAR(bind_keys); array_init(bind_keys); phalcon_is_iterable(values, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(value); /** * Key with auto bind-params */ PHALCON_INIT_NVAR(key); PHALCON_CONCAT_SV(key, "phi", hidden_param); PHALCON_INIT_NVAR(query_key); PHALCON_CONCAT_SVS(query_key, ":", key, ":"); phalcon_array_append(&bind_keys, query_key, 0); phalcon_array_update_zval(&bind_params, key, value, PH_COPY); phalcon_increment(hidden_param); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(joined_keys); phalcon_fast_join_str(joined_keys, SL(", "), bind_keys TSRMLS_CC); /** * Create a standard IN condition with bind params */ PHALCON_INIT_VAR(conditions); PHALCON_CONCAT_VSVS(conditions, expr, " IN (", joined_keys, ")"); /** * Append the IN to the current conditions using and 'and' */ PHALCON_CALL_METHOD(NULL, this_ptr, "andwhere", conditions, bind_params); phalcon_update_property_this(this_ptr, SL("_hiddenParamNumber"), hidden_param TSRMLS_CC); RETURN_THIS(); }
/** * Constructor for Phalcon\Session\Adapter\Memcache * * @param array $options */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, __construct){ zval *options; zval *host, *port, *lifetime, *persistent, *prefix; zval *frontend_data, *memcache, *option; zval *callable_open , *callable_close , *callable_read , *callable_write , *callable_destroy , *callable_gc; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &options); if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "The options must be an array"); return; } if (!phalcon_array_isset_string_fetch(&host, options, SS("host"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_session_exception_ce, "No session host given in options"); return; } if (!phalcon_array_isset_string_fetch(&port, options, SS("port"))) { PHALCON_INIT_VAR(port); ZVAL_LONG(port, 11211); } if (!phalcon_array_isset_string_fetch(&lifetime, options, SS("lifetime"))) { PHALCON_INIT_VAR(lifetime); ZVAL_LONG(lifetime, 8600); } phalcon_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC); if (!phalcon_array_isset_string_fetch(&persistent, options, SS("persistent"))) { PHALCON_INIT_VAR(persistent); ZVAL_FALSE(persistent); } if (!phalcon_array_isset_string_fetch(&prefix, options, SS("prefix"))) { PHALCON_INIT_VAR(prefix); ZVAL_EMPTY_STRING(prefix); } /* create memcache instance */ PHALCON_INIT_VAR(option); array_init_size(option, 1); phalcon_array_update_string(&option, SL("lifetime"), lifetime, PH_COPY); PHALCON_INIT_VAR(frontend_data); object_init_ex(frontend_data, phalcon_cache_frontend_data_ce); PHALCON_CALL_METHOD(NULL, frontend_data, "__construct", option); PHALCON_INIT_NVAR(option); array_init_size(option, 3); phalcon_array_update_string(&option, SL("host"), host, PH_COPY); phalcon_array_update_string(&option, SL("port"), port, PH_COPY); phalcon_array_update_string(&option, SL("persistent"), persistent, PH_COPY); phalcon_array_update_string(&option, SL("prefix"), prefix, PH_COPY); PHALCON_INIT_VAR(memcache); object_init_ex(memcache, phalcon_cache_backend_memcache_ce); PHALCON_CALL_METHOD(NULL, memcache, "__construct", frontend_data, option); phalcon_update_property_this(this_ptr, SL("_memcache"), memcache TSRMLS_CC); /* open callback */ PHALCON_INIT_VAR(callable_open); array_init_size(callable_open, 2); phalcon_array_append(&callable_open, this_ptr, PH_COPY); phalcon_array_append_string(&callable_open, SL("open"), 0); /* close callback */ PHALCON_INIT_VAR(callable_close); array_init_size(callable_close, 2); phalcon_array_append(&callable_close, this_ptr, PH_COPY); phalcon_array_append_string(&callable_close, SL("close"), 0); /* read callback */ PHALCON_INIT_VAR(callable_read); array_init_size(callable_read, 2); phalcon_array_append(&callable_read, this_ptr, PH_COPY); phalcon_array_append_string(&callable_read, SL("read"), 0); /* write callback */ PHALCON_INIT_VAR(callable_write); array_init_size(callable_write, 2); phalcon_array_append(&callable_write, this_ptr, PH_COPY); phalcon_array_append_string(&callable_write, SL("write"), 0); /* destroy callback */ PHALCON_INIT_VAR(callable_destroy); array_init_size(callable_destroy, 2); phalcon_array_append(&callable_destroy, this_ptr, PH_COPY); phalcon_array_append_string(&callable_destroy, SL("destroy"), 0); /* gc callback */ PHALCON_INIT_VAR(callable_gc); array_init_size(callable_gc, 2); phalcon_array_append(&callable_gc, this_ptr, PH_COPY); phalcon_array_append_string(&callable_gc, SL("gc"), 0); PHALCON_CALL_FUNCTION(NULL, "session_set_save_handler", callable_open, callable_close, callable_read, callable_write, callable_destroy, callable_gc); PHALCON_CALL_PARENT(NULL, phalcon_session_adapter_memcache_ce, this_ptr, "__construct", options); PHALCON_MM_RESTORE(); }
/** * Builds a HTML FORM tag * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, form){ zval *parameters = NULL, *params = NULL, *dispatcher = NULL, *dispatch_params = NULL; zval *action_parameters = NULL, *action = NULL, *controller_name = NULL; zval *action_name = NULL, *url = NULL, *form_action = NULL, *code = NULL, *avalue = NULL; zval *key = NULL, *attribute = NULL; zval *c0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_ALLOC_ZVAL_MM(parameters); ZVAL_NULL(parameters); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init(params); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(dispatcher); PHALCON_CALL_SELF(dispatcher, this_ptr, "getdispatcherservice"); PHALCON_INIT_VAR(dispatch_params); PHALCON_CALL_METHOD(dispatch_params, dispatcher, "getparams", PH_NO_CHECK); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_INIT_VAR(action_parameters); phalcon_fast_join(action_parameters, c0, dispatch_params TSRMLS_CC); eval_int = phalcon_array_isset_long(params, 0); if (!eval_int) { eval_int = phalcon_array_isset_string(params, SL("action")+1); if (eval_int) { PHALCON_INIT_VAR(action); phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(controller_name); PHALCON_CALL_METHOD(controller_name, dispatcher, "getcontrollername", PH_NO_CHECK); PHALCON_INIT_VAR(action_name); PHALCON_CALL_METHOD(action_name, dispatcher, "getactionname", PH_NO_CHECK); PHALCON_INIT_VAR(action); PHALCON_CONCAT_VSV(action, controller_name, "/", action_name); } } else { PHALCON_INIT_VAR(action); phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC); } eval_int = phalcon_array_isset_string(params, SL("method")+1); if (!eval_int) { phalcon_array_update_string_string(¶ms, SL("method"), SL("post"), PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); if (zend_is_true(action_parameters)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, url, "get", action, PH_NO_CHECK); PHALCON_CPY_WRT(action, r0); } else { PHALCON_INIT_VAR(form_action); PHALCON_CONCAT_VSV(form_action, action, "/", action_parameters); PHALCON_INIT_VAR(action); PHALCON_CALL_METHOD_PARAMS_1(action, url, "get", form_action, PH_NO_CHECK); } eval_int = phalcon_array_isset_string(params, SL("parameters")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, params, SL("parameters"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CONCAT_SV(r2, "?", r1); phalcon_concat_self(&action, r2 TSRMLS_CC); } PHALCON_INIT_VAR(code); PHALCON_CONCAT_SVS(code, "<form action=\"", action, "\" "); if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_9b93_5: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_9b93_5; } PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); PHALCON_INIT_VAR(avalue); ZVAL_ZVAL(avalue, *hd, 1, 0); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_INIT_VAR(attribute); PHALCON_CONCAT_VSVS(attribute, key, "= \"", avalue, "\" "); phalcon_concat_self(&code, attribute TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_9b93_5; fee_9b93_5: PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CONCAT_VS(r3, code, ">"); RETURN_CTOR(r3); }
/** * Produces a recursive representation of an array * * @param array $argument * @return string */ PHP_METHOD(Phalcon_Debug, _getArrayDump) { zval *argument, *n = NULL, *number_arguments, *dump; zval *v = NULL, *var_dump = NULL, *escaped_string = NULL, *next = NULL, *array_dump = NULL; zval *class_name = NULL, *joined_dump; zend_string *str_key; ulong idx; PHALCON_MM_GROW(); phalcon_fetch_params(0, 1, 1, &argument, &n); if (!n) { PHALCON_INIT_VAR(n); ZVAL_LONG(n, 0); } PHALCON_INIT_VAR(number_arguments); phalcon_fast_count(number_arguments, argument); if (PHALCON_LT_LONG(n, 3)) { if (PHALCON_GT_LONG(number_arguments, 0)) { if (PHALCON_LT_LONG(number_arguments, 10)) { PHALCON_INIT_VAR(dump); array_init(dump); ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(argument), idx, str_key, v) { zval tmp; if (str_key) { ZVAL_STR(&tmp, str_key); } else { ZVAL_LONG(&tmp, idx); } if (PHALCON_IS_SCALAR(v)) { if (PHALCON_IS_STRING(v, "")) { PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVS(var_dump, "[", &tmp, "] => (empty string)"); } else { PHALCON_CALL_METHOD(&escaped_string, getThis(), "_escapestring", v); PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSV(var_dump, "[", &tmp, "] => ", escaped_string); } phalcon_array_append(dump, var_dump, PH_COPY); } else { if (Z_TYPE_P(v) == IS_ARRAY) { PHALCON_INIT_NVAR(next); phalcon_add_function(next, n, &PHALCON_GLOBAL(z_one)); PHALCON_CALL_METHOD(&array_dump, getThis(), "_getarraydump", v, next); PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSVS(var_dump, "[", &tmp, "] => Array(", array_dump, ")"); phalcon_array_append(dump, var_dump, PH_COPY); continue; } if (Z_TYPE_P(v) == IS_OBJECT) { zend_class_entry *ce = Z_OBJCE_P(v); PHALCON_INIT_NVAR(class_name); ZVAL_NEW_STR(class_name, ce->name); PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSVS(var_dump, "[", &tmp, "] => Object(", class_name, ")"); phalcon_array_append(dump, var_dump, PH_COPY); continue; } if (Z_TYPE_P(v) == IS_NULL) { PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVS(var_dump, "[", &tmp, "] => null"); phalcon_array_append(dump, var_dump, PH_COPY); continue; } PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSV(var_dump, "[", &tmp, "] => ", v); phalcon_array_append(dump, var_dump, PH_COPY); } } ZEND_HASH_FOREACH_END(); PHALCON_INIT_VAR(joined_dump); phalcon_fast_join_str(joined_dump, SL(", "), dump); RETURN_CTOR(joined_dump); } RETURN_NCTOR(number_arguments); }
/** * Stores cached content into the Mongo backend and stops the frontend * * @param int|string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_Mongo, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *last_key, *frontend, *cached_content = NULL; zval *prepared_content = NULL, *ttl = NULL, *collection = NULL, *timestamp; zval *conditions, *document = NULL, *data, *is_buffering = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer); if (!key_name || Z_TYPE_P(key_name) == IS_NULL) { last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC); } else { zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, key_name); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC); if (!content || Z_TYPE_P(content) == IS_NULL) { PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent"); } else { cached_content = content; } if (!phalcon_is_numeric(cached_content)) { PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content); } if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) { zval *tmp = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC); if (Z_TYPE_P(tmp) == IS_NULL) { PHALCON_CALL_METHOD(&ttl, frontend, "getlifetime"); } else { ttl = tmp; } } else { ttl = lifetime; } PHALCON_CALL_METHOD(&collection, this_ptr, "_getcollection"); PHALCON_INIT_VAR(timestamp); ZVAL_LONG(timestamp, (long) time(NULL) + phalcon_get_intval(ttl)); PHALCON_INIT_VAR(conditions); array_init_size(conditions, 1); phalcon_array_update_string(&conditions, SL("key"), last_key, PH_COPY); PHALCON_CALL_METHOD(&document, collection, "findone", conditions); if (Z_TYPE_P(document) == IS_ARRAY) { phalcon_array_update_string(&document, SL("time"), timestamp, PH_COPY); if (prepared_content) { phalcon_array_update_string(&document, SL("data"), prepared_content, PH_COPY); } else { phalcon_array_update_string(&document, SL("data"), cached_content, PH_COPY); } PHALCON_CALL_METHOD(NULL, collection, "save", document); } else { PHALCON_INIT_VAR(data); array_init_size(data, 3); phalcon_array_update_string(&data, SL("key"), last_key, PH_COPY); phalcon_array_update_string(&data, SL("time"), timestamp, PH_COPY); if (prepared_content) { phalcon_array_update_string(&data, SL("data"), prepared_content, PH_COPY); } else { phalcon_array_update_string(&data, SL("data"), cached_content, PH_COPY); } PHALCON_CALL_METHOD(NULL, collection, "save", data); } PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering"); if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD(NULL, frontend, "stop"); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Updates data on a table using custom RBDM SQL syntax * * * * @param string $table * @param array $fields * @param array $values * @param string $whereCondition * @param boolean $automaticQuotes * @return boolean */ PHP_METHOD(Phalcon_Db, update){ zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL; zval *automatic_quotes = NULL, *i = NULL, *update_values = NULL, *update_sql = NULL; zval *field = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL; zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL; zval *a0 = NULL; zval *c0 = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|zz", &table, &fields, &values, &where_condition, &automatic_quotes) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!where_condition) { PHALCON_INIT_VAR(where_condition); ZVAL_NULL(where_condition); } if (!automatic_quotes) { PHALCON_INIT_VAR(automatic_quotes); ZVAL_BOOL(automatic_quotes, 0); } PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_count(r0, fields TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_fast_count(r1, values TSRMLS_CC); PHALCON_INIT_VAR(r2); is_not_equal_function(r2, r0, r1 TSRMLS_CC); if (zend_is_true(r2)) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values to update is not the same as fields"); return; } PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(update_values, a0); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CONCAT_SVS(r3, "UPDATE ", table, " SET "); PHALCON_CPY_WRT(update_sql, r3); if (phalcon_valid_foreach(fields TSRMLS_CC)) { ah0 = Z_ARRVAL_P(fields); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_e7f0_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e7f0_2; } PHALCON_INIT_VAR(field); ZVAL_ZVAL(field, *hd, 1, 0); if (zend_is_true(automatic_quotes)) { PHALCON_INIT_VAR(r4); phalcon_array_fetch(&r4, values, i, PHALCON_NOISY TSRMLS_CC); if (Z_TYPE_P(r4) == IS_OBJECT) { PHALCON_INIT_VAR(r5); phalcon_array_fetch(&r5, values, i, PHALCON_NOISY TSRMLS_CC); PHALCON_INIT_VAR(r6); phalcon_instance_of(r6, r5, phalcon_db_rawvalue_ce TSRMLS_CC); if (zend_is_true(r6)) { PHALCON_INIT_VAR(r7); PHALCON_INIT_VAR(r8); PHALCON_INIT_VAR(r9); phalcon_array_fetch(&r9, values, i, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD(r8, r9, "getvalue", PHALCON_NO_CHECK); PHALCON_CALL_METHOD_PARAMS_1(r7, this_ptr, "escapestring", r8, PHALCON_NO_CHECK); phalcon_array_update(&values, i, &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); goto fes_e7f0_2; } } PHALCON_INIT_VAR(r10); PHALCON_INIT_VAR(r11); PHALCON_INIT_VAR(r12); phalcon_array_fetch(&r12, values, i, PHALCON_NOISY TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_1(r11, this_ptr, "escapestring", r12, PHALCON_NO_CHECK); PHALCON_CONCAT_SVS(r10, "'", r11, "'"); phalcon_array_update(&values, i, &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC); } PHALCON_INIT_VAR(r13); PHALCON_INIT_VAR(r14); phalcon_array_fetch(&r14, values, i, PHALCON_NOISY TSRMLS_CC); PHALCON_CONCAT_VSV(r13, field, " = ", r14); phalcon_array_append(&update_values, r13, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah0, &hp0); goto fes_e7f0_2; fee_e7f0_2: if(0){} } else { return; } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ", ", 1); PHALCON_ALLOC_ZVAL_MM(r15); phalcon_fast_join(r15, c0, update_values TSRMLS_CC); phalcon_concat_self(&update_sql, r15 TSRMLS_CC); PHALCON_INIT_VAR(t0); ZVAL_NULL(t0); PHALCON_INIT_VAR(r16); is_not_equal_function(r16, where_condition, t0 TSRMLS_CC); if (zend_is_true(r16)) { PHALCON_ALLOC_ZVAL_MM(r17); PHALCON_CONCAT_SV(r17, " WHERE ", where_condition); phalcon_concat_self(&update_sql, r17 TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(r18); PHALCON_CALL_METHOD_PARAMS_1(r18, this_ptr, "query", update_sql, PHALCON_NO_CHECK); PHALCON_RETURN_DZVAL(r18); }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server doesn't return any row * *<code> * //Inserting data * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')"); * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy')); *</code> * * @param string $sqlStatement * @param array $bindParams * @param array $bindTypes * @return boolean */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){ zval *sql_statement, *bind_params = NULL, *bind_types = NULL; zval *events_manager, *event_name = NULL, *status, *pdo; zval *statement = NULL, *affected_rows = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &sql_statement, &bind_params, &bind_types) == FAILURE) { RETURN_MM_NULL(); } if (!bind_params) { PHALCON_INIT_VAR(bind_params); } if (!bind_types) { PHALCON_INIT_VAR(bind_types); } /** * Execute the beforeQuery event if a EventsManager is available */ PHALCON_OBS_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_VAR(event_name); ZVAL_STRING(event_name, "db:beforeQuery", 1); phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_sqlVariables"), bind_params TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_sqlBindTypes"), bind_types TSRMLS_CC); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, bind_params); if (PHALCON_IS_FALSE(status)) { RETURN_MM_FALSE; } } PHALCON_OBS_VAR(pdo); phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); if (Z_TYPE_P(bind_params) == IS_ARRAY) { PHALCON_INIT_VAR(statement); PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement); if (Z_TYPE_P(statement) == IS_OBJECT) { PHALCON_INIT_VAR(r0); PHALCON_CALL_METHOD_PARAMS_3(r0, this_ptr, "executeprepared", statement, bind_params, bind_types); PHALCON_CPY_WRT(statement, r0); PHALCON_INIT_VAR(affected_rows); PHALCON_CALL_METHOD(affected_rows, statement, "rowcount"); } } else { PHALCON_INIT_NVAR(affected_rows); PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement); } /** * Execute the afterQuery event if a EventsManager is available */ if (Z_TYPE_P(affected_rows) == IS_LONG) { phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC); if (Z_TYPE_P(events_manager) == IS_OBJECT) { PHALCON_INIT_NVAR(event_name); ZVAL_STRING(event_name, "db:afterQuery", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, bind_params); } } RETURN_MM_TRUE; }
/** * Rollbacks the transaction * * @param string $rollbackMessage * @param Phalcon_Model_Base $rollbackRecord * @return boolean */ PHP_METHOD(Phalcon_Transaction, rollback){ zval *v0 = NULL, *v1 = NULL, *v2 = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL; zval *a0 = NULL, *a1 = NULL; zval *r0 = NULL, *r1 = NULL; zval *i0 = NULL; zval *p2[] = { NULL, NULL }; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &v0, &v1) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!v0) { PHALCON_INIT_VAR(v0); ZVAL_STRING(v0, "", 1); } else { PHALCON_SEPARATE_PARAM(v0); } if (!v1) { PHALCON_INIT_VAR(v1); ZVAL_NULL(v1); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC); if (!PHALCON_COMPARE_STRING(t0, "")) { PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_manager", sizeof("_manager")-1, PHALCON_NOISY_FETCH TSRMLS_CC); Z_ADDREF_P(t1); PHALCON_SEPARATE_ARRAY(a0); add_next_index_zval(a0, t1); add_next_index_stringl(a0, "notifyRollback", strlen("notifyRollback"), 1); Z_ADDREF_P(a0); PHALCON_INIT_VAR(a1); array_init(a1); Z_ADDREF_P(this_ptr); PHALCON_SEPARATE_ARRAY(a1); add_next_index_zval(a1, this_ptr); Z_ADDREF_P(a1); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("call_user_func_array", a0, a1, 0x001); Z_DELREF_P(a0); Z_DELREF_P(a1); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_connection", sizeof("_connection")-1, PHALCON_NOISY_FETCH TSRMLS_CC); PHALCON_CALL_METHOD(r0, t2, "rollback", PHALCON_CALL_DEFAULT); PHALCON_CPY_WRT(v2, r0); PHALCON_INIT_VAR(t3); ZVAL_BOOL(t3, 1); PHALCON_ALLOC_ZVAL_MM(r1); is_equal_function(r1, v2, t3 TSRMLS_CC); if (zend_is_true(r1)) { if (PHALCON_COMPARE_STRING(v0, "")) { PHALCON_INIT_VAR(v0); ZVAL_STRING(v0, "Transaction aborted", 1); } if (zend_is_true(v1)) { phalcon_update_property_zval(this_ptr, "_rollbackRecord", strlen("_rollbackRecord"), v1 TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_transaction_failed_class_entry); Z_ADDREF_P(v0); p2[0] = v0; PHALCON_ALLOC_ZVAL_MM(t4); phalcon_read_property(&t4, this_ptr, "_rollbackRecord", sizeof("_rollbackRecord")-1, PHALCON_NOISY_FETCH TSRMLS_CC); Z_ADDREF_P(t4); p2[1] = t4; PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 2, p2, PHALCON_CALL_CHECK); Z_DELREF_P(p2[0]); Z_DELREF_P(p2[1]); zend_throw_exception_object(i0 TSRMLS_CC); Z_ADDREF_P(i0); PHALCON_MM_RESTORE(); return; } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Gets number of rows returned by a resulset * *<code> * $result = $connection->query("SELECT * FROM robots ORDER BY name"); * echo 'There are ', $result->numRows(), ' rows in the resulset'; *</code> * * @return int */ PHP_METHOD(Phalcon_Db_Result_Pdo, numRows){ zval *row_count = NULL, *connection, *type = NULL, *pdo_statement = NULL; zval *sql_statement, *bind_params, *bind_types; zval *matches, *pattern, *match, *else_clauses; zval *sql, *result = NULL, *row = NULL; PHALCON_MM_GROW(); row_count = phalcon_read_property(getThis(), SL("_rowCount"), PH_NOISY); if (PHALCON_IS_FALSE(row_count)) { connection = phalcon_read_property(getThis(), SL("_connection"), PH_NOISY); PHALCON_CALL_METHOD(&type, connection, "gettype"); /** * MySQL/PostgreSQL library property returns the number of records */ if (PHALCON_IS_STRING(type, "mysql") || PHALCON_IS_STRING(type, "pgsql")) { pdo_statement = phalcon_read_property(getThis(), SL("_pdoStatement"), PH_NOISY); PHALCON_CALL_METHOD(&row_count, pdo_statement, "rowcount"); } /** * We should get the count using a new statement :( */ if (PHALCON_IS_FALSE(row_count)) { /** * SQLite/Oracle/SQLServer returns resultsets that to the client eyes (PDO) has an * arbitrary number of rows, so we need to perform an extra count to know that */ sql_statement = phalcon_read_property(getThis(), SL("_sqlStatement"), PH_NOISY); /** * If the sql_statement starts with SELECT COUNT(*) we don't make the count */ if (!phalcon_start_with_str(sql_statement, SL("SELECT COUNT(*) "))) { bind_params = phalcon_read_property(getThis(), SL("_bindParams"), PH_NOISY); bind_types = phalcon_read_property(getThis(), SL("_bindTypes"), PH_NOISY); PHALCON_INIT_VAR(matches); PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "/^SELECT\\s+(.*)$/i"); PHALCON_INIT_VAR(match); RETURN_MM_ON_FAILURE(phalcon_preg_match(match, pattern, sql_statement, matches)); if (zend_is_true(match)) { PHALCON_OBS_VAR(else_clauses); phalcon_array_fetch_long(&else_clauses, matches, 1, PH_NOISY); PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "SELECT COUNT(*) \"numrows\" FROM (SELECT ", else_clauses, ")"); PHALCON_CALL_METHOD(&result, connection, "query", sql, bind_params, bind_types); PHALCON_CALL_METHOD(&row, result, "fetch"); PHALCON_OBS_NVAR(row_count); phalcon_array_fetch_str(&row_count, row, SL("numrows"), PH_NOISY); } } else { PHALCON_INIT_NVAR(row_count); ZVAL_LONG(row_count, 1); } } /** * Update the value to avoid further calculations */ phalcon_update_property_this(getThis(), SL("_rowCount"), row_count); } RETURN_CCTOR(row_count); }
/** * Executes validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Inclusionin, validate){ zval *record, *field = NULL, *is_set = NULL, *domain = NULL; zval *value = NULL, *option, *message = NULL, *joined_domain, *is_set_code = NULL, *code = NULL; zval *type; zval *allow_empty = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &record); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_CALL_METHOD(&field, this_ptr, "getoption", option); if (Z_TYPE_P(field) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string"); return; } /** * The 'domain' option must be a valid array of not allowed values */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "domain", 1); PHALCON_CALL_METHOD(&is_set, this_ptr, "issetoption", option); if (PHALCON_IS_FALSE(is_set)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The option 'domain' is required for this validator"); return; } PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "domain", 1); PHALCON_CALL_METHOD(&domain, this_ptr, "getoption", option); if (Z_TYPE_P(domain) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Option 'domain' must be an array"); return; } PHALCON_CALL_METHOD(&value, record, "readattribute", field); /* * Allow empty */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "allowEmpty", 1); PHALCON_CALL_METHOD(&allow_empty, this_ptr, "getoption", option); if (allow_empty && zend_is_true(allow_empty) && PHALCON_IS_EMPTY(value)) { RETURN_MM_TRUE; } /** * Check if the value is contained in the array */ if (!phalcon_fast_in_array(value, domain TSRMLS_CC)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_message); PHALCON_CALL_METHOD(&message, this_ptr, "getoption", option); if (!zend_is_true(message)) { PHALCON_INIT_VAR(joined_domain); phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC); PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVSV(message, "Value of field '", field, "' must be part of list: ", joined_domain); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Inclusion", 1); /* * Is code set */ PHALCON_INIT_NVAR(option); PHALCON_ZVAL_MAYBE_INTERNED_STRING(option, phalcon_interned_code); PHALCON_CALL_METHOD(&is_set_code, this_ptr, "issetoption", option); if (zend_is_true(is_set_code)) { PHALCON_CALL_METHOD(&code, this_ptr, "getoption", option); } else { PHALCON_INIT_VAR(code); ZVAL_LONG(code, 0); } PHALCON_CALL_METHOD(NULL, this_ptr, "appendmessage", message, field, type, code); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Gets number of rows returned by a resulset * *<code> * $result = $connection->query("SELECT * FROM robots ORDER BY name"); * echo 'There are ', $result->numRows(), ' rows in the resulset'; *</code> * * @return int */ PHP_METHOD(Phalcon_Db_Result_Pdo, numRows){ zval *row_count = NULL, *connection, *type, *sql_statement; zval *bind_params, *bind_types, *matches, *pattern; zval *match, *else_clauses, *sql, *fetch_num, *result; zval *row, *pdo_statement; PHALCON_MM_GROW(); PHALCON_INIT_VAR(row_count); phalcon_read_property(&row_count, this_ptr, SL("_rowCount"), PH_NOISY_CC); if (PHALCON_IS_FALSE(row_count)) { PHALCON_INIT_VAR(connection); phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC); PHALCON_INIT_VAR(type); PHALCON_CALL_METHOD(type, connection, "gettype", PH_NO_CHECK); if (PHALCON_COMPARE_STRING(type, "sqlite")) { /** * SQLite returns resultsets that to the client eyes (PDO) has an arbitrary number * of rows, so we need to perform an extra count to know that */ PHALCON_INIT_VAR(sql_statement); phalcon_read_property(&sql_statement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC); PHALCON_INIT_VAR(bind_params); phalcon_read_property(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY_CC); PHALCON_INIT_VAR(bind_types); phalcon_read_property(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY_CC); PHALCON_INIT_VAR(matches); PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "/^SELECT\\s+(.*)$/i", 1); Z_SET_ISREF_P(matches); PHALCON_INIT_VAR(match); PHALCON_CALL_FUNC_PARAMS_3(match, "preg_match", pattern, sql_statement, matches); Z_UNSET_ISREF_P(matches); if (zend_is_true(match)) { PHALCON_INIT_VAR(else_clauses); phalcon_array_fetch_long(&else_clauses, matches, 1, PH_NOISY_CC); PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "SELECT COUNT(*) FROM (SELECT ", else_clauses, ")"); PHALCON_INIT_VAR(fetch_num); ZVAL_LONG(fetch_num, 3); PHALCON_INIT_VAR(result); PHALCON_CALL_METHOD_PARAMS_3(result, connection, "query", sql, bind_params, bind_types, PH_NO_CHECK); PHALCON_INIT_VAR(row); PHALCON_CALL_METHOD(row, result, "fetch", PH_NO_CHECK); PHALCON_INIT_NVAR(row_count); phalcon_array_fetch_long(&row_count, row, 0, PH_NOISY_CC); } } else { PHALCON_INIT_VAR(pdo_statement); phalcon_read_property(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC); PHALCON_INIT_NVAR(row_count); PHALCON_CALL_METHOD(row_count, pdo_statement, "rowcount", PH_NO_CHECK); } phalcon_update_property_zval(this_ptr, SL("_rowCount"), row_count TSRMLS_CC); } RETURN_CCTOR(row_count); }
/** * Changes internal pointer to a specific position in the resultset * * @param int $position */ PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){ long i; zval *type, *result, *rows, *position; zval *pointer, *is_different; HashTable *ah0; if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &position) == FAILURE) { RETURN_NULL(); } PHALCON_MM_GROW(); pointer = phalcon_read_property(getThis(), SL("_pointer"), PH_NOISY); /** * We only seek the records if the current position is diferent than the passed one */ PHALCON_INIT_VAR(is_different); is_not_equal_function(is_different, pointer, position); if (PHALCON_IS_TRUE(is_different)) { type = phalcon_read_property(getThis(), SL("_type"), PH_NOISY); if (zend_is_true(type)) { /** * Here, the resultset is fetched one by one because is large */ result = phalcon_read_property(getThis(), SL("_result"), PH_NOISY); PHALCON_CALL_METHOD(NULL, result, "dataseek", position); } else { /** * Here, the resultset is a small array */ rows = phalcon_read_property(getThis(), SL("_rows"), PH_NOISY); /** * We need to fetch the records because rows is null */ if (Z_TYPE_P(rows) == IS_NULL) { result = phalcon_read_property(getThis(), SL("_result"), PH_NOISY); if (PHALCON_IS_NOT_FALSE(result)) { PHALCON_CALL_METHOD(&rows, result, "fetchall"); phalcon_update_property_zval(getThis(), SL("_rows"), rows); } } convert_to_long(position); if(Z_TYPE_P(rows) == IS_ARRAY){ ah0 = Z_ARRVAL_P(rows); zend_hash_internal_pointer_reset(ah0); i = 0; while (1) { if (i >= Z_LVAL_P(position)) { break; } zend_hash_move_forward(ah0); i++; } } phalcon_update_property_zval(getThis(), SL("_pointer"), position); } } PHALCON_MM_RESTORE();}
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate){ zval *validator, *attribute, *value = NULL, *domain; zval *message_str, *joined_domain, *message, *code; zval *allow_empty, *label, *pairs, *prepared = NULL; zend_class_entry *ce = Z_OBJCE_P(getThis()); PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &validator, &attribute); PHALCON_VERIFY_CLASS_EX(validator, phalcon_validation_ce, phalcon_validation_exception_ce, 1); PHALCON_CALL_METHOD(&value, validator, "getvalue", attribute); PHALCON_OBS_VAR(allow_empty); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &allow_empty, getThis(), phalcon_interned_allowEmpty TSRMLS_CC)); if (zend_is_true(allow_empty) && phalcon_validation_validator_isempty_helper(value)) { RETURN_MM_TRUE; } /* A domain is an array with a list of valid values */ PHALCON_OBS_VAR(domain); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &domain, getThis(), phalcon_interned_domain TSRMLS_CC)); if (Z_TYPE_P(domain) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_validation_exception_ce, "Option 'domain' must be an array"); return; } /** * Check if the value is contained by the array */ if (!phalcon_fast_in_array(value, domain TSRMLS_CC)) { PHALCON_OBS_VAR(label); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &label, getThis(), phalcon_interned_label TSRMLS_CC)); if (!zend_is_true(label)) { PHALCON_CALL_METHOD(&label, validator, "getlabel", attribute); if (!zend_is_true(label)) { PHALCON_CPY_WRT(label, attribute); } } ALLOC_INIT_ZVAL(joined_domain); phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC); PHALCON_ALLOC_GHOST_ZVAL(pairs); array_init_size(pairs, 2); Z_ADDREF_P(label); add_assoc_zval_ex(pairs, SS(":field"), label); add_assoc_zval_ex(pairs, SS(":domain"), joined_domain); PHALCON_OBS_VAR(message_str); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &message_str, getThis(), phalcon_interned_message TSRMLS_CC)); if (!zend_is_true(message_str)) { PHALCON_OBSERVE_OR_NULLIFY_VAR(message_str); RETURN_MM_ON_FAILURE(phalcon_validation_getdefaultmessage_helper(Z_OBJCE_P(validator), &message_str, validator, "InclusionIn" TSRMLS_CC)); } PHALCON_OBS_VAR(code); RETURN_MM_ON_FAILURE(phalcon_validation_validator_getoption_helper(ce, &code, getThis(), phalcon_interned_code TSRMLS_CC)); if (Z_TYPE_P(code) == IS_NULL) { ZVAL_LONG(code, 0); } PHALCON_CALL_FUNCTION(&prepared, "strtr", message_str, pairs); message = phalcon_validation_message_construct_helper(prepared, attribute, "InclusionIn", code TSRMLS_CC); Z_DELREF_P(message); PHALCON_CALL_METHOD(NULL, validator, "appendmessage", message); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Gets the column name in Sqlite * * @param Phalcon\Db\ColumnInterface $column * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, getColumnDefinition){ zval *column, *size = NULL, *column_type = NULL, *column_sql = NULL; zval *scale = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &column); if (Z_TYPE_P(column) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column definition must be an instance of Phalcon\\Db\\Column"); return; } PHALCON_CALL_METHOD(&size, column, "getsize"); PHALCON_CALL_METHOD(&column_type, column, "gettype"); switch (phalcon_get_intval(column_type)) { case 0: PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "INT"); break; case 1: PHALCON_INIT_NVAR(column_sql); ZVAL_STRING(column_sql, "DATE"); break; case 2: PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "VARCHAR(", size, ")"); break; case 3: PHALCON_CALL_METHOD(&scale, column, "getscale"); PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_SVSVS(column_sql, "NUMERIC(", size, ",", scale, ")"); break; case 4: PHALCON_INIT_NVAR(column_sql); ZVAL_STRING(column_sql, "TIMESTAMP"); break; case 5: PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "CHARACTER(", size, ")"); break; case 6: PHALCON_INIT_NVAR(column_sql); ZVAL_STRING(column_sql, "TEXT"); break; case 7: PHALCON_INIT_NVAR(column_sql); ZVAL_STRING(column_sql, "FLOAT"); break; default: PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Unrecognized SQLite data type"); return; } RETURN_CTOR(column_sql); }
/** * Gets the column name in PostgreSQL * * @param Phalcon\Db\Column $column */ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition){ zval *column = NULL, *size = NULL, *column_type = NULL, *column_sql = NULL; zval *scale = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(column) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column definition must be an instance of Phalcon\\Db\\Column"); return; } PHALCON_INIT_VAR(size); PHALCON_CALL_METHOD(size, column, "getsize", PH_NO_CHECK); PHALCON_INIT_VAR(column_type); PHALCON_CALL_METHOD(column_type, column, "gettype", PH_NO_CHECK); if (phalcon_compare_strict_long(column_type, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "INT", 1); goto ph_end_0; } if (phalcon_compare_strict_long(column_type, 1 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "DATE", 1); goto ph_end_0; } if (phalcon_compare_strict_long(column_type, 2 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "CHARACTER VARYING(", size, ")"); goto ph_end_0; } if (phalcon_compare_strict_long(column_type, 3 TSRMLS_CC)) { PHALCON_INIT_VAR(scale); PHALCON_CALL_METHOD(scale, column, "getscale", PH_NO_CHECK); PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVSVS(column_sql, "NUMERIC(", size, ",", scale, ")"); goto ph_end_0; } if (phalcon_compare_strict_long(column_type, 4 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "TIMESTAMP", 1); goto ph_end_0; } if (phalcon_compare_strict_long(column_type, 5 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "CHARACTER(", size, ")"); goto ph_end_0; } if (phalcon_compare_strict_long(column_type, 6 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "TEXT", 1); goto ph_end_0; } if (phalcon_compare_strict_long(column_type, 7 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "FLOAT", 1); goto ph_end_0; } PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Unrecognized PostgreSQL data type"); return; ph_end_0: RETURN_CTOR(column_sql); }
/** * Handles routing information received from the rewrite engine * * @param string $uri */ PHP_METHOD(Phalcon_Router_Rewrite, handle) { zval *uri = NULL, *parts = NULL, *params = NULL, *number_parts = NULL, *i = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL; zval *c0 = NULL; zval *t0 = NULL, *t1 = NULL; zval *a0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!uri) { PHALCON_INIT_VAR(uri); ZVAL_NULL(uri); } else { PHALCON_SEPARATE_PARAM(uri); } if (!zend_is_true(uri)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "_getrewriteuri", PHALCON_NO_CHECK); PHALCON_CPY_WRT(uri, r0); } if (zend_is_true(uri)) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_fast_explode(r1, c0, uri TSRMLS_CC); PHALCON_CPY_WRT(parts, r1); eval_int = phalcon_array_isset_long(parts, 0); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_filter_alphanum(r3, r2); phalcon_update_property_zval(this_ptr, "_controller", strlen("_controller"), r3 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_controller", sizeof("_controller")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); } } else { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); } eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_long(&r4, parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r5); phalcon_filter_alphanum(r5, r4); phalcon_update_property_zval(this_ptr, "_action", strlen("_action"), r5 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_action", sizeof("_action")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t1)) { phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } } else { phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(params, a0); PHALCON_ALLOC_ZVAL_MM(r6); phalcon_fast_count(r6, parts TSRMLS_CC); PHALCON_CPY_WRT(number_parts, r6); PHALCON_INIT_VAR(i); ZVAL_LONG(i, 2); fs_ef57_0: PHALCON_INIT_VAR(r7); is_smaller_function(r7, i, number_parts TSRMLS_CC); if (!zend_is_true(r7)) { goto fe_ef57_0; } PHALCON_INIT_VAR(r8); phalcon_array_fetch(&r8, parts, i, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(¶ms, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); goto fs_ef57_0; fe_ef57_0: phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC); } else { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Phalcon\Mvc\Model\MetaData\Redis constructor * * @param array $options */ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Redis, __construct){ zval *options = NULL; zval *host, *port, *auth, *persistent, *lifetime, *prefix; zval *frontend_data, *redis, *option; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &options); if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The options must be an array"); return; } if (!phalcon_array_isset_string_fetch(&host, options, SS("host"))) { host = NULL; } if (!phalcon_array_isset_string_fetch(&port, options, SS("port"))) { port = NULL; } if (!phalcon_array_isset_string_fetch(&auth, options, SS("auth"))) { auth = NULL; } if (!phalcon_array_isset_string_fetch(&persistent, options, SS("persistent"))) { persistent = NULL; } if (!phalcon_array_isset_string_fetch(&lifetime, options, SS("lifetime"))) { PHALCON_INIT_VAR(lifetime); ZVAL_LONG(lifetime, 8600); } phalcon_update_property_this(this_ptr, SL("_lifetime"), lifetime TSRMLS_CC); if (!phalcon_array_isset_string_fetch(&prefix, options, SS("prefix"))) { PHALCON_INIT_VAR(prefix); ZVAL_EMPTY_STRING(prefix); } /* create redis instance */ PHALCON_INIT_VAR(option); array_init_size(option, 1); phalcon_array_update_string(&option, SL("lifetime"), lifetime, PH_COPY); PHALCON_INIT_VAR(frontend_data); object_init_ex(frontend_data, phalcon_cache_frontend_data_ce); PHALCON_CALL_METHOD(NULL, frontend_data, "__construct", option); PHALCON_INIT_NVAR(option); array_init(option); phalcon_array_update_string_string(&option, SL("statsKey"), SL("$PMM$"), PH_COPY); if (host) { phalcon_array_update_string(&option, SL("host"), host, PH_COPY); } if (port) { phalcon_array_update_string(&option, SL("port"), port, PH_COPY); } if (auth) { phalcon_array_update_string(&option, SL("auth"), auth, PH_COPY); } if (persistent) { phalcon_array_update_string(&option, SL("persistent"), persistent, PH_COPY); } phalcon_array_update_string(&option, SL("prefix"), prefix, PH_COPY); PHALCON_INIT_VAR(redis); object_init_ex(redis, phalcon_cache_backend_redis_ce); PHALCON_CALL_METHOD(NULL, redis, "__construct", frontend_data, option); phalcon_update_property_this(this_ptr, SL("_redis"), redis TSRMLS_CC); phalcon_update_property_empty_array(this_ptr, SL("_metaData") TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server return rows * * //Querying data * $resultset = $connection->query("SELECT * FROM robots WHERE type='mechanical'"); * $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical")); * * @param string $sqlStatement * @return Phalcon\Db\Result\Pdo */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, query){ zval *sql_statement = NULL, *events_manager = NULL, *status = NULL; zval *pdo = NULL, *result = NULL, *pdo_result = NULL, *error_info = NULL, *error_message = NULL; zval *exception_message = NULL, *error_code = NULL, *exception = NULL; zval *c0 = NULL, *c1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &sql_statement) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "db:beforeQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c0, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(pdo); phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); PHALCON_INIT_VAR(result); PHALCON_CALL_METHOD_PARAMS_1(result, pdo, "query", sql_statement, PH_NO_CHECK); if (Z_TYPE_P(result) == IS_OBJECT) { if (zend_is_true(events_manager)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "db:afterQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c1, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(pdo_result); object_init_ex(pdo_result, phalcon_db_result_pdo_ce); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_result, "__construct", result, PH_CHECK); RETURN_CTOR(pdo_result); } PHALCON_INIT_VAR(error_info); PHALCON_CALL_METHOD(error_info, pdo, "errorinfo", PH_NO_CHECK); PHALCON_INIT_VAR(error_message); phalcon_array_fetch_long(&error_message, error_info, 2, PH_NOISY_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_VSV(exception_message, error_message, " when executing ", sql_statement); PHALCON_INIT_VAR(error_code); phalcon_array_fetch_long(&error_code, error_info, 1, PH_NOISY_CC); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", exception_message, error_code, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * The meta-data is obtained by reading the column descriptions from the database information schema * * @param Phalcon\Mvc\ModelInterface $model * @param Phalcon\DiInterface $dependencyInjector * @return array */ PHP_METHOD(Phalcon_Mvc_Model_MetaData_Strategy_Introspection, getMetaData){ zval *model, *dependency_injector, *class_name; zval *schema = NULL, *table = NULL, *read_connection = NULL, *exists = NULL; zval *complete_table = NULL, *exception_message = NULL; zval *columns = NULL, *attributes, *primary_keys, *non_primary_keys; zval *numeric_typed, *not_null, *field_types, *field_sizes, *field_bytes, *field_scales; zval *field_bind_types, *automatic_create_attributes, *automatic_update_attributes; zval *identity_field = NULL, *column = NULL, *field_name = NULL, *feature = NULL; zval *type = NULL, *size = NULL, *bytes = NULL, *scale = NULL, *bind_type = NULL; zval *field_default_values, *default_value = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &model, &dependency_injector); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, model, 0 TSRMLS_CC); PHALCON_CALL_METHOD(&schema, model, "getschema"); PHALCON_CALL_METHOD(&table, model, "getsource"); /** * Check if the mapped table exists on the database */ PHALCON_CALL_METHOD(&read_connection, model, "getreadconnection"); PHALCON_CALL_METHOD(&exists, read_connection, "tableexists", table, schema); if (!zend_is_true(exists)) { if (zend_is_true(schema)) { PHALCON_INIT_VAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } /** * The table not exists */ PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * Try to describe the table */ PHALCON_CALL_METHOD(&columns, read_connection, "describecolumns", table, schema); if (!phalcon_fast_count_ev(columns TSRMLS_CC)) { if (zend_is_true(schema)) { PHALCON_INIT_NVAR(complete_table); PHALCON_CONCAT_VSV(complete_table, schema, "\".\"", table); } else { PHALCON_CPY_WRT(complete_table, table); } /** * The table not exists */ PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSV(exception_message, "Cannot obtain table columns for the mapped source \"", complete_table, "\" used in model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * Initialize meta-data */ PHALCON_INIT_VAR(attributes); array_init(attributes); PHALCON_INIT_VAR(primary_keys); array_init(primary_keys); PHALCON_INIT_VAR(non_primary_keys); array_init(non_primary_keys); PHALCON_INIT_VAR(numeric_typed); array_init(numeric_typed); PHALCON_INIT_VAR(not_null); array_init(not_null); PHALCON_INIT_VAR(field_types); array_init(field_types); PHALCON_INIT_VAR(field_sizes); array_init(field_sizes); PHALCON_INIT_VAR(field_bytes); array_init(field_bytes); PHALCON_INIT_VAR(field_scales); array_init(field_scales); PHALCON_INIT_VAR(field_bind_types); array_init(field_bind_types); PHALCON_INIT_VAR(automatic_create_attributes); array_init(automatic_create_attributes); PHALCON_INIT_VAR(automatic_update_attributes); array_init(automatic_update_attributes); PHALCON_INIT_VAR(identity_field); ZVAL_FALSE(identity_field); PHALCON_INIT_VAR(field_default_values); array_init(field_default_values); phalcon_is_iterable(columns, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(column); PHALCON_CALL_METHOD(&field_name, column, "getname"); phalcon_array_append(&attributes, field_name, PH_SEPARATE); /** * To mark fields as primary keys */ PHALCON_CALL_METHOD(&feature, column, "isprimary"); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(&primary_keys, field_name, PH_COPY); } else { phalcon_array_append(&non_primary_keys, field_name, PH_COPY); } /** * To mark fields as numeric */ PHALCON_CALL_METHOD(&feature, column, "isnumeric"); if (PHALCON_IS_TRUE(feature)) { phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_COPY); } /** * To mark fields as not null */ PHALCON_CALL_METHOD(&feature, column, "isnotnull"); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(¬_null, field_name, PH_COPY); } /** * To mark fields as identity columns */ PHALCON_CALL_METHOD(&feature, column, "isautoincrement"); if (PHALCON_IS_TRUE(feature)) { PHALCON_CPY_WRT(identity_field, field_name); } /** * To get the internal types */ PHALCON_CALL_METHOD(&type, column, "gettype"); phalcon_array_update_zval(&field_types, field_name, type, PH_COPY); /** * To get the internal size */ PHALCON_CALL_METHOD(&size, column, "getsize"); phalcon_array_update_zval(&field_sizes, field_name, size, PH_COPY); /** * To get the internal bytes */ PHALCON_CALL_METHOD(&bytes, column, "getbytes"); phalcon_array_update_zval(&field_bytes, field_name, bytes, PH_COPY); /** * To get the internal scale */ PHALCON_CALL_METHOD(&scale, column, "getscale"); phalcon_array_update_zval(&field_scales, field_name, scale, PH_COPY); /** * To mark how the fields must be escaped */ PHALCON_CALL_METHOD(&bind_type, column, "getbindtype"); phalcon_array_update_zval(&field_bind_types, field_name, bind_type, PH_COPY); PHALCON_CALL_METHOD(&default_value, column, "getdefaultvalue"); if (Z_TYPE_P(default_value) != IS_NULL) { phalcon_array_update_zval(&field_default_values, field_name, default_value, PH_COPY); } zend_hash_move_forward_ex(ah0, &hp0); } /** * Create an array using the MODELS_* constants as indexes */ array_init_size(return_value, 14); phalcon_array_update_long(&return_value, 0, attributes, PH_COPY); phalcon_array_update_long(&return_value, 1, primary_keys, PH_COPY); phalcon_array_update_long(&return_value, 2, non_primary_keys, PH_COPY); phalcon_array_update_long(&return_value, 3, not_null, PH_COPY); phalcon_array_update_long(&return_value, 4, field_types, PH_COPY); phalcon_array_update_long(&return_value, 5, numeric_typed, PH_COPY); phalcon_array_update_long(&return_value, 8, identity_field, PH_COPY); phalcon_array_update_long(&return_value, 9, field_bind_types, PH_COPY); phalcon_array_update_long(&return_value, 10, automatic_create_attributes, PH_COPY); phalcon_array_update_long(&return_value, 11, automatic_update_attributes, PH_COPY); phalcon_array_update_long(&return_value, 12, field_default_values, PH_COPY); phalcon_array_update_long(&return_value, 13, field_sizes, PH_COPY); phalcon_array_update_long(&return_value, 14, field_scales, PH_COPY); phalcon_array_update_long(&return_value, 15, field_bytes, PH_COPY); PHALCON_MM_RESTORE(); }
/** * Sends SQL statements to the database server returning the success state. * Use this method only when the SQL statement sent to the server don't return any row * * //Inserting data * $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')"); * $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy')); * * @param string $sqlStatement * @param array $placeholders */ PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){ zval *sql_statement = NULL, *placeholders = NULL, *events_manager = NULL; zval *status = NULL, *pdo = NULL, *number_placeholders = NULL, *n = NULL, *statement = NULL; zval *value = NULL, *success = NULL, *affected_rows = NULL, *error_info = NULL; zval *error_message = NULL, *exception_message = NULL, *error_code = NULL; zval *exception = NULL; zval *c0 = NULL, *c1 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &sql_statement, &placeholders) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!placeholders) { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } PHALCON_INIT_VAR(events_manager); phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC); if (zend_is_true(events_manager)) { phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "db:beforeQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c0, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_INIT_VAR(pdo); phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC); PHALCON_INIT_VAR(number_placeholders); phalcon_fast_count(number_placeholders, placeholders TSRMLS_CC); if (zend_is_true(number_placeholders)) { PHALCON_INIT_VAR(n); ZVAL_LONG(n, 1); PHALCON_INIT_VAR(statement); PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK); if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(placeholders); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_7f5d_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_7f5d_1; } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", n, value, PH_NO_CHECK); PHALCON_SEPARATE(n); increment_function(n); zend_hash_move_forward_ex(ah0, &hp0); goto fes_7f5d_1; fee_7f5d_1: PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD(success, statement, "execute", PH_NO_CHECK); PHALCON_INIT_VAR(affected_rows); PHALCON_CALL_METHOD(affected_rows, statement, "rowcount", PH_NO_CHECK); } else { PHALCON_INIT_VAR(success); ZVAL_BOOL(success, 1); PHALCON_INIT_VAR(affected_rows); PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement, PH_NO_CHECK); } if (zend_is_true(success)) { if (Z_TYPE_P(affected_rows) == IS_LONG) { phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC); if (zend_is_true(events_manager)) { PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "db:afterQuery", 1); PHALCON_INIT_VAR(status); PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", c1, this_ptr, PH_NO_CHECK); if (Z_TYPE_P(status) == IS_BOOL && !Z_BVAL_P(status)) { PHALCON_MM_RESTORE(); RETURN_FALSE; } } PHALCON_MM_RESTORE(); RETURN_TRUE; } } PHALCON_INIT_VAR(error_info); PHALCON_CALL_METHOD(error_info, pdo, "errorinfo", PH_NO_CHECK); PHALCON_INIT_VAR(error_message); phalcon_array_fetch_long(&error_message, error_info, 2, PH_NOISY_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_VSV(exception_message, error_message, " when executing ", sql_statement); PHALCON_INIT_VAR(error_code); phalcon_array_fetch_long(&error_code, error_info, 1, PH_NOISY_CC); PHALCON_INIT_VAR(exception); object_init_ex(exception, phalcon_db_exception_ce); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", exception_message, error_code, PH_CHECK); phalcon_throw_exception(exception TSRMLS_CC); return; }
/** * Returns a MongoDb collection based on the backend parameters * * @return MongoCollection */ PHP_METHOD(Phalcon_Cache_Backend_Mongo, _getCollection){ zval *mongo_collection; zend_class_entry *ce0; PHALCON_MM_GROW(); mongo_collection = phalcon_read_property(getThis(), SL("_collection"), PH_NOISY); if (Z_TYPE_P(mongo_collection) != IS_OBJECT) { zval *options, *mongo; zval *server = NULL, *database = NULL, *collection = NULL; options = phalcon_read_property(getThis(), SL("_options"), PH_NOISY); /** * If mongo is defined a valid Mongo object must be passed */ if (phalcon_array_isset_str_fetch(&mongo, options, SL("mongo"))) { if (Z_TYPE_P(mongo) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The 'mongo' parameter must be a valid Mongo instance"); return; } } else { /** * Server must be defined otherwise */ phalcon_array_isset_str_fetch(&server, options, SL("server")); if (!server || Z_TYPE_P(server) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB connection string"); return; } ce0 = zend_fetch_class(SSL("MongoClient"), ZEND_FETCH_CLASS_AUTO); PHALCON_INIT_VAR(mongo); object_init_ex(mongo, ce0); assert(phalcon_has_constructor(mongo)); PHALCON_CALL_METHOD(NULL, mongo, "__construct", server); } /** * Check if the database name is a string */ phalcon_array_isset_str_fetch(&database, options, SL("db")); if (!database || Z_TYPE_P(database) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB db"); return; } /** * Retrieve the connection name */ phalcon_array_isset_str_fetch(&collection, options, SL("collection")); if (!collection || Z_TYPE_P(collection) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB collection"); return; } /** * Make the connection and get the collection */ PHALCON_RETURN_CALL_METHOD(mongo, "selectcollection", database, collection); } else { RETVAL_ZVAL(mongo_collection, 1, 0); } PHALCON_MM_RESTORE(); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_File, get){ zval *key_name, *lifetime = NULL, *backend, *front_end; zval *prefix, *filtered, *prefixed_key, *cache_dir; zval *cache_file, *time, *ttl = NULL, *modified_time, *difference; zval *not_expired, *cached_content, *processed; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } PHALCON_INIT_VAR(backend); phalcon_read_property(&backend, this_ptr, SL("_backendOptions"), PH_NOISY_CC); PHALCON_INIT_VAR(front_end); phalcon_read_property(&front_end, this_ptr, SL("_frontendObject"), PH_NOISY_CC); PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, filtered); phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, backend, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key); if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(time); PHALCON_CALL_FUNC(time, "time"); if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_INIT_VAR(ttl); PHALCON_CALL_METHOD(ttl, front_end, "getlifetime", PH_NO_CHECK); } else { PHALCON_CPY_WRT(ttl, lifetime); } PHALCON_INIT_VAR(modified_time); PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file); PHALCON_INIT_VAR(difference); sub_function(difference, time, ttl TSRMLS_CC); PHALCON_INIT_VAR(not_expired); is_smaller_function(not_expired, difference, modified_time TSRMLS_CC); if (PHALCON_IS_TRUE(not_expired)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file); PHALCON_INIT_VAR(processed); PHALCON_CALL_METHOD_PARAMS_1(processed, front_end, "afterretrieve", cached_content, PH_NO_CHECK); RETURN_CCTOR(processed); } } PHALCON_MM_RESTORE(); RETURN_NULL(); }