/**
* 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);
}
/**
* Get the document type declaration of content
*
* @return string
*/
PHP_METHOD(Phalcon_Tag, getDocType){
zval *doctype = NULL, *declaration, *eol, *doctype_html;
PHALCON_MM_GROW();
PHALCON_OBSERVE_VAR(doctype);
phalcon_read_static_property(&doctype, SL("phalcon\\tag"), SL("_documentType") TSRMLS_CC);
PHALCON_INIT_VAR(eol);
ZVAL_STRING(eol, PHP_EOL, 1);
PHALCON_INIT_VAR(declaration);
if (phalcon_compare_strict_long(doctype, 1 TSRMLS_CC)) {
ZVAL_STRING(declaration, " PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\"", 1);
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 2 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01//EN\"", eol, "\t\"http://www.w3.org/TR/html4/strict.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 3 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"", eol, "\t\"http://www.w3.org/TR/html4/loose.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 4 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\"", eol, "\t\"http://www.w3.org/TR/html4/frameset.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 6 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 7 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 8 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 9 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"", eol, "\t\"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\"");
goto ph_end_0;
}
if (phalcon_compare_strict_long(doctype, 10 TSRMLS_CC)) {
PHALCON_CONCAT_SVS(declaration, " PUBLIC \"-//W3C//DTD XHTML 2.0//EN\"", eol, "\t\"http://www.w3.org/MarkUp/DTD/xhtml2.dtd\"");
goto ph_end_0;
}
ph_end_0:
PHALCON_INIT_VAR(doctype_html);
PHALCON_CONCAT_SVSV(doctype_html, "<!DOCTYPE html", declaration, ">", eol);
RETURN_CTOR(doctype_html);
}
/**
* Changes the fetching mode affecting Phalcon\Db\Result\Pdo::fetchArray
*
* @param int $fetchMode
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, setFetchMode) {
zval *fetch_mode = NULL, *pdo_statement = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &fetch_mode) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(pdo_statement);
phalcon_read_property(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
if (phalcon_compare_strict_long(fetch_mode, 1 TSRMLS_CC)) {
PHALCON_INIT_VAR(c0);
ZVAL_LONG(c0, 2);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_statement, "setfetchmode", c0, PH_NO_CHECK);
phalcon_update_property_long(this_ptr, SL("_fetchMode"), 2 TSRMLS_CC);
} else {
if (phalcon_compare_strict_long(fetch_mode, 2 TSRMLS_CC)) {
PHALCON_INIT_VAR(c1);
ZVAL_LONG(c1, 4);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_statement, "setfetchmode", c1, PH_NO_CHECK);
phalcon_update_property_long(this_ptr, SL("_fetchMode"), 4 TSRMLS_CC);
} else {
if (phalcon_compare_strict_long(fetch_mode, 3 TSRMLS_CC)) {
PHALCON_INIT_VAR(c2);
ZVAL_LONG(c2, 3);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(pdo_statement, "setfetchmode", c2, PH_NO_CHECK);
phalcon_update_property_long(this_ptr, SL("_fetchMode"), 3 TSRMLS_CC);
}
}
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* Returns the string meaning of a logger constant
*
* @param integer $type
* @return string
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, getTypeString){
zval *type = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &type) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(type);
if (phalcon_compare_strict_long(type, 7 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "DEBUG", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 3 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "ERROR", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 4 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "WARNING", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 1 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "CRITICAL", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 8 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "CUSTOM", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 2 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "ALERT", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 5 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "NOTICE", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 6 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "INFO", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "EMERGENCE", 1);
goto se_654f_0;
}
if (phalcon_compare_strict_long(type, 9 TSRMLS_CC)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "SPECIAL", 1);
goto se_654f_0;
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "CUSTOM", 1);
se_654f_0:
RETURN_CCTOR(type);
}
/**
* Inserts data into a table using custom RBDM SQL syntax
*
* @param string $table
* @param array $values
* @param array $fields
* @return boolean
*/
PHP_METHOD(Phalcon_Db, insert){
zval *table = NULL, *values = NULL, *fields = NULL, *number_values = NULL, *exception_message = NULL;
zval *exception = NULL, *placeholders = NULL, *value = NULL, *position = NULL;
zval *str_value = NULL, *comma = NULL, *joined_values = NULL, *joined_fields = NULL;
zval *insert_sql = NULL, *success = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table, &values, &fields) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!fields) {
PHALCON_ALLOC_ZVAL_MM(fields);
ZVAL_NULL(fields);
}
if (Z_TYPE_P(values) == IS_ARRAY) {
PHALCON_INIT_VAR(number_values);
phalcon_fast_count(number_values, values TSRMLS_CC);
if (phalcon_compare_strict_long(number_values, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data");
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_db_exception_ce);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(exception, "__construct", exception_message, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
if (!phalcon_valid_foreach(values TSRMLS_CC)) {
return;
}
ALLOC_HASHTABLE(ah0);
zend_hash_init(ah0, 0, NULL, NULL, 0);
zend_hash_copy(ah0, Z_ARRVAL_P(values), NULL, NULL, sizeof(zval*));
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_INIT_VAR(position);
PHALCON_GET_FOREACH_KEY(position, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(value) == IS_OBJECT) {
PHALCON_INIT_VAR(str_value);
PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value);
phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE_PARAM(values);
phalcon_array_unset(values, position);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC);
PHALCON_SEPARATE_PARAM(values);
phalcon_array_unset(values, position);
} else {
phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
zend_hash_destroy(ah0);
efree(ah0);
PHALCON_INIT_VAR(comma);
ZVAL_STRING(comma, ", ", 1);
PHALCON_INIT_VAR(joined_values);
phalcon_fast_join(joined_values, comma, placeholders TSRMLS_CC);
if (Z_TYPE_P(fields) == IS_ARRAY) {
PHALCON_INIT_VAR(joined_fields);
phalcon_fast_join(joined_fields, comma, fields TSRMLS_CC);
PHALCON_INIT_VAR(insert_sql);
PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")");
} else {
PHALCON_INIT_VAR(insert_sql);
PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")");
}
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_2(success, this_ptr, "execute", insert_sql, values, PH_NO_CHECK);
RETURN_CCTOR(success);
}
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array");
return;
}
/**
* Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST
*
* @param Phalcon\DI $dependencyInjector
* @param string $modelName
* @param array $data
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput){
zval *dependency_injector = NULL, *model_name = NULL, *data = NULL;
zval *conditions = NULL, *number_data = NULL, *service = NULL, *meta_data = NULL;
zval *model = NULL, *data_types = NULL, *bind = NULL, *value = NULL, *field = NULL, *type = NULL;
zval *condition = NULL, *value_pattern = NULL, *criteria = NULL, *number_conditions = NULL;
zval *join_conditions = NULL;
zval *c0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &dependency_injector, &model_name, &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Input data must be an Array");
return;
}
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "A dependency injector container is required to obtain the ORM services");
return;
}
PHALCON_INIT_VAR(conditions);
array_init(conditions);
PHALCON_INIT_VAR(number_data);
phalcon_fast_count(number_data, data TSRMLS_CC);
if (!phalcon_compare_strict_long(number_data, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "modelsMetadata", 1);
PHALCON_INIT_VAR(meta_data);
PHALCON_CALL_METHOD_PARAMS_1(meta_data, dependency_injector, "getshared", service, PH_NO_CHECK);
ce0 = phalcon_fetch_class(model_name TSRMLS_CC);
PHALCON_INIT_VAR(model);
object_init_ex(model, ce0);
PHALCON_CALL_METHOD_NORETURN(model, "__construct", PH_CHECK);
PHALCON_INIT_VAR(data_types);
PHALCON_CALL_METHOD_PARAMS_1(data_types, meta_data, "getdatatypes", model, PH_NO_CHECK);
PHALCON_INIT_VAR(bind);
array_init(bind);
if (!phalcon_valid_foreach(data TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(data);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_1d26_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_1d26_0;
}
PHALCON_INIT_VAR(field);
PHALCON_GET_FOREACH_KEY(field, ah0, hp0);
PHALCON_INIT_VAR(value);
ZVAL_ZVAL(value, *hd, 1, 0);
eval_int = phalcon_array_isset(data_types, field);
if (eval_int) {
if (Z_TYPE_P(value) != IS_NULL) {
if (!PHALCON_COMPARE_STRING(value, "")) {
PHALCON_INIT_VAR(type);
phalcon_array_fetch(&type, data_types, field, PH_NOISY_CC);
if (phalcon_compare_strict_long(type, 2 TSRMLS_CC)) {
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSVS(condition, field, " LIKE :", field, ":");
PHALCON_INIT_VAR(value_pattern);
PHALCON_CONCAT_SVS(value_pattern, "%", value, "%");
phalcon_array_update_zval(&bind, field, &value_pattern, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_VSVS(condition, field, "=:", field, ":");
phalcon_array_update_zval(&bind, field, &value, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
phalcon_array_append(&conditions, condition, PH_SEPARATE TSRMLS_CC);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_1d26_0;
fee_1d26_0:
if(0){}
}
PHALCON_INIT_VAR(criteria);
object_init_ex(criteria, phalcon_mvc_model_criteria_ce);
PHALCON_CALL_METHOD_NORETURN(criteria, "__construct", PH_CHECK);
PHALCON_INIT_VAR(number_conditions);
phalcon_fast_count(number_conditions, conditions TSRMLS_CC);
if (!phalcon_compare_strict_long(number_conditions, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, " AND ", 1);
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join(join_conditions, c0, conditions TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(criteria, "where", join_conditions, PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(criteria, "bind", bind, PH_NO_CHECK);
}
RETURN_CTOR(criteria);
}
/**
* Generates SQL to add the table creation options
*
* @param array $definition
* @return array
*/
PHP_METHOD(Phalcon_Db_Dialect_Mysql, _getTableOptions){
zval *definition = NULL, *table_options = NULL, *engine = NULL, *sql_engine = NULL;
zval *auto_increment = NULL, *sql_autoincrement = NULL;
zval *table_collation = NULL, *collation_parts = NULL, *sql_charset = NULL;
zval *sql_collate = NULL, *number_options = NULL, *sql_table_options = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL, *c1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(table_options);
array_init(table_options);
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, definition, SL("options"), PH_NOISY_CC);
eval_int = phalcon_array_isset_string(r0, SL("ENGINE")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, SL("options"), PH_NOISY_CC);
PHALCON_INIT_VAR(engine);
phalcon_array_fetch_string(&engine, r1, SL("ENGINE"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, definition, SL("options"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, r2, SL("ENGINE"), PH_NOISY_CC);
if (zend_is_true(r3)) {
PHALCON_INIT_VAR(sql_engine);
PHALCON_CONCAT_SV(sql_engine, "ENGINE=", engine);
phalcon_array_append(&table_options, sql_engine, PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, definition, SL("options"), PH_NOISY_CC);
eval_int = phalcon_array_isset_string(r4, SL("AUTO_INCREMENT")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_array_fetch_string(&r5, definition, SL("options"), PH_NOISY_CC);
PHALCON_INIT_VAR(auto_increment);
phalcon_array_fetch_string(&auto_increment, r5, SL("AUTO_INCREMENT"), PH_NOISY_CC);
if (zend_is_true(auto_increment)) {
PHALCON_INIT_VAR(sql_autoincrement);
PHALCON_CONCAT_SV(sql_autoincrement, "AUTO_INCREMENT=", auto_increment);
phalcon_array_append(&table_options, sql_autoincrement, PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_array_fetch_string(&r6, definition, SL("options"), PH_NOISY_CC);
eval_int = phalcon_array_isset_string(r6, SL("TABLE_COLLATION")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r7);
phalcon_array_fetch_string(&r7, definition, SL("options"), PH_NOISY_CC);
PHALCON_INIT_VAR(table_collation);
phalcon_array_fetch_string(&table_collation, r7, SL("TABLE_COLLATION"), PH_NOISY_CC);
if (zend_is_true(table_collation)) {
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "_", 1);
PHALCON_INIT_VAR(collation_parts);
phalcon_fast_explode(collation_parts, c0, table_collation TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r8);
phalcon_array_fetch_long(&r8, collation_parts, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(sql_charset);
PHALCON_CONCAT_SV(sql_charset, "DEFAULT CHARSET=", r8);
phalcon_array_append(&table_options, sql_charset, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(sql_collate);
PHALCON_CONCAT_SV(sql_collate, "COLLATE=", table_collation);
phalcon_array_append(&table_options, sql_collate, PH_SEPARATE TSRMLS_CC);
}
}
PHALCON_INIT_VAR(number_options);
phalcon_fast_count(number_options, table_options TSRMLS_CC);
if (!phalcon_compare_strict_long(number_options, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, " ", 1);
PHALCON_INIT_VAR(sql_table_options);
phalcon_fast_join(sql_table_options, c1, table_options TSRMLS_CC);
RETURN_CTOR(sql_table_options);
}
PHALCON_MM_RESTORE();
RETURN_NULL();
}
/**
* 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);
}
/**
* Returns a slice of the resultset to show in the pagination
*
* @return stdClass
*/
PHP_METHOD(Phalcon_Paginator_Adapter_Model, getPaginate){
zval *show = NULL, *config = NULL, *items = NULL, *page_number = NULL, *zero = NULL, *one = NULL;
zval *smaller = NULL, *n = NULL, *page = NULL, *last_show_page = NULL, *start = NULL;
zval *last_page = NULL, *possible_pages = NULL, *total_pages = NULL;
zval *compare = NULL, *page_items = NULL, *i = NULL, *valid = NULL, *current = NULL, *maximum_pages = NULL;
zval *next = NULL, *additional_page = NULL, *before = NULL, *remainder = NULL;
zval *pages_total = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(show);
phalcon_read_property(&show, this_ptr, SL("_limitRows"), PH_NOISY_CC);
PHALCON_INIT_VAR(config);
phalcon_read_property(&config, this_ptr, SL("_config"), PH_NOISY_CC);
PHALCON_INIT_VAR(items);
phalcon_array_fetch_string(&items, config, SL("data"), PH_NOISY_CC);
PHALCON_INIT_VAR(page_number);
phalcon_read_property(&page_number, this_ptr, SL("_page"), PH_NOISY_CC);
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 1);
}
PHALCON_INIT_VAR(zero);
ZVAL_LONG(zero, 0);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(smaller);
is_smaller_function(smaller, show, zero TSRMLS_CC);
if (Z_TYPE_P(smaller) == IS_BOOL && Z_BVAL_P(smaller)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(n);
phalcon_fast_count(n, items TSRMLS_CC);
PHALCON_INIT_VAR(page);
object_init(page);
PHALCON_INIT_VAR(last_show_page);
sub_function(last_show_page, page_number, one TSRMLS_CC);
PHALCON_INIT_VAR(start);
mul_function(start, show, last_show_page TSRMLS_CC);
PHALCON_INIT_VAR(last_page);
sub_function(last_page, n, one TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, last_page, show TSRMLS_CC);
PHALCON_INIT_VAR(total_pages);
PHALCON_CALL_FUNC_PARAMS_1(total_pages, "ceil", possible_pages);
if (Z_TYPE_P(items) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "Invalid data for paginator");
return;
}
if (Z_TYPE_P(page_number) == IS_NULL) {
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 0);
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, start, zero TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_paginator_exception_ce, "The start page number is zero or less");
return;
}
PHALCON_INIT_VAR(page_items);
array_init(page_items);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, zero, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(compare);
is_smaller_or_equal_function(compare, start, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", start, PH_NO_CHECK);
} else {
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(items, "seek", one, PH_NO_CHECK);
PHALCON_INIT_VAR(page_number);
ZVAL_LONG(page_number, 1);
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 1);
ws_e435_0:
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, items, "valid", PH_NO_CHECK);
PHALCON_CPY_WRT(valid, r0);
if (Z_TYPE_P(valid) != IS_BOOL || (Z_TYPE_P(valid) == IS_BOOL && !Z_BVAL_P(valid))) {
goto we_e435_0;
}
PHALCON_INIT_VAR(current);
PHALCON_CALL_METHOD(current, items, "current", PH_NO_CHECK);
phalcon_array_append(&page_items, current, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_or_equal_function(compare, show, i TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
goto we_e435_0;
}
PHALCON_SEPARATE(i);
increment_function(i);
goto ws_e435_0;
we_e435_0:
if(0){}
}
phalcon_update_property_zval(page, SL("items"), page_items TSRMLS_CC);
phalcon_update_property_long(page, SL("first"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(maximum_pages);
phalcon_add_function(maximum_pages, start, show TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, maximum_pages, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 1);
PHALCON_INIT_VAR(next);
phalcon_add_function(next, page_number, t0 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(compare);
is_equal_function(compare, maximum_pages, n TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CPY_WRT(next, n);
} else {
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, n, show TSRMLS_CC);
PHALCON_INIT_VAR(additional_page);
phalcon_add_function(additional_page, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(next);
PHALCON_CALL_FUNC_PARAMS_1(next, "intval", additional_page);
}
}
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, total_pages, next TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_CPY_WRT(next, total_pages);
}
phalcon_update_property_zval(page, SL("next"), next TSRMLS_CC);
PHALCON_INIT_VAR(compare);
is_smaller_function(compare, one, page_number TSRMLS_CC);
if (Z_TYPE_P(compare) == IS_BOOL && Z_BVAL_P(compare)) {
PHALCON_INIT_VAR(before);
sub_function(before, page_number, one TSRMLS_CC);
} else {
PHALCON_INIT_VAR(before);
ZVAL_LONG(before, 1);
}
phalcon_update_property_zval(page, SL("before"), before TSRMLS_CC);
phalcon_update_property_zval(page, SL("current"), page_number TSRMLS_CC);
PHALCON_INIT_VAR(remainder);
mod_function(remainder, n, show TSRMLS_CC);
PHALCON_INIT_VAR(possible_pages);
div_function(possible_pages, n, show TSRMLS_CC);
if (!phalcon_compare_strict_long(remainder, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(next);
phalcon_add_function(next, possible_pages, one TSRMLS_CC);
PHALCON_INIT_VAR(pages_total);
PHALCON_CALL_FUNC_PARAMS_1(pages_total, "intval", possible_pages);
} else {
PHALCON_CPY_WRT(pages_total, possible_pages);
}
phalcon_update_property_zval(page, SL("last"), pages_total TSRMLS_CC);
phalcon_update_property_zval(page, SL("total_pages"), pages_total TSRMLS_CC);
RETURN_CTOR(page);
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $connection->prepare('SELECT * FROM robots WHERE name = :name');
* $pdoResult = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *z_one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
zval *profiler, *sql_statement;
HashTable *ah0;
HashPosition hp0;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_NULL();
}
PHALCON_MM_GROW();
z_one = PHALCON_GLOBAL(z_one);
phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(wildcard, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, z_one);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value);
} else {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_INIT_NVAR(type);
if (Z_TYPE_P(value) == IS_LONG) {
ZVAL_LONG(type, 1 /* BIND_PARAM_INT */);
}
else {
ZVAL_LONG(type, 2 /* BIND_PARAM_STR */);
}
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value, type);
Z_UNSET_ISREF_P(value);
/*
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
*/
}
} else {
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
sql_statement = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement, placeholders, data_types);
PHALCON_CALL_METHOD(NULL, statement, "execute");
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(NULL, statement, "execute");
}
RETURN_CTOR(statement);
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
* $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_is_iterable_ex(placeholders, &ah0, &hp0, 0, 0)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
phalcon_call_method_p2_noret(statement, "bindparam", parameter, cast_value);
} else {
phalcon_call_method_p3_noret(statement, "bindparam", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
Z_SET_ISREF_P(value);
phalcon_call_method_p2_noret(statement, "bindparam", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_call_method_noret(statement, "execute");
RETURN_CCTOR(statement);
}
/**
* Process a request header and return the one with best quality
*
* @param array $qualityParts
* @param string $name
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, _getBestQuality){
zval *quality_parts = NULL, *name = NULL, *i = NULL, *quality = NULL, *selected_name = NULL;
zval *accept = NULL, *accept_quality = NULL;
zval *r0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &quality_parts, &name) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(quality);
ZVAL_LONG(quality, 0);
PHALCON_INIT_VAR(selected_name);
ZVAL_STRING(selected_name, "", 1);
if (!phalcon_valid_foreach(quality_parts TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(quality_parts);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ac06_3:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ac06_3;
}
PHALCON_INIT_VAR(accept);
ZVAL_ZVAL(accept, *hd, 1, 0);
if (phalcon_compare_strict_long(i, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(quality);
phalcon_array_fetch_string(&quality, accept, SL("quality"), PH_NOISY_CC);
PHALCON_INIT_VAR(selected_name);
phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC);
} else {
PHALCON_INIT_VAR(accept_quality);
phalcon_array_fetch_string(&accept_quality, accept, SL("quality"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
is_smaller_function(r0, quality, accept_quality TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_CPY_WRT(quality, accept_quality);
PHALCON_INIT_VAR(selected_name);
phalcon_array_fetch(&selected_name, accept, name, PH_NOISY_CC);
}
}
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ac06_3;
fee_ac06_3:
RETURN_CCTOR(selected_name);
}
/**
* Phalcon\Db\Column constructor
*
* @param string $columnName
* @param array $definition
*/
PHP_METHOD(Phalcon_Db_Column, __construct){
zval *column_name = NULL, *definition = NULL, *type = NULL, *not_null = NULL;
zval *primary = NULL, *size = NULL, *is_numeric = NULL, *scale = NULL, *dunsigned = NULL;
zval *auto_increment = NULL, *first = NULL, *after = NULL;
zval *t0 = NULL, *t1 = NULL;
zval *r0 = NULL, *r1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &column_name, &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_update_property_zval(this_ptr, SL("_columnName"), column_name TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, SL("type")+1);
if (eval_int) {
PHALCON_INIT_VAR(type);
phalcon_array_fetch_string(&type, definition, SL("type"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_type"), type TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type is required");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("notNull")+1);
if (eval_int) {
PHALCON_INIT_VAR(not_null);
phalcon_array_fetch_string(¬_null, definition, SL("notNull"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_notNull"), not_null TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("primary")+1);
if (eval_int) {
PHALCON_INIT_VAR(primary);
phalcon_array_fetch_string(&primary, definition, SL("primary"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_primary"), primary TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("size")+1);
if (eval_int) {
PHALCON_INIT_VAR(size);
phalcon_array_fetch_string(&size, definition, SL("size"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_size"), size TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("scale")+1);
if (eval_int) {
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 3);
PHALCON_ALLOC_ZVAL_MM(r0);
is_equal_function(r0, type, t0 TSRMLS_CC);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 7);
PHALCON_ALLOC_ZVAL_MM(r1);
is_equal_function(r1, type, t1 TSRMLS_CC);
PHALCON_INIT_VAR(is_numeric);
ZVAL_BOOL(is_numeric, zend_is_true(r0) || zend_is_true(r1));
if (zend_is_true(is_numeric)) {
PHALCON_INIT_VAR(scale);
phalcon_array_fetch_string(&scale, definition, SL("scale"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_scale"), scale TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type does not support scale parameter");
return;
}
}
eval_int = phalcon_array_isset_string(definition, SL("unsigned")+1);
if (eval_int) {
PHALCON_INIT_VAR(dunsigned);
phalcon_array_fetch_string(&dunsigned, definition, SL("unsigned"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_unsigned"), dunsigned TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("isNumeric")+1);
if (eval_int) {
PHALCON_INIT_VAR(is_numeric);
phalcon_array_fetch_string(&is_numeric, definition, SL("isNumeric"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_isNumeric"), is_numeric TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("autoIncrement")+1);
if (eval_int) {
if (phalcon_compare_strict_long(type, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(auto_increment);
phalcon_array_fetch_string(&auto_increment, definition, SL("autoIncrement"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_autoIncrement"), auto_increment TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type cannot be auto-increment");
return;
}
}
eval_int = phalcon_array_isset_string(definition, SL("first")+1);
if (eval_int) {
PHALCON_INIT_VAR(first);
phalcon_array_fetch_string(&first, definition, SL("first"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_first"), first TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("after")+1);
if (eval_int) {
PHALCON_INIT_VAR(after);
phalcon_array_fetch_string(&after, definition, SL("after"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_after"), after TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Executes a prepared statement binding
*
* @param PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, _executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one = NULL, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_valid_foreach(placeholders TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(placeholders);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto ph_cycle_end_0;
}
PHALCON_INIT_VAR(wildcard);
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_VAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
eval_int = phalcon_array_isset(data_types, wildcard);
if (eval_int) {
PHALCON_INIT_VAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY_CC);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_VAR(cast_value);
PHALCON_CALL_FUNC_PARAMS_1(cast_value, "doubleval", value);
PHALCON_INIT_VAR(type);
ZVAL_LONG(type, 2);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
Z_SET_ISREF_P(cast_value);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(statement, "bindparam", parameter, cast_value, type, PH_NO_CHECK);
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(statement, "bindparam", parameter, value, PH_NO_CHECK);
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_CALL_METHOD_NORETURN(statement, "execute", PH_NO_CHECK);
RETURN_CCTOR(statement);}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View, _loadTemplateEngines){
zval *engines = NULL, *dependency_injector = NULL, *registered_engines = NULL;
zval *number_engines = NULL, *php_engine = NULL, *arguments = NULL;
zval *engine_service = NULL, *extension = NULL, *engine_object = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(engines);
phalcon_read_property(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
if (Z_TYPE_P(engines) == IS_BOOL && !Z_BVAL_P(engines)) {
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
PHALCON_INIT_VAR(engines);
array_init(engines);
PHALCON_INIT_VAR(registered_engines);
phalcon_read_property(®istered_engines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
PHALCON_INIT_VAR(number_engines);
phalcon_fast_count(number_engines, registered_engines TSRMLS_CC);
if (phalcon_compare_strict_long(number_engines, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(php_engine);
object_init_ex(php_engine, phalcon_mvc_view_engine_php_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(php_engine, "__construct", this_ptr, dependency_injector, PH_CHECK);
phalcon_array_update_string(&engines, SL(".phtml"), &php_engine, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_view_exception_ce, "A dependency injector container is required to obtain the application services");
return;
}
PHALCON_INIT_VAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, this_ptr, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, dependency_injector, PH_SEPARATE TSRMLS_CC);
if (!phalcon_valid_foreach(registered_engines TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(registered_engines);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_ecde_0:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_ecde_0;
}
PHALCON_INIT_VAR(extension);
PHALCON_GET_FOREACH_KEY(extension, ah0, hp0);
PHALCON_INIT_VAR(engine_service);
ZVAL_ZVAL(engine_service, *hd, 1, 0);
PHALCON_INIT_VAR(engine_object);
PHALCON_CALL_METHOD_PARAMS_2(engine_object, dependency_injector, "getshared", engine_service, arguments, PH_NO_CHECK);
phalcon_array_update_zval(&engines, extension, &engine_object, PH_COPY | PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_ecde_0;
fee_ecde_0:
if(0){}
}
phalcon_update_property_zval(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
PHALCON_INIT_VAR(engines);
phalcon_read_property(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* Gets the column name in PostgreSQL
*
* @param Phalcon\Db\Column $column
*/
PHP_METHOD(Phalcon_Db_Dialect_Postgresql, getColumnDefinition){
zval *column = NULL, *size = NULL, *column_type = NULL, *column_sql = NULL;
zval *scale = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &column) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(column) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column definition must be an instance of Phalcon\\Db\\Column");
return;
}
PHALCON_INIT_VAR(size);
PHALCON_CALL_METHOD(size, column, "getsize", PH_NO_CHECK);
PHALCON_INIT_VAR(column_type);
PHALCON_CALL_METHOD(column_type, column, "gettype", PH_NO_CHECK);
if (phalcon_compare_strict_long(column_type, 0 TSRMLS_CC)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "INT", 1);
goto ph_end_0;
}
if (phalcon_compare_strict_long(column_type, 1 TSRMLS_CC)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "DATE", 1);
goto ph_end_0;
}
if (phalcon_compare_strict_long(column_type, 2 TSRMLS_CC)) {
PHALCON_INIT_VAR(column_sql);
PHALCON_CONCAT_SVS(column_sql, "CHARACTER VARYING(", size, ")");
goto ph_end_0;
}
if (phalcon_compare_strict_long(column_type, 3 TSRMLS_CC)) {
PHALCON_INIT_VAR(scale);
PHALCON_CALL_METHOD(scale, column, "getscale", PH_NO_CHECK);
PHALCON_INIT_VAR(column_sql);
PHALCON_CONCAT_SVSVS(column_sql, "NUMERIC(", size, ",", scale, ")");
goto ph_end_0;
}
if (phalcon_compare_strict_long(column_type, 4 TSRMLS_CC)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "TIMESTAMP", 1);
goto ph_end_0;
}
if (phalcon_compare_strict_long(column_type, 5 TSRMLS_CC)) {
PHALCON_INIT_VAR(column_sql);
PHALCON_CONCAT_SVS(column_sql, "CHARACTER(", size, ")");
goto ph_end_0;
}
if (phalcon_compare_strict_long(column_type, 6 TSRMLS_CC)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "TEXT", 1);
goto ph_end_0;
}
if (phalcon_compare_strict_long(column_type, 7 TSRMLS_CC)) {
PHALCON_INIT_VAR(column_sql);
ZVAL_STRING(column_sql, "FLOAT", 1);
goto ph_end_0;
}
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Unrecognized PostgreSQL data type");
return;
ph_end_0:
RETURN_CTOR(column_sql);
}
