/** * Removes an access from a resource * * @param string $resourceName * @param mixed $accessList */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, dropResourceAccess){ zval *resource_name, *access_list, *access_name = NULL; zval *access_key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &resource_name, &access_list); if (Z_TYPE_P(access_list) == IS_ARRAY) { phalcon_is_iterable(access_list, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(access_name); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access_name); phalcon_unset_property_array(this_ptr, SL("_accessList"), access_key TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } } else { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access_name); phalcon_unset_property_array(this_ptr, SL("_accessList"), access_key TSRMLS_CC); } PHALCON_MM_RESTORE(); }
/** * Adds access to resources * * @param string $resourceName * @param mixed $accessList */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, addResourceAccess){ zval *resource_name, *access_list, *resources_names; zval *exception_message, *exists, *internal_access_list; zval *access_name = NULL, *access_key = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &resource_name, &access_list); PHALCON_OBS_VAR(resources_names); phalcon_read_property_this(&resources_names, this_ptr, SL("_resourcesNames"), PH_NOISY_CC); if (!phalcon_array_isset(resources_names, resource_name)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource '", resource_name, "' does not exist in ACL"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } PHALCON_INIT_VAR(exists); ZVAL_BOOL(exists, 1); PHALCON_OBS_VAR(internal_access_list); phalcon_read_property_this(&internal_access_list, this_ptr, SL("_accessList"), PH_NOISY_CC); if (Z_TYPE_P(access_list) == IS_ARRAY) { phalcon_is_iterable(access_list, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(access_name); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access_name); if (!phalcon_array_isset(internal_access_list, access_key)) { phalcon_update_property_array(this_ptr, SL("_accessList"), access_key, exists TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } } else { if (Z_TYPE_P(access_list) == IS_STRING) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access_list); if (!phalcon_array_isset(internal_access_list, access_key)) { phalcon_update_property_array(this_ptr, SL("_accessList"), access_key, exists TSRMLS_CC); } } } RETURN_MM_TRUE; }
/** * Generates SQL to drop a table * * @param string $tableName * @param string $schemaName * @param boolean $ifExists * @return boolean */ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, dropTable){ zval *table_name = NULL, *schema_name = NULL, *if_exists = NULL, *table = NULL; zval *sql = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table_name, &schema_name, &if_exists) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!if_exists) { PHALCON_ALLOC_ZVAL_MM(if_exists); ZVAL_BOOL(if_exists, 1); } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(table); PHALCON_CONCAT_VSV(table, schema_name, ".", table_name); } else { PHALCON_CPY_WRT(table, table_name); } if (zend_is_true(if_exists)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SV(sql, "DROP TABLE IF EXISTS ", table); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SV(sql, "DROP TABLE ", table); } RETURN_CTOR(sql); }
/** * Generates SQL to drop a view * * @param string $viewName * @param string $schemaName * @param boolean $ifExists * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Sqlite, dropView){ zval *view_name, *schema_name, *if_exists = NULL, *view = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &view_name, &schema_name, &if_exists); if (!if_exists) { if_exists = &PHALCON_GLOBAL(z_true); } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(view); PHALCON_CONCAT_VSV(view, schema_name, "\".\"", view_name); } else { PHALCON_CPY_WRT(view, view_name); } if (zend_is_true(if_exists)) { PHALCON_CONCAT_SVS(return_value, "DROP VIEW IF EXISTS \"", view, "\""); } else { PHALCON_CONCAT_SVS(return_value, "DROP VIEW \"", view, "\""); } PHALCON_MM_RESTORE(); }
/** * Generates SQL to drop a table * * @param string $tableName * @param string $schemaName * @param boolean $ifExists * @return boolean */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, dropTable){ zval *table_name, *schema_name, *if_exists = NULL, *table = NULL; zval *sql = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &table_name, &schema_name, &if_exists); if (!if_exists) { PHALCON_INIT_VAR(if_exists); ZVAL_BOOL(if_exists, 1); } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(table); PHALCON_CONCAT_VSV(table, schema_name, ".", table_name); } else { PHALCON_CPY_WRT(table, table_name); } if (zend_is_true(if_exists)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SV(sql, "DROP TABLE IF EXISTS ", table); } else { PHALCON_INIT_NVAR(sql); PHALCON_CONCAT_SV(sql, "DROP TABLE ", table); } RETURN_CTOR(sql); }
/** * Escapes a column/table/schema name * * @param string $identifier * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, escapeIdentifier){ zval *identifier, *domain, *name; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &identifier); if (Z_TYPE_P(identifier) == IS_ARRAY) { PHALCON_OBS_VAR(domain); phalcon_array_fetch_long(&domain, identifier, 0, PH_NOISY); PHALCON_OBS_VAR(name); phalcon_array_fetch_long(&name, identifier, 1, PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_CONCAT_SVSVS(return_value, "`", domain, "`.`", name, "`"); RETURN_MM(); } PHALCON_CONCAT_VSV(return_value, domain, ".", name); RETURN_MM(); } if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_CONCAT_SVS(return_value, "`", identifier, "`"); RETURN_MM(); } RETURN_CCTOR(identifier); }
/** * Sets the response content-type mime, optionally the charset * *<code> * $response->setContentType('application/pdf'); * $response->setContentType('text/plain', 'UTF-8'); *</code> * * @param string $contentType * @param string $charset * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Http_Response, setContentType){ zval *content_type, *charset = NULL, *headers, *name, *header_value; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &content_type, &charset); if (!charset) { PHALCON_INIT_VAR(charset); } PHALCON_INIT_VAR(headers); phalcon_call_method(headers, this_ptr, "getheaders"); PHALCON_INIT_VAR(name); ZVAL_STRING(name, "Content-Type", 1); if (Z_TYPE_P(charset) == IS_NULL) { phalcon_call_method_p2_noret(headers, "set", name, content_type); } else { PHALCON_INIT_VAR(header_value); PHALCON_CONCAT_VSV(header_value, content_type, "; charset=", charset); phalcon_call_method_p2_noret(headers, "set", name, header_value); } RETURN_THIS(); }
/** * Generates the SQL for LIMIT clause * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect, limit){ zval *sql_query = NULL, *number = NULL, *is_numeric = NULL, *limit = NULL, *sql_limit = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_query, &number) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(is_numeric); PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", number); if (Z_TYPE_P(is_numeric) == IS_BOOL && Z_BVAL_P(is_numeric)) { PHALCON_INIT_VAR(limit); PHALCON_CALL_FUNC_PARAMS_1(limit, "intval", number); PHALCON_INIT_VAR(sql_limit); PHALCON_CONCAT_VSV(sql_limit, sql_query, " LIMIT ", limit); RETURN_CTOR(sql_limit); } RETURN_CCTOR(sql_query); }
/** * Sets the HTTP response code * *<code> * $response->setStatusCode(404, "Not Found"); *</code> * * @param int $code * @param string $message * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Http_Response, setStatusCode){ zval *code, *message, *headers, *header_value, *status_value; zval *status_header; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &code, &message) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(headers); PHALCON_CALL_METHOD(headers, this_ptr, "getheaders"); /** * We use HTTP/1.1 instead of HTTP/1.0 */ PHALCON_INIT_VAR(header_value); PHALCON_CONCAT_SVSV(header_value, "HTTP/1.1 ", code, " ", message); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(headers, "setraw", header_value); /** * We also define a 'Status' header with the HTTP status */ PHALCON_INIT_VAR(status_value); PHALCON_CONCAT_VSV(status_value, code, " ", message); PHALCON_INIT_VAR(status_header); ZVAL_STRING(status_header, "Status", 1); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(headers, "set", status_header, status_value); phalcon_update_property_zval(this_ptr, SL("_headers"), headers TSRMLS_CC); RETURN_THIS(); }
/** * Generates SQL to drop a table * * @param string $tableName * @param string $schemaName * @param boolean $ifExists * @return boolean */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, dropTable){ zval *table_name, *schema_name, *if_exists = NULL, *table = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 1, &table_name, &schema_name, &if_exists); if (!if_exists) { if_exists = PHALCON_GLOBAL(z_true); } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(table); PHALCON_CONCAT_VSV(table, schema_name, ".", table_name); } else { PHALCON_CPY_WRT(table, table_name); } if (zend_is_true(if_exists)) { PHALCON_CONCAT_SV(return_value, "DROP TABLE IF EXISTS ", table); } else { PHALCON_CONCAT_SV(return_value, "DROP TABLE ", table); } PHALCON_MM_RESTORE(); }
/** * Generates SQL to create a view * * @param string $viewName * @param array $definition * @param string $schemaName * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, createView){ zval *view_name, *definition, *schema_name, *view_sql; zval *view = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 3, 0, &view_name, &definition, &schema_name); if (!phalcon_array_isset_string(definition, SS("sql"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'sql' is required in the definition array"); return; } PHALCON_OBS_VAR(view_sql); phalcon_array_fetch_string(&view_sql, definition, SL("sql"), PH_NOISY); if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(view); PHALCON_CONCAT_VSV(view, view_name, ".", schema_name); } else { PHALCON_CPY_WRT(view, view_name); } PHALCON_CONCAT_SVSV(return_value, "CREATE VIEW ", view, " AS ", view_sql); PHALCON_MM_RESTORE(); }
/** * Sets the response content-type mime, optionally the charset * *<code> * $response->setContentType('application/pdf'); * $response->setContentType('text/plain', 'UTF-8'); *</code> * * @param string $contentType * @param string $charset * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Http_Response, setContentType){ zval *content_type, *charset = NULL, *headers, *name, *header_value; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &content_type, &charset) == FAILURE) { RETURN_MM_NULL(); } if (!charset) { PHALCON_INIT_VAR(charset); } PHALCON_INIT_VAR(headers); PHALCON_CALL_METHOD(headers, this_ptr, "getheaders"); PHALCON_INIT_VAR(name); ZVAL_STRING(name, "Content-Type", 1); if (Z_TYPE_P(charset) == IS_NULL) { PHALCON_CALL_METHOD_PARAMS_2_NORETURN(headers, "set", name, content_type); } else { PHALCON_INIT_VAR(header_value); PHALCON_CONCAT_VSV(header_value, content_type, "; charset=", charset); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(headers, "set", name, header_value); } RETURN_THIS(); }
/** * Sets the HTTP response code * *<code> * $response->setStatusCode(404, "Not Found"); *</code> * * @param int $code * @param string $message * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Http_Response, setStatusCode){ zval *code, *message, *headers, *header_value, *status_value; zval *status_header; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &code, &message); PHALCON_INIT_VAR(headers); phalcon_call_method(headers, this_ptr, "getheaders"); /** * We use HTTP/1.1 instead of HTTP/1.0 */ PHALCON_INIT_VAR(header_value); PHALCON_CONCAT_SVSV(header_value, "HTTP/1.1 ", code, " ", message); phalcon_call_method_p1_noret(headers, "setraw", header_value); /** * We also define a 'Status' header with the HTTP status */ PHALCON_INIT_VAR(status_value); PHALCON_CONCAT_VSV(status_value, code, " ", message); PHALCON_INIT_VAR(status_header); ZVAL_STRING(status_header, "Status", 1); phalcon_call_method_p2_noret(headers, "set", status_header, status_value); phalcon_update_property_this(this_ptr, SL("_headers"), headers TSRMLS_CC); RETURN_THIS(); }
/** * Generates the SQL for a MySQL LIMIT clause * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, limit){ zval *sql_query = NULL, *number = NULL, *limit = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_query, &number) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_FUNC_PARAMS_1(r0, "is_numeric", number); if (zend_is_true(r0)) { PHALCON_INIT_VAR(limit); PHALCON_CALL_FUNC_PARAMS_1(limit, "intval", number); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_VSV(r1, sql_query, " LIMIT ", limit); RETURN_CTOR(r1); } else { RETURN_CCTOR(sql_query); } PHALCON_MM_RESTORE(); }
/** * Sends the headers to the client * * @return boolean */ PHP_METHOD(Phalcon_Http_Response_Headers, send){ zval *headers_was_sent, *t, *headers, *value = NULL, *header = NULL; zval *http_header = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; PHALCON_MM_GROW(); PHALCON_INIT_VAR(headers_was_sent); PHALCON_CALL_FUNC(headers_was_sent, "headers_sent"); if (!zend_is_true(headers_was_sent)) { PHALCON_INIT_VAR(t); ZVAL_BOOL(t, 1); PHALCON_INIT_VAR(headers); phalcon_read_property(&headers, this_ptr, SL("_headers"), PH_NOISY_CC); if (!phalcon_valid_foreach(headers TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(headers); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_KEY(header, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (zend_is_true(value)) { PHALCON_INIT_NVAR(http_header); PHALCON_CONCAT_VSV(http_header, header, ": ", value); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("header", http_header, t); } else { PHALCON_CALL_FUNC_PARAMS_2_NORETURN("header", header, t); } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_MM_RESTORE(); RETURN_TRUE; } PHALCON_MM_RESTORE(); RETURN_FALSE; }
/** * Sends the headers to the client * * @return boolean */ PHP_METHOD(Phalcon_Http_Response_Headers, send){ zval *headers, *value = NULL, *header = NULL; zval *http_header = NULL; zval copy; int use_copy; HashTable *ah0; HashPosition hp0; zval **hd; sapi_header_line ctr = { NULL, 0, 0 }; PHALCON_MM_GROW(); if (!SG(headers_sent)) { PHALCON_OBS_VAR(headers); phalcon_read_property_this(&headers, this_ptr, SL("_headers"), PH_NOISY_CC); phalcon_is_iterable(headers, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(header, ah0, hp0); PHALCON_GET_HVALUE(value); if (PHALCON_IS_NOT_EMPTY(value)) { PHALCON_INIT_NVAR(http_header); PHALCON_CONCAT_VSV(http_header, header, ": ", value); ctr.line = Z_STRVAL_P(http_header); ctr.line_len = Z_STRLEN_P(http_header); sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC); } else { zend_make_printable_zval(header, ©, &use_copy); if (unlikely(use_copy)) { header = © } ctr.line = Z_STRVAL_P(header); ctr.line_len = Z_STRLEN_P(header); sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC); if (unlikely(use_copy)) { zval_dtor(©); } } zend_hash_move_forward_ex(ah0, &hp0); } RETURN_MM_TRUE; } RETURN_MM_FALSE; }
/** * Returns uri * * @return string */ PHP_METHOD(Phalcon_Http_Uri, build){ zval *parts, *uri, *scheme, *host, *user, *pass, *port, *path, *query, *fragment, *tmp = NULL; PHALCON_MM_GROW(); parts = phalcon_read_property(getThis(), SL("_parts"), PH_NOISY); PHALCON_INIT_VAR(uri); if (phalcon_array_isset_str_fetch(&scheme, parts, SL("scheme")) && PHALCON_IS_NOT_EMPTY(scheme)) { if (phalcon_array_isset_str_fetch(&host, parts, SL("host")) && PHALCON_IS_NOT_EMPTY(host)) { if (phalcon_array_isset_str_fetch(&user, parts, SL("user")) && PHALCON_IS_NOT_EMPTY(user)) { if (phalcon_array_isset_str_fetch(&pass, parts, SL("pass")) && PHALCON_IS_NOT_EMPTY(pass)) { PHALCON_CONCAT_VSVSVSV(uri, scheme, "://", user, ":", pass, "@", host); } else { PHALCON_CONCAT_VSVSV(uri, scheme, "://", user, "@", host); } } else { PHALCON_CONCAT_VSV(uri, scheme, "://", host); } } else { PHALCON_CONCAT_VS(uri, scheme, ":"); } } if (phalcon_array_isset_str_fetch(&port, parts, SL("port")) && PHALCON_IS_NOT_EMPTY(port)) { PHALCON_SCONCAT_SV(uri, ":", port); } if (phalcon_array_isset_str_fetch(&path, parts, SL("path")) && PHALCON_IS_NOT_EMPTY(path)) { if (!phalcon_start_with_str(path, SL("/"))) { PHALCON_SCONCAT_SV(uri, "/", path); } else { PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VV(tmp, uri, path); PHALCON_CPY_WRT(uri, tmp); } } if (phalcon_array_isset_str_fetch(&query, parts, SL("query")) && PHALCON_IS_NOT_EMPTY(query)) { PHALCON_INIT_NVAR(tmp); phalcon_http_build_query(tmp, query, "&"); PHALCON_SCONCAT_SV(uri, "?", tmp); } if (phalcon_array_isset_str_fetch(&fragment, parts, SL("fragment")) && PHALCON_IS_NOT_EMPTY(fragment)) { PHALCON_SCONCAT_SV(uri, "#", fragment); } RETURN_CTOR(uri); }
/** * Generates the SQL for LIMIT clause * *<code> * $sql = $dialect->limit('SELECT * FROM robots', 10); * echo $sql; // SELECT * FROM robots LIMIT 10 *</code> * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect, limit){ zval *sql_query, *number, limit = {}; phalcon_fetch_params(0, 2, 0, &sql_query, &number); if (phalcon_is_numeric(number)) { ZVAL_LONG(&limit, phalcon_get_intval(number)); PHALCON_CONCAT_VSV(return_value, sql_query, " LIMIT ", &limit); return; } RETURN_CTORW(sql_query); }
/** * Generates the SQL for LIMIT clause * *<code> * $sql = $dialect->limit('SELECT * FROM robots', 10); * echo $sql; // SELECT * FROM robots LIMIT 10 *</code> * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect, limit){ zval *sql_query, *number, *limit; phalcon_fetch_params(1, 2, 0, &sql_query, &number); if (phalcon_is_numeric(number)) { PHALCON_MM_GROW(); PHALCON_INIT_VAR(limit); ZVAL_LONG(limit, phalcon_get_intval(number)); PHALCON_CONCAT_VSV(return_value, sql_query, " LIMIT ", limit); RETURN_MM(); } RETURN_ZVAL(sql_query, 1, 0); }
/** * Returns uri * * @return string */ PHP_METHOD(Phalcon_Http_Uri, build) { zval parts = {}, uri = {}, scheme = {}, host = {}, user = {}, pass = {}, port = {}, path = {}, query = {}, fragment = {}, tmp = {}; phalcon_read_property(&parts, getThis(), SL("_parts"), PH_NOISY); if (phalcon_array_isset_fetch_str(&scheme, &parts, SL("scheme")) && PHALCON_IS_NOT_EMPTY(&scheme)) { if (phalcon_array_isset_fetch_str(&host, &parts, SL("host")) && PHALCON_IS_NOT_EMPTY(&host)) { if (phalcon_array_isset_fetch_str(&user, &parts, SL("user")) && PHALCON_IS_NOT_EMPTY(&user)) { if (phalcon_array_isset_fetch_str(&pass, &parts, SL("pass")) && PHALCON_IS_NOT_EMPTY(&pass)) { PHALCON_CONCAT_VSVSVSV(&uri, &scheme, "://", &user, ":", &pass, "@", &host); } else { PHALCON_CONCAT_VSVSV(&uri, &scheme, "://", &user, "@", &host); } } else { PHALCON_CONCAT_VSV(&uri, &scheme, "://", &host); } } else { PHALCON_CONCAT_VS(&uri, &scheme, ":"); } } if (phalcon_array_isset_fetch_str(&port, &parts, SL("port")) && PHALCON_IS_NOT_EMPTY(&port)) { PHALCON_SCONCAT_SV(&uri, ":", &port); } if (phalcon_array_isset_fetch_str(&path, &parts, SL("path")) && PHALCON_IS_NOT_EMPTY(&path)) { if (!phalcon_start_with_str(&path, SL("/"))) { PHALCON_SCONCAT_SV(&uri, "/", &path); } else { PHALCON_SCONCAT(&uri, &path); } } if (phalcon_array_isset_fetch_str(&query, &parts, SL("query")) && PHALCON_IS_NOT_EMPTY(&query)) { phalcon_http_build_query(&tmp, &query, "&"); PHALCON_SCONCAT_SV(&uri, "?", &tmp); } if (phalcon_array_isset_fetch_str(&fragment, &parts, SL("fragment")) && PHALCON_IS_NOT_EMPTY(&fragment)) { PHALCON_SCONCAT_SV(&uri, "#", &fragment); } RETURN_CTORW(&uri); }
/** * Generates the SQL for LIMIT clause * *<code> * $sql = $dialect->limit('SELECT * FROM robots', 10); * echo $sql; // SELECT * FROM robots LIMIT 10 *</code> * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, limit){ zval *sql_query, *number, *limit, *sql_limit; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_query, &number) == FAILURE) { RETURN_MM_NULL(); } if (phalcon_is_numeric(number)) { PHALCON_INIT_VAR(limit); ZVAL_LONG(limit, phalcon_get_intval(number)); PHALCON_INIT_VAR(sql_limit); PHALCON_CONCAT_VSV(sql_limit, sql_query, " LIMIT ", limit); RETURN_CTOR(sql_limit); } RETURN_CTOR(sql_query); }
/** * Generates the SQL for LIMIT clause * *<code> * $sql = $dialect->limit('SELECT * FROM robots', 10); * echo $sql; // SELECT * FROM robots LIMIT 10 *</code> * * @param string $sqlQuery * @param int $number * @return string */ PHP_METHOD(Phalcon_Db_Dialect, limit){ zval *sql_query, *number, *is_numeric, *limit, *sql_limit; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &sql_query, &number) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(is_numeric); PHALCON_CALL_FUNC_PARAMS_1(is_numeric, "is_numeric", number); if (PHALCON_IS_TRUE(is_numeric)) { PHALCON_INIT_VAR(limit); PHALCON_CALL_FUNC_PARAMS_1(limit, "intval", number); PHALCON_INIT_VAR(sql_limit); PHALCON_CONCAT_VSV(sql_limit, sql_query, " LIMIT ", limit); RETURN_CTOR(sql_limit); } RETURN_CCTOR(sql_query); }
/** * Builds a SELECT statement * * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, select){ zval *definition, *escape_char = NULL, *columns, *selected_columns, *distinct; zval *column = NULL, *column_item = NULL, *column_sql = NULL, *columns_sql = NULL; zval *column_domain = NULL, *column_domain_sql = NULL, *column_alias = NULL; zval *column_alias_sql = NULL, *tables, *selected_tables; zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins; zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL; zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL; zval *join_conditions = NULL, *where_conditions; zval *where_expression = NULL, *group_items, *group_fields; zval *group_field = NULL, *group_expression = NULL, *group_sql; zval *group_clause, *having_conditions, *having_expression = NULL; zval *order_fields, *order_items, *order_item = NULL; zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL; zval *order_sql_item_type = NULL, *order_sql, *limit_value; zval *number, *offset, *tmp1 = NULL, *tmp2 = NULL; zval *z_one, *ini_range, *end_range = NULL, *sql_limit; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5; HashPosition hp0, hp1, hp2, hp3, hp4, hp5; zval **hd; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { RETURN_NULL(); } if (Z_TYPE_P(definition) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "Invalid SELECT definition"); return; } if (!phalcon_array_isset_string(definition, SS("tables"))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'tables' is required in the definition array"); return; } if (!phalcon_array_isset_string(definition, SS("columns"))) { PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } PHALCON_MM_GROW(); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_OBS_VAR(escape_char); phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC); } else { PHALCON_INIT_NVAR(escape_char); } PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY); if (Z_TYPE_P(columns) == IS_ARRAY) { PHALCON_INIT_VAR(selected_columns); array_init(selected_columns); phalcon_is_iterable(columns, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(column); /** * Escape column name */ PHALCON_OBS_NVAR(column_item); phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY); if (Z_TYPE_P(column_item) == IS_ARRAY) { PHALCON_CALL_METHOD(&column_sql, this_ptr, "getsqlexpression", column_item, escape_char); } else if (PHALCON_IS_STRING(column_item, "*")) { PHALCON_CPY_WRT(column_sql, column_item); } else if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char); } else { PHALCON_CPY_WRT(columns_sql, column_item); } /** * Escape column domain */ if (phalcon_array_isset_long(column, 1)) { PHALCON_OBS_NVAR(column_domain); phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY); if (zend_is_true(column_domain)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql); } else { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } /** * Escape column alias */ if (phalcon_array_isset_long(column, 2)) { PHALCON_OBS_NVAR(column_alias); phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY); if (zend_is_true(column_alias)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " ", escape_char, column_alias, escape_char); } else { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " ", column_alias); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(columns_sql); phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC); } else { PHALCON_CPY_WRT(columns_sql, columns); } /** * Check and escape tables */ PHALCON_OBS_VAR(tables); phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY); if (Z_TYPE_P(tables) == IS_ARRAY) { PHALCON_INIT_VAR(selected_tables); array_init(selected_tables); phalcon_is_iterable(tables, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(table); PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(tables_sql); phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC); } else { PHALCON_CPY_WRT(tables_sql, tables); } PHALCON_INIT_VAR(sql); if (phalcon_array_isset_string_fetch(&distinct, definition, SS("definition"))) { assert(Z_TYPE_P(distinct) == IS_LONG); if (Z_LVAL_P(distinct) == 0) { ZVAL_STRING(sql, "SELECT ALL ", 1); } else if (Z_LVAL_P(distinct) == 1) { ZVAL_STRING(sql, "SELECT DISTINCT ", 1); } else { ZVAL_STRING(sql, "SELECT ", 1); } } else { ZVAL_STRING(sql, "SELECT ", 1); } /** * Check for joins */ if (phalcon_array_isset_string(definition, SS("joins"))) { PHALCON_OBS_VAR(joins); phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY); phalcon_is_iterable(joins, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HVALUE(join); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY); PHALCON_OBS_NVAR(table); phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY); PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE); PHALCON_INIT_NVAR(sql_join); PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table); /** * Check if the join has conditions */ if (phalcon_array_isset_string(join, SS("conditions"))) { PHALCON_OBS_NVAR(join_conditions_array); phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY); if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) { PHALCON_INIT_NVAR(join_expressions); array_init(join_expressions); phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0); while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_HVALUE(join_condition); PHALCON_CALL_METHOD(&join_expression, this_ptr, "getsqlexpression", join_condition, escape_char); phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah3, &hp3); } PHALCON_INIT_NVAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC); PHALCON_SCONCAT_SV(sql_join, " ON ", join_conditions); } } phalcon_concat_self(&sql, sql_join TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } } /** * Check for a WHERE clause */ if (phalcon_array_isset_string(definition, SS("where"))) { PHALCON_OBS_VAR(where_conditions); phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY); if (Z_TYPE_P(where_conditions) == IS_ARRAY) { PHALCON_CALL_METHOD(&where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression); } else { PHALCON_SCONCAT_SV(sql, " WHERE ", where_conditions); } } /** * Check for a GROUP clause */ if (phalcon_array_isset_string(definition, SS("group"))) { PHALCON_INIT_VAR(group_items); array_init(group_items); PHALCON_OBS_VAR(group_fields); phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY); phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0); while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_HVALUE(group_field); PHALCON_CALL_METHOD(&group_expression, this_ptr, "getsqlexpression", group_field, escape_char); phalcon_array_append(&group_items, group_expression, PH_SEPARATE); zend_hash_move_forward_ex(ah4, &hp4); } PHALCON_INIT_VAR(group_sql); phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC); PHALCON_INIT_VAR(group_clause); PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql); phalcon_concat_self(&sql, group_clause TSRMLS_CC); } /** * Check for a HAVING clause */ if (phalcon_array_isset_string(definition, SS("having"))) { PHALCON_OBS_VAR(having_conditions); phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY); PHALCON_CALL_METHOD(&having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression); } /** * Check for a ORDER clause */ if (phalcon_array_isset_string(definition, SS("order"))) { PHALCON_OBS_VAR(order_fields); phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY); PHALCON_INIT_VAR(order_items); array_init(order_items); phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0); while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) { PHALCON_GET_HVALUE(order_item); PHALCON_OBS_NVAR(order_expression); phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY); PHALCON_CALL_METHOD(&order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char); /** * In the numeric 1 position could be a ASC/DESC clause */ if (phalcon_array_isset_long(order_item, 1)) { PHALCON_OBS_NVAR(sql_order_type); phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY); PHALCON_INIT_NVAR(order_sql_item_type); PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type); } else { PHALCON_CPY_WRT(order_sql_item_type, order_sql_item); } phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE); zend_hash_move_forward_ex(ah5, &hp5); } PHALCON_INIT_VAR(order_sql); phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC); PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql); } /** * Oracle does not implement the LIMIT clause as some RDBMS do. * We have to simulate it with subqueries and ROWNUM. * Unfortunately because we use the column wildcard "*", * this puts an extra column into the query result set. */ if (phalcon_array_isset_string_fetch(&limit_value, definition, SS("limit"))) { if (likely(Z_TYPE_P(limit_value) == IS_ARRAY)) { if (likely(phalcon_array_isset_string_fetch(&number, limit_value, SS("number")))) { PHALCON_OBS_NVAR(tmp1); phalcon_array_fetch_string(&tmp1, number, SL("value"), PH_NOISY); if (phalcon_array_isset_string_fetch(&offset, limit_value, SS("offset"))) { PHALCON_OBS_NVAR(tmp2); phalcon_array_fetch_string(&tmp2, offset, SL("value"), PH_NOISY); } else { PHALCON_INIT_NVAR(tmp2); ZVAL_LONG(tmp2, 0); } z_one = PHALCON_GLOBAL(z_one); PHALCON_INIT_VAR(ini_range); phalcon_add_function(ini_range, tmp2, z_one TSRMLS_CC); PHALCON_INIT_VAR(end_range); phalcon_add_function(end_range, tmp2, tmp1 TSRMLS_CC); PHALCON_INIT_VAR(sql_limit); PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range ); PHALCON_CPY_WRT(sql, sql_limit); } } else { PHALCON_INIT_VAR(ini_range); ZVAL_LONG(ini_range, 1); PHALCON_CPY_WRT(end_range, limit_value); PHALCON_INIT_VAR(sql_limit); PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range ); PHALCON_CPY_WRT(sql, sql_limit); } } RETURN_CTOR(sql); }
/** * Transform an intermediate representation for a schema/table into a database system valid expression * * @param array $table * @param string $escapeChar * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Oracle, getSqlTable){ zval *table, *escape_char = NULL, *table_name, *sql_table = NULL; zval *schema_name, *sql_schema = NULL, *alias_name; zval *sql_table_alias = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &table, &escape_char); if (!escape_char) { PHALCON_INIT_VAR(escape_char); } else { PHALCON_SEPARATE_PARAM(escape_char); } if (Z_TYPE_P(escape_char) == IS_NULL) { PHALCON_OBS_NVAR(escape_char); phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC); } if (Z_TYPE_P(table) == IS_ARRAY) { /** * The index '0' is the table name */ PHALCON_OBS_VAR(table_name); phalcon_array_fetch_long(&table_name, table, 0, PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_table); PHALCON_CONCAT_VVV(sql_table, escape_char, table_name, escape_char); } else { PHALCON_CPY_WRT(sql_table, table_name); } /** * The index '1' is the schema name */ PHALCON_OBS_VAR(schema_name); phalcon_array_fetch_long(&schema_name, table, 1, PH_NOISY); if (Z_TYPE_P(schema_name) != IS_NULL) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_schema); PHALCON_CONCAT_VVVSV(sql_schema, escape_char, schema_name, escape_char, ".", sql_table); } else { PHALCON_INIT_NVAR(sql_schema); PHALCON_CONCAT_VSV(sql_schema, schema_name, ".", sql_table); } } else { PHALCON_CPY_WRT(sql_schema, sql_table); } /** * The index '2' is the table alias */ if (phalcon_array_isset_long(table, 2)) { PHALCON_OBS_VAR(alias_name); phalcon_array_fetch_long(&alias_name, table, 2, PH_NOISY); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(sql_table_alias); PHALCON_CONCAT_VSVVV(sql_table_alias, sql_schema, " ", escape_char, alias_name, escape_char); } else { PHALCON_INIT_NVAR(sql_table_alias); PHALCON_CONCAT_VSV(sql_table_alias, sql_schema, " ", alias_name); } } else { PHALCON_CPY_WRT(sql_table_alias, sql_schema); } RETURN_CTOR(sql_table_alias); } if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(sql_table); PHALCON_CONCAT_VVV(sql_table, escape_char, table, escape_char); RETURN_CTOR(sql_table); } RETURN_CTOR(table); }
/** * Transforms an intermediate representation for a expression into a database system valid expression * * @param array $expression * @param string $escapeChar * @return string */ PHP_METHOD(Phalcon_Db_Dialect, getSqlExpression){ zval *expression, *escape_char = NULL, *type, *name = NULL, *escaped_name = NULL; zval *domain, *escaped_domain = NULL, *value = NULL, *operator = NULL; zval *left = NULL, *expression_left = NULL, *right = NULL, *expression_right = NULL; zval *binary_expr, *unary_expr = NULL, *expression_group; zval *sql_arguments, *arguments, *argument = NULL, *argument_expression = NULL; zval *arguments_joined, *function_expression = NULL; zval *sql_items, *items, *item = NULL, *item_expression = NULL; zval *list_expression, *group_expression; zval *exception_message; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &expression, &escape_char) == FAILURE) { RETURN_MM_NULL(); } if (!escape_char) { PHALCON_INIT_VAR(escape_char); } else { PHALCON_SEPARATE_PARAM(escape_char); } if (PHALCON_GLOBAL(db).escape_identifiers) { if (Z_TYPE_P(escape_char) == IS_NULL) { PHALCON_OBS_NVAR(escape_char); phalcon_read_property(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC); } } if (Z_TYPE_P(expression) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression"); return; } if (!phalcon_array_isset_string(expression, SS("type"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression"); return; } PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, expression, SL("type"), PH_NOISY_CC); /** * Resolve qualified expressions */ if (PHALCON_IS_STRING(type, "qualified")) { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY_CC); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(escaped_name); PHALCON_CONCAT_VVV(escaped_name, escape_char, name, escape_char); } else { PHALCON_CPY_WRT(escaped_name, name); } /** * A domain could be a table/schema */ if (phalcon_array_isset_string(expression, SS("domain"))) { PHALCON_OBS_VAR(domain); phalcon_array_fetch_string(&domain, expression, SL("domain"), PH_NOISY_CC); if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_VAR(escaped_domain); PHALCON_CONCAT_VVVSV(escaped_domain, escape_char, domain, escape_char, ".", escaped_name); } else { PHALCON_INIT_NVAR(escaped_domain); PHALCON_CONCAT_VSV(escaped_domain, domain, ".", escaped_name); } RETURN_CTOR(escaped_domain); } RETURN_CCTOR(escaped_name); } /** * Resolve literal expressions */ if (PHALCON_IS_STRING(type, "literal")) { PHALCON_OBS_VAR(value); phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); } /** * Resolve binary operations expressions */ if (PHALCON_IS_STRING(type, "binary-op")) { PHALCON_OBS_VAR(operator); phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY_CC); PHALCON_OBS_VAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC); PHALCON_INIT_VAR(expression_left); PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_OBS_VAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY_CC); PHALCON_INIT_VAR(expression_right); PHALCON_CALL_METHOD_PARAMS_2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_INIT_VAR(binary_expr); PHALCON_CONCAT_VSVSV(binary_expr, expression_left, " ", operator, " ", expression_right); RETURN_CTOR(binary_expr); } /** * Resolve unary operations expressions */ if (PHALCON_IS_STRING(type, "unary-op")) { PHALCON_OBS_NVAR(operator); phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY_CC); /** * Some unary operators uses the left operand... */ if (phalcon_array_isset_string(expression, SS("left"))) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC); PHALCON_INIT_NVAR(expression_left); PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_INIT_VAR(unary_expr); PHALCON_CONCAT_VV(unary_expr, expression_left, operator); RETURN_CTOR(unary_expr); } /** * ...Others uses the right operand */ if (phalcon_array_isset_string(expression, SS("right"))) { PHALCON_OBS_NVAR(right); phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY_CC); PHALCON_INIT_NVAR(expression_right); PHALCON_CALL_METHOD_PARAMS_2(expression_right, this_ptr, "getsqlexpression", right, escape_char); PHALCON_INIT_NVAR(unary_expr); PHALCON_CONCAT_VV(unary_expr, operator, expression_right); RETURN_CTOR(unary_expr); } } /** * Resolve placeholder */ if (PHALCON_IS_STRING(type, "placeholder")) { PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY_CC); RETURN_CCTOR(value); } /** * Resolve parentheses */ if (PHALCON_IS_STRING(type, "parentheses")) { PHALCON_OBS_NVAR(left); phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC); PHALCON_INIT_NVAR(expression_left); PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char); PHALCON_INIT_VAR(expression_group); PHALCON_CONCAT_SVS(expression_group, "(", expression_left, ")"); RETURN_CTOR(expression_group); } /** * Resolve function calls */ if (PHALCON_IS_STRING(type, "functionCall")) { PHALCON_OBS_NVAR(name); phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY_CC); PHALCON_INIT_VAR(sql_arguments); array_init(sql_arguments); if (phalcon_array_isset_string(expression, SS("arguments"))) { PHALCON_OBS_VAR(arguments); phalcon_array_fetch_string(&arguments, expression, SL("arguments"), PH_NOISY_CC); if (!phalcon_is_iterable(arguments, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(argument); PHALCON_INIT_NVAR(argument_expression); PHALCON_CALL_METHOD_PARAMS_2(argument_expression, this_ptr, "getsqlexpression", argument, escape_char); phalcon_array_append(&sql_arguments, argument_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(arguments_joined); phalcon_fast_join_str(arguments_joined, SL(", "), sql_arguments TSRMLS_CC); PHALCON_INIT_VAR(function_expression); PHALCON_CONCAT_VSVS(function_expression, name, "(", arguments_joined, ")"); } else { PHALCON_INIT_NVAR(function_expression); PHALCON_CONCAT_VS(function_expression, name, "()"); } RETURN_CTOR(function_expression); } /** * Resolve lists */ if (PHALCON_IS_STRING(type, "list")) { PHALCON_INIT_VAR(sql_items); array_init(sql_items); PHALCON_OBS_VAR(items); phalcon_array_fetch_long(&items, expression, 0, PH_NOISY_CC); if (!phalcon_is_iterable(items, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(item); PHALCON_INIT_NVAR(item_expression); PHALCON_CALL_METHOD_PARAMS_2(item_expression, this_ptr, "getsqlexpression", item, escape_char); phalcon_array_append(&sql_items, item_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(list_expression); phalcon_fast_join_str(list_expression, SL(", "), sql_items TSRMLS_CC); PHALCON_INIT_VAR(group_expression); PHALCON_CONCAT_SVS(group_expression, "(", list_expression, ")"); RETURN_CTOR(group_expression); } /** * Resolve * */ if (PHALCON_IS_STRING(type, "all")) { PHALCON_MM_RESTORE(); RETURN_STRING("*", 1); } /** * Expression type wasn't found */ PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Invalid SQL expression type '", type, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message); return; }
/** * Builds a SELECT statement * * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect, select){ zval *definition, *escape_char = NULL, *columns, *selected_columns; zval *column = NULL, *column_item = NULL, *column_sql = NULL, *columns_sql = NULL; zval *column_domain = NULL, *column_domain_sql = NULL, *column_alias = NULL; zval *column_alias_sql = NULL, *tables, *selected_tables; zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins; zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL; zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL; zval *join_conditions = NULL, *where_conditions; zval *where_expression, *group_items, *group_fields; zval *group_field = NULL, *group_expression = NULL, *group_sql; zval *group_clause, *having_conditions, *having_expression; zval *order_fields, *order_items, *order_item = NULL; zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL; zval *order_sql_item_type = NULL, *order_sql, *limit_value; zval *number, *offset; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5; HashPosition hp0, hp1, hp2, hp3, hp4, hp5; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { RETURN_MM_NULL(); } if (Z_TYPE_P(definition) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SELECT definition"); return; } if (!phalcon_array_isset_string(definition, SS("tables"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'tables' is required in the definition array"); return; } if (!phalcon_array_isset_string(definition, SS("columns"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_OBS_VAR(escape_char); phalcon_read_property(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC); } else { PHALCON_INIT_NVAR(escape_char); } PHALCON_OBS_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC); if (Z_TYPE_P(columns) == IS_ARRAY) { PHALCON_INIT_VAR(selected_columns); array_init(selected_columns); if (!phalcon_is_iterable(columns, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(column); /** * Escape column name */ PHALCON_OBS_NVAR(column_item); phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY_CC); if (Z_TYPE_P(column_item) == IS_ARRAY) { PHALCON_INIT_NVAR(column_sql); PHALCON_CALL_METHOD_PARAMS_2(column_sql, this_ptr, "getsqlexpression", column_item, escape_char); } else { if (PHALCON_IS_STRING(column_item, "*")) { PHALCON_CPY_WRT(column_sql, column_item); } else { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_sql); PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char); } else { PHALCON_CPY_WRT(columns_sql, column_item); } } } /** * Escape column domain */ PHALCON_OBS_NVAR(column_domain); phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY_CC); if (zend_is_true(column_domain)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql); } else { PHALCON_INIT_NVAR(column_domain_sql); PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql); } } else { PHALCON_CPY_WRT(column_domain_sql, column_sql); } /** * Escape column alias */ if (phalcon_array_isset_long(column, 2)) { PHALCON_OBS_NVAR(column_alias); phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY_CC); if (zend_is_true(column_alias)) { if (PHALCON_GLOBAL(db).escape_identifiers) { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " AS ", escape_char, column_alias, escape_char); } else { PHALCON_INIT_NVAR(column_alias_sql); PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " AS ", column_alias); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } } else { PHALCON_CPY_WRT(column_alias_sql, column_domain_sql); } phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(columns_sql); phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC); } else { PHALCON_CPY_WRT(columns_sql, columns); } /** * Check and escape tables */ PHALCON_OBS_VAR(tables); phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY_CC); if (Z_TYPE_P(tables) == IS_ARRAY) { PHALCON_INIT_VAR(selected_tables); array_init(selected_tables); if (!phalcon_is_iterable(tables, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(table); PHALCON_INIT_NVAR(sql_table); PHALCON_CALL_METHOD_PARAMS_2(sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_VAR(tables_sql); phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC); } else { PHALCON_CPY_WRT(tables_sql, tables); } PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSV(sql, "SELECT ", columns_sql, " FROM ", tables_sql); /** * Check for joins */ if (phalcon_array_isset_string(definition, SS("joins"))) { PHALCON_OBS_VAR(joins); phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY_CC); if (!phalcon_is_iterable(joins, &ah2, &hp2, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(join); PHALCON_OBS_NVAR(type); phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY_CC); PHALCON_OBS_NVAR(table); phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY_CC); PHALCON_INIT_NVAR(sql_table); PHALCON_CALL_METHOD_PARAMS_2(sql_table, this_ptr, "getsqltable", table, escape_char); phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(sql_join); PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table); /** * Check if the join has conditions */ if (phalcon_array_isset_string(join, SS("conditions"))) { PHALCON_OBS_NVAR(join_conditions_array); phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY_CC); if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) { PHALCON_INIT_NVAR(join_expressions); array_init(join_expressions); if (!phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(join_condition); PHALCON_INIT_NVAR(join_expression); PHALCON_CALL_METHOD_PARAMS_2(join_expression, this_ptr, "getsqlexpression", join_condition, escape_char); phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah3, &hp3); } PHALCON_INIT_NVAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC); PHALCON_SCONCAT_SV(sql_join, " ON ", join_conditions); } } phalcon_concat_self(&sql, sql_join TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } } /** * Check for a WHERE clause */ if (phalcon_array_isset_string(definition, SS("where"))) { PHALCON_OBS_VAR(where_conditions); phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY_CC); PHALCON_INIT_VAR(where_expression); PHALCON_CALL_METHOD_PARAMS_2(where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression); } /** * Check for a GROUP clause */ if (phalcon_array_isset_string(definition, SS("group"))) { PHALCON_INIT_VAR(group_items); array_init(group_items); PHALCON_OBS_VAR(group_fields); phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY_CC); if (!phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(group_field); PHALCON_INIT_NVAR(group_expression); PHALCON_CALL_METHOD_PARAMS_2(group_expression, this_ptr, "getsqlexpression", group_field, escape_char); phalcon_array_append(&group_items, group_expression, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah4, &hp4); } PHALCON_INIT_VAR(group_sql); phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC); PHALCON_INIT_VAR(group_clause); PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql); phalcon_concat_self(&sql, group_clause TSRMLS_CC); /** * Check for a HAVING clause */ if (phalcon_array_isset_string(definition, SS("having"))) { PHALCON_OBS_VAR(having_conditions); phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY_CC); PHALCON_INIT_VAR(having_expression); PHALCON_CALL_METHOD_PARAMS_2(having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char); PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression); } } /** * Check for a ORDER clause */ if (phalcon_array_isset_string(definition, SS("order"))) { PHALCON_OBS_VAR(order_fields); phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY_CC); PHALCON_INIT_VAR(order_items); array_init(order_items); if (!phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(order_item); PHALCON_OBS_NVAR(order_expression); phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY_CC); PHALCON_INIT_NVAR(order_sql_item); PHALCON_CALL_METHOD_PARAMS_2(order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char); /** * In the numeric 1 position could be a ASC/DESC clause */ if (phalcon_array_isset_long(order_item, 1)) { PHALCON_OBS_NVAR(sql_order_type); phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY_CC); PHALCON_INIT_NVAR(order_sql_item_type); PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type); } else { PHALCON_CPY_WRT(order_sql_item_type, order_sql_item); } phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah5, &hp5); } PHALCON_INIT_VAR(order_sql); phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC); PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql); } /** * Check for a LIMIT condition */ if (phalcon_array_isset_string(definition, SS("limit"))) { PHALCON_OBS_VAR(limit_value); phalcon_array_fetch_string(&limit_value, definition, SL("limit"), PH_NOISY_CC); if (Z_TYPE_P(limit_value) == IS_ARRAY) { PHALCON_OBS_VAR(number); phalcon_array_fetch_string(&number, limit_value, SL("number"), PH_NOISY_CC); /** * Check for a OFFSET condition */ if (phalcon_array_isset_string(limit_value, SS("offset"))) { PHALCON_OBS_VAR(offset); phalcon_array_fetch_string(&offset, limit_value, SL("offset"), PH_NOISY_CC); PHALCON_SCONCAT_SVSV(sql, " LIMIT ", number, " OFFSET ", offset); } else { PHALCON_SCONCAT_SV(sql, " LIMIT ", number); } } else { PHALCON_SCONCAT_SV(sql, " LIMIT ", limit_value); } } RETURN_CTOR(sql); }
/** * Updates data on a table using custom RBDM SQL syntax * * @param string $table * @param array $fields * @param array $values * @param string $whereCondition * @return boolean */ PHP_METHOD(Phalcon_Db, update){ zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL; zval *placeholders = NULL, *value = NULL, *position = NULL, *field = NULL, *set_clause_part = NULL; zval *comma = NULL, *set_clause = NULL, *update_sql = NULL, *success = 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, "zzz|z", &table, &fields, &values, &where_condition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_SEPARATE_PARAM(values); if (!where_condition) { PHALCON_ALLOC_ZVAL_MM(where_condition); ZVAL_NULL(where_condition); } PHALCON_INIT_VAR(placeholders); array_init(placeholders); if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ALLOC_HASHTABLE(ah0); zend_hash_init(ah0, 0, NULL, NULL, 0); zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*)); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto ph_cycle_end_0; } PHALCON_INIT_VAR(position); PHALCON_GET_FOREACH_KEY(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); eval_int = phalcon_array_isset(fields, position); if (eval_int) { PHALCON_INIT_VAR(field); phalcon_array_fetch(&field, fields, position, PH_NOISY_CC); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value); phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { if (Z_TYPE_P(value) == IS_NULL) { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = null"); PHALCON_SEPARATE_PARAM(values); phalcon_array_unset(values, position); } else { PHALCON_INIT_VAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = ?"); } phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); } } else { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values in the update is not the same as fields"); return; } zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: zend_hash_destroy(ah0); efree(ah0); PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ", ", 1); PHALCON_INIT_VAR(set_clause); phalcon_fast_join(set_clause, comma, placeholders TSRMLS_CC); if (Z_TYPE_P(where_condition) != IS_NULL) { PHALCON_INIT_VAR(update_sql); PHALCON_CONCAT_SVSVSV(update_sql, "UPDATE ", table, " SET ", set_clause, " WHERE ", where_condition); } else { PHALCON_INIT_VAR(update_sql); PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", update_sql, values, PH_NO_CHECK); RETURN_CCTOR(success); }
/** * Checks if a role has access to a resource * * @param string $roleName * @param string $resourceName * @param string $access * @param string $action */ PHP_METHOD(Phalcon_Acl_Adapter_Memory, _allowOrDeny){ zval *role_name, *resource_name, *access, *action; zval *roles_names, *exception_message = NULL, *resources_names; zval *default_access, *access_list, *internal_access; zval *access_name = NULL, *access_key = NULL, *access_key_all = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 4, 0, &role_name, &resource_name, &access, &action); PHALCON_OBS_VAR(roles_names); phalcon_read_property_this(&roles_names, this_ptr, SL("_rolesNames"), PH_NOISY_CC); if (!phalcon_array_isset(roles_names, role_name)) { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Role \"", role_name, "\" does not exist in ACL"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } PHALCON_OBS_VAR(resources_names); phalcon_read_property_this(&resources_names, this_ptr, SL("_resourcesNames"), PH_NOISY_CC); if (!phalcon_array_isset(resources_names, resource_name)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Resource \"", resource_name, "\" does not exist in ACL"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } PHALCON_OBS_VAR(default_access); phalcon_read_property_this(&default_access, this_ptr, SL("_defaultAccess"), PH_NOISY_CC); PHALCON_OBS_VAR(access_list); phalcon_read_property_this(&access_list, this_ptr, SL("_accessList"), PH_NOISY_CC); PHALCON_OBS_VAR(internal_access); phalcon_read_property_this(&internal_access, this_ptr, SL("_access"), PH_NOISY_CC); if (Z_TYPE_P(access) == IS_ARRAY) { phalcon_is_iterable(access, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(access_name); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access_name); if (!phalcon_array_isset(access_list, access_key)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSVS(exception_message, "Acccess '", access_name, "' does not exist in resource '", resource_name, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } zend_hash_move_forward_ex(ah0, &hp0); } phalcon_is_iterable(access, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(access_name); PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVSV(access_key, role_name, "!", resource_name, "!", access_name); phalcon_update_property_array(this_ptr, SL("_access"), access_key, action TSRMLS_CC); if (!PHALCON_IS_STRING(access_name, "*")) { PHALCON_INIT_NVAR(access_key_all); PHALCON_CONCAT_VSVS(access_key_all, role_name, "!", resource_name, "!*"); if (!phalcon_array_isset(internal_access, access_key_all)) { phalcon_update_property_array(this_ptr, SL("_access"), access_key_all, default_access TSRMLS_CC); } } zend_hash_move_forward_ex(ah1, &hp1); } } else { if (!PHALCON_IS_STRING(access, "*")) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSV(access_key, resource_name, "!", access); if (!phalcon_array_isset(access_list, access_key)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVSVS(exception_message, "Acccess '", access, "' does not exist in resource '", resource_name, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_acl_exception_ce, exception_message); return; } } PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVSV(access_key, role_name, "!", resource_name, "!", access); /** * Define the access action for the specified accessKey */ phalcon_update_property_array(this_ptr, SL("_access"), access_key, action TSRMLS_CC); if (!PHALCON_IS_STRING(access, "*")) { PHALCON_INIT_NVAR(access_key); PHALCON_CONCAT_VSVS(access_key, role_name, "!", resource_name, "!*"); /** * If there is no default action for all the rest actions in the resource set the * default one */ if (!phalcon_array_isset(internal_access, access_key)) { phalcon_update_property_array(this_ptr, SL("_access"), access_key, default_access TSRMLS_CC); } } } PHALCON_MM_RESTORE(); }
/** * Helper method to query records based on a relation definition * * @param array $relation * @param string $method * @param Phalcon\Mvc\Model $record * @param array $parameters * @return Phalcon\Mvc\Model\Resultset\Simple */ PHP_METHOD(Phalcon_Mvc_Model_Manager, _getRelationRecords){ zval *relation = NULL, *method = NULL, *record = NULL, *parameters = NULL, *placeholders = NULL; zval *pre_conditions = NULL, *conditions = NULL, *fields = NULL, *field = NULL; zval *value = NULL, *referenced_field = NULL, *condition = NULL, *i = NULL; zval *referenced_fields = NULL, *join_conditions = NULL; zval *find_params = NULL, *find_arguments = NULL, *arguments = NULL; zval *reference_table = NULL, *referenced_entity = NULL; zval *connection_service = NULL, *call_object = NULL, *records = NULL; zval *c0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; zend_class_entry *ce0; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &relation, &method, &record, ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_ALLOC_ZVAL_MM(parameters); ZVAL_NULL(parameters); } else { PHALCON_SEPARATE_PARAM(parameters); } if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_string(parameters, SL("bind")+1); if (eval_int) { PHALCON_INIT_VAR(placeholders); phalcon_array_fetch_string(&placeholders, parameters, SL("bind"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("bind")+1); } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } } else { PHALCON_INIT_VAR(placeholders); array_init(placeholders); } PHALCON_INIT_VAR(pre_conditions); ZVAL_NULL(pre_conditions); if (Z_TYPE_P(parameters) == IS_ARRAY) { eval_int = phalcon_array_isset_long(parameters, 0); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_long(&pre_conditions, parameters, 0, PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_long(parameters, 0); } else { eval_int = phalcon_array_isset_string(parameters, SL("conditions")+1); if (eval_int) { PHALCON_INIT_VAR(pre_conditions); phalcon_array_fetch_string(&pre_conditions, parameters, SL("conditions"), PH_NOISY_CC); PHALCON_SEPARATE_PARAM(parameters); phalcon_array_unset_string(parameters, SL("conditions")+1); } } } else { if (Z_TYPE_P(parameters) == IS_STRING) { PHALCON_CPY_WRT(pre_conditions, parameters); } } if (Z_TYPE_P(pre_conditions) != IS_NULL) { PHALCON_INIT_VAR(conditions); array_init(conditions); phalcon_array_append(&conditions, pre_conditions, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(conditions); array_init(conditions); } PHALCON_INIT_VAR(fields); phalcon_array_fetch_string(&fields, relation, SL("fi"), PH_NOISY_CC); if (Z_TYPE_P(fields) != IS_ARRAY) { PHALCON_CPY_WRT(field, fields); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch_string(&referenced_field, relation, SL("rf"), PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VS(condition, referenced_field, " = ?0"); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(i); ZVAL_LONG(i, 0); PHALCON_INIT_VAR(referenced_fields); phalcon_array_fetch_string(&referenced_fields, relation, SL("rf"), PH_NOISY_CC); if (!phalcon_valid_foreach(fields TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(fields); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_74b5_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_74b5_0; } PHALCON_INIT_VAR(field); ZVAL_ZVAL(field, *hd, 1, 0); PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_field); phalcon_array_fetch(&referenced_field, referenced_fields, i, PH_NOISY_CC); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_VSV(condition, referenced_field, " = ?", i); phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&placeholders, value, PH_SEPARATE TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); zend_hash_move_forward_ex(ah0, &hp0); goto fes_74b5_0; fee_74b5_0: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, " AND ", 1); PHALCON_INIT_VAR(join_conditions); phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC); PHALCON_INIT_VAR(find_params); array_init(find_params); phalcon_array_append(&find_params, join_conditions, PH_SEPARATE TSRMLS_CC); phalcon_array_update_string(&find_params, SL("bind"), &placeholders, PH_COPY | PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(parameters) == IS_ARRAY) { PHALCON_INIT_VAR(find_arguments); PHALCON_CALL_FUNC_PARAMS_2(find_arguments, "array_merge", find_params, parameters); } else { PHALCON_CPY_WRT(find_arguments, find_params); } PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, find_arguments, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(reference_table); phalcon_array_fetch_string(&reference_table, relation, SL("rt"), PH_NOISY_CC); ce0 = phalcon_fetch_class(reference_table TSRMLS_CC); PHALCON_INIT_VAR(referenced_entity); object_init_ex(referenced_entity, ce0); PHALCON_CALL_METHOD_NORETURN(referenced_entity, "__construct", PH_CHECK); PHALCON_INIT_VAR(connection_service); PHALCON_CALL_METHOD(connection_service, record, "getconnectionservice", PH_NO_CHECK); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(referenced_entity, "setconnectionservice", connection_service, PH_NO_CHECK); PHALCON_INIT_VAR(call_object); array_init(call_object); phalcon_array_append(&call_object, referenced_entity, PH_SEPARATE TSRMLS_CC); phalcon_array_append(&call_object, method, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(records); PHALCON_CALL_FUNC_PARAMS_2(records, "call_user_func_array", call_object, arguments); RETURN_CCTOR(records); }
/** * Initialize the metadata for certain table * * @param Phalcon\Mvc\Model $model * @param string $key * @param string $table * @param string $schema */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initializeMetaData){ zval *model, *key, *table, *schema, *meta_data, *data; zval *table_metadata = NULL, *class_name = NULL, *exception_message = NULL; zval *connection, *exists, *complete_table = NULL, *attributes; zval *primary_keys, *non_primary_keys, *numeric_typed; zval *not_null, *field_types, *field_bind_types; zval *automatic_default, *identity_field = NULL; zval *columns, *column = NULL, *field_name = NULL, *feature = NULL, *type = NULL; zval *bind_type = NULL; zval *t0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &model, &key, &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(meta_data); phalcon_read_property(&meta_data, this_ptr, SL("_metaData"), PH_NOISY_CC); eval_int = phalcon_array_isset(meta_data, key); if (!eval_int) { PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", key, PH_NO_CHECK); if (Z_TYPE_P(data) != IS_NULL) { phalcon_array_update_zval(&meta_data, key, &data, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), meta_data TSRMLS_CC); PHALCON_MM_RESTORE(); RETURN_NULL(); } if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(table_metadata); PHALCON_CALL_METHOD(table_metadata, model, "metadata", PH_NO_CHECK); if (Z_TYPE_P(table_metadata) != IS_ARRAY) { PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SV(exception_message, "Invalid meta-data for model ", class_name); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_INIT_VAR(connection); PHALCON_CALL_METHOD(connection, model, "getconnection", PH_NO_CHECK); PHALCON_INIT_VAR(exists); PHALCON_CALL_METHOD_PARAMS_2(exists, connection, "tableexists", table, schema, PH_NO_CHECK); 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); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_NVAR(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; } 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_bind_types); array_init(field_bind_types); PHALCON_INIT_VAR(automatic_default); array_init(automatic_default); PHALCON_INIT_VAR(identity_field); ZVAL_BOOL(identity_field, 0); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD_PARAMS_2(columns, connection, "describecolumns", table, schema, PH_NO_CHECK); 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); } PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); 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; } if (!phalcon_valid_foreach(columns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns); zend_hash_internal_pointer_reset_ex(ah0, &hp0); ph_cycle_start_0: if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) { goto ph_cycle_end_0; } PHALCON_GET_FOREACH_VALUE(column); PHALCON_INIT_NVAR(field_name); PHALCON_CALL_METHOD(field_name, column, "getname", PH_NO_CHECK); phalcon_array_append(&attributes, field_name, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isprimary", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(&primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } else { phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnumeric", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isnotnull", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(¬_null, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_NVAR(feature); PHALCON_CALL_METHOD(feature, column, "isautoincrement", PH_NO_CHECK); if (PHALCON_IS_TRUE(feature)) { PHALCON_CPY_WRT(identity_field, field_name); } PHALCON_INIT_NVAR(type); PHALCON_CALL_METHOD(type, column, "gettype", PH_NO_CHECK); phalcon_array_update_zval(&field_types, field_name, &type, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(bind_type); PHALCON_CALL_METHOD(bind_type, column, "getbindtype", PH_NO_CHECK); phalcon_array_update_zval(&field_bind_types, field_name, &bind_type, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto ph_cycle_start_0; ph_cycle_end_0: PHALCON_INIT_NVAR(table_metadata); array_init(table_metadata); phalcon_array_update_long(&table_metadata, 0, &attributes, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 4, &field_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&table_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(t0); phalcon_read_property(&t0, this_ptr, SL("_metaData"), PH_NOISY_CC); phalcon_array_update_zval(&t0, key, &table_metadata, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), t0 TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", key, table_metadata, PH_NO_CHECK); } PHALCON_MM_RESTORE(); }