/** * Gets the current document title * * <code> * echo Phalcon\Tag::getTitle(); * </code> * * <code> * {{ get_title() }} * </code> * * @return string */ PHP_METHOD(Phalcon_Tag, getTitle){ zval *tags = NULL, *document_title, *eol, *title_html; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &tags); if (!tags) { PHALCON_INIT_VAR(tags); ZVAL_BOOL(tags, 1); } PHALCON_OBS_VAR(document_title); phalcon_read_static_property(&document_title, SL("phalcon\\tag"), SL("_documentTitle") TSRMLS_CC); if (PHALCON_IS_TRUE(tags)) { PHALCON_INIT_VAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); PHALCON_INIT_VAR(title_html); PHALCON_CONCAT_SVSV(title_html, "<title>", document_title, "</title>", eol); RETURN_CTOR(title_html); } RETURN_CCTOR(document_title); }
/** * 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(); }
/** * Creates a password hash using bcrypt with a pseudo random salt * * @param string $password * @param int $workFactor * @return string */ PHP_METHOD(Phalcon_Security, hash){ zval *password, *work_factor = NULL, *format, *factor; zval *salt_bytes, *salt; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &password, &work_factor); if (!work_factor) { PHALCON_INIT_VAR(work_factor); } else { PHALCON_SEPARATE_PARAM(work_factor); } if (Z_TYPE_P(work_factor) == IS_NULL) { PHALCON_OBS_NVAR(work_factor); phalcon_read_property_this(&work_factor, this_ptr, SL("_workFactor"), PH_NOISY_CC); } PHALCON_INIT_VAR(format); ZVAL_STRING(format, "%02s", 1); PHALCON_INIT_VAR(factor); phalcon_call_func_p2(factor, "sprintf", format, work_factor); PHALCON_INIT_VAR(salt_bytes); phalcon_call_method(salt_bytes, this_ptr, "getsaltbytes"); PHALCON_INIT_VAR(salt); PHALCON_CONCAT_SVSV(salt, "$2a$", factor, "$", salt_bytes); phalcon_call_func_p2(return_value, "crypt", password, salt); RETURN_MM(); }
/** * 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 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(); }
/** * Executes the validation * * @param Phalcon\Validation $validator * @param string $attribute * @return boolean */ PHP_METHOD(Phalcon_Validation_Validator_InclusionIn, validate){ zval *validator, *attribute, *value, *option = NULL, *domain; zval *message_str = NULL, *joined_domain, *type, *message; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &validator, &attribute) == FAILURE) { RETURN_MM_NULL(); } PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, validator, "getvalue", attribute); /** * A domain is an array with a list of valid values */ PHALCON_INIT_VAR(option); ZVAL_STRING(option, "domain", 1); PHALCON_INIT_VAR(domain); PHALCON_CALL_METHOD_PARAMS_1(domain, this_ptr, "getoption", option); 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_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message_str); PHALCON_CALL_METHOD_PARAMS_1(message_str, this_ptr, "getoption", option); if (!zend_is_true(message_str)) { PHALCON_INIT_VAR(joined_domain); phalcon_fast_join_str(joined_domain, SL(", "), domain TSRMLS_CC); PHALCON_INIT_NVAR(message_str); PHALCON_CONCAT_SVSV(message_str, "Value of field '", attribute, "' must be part of list: ", joined_domain); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "InclusionIn", 1); PHALCON_INIT_VAR(message); object_init_ex(message, phalcon_validation_message_ce); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(message, "__construct", message_str, attribute, type); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(validator, "appendmessage", message); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Get the document type declaration of content * * @return string */ PHP_METHOD(Phalcon_Tag, getDocType){ zval *doctype = NULL, *declaration, *eol, *doctype_html; PHALCON_MM_GROW(); PHALCON_OBSERVE_VAR(doctype); phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC); PHALCON_INIT_VAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); PHALCON_INIT_VAR(declaration); if (phalcon_compare_strict_long(doctype, 1 TSRMLS_CC)) { ZVAL_STRING(declaration, " PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\"", 1); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 2 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01//EN\"", eol, "\t\"http://www.w3.org/TR/html4/strict.dtd\""); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 3 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"", eol, "\t\"http://www.w3.org/TR/html4/loose.dtd\""); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 4 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\"", eol, "\t\"http://www.w3.org/TR/html4/frameset.dtd\""); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 6 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\""); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 7 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\""); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 8 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\""); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 9 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\""); goto ph_end_0; } if (phalcon_compare_strict_long(doctype, 10 TSRMLS_CC)) { PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 2.0//EN\"", eol, "\t\"http://www.w3.org/MarkUp/DTD/xhtml2.dtd\""); goto ph_end_0; } ph_end_0: PHALCON_INIT_VAR(doctype_html); PHALCON_CONCAT_SVSV(doctype_html, "<!DOCTYPE html", declaration, ">", eol); RETURN_CTOR(doctype_html); }
/** * Executes validator * * @return boolean */ PHP_METHOD(Phalcon_Model_Validator_Exclusionin, validate) { zval *domain = NULL, *field_name = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL; PHALCON_MM_GROW(); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK); if (zend_is_true(r0)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "domain", 1); PHALCON_CALL_METHOD_PARAMS_1(r1, this_ptr, "issetoption", c0, PHALCON_NO_CHECK); if (zend_is_true(r1)) { PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "domain", 1); PHALCON_CALL_METHOD_PARAMS_1(r2, this_ptr, "getoption", c1, PHALCON_NO_CHECK); PHALCON_CPY_WRT(domain, r2); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD(r4, this_ptr, "getvalue", PHALCON_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_2(r3, "in_array", r4, domain, 0x03E); if (zend_is_true(r3)) { PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, this_ptr, "getfieldname", PHALCON_NO_CHECK); PHALCON_CPY_WRT(field_name, r5); PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, ", ", 1); PHALCON_ALLOC_ZVAL_MM(r7); phalcon_fast_join(r7, c2, domain TSRMLS_CC); PHALCON_CONCAT_SVSV(r6, "Value of field '", field_name, "' must not be part of list: ", r7); PHALCON_INIT_VAR(c3); ZVAL_STRING(c3, "exclusion", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r6, field_name, c3, PHALCON_NO_CHECK); PHALCON_MM_RESTORE(); RETURN_FALSE; } } } PHALCON_MM_RESTORE(); RETURN_TRUE; }
/** * Generates SQL to modify a column in a table * * @param string $tableName * @param string $schemaName * @param Phalcon_Db_Column $column * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, modifyColumn){ zval *table_name = NULL, *schema_name = NULL, *column = NULL, *sql = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL; zval *t0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &column) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(column) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column parameter must be an instance of Phalcon_Db_Column"); return; } if (zend_is_true(schema_name)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "ALTER TABLE `", schema_name, "`.`", table_name, "` MODIFY "); PHALCON_CPY_WRT(sql, r0); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "ALTER TABLE `", table_name, "` MODIFY "); PHALCON_CPY_WRT(sql, r1); } PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CALL_METHOD(r3, column, "getname", PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_SELF_PARAMS_1(r4, this_ptr, "getcolumndefinition", column); PHALCON_CONCAT_SVSV(r2, "`", r3, "` ", r4); phalcon_concat_self(&sql, r2 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, column, "isnotnull", PHALCON_NO_CHECK); if (zend_is_true(r5)) { PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, " NOT NULL", 1); phalcon_concat_self(&sql, t0 TSRMLS_CC); } PHALCON_RETURN_CTOR(sql); }
/** * Get the title of view content * * @return string */ PHP_METHOD(Phalcon_Tag, getTitle){ zval *document_title = NULL, *eol = NULL, *title_html = NULL; PHALCON_MM_GROW(); PHALCON_OBSERVE_VAR(document_title); phalcon_read_static_property(&document_title, SL("phalcon\\tag"), SL("_documentTitle") TSRMLS_CC); PHALCON_INIT_VAR(eol); zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC); PHALCON_INIT_VAR(title_html); PHALCON_CONCAT_SVSV(title_html, "<title>", document_title, "</title>", eol); RETURN_CTOR(title_html); }
/** * Returns last error message from MySQL * * @param string $errorString * @return string */ PHP_METHOD(Phalcon_Db_Adapter_Mysql, error){ zval *error_string = NULL, *id_connection = NULL, *error_message = NULL; zval *t0 = NULL, *t1 = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &error_string) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!error_string) { PHALCON_INIT_VAR(error_string); ZVAL_NULL(error_string); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_idConnection"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(id_connection, t0); if (zend_is_true(id_connection)) { PHALCON_INIT_VAR(error_message); PHALCON_CALL_FUNC_PARAMS_1(error_message, "mysqli_error", id_connection); } else { PHALCON_INIT_VAR(error_message); ZVAL_STRING(error_message, "", 1); } if (zend_is_true(error_message)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSV(r0, "\"", error_message, "\" ", error_string); phalcon_update_property_zval(this_ptr, SL("_lastError"), r0 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "[Unknown MySQL error: ", error_string, "]"); phalcon_update_property_zval(this_ptr, SL("_lastError"), r1 TSRMLS_CC); } PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, SL("_lastError"), PHALCON_NOISY TSRMLS_CC); RETURN_CHECK_CTOR(t1); }
/** * 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(); }
/** * 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); }
/** * 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); }
/** * Generates SQL to create a table in MySQL * * @param string $tableName * @param string $schemaName * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable){ zval *table_name = NULL, *schema_name = NULL, *definition = NULL; zval *table = NULL, *temporary = NULL, *sql = NULL, *create_lines = NULL, *columns = NULL; zval *column = NULL, *column_name = NULL, *column_definition = NULL; zval *column_line = NULL, *attribute = NULL, *indexes = NULL, *index = NULL; zval *index_name = NULL, *column_list = NULL, *index_sql = NULL, *references = NULL; zval *reference = NULL, *name = NULL, *referenced_table = NULL, *referenced_columns = NULL; zval *constaint_sql = NULL, *reference_sql = NULL, *joined_lines = NULL; zval *options = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL; zval *t0 = NULL, *t1 = NULL; zval *c0 = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } eval_int = phalcon_array_isset_string(definition, SL("columns")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVSVS(table, "`", schema_name, "`.`", table_name, "`"); } else { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVS(table, "`", table_name, "`"); } PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 0); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r0, SL("temporary")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, r1, SL("temporary"), PH_NOISY_CC); if (zend_is_true(r2)) { PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 1); } } } if (Z_TYPE_P(temporary) == IS_BOOL && Z_BVAL_P(temporary)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TEMPORARY TABLE ", table, " (\n\t"); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TABLE ", table, " (\n\t"); } PHALCON_INIT_VAR(create_lines); array_init(create_lines); PHALCON_INIT_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC); if (!phalcon_valid_foreach(columns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_52be_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_52be_2; } PHALCON_INIT_VAR(column); ZVAL_ZVAL(column, *hd, 1, 0); PHALCON_INIT_VAR(column_name); PHALCON_CALL_METHOD(column_name, column, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(column_definition); PHALCON_CALL_METHOD_PARAMS_1(column_definition, this_ptr, "getcolumndefinition", column, PH_NO_CHECK); PHALCON_INIT_VAR(column_line); PHALCON_CONCAT_SVSV(column_line, "`", column_name, "` ", column_definition); PHALCON_INIT_VAR(attribute); PHALCON_CALL_METHOD(attribute, column, "isnotnull", PH_NO_CHECK); if (zend_is_true(attribute)) { PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, " NOT NULL", 1); phalcon_concat_self(&column_line, t0 TSRMLS_CC); } PHALCON_INIT_VAR(attribute); PHALCON_CALL_METHOD(attribute, column, "isautoincrement", PH_NO_CHECK); if (zend_is_true(attribute)) { PHALCON_INIT_VAR(t1); ZVAL_STRING(t1, " AUTO_INCREMENT", 1); phalcon_concat_self(&column_line, t1 TSRMLS_CC); } phalcon_array_append(&create_lines, column_line, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_52be_2; fee_52be_2: eval_int = phalcon_array_isset_string(definition, SL("indexes")+1); if (eval_int) { PHALCON_INIT_VAR(indexes); phalcon_array_fetch_string(&indexes, definition, SL("indexes"), PH_NOISY_CC); if (!phalcon_valid_foreach(indexes TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(indexes); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_52be_3: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_52be_3; } PHALCON_INIT_VAR(index); ZVAL_ZVAL(index, *hd, 1, 0); PHALCON_INIT_VAR(index_name); PHALCON_CALL_METHOD(index_name, index, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD(columns, index, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK); if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) { PHALCON_INIT_VAR(index_sql); PHALCON_CONCAT_SVS(index_sql, "PRIMARY KEY (", column_list, ")"); } else { PHALCON_INIT_VAR(index_sql); PHALCON_CONCAT_SVSVS(index_sql, "KEY `", index_name, "` (", column_list, ")"); } phalcon_array_append(&create_lines, index_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto fes_52be_3; fee_52be_3: if(0){} } eval_int = phalcon_array_isset_string(definition, SL("references")+1); if (eval_int) { PHALCON_INIT_VAR(references); phalcon_array_fetch_string(&references, definition, SL("references"), PH_NOISY_CC); if (!phalcon_valid_foreach(references TSRMLS_CC)) { return; } ah2 = Z_ARRVAL_P(references); zend_hash_internal_pointer_reset_ex(ah2, &hp2); fes_52be_4: if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){ goto fee_52be_4; } PHALCON_INIT_VAR(reference); ZVAL_ZVAL(reference, *hd, 1, 0); PHALCON_INIT_VAR(name); PHALCON_CALL_METHOD(name, reference, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD(columns, reference, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_table); PHALCON_CALL_METHOD(referenced_table, reference, "getreferencedtable", PH_NO_CHECK); PHALCON_INIT_VAR(referenced_columns); PHALCON_CALL_METHOD(referenced_columns, reference, "getreferencedcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_METHOD_PARAMS_1(column_list, this_ptr, "getcolumnlist", referenced_columns, PH_NO_CHECK); PHALCON_INIT_VAR(constaint_sql); PHALCON_CONCAT_SVSVS(constaint_sql, "CONSTRAINT `", name, "` FOREIGN KEY (", column_list, ")"); PHALCON_INIT_VAR(reference_sql); PHALCON_CONCAT_VSVSVS(reference_sql, constaint_sql, " REFERENCES `", referenced_table, "`(", column_list, ")"); phalcon_array_append(&create_lines, reference_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); goto fes_52be_4; fee_52be_4: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ",\n\t", 1); PHALCON_INIT_VAR(joined_lines); phalcon_fast_join(joined_lines, c0, create_lines TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CONCAT_VS(r3, joined_lines, "\n)"); phalcon_concat_self(&sql, r3 TSRMLS_CC); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_INIT_VAR(options); PHALCON_CALL_METHOD_PARAMS_1(options, this_ptr, "_gettableoptions", definition, PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CONCAT_SV(r4, " ", options); phalcon_concat_self(&sql, r4 TSRMLS_CC); } RETURN_CTOR(sql); }
/** * Generates SQL to add a column to a table * * @param string $tableName * @param string $schemaName * @param Phalcon\Db\Column $column * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, addColumn){ zval *table_name = NULL, *schema_name = NULL, *column = NULL, *sql = NULL, *name = NULL; zval *column_definition = NULL, *is_not_null = NULL, *is_first = NULL; zval *after_position = NULL, *after_sql = NULL; zval *r0 = NULL; zval *t0 = NULL, *t1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &column) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(column) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column parameter must be an instance of Phalcon\\Db\\Column"); return; } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSVS(sql, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD "); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "ALTER TABLE `", table_name, "` ADD "); } PHALCON_INIT_VAR(name); PHALCON_CALL_METHOD(name, column, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(column_definition); PHALCON_CALL_METHOD_PARAMS_1(column_definition, this_ptr, "getcolumndefinition", column, PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSV(r0, "`", name, "` ", column_definition); phalcon_concat_self(&sql, r0 TSRMLS_CC); PHALCON_INIT_VAR(is_not_null); PHALCON_CALL_METHOD(is_not_null, column, "isnotnull", PH_NO_CHECK); if (zend_is_true(is_not_null)) { PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, " NOT NULL", 1); phalcon_concat_self(&sql, t0 TSRMLS_CC); } PHALCON_INIT_VAR(is_first); PHALCON_CALL_METHOD(is_first, column, "isfirst", PH_NO_CHECK); if (zend_is_true(is_first)) { PHALCON_INIT_VAR(t1); ZVAL_STRING(t1, " FIRST", 1); phalcon_concat_self(&sql, t1 TSRMLS_CC); } else { PHALCON_INIT_VAR(after_position); PHALCON_CALL_METHOD(after_position, column, "getafterposition", PH_NO_CHECK); if (zend_is_true(after_position)) { PHALCON_INIT_VAR(after_sql); PHALCON_CONCAT_SV(after_sql, " AFTER ", after_position); phalcon_concat_self(&sql, after_sql TSRMLS_CC); } } RETURN_CTOR(sql); }
/** * 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, *table, *read_connection, *exists; zval *complete_table = NULL, *exception_message = NULL; zval *columns, *attributes, *primary_keys, *non_primary_keys; zval *numeric_typed, *not_null, *field_types; zval *field_bind_types, *automatic_default; zval *identity_field = NULL, *column = NULL, *field_name = NULL, *feature = NULL; zval *type = NULL, *bind_type = NULL, *model_metadata; 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_INIT_VAR(schema); phalcon_call_method(schema, model, "getschema"); PHALCON_INIT_VAR(table); phalcon_call_method(table, model, "getsource"); /** * Check if the mapped table exists on the database */ PHALCON_INIT_VAR(read_connection); phalcon_call_method(read_connection, model, "getreadconnection"); PHALCON_INIT_VAR(exists); phalcon_call_method_p2(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_INIT_VAR(columns); phalcon_call_method_p2(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_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_is_iterable(columns, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(column); PHALCON_INIT_NVAR(field_name); phalcon_call_method(field_name, column, "getname"); phalcon_array_append(&attributes, field_name, PH_SEPARATE); /** * To mark fields as primary keys */ PHALCON_INIT_NVAR(feature); phalcon_call_method(feature, column, "isprimary"); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(&primary_keys, field_name, PH_SEPARATE); } else { phalcon_array_append(&non_primary_keys, field_name, PH_SEPARATE); } /** * To mark fields as numeric */ PHALCON_INIT_NVAR(feature); phalcon_call_method(feature, column, "isnumeric"); if (PHALCON_IS_TRUE(feature)) { phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE); } /** * To mark fields as not null */ PHALCON_INIT_NVAR(feature); phalcon_call_method(feature, column, "isnotnull"); if (PHALCON_IS_TRUE(feature)) { phalcon_array_append(¬_null, field_name, PH_SEPARATE); } /** * To mark fields as identity columns */ PHALCON_INIT_NVAR(feature); phalcon_call_method(feature, column, "isautoincrement"); if (PHALCON_IS_TRUE(feature)) { PHALCON_CPY_WRT(identity_field, field_name); } /** * To get the internal types */ PHALCON_INIT_NVAR(type); phalcon_call_method(type, column, "gettype"); phalcon_array_update_zval(&field_types, field_name, &type, PH_COPY | PH_SEPARATE); /** * To mark how the fields must be escaped */ PHALCON_INIT_NVAR(bind_type); phalcon_call_method(bind_type, column, "getbindtype"); phalcon_array_update_zval(&field_bind_types, field_name, &bind_type, PH_COPY | PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } /** * Create an array using the MODELS_* constants as indexes */ PHALCON_INIT_VAR(model_metadata); array_init(model_metadata); phalcon_array_update_long(&model_metadata, 0, &attributes, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 1, &primary_keys, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 2, &non_primary_keys, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 3, ¬_null, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 4, &field_types, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 5, &numeric_typed, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 8, &identity_field, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 9, &field_bind_types, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 10, &automatic_default, PH_COPY | PH_SEPARATE); phalcon_array_update_long(&model_metadata, 11, &automatic_default, PH_COPY | PH_SEPARATE); RETURN_CTOR(model_metadata); }
/** * Initialize the metadata for certain table * * @param Phalcon\Mvc\ModelInterface $model * @param string $key * @param string $table * @param string $schema */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize){ zval *model, *key, *table, *schema, *class_name = NULL, *meta_data = NULL; zval *data = NULL, *table_metadata = NULL, *exception_message = NULL; zval *connection, *exists, *complete_table = NULL, *columns; zval *attributes, *primary_keys, *non_primary_keys; zval *numeric_typed, *not_null, *field_types; zval *field_bind_types, *automatic_default; zval *identity_field = NULL, *column = NULL, *field_name = NULL, *feature = NULL; zval *type = NULL, *bind_type = NULL, *column_map = NULL, *ordered_column_map = NULL; zval *reversed_column_map = NULL, *user_column_map; zval *user_name = NULL, *name = NULL, *model_column_map; zval *t0 = NULL; HashTable *ah0, *ah1; HashPosition hp0, hp1; 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, "zzzz", &model, &key, &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); if (Z_TYPE_P(key) != IS_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) { /** * The meta-data is read from the adapter always */ PHALCON_INIT_VAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", key, PH_NO_CHECK); if (Z_TYPE_P(data) != IS_NULL) { if (Z_TYPE_P(meta_data) != IS_ARRAY) { PHALCON_INIT_NVAR(meta_data); array_init(meta_data); } 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); } else { /** * Check if there is a method 'metaData' in the model and retrieve data from it */ 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(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 { /** * Check if the mapped table exists on the database */ 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(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_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(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_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); 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: /** * Create an array using the MODELS_* constants as indexes */ 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); } } } /** * Check for a column map, store in _columnMap in order and reversed order */ PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, model TSRMLS_CC); PHALCON_INIT_VAR(column_map); phalcon_read_property(&column_map, this_ptr, SL("_columnMap"), PH_NOISY_CC); eval_int = phalcon_array_isset(column_map, class_name); if (!eval_int) { if (Z_TYPE_P(column_map) != IS_ARRAY) { PHALCON_INIT_NVAR(column_map); array_init(column_map); } PHALCON_INIT_NVAR(data); PHALCON_CALL_METHOD_PARAMS_1(data, this_ptr, "read", class_name, PH_NO_CHECK); if (Z_TYPE_P(data) != IS_NULL) { phalcon_array_update_zval(&column_map, class_name, &data, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_columnMap"), column_map TSRMLS_CC); } else { PHALCON_INIT_VAR(ordered_column_map); PHALCON_INIT_VAR(reversed_column_map); /** * Check for a columnMap() method on the model */ if (phalcon_method_exists_ex(model, SS("columnmap") TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(user_column_map); PHALCON_CALL_METHOD(user_column_map, model, "columnmap", PH_NO_CHECK); if (Z_TYPE_P(user_column_map) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "columnMap() not returned an array"); return; } array_init(reversed_column_map); PHALCON_CPY_WRT(ordered_column_map, user_column_map); if (!phalcon_valid_foreach(user_column_map TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(user_column_map); zend_hash_internal_pointer_reset_ex(ah1, &hp1); ph_cycle_start_1: if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) { goto ph_cycle_end_1; } PHALCON_GET_FOREACH_KEY(name, ah1, hp1); PHALCON_GET_FOREACH_VALUE(user_name); phalcon_array_update_zval(&reversed_column_map, user_name, &name, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); goto ph_cycle_start_1; ph_cycle_end_1: if(0){} } PHALCON_INIT_VAR(model_column_map); array_init(model_column_map); phalcon_array_update_long(&model_column_map, 0, &ordered_column_map, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_long(&model_column_map, 1, &reversed_column_map, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_array_update_zval(&column_map, class_name, &model_column_map, PH_COPY | PH_SEPARATE TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_columnMap"), column_map TSRMLS_CC); PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "write", class_name, model_column_map, PH_NO_CHECK); } } PHALCON_MM_RESTORE(); }
/** * 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); }
/** * Executes validator * * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Exclusionin, validate){ zval *record = NULL, *field_name = NULL, *domain = NULL, *value = NULL; zval *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL, *c4 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "field", 1); PHALCON_INIT_VAR(field_name); PHALCON_CALL_METHOD_PARAMS_1(field_name, this_ptr, "getoption", c0, PH_NO_CHECK); if (Z_TYPE_P(field_name) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string"); return; } PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "domain", 1); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "issetoption", c1, PH_NO_CHECK); if (!zend_is_true(r0)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "The option 'domain' is required for this validator"); return; } PHALCON_INIT_VAR(c2); ZVAL_STRING(c2, "domain", 1); PHALCON_INIT_VAR(domain); PHALCON_CALL_METHOD_PARAMS_1(domain, this_ptr, "getoption", c2, PH_NO_CHECK); if (Z_TYPE_P(domain) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Option 'domain' must be an array"); return; } PHALCON_INIT_VAR(value); PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field_name, PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_FUNC_PARAMS_2(r1, "in_array", value, domain); if (zend_is_true(r1)) { PHALCON_INIT_VAR(c3); ZVAL_STRING(c3, ", ", 1); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_fast_join(r2, c3, domain TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CONCAT_SVSV(r3, "Value of field '", field_name, "' must not be part of list: ", r2); PHALCON_INIT_VAR(c4); ZVAL_STRING(c4, "exclusion", 1); PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r3, field_name, c4, PH_NO_CHECK); PHALCON_MM_RESTORE(); RETURN_FALSE; } PHALCON_MM_RESTORE(); RETURN_TRUE; }
/** * Initialize the metadata for certain table * * @param Phalcon\Mvc\Model $model * @param string $table * @param string $schema */ PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initializeMetaData){ zval *model = NULL, *table = NULL, *schema = NULL, *key = NULL, *connection = NULL, *exists = NULL; zval *complete_table = NULL, *attributes = NULL, *primary_keys = NULL; zval *non_primary_keys = NULL, *numeric_typed = NULL, *not_null = NULL; zval *field_types = NULL, *identity_field = NULL, *columns = NULL; zval *column = NULL, *field_name = NULL, *table_metadata = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL; zval *i0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *a0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &model, &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(key); PHALCON_CONCAT_VV(key, schema, table); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, SL("_metaData"), PH_NOISY_CC); eval_int = phalcon_array_isset(t0, key); if (!eval_int) { 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_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_mvc_model_exception_ce); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_get_class(r0, model TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVSV(r1, "Table \"", complete_table, "\" doesn't exist on database when dumping meta-data for ", r0); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r1, PH_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); 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(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_valid_foreach(columns TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(columns); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_c40c_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_c40c_0; } PHALCON_INIT_VAR(column); ZVAL_ZVAL(column, *hd, 1, 0); PHALCON_INIT_VAR(field_name); PHALCON_CALL_METHOD(field_name, column, "getname", PH_NO_CHECK); phalcon_array_append(&attributes, field_name, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(r2); PHALCON_CALL_METHOD(r2, column, "isprimary", PH_NO_CHECK); if (zend_is_true(r2)) { 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_VAR(r3); PHALCON_CALL_METHOD(r3, column, "isnumeric", PH_NO_CHECK); if (zend_is_true(r3)) { phalcon_array_update_zval_bool(&numeric_typed, field_name, 1, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(r4); PHALCON_CALL_METHOD(r4, column, "isnotnull", PH_NO_CHECK); if (zend_is_true(r4)) { phalcon_array_append(¬_null, field_name, PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(r5); PHALCON_CALL_METHOD(r5, column, "isautoincrement", PH_NO_CHECK); if (zend_is_true(r5)) { PHALCON_CPY_WRT(identity_field, field_name); } PHALCON_INIT_VAR(r6); PHALCON_CALL_METHOD(r6, column, "gettype", PH_NO_CHECK); phalcon_array_update_zval(&field_types, field_name, &r6, PH_COPY | PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_c40c_0; fee_c40c_0: if(0){} PHALCON_INIT_VAR(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_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, SL("_metaData"), PH_NOISY_CC); phalcon_array_update_zval(&t1, key, &table_metadata, PH_COPY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_metaData"), t1 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, SL("_changed"), PH_NOISY_CC); if (!zend_is_true(t2)) { PHALCON_ALLOC_ZVAL_MM(a0); array_init(a0); phalcon_array_append(&a0, this_ptr, PH_SEPARATE TSRMLS_CC); add_next_index_stringl(a0, SL("storeMetaData"), 1); PHALCON_CALL_FUNC_PARAMS_1_NORETURN("register_shutdown_function", a0); phalcon_update_property_bool(this_ptr, SL("_changed"), 1 TSRMLS_CC); } } PHALCON_MM_RESTORE(); }
/** * Updates data on a table using custom RBDM SQL syntax * * <code> * //Updating existing robot * $success = $connection->update( * "robots", * array("name") * array("New Astro Boy"), * "id = 101" * ); * * //Next SQL sentence is sent to the database system * UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101 * </code> * * @param string $table * @param array $fields * @param array $values * @param string $whereCondition * @param array $dataTypes * @return boolean */ PHP_METHOD(Phalcon_Db, update){ zval *table, *fields, *values, *where_condition = NULL; zval *data_types = NULL, *placeholders, *update_values; zval *bind_data_types = NULL, *value = NULL, *position = NULL, *field = NULL; zval *set_clause_part = NULL, *bind_type = NULL, *set_clause; zval *update_sql = NULL, *success; 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|zz", &table, &fields, &values, &where_condition, &data_types) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!where_condition) { PHALCON_INIT_NVAR(where_condition); } if (!data_types) { PHALCON_INIT_NVAR(data_types); } PHALCON_INIT_VAR(placeholders); array_init(placeholders); PHALCON_INIT_VAR(update_values); array_init(update_values); if (Z_TYPE_P(data_types) == IS_ARRAY) { PHALCON_INIT_VAR(bind_data_types); array_init(bind_data_types); } else { PHALCON_CPY_WRT(bind_data_types, data_types); } if (!phalcon_valid_foreach(values TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(values); 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(position, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); eval_int = phalcon_array_isset(fields, position); if (eval_int) { PHALCON_INIT_NVAR(field); phalcon_array_fetch(&field, fields, position, PH_NOISY_CC); if (Z_TYPE_P(value) == IS_OBJECT) { PHALCON_INIT_NVAR(set_clause_part); PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value); phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC); } else { if (Z_TYPE_P(value) == IS_NULL) { PHALCON_INIT_NVAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = null"); } else { PHALCON_INIT_NVAR(set_clause_part); PHALCON_CONCAT_VS(set_clause_part, field, " = ?"); phalcon_array_append(&update_values, value, PH_SEPARATE TSRMLS_CC); if (Z_TYPE_P(data_types) == IS_ARRAY) { eval_int = phalcon_array_isset(data_types, position); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Incomplete number of bind types"); return; } PHALCON_INIT_NVAR(bind_type); phalcon_array_fetch(&bind_type, data_types, position, PH_NOISY_CC); phalcon_array_append(&bind_data_types, bind_type, PH_SEPARATE TSRMLS_CC); } } 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: PHALCON_INIT_VAR(set_clause); phalcon_fast_join_str(set_clause, SL(", "), 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_NVAR(update_sql); PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause); } PHALCON_INIT_VAR(success); PHALCON_CALL_METHOD_PARAMS_3(success, this_ptr, "execute", update_sql, update_values, bind_data_types, PH_NO_CHECK); RETURN_CCTOR(success); }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Exclusionin, validate){ zval *record, *option = NULL, *field_name, *is_set, *domain; zval *value, *message = NULL, *joined_domain, *type; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &record); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_INIT_VAR(field_name); phalcon_call_method_p1(field_name, this_ptr, "getoption", option); if (Z_TYPE_P(field_name) != 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_INIT_VAR(is_set); phalcon_call_method_p1(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_INIT_VAR(domain); phalcon_call_method_p1(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_INIT_VAR(value); phalcon_call_method_p1(value, record, "readattribute", field_name); /** * We check if the value contained in the array using "in_array" from the PHP * userland */ if (phalcon_fast_in_array(value, domain TSRMLS_CC)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message); phalcon_call_method_p1(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_name, "' must not be part of list: ", joined_domain); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Exclusion", 1); phalcon_call_method_p3_noret(this_ptr, "appendmessage", message, field_name, type); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
PHP_METHOD(Phalcon_Http_Client_Adapter_Stream, buildBody){ zval *stream, *header, *data, *file, *username, *password, *authtype, *digest, *method, *entity_body; zval *key = NULL, *value = NULL, *realm, *qop, *nonce, *nc, *cnonce, *qoc, *ha1 = NULL, *path = NULL, *md5_entity_body = NULL, *ha2 = NULL; zval *http, *option = NULL, *body, *headers = NULL, *uniqid = NULL, *boundary; zval *path_parts = NULL, *filename, *basename, *filedata = NULL, *tmp = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); stream = phalcon_fetch_nproperty_this(this_ptr, SL("_stream"), PH_NOISY TSRMLS_CC); header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC); data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC); file = phalcon_fetch_nproperty_this(this_ptr, SL("_file"), PH_NOISY TSRMLS_CC); username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC); password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC); authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC); digest = phalcon_fetch_nproperty_this(this_ptr, SL("_digest"), PH_NOISY TSRMLS_CC); method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC); entity_body = phalcon_fetch_nproperty_this(this_ptr, SL("_entity_body"), PH_NOISY TSRMLS_CC); if (PHALCON_IS_NOT_EMPTY(username)) { if (PHALCON_IS_STRING(authtype, "basic")) { PHALCON_INIT_NVAR(key); ZVAL_STRING(key, "Authorization", 1); PHALCON_INIT_NVAR(value); PHALCON_CONCAT_SVSV(value, "Basic ", username, ":", password); PHALCON_CALL_METHOD(NULL, header, "set", key, value); } else if (PHALCON_IS_STRING(authtype, "digest") && PHALCON_IS_NOT_EMPTY(digest)) { if (phalcon_array_isset_string_fetch(&realm, digest, SS("realm"))) { PHALCON_INIT_VAR(realm); ZVAL_NULL(realm); } PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VSVSV(tmp, username, ":", realm, ":", password); PHALCON_CALL_FUNCTION(&ha1, "md5", tmp); if (!phalcon_array_isset_string_fetch(&qop, digest, SS("qop"))) { PHALCON_INIT_VAR(qop); ZVAL_NULL(qop); } if (PHALCON_IS_EMPTY(qop) || phalcon_memnstr_str(qop, SL("auth"))) { PHALCON_CALL_SELF(&path, "getpath"); PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VSV(tmp, method, ":", path); PHALCON_CALL_FUNCTION(&ha2, "md5", tmp); } else if (phalcon_memnstr_str(qop, SL("auth-int"))) { PHALCON_CALL_SELF(&path, "getpath"); PHALCON_CALL_FUNCTION(&md5_entity_body, "md5", entity_body); PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VSVSV(tmp, method, ":", path, ":", md5_entity_body); PHALCON_CALL_FUNCTION(&ha2, "md5", tmp); } PHALCON_INIT_NVAR(key); ZVAL_STRING(key, "Authorization", 1); if (phalcon_array_isset_string_fetch(&nonce, digest, SS("nonce"))) { PHALCON_INIT_VAR(nonce); ZVAL_NULL(nonce); } if (PHALCON_IS_EMPTY(qop)) { PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VSVSV(tmp, ha1, ":", nonce, ":", ha2); PHALCON_CALL_FUNCTION(&value, "md5", tmp); PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_SV(tmp, "Digest ", value); PHALCON_CALL_METHOD(NULL, header, "set", key, tmp); } else { if (phalcon_array_isset_string_fetch(&nc, digest, SS("nc"))) { PHALCON_INIT_VAR(nc); ZVAL_NULL(nc); } if (phalcon_array_isset_string_fetch(&cnonce, digest, SS("cnonce"))) { PHALCON_INIT_VAR(cnonce); ZVAL_NULL(cnonce); } if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) { PHALCON_INIT_VAR(qoc); ZVAL_NULL(qoc); } if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) { PHALCON_INIT_VAR(qoc); ZVAL_NULL(qoc); } PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VSVSVS(tmp, ha1, ":", nonce, ":", nc, ":"); PHALCON_SCONCAT_VSVSV(tmp, cnonce, ":", qoc, ":", ha2); PHALCON_CALL_FUNCTION(&value, "md5", tmp); PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_SV(tmp, "Digest ", value); PHALCON_CALL_METHOD(NULL, header, "set", key, tmp); } } } PHALCON_INIT_VAR(http); ZVAL_STRING(http, "http", 1); PHALCON_CALL_FUNCTION(&uniqid, "uniqid"); PHALCON_INIT_VAR(boundary); PHALCON_CONCAT_SV(boundary, "--------------", uniqid); PHALCON_INIT_VAR(body); if (PHALCON_IS_NOT_EMPTY(data) && Z_TYPE_P(data) == IS_STRING){ PHALCON_INIT_NVAR(key); ZVAL_STRING(key, "Content-Type", 1); PHALCON_INIT_NVAR(value); ZVAL_STRING(value, "application/x-www-form-urlencoded", 1); PHALCON_CALL_METHOD(NULL, header, "set", key, value); PHALCON_INIT_NVAR(option); ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS); PHALCON_CALL_METHOD(&headers, header, "build", option); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "header", 1); PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "content", 1); PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, data); RETURN_MM(); } if (Z_TYPE_P(data) == IS_ARRAY) { phalcon_is_iterable(data, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(key, ah0, hp0); PHALCON_GET_HVALUE(value); PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n"); PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n"); zend_hash_move_forward_ex(ah0, &hp0); } } if (PHALCON_IS_NOT_EMPTY(file)) { PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file); if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) { PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file); PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n"); PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n"); PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n"); } } if (!PHALCON_IS_EMPTY(body)) { PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n"); PHALCON_INIT_NVAR(key); ZVAL_STRING(key, "Content-Type", 1); PHALCON_INIT_NVAR(value); PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary); PHALCON_CALL_METHOD(NULL, header, "set", key, value); PHALCON_INIT_NVAR(key); ZVAL_STRING(key, "Content-Length", 1); PHALCON_INIT_NVAR(value); ZVAL_LONG(value, Z_STRLEN_P(body)); PHALCON_CALL_METHOD(NULL, header, "set", key, value); PHALCON_INIT_NVAR(option); ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS); PHALCON_CALL_METHOD(&headers, header, "build", option); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "header", 1); PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers); PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "content", 1); PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, body); } PHALCON_MM_RESTORE(); }
/** * Produces a recursive representation of an array * * @param array $argument * @return string */ PHP_METHOD(Phalcon_Debug, _getArrayDump){ zval *argument, *n = NULL, *number_arguments, *one, *dump; zval *v = NULL, *k = NULL, *var_dump = NULL, *escaped_string = NULL, *next = NULL, *array_dump = NULL; zval *class_name = NULL, *joined_dump; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 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 TSRMLS_CC); if (PHALCON_LT_LONG(n, 3)) { if (PHALCON_GT_LONG(number_arguments, 0)) { if (PHALCON_LT_LONG(number_arguments, 10)) { PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(dump); array_init(dump); phalcon_is_iterable(argument, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(k, ah0, hp0); PHALCON_GET_HVALUE(v); if (PHALCON_IS_SCALAR(v)) { if (PHALCON_IS_STRING(v, "")) { PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVS(var_dump, "[", k, "] => (empty string)"); } else { PHALCON_INIT_NVAR(escaped_string); phalcon_call_method_p1(escaped_string, this_ptr, "_escapestring", v); PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", escaped_string); } phalcon_array_append(&dump, var_dump, PH_SEPARATE); } else { if (Z_TYPE_P(v) == IS_ARRAY) { PHALCON_INIT_NVAR(next); phalcon_add_function(next, n, one TSRMLS_CC); PHALCON_INIT_NVAR(array_dump); phalcon_call_method_p2(array_dump, this_ptr, "_getarraydump", v, next); PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Array(", array_dump, ")"); phalcon_array_append(&dump, var_dump, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); continue; } if (Z_TYPE_P(v) == IS_OBJECT) { PHALCON_INIT_NVAR(class_name); phalcon_get_class(class_name, v, 0 TSRMLS_CC); PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSVS(var_dump, "[", k, "] => Object(", class_name, ")"); phalcon_array_append(&dump, var_dump, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); continue; } if (Z_TYPE_P(v) == IS_NULL) { PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVS(var_dump, "[", k, "] => null"); phalcon_array_append(&dump, var_dump, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); continue; } PHALCON_INIT_NVAR(var_dump); PHALCON_CONCAT_SVSV(var_dump, "[", k, "] => ", v); phalcon_array_append(&dump, var_dump, PH_SEPARATE); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(joined_dump); phalcon_fast_join_str(joined_dump, SL(", "), dump TSRMLS_CC); RETURN_CTOR(joined_dump); } RETURN_NCTOR(number_arguments); } } RETURN_MM_NULL(); }
/** * Generates SQL to create a table in MySQL * * @param string $tableName * @param string $schemaName * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, createTable){ zval *table_name = NULL, *schema_name = NULL, *definition = NULL; zval *table = NULL, *temporary = NULL, *sql = NULL, *create_lines = NULL, *column = NULL; zval *column_line = NULL, *index = NULL, *index_name = NULL, *column_list = NULL; zval *reference = NULL, *reference_sql = 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, *r19 = NULL, *r20 = NULL; zval *r21 = NULL, *r22 = NULL, *r23 = NULL; zval *t0 = NULL, *t1 = NULL; zval *c0 = NULL; HashTable *ah0, *ah1, *ah2; HashPosition hp0, hp1, hp2; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVSVS(table, "`", schema_name, "`.`", table_name, "`"); } else { PHALCON_INIT_VAR(table); PHALCON_CONCAT_SVS(table, "`", table_name, "`"); } PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 0); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC); eval_int = phalcon_array_isset_string(r0, SL("temporary")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, r1, SL("temporary"), PH_NOISY_CC); if (zend_is_true(r2)) { PHALCON_INIT_VAR(temporary); ZVAL_BOOL(temporary, 1); } } } if (zend_is_true(temporary)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TEMPORARY TABLE ", table, " (\n\t"); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "CREATE TABLE ", table, " (\n\t"); } PHALCON_INIT_VAR(create_lines); array_init(create_lines); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, definition, SL("columns"), PH_NOISY_CC); if (!phalcon_valid_foreach(r3 TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(r3); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_52be_2: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_52be_2; } PHALCON_INIT_VAR(column); ZVAL_ZVAL(column, *hd, 1, 0); PHALCON_INIT_VAR(r4); PHALCON_CALL_METHOD(r4, column, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(r5); PHALCON_CALL_SELF_PARAMS_1(r5, this_ptr, "getcolumndefinition", column); PHALCON_INIT_VAR(column_line); PHALCON_CONCAT_SVSV(column_line, "`", r4, "` ", r5); PHALCON_INIT_VAR(r6); PHALCON_CALL_METHOD(r6, column, "isnotnull", PH_NO_CHECK); if (zend_is_true(r6)) { PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, " NOT NULL", 1); phalcon_concat_self(&column_line, t0 TSRMLS_CC); } PHALCON_INIT_VAR(r7); PHALCON_CALL_METHOD(r7, column, "isautoincrement", PH_NO_CHECK); if (zend_is_true(r7)) { PHALCON_INIT_VAR(t1); ZVAL_STRING(t1, " AUTO_INCREMENT", 1); phalcon_concat_self(&column_line, t1 TSRMLS_CC); } phalcon_array_append(&create_lines, column_line, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_52be_2; fee_52be_2: if(0){} eval_int = phalcon_array_isset_string(definition, SL("indexes")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_string(&r8, definition, SL("indexes"), PH_NOISY_CC); if (!phalcon_valid_foreach(r8 TSRMLS_CC)) { return; } ah1 = Z_ARRVAL_P(r8); zend_hash_internal_pointer_reset_ex(ah1, &hp1); fes_52be_3: if(zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS){ goto fee_52be_3; } PHALCON_INIT_VAR(index); ZVAL_ZVAL(index, *hd, 1, 0); PHALCON_INIT_VAR(index_name); PHALCON_CALL_METHOD(index_name, index, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(r9); PHALCON_CALL_METHOD(r9, index, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(column_list); PHALCON_CALL_SELF_PARAMS_1(column_list, this_ptr, "getcolumnlist", r9); if (PHALCON_COMPARE_STRING(index_name, "PRIMARY")) { PHALCON_INIT_VAR(r10); PHALCON_CONCAT_SVS(r10, "PRIMARY KEY (", column_list, ")"); phalcon_array_append(&create_lines, r10, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_VAR(r11); PHALCON_CONCAT_SVSVS(r11, "KEY `", index_name, "` (", column_list, ")"); phalcon_array_append(&create_lines, r11, PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah1, &hp1); goto fes_52be_3; fee_52be_3: if(0){} } eval_int = phalcon_array_isset_string(definition, SL("references")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r12); phalcon_array_fetch_string(&r12, definition, SL("references"), PH_NOISY_CC); if (!phalcon_valid_foreach(r12 TSRMLS_CC)) { return; } ah2 = Z_ARRVAL_P(r12); zend_hash_internal_pointer_reset_ex(ah2, &hp2); fes_52be_4: if(zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) != SUCCESS){ goto fee_52be_4; } PHALCON_INIT_VAR(reference); ZVAL_ZVAL(reference, *hd, 1, 0); PHALCON_INIT_VAR(r13); PHALCON_CALL_METHOD(r13, reference, "getname", PH_NO_CHECK); PHALCON_INIT_VAR(r14); PHALCON_CALL_METHOD(r14, reference, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(r15); PHALCON_CALL_SELF_PARAMS_1(r15, this_ptr, "getcolumnlist", r14); PHALCON_INIT_VAR(reference_sql); PHALCON_CONCAT_SVSV(reference_sql, "CONSTRAINT `", r13, "` FOREIGN KEY (", r15); PHALCON_INIT_VAR(r16); PHALCON_CALL_METHOD(r16, reference, "getreferencedtable", PH_NO_CHECK); PHALCON_INIT_VAR(r17); PHALCON_CALL_METHOD(r17, reference, "getreferencedcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(r18); PHALCON_CALL_SELF_PARAMS_1(r18, this_ptr, "getcolumnlist", r17); PHALCON_INIT_VAR(r19); PHALCON_CONCAT_SVSVS(r19, ") REFERENCES `", r16, "`(", r18, ")"); phalcon_concat_self(&reference_sql, r19 TSRMLS_CC); phalcon_array_append(&create_lines, reference_sql, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); goto fes_52be_4; fee_52be_4: if(0){} } PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, ",\n\t", 1); PHALCON_ALLOC_ZVAL_MM(r20); phalcon_fast_join(r20, c0, create_lines TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r21); PHALCON_CONCAT_VS(r21, r20, "\n)"); phalcon_concat_self(&sql, r21 TSRMLS_CC); eval_int = phalcon_array_isset_string(definition, SL("options")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r22); PHALCON_CALL_SELF_PARAMS_1(r22, this_ptr, "_gettableoptions", definition); PHALCON_ALLOC_ZVAL_MM(r23); PHALCON_CONCAT_SV(r23, " ", r22); phalcon_concat_self(&sql, r23 TSRMLS_CC); } RETURN_CTOR(sql); }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Exclusionin, validate){ zval *record, *option = NULL, *field_name = NULL, *is_set = NULL, *domain = NULL; zval *value = NULL, *message = NULL, *joined_domain, *type, *is_set_code = NULL, *code = NULL; 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_name, this_ptr, "getoption", option); if (Z_TYPE_P(field_name) != 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_name); /* * 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; } /** * We check if the value contained in the array using "in_array" from the PHP * userland */ 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_name, "' must not be part of list: ", joined_domain); } PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Exclusion", 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_name, type, code); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * Executes the validator * * @param Phalcon\Mvc\ModelInterface $record * @return boolean */ PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate){ zval *record, *option = NULL, *field, *dependency_injector; zval *service, *meta_data, *bind_types, *bind_data_types; zval *column_map = NULL, *conditions, *bind_params; zval *number = NULL, *compose_field = NULL, *column_field = NULL; zval *exception_message = NULL, *value = NULL, *compose_condition = NULL; zval *bind_type = NULL, *condition = NULL, *operation_made; zval *primary_fields, *primary_field = NULL, *attribute_field = NULL; zval *join_conditions, *params, *class_name; zval *message = NULL, *join_fields, *type; HashTable *ah0, *ah1; HashPosition hp0, hp1; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &record); PHALCON_INIT_VAR(option); ZVAL_STRING(option, "field", 1); PHALCON_INIT_VAR(field); phalcon_call_method_p1(field, this_ptr, "getoption", option); PHALCON_INIT_VAR(dependency_injector); phalcon_call_method(dependency_injector, record, "getdi"); PHALCON_INIT_VAR(service); ZVAL_STRING(service, "modelsMetadata", 1); PHALCON_INIT_VAR(meta_data); phalcon_call_method_p1(meta_data, dependency_injector, "getshared", service); /** * PostgreSQL check if the compared constant has the same type as the column, so we * make cast to the data passed to match those column types */ PHALCON_INIT_VAR(bind_types); array_init(bind_types); PHALCON_INIT_VAR(bind_data_types); phalcon_call_method_p1(bind_data_types, meta_data, "getbindtypes", record); if (PHALCON_GLOBAL(orm).column_renaming) { PHALCON_INIT_VAR(column_map); phalcon_call_method_p1(column_map, meta_data, "getreversecolumnmap", record); } else { PHALCON_INIT_NVAR(column_map); } PHALCON_INIT_VAR(conditions); array_init(conditions); PHALCON_INIT_VAR(bind_params); array_init(bind_params); PHALCON_INIT_VAR(number); ZVAL_LONG(number, 0); if (Z_TYPE_P(field) == IS_ARRAY) { /** * The field can be an array of values */ phalcon_is_iterable(field, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(compose_field); /** * The reversed column map is used in the case to get real column name */ if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, compose_field)) { PHALCON_OBS_NVAR(column_field); phalcon_array_fetch(&column_field, column_map, compose_field, PH_NOISY); } else { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", compose_field, "\" isn't part of the column map"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_CPY_WRT(column_field, compose_field); } /** * Some database systems require that we pass the values using bind casting */ if (!phalcon_array_isset(bind_data_types, column_field)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", column_field, "\" isn't part of the table columns"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * The attribute could be "protected" so we read using "readattribute" */ PHALCON_INIT_NVAR(value); phalcon_call_method_p1(value, record, "readattribute", compose_field); PHALCON_INIT_NVAR(compose_condition); PHALCON_CONCAT_SVSV(compose_condition, "[", compose_field, "] = ?", number); phalcon_array_append(&conditions, compose_condition, PH_SEPARATE); phalcon_array_append(&bind_params, value, PH_SEPARATE); PHALCON_OBS_NVAR(bind_type); phalcon_array_fetch(&bind_type, bind_data_types, column_field, PH_NOISY); phalcon_array_append(&bind_types, bind_type, PH_SEPARATE); phalcon_increment(number); zend_hash_move_forward_ex(ah0, &hp0); } } else { /** * The reversed column map is used in the case to get real column name */ if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, field)) { PHALCON_OBS_NVAR(column_field); phalcon_array_fetch(&column_field, column_map, field, PH_NOISY); } else { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", field, "\" isn't part of the column map"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_CPY_WRT(column_field, field); } /** * Some database systems require that we pass the values using bind casting */ if (!phalcon_array_isset(bind_data_types, column_field)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", column_field, "\" isn't part of the table columns"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * We're checking the uniqueness with only one field */ PHALCON_INIT_NVAR(value); phalcon_call_method_p1(value, record, "readattribute", field); PHALCON_INIT_VAR(condition); PHALCON_CONCAT_SVS(condition, "[", field, "] = ?0"); phalcon_array_append(&conditions, condition, PH_SEPARATE); phalcon_array_append(&bind_params, value, PH_SEPARATE); PHALCON_OBS_NVAR(bind_type); phalcon_array_fetch(&bind_type, bind_data_types, column_field, PH_NOISY); phalcon_array_append(&bind_types, bind_type, PH_SEPARATE); phalcon_increment(number); } /** * If the operation is update, there must be values in the object */ PHALCON_INIT_VAR(operation_made); phalcon_call_method(operation_made, record, "getoperationmade"); if (PHALCON_IS_LONG(operation_made, 2)) { /** * We build a query with the primary key attributes */ if (PHALCON_GLOBAL(orm).column_renaming) { PHALCON_INIT_NVAR(column_map); phalcon_call_method_p1(column_map, meta_data, "getcolumnmap", record); } else { PHALCON_INIT_NVAR(column_map); } PHALCON_INIT_VAR(primary_fields); phalcon_call_method_p1(primary_fields, meta_data, "getprimarykeyattributes", record); phalcon_is_iterable(primary_fields, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HVALUE(primary_field); if (!phalcon_array_isset(bind_data_types, primary_field)) { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", primary_field, "\" isn't part of the table columns"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } /** * Rename the column if there is a column map */ if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, primary_field)) { PHALCON_OBS_NVAR(attribute_field); phalcon_array_fetch(&attribute_field, column_map, primary_field, PH_NOISY); } else { PHALCON_INIT_NVAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", primary_field, "\" isn't part of the column map"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message); return; } } else { PHALCON_CPY_WRT(attribute_field, primary_field); } /** * Create a condition based on the renamed primary key */ PHALCON_INIT_NVAR(value); phalcon_call_method_p1(value, record, "readattribute", primary_field); PHALCON_INIT_NVAR(condition); PHALCON_CONCAT_SVSV(condition, "[", attribute_field, "] <> ?", number); phalcon_array_append(&conditions, condition, PH_SEPARATE); phalcon_array_append(&bind_params, value, PH_SEPARATE); PHALCON_OBS_NVAR(bind_type); phalcon_array_fetch(&bind_type, bind_data_types, primary_field, PH_NOISY); phalcon_array_append(&bind_types, bind_type, PH_SEPARATE); phalcon_increment(number); zend_hash_move_forward_ex(ah1, &hp1); } } PHALCON_INIT_VAR(join_conditions); phalcon_fast_join_str(join_conditions, SL(" AND "), conditions TSRMLS_CC); /** * We don't trust the user, so we pass the parameters as bound parameters */ PHALCON_INIT_VAR(params); array_init(params); phalcon_array_update_string(¶ms, SL("di"), &dependency_injector, PH_COPY | PH_SEPARATE); phalcon_array_update_string(¶ms, SL("conditions"), &join_conditions, PH_COPY | PH_SEPARATE); phalcon_array_update_string(¶ms, SL("bind"), &bind_params, PH_COPY | PH_SEPARATE); phalcon_array_update_string(¶ms, SL("bindTypes"), &bind_types, PH_COPY | PH_SEPARATE); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, record, 0 TSRMLS_CC); /** * Check using a standard count */ phalcon_call_zval_str_static_p1(number, class_name, "count", params); if (!PHALCON_IS_LONG(number, 0)) { /** * Check if the developer has defined a custom message */ PHALCON_INIT_NVAR(option); ZVAL_STRING(option, "message", 1); PHALCON_INIT_VAR(message); phalcon_call_method_p1(message, this_ptr, "getoption", option); if (!zend_is_true(message)) { if (Z_TYPE_P(field) == IS_ARRAY) { PHALCON_INIT_VAR(join_fields); phalcon_fast_join_str(join_fields, SL(", "), field TSRMLS_CC); PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVS(message, "Value of fields: '", join_fields, "' are already present in another record"); } else { PHALCON_INIT_NVAR(message); PHALCON_CONCAT_SVS(message, "Value of field: '", field, "' is already present in another record"); } } /** * Append the message to the validator */ PHALCON_INIT_VAR(type); ZVAL_STRING(type, "Unique", 1); phalcon_call_method_p3_noret(this_ptr, "appendmessage", message, field, type); RETURN_MM_FALSE; } RETURN_MM_TRUE; }
/** * 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); }
/** * Builds a SELECT statement * * @param array $definition * @return string */ PHP_METHOD(Phalcon_Db_Dialect, select){ zval *definition = NULL, *columns = NULL, *comma = NULL, *columns_sql = NULL; zval *tables = NULL, *tables_sql = NULL, *sql = NULL, *joins = NULL, *join = NULL, *type = NULL; zval *source = NULL, *sql_join = NULL, *and_word = NULL, *join_conditions_array = NULL; zval *join_conditions = NULL, *on_join = NULL, *where_conditions = NULL; zval *where_clause = NULL, *group_fields = NULL, *group_clause = NULL; zval *having_conditions = NULL, *having_clause = NULL, *order_fields = NULL; zval *order_clause = NULL, *limit_value = NULL, *limit_clause = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } eval_int = phalcon_array_isset_string(definition, SL("tables")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'tables' is required in the definition array"); return; } eval_int = phalcon_array_isset_string(definition, SL("columns")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The index 'columns' is required in the definition array"); return; } PHALCON_INIT_VAR(columns); phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC); if (Z_TYPE_P(columns) == IS_ARRAY) { PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ",", 1); PHALCON_INIT_VAR(columns_sql); phalcon_fast_join(columns_sql, comma, columns TSRMLS_CC); } else { PHALCON_CPY_WRT(columns_sql, columns); } PHALCON_INIT_VAR(tables); phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY_CC); if (Z_TYPE_P(tables) == IS_ARRAY) { PHALCON_INIT_VAR(comma); ZVAL_STRING(comma, ",", 1); PHALCON_INIT_VAR(tables_sql); phalcon_fast_join(tables_sql, comma, tables TSRMLS_CC); } else { PHALCON_CPY_WRT(tables_sql, tables); } PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSV(sql, "SELECT ", columns_sql, " FROM ", tables_sql); eval_int = phalcon_array_isset_string(definition, SL("joins")+1); if (eval_int) { PHALCON_INIT_VAR(joins); phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY_CC); if (!phalcon_valid_foreach(joins TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(joins); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_62b2_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_62b2_0; } PHALCON_INIT_VAR(join); ZVAL_ZVAL(join, *hd, 1, 0); PHALCON_INIT_VAR(type); phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY_CC); PHALCON_INIT_VAR(source); phalcon_array_fetch_string(&source, join, SL("source"), PH_NOISY_CC); PHALCON_INIT_VAR(sql_join); PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", source); eval_int = phalcon_array_isset_string(join, SL("conditions")+1); if (eval_int) { PHALCON_INIT_VAR(and_word); ZVAL_STRING(and_word, " AND ", 1); PHALCON_INIT_VAR(join_conditions_array); phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY_CC); PHALCON_INIT_VAR(join_conditions); phalcon_fast_join(join_conditions, and_word, join_conditions_array TSRMLS_CC); PHALCON_INIT_VAR(on_join); PHALCON_CONCAT_SV(on_join, " ON ", join_conditions); phalcon_concat_self(&sql_join, on_join TSRMLS_CC); } phalcon_concat_self(&sql, sql_join TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); goto fes_62b2_0; fee_62b2_0: if(0){} } eval_int = phalcon_array_isset_string(definition, SL("where")+1); if (eval_int) { PHALCON_INIT_VAR(where_conditions); phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY_CC); PHALCON_INIT_VAR(where_clause); PHALCON_CONCAT_SV(where_clause, " WHERE ", where_conditions); phalcon_concat_self(&sql, where_clause TSRMLS_CC); } eval_int = phalcon_array_isset_string(definition, SL("group")+1); if (eval_int) { PHALCON_INIT_VAR(group_fields); phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY_CC); PHALCON_INIT_VAR(group_clause); PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_fields); phalcon_concat_self(&sql, group_clause TSRMLS_CC); eval_int = phalcon_array_isset_string(definition, SL("having")+1); if (eval_int) { PHALCON_INIT_VAR(having_conditions); phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY_CC); PHALCON_INIT_VAR(having_clause); PHALCON_CONCAT_SV(having_clause, " HAVING ", having_conditions); phalcon_concat_self(&sql, having_clause TSRMLS_CC); } } eval_int = phalcon_array_isset_string(definition, SL("order")+1); if (eval_int) { PHALCON_INIT_VAR(order_fields); phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY_CC); PHALCON_INIT_VAR(order_clause); PHALCON_CONCAT_SV(order_clause, " ORDER BY ", order_fields); phalcon_concat_self(&sql, order_clause TSRMLS_CC); } eval_int = phalcon_array_isset_string(definition, SL("limit")+1); if (eval_int) { PHALCON_INIT_VAR(limit_value); phalcon_array_fetch_string(&limit_value, definition, SL("limit"), PH_NOISY_CC); PHALCON_INIT_VAR(limit_clause); PHALCON_CONCAT_SV(limit_clause, " LIMIT ", limit_value); phalcon_concat_self(&sql, limit_clause TSRMLS_CC); } RETURN_CTOR(sql); }