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