/**
* 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();
}
