/** * Generates the SQL to describe the table creation options * * @param string $table * @param string $schema * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, tableOptions){ zval *table = NULL, *schema = NULL, *sql = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(sql); ZVAL_STRING(sql, "SELECT TABLES.TABLE_TYPE,TABLES.AUTO_INCREMENT,TABLES.ENGINE,TABLES.TABLE_COLLATION FROM INFORMATION_SCHEMA.TABLES WHERE ", 1); if (zend_is_true(schema)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "TABLES.TABLE_SCHEMA = \"", schema, "\" AND TABLES.TABLE_NAME = \"", table, "\""); phalcon_concat_self(&sql, r0 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "TABLES.TABLE_NAME = \"", table, "\""); phalcon_concat_self(&sql, r1 TSRMLS_CC); } RETURN_CTOR(sql); }
/** * Generates SQL to query foreign keys on a table * * @param string $table * @param string $schema * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, describeReferences){ zval *table = NULL, *schema = NULL, *sql = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(sql); ZVAL_STRING(sql, "SELECT TABLE_NAME,COLUMN_NAME,CONSTRAINT_NAME,REFERENCED_TABLE_SCHEMA,REFERENCED_TABLE_NAME,REFERENCED_COLUMN_NAME\n\t\t\tFROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE REFERENCED_TABLE_NAME IS NOT NULL AND ", 1); if (zend_is_true(schema)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "CONSTRAINT_SCHEMA = \"", schema, "\" AND TABLE_NAME = \"", table, "\""); phalcon_concat_self(&sql, r0 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "TABLE_NAME = \"", table, "\""); phalcon_concat_self(&sql, r1 TSRMLS_CC); } RETURN_CTOR(sql); }
/** * 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); }
/** * Generates SQL to query foreign keys on a table * * @param string $table * @param string $schema * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Postgresql, describeReferences){ zval *table = NULL, *schema = NULL, *sql = NULL, *final_sql = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &table, &schema) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!schema) { PHALCON_ALLOC_ZVAL_MM(schema); ZVAL_NULL(schema); } PHALCON_INIT_VAR(sql); ZVAL_STRING(sql, "SELECT tc.table_name as TABLE_NAME, kcu.column_name as COLUMN_NAME, tc.constraint_name as CONSTRAINT_NAME, tc.table_catalog as REFERENCED_TABLE_SCHEMA, ccu.table_name AS REFERENCED_TABLE_NAME, ccu.column_name AS REFERENCED_COLUMN_NAME FROM information_schema.table_constraints AS tc JOIN information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name JOIN information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name WHERE constraint_type = 'FOREIGN KEY' AND ", 1); if (zend_is_true(schema)) { PHALCON_INIT_VAR(final_sql); PHALCON_CONCAT_SVSVS(final_sql, "tc.table_schema = '", schema, "' AND tc.table_name='", table, "'"); } else { PHALCON_INIT_VAR(final_sql); PHALCON_CONCAT_SVS(final_sql, "tc.table_name='", table, "'"); } phalcon_concat_self(&sql, final_sql TSRMLS_CC); RETURN_CTOR(sql); }
/** * Generates SQL to delete an index from a table * * @param string $tableName * @param string $schemaName * @param string $indexName * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, dropIndex){ zval *table_name = NULL, *schema_name = NULL, *index_name = NULL; zval *sql = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &index_name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (zend_is_true(schema_name)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "ALTER TABLE `", schema_name, "`.`", table_name, "` DROP INDEX "); PHALCON_CPY_WRT(sql, r0); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "ALTER TABLE `", table_name, "` DROP INDEX "); PHALCON_CPY_WRT(sql, r1); } PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CONCAT_SVS(r2, "`", index_name, "`"); phalcon_concat_self(&sql, r2 TSRMLS_CC); PHALCON_RETURN_CTOR(sql); }
/** * Generates SQL to delete a foreign key from a table * * @param string $tableName * @param string $schemaName * @param string $referenceName * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, dropForeignKey){ zval *table_name = NULL, *schema_name = NULL, *reference_name = NULL; zval *sql = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &reference_name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSVS(sql, "ALTER TABLE `", schema_name, "`.`", table_name, "` DROP FOREIGN KEY "); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "ALTER TABLE `", table_name, "` DROP FOREIGN KEY "); } PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVS(r0, "`", reference_name, "`"); phalcon_concat_self(&sql, r0 TSRMLS_CC); RETURN_CTOR(sql); }
/** * Returns the active version (string) * * @return string */ PHP_METHOD(Phalcon_Version, get){ zval *version, *major, *medium, *minor, *special, *special_number; zval *result, *suffix = NULL, *final_version; PHALCON_MM_GROW(); PHALCON_INIT_VAR(version); PHALCON_CALL_SELF(version, this_ptr, "_getversion"); PHALCON_INIT_VAR(major); phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC); PHALCON_INIT_VAR(medium); phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC); PHALCON_INIT_VAR(minor); phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC); PHALCON_INIT_VAR(special); phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC); PHALCON_INIT_VAR(special_number); phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC); PHALCON_INIT_VAR(result); PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " "); if (phalcon_compare_strict_long(special, 1 TSRMLS_CC)) { PHALCON_INIT_VAR(suffix); PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number); goto ph_end_0; } if (phalcon_compare_strict_long(special, 2 TSRMLS_CC)) { PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "BETA ", special_number); goto ph_end_0; } if (phalcon_compare_strict_long(special, 1 TSRMLS_CC)) { PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "RC ", special_number); goto ph_end_0; } PHALCON_INIT_NVAR(suffix); ZVAL_STRING(suffix, "", 1); goto ph_end_0; ph_end_0: phalcon_concat_self(result, suffix TSRMLS_CC); PHALCON_INIT_VAR(final_version); PHALCON_CALL_FUNC_PARAMS_1(final_version, "trim", result); RETURN_CCTOR(final_version); }
/** * Returns the active version (string) * * <code> * echo Phalcon\Version::get(); * </code> * * @return string */ PHP_METHOD(Phalcon_Version, get){ zval *version, *major, *medium, *minor, *special, *special_number; zval *result, *suffix = NULL, *final_version; PHALCON_MM_GROW(); PHALCON_INIT_VAR(version); PHALCON_CALL_SELF(version, this_ptr, "_getversion"); PHALCON_OBS_VAR(major); phalcon_array_fetch_long(&major, version, 0, PH_NOISY_CC); PHALCON_OBS_VAR(medium); phalcon_array_fetch_long(&medium, version, 1, PH_NOISY_CC); PHALCON_OBS_VAR(minor); phalcon_array_fetch_long(&minor, version, 2, PH_NOISY_CC); PHALCON_OBS_VAR(special); phalcon_array_fetch_long(&special, version, 3, PH_NOISY_CC); PHALCON_OBS_VAR(special_number); phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY_CC); PHALCON_INIT_VAR(result); PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " "); switch (phalcon_get_intval(special)) { case 1: PHALCON_INIT_VAR(suffix); PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number); break; case 2: PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "BETA ", special_number); break; case 3: PHALCON_INIT_NVAR(suffix); PHALCON_CONCAT_SV(suffix, "RC ", special_number); break; default: PHALCON_INIT_NVAR(suffix); ZVAL_STRING(suffix, "", 1); break; } phalcon_concat_self(&result, suffix TSRMLS_CC); PHALCON_INIT_VAR(final_version); PHALCON_CALL_FUNC_PARAMS_1(final_version, "trim", result); RETURN_CCTOR(final_version); }
/** * Returns the active version (string) * * <code> * echo Phalcon\Version::get(); * </code> * * @return string */ PHP_METHOD(Phalcon_Version, get){ zval *version = NULL, *major, *medium, *minor, *special, *special_number; zval *result, *suffix; PHALCON_MM_GROW(); PHALCON_CALL_SELF(&version, "_getversion"); PHALCON_OBS_VAR(major); phalcon_array_fetch_long(&major, version, 0, PH_NOISY); PHALCON_OBS_VAR(medium); phalcon_array_fetch_long(&medium, version, 1, PH_NOISY); PHALCON_OBS_VAR(minor); phalcon_array_fetch_long(&minor, version, 2, PH_NOISY); PHALCON_OBS_VAR(special); phalcon_array_fetch_long(&special, version, 3, PH_NOISY); PHALCON_OBS_VAR(special_number); phalcon_array_fetch_long(&special_number, version, 4, PH_NOISY); PHALCON_INIT_VAR(result); PHALCON_CONCAT_VSVSVS(result, major, ".", medium, ".", minor, " "); PHALCON_INIT_VAR(suffix); switch (phalcon_get_intval(special)) { case PHALCON_VERSION_ALPHA: PHALCON_CONCAT_SV(suffix, "ALPHA ", special_number); break; case PHALCON_VERSION_BETA: PHALCON_CONCAT_SV(suffix, "BETA ", special_number); break; case PHALCON_VERSION_RC: PHALCON_CONCAT_SV(suffix, "RC ", special_number); break; default: ZVAL_STRING(suffix, "", 1); break; } phalcon_concat_self(&result, suffix TSRMLS_CC); phalcon_fast_trim(return_value, result, PHALCON_TRIM_BOTH TSRMLS_CC); RETURN_MM(); }
/** * Generates SQL to add an index to a table * * @param string $tableName * @param string $schemaName * @param Phalcon_Db_Index $index * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, addIndex){ zval *table_name = NULL, *schema_name = NULL, *index = NULL, *sql = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &index) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(index) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Index parameter must be an instance of Phalcon_Db_Index"); return; } if (zend_is_true(schema_name)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD INDEX "); PHALCON_CPY_WRT(sql, r0); } else { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, "ALTER TABLE `", table_name, "` ADD INDEX "); PHALCON_CPY_WRT(sql, r1); } PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CALL_METHOD(r3, index, "getname", PHALCON_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, index, "getcolumns", PHALCON_NO_CHECK); PHALCON_CALL_SELF_PARAMS_1(r4, this_ptr, "getcolumnlist", r5); PHALCON_CONCAT_SVSVS(r2, "`", r3, "` (", r4, ")"); phalcon_concat_self(&sql, r2 TSRMLS_CC); PHALCON_RETURN_CTOR(sql); }
/** * Generates SQL to add an index to a table * * @param string $tableName * @param string $schemaName * @param Phalcon\Db\Index $index * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, addIndex){ zval *table_name = NULL, *schema_name = NULL, *index = NULL, *sql = NULL, *columns = NULL; zval *quoted_column_list = NULL, *name = NULL; zval *r0 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &index) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(index) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Index parameter must be an instance of Phalcon\\Db\\Index"); return; } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSVS(sql, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD INDEX "); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "ALTER TABLE `", table_name, "` ADD INDEX "); } PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD(columns, index, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(quoted_column_list); PHALCON_CALL_METHOD_PARAMS_1(quoted_column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK); PHALCON_INIT_VAR(name); PHALCON_CALL_METHOD(name, index, "getname", PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SVSVS(r0, "`", name, "` (", quoted_column_list, ")"); phalcon_concat_self(&sql, r0 TSRMLS_CC); RETURN_CTOR(sql); }
/** * Builds a HTML tag closing tag * *<code> * echo Phalcon\Tag::tagHtmlClose('script', true) *</code> * * @param string $tagName * @param boolean $useEol * @return string */ PHP_METHOD(Phalcon_Tag, tagHtmlClose){ zval *tag_name, *use_eol = NULL, *local_code, *eol; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &tag_name, &use_eol); if (!use_eol) { PHALCON_INIT_VAR(use_eol); ZVAL_BOOL(use_eol, 0); } PHALCON_INIT_VAR(local_code); PHALCON_CONCAT_SVS(local_code, "</", tag_name, ">"); if (zend_is_true(use_eol)) { PHALCON_INIT_VAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); phalcon_concat_self(&local_code, eol TSRMLS_CC); } RETURN_CTOR(local_code); }
/** * Builds a HTML tag * *<code> * echo Phalcon\Tag::tagHtml($name, $parameters, $selfClose, $onlyStart, $eol); *</code> * * @param string $tagName * @param array $parameters * @param boolean $selfClose * @param boolean $onlyStart * @param boolean $useEol * @return string */ PHP_METHOD(Phalcon_Tag, tagHtml){ zval *tag_name, *parameters = NULL, *self_close = NULL, *only_start = NULL; zval *use_eol = NULL, *params = NULL, *local_code, *value = NULL, *key = NULL; zval *five, *doctype, *is_xhtml, *eol; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 4, &tag_name, ¶meters, &self_close, &only_start, &use_eol); if (!parameters) { PHALCON_INIT_VAR(parameters); } if (!self_close) { PHALCON_INIT_VAR(self_close); ZVAL_BOOL(self_close, 0); } if (!only_start) { PHALCON_INIT_VAR(only_start); ZVAL_BOOL(only_start, 0); } if (!use_eol) { PHALCON_INIT_VAR(use_eol); ZVAL_BOOL(use_eol, 0); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 1); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(local_code); PHALCON_CONCAT_SV(local_code, "<", tag_name); if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(value); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_SCONCAT_SVSVS(local_code, " ", key, "=\"", value, "\""); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(five); ZVAL_LONG(five, 5); PHALCON_OBS_VAR(doctype); phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC); /** * Check if Doctype is XHTML */ PHALCON_INIT_VAR(is_xhtml); is_smaller_function(is_xhtml, five, doctype TSRMLS_CC); if (zend_is_true(is_xhtml)) { if (zend_is_true(self_close)) { phalcon_concat_self_str(&local_code, SL(" />") TSRMLS_CC); } else { phalcon_concat_self_str(&local_code, SL(">") TSRMLS_CC); } } else { if (zend_is_true(only_start)) { phalcon_concat_self_str(&local_code, SL(">") TSRMLS_CC); } else { PHALCON_SCONCAT_SVS(local_code, "></", tag_name, ">"); } } if (zend_is_true(use_eol)) { PHALCON_INIT_VAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); phalcon_concat_self(&local_code, eol TSRMLS_CC); } RETURN_CTOR(local_code); }
/** * Prints the HTML for JS resources * * @param string $collectionName */ PHP_METHOD(Phalcon_Assets_Manager, outputJs){ zval *collection_name = NULL, *collection = NULL, *output; zval *use_implicit_output, *resources, *prefix; zval *resource = NULL, *path = NULL, *local = NULL, *prefixed_path = NULL, *html = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &collection_name) == FAILURE) { RETURN_MM_NULL(); } if (!collection_name) { PHALCON_INIT_VAR(collection_name); } if (PHALCON_IS_EMPTY(collection_name)) { PHALCON_INIT_VAR(collection); PHALCON_CALL_METHOD(collection, this_ptr, "getjs"); } else { PHALCON_INIT_NVAR(collection); PHALCON_CALL_METHOD_PARAMS_1(collection, this_ptr, "get", collection_name); } PHALCON_INIT_VAR(output); PHALCON_OBS_VAR(use_implicit_output); phalcon_read_property_this(&use_implicit_output, this_ptr, SL("_implicitOutput"), PH_NOISY_CC); /** * Get the resources as an array */ PHALCON_INIT_VAR(resources); PHALCON_CALL_METHOD(resources, collection, "getresources"); /** * Get the collection's prefix */ PHALCON_INIT_VAR(prefix); PHALCON_CALL_METHOD(prefix, collection, "getprefix"); if (!phalcon_is_iterable(resources, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(resource); PHALCON_INIT_NVAR(path); PHALCON_CALL_METHOD(path, resource, "getpath"); PHALCON_INIT_NVAR(local); PHALCON_CALL_METHOD(local, resource, "getlocal"); if (Z_TYPE_P(prefix) != IS_NULL) { PHALCON_INIT_NVAR(prefixed_path); PHALCON_CONCAT_VV(prefixed_path, prefix, path); } else { PHALCON_CPY_WRT(prefixed_path, path); } /** * Generate the html using Phalcon\Tag */ PHALCON_INIT_NVAR(html); PHALCON_CALL_STATIC_PARAMS_2(html, "phalcon\\tag", "javascriptinclude", prefixed_path, local); if (zend_is_true(use_implicit_output)) { zend_print_zval(html, 0); } else { phalcon_concat_self(&output, html TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } RETURN_CCTOR(output); }
/** * 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); }
PHP_METHOD(Phalcon_Tag_Select, select){ zval *parameters = NULL, *data = NULL, *params = NULL, *eol = NULL, *id = NULL, *value = NULL, *dummy_value = NULL; zval *dummy_text = NULL, *code = NULL, *avalue = NULL, *key = NULL, *close_option = NULL; zval *options = NULL, *using = NULL; zval *a0 = NULL; zval *t0 = NULL, *t1 = 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 *p1[] = { NULL, NULL, NULL, NULL }; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &data) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!data) { PHALCON_INIT_VAR(data); ZVAL_NULL(data); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(a0); array_init(a0); phalcon_array_append(&a0, parameters, PHALCON_SEPARATE_PLZ TSRMLS_CC); phalcon_array_append(&a0, data, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_CPY_WRT(params, a0); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_ALLOC_ZVAL_MM(t0); zend_get_constant("PHP_EOL", strlen("PHP_EOL"), t0 TSRMLS_CC); PHALCON_CPY_WRT(eol, t0); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_array_fetch_long(&r0, params, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(id, r0); eval_int = phalcon_array_isset_string(params, "value", strlen("value")+1); if (!eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CALL_STATIC_PARAMS_1(r1, "phalcon_tag", "getvalue", id); PHALCON_CPY_WRT(value, r1); } else { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_string(&r2, params, "value", strlen("value"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(value, r2); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, "value", strlen("value")+1); } eval_int = phalcon_array_isset_string(params, "dummyValue", strlen("dummyValue")+1); if (!eval_int) { PHALCON_INIT_VAR(dummy_value); ZVAL_STRING(dummy_value, "", 1); } else { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, params, "dummyValue", strlen("dummyValue"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(dummy_value, r3); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, "dummyValue", strlen("dummyValue")+1); } eval_int = phalcon_array_isset_string(params, "dummyText", strlen("dummyText")+1); if (!eval_int) { PHALCON_INIT_VAR(dummy_text); ZVAL_STRING(dummy_text, "Choose...", 1); } else { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_string(&r4, params, "dummyText", strlen("dummyText"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(dummy_text, r4); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, "dummyText", strlen("dummyText")+1); } PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CONCAT_SVSVS(r5, "<select id=\"", id, "\" name=\"", id, "\""); PHALCON_CPY_WRT(code, r5); if (Z_TYPE_P(params) == IS_ARRAY) { if (phalcon_valid_foreach(params TSRMLS_CC)) { ah0 = Z_ARRVAL_P(params); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_9c31_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_9c31_0; } else { PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); } PHALCON_INIT_VAR(avalue); ZVAL_ZVAL(avalue, *hd, 1, 0); if (Z_TYPE_P(key) != IS_LONG) { if (Z_TYPE_P(avalue) != IS_ARRAY) { PHALCON_INIT_VAR(r6); PHALCON_CONCAT_SVSVS(r6, " ", key, "=\"", avalue, "\""); phalcon_concat_self(&code, r6 TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); goto fes_9c31_0; fee_9c31_0: if(0){} } else { return; } } PHALCON_ALLOC_ZVAL_MM(r7); PHALCON_CONCAT_SV(r7, ">", eol); phalcon_concat_self(&code, r7 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); PHALCON_CONCAT_SV(r8, "</option>", eol); PHALCON_CPY_WRT(close_option, r8); eval_int = phalcon_array_isset_string(params, "useDummy", strlen("useDummy")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r9); PHALCON_CONCAT_SVSVV(r9, "\t<option value=\"", dummy_value, "\">", dummy_text, close_option); phalcon_concat_self(&code, r9 TSRMLS_CC); } eval_int = phalcon_array_isset_long(params, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r10); phalcon_array_fetch_long(&r10, params, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(options, r10); } else { PHALCON_CPY_WRT(options, data); } if (Z_TYPE_P(options) == IS_OBJECT) { eval_int = phalcon_array_isset_string(params, "using", strlen("using")+1); if (!eval_int) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required"); return; } else { PHALCON_ALLOC_ZVAL_MM(r11); phalcon_array_fetch_string(&r11, params, "using", strlen("using"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(using, r11); if (Z_TYPE_P(using) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array"); return; } } PHALCON_ALLOC_ZVAL_MM(r12); p1[0] = options; p1[1] = using; p1[2] = value; p1[3] = close_option; PHALCON_CALL_SELF_PARAMS(r12, this_ptr, "_optionsfromresultset", 4, p1); phalcon_concat_self(&code, r12 TSRMLS_CC); } else {
/** * Outputs a message formatting it with HTML * *<code> * $flash->outputMessage('error', $message); *</code> * * @param string $type * @param string $message */ PHP_METHOD(Phalcon_Flash, outputMessage){ zval *type, *message, *automatic_html, *classes; zval *type_classes, *joined_classes, *css_classes = NULL; zval *eol = NULL, *implicit_flush, *content, *msg = NULL, *html_message = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) { RETURN_MM_NULL(); } PHALCON_OBS_VAR(automatic_html); phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_OBS_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC); if (phalcon_array_isset(classes, type)) { PHALCON_OBS_VAR(type_classes); phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC); if (Z_TYPE_P(type_classes) == IS_ARRAY) { PHALCON_INIT_VAR(joined_classes); phalcon_fast_join_str(joined_classes, SL(" "), type_classes TSRMLS_CC); PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\""); } else { PHALCON_INIT_NVAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\""); } } else { PHALCON_INIT_NVAR(css_classes); ZVAL_STRING(css_classes, "", 1); } PHALCON_INIT_VAR(eol); PHALCON_INIT_NVAR(eol); ZVAL_STRING(eol, PHP_EOL, 1); } PHALCON_OBS_VAR(implicit_flush); phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC); if (Z_TYPE_P(message) == IS_ARRAY) { /** * We create the message with implicit flush or other */ if (PHALCON_IS_FALSE(implicit_flush)) { PHALCON_INIT_VAR(content); ZVAL_STRING(content, "", 1); } /** * We create the message with implicit flush or other */ if (!phalcon_is_iterable(message, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(msg); /** * We create the applying formatting or not */ if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_NVAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, msg); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 0); } else { phalcon_concat_self(&content, html_message TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } /** * We return the message as string if the implicit_flush is turned off */ if (PHALCON_IS_FALSE(implicit_flush)) { RETURN_CTOR(content); } } else { /** * We create the applying formatting or not */ if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_NVAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, message); } /** * We return the message as string if the implicit_flush is turned off */ if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 0); } else { RETURN_CCTOR(html_message); } } PHALCON_MM_RESTORE(); }
/** * 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); }
/** * Handles uncaught exceptions * * @param \Exception $exception * @return boolean */ PHP_METHOD(Phalcon_Debug, onUncaughtException){ zval *exception, *is_active = NULL, *message = NULL; zval *class_name, *css_sources, *escaped_message = NULL; zval *html, *version, *file, *line, *show_back_trace; zval *data_vars, *trace, *trace_item = NULL, *n = NULL, *html_item = NULL; zval *_REQUEST, *value = NULL, *key_request = NULL, *_SERVER; zval *key_server = NULL, *files, *key_file = NULL; zval *memory, *data_var = NULL, *key_var = NULL, *variable = NULL, *dumped_argument = NULL; zval *js_sources; HashTable *ah0, *ah1, *ah2, *ah3, *ah4; HashPosition hp0, hp1, hp2, hp3, hp4; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &exception); /** * Cancel the output buffer if active */ if (phalcon_ob_get_level(TSRMLS_C) > 0) { phalcon_ob_end_clean(TSRMLS_C); } PHALCON_OBS_VAR(is_active); phalcon_read_static_property(&is_active, SL("phalcon\\debug"), SL("_isActive") TSRMLS_CC); /** * Avoid that multiple exceptions being showed */ if (zend_is_true(is_active)) { PHALCON_INIT_VAR(message); phalcon_call_method(message, exception, "getmessage"); zend_print_zval(message, 0); } PHALCON_INIT_NVAR(is_active); ZVAL_BOOL(is_active, 1); /** * Globally block the debug component to avoid other exceptions must be shown */ phalcon_update_static_property(SL("phalcon\\debug"), SL("_isActive"), is_active TSRMLS_CC); PHALCON_INIT_VAR(class_name); phalcon_get_class(class_name, exception, 0 TSRMLS_CC); PHALCON_INIT_NVAR(message); phalcon_call_method(message, exception, "getmessage"); /** * CSS static sources to style the error presentation */ PHALCON_INIT_VAR(css_sources); phalcon_call_method(css_sources, this_ptr, "getcsssources"); /** * Escape the exception's message avoiding possible XSS injections? */ PHALCON_CPY_WRT(escaped_message, message); /** * Use the exception info as document's title */ PHALCON_INIT_VAR(html); PHALCON_CONCAT_SVSVS(html, "<html><head><title>", class_name, ": ", escaped_message, "</title>"); PHALCON_SCONCAT_VS(html, css_sources, "</head><body>"); /** * Get the version link */ PHALCON_INIT_VAR(version); phalcon_call_method(version, this_ptr, "getversion"); phalcon_concat_self(&html, version TSRMLS_CC); PHALCON_INIT_VAR(file); phalcon_call_method(file, exception, "getfile"); PHALCON_INIT_VAR(line); phalcon_call_method(line, exception, "getline"); /** * Main exception info */ phalcon_concat_self_str(&html, SL("<div align=\"center\"><div class=\"error-main\">") TSRMLS_CC); PHALCON_SCONCAT_SVSVS(html, "<h1>", class_name, ": ", escaped_message, "</h1>"); PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-file\">", file, " (", line, ")</span>"); phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC); PHALCON_OBS_VAR(show_back_trace); phalcon_read_property_this(&show_back_trace, this_ptr, SL("_showBackTrace"), PH_NOISY_CC); /** * Check if the developer wants to show the backtrace or not */ if (zend_is_true(show_back_trace)) { PHALCON_OBS_VAR(data_vars); phalcon_read_property_this(&data_vars, this_ptr, SL("_data"), PH_NOISY_CC); /** * Create the tabs in the page */ phalcon_concat_self_str(&html, SL("<div class=\"error-info\"><div id=\"tabs\"><ul>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-1\">Backtrace</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-2\">Request</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-3\">Server</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-4\">Included Files</a></li>") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-5\">Memory</a></li>") TSRMLS_CC); if (Z_TYPE_P(data_vars) == IS_ARRAY) { phalcon_concat_self_str(&html, SL("<li><a href=\"#error-tabs-6\">Variables</a></li>") TSRMLS_CC); } phalcon_concat_self_str(&html, SL("</ul>") TSRMLS_CC); /** * Print backtrace */ phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-1\"><table cellspacing=\"0\" align=\"center\" width=\"100%\">") TSRMLS_CC); PHALCON_INIT_VAR(trace); phalcon_call_method(trace, exception, "gettrace"); phalcon_is_iterable(trace, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(n, ah0, hp0); PHALCON_GET_HVALUE(trace_item); /** * Every line in the trace is rendered using 'showTraceItem' */ PHALCON_INIT_NVAR(html_item); phalcon_call_method_p2(html_item, this_ptr, "showtraceitem", n, trace_item); phalcon_concat_self(&html, html_item TSRMLS_CC); zend_hash_move_forward_ex(ah0, &hp0); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Print _REQUEST superglobal */ phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-2\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC); phalcon_get_global(&_REQUEST, SS("_REQUEST") TSRMLS_CC); phalcon_is_iterable(_REQUEST, &ah1, &hp1, 0, 0); while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_HKEY(key_request, ah1, hp1); PHALCON_GET_HVALUE(value); PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_request, "</td><td>", value, "</td></tr>"); zend_hash_move_forward_ex(ah1, &hp1); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Print _SERVER superglobal */ phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-3\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC); phalcon_get_global(&_SERVER, SS("_SERVER") TSRMLS_CC); phalcon_is_iterable(_SERVER, &ah2, &hp2, 0, 0); while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_HKEY(key_server, ah2, hp2); PHALCON_GET_HVALUE(value); PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_server, "</td><td>", value, "</td></tr>"); zend_hash_move_forward_ex(ah2, &hp2); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Show included files */ PHALCON_INIT_VAR(files); phalcon_call_func(files, "get_included_files"); phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-4\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>#</th><th>Path</th></tr>") TSRMLS_CC); phalcon_is_iterable(files, &ah3, &hp3, 0, 0); while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_HKEY(key_file, ah3, hp3); PHALCON_GET_HVALUE(value); PHALCON_SCONCAT_SVSVS(html, "<tr><td>", key_file, "</th><td>", value, "</td></tr>"); zend_hash_move_forward_ex(ah3, &hp3); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Memory usage */ PHALCON_INIT_VAR(memory); ZVAL_LONG(memory, zend_memory_usage(1 TSRMLS_CC)); phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-5\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); PHALCON_SCONCAT_SVS(html, "<tr><th colspan=\"2\">Memory</th></tr><tr><td>Usage</td><td>", memory, "</td></tr>"); phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); /** * Print extra variables passed to the component */ if (Z_TYPE_P(data_vars) == IS_ARRAY) { phalcon_concat_self_str(&html, SL("<div id=\"error-tabs-6\"><table cellspacing=\"0\" align=\"center\" class=\"superglobal-detail\">") TSRMLS_CC); phalcon_concat_self_str(&html, SL("<tr><th>Key</th><th>Value</th></tr>") TSRMLS_CC); phalcon_is_iterable(data_vars, &ah4, &hp4, 0, 0); while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_HKEY(key_var, ah4, hp4); PHALCON_GET_HVALUE(data_var); PHALCON_OBS_NVAR(variable); phalcon_array_fetch_long(&variable, data_var, 0, PH_NOISY); PHALCON_INIT_NVAR(dumped_argument); phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", variable); PHALCON_SCONCAT_SVSVS(html, "<tr><td class=\"key\">", key_var, "</td><td>", dumped_argument, "</td></tr>"); zend_hash_move_forward_ex(ah4, &hp4); } phalcon_concat_self_str(&html, SL("</table></div>") TSRMLS_CC); } phalcon_concat_self_str(&html, SL("</div>") TSRMLS_CC); } /** * Get Javascript sources */ PHALCON_INIT_VAR(js_sources); phalcon_call_method(js_sources, this_ptr, "getjssources"); PHALCON_SCONCAT_VS(html, js_sources, "</div></body></html>"); /** * Print the HTML, @TODO, add an option to store the html */ zend_print_zval(html, 0); PHALCON_INIT_NVAR(is_active); ZVAL_BOOL(is_active, 0); /** * Unlock the exception renderer */ phalcon_update_static_property(SL("phalcon\\debug"), SL("_isActive"), is_active TSRMLS_CC); RETURN_MM_TRUE; }
/** * Generates a SELECT tag * * @param array $parameters * @param array $data */ PHP_METHOD(Phalcon_Tag_Select, selectField){ zval *parameters, *data = NULL, *params = NULL, *eol, *id = NULL, *name, *value = NULL; zval *use_empty = NULL, *empty_value = NULL, *empty_text = NULL, *code; zval *avalue = NULL, *key = NULL, *close_option, *options = NULL, *using; zval *resultset_options, *array_options; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", ¶meters, &data) == FAILURE) { RETURN_MM_NULL(); } if (!data) { PHALCON_INIT_VAR(data); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init_size(params, 2); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); phalcon_array_append(¶ms, data, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(eol); zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC); if (!phalcon_array_isset_long(params, 0)) { PHALCON_OBS_VAR(id); phalcon_array_fetch_string(&id, params, SL("id"), PH_NOISY_CC); phalcon_array_update_long(¶ms, 0, &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } PHALCON_OBS_NVAR(id); phalcon_array_fetch_long(&id, params, 0, PH_NOISY_CC); if (!phalcon_array_isset_string(params, SS("name"))) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } else { PHALCON_OBS_VAR(name); phalcon_array_fetch_string(&name, params, SL("name"), PH_NOISY_CC); if (!zend_is_true(name)) { phalcon_array_update_string(¶ms, SL("name"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } } if (!phalcon_array_isset_string(params, SS("id"))) { phalcon_array_update_string(¶ms, SL("id"), &id, PH_COPY | PH_SEPARATE TSRMLS_CC); } if (!phalcon_array_isset_string(params, SS("value"))) { PHALCON_INIT_VAR(value); PHALCON_CALL_STATIC_PARAMS_2(value, "phalcon\\tag", "getvalue", id, params); } else { PHALCON_OBS_NVAR(value); phalcon_array_fetch_string(&value, params, SL("value"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("value")); } PHALCON_INIT_VAR(use_empty); ZVAL_BOOL(use_empty, 0); if (phalcon_array_isset_string(params, SS("useEmpty"))) { if (!phalcon_array_isset_string(params, SS("emptyValue"))) { PHALCON_INIT_VAR(empty_value); ZVAL_STRING(empty_value, "", 1); } else { PHALCON_OBS_NVAR(empty_value); phalcon_array_fetch_string(&empty_value, params, SL("emptyValue"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("emptyValue")); } if (!phalcon_array_isset_string(params, SS("emptyText"))) { PHALCON_INIT_VAR(empty_text); ZVAL_STRING(empty_text, "Choose...", 1); } else { PHALCON_OBS_NVAR(empty_text); phalcon_array_fetch_string(&empty_text, params, SL("emptyText"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("emptyText")); } PHALCON_OBS_NVAR(use_empty); phalcon_array_fetch_string(&use_empty, params, SL("useEmpty"), PH_NOISY_CC); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("useEmpty")); } PHALCON_INIT_VAR(code); ZVAL_STRING(code, "<select", 1); if (Z_TYPE_P(params) == IS_ARRAY) { if (!phalcon_is_iterable(params, &ah0, &hp0, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_FOREACH_KEY(key, ah0, hp0); PHALCON_GET_FOREACH_VALUE(avalue); if (Z_TYPE_P(key) != IS_LONG) { if (Z_TYPE_P(avalue) != IS_ARRAY) { PHALCON_SCONCAT_SVSVS(code, " ", key, "=\"", avalue, "\""); } } zend_hash_move_forward_ex(ah0, &hp0); } } PHALCON_SCONCAT_SV(code, ">", eol); PHALCON_INIT_VAR(close_option); PHALCON_CONCAT_SV(close_option, "</option>", eol); if (zend_is_true(use_empty)) { /** * Create an empty value */ PHALCON_SCONCAT_SVSVV(code, "\t<option value=\"", empty_value, "\">", empty_text, close_option); PHALCON_SEPARATE(params); phalcon_array_unset_string(params, SS("useEmpty")); } if (phalcon_array_isset_long(params, 1)) { PHALCON_OBS_VAR(options); phalcon_array_fetch_long(&options, params, 1, PH_NOISY_CC); } else { PHALCON_CPY_WRT(options, data); } if (Z_TYPE_P(options) == IS_OBJECT) { /** * The options is a resultset */ if (!phalcon_array_isset_string(params, SS("using"))) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter is required"); return; } else { PHALCON_OBS_VAR(using); phalcon_array_fetch_string(&using, params, SL("using"), PH_NOISY_CC); if (Z_TYPE_P(using) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_tag_exception_ce, "The 'using' parameter should be an Array"); return; } } /** * Create the SELECT's option from a resultset */ PHALCON_INIT_VAR(resultset_options); PHALCON_CALL_SELF_PARAMS_4(resultset_options, this_ptr, "_optionsfromresultset", options, using, value, close_option); phalcon_concat_self(&code, resultset_options TSRMLS_CC); } else { if (Z_TYPE_P(options) == IS_ARRAY) {
/** * Returns a PHQL statement built based on the builder parameters * * @return string */ PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, getPhql){ zval *dependency_injector = NULL, *models, *conditions = NULL; zval *one, *number_models, *invalid_condition; zval *model = NULL, *service_name, *meta_data, *model_instance; zval *no_primary = NULL, *primary_keys, *first_primary_key; zval *column_map = NULL, *attribute_field = NULL, *exception_message; zval *primary_key_condition, *phql, *columns; zval *selected_columns = NULL, *column = NULL, *alias = NULL, *aliased_column = NULL; zval *joined_columns = NULL, *selected_column = NULL, *selected_models; zval *selected_model = NULL, *joined_models, *joins; zval *join = NULL, *join_model = NULL, *join_conditions = NULL, *join_alias = NULL; zval *join_type = NULL, *group, *group_items, *group_item = NULL; zval *escaped_item = NULL, *joined_items = NULL, *having, *order; zval *order_items, *order_item = NULL, *limit, *number; zval *offset = NULL; HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5; HashPosition hp0, hp1, hp2, hp3, hp4, hp5; zval **hd; zend_class_entry *ce0; PHALCON_MM_GROW(); PHALCON_OBS_VAR(dependency_injector); phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_INIT_NVAR(dependency_injector); PHALCON_CALL_STATIC(dependency_injector, "phalcon\\di", "getdefault"); phalcon_update_property_zval(this_ptr, SL("_dependencyInjector"), dependency_injector TSRMLS_CC); } PHALCON_OBS_VAR(models); phalcon_read_property(&models, this_ptr, SL("_models"), PH_NOISY_CC); if (Z_TYPE_P(models) == IS_ARRAY) { if (!phalcon_fast_count_ev(models TSRMLS_CC)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query"); return; } } else { if (!zend_is_true(models)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "At least one model is required to build the query"); return; } } PHALCON_OBS_VAR(conditions); phalcon_read_property(&conditions, this_ptr, SL("_conditions"), PH_NOISY_CC); if (phalcon_is_numeric(conditions)) { /** * If the conditions is a single numeric field. We internally create a condition * using the related primary key */ if (Z_TYPE_P(models) == IS_ARRAY) { PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_INIT_VAR(number_models); phalcon_fast_count(number_models, models TSRMLS_CC); PHALCON_INIT_VAR(invalid_condition); is_smaller_function(invalid_condition, one, number_models TSRMLS_CC); if (PHALCON_IS_TRUE(invalid_condition)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Cannot build the query. Invalid condition"); return; } PHALCON_OBS_VAR(model); phalcon_array_fetch_long(&model, models, 0, PH_NOISY_CC); } else { PHALCON_CPY_WRT(model, models); } PHALCON_INIT_VAR(service_name); ZVAL_STRING(service_name, "modelsMetadata", 1); /** * Get the models metadata service to obtain the column names, column map and * primary key */ PHALCON_INIT_VAR(meta_data); PHALCON_CALL_METHOD_PARAMS_1(meta_data, dependency_injector, "getshared", service_name); ce0 = phalcon_fetch_class(model TSRMLS_CC); PHALCON_INIT_VAR(model_instance); object_init_ex(model_instance, ce0); if (phalcon_has_constructor(model_instance TSRMLS_CC)) { PHALCON_CALL_METHOD_PARAMS_1_NORETURN(model_instance, "__construct", dependency_injector); } PHALCON_INIT_VAR(no_primary); ZVAL_BOOL(no_primary, 1); PHALCON_INIT_VAR(primary_keys); PHALCON_CALL_METHOD_PARAMS_1(primary_keys, meta_data, "getprimarykeyattributes", model_instance); if (phalcon_fast_count_ev(primary_keys TSRMLS_CC)) { if (phalcon_array_isset_long(primary_keys, 0)) { PHALCON_OBS_VAR(first_primary_key); phalcon_array_fetch_long(&first_primary_key, primary_keys, 0, PH_NOISY_CC); /** * The PHQL contains the renamed columns if available */ if (PHALCON_GLOBAL(orm).column_renaming) { PHALCON_INIT_VAR(column_map); PHALCON_CALL_METHOD_PARAMS_1(column_map, meta_data, "getcolumnmap", model_instance); } else { PHALCON_INIT_NVAR(column_map); } if (Z_TYPE_P(column_map) == IS_ARRAY) { if (phalcon_array_isset(column_map, first_primary_key)) { PHALCON_OBS_VAR(attribute_field); phalcon_array_fetch(&attribute_field, column_map, first_primary_key, PH_NOISY_CC); } else { PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Column '", first_primary_key, "\" 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, first_primary_key); } PHALCON_INIT_VAR(primary_key_condition); PHALCON_CONCAT_SVSVSV(primary_key_condition, "[", model, "].[", attribute_field, "] = ", conditions); PHALCON_CPY_WRT(conditions, primary_key_condition); ZVAL_BOOL(no_primary, 0); } } /** * A primary key is mandatory in these cases */ if (PHALCON_IS_TRUE(no_primary)) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Source related to this model does not have a primary key defined"); return; } } PHALCON_INIT_VAR(phql); ZVAL_STRING(phql, "SELECT ", 1); PHALCON_OBS_VAR(columns); phalcon_read_property(&columns, this_ptr, SL("_columns"), PH_NOISY_CC); if (Z_TYPE_P(columns) != IS_NULL) { 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_KEY(alias, ah0, hp0); PHALCON_GET_FOREACH_VALUE(column); if (Z_TYPE_P(alias) == IS_LONG) { phalcon_array_append(&selected_columns, column, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_NVAR(aliased_column); PHALCON_CONCAT_VSV(aliased_column, column, " AS ", alias); phalcon_array_append(&selected_columns, aliased_column, PH_SEPARATE TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_INIT_VAR(joined_columns); phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC); phalcon_concat_self(&phql, joined_columns TSRMLS_CC); } else { phalcon_concat_self(&phql, columns TSRMLS_CC); } } else { if (Z_TYPE_P(models) == IS_ARRAY) { PHALCON_INIT_NVAR(selected_columns); array_init(selected_columns); if (!phalcon_is_iterable(models, &ah1, &hp1, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) { PHALCON_GET_FOREACH_KEY(alias, ah1, hp1); PHALCON_GET_FOREACH_VALUE(model); if (Z_TYPE_P(alias) == IS_LONG) { PHALCON_INIT_NVAR(selected_column); PHALCON_CONCAT_SVS(selected_column, "[", model, "].*"); } else { PHALCON_INIT_NVAR(selected_column); PHALCON_CONCAT_SVS(selected_column, "[", alias, "].*"); } phalcon_array_append(&selected_columns, selected_column, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah1, &hp1); } PHALCON_INIT_NVAR(joined_columns); phalcon_fast_join_str(joined_columns, SL(", "), selected_columns TSRMLS_CC); phalcon_concat_self(&phql, joined_columns TSRMLS_CC); } else { PHALCON_SCONCAT_SVS(phql, "[", models, "].*"); } } /** * Join multiple models or use a single one if it is a string */ if (Z_TYPE_P(models) == IS_ARRAY) { PHALCON_INIT_VAR(selected_models); array_init(selected_models); if (!phalcon_is_iterable(models, &ah2, &hp2, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) { PHALCON_GET_FOREACH_KEY(alias, ah2, hp2); PHALCON_GET_FOREACH_VALUE(model); if (Z_TYPE_P(alias) == IS_STRING) { PHALCON_INIT_NVAR(selected_model); PHALCON_CONCAT_SVSVS(selected_model, "[", model, "] AS [", alias, "]"); } else { PHALCON_INIT_NVAR(selected_model); PHALCON_CONCAT_SVS(selected_model, "[", model, "]"); } phalcon_array_append(&selected_models, selected_model, PH_SEPARATE TSRMLS_CC); zend_hash_move_forward_ex(ah2, &hp2); } PHALCON_INIT_VAR(joined_models); phalcon_fast_join_str(joined_models, SL(", "), selected_models TSRMLS_CC); PHALCON_SCONCAT_SV(phql, " FROM ", joined_models); } else { PHALCON_SCONCAT_SVS(phql, " FROM [", models, "]"); } /** * Check if joins were passed to the builders */ PHALCON_OBS_VAR(joins); phalcon_read_property(&joins, this_ptr, SL("_joins"), PH_NOISY_CC); if (Z_TYPE_P(joins) == IS_ARRAY) { if (!phalcon_is_iterable(joins, &ah3, &hp3, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(join); /** * The joined table is in the first place of the array */ PHALCON_OBS_NVAR(join_model); phalcon_array_fetch_long(&join_model, join, 0, PH_NOISY_CC); /** * The join conditions are in the second place of the array */ PHALCON_OBS_NVAR(join_conditions); phalcon_array_fetch_long(&join_conditions, join, 1, PH_NOISY_CC); /** * The join alias is in the second place of the array */ PHALCON_OBS_NVAR(join_alias); phalcon_array_fetch_long(&join_alias, join, 2, PH_NOISY_CC); /** * Join type */ PHALCON_OBS_NVAR(join_type); phalcon_array_fetch_long(&join_type, join, 3, PH_NOISY_CC); /** * Create the join according to the type */ if (zend_is_true(join_type)) { PHALCON_SCONCAT_VSVS(phql, join_type, " JOIN [", join_model, "]"); } else { PHALCON_SCONCAT_SVS(phql, " JOIN [", join_model, "]"); } /** * Alias comes first */ if (zend_is_true(join_alias)) { PHALCON_SCONCAT_SVS(phql, " AS [", join_alias, "]"); } /** * Conditions then */ if (zend_is_true(join_conditions)) { PHALCON_SCONCAT_SV(phql, " ON ", join_conditions); } zend_hash_move_forward_ex(ah3, &hp3); } } if (Z_TYPE_P(conditions) == IS_STRING) { PHALCON_SCONCAT_SV(phql, " WHERE ", conditions); } /** * Process group parameters */ PHALCON_OBS_VAR(group); phalcon_read_property(&group, this_ptr, SL("_group"), PH_NOISY_CC); if (Z_TYPE_P(group) != IS_NULL) { if (Z_TYPE_P(group) == IS_ARRAY) { PHALCON_INIT_VAR(group_items); array_init(group_items); if (!phalcon_is_iterable(group, &ah4, &hp4, 0, 0 TSRMLS_CC)) { return; } while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) { PHALCON_GET_FOREACH_VALUE(group_item); if (phalcon_is_numeric(group_item)) { phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(group_item, SL(".") TSRMLS_CC)) { phalcon_array_append(&group_items, group_item, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_NVAR(escaped_item); PHALCON_CONCAT_SVS(escaped_item, "[", group_item, "]"); phalcon_array_append(&group_items, escaped_item, PH_SEPARATE TSRMLS_CC); } } zend_hash_move_forward_ex(ah4, &hp4); } PHALCON_INIT_VAR(joined_items); phalcon_fast_join_str(joined_items, SL(", "), group_items TSRMLS_CC); PHALCON_SCONCAT_SV(phql, " GROUP BY ", joined_items); } else { if (phalcon_is_numeric(group)) { PHALCON_SCONCAT_SV(phql, " GROUP BY ", group); } else { if (phalcon_memnstr_str(group, SL(".") TSRMLS_CC)) { PHALCON_SCONCAT_SV(phql, " GROUP BY ", group); } else { PHALCON_SCONCAT_SVS(phql, " GROUP BY [", group, "]"); } } } PHALCON_OBS_VAR(having); phalcon_read_property(&having, this_ptr, SL("_having"), PH_NOISY_CC); if (Z_TYPE_P(having) != IS_NULL) { PHALCON_SCONCAT_SV(phql, " HAVING ", having); } } /** * Process order clause */ PHALCON_OBS_VAR(order); phalcon_read_property(&order, this_ptr, SL("_order"), PH_NOISY_CC); if (Z_TYPE_P(order) != IS_NULL) { if (Z_TYPE_P(order) == IS_ARRAY) { PHALCON_INIT_VAR(order_items); array_init(order_items); if (!phalcon_is_iterable(order, &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); if (phalcon_is_numeric(order_item)) { phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC); } else { if (phalcon_memnstr_str(order_item, SL(".") TSRMLS_CC)) { phalcon_array_append(&order_items, order_item, PH_SEPARATE TSRMLS_CC); } else { PHALCON_INIT_NVAR(escaped_item); PHALCON_CONCAT_SVS(escaped_item, "[", order_item, "]"); phalcon_array_append(&order_items, escaped_item, PH_SEPARATE TSRMLS_CC); } } zend_hash_move_forward_ex(ah5, &hp5); } PHALCON_INIT_NVAR(joined_items); phalcon_fast_join_str(joined_items, SL(", "), order_items TSRMLS_CC); PHALCON_SCONCAT_SV(phql, " ORDER BY ", joined_items); } else { PHALCON_SCONCAT_SV(phql, " ORDER BY ", order); } } /** * Process limit parameters */ PHALCON_OBS_VAR(limit); phalcon_read_property(&limit, this_ptr, SL("_limit"), PH_NOISY_CC); if (Z_TYPE_P(limit) != IS_NULL) { if (Z_TYPE_P(limit) == IS_ARRAY) { PHALCON_OBS_VAR(number); phalcon_array_fetch_string(&number, limit, SL("number"), PH_NOISY_CC); if (phalcon_array_isset_string(limit, SS("offset"))) { PHALCON_OBS_VAR(offset); phalcon_array_fetch_string(&offset, limit, SL("offset"), PH_NOISY_CC); if (phalcon_is_numeric(offset)) { PHALCON_SCONCAT_SVSV(phql, " LIMIT ", number, " OFFSET ", offset); } else { PHALCON_SCONCAT_SVS(phql, " LIMIT ", number, " OFFSET 0"); } } else { PHALCON_SCONCAT_SV(phql, " LIMIT ", number); } } else { if (phalcon_is_numeric(limit)) { PHALCON_SCONCAT_SV(phql, " LIMIT ", limit); PHALCON_OBS_NVAR(offset); phalcon_read_property(&offset, this_ptr, SL("_offset"), PH_NOISY_CC); if (Z_TYPE_P(offset) != IS_NULL) { if (phalcon_is_numeric(offset)) { PHALCON_SCONCAT_SV(phql, " OFFSET ", offset); } else { phalcon_concat_self_str(&phql, SL(" OFFSET 0") TSRMLS_CC); } } } } } RETURN_CTOR(phql); }
/** * 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); }
/** * Gets the column name in MySQL * * @param Phalcon\Db\Column $column */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition){ zval *column = NULL, *size = NULL, *column_sql = NULL, *scale = 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; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL; zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL, *t11 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(column) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column definition must be an instance of Phalcon\\Db\\Column"); return; } PHALCON_INIT_VAR(size); PHALCON_CALL_METHOD(size, column, "getsize", PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, column, "gettype", PH_NO_CHECK); PHALCON_INIT_VAR(t0); ZVAL_LONG(t0, 0); PHALCON_ALLOC_ZVAL_MM(r1); is_equal_function(r1, r0, t0 TSRMLS_CC); if (zend_is_true(r1)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "INT(", size, ")"); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_METHOD(r2, column, "isunsigned", PH_NO_CHECK); if (zend_is_true(r2)) { PHALCON_INIT_VAR(t1); ZVAL_STRING(t1, " UNSIGNED", 1); phalcon_concat_self(&column_sql, t1 TSRMLS_CC); } goto se_52be_1; } PHALCON_INIT_VAR(t2); ZVAL_LONG(t2, 1); PHALCON_ALLOC_ZVAL_MM(r3); is_equal_function(r3, r0, t2 TSRMLS_CC); if (zend_is_true(r3)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "DATE", 1); goto se_52be_1; } PHALCON_INIT_VAR(t3); ZVAL_LONG(t3, 2); PHALCON_ALLOC_ZVAL_MM(r4); is_equal_function(r4, r0, t3 TSRMLS_CC); if (zend_is_true(r4)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "VARCHAR(", size, ")"); goto se_52be_1; } PHALCON_INIT_VAR(t4); ZVAL_LONG(t4, 3); PHALCON_ALLOC_ZVAL_MM(r5); is_equal_function(r5, r0, t4 TSRMLS_CC); if (zend_is_true(r5)) { PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_CALL_METHOD(r6, column, "getscale", PH_NO_CHECK); PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVSVS(column_sql, "DECIMAL(", size, ",", r6, ")"); PHALCON_ALLOC_ZVAL_MM(r7); PHALCON_CALL_METHOD(r7, column, "isunsigned", PH_NO_CHECK); if (zend_is_true(r7)) { PHALCON_INIT_VAR(t5); ZVAL_STRING(t5, " UNSIGNED", 1); phalcon_concat_self(&column_sql, t5 TSRMLS_CC); } goto se_52be_1; } PHALCON_INIT_VAR(t6); ZVAL_LONG(t6, 4); PHALCON_ALLOC_ZVAL_MM(r8); is_equal_function(r8, r0, t6 TSRMLS_CC); if (zend_is_true(r8)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "DATETIME", 1); goto se_52be_1; } PHALCON_INIT_VAR(t7); ZVAL_LONG(t7, 5); PHALCON_ALLOC_ZVAL_MM(r9); is_equal_function(r9, r0, t7 TSRMLS_CC); if (zend_is_true(r9)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "CHAR(", size, ")"); goto se_52be_1; } PHALCON_INIT_VAR(t8); ZVAL_LONG(t8, 6); PHALCON_ALLOC_ZVAL_MM(r10); is_equal_function(r10, r0, t8 TSRMLS_CC); if (zend_is_true(r10)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "TEXT", 1); goto se_52be_1; } PHALCON_INIT_VAR(t9); ZVAL_LONG(t9, 7); PHALCON_ALLOC_ZVAL_MM(r11); is_equal_function(r11, r0, t9 TSRMLS_CC); if (zend_is_true(r11)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "FLOAT", 1); PHALCON_INIT_VAR(scale); PHALCON_CALL_METHOD(scale, column, "getscale", PH_NO_CHECK); if (zend_is_true(size)) { PHALCON_ALLOC_ZVAL_MM(r12); PHALCON_CONCAT_SV(r12, "(", size); phalcon_concat_self(&column_sql, r12 TSRMLS_CC); if (zend_is_true(scale)) { PHALCON_ALLOC_ZVAL_MM(r13); PHALCON_CONCAT_SVS(r13, ",", scale, ")"); phalcon_concat_self(&column_sql, r13 TSRMLS_CC); } else { PHALCON_INIT_VAR(t10); ZVAL_STRING(t10, ")", 1); phalcon_concat_self(&column_sql, t10 TSRMLS_CC); } } PHALCON_ALLOC_ZVAL_MM(r14); PHALCON_CALL_METHOD(r14, column, "isunsigned", PH_NO_CHECK); if (zend_is_true(r14)) { PHALCON_INIT_VAR(t11); ZVAL_STRING(t11, " UNSIGNED", 1); phalcon_concat_self(&column_sql, t11 TSRMLS_CC); } goto se_52be_1; } PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Unrecognized MySQL data type"); return; se_52be_1: RETURN_CTOR(column_sql); }
/** * Outputs a message formatting it with HTML * * @param string $type * @param string $message */ PHP_METHOD(Phalcon_Flash, outputMessage){ zval *type = NULL, *message = NULL, *automatic_html = NULL, *classes = NULL; zval *type_classes = NULL, *space = NULL, *joined_classes = NULL; zval *css_classes = NULL, *eol = NULL, *implicit_flush = NULL, *content = NULL; zval *msg = NULL, *html_message = NULL; HashTable *ah0; HashPosition hp0; zval **hd; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &type, &message) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(automatic_html); phalcon_read_property(&automatic_html, this_ptr, SL("_automaticHtml"), PH_NOISY_CC); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(classes); phalcon_read_property(&classes, this_ptr, SL("_cssClasses"), PH_NOISY_CC); eval_int = phalcon_array_isset(classes, type); if (eval_int) { PHALCON_INIT_VAR(type_classes); phalcon_array_fetch(&type_classes, classes, type, PH_NOISY_CC); if (Z_TYPE_P(type_classes) == IS_ARRAY) { PHALCON_INIT_VAR(space); ZVAL_STRING(space, " ", 1); PHALCON_INIT_VAR(joined_classes); phalcon_fast_join(joined_classes, space, type_classes TSRMLS_CC); PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", joined_classes, "\""); } else { PHALCON_INIT_VAR(css_classes); PHALCON_CONCAT_SVS(css_classes, " class=\"", type_classes, "\""); } } else { PHALCON_INIT_VAR(css_classes); ZVAL_STRING(css_classes, "", 1); } PHALCON_INIT_VAR(eol); zend_get_constant(SL("PHP_EOL"), eol TSRMLS_CC); } PHALCON_INIT_VAR(implicit_flush); phalcon_read_property(&implicit_flush, this_ptr, SL("_implicitFlush"), PH_NOISY_CC); if (Z_TYPE_P(message) == IS_ARRAY) { if (PHALCON_IS_FALSE(implicit_flush)) { PHALCON_INIT_VAR(content); ZVAL_STRING(content, "", 1); } if (!phalcon_valid_foreach(message TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(message); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_3b3c_0: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_3b3c_0; } PHALCON_INIT_VAR(msg); ZVAL_ZVAL(msg, *hd, 1, 0); if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", msg, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, msg); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 1); } else { phalcon_concat_self(&content, html_message TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_3b3c_0; fee_3b3c_0: if (PHALCON_IS_FALSE(implicit_flush)) { RETURN_CTOR(content); } } else { if (PHALCON_IS_TRUE(automatic_html)) { PHALCON_INIT_VAR(html_message); PHALCON_CONCAT_SVSVSV(html_message, "<div", css_classes, ">", message, "</div>", eol); } else { PHALCON_CPY_WRT(html_message, message); } if (PHALCON_IS_TRUE(implicit_flush)) { zend_print_zval(html_message, 1); } else { RETURN_CCTOR(html_message); } } PHALCON_MM_RESTORE(); }
/** * Generates SQL to add an index to a table * * @param string $tableName * @param string $schemaName * @param Phalcon\Db\Reference $reference * @return string */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, addForeignKey){ zval *table_name = NULL, *schema_name = NULL, *reference = NULL, *sql = NULL; zval *columns = NULL, *quoted_column_list = NULL, *referenced_schema = NULL; zval *referenced_columns = NULL, *quoted_columns = NULL; zval *referenced_table = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &reference) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(reference) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Reference parameter must be an instance of Phalcon\\Db\\Reference"); return; } if (zend_is_true(schema_name)) { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVSVS(sql, "ALTER TABLE `", schema_name, "`.`", table_name, "` ADD FOREIGN KEY "); } else { PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "ALTER TABLE `", table_name, "` ADD FOREIGN KEY "); } PHALCON_INIT_VAR(columns); PHALCON_CALL_METHOD(columns, reference, "getcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(quoted_column_list); PHALCON_CALL_METHOD_PARAMS_1(quoted_column_list, this_ptr, "getcolumnlist", columns, PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, reference, "getname", PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVSVS(r1, "`", r0, "`(", quoted_column_list, ") REFERENCES "); phalcon_concat_self(&sql, r1 TSRMLS_CC); PHALCON_INIT_VAR(referenced_schema); PHALCON_CALL_METHOD(referenced_schema, reference, "getreferencedschema", PH_NO_CHECK); if (zend_is_true(referenced_schema)) { PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CONCAT_SVS(r2, "`", referenced_schema, "`."); phalcon_concat_self(&sql, r2 TSRMLS_CC); } PHALCON_INIT_VAR(referenced_columns); PHALCON_CALL_METHOD(referenced_columns, reference, "getreferencedcolumns", PH_NO_CHECK); PHALCON_INIT_VAR(quoted_columns); PHALCON_CALL_METHOD_PARAMS_1(quoted_columns, this_ptr, "getcolumnlist", referenced_columns, PH_NO_CHECK); PHALCON_INIT_VAR(referenced_table); PHALCON_CALL_METHOD(referenced_table, reference, "getreferencedtable", PH_NO_CHECK); PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CONCAT_SVSVS(r3, "`", referenced_table, "`(", quoted_columns, ")"); phalcon_concat_self(&sql, r3 TSRMLS_CC); RETURN_CTOR(sql); }
/** * Shows a backtrace item * * @param int $n * @param array $trace */ PHP_METHOD(Phalcon_Debug, showTraceItem){ zval *n, *trace, *space, *two_spaces, *underscore; zval *minus, *html, *class_name, *pattern, *is_phalcon_class; zval *namespace_separator, *prepare_uri_class; zval *class_reflection, *is_internal = NULL, *lower_class_name; zval *prepare_internal_class, *type, *function_name = NULL; zval *function_reflection, *prepared_function_name; zval *trace_args, *arguments, *argument = NULL, *dumped_argument = NULL; zval *span_argument = NULL, *joined_arguments, *one; zval *file, *line, *show_files, *lines, *number_lines; zval *show_file_fragment, *seven, *before_line; zval *first_line = NULL, *five, *after_line, *last_line = NULL; zval *comment_pattern, *utf8, *ent_compat, *tab; zval *comment, *i = NULL, *line_position = NULL, *current_line = NULL; zval *trimmed = NULL, *is_comment = NULL, *spaced_current_line = NULL; zval *escaped_line = NULL; HashTable *ah0; HashPosition hp0; zval **hd; zend_class_entry *ce0, *ce1; PHALCON_MM_GROW(); phalcon_fetch_params(1, 2, 0, &n, &trace); PHALCON_INIT_VAR(space); ZVAL_STRING(space, " ", 1); PHALCON_INIT_VAR(two_spaces); ZVAL_STRING(two_spaces, " ", 1); PHALCON_INIT_VAR(underscore); ZVAL_STRING(underscore, "_", 1); PHALCON_INIT_VAR(minus); ZVAL_STRING(minus, "-", 1); /** * Every trace in the backtrace have a unique number */ PHALCON_INIT_VAR(html); PHALCON_CONCAT_SVS(html, "<tr><td align=\"right\" valign=\"top\" class=\"error-number\">#", n, "</td><td>"); if (phalcon_array_isset_string(trace, SS("class"))) { PHALCON_OBS_VAR(class_name); phalcon_array_fetch_string(&class_name, trace, SL("class"), PH_NOISY); PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "/^Phalcon/", 1); PHALCON_INIT_VAR(is_phalcon_class); phalcon_preg_match(is_phalcon_class, pattern, class_name, NULL TSRMLS_CC); /** * We assume that classes starting by Phalcon are framework's classes */ if (zend_is_true(is_phalcon_class)) { PHALCON_INIT_VAR(namespace_separator); ZVAL_STRING(namespace_separator, "\\", 1); /** * Prepare the class name according to the Phalcon's conventions */ PHALCON_INIT_VAR(prepare_uri_class); phalcon_fast_str_replace(prepare_uri_class, namespace_separator, underscore, class_name); /** * Generate a link to the official docs */ PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://docs.phalconphp.com/en/latest/api/", prepare_uri_class, ".html\">", class_name, "</a></span>"); } else { ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); PHALCON_INIT_VAR(class_reflection); object_init_ex(class_reflection, ce0); if (phalcon_has_constructor(class_reflection TSRMLS_CC)) { phalcon_call_method_p1_noret(class_reflection, "__construct", class_name); } /** * Check if classes are PHP's classes */ PHALCON_INIT_VAR(is_internal); phalcon_call_method(is_internal, class_reflection, "isinternal"); if (zend_is_true(is_internal)) { PHALCON_INIT_VAR(lower_class_name); phalcon_fast_strtolower(lower_class_name, class_name); PHALCON_INIT_VAR(prepare_internal_class); phalcon_fast_str_replace(prepare_internal_class, underscore, minus, lower_class_name); /** * Generate a link to the official docs */ PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-class\"><a target=\"_new\" href=\"http://php.net/manual/en/class.", prepare_internal_class, ".php\">", class_name, "</a></span>"); } else { PHALCON_SCONCAT_SVS(html, "<span class=\"error-class\">", class_name, "</span>"); } } /** * Object access operator: static/instance */ PHALCON_OBS_VAR(type); phalcon_array_fetch_string(&type, trace, SL("type"), PH_NOISY); phalcon_concat_self(&html, type TSRMLS_CC); } /** * Normally the backtrace contains only classes */ if (phalcon_array_isset_string(trace, SS("class"))) { PHALCON_OBS_VAR(function_name); phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY); PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>"); } else { PHALCON_OBS_NVAR(function_name); phalcon_array_fetch_string(&function_name, trace, SL("function"), PH_NOISY); /** * Check if the function exists */ if (phalcon_function_exists(function_name TSRMLS_CC) == SUCCESS) { ce1 = zend_fetch_class(SL("ReflectionFunction"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC); PHALCON_INIT_VAR(function_reflection); object_init_ex(function_reflection, ce1); if (phalcon_has_constructor(function_reflection TSRMLS_CC)) { phalcon_call_method_p1_noret(function_reflection, "__construct", function_name); } PHALCON_INIT_NVAR(is_internal); phalcon_call_method(is_internal, function_reflection, "isinternal"); /** * Internal functions links to the PHP documentation */ if (zend_is_true(is_internal)) { /** * Prepare function's name according to the conventions in the docs */ PHALCON_INIT_VAR(prepared_function_name); phalcon_fast_str_replace(prepared_function_name, underscore, minus, function_name); PHALCON_SCONCAT_SVSVS(html, "<span class=\"error-function\"><a target=\"_new\" href=\"http://php.net/manual/en/function.", prepared_function_name, ".php\">", function_name, "</a></span>"); } else { PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>"); } } else { PHALCON_SCONCAT_SVS(html, "<span class=\"error-function\">", function_name, "</span>"); } } /** * Check for arguments in the function */ if (phalcon_array_isset_string(trace, SS("args"))) { PHALCON_OBS_VAR(trace_args); phalcon_array_fetch_string(&trace_args, trace, SL("args"), PH_NOISY); if (phalcon_fast_count_ev(trace_args TSRMLS_CC)) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_is_iterable(trace_args, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HVALUE(argument); /** * Every argument is generated using _getVarDump */ PHALCON_INIT_NVAR(dumped_argument); phalcon_call_method_p1(dumped_argument, this_ptr, "_getvardump", argument); PHALCON_INIT_NVAR(span_argument); PHALCON_CONCAT_SVS(span_argument, "<span class=\"error-parameter\">", dumped_argument, "</span>"); /** * Append the HTML generated to the argument's list */ phalcon_array_append(&arguments, span_argument, PH_SEPARATE); zend_hash_move_forward_ex(ah0, &hp0); } /** * Join all the arguments */ PHALCON_INIT_VAR(joined_arguments); phalcon_fast_join_str(joined_arguments, SL(", "), arguments TSRMLS_CC); PHALCON_SCONCAT_SVS(html, "(", joined_arguments, ")"); } else { phalcon_concat_self_str(&html, SL("()") TSRMLS_CC); } } /** * When 'file' is present, it usually means the function is provided by the user */ if (phalcon_array_isset_string(trace, SS("file"))) { PHALCON_INIT_VAR(one); ZVAL_LONG(one, 1); PHALCON_OBS_VAR(file); phalcon_array_fetch_string(&file, trace, SL("file"), PH_NOISY); PHALCON_OBS_VAR(line); phalcon_array_fetch_string(&line, trace, SL("line"), PH_NOISY); /** * Realpath to the file and its line using a special header */ PHALCON_SCONCAT_SVSVS(html, "<br/><div class=\"error-file\">", file, " (", line, ")</div>"); PHALCON_OBS_VAR(show_files); phalcon_read_property_this(&show_files, this_ptr, SL("_showFiles"), PH_NOISY_CC); /** * The developer can change if the files must be opened or not */ if (zend_is_true(show_files)) { /** * Open the file to an array using 'file', this respects the openbase-dir directive */ PHALCON_INIT_VAR(lines); phalcon_call_func_p1(lines, "file", file); PHALCON_INIT_VAR(number_lines); phalcon_fast_count(number_lines, lines TSRMLS_CC); PHALCON_OBS_VAR(show_file_fragment); phalcon_read_property_this(&show_file_fragment, this_ptr, SL("_showFileFragment"), PH_NOISY_CC); /** * File fragments just show a piece of the file where the exception is located */ if (zend_is_true(show_file_fragment)) { /** * Take seven lines back to the current exception's line, @TODO add an option for * this */ PHALCON_INIT_VAR(seven); ZVAL_LONG(seven, 7); PHALCON_INIT_VAR(before_line); sub_function(before_line, line, seven TSRMLS_CC); /** * Check for overflows */ if (PHALCON_LT_LONG(before_line, 1)) { PHALCON_CPY_WRT(first_line, one); } else { PHALCON_CPY_WRT(first_line, before_line); } /** * Take five lines after the current exception's line, @TODO add an option for this */ PHALCON_INIT_VAR(five); ZVAL_LONG(five, 5); PHALCON_INIT_VAR(after_line); phalcon_add_function(after_line, line, five TSRMLS_CC); /** * Check for overflows */ if (PHALCON_GT(after_line, number_lines)) { PHALCON_CPY_WRT(last_line, number_lines); } else { PHALCON_CPY_WRT(last_line, after_line); } PHALCON_SCONCAT_SVSVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums:", first_line, "'>"); } else { PHALCON_CPY_WRT(first_line, one); PHALCON_CPY_WRT(last_line, number_lines); PHALCON_SCONCAT_SVSVS(html, "<pre class='prettyprint highlight:", first_line, ":", line, " linenums error-scroll'>"); } PHALCON_INIT_VAR(comment_pattern); ZVAL_STRING(comment_pattern, "#\\*\\/$#", 1); /** * We assume the file is utf-8 encoded, @TODO add an option for this */ PHALCON_INIT_VAR(utf8); ZVAL_STRING(utf8, "UTF-8", 1); /** * Don't escape quotes */ PHALCON_INIT_VAR(ent_compat); ZVAL_LONG(ent_compat, 2); PHALCON_INIT_VAR(tab); ZVAL_STRING(tab, "\t", 1); PHALCON_INIT_VAR(comment); ZVAL_STRING(comment, "* /", 1); PHALCON_CPY_WRT(i, first_line); while (1) { if (PHALCON_LE(i, last_line)) { } else { break; } /** * Current line in the file */ PHALCON_INIT_NVAR(line_position); sub_function(line_position, i, one TSRMLS_CC); /** * Current line content in the piece of file */ PHALCON_OBS_NVAR(current_line); phalcon_array_fetch(¤t_line, lines, line_position, PH_NOISY); /** * File fragments are cleaned, removing tabs and comments */ if (zend_is_true(show_file_fragment)) { if (PHALCON_IS_EQUAL(i, first_line)) { PHALCON_INIT_NVAR(trimmed); phalcon_fast_trim(trimmed, current_line, PHALCON_TRIM_RIGHT TSRMLS_CC); PHALCON_INIT_NVAR(is_comment); phalcon_preg_match(is_comment, comment_pattern, current_line, NULL TSRMLS_CC); if (zend_is_true(is_comment)) { PHALCON_INIT_NVAR(spaced_current_line); phalcon_fast_str_replace(spaced_current_line, comment, space, current_line); PHALCON_CPY_WRT(current_line, spaced_current_line); } } } /** * Print a non break space if the current line is a line break, this allows to show * the html zebra properly */ if (PHALCON_IS_STRING(current_line, "\n")) { phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC); } else { if (PHALCON_IS_STRING(current_line, "\r\n")) { phalcon_concat_self_str(&html, SL(" \n") TSRMLS_CC); } else { PHALCON_INIT_NVAR(spaced_current_line); phalcon_fast_str_replace(spaced_current_line, tab, two_spaces, current_line); PHALCON_INIT_NVAR(escaped_line); phalcon_call_func_p3(escaped_line, "htmlentities", spaced_current_line, ent_compat, utf8); phalcon_concat_self(&html, escaped_line TSRMLS_CC); } } PHALCON_SEPARATE(i); phalcon_increment(i); } phalcon_concat_self_str(&html, SL("</pre>") TSRMLS_CC); } } phalcon_concat_self_str(&html, SL("</td></tr>") TSRMLS_CC); RETURN_CTOR(html); }
/** * Builds a HTML FORM tag * * <code> * echo Phalcon\Tag::form("posts/save"); * echo Phalcon\Tag::form(array("posts/save", "method" => "post")); * </code> * * @param array $parameters * @return string */ PHP_METHOD(Phalcon_Tag, form){ zval *parameters = NULL, *params = NULL, *dispatcher = NULL, *dispatch_params = NULL; zval *slash = NULL, *action_parameters = NULL, *action = NULL, *controller_name = NULL; zval *action_name = NULL, *url = NULL, *form_action = NULL, *query_parameters = NULL; zval *code = NULL, *avalue = NULL, *key = NULL, *attribute = NULL, *final_code = NULL; zval *r0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶meters) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!parameters) { PHALCON_ALLOC_ZVAL_MM(parameters); ZVAL_NULL(parameters); } else { PHALCON_SEPARATE_PARAM(parameters); } if (Z_TYPE_P(parameters) != IS_ARRAY) { PHALCON_INIT_VAR(params); array_init(params); phalcon_array_append(¶ms, parameters, PH_SEPARATE TSRMLS_CC); } else { PHALCON_CPY_WRT(params, parameters); } PHALCON_INIT_VAR(dispatcher); PHALCON_CALL_SELF(dispatcher, this_ptr, "getdispatcherservice"); PHALCON_INIT_VAR(dispatch_params); PHALCON_CALL_METHOD(dispatch_params, dispatcher, "getparams", PH_NO_CHECK); PHALCON_INIT_VAR(slash); ZVAL_STRING(slash, "/", 1); PHALCON_INIT_VAR(action_parameters); phalcon_fast_join(action_parameters, slash, dispatch_params TSRMLS_CC); eval_int = phalcon_array_isset_long(params, 0); if (!eval_int) { eval_int = phalcon_array_isset_string(params, SL("action")+1); if (eval_int) { PHALCON_INIT_VAR(action); phalcon_array_fetch_string(&action, params, SL("action"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(controller_name); PHALCON_CALL_METHOD(controller_name, dispatcher, "getcontrollername", PH_NO_CHECK); PHALCON_INIT_VAR(action_name); PHALCON_CALL_METHOD(action_name, dispatcher, "getactionname", PH_NO_CHECK); PHALCON_INIT_VAR(action); PHALCON_CONCAT_VSV(action, controller_name, "/", action_name); } } else { PHALCON_INIT_VAR(action); phalcon_array_fetch_long(&action, params, 0, PH_NOISY_CC); } eval_int = phalcon_array_isset_string(params, SL("method")+1); if (!eval_int) { phalcon_array_update_string_string(¶ms, SL("method"), SL("post"), PH_SEPARATE TSRMLS_CC); } PHALCON_INIT_VAR(url); PHALCON_CALL_SELF(url, this_ptr, "geturlservice"); if (zend_is_true(action_parameters)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD_PARAMS_1(r0, url, "get", action, PH_NO_CHECK); PHALCON_CPY_WRT(action, r0); } else { PHALCON_INIT_VAR(form_action); PHALCON_CONCAT_VSV(form_action, action, "/", action_parameters); PHALCON_INIT_VAR(action); PHALCON_CALL_METHOD_PARAMS_1(action, url, "get", form_action, PH_NO_CHECK); } eval_int = phalcon_array_isset_string(params, SL("parameters")+1); if (eval_int) { PHALCON_INIT_VAR(parameters); phalcon_array_fetch_string(¶meters, params, SL("parameters"), PH_NOISY_CC); PHALCON_INIT_VAR(query_parameters); PHALCON_CONCAT_SV(query_parameters, "?", parameters); phalcon_concat_self(&action, query_parameters TSRMLS_CC); } PHALCON_INIT_VAR(code); PHALCON_CONCAT_SVS(code, "<form action=\"", action, "\" "); if (!phalcon_valid_foreach(params TSRMLS_CC)) { return; } ah0 = Z_ARRVAL_P(params); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_9b93_5: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_9b93_5; } PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); PHALCON_INIT_VAR(avalue); ZVAL_ZVAL(avalue, *hd, 1, 0); if (Z_TYPE_P(key) != IS_LONG) { PHALCON_INIT_VAR(attribute); PHALCON_CONCAT_VSVS(attribute, key, "= \"", avalue, "\" "); phalcon_concat_self(&code, attribute TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_9b93_5; fee_9b93_5: PHALCON_INIT_VAR(final_code); PHALCON_CONCAT_VS(final_code, code, ">"); RETURN_CTOR(final_code); }
/** * 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); }
/** * Gets the column name in MySQL * * @param Phalcon\Db\Column $column */ PHP_METHOD(Phalcon_Db_Dialect_Mysql, getColumnDefinition){ zval *column = NULL, *size = NULL, *column_type = NULL, *column_sql = NULL; zval *is_unsigned = NULL, *scale = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL; zval *r0 = NULL, *r1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(column) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column definition must be an instance of Phalcon\\Db\\Column"); return; } PHALCON_INIT_VAR(size); PHALCON_CALL_METHOD(size, column, "getsize", PH_NO_CHECK); PHALCON_INIT_VAR(column_type); PHALCON_CALL_METHOD(column_type, column, "gettype", PH_NO_CHECK); if (phalcon_compare_strict_long(column_type, 0 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "INT(", size, ")"); PHALCON_INIT_VAR(is_unsigned); PHALCON_CALL_METHOD(is_unsigned, column, "isunsigned", PH_NO_CHECK); if (zend_is_true(is_unsigned)) { PHALCON_INIT_VAR(t0); ZVAL_STRING(t0, " UNSIGNED", 1); phalcon_concat_self(&column_sql, t0 TSRMLS_CC); } goto se_52be_1; } if (phalcon_compare_strict_long(column_type, 1 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "DATE", 1); goto se_52be_1; } if (phalcon_compare_strict_long(column_type, 2 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "VARCHAR(", size, ")"); goto se_52be_1; } if (phalcon_compare_strict_long(column_type, 3 TSRMLS_CC)) { PHALCON_INIT_VAR(scale); PHALCON_CALL_METHOD(scale, column, "getscale", PH_NO_CHECK); PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVSVS(column_sql, "DECIMAL(", size, ",", scale, ")"); PHALCON_INIT_VAR(is_unsigned); PHALCON_CALL_METHOD(is_unsigned, column, "isunsigned", PH_NO_CHECK); if (zend_is_true(is_unsigned)) { PHALCON_INIT_VAR(t1); ZVAL_STRING(t1, " UNSIGNED", 1); phalcon_concat_self(&column_sql, t1 TSRMLS_CC); } goto se_52be_1; } if (phalcon_compare_strict_long(column_type, 4 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "DATETIME", 1); goto se_52be_1; } if (phalcon_compare_strict_long(column_type, 5 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); PHALCON_CONCAT_SVS(column_sql, "CHAR(", size, ")"); goto se_52be_1; } if (phalcon_compare_strict_long(column_type, 6 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "TEXT", 1); goto se_52be_1; } if (phalcon_compare_strict_long(column_type, 7 TSRMLS_CC)) { PHALCON_INIT_VAR(column_sql); ZVAL_STRING(column_sql, "FLOAT", 1); PHALCON_INIT_VAR(scale); PHALCON_CALL_METHOD(scale, column, "getscale", PH_NO_CHECK); if (zend_is_true(size)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CONCAT_SV(r0, "(", size); phalcon_concat_self(&column_sql, r0 TSRMLS_CC); if (zend_is_true(scale)) { PHALCON_ALLOC_ZVAL_MM(r1); PHALCON_CONCAT_SVS(r1, ",", scale, ")"); phalcon_concat_self(&column_sql, r1 TSRMLS_CC); } else { PHALCON_INIT_VAR(t2); ZVAL_STRING(t2, ")", 1); phalcon_concat_self(&column_sql, t2 TSRMLS_CC); } } PHALCON_INIT_VAR(is_unsigned); PHALCON_CALL_METHOD(is_unsigned, column, "isunsigned", PH_NO_CHECK); if (zend_is_true(is_unsigned)) { PHALCON_INIT_VAR(t3); ZVAL_STRING(t3, " UNSIGNED", 1); phalcon_concat_self(&column_sql, t3 TSRMLS_CC); } goto se_52be_1; } PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Unrecognized MySQL data type"); return; se_52be_1: RETURN_CTOR(column_sql); }