/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Oracle, describeColumns) {
zval *table, *schema = NULL, *columns, *dialect, *sql = NULL, *fetch_num;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *column_size = NULL, *column_precision = NULL, *column_scale = NULL;
zval *column_type = NULL, *attribute = NULL, *column_name = NULL;
zval *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
schema = PHALCON_GLOBAL(z_null);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_OBS_VAR(dialect);
phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&sql, dialect, "describecolumns", table, schema);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, PDO_FETCH_NUM);
PHALCON_CALL_METHOD(&describe, this_ptr, "fetchall", sql, fetch_num);
/**
* 0:column_name, 1:data_type, 2:data_length, 3:data_precision, 4:data_scale,
* 5:nullable, 6:constraint_type, 7:default, 8:position;
*/
PHALCON_INIT_VAR(old_column);
phalcon_is_iterable(describe, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(field);
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 1);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_OBS_NVAR(column_size);
phalcon_array_fetch_long(&column_size, field, 2, PH_NOISY);
PHALCON_OBS_NVAR(column_precision);
phalcon_array_fetch_long(&column_precision, field, 3, PH_NOISY);
PHALCON_OBS_NVAR(column_scale);
phalcon_array_fetch_long(&column_scale, field, 4, PH_NOISY);
PHALCON_OBS_NVAR(column_type);
phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY);
/**
* Check the column type to get the correct Phalcon type
*/
while (1) {
/**
* Integer
*/
if (phalcon_memnstr_str(column_type, SL("NUMBER"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DECIMAL, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), column_precision, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
if (phalcon_is_numeric(column_precision)) {
phalcon_array_update_string_long(&definition, SL("bytes"), Z_LVAL_P(column_precision) * 8, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("size"), 30, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), 80, PH_COPY);
}
if (phalcon_is_numeric(column_scale)) {
phalcon_array_update_string(&definition, SL("scale"), column_scale, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("scale"), 6, PH_COPY);
}
break;
}
/**
* Tinyint(1) is boolean
*/
if (phalcon_memnstr_str(column_type, SL("TINYINT(1)"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY);
break;
}
/**
* Smallint/Bigint/Integers/Int are int
*/
if (phalcon_memnstr_str(column_type, SL("INTEGER"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_INTEGER, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), column_precision, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), 32, PH_COPY);
break;
}
/**
* Float/Smallfloats/Decimals are float
*/
if (phalcon_memnstr_str(column_type, SL("FLOAT"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_FLOAT, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), column_size, PH_COPY);
phalcon_array_update_string(&definition, SL("scale"), column_scale, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
break;
}
/**
* Date
*/
if (phalcon_memnstr_str(column_type, SL("TIMESTAMP"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATE, PH_COPY);
break;
}
/**
* Text
*/
if (phalcon_memnstr_str(column_type, SL("RAW"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY);
break;
}
/**
* Text
*/
if (phalcon_memnstr_str(column_type, SL("BLOB"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY);
break;
}
/**
* Text
*/
if (phalcon_memnstr_str(column_type, SL("CLOB"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY);
break;
}
/**
* Chars2 are string
*/
if (phalcon_memnstr_str(column_type, SL("VARCHAR2"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), column_size, PH_COPY);
break;
}
/**
* Chars are chars
*/
if (phalcon_memnstr_str(column_type, SL("CHAR"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), column_size, PH_COPY);
break;
}
/**
* Text are varchars
*/
if (phalcon_memnstr_str(column_type, SL("text"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY);
break;
}
/**
* By default is string
*/
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY);
break;
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_COPY);
} else {
phalcon_array_update_string(&definition, SL("after"), old_column, PH_COPY);
}
/**
* Check if the field is primary key
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "P")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_COPY);
}
/**
* Check if the column allows null values
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "N")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_COPY);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY);
/**
* If the column set the default values, get it
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 7, PH_NOISY);
if (!PHALCON_IS_EMPTY(attribute)) {
phalcon_array_update_string(&definition, SL("default"), attribute, PH_COPY);
}
/**
* Create a Phalcon\Db\Column to abstract the column
*/
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD(NULL, column, "__construct", column_name, definition);
phalcon_array_append(&columns, column, PH_COPY);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(columns);
}
/**
* Builds a Phalcon\Mvc\Model\Criteria based on an input array like $_POST
*
* @param Phalcon\DiInterface $dependencyInjector
* @param string $modelName
* @param array $data
* @return static
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, fromInput){
zval *dependency_injector, *model_name, *data;
zval *conditions, *service, *meta_data, *model;
zval *data_types, *bind, *value = NULL, *field = NULL, *type = NULL, *condition = NULL;
zval *value_pattern = NULL, *criteria, *join_conditions;
HashTable *ah0;
HashPosition hp0;
zval **hd;
zend_class_entry *ce0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 3, 0, &dependency_injector, &model_name, &data);
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);
if (phalcon_fast_count_ev(data TSRMLS_CC)) {
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "modelsMetadata", 1);
PHALCON_INIT_VAR(meta_data);
phalcon_call_method_p1(meta_data, dependency_injector, "getshared", service);
ce0 = phalcon_fetch_class(model_name TSRMLS_CC);
PHALCON_INIT_VAR(model);
object_init_ex(model, ce0);
if (phalcon_has_constructor(model TSRMLS_CC)) {
phalcon_call_method_noret(model, "__construct");
}
PHALCON_INIT_VAR(data_types);
phalcon_call_method_p1(data_types, meta_data, "getdatatypes", model);
PHALCON_INIT_VAR(bind);
array_init(bind);
/**
* We look for attributes in the array passed as data
*/
phalcon_is_iterable(data, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(field, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (phalcon_array_isset(data_types, field)) {
if (Z_TYPE_P(value) != IS_NULL) {
if (!PHALCON_IS_STRING(value, "")) {
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, field, PH_NOISY_CC);
if (PHALCON_IS_LONG(type, 2)) {
/**
* For varchar types we use LIKE operator
*/
PHALCON_INIT_NVAR(condition);
PHALCON_CONCAT_VSVS(condition, field, " LIKE :", field, ":");
PHALCON_INIT_NVAR(value_pattern);
PHALCON_CONCAT_SVS(value_pattern, "%", value, "%");
phalcon_array_update_zval(&bind, field, &value_pattern, PH_COPY | PH_SEPARATE TSRMLS_CC);
} else {
/**
* For the rest of data types we use a plain = operator
*/
PHALCON_INIT_NVAR(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);
}
}
/**
* Create an object instance and pass the paramaters to it
*/
PHALCON_INIT_VAR(criteria);
object_init_ex(criteria, phalcon_mvc_model_criteria_ce);
if (phalcon_fast_count_ev(conditions TSRMLS_CC)) {
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join_str(join_conditions, SL(" AND "), conditions TSRMLS_CC);
phalcon_call_method_p1_noret(criteria, "where", join_conditions);
phalcon_call_method_p1_noret(criteria, "bind", bind);
}
RETURN_CTOR(criteria);
}
/**
* Phalcon\Db\Column constructor
*
* @param string $columnName
* @param array $definition
*/
PHP_METHOD(Phalcon_Db_Column, __construct){
zval *column_name, *definition, *type, *not_null;
zval *primary, *size, *is_numeric = NULL, *scale, *dunsigned;
zval *auto_increment, *first, *after, *bind_type;
zval *t0 = NULL, *t1 = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &column_name, &definition);
phalcon_update_property_this(this_ptr, SL("_columnName"), column_name TSRMLS_CC);
/**
* Get the column type, one of the TYPE_* constants
*/
if (phalcon_array_isset_string(definition, SS("type"))) {
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, definition, SL("type"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type is required");
return;
}
/**
* Check if the field is nullable
*/
if (phalcon_array_isset_string(definition, SS("notNull"))) {
PHALCON_OBS_VAR(not_null);
phalcon_array_fetch_string(¬_null, definition, SL("notNull"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_notNull"), not_null TSRMLS_CC);
}
/**
* Check if the field is primary key
*/
if (phalcon_array_isset_string(definition, SS("primary"))) {
PHALCON_OBS_VAR(primary);
phalcon_array_fetch_string(&primary, definition, SL("primary"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_primary"), primary TSRMLS_CC);
}
if (phalcon_array_isset_string(definition, SS("size"))) {
PHALCON_OBS_VAR(size);
phalcon_array_fetch_string(&size, definition, SL("size"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC);
}
/**
* Check if the column has a decimal scale
*/
if (phalcon_array_isset_string(definition, SS("scale"))) {
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, 3);
PHALCON_INIT_VAR(is_numeric);
is_equal_function(is_numeric, type, t0 TSRMLS_CC);
if (PHALCON_IS_NOT_TRUE(is_numeric)) {
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 7);
is_equal_function(is_numeric, type, t1 TSRMLS_CC);
}
if (PHALCON_IS_TRUE(is_numeric)) {
PHALCON_OBS_VAR(scale);
phalcon_array_fetch_string(&scale, definition, SL("scale"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_scale"), scale TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type does not support scale parameter");
return;
}
}
/**
* Check if the field is unsigned (only MySQL)
*/
if (phalcon_array_isset_string(definition, SS("unsigned"))) {
PHALCON_OBS_VAR(dunsigned);
phalcon_array_fetch_string(&dunsigned, definition, SL("unsigned"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_unsigned"), dunsigned TSRMLS_CC);
}
/**
* Check if the field is numeric
*/
if (phalcon_array_isset_string(definition, SS("isNumeric"))) {
PHALCON_OBS_NVAR(is_numeric);
phalcon_array_fetch_string(&is_numeric, definition, SL("isNumeric"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_isNumeric"), is_numeric TSRMLS_CC);
}
/**
* Check if the field is auto-increment/serial
*/
if (phalcon_array_isset_string(definition, SS("autoIncrement"))) {
if (PHALCON_IS_LONG(type, 0)) {
PHALCON_OBS_VAR(auto_increment);
phalcon_array_fetch_string(&auto_increment, definition, SL("autoIncrement"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_autoIncrement"), auto_increment TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column type cannot be auto-increment");
return;
}
}
/**
* Check if the field is placed at the first position of the table
*/
if (phalcon_array_isset_string(definition, SS("first"))) {
PHALCON_OBS_VAR(first);
phalcon_array_fetch_string(&first, definition, SL("first"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_first"), first TSRMLS_CC);
}
/**
* Name of the column which is placed before the current field
*/
if (phalcon_array_isset_string(definition, SS("after"))) {
PHALCON_OBS_VAR(after);
phalcon_array_fetch_string(&after, definition, SL("after"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_after"), after TSRMLS_CC);
}
/**
* The bind type to cast the field when passing it to PDO
*/
if (phalcon_array_isset_string(definition, SS("bindType"))) {
PHALCON_OBS_VAR(bind_type);
phalcon_array_fetch_string(&bind_type, definition, SL("bindType"), PH_NOISY_CC);
phalcon_update_property_this(this_ptr, SL("_bindType"), bind_type TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Renders a view
*
* @param string $path
* @param array $params
* @return string
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, render){
zval *path, *params = NULL, *cache, *is_started = NULL, *key = NULL, *lifetime = NULL;
zval *cache_options, *content = NULL, *view_params;
zval *merged_params = NULL, *is_fresh;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &path, ¶ms);
if (!params) {
PHALCON_INIT_VAR(params);
}
/**
* Create/Get a cache
*/
PHALCON_INIT_VAR(cache);
phalcon_call_method(cache, this_ptr, "getcache");
if (Z_TYPE_P(cache) == IS_OBJECT) {
/**
* Check if the cache is started, the first time a cache is started we start the
* cache
*/
PHALCON_INIT_VAR(is_started);
phalcon_call_method(is_started, cache, "isstarted");
if (PHALCON_IS_FALSE(is_started)) {
PHALCON_INIT_VAR(key);
PHALCON_INIT_VAR(lifetime);
PHALCON_OBS_VAR(cache_options);
phalcon_read_property_this(&cache_options, this_ptr, SL("_cacheOptions"), PH_NOISY_CC);
/**
* Check if the user has defined a different options to the default
*/
if (Z_TYPE_P(cache_options) == IS_ARRAY) {
if (phalcon_array_isset_string(cache_options, SS("key"))) {
PHALCON_OBS_NVAR(key);
phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY);
}
if (phalcon_array_isset_string(cache_options, SS("lifetime"))) {
PHALCON_OBS_NVAR(lifetime);
phalcon_array_fetch_string(&lifetime, cache_options, SL("lifetime"), PH_NOISY);
}
}
/**
* If a cache key is not set we create one using a md5
*/
if (Z_TYPE_P(key) == IS_NULL) {
PHALCON_INIT_NVAR(key);
phalcon_md5(key, path);
}
/**
* We start the cache using the key set
*/
PHALCON_INIT_VAR(content);
phalcon_call_method_p2(content, cache, "start", key, lifetime);
if (Z_TYPE_P(content) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_content"), content TSRMLS_CC);
RETURN_CCTOR(content);
}
}
}
/**
* Create a virtual symbol table
*/
phalcon_create_symbol_table(TSRMLS_C);
phalcon_ob_start(TSRMLS_C);
PHALCON_OBS_VAR(view_params);
phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC);
/**
* Merge parameters
*/
if (Z_TYPE_P(params) == IS_ARRAY) {
if (Z_TYPE_P(view_params) == IS_ARRAY) {
PHALCON_INIT_VAR(merged_params);
phalcon_fast_array_merge(merged_params, &view_params, ¶ms TSRMLS_CC);
} else {
PHALCON_CPY_WRT(merged_params, params);
}
} else {
PHALCON_CPY_WRT(merged_params, view_params);
}
/**
* internalRender is also reused by partials
*/
phalcon_call_method_p2_noret(this_ptr, "_internalrender", path, merged_params);
/**
* Store the data in output into the cache
*/
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_NVAR(is_started);
phalcon_call_method(is_started, cache, "isstarted");
if (PHALCON_IS_TRUE(is_started)) {
PHALCON_INIT_VAR(is_fresh);
phalcon_call_method(is_fresh, cache, "isfresh");
if (PHALCON_IS_TRUE(is_fresh)) {
phalcon_call_method_noret(cache, "save");
} else {
phalcon_call_method_noret(cache, "stop");
}
} else {
phalcon_call_method_noret(cache, "stop");
}
}
phalcon_ob_end_clean(TSRMLS_C);
PHALCON_OBS_NVAR(content);
phalcon_read_property_this(&content, this_ptr, SL("_content"), PH_NOISY_CC);
RETURN_CCTOR(content);
}
/**
* 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) {
/**
* Builds a SELECT statement
*
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, 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;
zval *one, *ini_range, *end_range, *sql_limit;
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_this(&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_ex(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_p2(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_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);
}
} 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, " ", 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 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_ex(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_p2(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_ex(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_p2(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_ex(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_p2(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);
if (Z_TYPE_P(where_conditions) == IS_ARRAY) {
PHALCON_INIT_VAR(where_expression);
phalcon_call_method_p2(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_CC);
if (!phalcon_is_iterable_ex(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_p2(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_p2(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_ex(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_p2(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);
}
/**
* 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(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);
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);
} else {
PHALCON_INIT_VAR(offset);
ZVAL_LONG(offset, 0);
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(ini_range);
phalcon_add_function(ini_range, offset, one TSRMLS_CC);
PHALCON_INIT_VAR(end_range);
phalcon_add_function(end_range, offset, number 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(offset);
ZVAL_LONG(offset, 0);
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
PHALCON_INIT_VAR(ini_range);
phalcon_add_function(ini_range, offset, one TSRMLS_CC);
PHALCON_INIT_VAR(end_range);
phalcon_add_function(end_range, offset, limit_value 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);
}
}
RETURN_CTOR(sql);
}
/**
* 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, *column_domain = NULL;
zval *column_domain_sql = NULL, *column_alias = NULL, *column_alias_sql = NULL;
zval *columns_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();
phalcon_fetch_params(1, 1, 0, &definition);
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_this(&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);
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_INIT_NVAR(column_sql);
phalcon_call_method_p2(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(column_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, " 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);
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_INIT_NVAR(sql_table);
phalcon_call_method_p2(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);
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);
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_INIT_NVAR(sql_table);
phalcon_call_method_p2(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_INIT_NVAR(join_expression);
phalcon_call_method_p2(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_SVS(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_INIT_VAR(where_expression);
phalcon_call_method_p2(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_INIT_NVAR(group_expression);
phalcon_call_method_p2(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_INIT_VAR(having_expression);
phalcon_call_method_p2(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_INIT_NVAR(order_sql_item);
phalcon_call_method_p2(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);
}
/**
* 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);
if (Z_TYPE_P(limit_value) == IS_ARRAY) {
PHALCON_OBS_VAR(number);
phalcon_array_fetch_string(&number, limit_value, SL("number"), PH_NOISY);
/**
* 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);
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);
}
/**
* Commits the active transaction in the connection
*
* @param boolean $nesting
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, commit){
zval *nesting = NULL, *pdo, *transaction_level, *events_manager = NULL;
zval *event_name = NULL, *ntw_savepoint, *savepoint_name;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &nesting);
if (!nesting) {
PHALCON_INIT_VAR(nesting);
ZVAL_BOOL(nesting, 1);
}
PHALCON_OBS_VAR(pdo);
phalcon_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
RETURN_MM_FALSE;
}
/**
* Check the transaction nesting level
*/
PHALCON_OBS_VAR(transaction_level);
phalcon_read_property_this(&transaction_level, this_ptr, SL("_transactionLevel"), PH_NOISY_CC);
if (!zend_is_true(transaction_level)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "There is no active transaction");
return;
}
if (PHALCON_IS_LONG(transaction_level, 1)) {
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
/**
* Notify the events manager about the commited transaction
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:commitTransaction", 1);
phalcon_call_method_p2_noret(events_manager, "fire", event_name, this_ptr);
}
/**
* Reduce the transaction nesting level
*/
phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
phalcon_call_method(return_value, pdo, "commit");
RETURN_MM();
} else {
if (zend_is_true(transaction_level)) {
if (zend_is_true(nesting)) {
/**
* Check if the current database system supports nested transactions
*/
PHALCON_INIT_VAR(ntw_savepoint);
phalcon_call_method(ntw_savepoint, this_ptr, "isnestedtransactionswithsavepoints");
if (zend_is_true(ntw_savepoint)) {
PHALCON_OBS_NVAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
PHALCON_INIT_VAR(savepoint_name);
phalcon_call_method(savepoint_name, this_ptr, "getnestedtransactionsavepointname");
/**
* Notify the events manager about the commited savepoint
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "db:releaseSavepoint", 1);
phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, savepoint_name);
}
/**
* Reduce the transaction nesting level
*/
phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
phalcon_call_method_p1(return_value, this_ptr, "releasesavepoint", savepoint_name);
RETURN_MM();
}
}
}
}
/**
* Reduce the transaction nesting level
*/
if (PHALCON_GT_LONG(transaction_level, 0)) {
phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
}
RETURN_MM_FALSE;
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>
* print_r($connection->describeColumns("posts")); ?>
* </code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Mysql, describeColumns){
zval *table, *schema = NULL, *dialect, *sql = NULL, *fetch_num;
zval *describe = NULL, *old_column = NULL, *size_pattern, *columns;
zval *field = NULL, *definition = NULL, *column_type = NULL, *matches = NULL;
zval *pos = NULL, *match_one = NULL, *match_two = NULL, *attribute = NULL, *column_name = NULL;
zval *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
schema = PHALCON_GLOBAL(z_null);
}
PHALCON_OBS_VAR(dialect);
phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY TSRMLS_CC);
/**
* Get the SQL to describe a table
*/
PHALCON_CALL_METHOD(&sql, dialect, "describecolumns", table, schema);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, PDO_FETCH_NUM);
/**
* Get the describe
*/
PHALCON_CALL_METHOD(&describe, this_ptr, "fetchall", sql, fetch_num);
PHALCON_INIT_VAR(old_column);
PHALCON_INIT_VAR(size_pattern);
ZVAL_STRING(size_pattern, "#\\(([0-9]++)(?:,\\s*([0-9]++))?\\)#", 1);
PHALCON_INIT_VAR(columns);
array_init(columns);
/**
* Field Indexes: 0:name, 1:type, 2:not null, 3:key, 4:default, 5:extra
*/
phalcon_is_iterable(describe, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(field);
/**
* By default the bind types is two
*/
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 1);
add_assoc_long_ex(definition, SS("bindType"), 2);
/**
* By checking every column type we convert it to a Phalcon\Db\Column
*/
PHALCON_OBS_NVAR(column_type);
phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY);
/**
* Check the column type to get the correct Phalcon type
*/
while (1) {
/**
* Point are varchars
*/
if (phalcon_memnstr_str(column_type, SL("point"))) {
phalcon_array_update_string_long(&definition, SL("type"), 2, 0);
break;
}
/**
* Enum are treated as char
*/
if (phalcon_memnstr_str(column_type, SL("enum"))) {
phalcon_array_update_string_long(&definition, SL("type"), 5, 0);
break;
}
/**
* Smallint/Bigint/Integers/Int are int
*/
if (phalcon_memnstr_str(column_type, SL("int"))) {
phalcon_array_update_string_long(&definition, SL("type"), 0, 0);
phalcon_array_update_string(&definition, SL("isNumeric"), PHALCON_GLOBAL(z_true), PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, 0);
break;
}
/**
* Varchar are varchars
*/
if (phalcon_memnstr_str(column_type, SL("varchar"))) {
phalcon_array_update_string_long(&definition, SL("type"), 2, 0);
break;
}
/**
* Special type for datetime
*/
if (phalcon_memnstr_str(column_type, SL("datetime"))) {
phalcon_array_update_string_long(&definition, SL("type"), 4, 0);
break;
}
/**
* Decimals are floats
*/
if (phalcon_memnstr_str(column_type, SL("decimal"))) {
phalcon_array_update_string_long(&definition, SL("type"), 3, 0);
phalcon_array_update_string(&definition, SL("isNumeric"), PHALCON_GLOBAL(z_true), PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, 0);
break;
}
/**
* Chars are chars
*/
if (phalcon_memnstr_str(column_type, SL("char"))) {
phalcon_array_update_string_long(&definition, SL("type"), 5, 0);
break;
}
/**
* Date/Datetime are varchars
*/
if (phalcon_memnstr_str(column_type, SL("date"))) {
phalcon_array_update_string_long(&definition, SL("type"), 1, 0);
break;
}
/**
* Timestamp as date
*/
if (phalcon_memnstr_str(column_type, SL("timestamp"))) {
phalcon_array_update_string_long(&definition, SL("type"), 1, 0);
break;
}
/**
* Text are varchars
*/
if (phalcon_memnstr_str(column_type, SL("text"))) {
phalcon_array_update_string_long(&definition, SL("type"), 6, 0);
break;
}
/**
* Float/Smallfloats/Decimals are float
*/
if (phalcon_memnstr_str(column_type, SL("float"))) {
phalcon_array_update_string_long(&definition, SL("type"), 7, 0);
phalcon_array_update_string(&definition, SL("isNumeric"), PHALCON_GLOBAL(z_true), PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, 0);
break;
}
/**
* Double are floats
*/
if (phalcon_memnstr_str(column_type, SL("double"))) {
phalcon_array_update_string_long(&definition, SL("type"), 9, 0);
phalcon_array_update_string(&definition, SL("isNumeric"), PHALCON_GLOBAL(z_true), PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, 0);
break;
}
/**
* By default is string
*/
phalcon_array_update_string_long(&definition, SL("type"), 2, 0);
break;
}
/**
* If the column type has a parentheses we try to get the column size from it
*/
if (phalcon_memnstr_str(column_type, SL("("))) {
PHALCON_INIT_NVAR(matches);
PHALCON_INIT_NVAR(pos);
RETURN_MM_ON_FAILURE(phalcon_preg_match(pos, size_pattern, column_type, matches TSRMLS_CC));
if (zend_is_true(pos)) {
if (phalcon_array_isset_long(matches, 1)) {
PHALCON_OBS_NVAR(match_one);
phalcon_array_fetch_long(&match_one, matches, 1, PH_NOISY);
phalcon_array_update_string(&definition, SL("size"), match_one, PH_COPY | PH_SEPARATE);
}
if (phalcon_array_isset_long(matches, 2)) {
PHALCON_OBS_NVAR(match_two);
phalcon_array_fetch_long(&match_two, matches, 2, PH_NOISY);
phalcon_array_update_string(&definition, SL("scale"), match_two, PH_COPY | PH_SEPARATE);
}
}
}
/**
* Check if the column is unsigned, only MySQL support this
*/
if (phalcon_memnstr_str(column_type, SL("unsigned"))) {
phalcon_array_update_string(&definition, SL("unsigned"), PHALCON_GLOBAL(z_true), PH_COPY);
}
/**
* Positions
*/
if (!zend_is_true(old_column)) {
phalcon_array_update_string(&definition, SL("first"), PHALCON_GLOBAL(z_true), PH_COPY);
} else {
phalcon_array_update_string(&definition, SL("after"), old_column, PH_COPY);
}
/**
* Check if the field is primary key
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 3, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "PRI")) {
phalcon_array_update_string(&definition, SL("primary"), PHALCON_GLOBAL(z_true), PH_COPY);
}
/**
* Check if the column allows null values
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 2, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "NO")) {
phalcon_array_update_string(&definition, SL("notNull"), PHALCON_GLOBAL(z_true), PH_COPY);
}
/**
* Check if the column is auto increment
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "auto_increment")) {
phalcon_array_update_string(&definition, SL("autoIncrement"), PHALCON_GLOBAL(z_true), PH_COPY);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY);
/**
* Every route is stored as a Phalcon\Db\Column
*/
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD(NULL, column, "__construct", column_name, definition);
phalcon_array_append(&columns, column, PH_SEPARATE);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(columns);
}
/**
* 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);
}
/**
* Starts a transaction in the connection
*
* @param boolean $nesting
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, begin){
zval *nesting = NULL, *pdo, *transaction_level, *events_manager = NULL;
zval *event_name = NULL, *ntw_savepoint, *savepoint_name;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &nesting);
if (!nesting) {
PHALCON_INIT_VAR(nesting);
ZVAL_BOOL(nesting, 1);
}
PHALCON_OBS_VAR(pdo);
phalcon_read_property_this(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
RETURN_MM_FALSE;
}
/**
* Increase the transaction nesting level
*/
phalcon_property_incr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
/**
* Check the transaction nesting level
*/
PHALCON_OBS_VAR(transaction_level);
phalcon_read_property_this(&transaction_level, this_ptr, SL("_transactionLevel"), PH_NOISY_CC);
if (PHALCON_IS_LONG(transaction_level, 1)) {
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
/**
* Notify the events manager about the started transaction
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:beginTransaction", 1);
phalcon_call_method_p2_noret(events_manager, "fire", event_name, this_ptr);
}
phalcon_call_method(return_value, pdo, "begintransaction");
RETURN_MM();
} else {
if (zend_is_true(transaction_level)) {
if (zend_is_true(nesting)) {
PHALCON_INIT_VAR(ntw_savepoint);
phalcon_call_method(ntw_savepoint, this_ptr, "isnestedtransactionswithsavepoints");
if (zend_is_true(ntw_savepoint)) {
PHALCON_OBS_NVAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
PHALCON_INIT_VAR(savepoint_name);
phalcon_call_method(savepoint_name, this_ptr, "getnestedtransactionsavepointname");
/**
* Notify the events manager about the created savepoint
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "db:createSavepoint", 1);
phalcon_call_method_p3_noret(events_manager, "fire", event_name, this_ptr, savepoint_name);
}
phalcon_call_method_p1(return_value, this_ptr, "createsavepoint", savepoint_name);
RETURN_MM();
}
}
}
}
RETURN_MM_FALSE;
}
/**
* Stores cached content into the Memcached backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *last_key = NULL, *prefix, *frontend, *memcache = NULL, *cached_content = NULL;
zval *prepared_content, *ttl = NULL, *flags, *success;
zval *options, *special_key, *keys = NULL, *is_buffering;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) {
RETURN_MM_NULL();
}
if (!key_name) {
PHALCON_INIT_VAR(key_name);
}
if (!content) {
PHALCON_INIT_VAR(content);
}
if (!lifetime) {
PHALCON_INIT_VAR(lifetime);
}
if (!stop_buffer) {
PHALCON_INIT_VAR(stop_buffer);
ZVAL_BOOL(stop_buffer, 1);
}
if (Z_TYPE_P(key_name) == IS_NULL) {
PHALCON_OBS_VAR(last_key);
phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC);
} else {
PHALCON_OBS_VAR(prefix);
phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC);
PHALCON_INIT_NVAR(last_key);
PHALCON_CONCAT_VV(last_key, prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
PHALCON_OBS_VAR(frontend);
phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC);
/**
* Check if a connection is created or make a new one
*/
PHALCON_OBS_VAR(memcache);
phalcon_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
PHALCON_CALL_METHOD_NORETURN(this_ptr, "_connect");
PHALCON_OBS_NVAR(memcache);
phalcon_read_property(&memcache, this_ptr, SL("_memcache"), PH_NOISY_CC);
}
if (Z_TYPE_P(content) == IS_NULL) {
PHALCON_INIT_VAR(cached_content);
PHALCON_CALL_METHOD(cached_content, frontend, "getcontent");
} else {
PHALCON_CPY_WRT(cached_content, content);
}
/**
* Prepare the content in the frontend
*/
PHALCON_INIT_VAR(prepared_content);
PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content);
if (Z_TYPE_P(lifetime) == IS_NULL) {
PHALCON_INIT_VAR(ttl);
PHALCON_CALL_METHOD(ttl, frontend, "getlifetime");
} else {
PHALCON_CPY_WRT(ttl, lifetime);
}
PHALCON_INIT_VAR(flags);
ZVAL_LONG(flags, 0);
/**
* We store without flags
*/
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_4(success, memcache, "set", last_key, prepared_content, flags, ttl);
if (!zend_is_true(success)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Failed storing data in memcached");
return;
}
PHALCON_OBS_VAR(options);
phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC);
PHALCON_OBS_VAR(special_key);
phalcon_array_fetch_string(&special_key, options, SL("statsKey"), PH_NOISY_CC);
/**
* Update the stats key
*/
PHALCON_INIT_VAR(keys);
PHALCON_CALL_METHOD_PARAMS_1(keys, memcache, "get", special_key);
if (Z_TYPE_P(keys) != IS_ARRAY) {
PHALCON_INIT_NVAR(keys);
array_init(keys);
}
if (!phalcon_array_isset(keys, last_key)) {
phalcon_array_update_zval(&keys, last_key, &ttl, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(memcache, "set", special_key, keys);
}
PHALCON_INIT_VAR(is_buffering);
PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering");
if (PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD_NORETURN(frontend, "stop");
}
if (PHALCON_IS_TRUE(is_buffering)) {
zend_print_zval(cached_content, 0);
}
phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns){
zval *table, *schema = NULL, *columns, *dialect, *sql = NULL, *fetch_num;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *char_size = NULL, *numeric_size = NULL, *numeric_scale = NULL, *column_type = NULL;
zval *attribute = NULL, *column_name = NULL, *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &schema);
if (!schema || !zend_is_true(schema)) {
schema = phalcon_fetch_nproperty_this(this_ptr, SL("_schema"), PH_NOISY TSRMLS_CC);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_OBS_VAR(dialect);
phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&sql, dialect, "describecolumns", table, schema);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, PDO_FETCH_NUM);
PHALCON_CALL_METHOD(&describe, this_ptr, "fetchall", sql, fetch_num);
/**
* 0:name, 1:type, 2:size, 3:numeric size, 4:numeric scale, 5: null, 6: key, 7: extra, 8: position, 9: element type
*/
PHALCON_INIT_VAR(old_column);
phalcon_is_iterable(describe, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(field);
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 1);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_OBS_NVAR(char_size);
phalcon_array_fetch_long(&char_size, field, 2, PH_NOISY);
if (Z_TYPE_P(char_size) != IS_NULL) {
convert_to_long(char_size);
}
PHALCON_OBS_NVAR(numeric_size);
phalcon_array_fetch_long(&numeric_size, field, 3, PH_NOISY);
if (phalcon_is_numeric(numeric_size)) {
convert_to_long(numeric_size);
}
PHALCON_OBS_NVAR(numeric_scale);
phalcon_array_fetch_long(&numeric_scale, field, 4, PH_NOISY);
if (phalcon_is_numeric(numeric_scale)) {
convert_to_long(numeric_scale);
}
PHALCON_OBS_NVAR(column_type);
phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY);
/**
* Check the column type to get the correct Phalcon type
*/
while (1) {
/**
* Tinyint(1) is boolean
*/
if (phalcon_memnstr_str(column_type, SL("smallint(1)"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY);
break;
}
/**
* Smallint/Bigint/Integers/Int are int
*/
if (phalcon_memnstr_str(column_type, SL("int"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_INTEGER, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_COPY);
break;
}
/**
* Varchar
*/
if (phalcon_memnstr_str(column_type, SL("varying"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Special type for datetime
*/
if (phalcon_memnstr_str(column_type, SL("date"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATE, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
break;
}
/**
* Numeric
*/
if (phalcon_memnstr_str(column_type, SL("numeric"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DECIMAL, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
if (phalcon_is_numeric(numeric_size)) {
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), Z_LVAL_P(numeric_size) * 8, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("size"), 30, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), 80, PH_COPY);
}
if (phalcon_is_numeric(numeric_scale)) {
phalcon_array_update_string(&definition, SL("scale"), numeric_scale, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("scale"), 6, PH_COPY);
}
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
break;
}
/**
* Chars are chars
*/
if (phalcon_memnstr_str(column_type, SL("char"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Date
*/
if (phalcon_memnstr_str(column_type, SL("timestamp"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATETIME, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
break;
}
/**
* Text are varchars
*/
if (phalcon_memnstr_str(column_type, SL("text"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Float/Smallfloats/Decimals are float
*/
if (phalcon_memnstr_str(column_type, SL("float"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_FLOAT, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
break;
}
/**
* Boolean
*/
if (phalcon_memnstr_str(column_type, SL("bool"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY);
break;
}
/**
* UUID
*/
if (phalcon_memnstr_str(column_type, SL("uuid"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_COPY);
break;
}
/**
* JSON
*/
if (phalcon_memnstr_str(column_type, SL("json"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_JSON, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* ARRAY
*/
if (phalcon_memnstr_str(column_type, SL("ARRAY"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_ARRAY, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* By default is string
*/
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_OTHER, PH_COPY);
break;
}
if (phalcon_memnstr_str(column_type, SL("unsigned"))) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_COPY);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_COPY);
} else {
phalcon_array_update_string(&definition, SL("after"), old_column, PH_COPY);
}
/**
* Check if the field is primary key
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "PRI")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_COPY);
}
/**
* Check if the column allows null values
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "NO")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_COPY);
}
/**
* Check if the column is auto increment
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 7, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "auto_increment")) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_COPY);
} else if (!PHALCON_IS_EMPTY(attribute)) {
phalcon_array_update_string(&definition, SL("default"), attribute, PH_COPY);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY);
/**
* Create a Phalcon\Db\Column to abstract the column
*/
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD(NULL, column, "__construct", column_name, definition);
phalcon_array_append(&columns, column, PH_COPY);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(columns);
}
/**
* Writes meta-data for certain model using a MODEL_* constant
*
*<code>
* print_r($metaData->writeColumnMapIndex(new Robots(), MetaData::MODELS_REVERSE_COLUMN_MAP, array('leName' => 'name')));
*</code>
*
* @param Phalcon\Mvc\ModelInterface $model
* @param int $index
* @param mixed $data
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, writeMetaDataIndex){
zval *model, *index, *data, *replace, *table = NULL, *schema = NULL, *class_name;
zval *key, *meta_data = NULL, *arr, *value;
HashTable *ah2;
HashPosition hp2;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 4, 0, &model, &index, &data, &replace);
PHALCON_VERIFY_INTERFACE_EX(model, phalcon_mvc_modelinterface_ce, phalcon_mvc_model_exception_ce, 1);
if (Z_TYPE_P(index) != IS_LONG) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Index must be a valid integer constant");
return;
}
if (Z_TYPE_P(data) != IS_ARRAY && Z_TYPE_P(data) != IS_STRING && Z_TYPE_P(data) != IS_BOOL) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Invalid data for index");
return;
}
PHALCON_CALL_METHOD(&table, model, "getsource");
PHALCON_CALL_METHOD(&schema, model, "getschema");
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 1 TSRMLS_CC);
/**
* Unique key for meta-data is created using class-name-schema-table
*/
PHALCON_INIT_VAR(key);
PHALCON_CONCAT_VSVV(key, class_name, "-", schema, table);
PHALCON_OBS_VAR(meta_data);
phalcon_read_property_this(&meta_data, this_ptr, SL("_metaData"), PH_NOISY TSRMLS_CC);
if (!phalcon_array_isset(meta_data, key)) {
PHALCON_CALL_METHOD(NULL, this_ptr, "_initialize", model, key, table, schema);
PHALCON_OBS_NVAR(meta_data);
phalcon_read_property_this(&meta_data, this_ptr, SL("_metaData"), PH_NOISY TSRMLS_CC);
} else if (!zend_is_true(replace)) {
PHALCON_OBS_VAR(arr);
phalcon_array_fetch(&arr, meta_data, key, PH_NOISY);
PHALCON_OBS_VAR(value);
phalcon_array_fetch(&value, arr, index, PH_NOISY);
PHALCON_SEPARATE_PARAM(data);
phalcon_is_iterable(value, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
zval key2 = phalcon_get_current_key_w(ah2, &hp2);
if (!phalcon_array_isset(data, &key2)) {
phalcon_array_update_zval(&data, &key2, *hd, PH_COPY | PH_SEPARATE);
}
zend_hash_move_forward_ex(ah2, &hp2);
}
}
phalcon_array_update_multi_2(&meta_data, key, index, data, 0);
phalcon_update_property_this(this_ptr, SL("_metaData"), meta_data TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Mvc\Model\Query\Builder constructor
*
* @param array $params
*/
PHP_METHOD(Phalcon_Mvc_Model_Query_Builder, __construct){
zval *params = NULL, *conditions = NULL, *columns, *group_clause;
zval *having_clause, *order_clause, *limit_clause;
zval *for_update, *shared_lock;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", ¶ms) == FAILURE) {
RETURN_MM_NULL();
}
if (!params) {
PHALCON_INIT_VAR(params);
}
if (Z_TYPE_P(params) == IS_ARRAY) {
/**
* Process conditions
*/
if (phalcon_array_isset_long(params, 0)) {
PHALCON_OBS_VAR(conditions);
phalcon_array_fetch_long(&conditions, params, 0, PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_conditions"), conditions TSRMLS_CC);
} else {
if (phalcon_array_isset_string(params, SS("conditions"))) {
PHALCON_OBS_NVAR(conditions);
phalcon_array_fetch_string(&conditions, params, SL("conditions"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_conditions"), conditions TSRMLS_CC);
}
}
/**
* Assign COLUMNS clause
*/
if (phalcon_array_isset_string(params, SS("columns"))) {
PHALCON_OBS_VAR(columns);
phalcon_array_fetch_string(&columns, params, SL("columns"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_columns"), columns TSRMLS_CC);
}
/**
* Assign GROUP clause
*/
if (phalcon_array_isset_string(params, SS("group"))) {
PHALCON_OBS_VAR(group_clause);
phalcon_array_fetch_string(&group_clause, params, SL("group"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_group"), group_clause TSRMLS_CC);
}
/**
* Assign HAVING clause
*/
if (phalcon_array_isset_string(params, SS("having"))) {
PHALCON_OBS_VAR(having_clause);
phalcon_array_fetch_string(&having_clause, params, SL("having"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_group"), having_clause TSRMLS_CC);
}
/**
* Assign ORDER clause
*/
if (phalcon_array_isset_string(params, SS("order"))) {
PHALCON_OBS_VAR(order_clause);
phalcon_array_fetch_string(&order_clause, params, SL("order"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_order"), order_clause TSRMLS_CC);
}
/**
* Assign LIMIT clause
*/
if (phalcon_array_isset_string(params, SS("limit"))) {
PHALCON_OBS_VAR(limit_clause);
phalcon_array_fetch_string(&limit_clause, params, SL("limit"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_limit"), limit_clause TSRMLS_CC);
}
/**
* Assign FOR UPDATE clause
*/
if (phalcon_array_isset_string(params, SS("for_update"))) {
PHALCON_OBS_VAR(for_update);
phalcon_array_fetch_string(&for_update, params, SL("for_update"), PH_NOISY_CC);
if (zend_is_true(for_update)) {
phalcon_update_property_bool(this_ptr, SL("_forUpdate"), 1 TSRMLS_CC);
}
}
/**
* Assign SHARED LOCK clause
*/
if (phalcon_array_isset_string(params, SS("shared_lock"))) {
PHALCON_OBS_VAR(shared_lock);
phalcon_array_fetch_string(&shared_lock, params, SL("shared_lock"), PH_NOISY_CC);
if (zend_is_true(shared_lock)) {
phalcon_update_property_bool(this_ptr, SL("_sharedLock"), 1 TSRMLS_CC);
}
}
}
PHALCON_MM_RESTORE();
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){
zval *type = NULL, *result, *row = NULL, *rows, *hydrate_mode, *underscore;
zval *empty_str, *active_row = NULL, *columns_types;
zval *dirty_state, *column = NULL, *alias = NULL, *source = NULL, *attributes = NULL;
zval *column_map = NULL, *row_model = NULL, *attribute = NULL, *column_alias = NULL;
zval *column_value = NULL, *keep_snapshots = NULL, *instance = NULL;
zval *value = NULL, *sql_alias = NULL, *n_alias = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(type);
phalcon_read_property_this(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
/**
* The result is bigger than 32 rows so it's retrieved one by one
*/
PHALCON_OBS_VAR(result);
phalcon_read_property_this(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_INIT_VAR(row);
phalcon_call_method_p1(row, result, "fetch", result);
} else {
PHALCON_INIT_NVAR(row);
ZVAL_BOOL(row, 0);
}
} else {
/**
* The full rows are dumped in this_ptr->rows
*/
PHALCON_OBS_VAR(rows);
phalcon_read_property_this(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
if (Z_TYPE_P(rows) == IS_ARRAY) {
PHALCON_INIT_NVAR(row);
phalcon_array_get_current(row, rows);
if (Z_TYPE_P(row) == IS_OBJECT) {
phalcon_array_next(rows);
}
} else {
PHALCON_INIT_NVAR(row);
ZVAL_BOOL(row, 0);
}
}
/**
* Valid records are arrays
*/
if (Z_TYPE_P(row) == IS_ARRAY || Z_TYPE_P(row) == IS_OBJECT) {
/**
* The result type=1 so we need to build every row
*/
if (zend_is_true(type)) {
/**
* Get current hydration mode
*/
PHALCON_OBS_VAR(hydrate_mode);
phalcon_read_property_this(&hydrate_mode, this_ptr, SL("_hydrateMode"), PH_NOISY_CC);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_STRING(empty_str, "", 1);
/**
* Each row in a complex result is a Phalcon\Mvc\Model\Row instance
*/
switch (phalcon_get_intval(hydrate_mode)) {
case 0:
PHALCON_INIT_VAR(active_row);
object_init_ex(active_row, phalcon_mvc_model_row_ce);
break;
case 1:
PHALCON_INIT_NVAR(active_row);
array_init(active_row);
break;
case 2:
PHALCON_INIT_NVAR(active_row);
object_init(active_row);
break;
}
/**
* Create every record according to the column types
*/
PHALCON_OBS_VAR(columns_types);
phalcon_read_property_this(&columns_types, this_ptr, SL("_columnTypes"), PH_NOISY_CC);
/**
* Set records as dirty state PERSISTENT by default
*/
PHALCON_INIT_VAR(dirty_state);
ZVAL_LONG(dirty_state, 0);
phalcon_is_iterable(columns_types, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(alias, ah0, hp0);
PHALCON_GET_HVALUE(column);
PHALCON_OBS_NVAR(type);
phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY);
if (PHALCON_IS_STRING(type, "object")) {
/**
* Object columns are assigned column by column
*/
PHALCON_OBS_NVAR(source);
phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY);
PHALCON_OBS_NVAR(attributes);
phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY);
PHALCON_OBS_NVAR(column_map);
phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY);
/**
* Assign the values from the _source_attribute notation to its real column name
*/
PHALCON_INIT_NVAR(row_model);
array_init(row_model);
phalcon_is_iterable(attributes, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(attribute);
/**
* Columns are supposed to be in the form _table_field
*/
PHALCON_INIT_NVAR(column_alias);
PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute);
PHALCON_OBS_NVAR(column_value);
phalcon_array_fetch(&column_value, row, column_alias, PH_NOISY);
phalcon_array_update_zval(&row_model, attribute, &column_value, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Generate the column value according to the hydration type
*/
switch (phalcon_get_intval(hydrate_mode)) {
case 0:
/**
* Check if the resultset must keep snapshots
*/
if (phalcon_array_isset_string(column, SS("keepSnapshots"))) {
PHALCON_OBS_NVAR(keep_snapshots);
phalcon_array_fetch_string(&keep_snapshots, column, SL("keepSnapshots"), PH_NOISY);
} else {
PHALCON_INIT_NVAR(keep_snapshots);
ZVAL_BOOL(keep_snapshots, 0);
}
/**
* Get the base instance
*/
PHALCON_OBS_NVAR(instance);
phalcon_array_fetch_string(&instance, column, SL("instance"), PH_NOISY);
/**
* Assign the values to the attributes using a column map
*/
PHALCON_INIT_NVAR(value);
PHALCON_CALL_STATIC_PARAMS_5(value, "phalcon\\mvc\\model", "cloneresultmap", instance, row_model, column_map, dirty_state, keep_snapshots);
break;
default:
/**
* Other kinds of hydrations
*/
PHALCON_INIT_NVAR(value);
PHALCON_CALL_STATIC_PARAMS_3(value, "phalcon\\mvc\\model", "cloneresultmaphydrate", row_model, column_map, hydrate_mode);
break;
}
/**
* The complete object is assigned to an attribute with the name of the alias or
* the model name
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY);
} else {
/**
* Scalar columns are simply assigned to the result object
*/
if (phalcon_array_isset_string(column, SS("sqlAlias"))) {
PHALCON_OBS_NVAR(sql_alias);
phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY);
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, row, sql_alias, PH_NOISY);
} else {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, row, alias, PH_NOISY);
}
/**
* If a 'balias' is defined is not an unnamed scalar
*/
if (phalcon_array_isset_string(column, SS("balias"))) {
PHALCON_CPY_WRT(attribute, alias);
} else {
PHALCON_INIT_NVAR(n_alias);
phalcon_fast_str_replace(n_alias, underscore, empty_str, alias);
PHALCON_CPY_WRT(attribute, n_alias);
}
}
/**
* Assign the instance according to the hydration type
*/
switch (phalcon_get_intval(hydrate_mode)) {
case 1:
phalcon_array_update_zval(&active_row, attribute, &value, PH_COPY | PH_SEPARATE);
break;
default:
phalcon_update_property_zval_zval(active_row, attribute, value TSRMLS_CC);
break;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Store the generated row in this_ptr->activeRow to be retrieved by 'current'
*/
phalcon_update_property_this(this_ptr, SL("_activeRow"), active_row TSRMLS_CC);
} else {
/**
* The row is already built so we just assign it to the activeRow
*/
phalcon_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC);
}
RETURN_MM_TRUE;
}
/**
* There are no results to retrieve so we update this_ptr->activeRow as false
*/
phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC);
RETURN_MM_FALSE;
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Uniqueness, validate){
zval *record, *option = NULL, *field, *dependency_injector;
zval *service, *meta_data, *bind_types, *bind_data_types;
zval *column_map = NULL, *conditions, *bind_params;
zval *number = NULL, *compose_field = NULL, *column_field = NULL;
zval *exception_message = NULL, *value = NULL, *compose_condition = NULL;
zval *bind_type = NULL, *condition = NULL, *operation_made;
zval *primary_fields, *primary_field = NULL, *attribute_field = NULL;
zval *join_conditions, *params, *class_name;
zval *message = NULL, *join_fields, *type;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &record);
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field);
phalcon_call_method_p1(field, this_ptr, "getoption", option);
PHALCON_INIT_VAR(dependency_injector);
phalcon_call_method(dependency_injector, record, "getdi");
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "modelsMetadata", 1);
PHALCON_INIT_VAR(meta_data);
phalcon_call_method_p1(meta_data, dependency_injector, "getshared", service);
/**
* PostgreSQL check if the compared constant has the same type as the column, so we
* make cast to the data passed to match those column types
*/
PHALCON_INIT_VAR(bind_types);
array_init(bind_types);
PHALCON_INIT_VAR(bind_data_types);
phalcon_call_method_p1(bind_data_types, meta_data, "getbindtypes", record);
if (PHALCON_GLOBAL(orm).column_renaming) {
PHALCON_INIT_VAR(column_map);
phalcon_call_method_p1(column_map, meta_data, "getreversecolumnmap", record);
} else {
PHALCON_INIT_NVAR(column_map);
}
PHALCON_INIT_VAR(conditions);
array_init(conditions);
PHALCON_INIT_VAR(bind_params);
array_init(bind_params);
PHALCON_INIT_VAR(number);
ZVAL_LONG(number, 0);
if (Z_TYPE_P(field) == IS_ARRAY) {
/**
* The field can be an array of values
*/
phalcon_is_iterable(field, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(compose_field);
/**
* The reversed column map is used in the case to get real column name
*/
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, compose_field)) {
PHALCON_OBS_NVAR(column_field);
phalcon_array_fetch(&column_field, column_map, compose_field, PH_NOISY);
} else {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", compose_field, "\" isn't part of the column map");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
PHALCON_CPY_WRT(column_field, compose_field);
}
/**
* Some database systems require that we pass the values using bind casting
*/
if (!phalcon_array_isset(bind_data_types, column_field)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", column_field, "\" isn't part of the table columns");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* The attribute could be "protected" so we read using "readattribute"
*/
PHALCON_INIT_NVAR(value);
phalcon_call_method_p1(value, record, "readattribute", compose_field);
PHALCON_INIT_NVAR(compose_condition);
PHALCON_CONCAT_SVSV(compose_condition, "[", compose_field, "] = ?", number);
phalcon_array_append(&conditions, compose_condition, PH_SEPARATE);
phalcon_array_append(&bind_params, value, PH_SEPARATE);
PHALCON_OBS_NVAR(bind_type);
phalcon_array_fetch(&bind_type, bind_data_types, column_field, PH_NOISY);
phalcon_array_append(&bind_types, bind_type, PH_SEPARATE);
phalcon_increment(number);
zend_hash_move_forward_ex(ah0, &hp0);
}
} else {
/**
* The reversed column map is used in the case to get real column name
*/
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, field)) {
PHALCON_OBS_NVAR(column_field);
phalcon_array_fetch(&column_field, column_map, field, PH_NOISY);
} else {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", field, "\" isn't part of the column map");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
PHALCON_CPY_WRT(column_field, field);
}
/**
* Some database systems require that we pass the values using bind casting
*/
if (!phalcon_array_isset(bind_data_types, column_field)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", column_field, "\" isn't part of the table columns");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* We're checking the uniqueness with only one field
*/
PHALCON_INIT_NVAR(value);
phalcon_call_method_p1(value, record, "readattribute", field);
PHALCON_INIT_VAR(condition);
PHALCON_CONCAT_SVS(condition, "[", field, "] = ?0");
phalcon_array_append(&conditions, condition, PH_SEPARATE);
phalcon_array_append(&bind_params, value, PH_SEPARATE);
PHALCON_OBS_NVAR(bind_type);
phalcon_array_fetch(&bind_type, bind_data_types, column_field, PH_NOISY);
phalcon_array_append(&bind_types, bind_type, PH_SEPARATE);
phalcon_increment(number);
}
/**
* If the operation is update, there must be values in the object
*/
PHALCON_INIT_VAR(operation_made);
phalcon_call_method(operation_made, record, "getoperationmade");
if (PHALCON_IS_LONG(operation_made, 2)) {
/**
* We build a query with the primary key attributes
*/
if (PHALCON_GLOBAL(orm).column_renaming) {
PHALCON_INIT_NVAR(column_map);
phalcon_call_method_p1(column_map, meta_data, "getcolumnmap", record);
} else {
PHALCON_INIT_NVAR(column_map);
}
PHALCON_INIT_VAR(primary_fields);
phalcon_call_method_p1(primary_fields, meta_data, "getprimarykeyattributes", record);
phalcon_is_iterable(primary_fields, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(primary_field);
if (!phalcon_array_isset(bind_data_types, primary_field)) {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", primary_field, "\" isn't part of the table columns");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
/**
* Rename the column if there is a column map
*/
if (Z_TYPE_P(column_map) == IS_ARRAY) {
if (phalcon_array_isset(column_map, primary_field)) {
PHALCON_OBS_NVAR(attribute_field);
phalcon_array_fetch(&attribute_field, column_map, primary_field, PH_NOISY);
} else {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Column '", primary_field, "\" isn't part of the column map");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
PHALCON_CPY_WRT(attribute_field, primary_field);
}
/**
* Create a condition based on the renamed primary key
*/
PHALCON_INIT_NVAR(value);
phalcon_call_method_p1(value, record, "readattribute", primary_field);
PHALCON_INIT_NVAR(condition);
PHALCON_CONCAT_SVSV(condition, "[", attribute_field, "] <> ?", number);
phalcon_array_append(&conditions, condition, PH_SEPARATE);
phalcon_array_append(&bind_params, value, PH_SEPARATE);
PHALCON_OBS_NVAR(bind_type);
phalcon_array_fetch(&bind_type, bind_data_types, primary_field, PH_NOISY);
phalcon_array_append(&bind_types, bind_type, PH_SEPARATE);
phalcon_increment(number);
zend_hash_move_forward_ex(ah1, &hp1);
}
}
PHALCON_INIT_VAR(join_conditions);
phalcon_fast_join_str(join_conditions, SL(" AND "), conditions TSRMLS_CC);
/**
* We don't trust the user, so we pass the parameters as bound parameters
*/
PHALCON_INIT_VAR(params);
array_init(params);
phalcon_array_update_string(¶ms, SL("di"), &dependency_injector, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(¶ms, SL("conditions"), &join_conditions, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(¶ms, SL("bind"), &bind_params, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(¶ms, SL("bindTypes"), &bind_types, PH_COPY | PH_SEPARATE);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, record, 0 TSRMLS_CC);
/**
* Check using a standard count
*/
phalcon_call_zval_str_static_p1(number, class_name, "count", params);
if (!PHALCON_IS_LONG(number, 0)) {
/**
* Check if the developer has defined a custom message
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "message", 1);
PHALCON_INIT_VAR(message);
phalcon_call_method_p1(message, this_ptr, "getoption", option);
if (!zend_is_true(message)) {
if (Z_TYPE_P(field) == IS_ARRAY) {
PHALCON_INIT_VAR(join_fields);
phalcon_fast_join_str(join_fields, SL(", "), field TSRMLS_CC);
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "Value of fields: '", join_fields, "' are already present in another record");
} else {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "Value of field: '", field, "' is already present in another record");
}
}
/**
* Append the message to the validator
*/
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "Unique", 1);
phalcon_call_method_p3_noret(this_ptr, "appendmessage", message, field, type);
RETURN_MM_FALSE;
}
RETURN_MM_TRUE;
}
/**
* Handles routing information received from command-line arguments
*
* @param array $arguments
*/
PHP_METHOD(Phalcon_CLI_Router, handle){
zval *arguments = NULL, *namespace_name, *module_name = NULL, *task_name = NULL, *action_name = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &arguments);
if (!arguments) {
PHALCON_INIT_VAR(arguments);
array_init(arguments);
} else {
PHALCON_SEPARATE_PARAM(arguments);
}
if (Z_TYPE_P(arguments) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cli_router_exception_ce, "Arguments must be an Array");
return;
}
PHALCON_INIT_VAR(module_name);
PHALCON_INIT_VAR(namespace_name);
PHALCON_INIT_VAR(task_name);
PHALCON_INIT_VAR(action_name);
/**
* Check for a module
*/
if (phalcon_array_isset_string(arguments, SS("module"))) {
PHALCON_OBS_NVAR(module_name);
phalcon_array_fetch_string(&module_name, arguments, SL("module"), PH_NOISY);
phalcon_array_unset_string(&arguments, SS("module"), PH_COPY);
}
/**
* Check for a namespace
*/
if (phalcon_array_isset_string(arguments, SS("namespace"))) {
PHALCON_OBS_NVAR(namespace_name);
phalcon_array_fetch_string(&namespace_name, arguments, SL("namespace"), PH_NOISY);
phalcon_array_unset_string(&arguments, SS("namespace"), PH_COPY);
}
/**
* Check for a task
*/
if (phalcon_array_isset_string(arguments, SS("task"))) {
PHALCON_OBS_NVAR(task_name);
phalcon_array_fetch_string(&task_name, arguments, SL("task"), PH_NOISY);
phalcon_array_unset_string(&arguments, SS("task"), PH_COPY);
}
/**
* Check for an action
*/
if (phalcon_array_isset_string(arguments, SS("action"))) {
PHALCON_OBS_NVAR(action_name);
phalcon_array_fetch_string(&action_name, arguments, SL("action"), PH_NOISY);
phalcon_array_unset_string(&arguments, SS("action"), PH_COPY);
}
phalcon_update_property_this(this_ptr, SL("_module"), module_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_namespace"), namespace_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_task"), task_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_action"), action_name TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_params"), arguments TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Transform an intermediate representation for a schema/table into a database system valid expression
*
* @param array $table
* @param string $escapeChar
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, getSqlTable){
zval *table, *escape_char = NULL, *table_name, *sql_table = NULL;
zval *schema_name, *sql_schema = NULL, *alias_name;
zval *sql_table_alias = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &escape_char);
if (!escape_char) {
PHALCON_INIT_VAR(escape_char);
} else {
PHALCON_SEPARATE_PARAM(escape_char);
}
if (Z_TYPE_P(escape_char) == IS_NULL) {
PHALCON_OBS_NVAR(escape_char);
phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC);
}
if (Z_TYPE_P(table) == IS_ARRAY) {
/**
* The index '0' is the table name
*/
PHALCON_OBS_VAR(table_name);
phalcon_array_fetch_long(&table_name, table, 0, PH_NOISY);
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_VAR(sql_table);
PHALCON_CONCAT_VVV(sql_table, escape_char, table_name, escape_char);
} else {
PHALCON_CPY_WRT(sql_table, table_name);
}
/**
* The index '1' is the schema name
*/
PHALCON_OBS_VAR(schema_name);
phalcon_array_fetch_long(&schema_name, table, 1, PH_NOISY);
if (Z_TYPE_P(schema_name) != IS_NULL) {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_VAR(sql_schema);
PHALCON_CONCAT_VVVSV(sql_schema, escape_char, schema_name, escape_char, ".", sql_table);
} else {
PHALCON_INIT_NVAR(sql_schema);
PHALCON_CONCAT_VSV(sql_schema, schema_name, ".", sql_table);
}
} else {
PHALCON_CPY_WRT(sql_schema, sql_table);
}
/**
* The index '2' is the table alias
*/
if (phalcon_array_isset_long(table, 2)) {
PHALCON_OBS_VAR(alias_name);
phalcon_array_fetch_long(&alias_name, table, 2, PH_NOISY);
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_VAR(sql_table_alias);
PHALCON_CONCAT_VSVVV(sql_table_alias, sql_schema, " AS ", escape_char, alias_name, escape_char);
} else {
PHALCON_INIT_NVAR(sql_table_alias);
PHALCON_CONCAT_VSV(sql_table_alias, sql_schema, " AS ", alias_name);
}
} else {
PHALCON_CPY_WRT(sql_table_alias, sql_schema);
}
RETURN_CCTOR(sql_table_alias);
}
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_CONCAT_VVV(return_value, escape_char, table, escape_char);
RETURN_MM();
}
RETURN_CCTOR(table);
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection
*
*<code>
* //Make a connection
* $connection = new Phalcon\Db\Adapter\Pdo\Mysql(array(
* 'host' => '192.168.0.11',
* 'username' => 'sigma',
* 'password' => 'secret',
* 'dbname' => 'blog',
* ));
*
* //Reconnect
* $connection->connect();
* </code>
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, connect){
zval *descriptor = NULL, *username = NULL, *password = NULL, *dsn_parts;
zval *value = NULL, *key = NULL, *dsn_attribute = NULL, *dsn_attributes = NULL;
zval *pdo_type, *dsn, *options = NULL, *persistent, *pdo;
zend_class_entry *ce;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &descriptor) == FAILURE) {
RETURN_MM_NULL();
}
if (!descriptor) {
PHALCON_INIT_VAR(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (Z_TYPE_P(descriptor) == IS_NULL) {
PHALCON_OBS_NVAR(descriptor);
phalcon_read_property(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC);
}
/**
* Check for a username or use null as default
*/
if (phalcon_array_isset_string(descriptor, SS("username"))) {
PHALCON_OBS_VAR(username);
phalcon_array_fetch_string(&username, descriptor, SL("username"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("username"), PH_COPY);
} else {
PHALCON_INIT_NVAR(username);
}
/**
* Check for a password or use null as default
*/
if (phalcon_array_isset_string(descriptor, SS("password"))) {
PHALCON_OBS_VAR(password);
phalcon_array_fetch_string(&password, descriptor, SL("password"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("password"), PH_COPY);
} else {
PHALCON_INIT_NVAR(password);
}
/**
* Check if the developer has defined custom options or create one from scratch
*/
if (phalcon_array_isset_string(descriptor, SS("options"))) {
PHALCON_OBS_VAR(options);
phalcon_array_fetch_string(&options, descriptor, SL("options"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("options"), PH_COPY);
} else {
PHALCON_INIT_NVAR(options);
array_init(options);
}
/**
* Remove the dialectClass from the descriptor if any
*/
if (phalcon_array_isset_string(descriptor, SS("dialectClass"))) {
phalcon_array_unset_string(&descriptor, SS("dialectClass"), PH_COPY);
}
/**
* Check if the user has defined a custom dsn
*/
if (!phalcon_array_isset_string(descriptor, SS("dsn"))) {
PHALCON_INIT_VAR(dsn_parts);
array_init(dsn_parts);
phalcon_is_iterable(descriptor, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(key, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_INIT_NVAR(dsn_attribute);
PHALCON_CONCAT_VSV(dsn_attribute, key, "=", value);
phalcon_array_append(&dsn_parts, dsn_attribute, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(dsn_attributes);
phalcon_fast_join_str(dsn_attributes, SL(";"), dsn_parts TSRMLS_CC);
} else {
PHALCON_OBS_NVAR(dsn_attributes);
phalcon_array_fetch_string(&dsn_attributes, descriptor, SL("dsn"), PH_NOISY);
}
PHALCON_OBS_VAR(pdo_type);
phalcon_read_property(&pdo_type, this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(dsn);
PHALCON_CONCAT_VSV(dsn, pdo_type, ":", dsn_attributes);
/**
* Default options
*/
phalcon_array_update_long_long(&options, PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION, PH_COPY);
/*
phalcon_array_update_long_long(&options, PDO_ATTR_CASE, PDO_CASE_LOWER, PH_COPY);
phalcon_array_update_long_long(&options, PDO_ATTR_CURSOR, PDO_CURSOR_SCROLL, PH_COPY);
*/
/**
* Check if the connection must be persistent
*/
if (phalcon_array_isset_string(descriptor, SS("persistent"))) {
PHALCON_OBS_VAR(persistent);
phalcon_array_fetch_string(&persistent, descriptor, SL("persistent"), PH_NOISY);
if (zend_is_true(persistent)) {
phalcon_array_update_long_bool(&options, PDO_ATTR_PERSISTENT, 1, PH_COPY);
}
}
/**
* Create the connection using PDO
*/
ce = zend_fetch_class(SL("PDO"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(pdo);
object_init_ex(pdo, ce);
PHALCON_CALL_METHOD(NULL, pdo, "__construct", dsn, username, password, options);
phalcon_update_property_zval(this_ptr, SL("_pdo"), pdo TSRMLS_CC);
PHALCON_MM_RESTORE();
}
/**
* Loads registered template engines, if none is registered it will use Phalcon\Mvc\View\Engine\Php
*
* @return array
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _loadTemplateEngines){
zval *engines = NULL, *dependency_injector, *registered_engines;
zval *php_engine, *arguments, *engine_service = NULL;
zval *extension = NULL, *engine_object = NULL, *exception_message = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(engines);
phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
/**
* If the engines aren't initialized 'engines' is false
*/
if (PHALCON_IS_FALSE(engines)) {
PHALCON_OBS_VAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
PHALCON_INIT_NVAR(engines);
array_init(engines);
PHALCON_OBS_VAR(registered_engines);
phalcon_read_property_this(®istered_engines, this_ptr, SL("_registeredEngines"), PH_NOISY_CC);
if (Z_TYPE_P(registered_engines) != IS_ARRAY) {
/**
* We use Phalcon\Mvc\View\Engine\Php as default
*/
PHALCON_INIT_VAR(php_engine);
object_init_ex(php_engine, phalcon_mvc_view_engine_php_ce);
phalcon_call_method_p2_noret(php_engine, "__construct", this_ptr, dependency_injector);
/**
* Use .phtml as extension for the PHP engine
*/
phalcon_array_update_string(&engines, SL(".phtml"), &php_engine, PH_COPY | PH_SEPARATE);
} 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;
}
/**
* Arguments for instantiated engines
*/
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, 2);
phalcon_array_append(&arguments, this_ptr, PH_SEPARATE);
phalcon_array_append(&arguments, dependency_injector, PH_SEPARATE);
phalcon_is_iterable(registered_engines, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(extension, ah0, hp0);
PHALCON_GET_HVALUE(engine_service);
if (Z_TYPE_P(engine_service) == IS_OBJECT) {
/**
* Engine can be a closure
*/
if (phalcon_is_instance_of(engine_service, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_NVAR(engine_object);
PHALCON_CALL_USER_FUNC_ARRAY(engine_object, engine_service, arguments);
} else {
PHALCON_CPY_WRT(engine_object, engine_service);
}
} else {
/**
* Engine can be a string representing a service in the DI
*/
if (Z_TYPE_P(engine_service) == IS_STRING) {
PHALCON_INIT_NVAR(engine_object);
phalcon_call_method_p2(engine_object, dependency_injector, "getshared", engine_service, arguments);
} else {
PHALCON_INIT_NVAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid template engine registration for extension: ", extension);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
}
phalcon_array_update_zval(&engines, extension, &engine_object, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
}
phalcon_update_property_this(this_ptr, SL("_engines"), engines TSRMLS_CC);
} else {
PHALCON_OBS_NVAR(engines);
phalcon_read_property_this(&engines, this_ptr, SL("_engines"), PH_NOISY_CC);
}
RETURN_CCTOR(engines);
}
/**
* 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);
}
/**
* Reads annotations from the class dockblocks, its methods and/or properties
*
* @param string $className
* @return array
*/
PHP_METHOD(Phalcon_Annotations_Reader, parse){
zval *class_name, *annotations, *reflection;
zval *comment = NULL, *file = NULL, *line = NULL, *class_annotations;
zval *properties, *annotations_properties;
zval *property = NULL, *property_annotations = NULL, *name = NULL;
zval *methods, *annotations_methods, *method = NULL;
zval *method_annotations = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
zend_class_entry *ce0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &class_name);
if (unlikely(Z_TYPE_P(class_name) != IS_STRING)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "The class name must be an object");
return;
}
PHALCON_INIT_VAR(annotations);
array_init(annotations);
/**
* A ReflectionClass is used to obtain the class dockblock
*/
ce0 = zend_fetch_class(SL("ReflectionClass"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(reflection);
object_init_ex(reflection, ce0);
if (phalcon_has_constructor(reflection TSRMLS_CC)) {
phalcon_call_method_p1_noret(reflection, "__construct", class_name);
}
PHALCON_INIT_VAR(comment);
phalcon_call_method(comment, reflection, "getdoccomment");
if (Z_TYPE_P(comment) == IS_STRING) {
/**
* Get the file where the class was declared
*/
PHALCON_INIT_VAR(file);
phalcon_call_method(file, reflection, "getfilename");
/**
* Get the line where the class was declared
*/
PHALCON_INIT_VAR(line);
phalcon_call_method(line, reflection, "getstartline");
/**
* Read annotations from class
*/
PHALCON_INIT_VAR(class_annotations);
if (phannot_parse_annotations(class_annotations, comment, file, line TSRMLS_CC) == FAILURE) {
return;
}
/**
* Append the class annotations to the annotations var
*/
if (Z_TYPE_P(class_annotations) == IS_ARRAY) {
phalcon_array_update_string(&annotations, SL("class"), &class_annotations, PH_COPY | PH_SEPARATE);
}
}
/**
* Get the class properties
*/
PHALCON_INIT_VAR(properties);
phalcon_call_method(properties, reflection, "getproperties");
if (phalcon_fast_count_ev(properties TSRMLS_CC)) {
/**
* Line declaration for properties isn't available
*/
PHALCON_INIT_NVAR(line);
ZVAL_LONG(line, 1);
PHALCON_INIT_VAR(annotations_properties);
array_init(annotations_properties);
phalcon_is_iterable(properties, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(property);
/**
* Read comment from method
*/
PHALCON_INIT_NVAR(comment);
phalcon_call_method(comment, property, "getdoccomment");
if (Z_TYPE_P(comment) == IS_STRING) {
/**
* Get the file where the property was declared
*/
PHALCON_INIT_NVAR(file);
phalcon_call_method(file, reflection, "getfilename");
/**
* Read annotations from the docblock
*/
PHALCON_INIT_NVAR(property_annotations);
if (phannot_parse_annotations(property_annotations, comment, file, line TSRMLS_CC) == FAILURE) {
return;
}
if (Z_TYPE_P(property_annotations) == IS_ARRAY) {
PHALCON_OBS_NVAR(name);
phalcon_read_property(&name, property, SL("name"), PH_NOISY_CC);
phalcon_array_update_zval(&annotations_properties, name, &property_annotations, PH_COPY | PH_SEPARATE);
}
}
zend_hash_move_forward_ex(ah0, &hp0);
}
if (phalcon_fast_count_ev(annotations_properties TSRMLS_CC)) {
phalcon_array_update_string(&annotations, SL("properties"), &annotations_properties, PH_COPY | PH_SEPARATE);
}
}
/**
* Get the class methods
*/
PHALCON_INIT_VAR(methods);
phalcon_call_method(methods, reflection, "getmethods");
if (phalcon_fast_count_ev(methods TSRMLS_CC)) {
PHALCON_INIT_VAR(annotations_methods);
array_init(annotations_methods);
phalcon_is_iterable(methods, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(method);
/**
* Read comment from method
*/
PHALCON_INIT_NVAR(comment);
phalcon_call_method(comment, method, "getdoccomment");
if (Z_TYPE_P(comment) == IS_STRING) {
/**
* Get the file where the method was declared
*/
PHALCON_INIT_NVAR(file);
phalcon_call_method(file, method, "getfilename");
/**
* Get the line where the method was declared
*/
PHALCON_INIT_NVAR(line);
phalcon_call_method(line, method, "getstartline");
/**
* Read annotations from class
*/
PHALCON_INIT_NVAR(method_annotations);
if (phannot_parse_annotations(method_annotations, comment, file, line TSRMLS_CC) == FAILURE) {
return;
}
if (Z_TYPE_P(method_annotations) == IS_ARRAY) {
PHALCON_OBS_NVAR(name);
phalcon_read_property(&name, method, SL("name"), PH_NOISY_CC);
phalcon_array_update_zval(&annotations_methods, name, &method_annotations, PH_COPY | PH_SEPARATE);
}
}
zend_hash_move_forward_ex(ah1, &hp1);
}
if (phalcon_fast_count_ev(annotations_methods TSRMLS_CC)) {
phalcon_array_update_string(&annotations, SL("methods"), &annotations_methods, PH_COPY | PH_SEPARATE);
}
}
RETURN_CTOR(annotations);
}
/**
* Converts bound parameters such as :name: or ?1 into PDO bind params ?
*
*<code>
* print_r($connection->convertBoundParams('SELECT * FROM robots WHERE name = :name:', array('Bender')));
*</code>
*
* @param string $sql
* @param array $params
* @return array
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, convertBoundParams){
zval *sql, *params, *query_params, *placeholders;
zval *matches, *set_order, *bind_pattern, *status = NULL;
zval *place_match = NULL, *numeric_place = NULL, *value = NULL, *str_place = NULL;
zval *question, *bound_sql = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &sql, ¶ms);
PHALCON_INIT_VAR(query_params);
array_init(query_params);
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(set_order);
ZVAL_LONG(set_order, 2);
PHALCON_INIT_VAR(bind_pattern);
ZVAL_STRING(bind_pattern, "/\\?([0-9]+)|:([a-zA-Z0-9_]+):/", 1);
Z_SET_ISREF_P(matches);
PHALCON_CALL_FUNCTION(&status, "preg_match_all", bind_pattern, sql, matches, set_order);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(status)) {
phalcon_is_iterable(matches, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(place_match);
PHALCON_OBS_NVAR(numeric_place);
phalcon_array_fetch_long(&numeric_place, place_match, 1, PH_NOISY);
if (phalcon_array_isset(params, numeric_place)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, params, numeric_place, PH_NOISY);
} else {
if (phalcon_array_isset_long(place_match, 2)) {
PHALCON_OBS_NVAR(str_place);
phalcon_array_fetch_long(&str_place, place_match, 2, PH_NOISY);
if (phalcon_array_isset(params, str_place)) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, params, str_place, PH_NOISY);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Matched parameter wasn't found in parameters list");
return;
}
}
phalcon_array_append(&placeholders, value, PH_COPY);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(question);
ZVAL_STRING(question, "?", 1);
PHALCON_CALL_FUNCTION(&bound_sql, "preg_replace", bind_pattern, question, sql);
} else {
PHALCON_CPY_WRT(bound_sql, sql);
}
/**
* Returns an array with the processed SQL and parameters
*/
array_init_size(return_value, 2);
phalcon_array_update_string(&return_value, SL("sql"), bound_sql, PH_COPY);
phalcon_array_update_string(&return_value, SL("params"), placeholders, PH_COPY);
RETURN_MM();
}
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns){
zval *table, *schema = NULL, *columns, *dialect, *sql, *fetch_num;
zval *describe, *old_column = NULL, *field = NULL, *definition = NULL;
zval *char_size = NULL, *numeric_size = NULL, *numeric_scale = NULL, *column_type = NULL;
zval *attribute = NULL, *column_name = NULL, *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &schema);
if (!schema) {
PHALCON_INIT_VAR(schema);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_OBS_VAR(dialect);
phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
phalcon_call_method_p2(sql, dialect, "describecolumns", table, schema);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, 3);
PHALCON_INIT_VAR(describe);
phalcon_call_method_p2(describe, this_ptr, "fetchall", sql, fetch_num);
/**
* 0:name, 1:type, 2:size, 3:numericsize, 4: null, 5: key, 6: extra, 7: position
*/
PHALCON_INIT_VAR(old_column);
phalcon_is_iterable(describe, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(field);
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 1);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_OBS_NVAR(char_size);
phalcon_array_fetch_long(&char_size, field, 2, PH_NOISY);
PHALCON_OBS_NVAR(numeric_size);
phalcon_array_fetch_long(&numeric_size, field, 3, PH_NOISY);
PHALCON_OBS_NVAR(numeric_scale);
phalcon_array_fetch_long(&numeric_scale, field, 4, PH_NOISY);
PHALCON_OBS_NVAR(column_type);
phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY);
/**
* Check the column type to get the correct Phalcon type
*/
if (phalcon_memnstr_str(column_type, SL("int"))) {
phalcon_array_update_string_long(&definition, SL("type"), 0, PH_SEPARATE);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("varying"))) {
phalcon_array_update_string_long(&definition, SL("type"), 2, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("date"))) {
phalcon_array_update_string_long(&definition, SL("type"), 1, PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("numeric"))) {
phalcon_array_update_string_long(&definition, SL("type"), 3, PH_SEPARATE);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE);
phalcon_array_update_string(&definition, SL("scale"), &numeric_scale, PH_COPY | PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("char"))) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("timestamp"))) {
phalcon_array_update_string_long(&definition, SL("type"), 4, PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("text"))) {
phalcon_array_update_string_long(&definition, SL("type"), 6, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("float"))) {
phalcon_array_update_string_long(&definition, SL("type"), 7, PH_SEPARATE);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &numeric_size, PH_COPY | PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("bool"))) {
phalcon_array_update_string_long(&definition, SL("type"), 8, PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_SEPARATE);
} else {
if (phalcon_memnstr_str(column_type, SL("uuid"))) {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE);
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_SEPARATE);
} else {
phalcon_array_update_string_long(&definition, SL("type"), 5, PH_SEPARATE);
phalcon_array_update_string(&definition, SL("size"), &char_size, PH_COPY | PH_SEPARATE);
}
}
}
}
}
}
}
}
}
}
if (phalcon_memnstr_str(column_type, SL("unsigned"))) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_SEPARATE);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_SEPARATE);
} else {
phalcon_array_update_string(&definition, SL("after"), &old_column, PH_COPY | PH_SEPARATE);
}
/**
* Check if the field is primary key
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "PRI")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_SEPARATE);
}
/**
* Check if the column allows null values
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "NO")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_SEPARATE);
}
/**
* Check if the column is auto increment
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 7, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "auto_increment")) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_SEPARATE);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY);
/**
* Create a Phalcon\Db\Column to abstract the column
*/
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
phalcon_call_method_p2_noret(column, "__construct", column_name, definition);
phalcon_array_append(&columns, column, PH_SEPARATE);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(columns);
}
/**
* Returns the cookie's value
*
* @param string|array $filters
* @param string $defaultValue
* @return mixed
*/
PHP_METHOD(Phalcon_Http_Cookie, getValue){
zval *filters = NULL, *default_value = NULL, *restored, *dependency_injector = NULL;
zval *readed, *name, *_COOKIE, *value = NULL, *encryption;
zval *service = NULL, *crypt, *decrypted_value = NULL, *filter = NULL;
zval *sanitized_value;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 2, &filters, &default_value);
if (!filters) {
PHALCON_INIT_VAR(filters);
}
if (!default_value) {
PHALCON_INIT_VAR(default_value);
}
PHALCON_OBS_VAR(restored);
phalcon_read_property_this(&restored, this_ptr, SL("_restored"), PH_NOISY_CC);
if (!zend_is_true(restored)) {
phalcon_call_method_noret(this_ptr, "restore");
}
PHALCON_INIT_VAR(dependency_injector);
PHALCON_OBS_VAR(readed);
phalcon_read_property_this(&readed, this_ptr, SL("_readed"), PH_NOISY_CC);
if (PHALCON_IS_FALSE(readed)) {
PHALCON_OBS_VAR(name);
phalcon_read_property_this(&name, this_ptr, SL("_name"), PH_NOISY_CC);
phalcon_get_global(&_COOKIE, SS("_COOKIE") TSRMLS_CC);
if (phalcon_array_isset(_COOKIE, name)) {
PHALCON_OBS_VAR(value);
phalcon_array_fetch(&value, _COOKIE, name, PH_NOISY);
PHALCON_OBS_VAR(encryption);
phalcon_read_property_this(&encryption, this_ptr, SL("_useEncryption"), PH_NOISY_CC);
if (zend_is_true(encryption)) {
PHALCON_OBS_NVAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service");
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "crypt", 1);
PHALCON_INIT_VAR(crypt);
phalcon_call_method_p1(crypt, dependency_injector, "getshared", service);
/**
* Decrypt the value also decoding it with base64
*/
PHALCON_INIT_VAR(decrypted_value);
phalcon_call_method_p1(decrypted_value, crypt, "decryptbase64", value);
} else {
PHALCON_CPY_WRT(decrypted_value, value);
}
/**
* Update the decrypted value
*/
phalcon_update_property_this(this_ptr, SL("_value"), decrypted_value TSRMLS_CC);
if (Z_TYPE_P(filters) != IS_NULL) {
PHALCON_OBS_VAR(filter);
phalcon_read_property_this(&filter, this_ptr, SL("_filter"), PH_NOISY_CC);
if (Z_TYPE_P(filter) != IS_OBJECT) {
if (Z_TYPE_P(dependency_injector) == IS_NULL) {
PHALCON_OBS_NVAR(dependency_injector);
phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_http_response_exception_ce, "A dependency injection object is required to access the 'filter' service");
return;
}
}
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "filter", 1);
PHALCON_INIT_NVAR(filter);
phalcon_call_method_p1(filter, dependency_injector, "getshared", service);
phalcon_update_property_this(this_ptr, SL("_filter"), filter TSRMLS_CC);
}
PHALCON_INIT_VAR(sanitized_value);
phalcon_call_method_p2(sanitized_value, filter, "sanitize", decrypted_value, filters);
RETURN_CCTOR(sanitized_value);
}
/**
* Return the value without filtering
*/
RETURN_CCTOR(decrypted_value);
}
RETURN_CCTOR(default_value);
}
PHALCON_OBS_NVAR(value);
phalcon_read_property_this(&value, this_ptr, SL("_value"), PH_NOISY_CC);
RETURN_CCTOR(value);
}
/**
* Appends a condition to the current conditions using an OR operator
*
* @param string $conditions
* @param array $bindParams
* @param array $bindTypes
* @return Phalcon\Mvc\Model\Criteria
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, orWhere){
zval *conditions, *bind_params = NULL, *bind_types = NULL;
zval *params = NULL, *current_conditions, *new_conditions = NULL;
zval *current_bind_params, *merged_params = NULL;
zval *current_bind_types, *merged_params_types = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &conditions, &bind_params, &bind_types);
if (!bind_params) {
PHALCON_INIT_VAR(bind_params);
}
if (!bind_types) {
PHALCON_INIT_VAR(bind_types);
}
if (Z_TYPE_P(conditions) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Conditions must be string");
return;
}
PHALCON_OBS_VAR(params);
phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
if (phalcon_array_isset_string(params, SS("conditions"))) {
PHALCON_OBS_VAR(current_conditions);
phalcon_array_fetch_string(¤t_conditions, params, SL("conditions"), PH_NOISY_CC);
PHALCON_INIT_VAR(new_conditions);
PHALCON_CONCAT_SVSVS(new_conditions, "(", current_conditions, ") OR (", conditions, ")");
} else {
PHALCON_CPY_WRT(new_conditions, conditions);
}
phalcon_update_property_array_string(this_ptr, SL("_params"), SS("conditions"), new_conditions TSRMLS_CC);
/**
* Update or merge existing bound parameters
*/
if (Z_TYPE_P(bind_params) == IS_ARRAY) {
PHALCON_OBS_NVAR(params);
phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
if (phalcon_array_isset_string(params, SS("bind"))) {
PHALCON_OBS_VAR(current_bind_params);
phalcon_array_fetch_string(¤t_bind_params, params, SL("bind"), PH_NOISY_CC);
PHALCON_INIT_VAR(merged_params);
phalcon_fast_array_merge(merged_params, ¤t_bind_params, &bind_params TSRMLS_CC);
} else {
PHALCON_CPY_WRT(merged_params, bind_params);
}
phalcon_update_property_array_string(this_ptr, SL("_params"), SS("bind"), merged_params TSRMLS_CC);
}
/**
* Update or merge existing bind types parameters
*/
if (Z_TYPE_P(bind_types) == IS_ARRAY) {
PHALCON_OBS_NVAR(params);
phalcon_read_property_this(¶ms, this_ptr, SL("_params"), PH_NOISY_CC);
if (phalcon_array_isset_string(params, SS("bindTypes"))) {
PHALCON_OBS_VAR(current_bind_types);
phalcon_array_fetch_string(¤t_bind_types, params, SL("bindTypes"), PH_NOISY_CC);
PHALCON_INIT_VAR(merged_params_types);
phalcon_fast_array_merge(merged_params_types, ¤t_bind_types, &bind_types TSRMLS_CC);
} else {
PHALCON_CPY_WRT(merged_params_types, bind_types);
}
phalcon_update_property_array_string(this_ptr, SL("_params"), SS("bindTypes"), merged_params_types TSRMLS_CC);
}
RETURN_THIS();
}
/**
* 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);
}
/**
* Transforms an intermediate representation for a expression into a database system valid expression
*
* @param array $expression
* @param string $escapeChar
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, getSqlExpression){
zval *expression, *escape_char = NULL, *type, *name = NULL, *escaped_name = NULL;
zval *domain, *escaped_domain = NULL, *value = NULL, *operator = NULL;
zval *left = NULL, *expression_left = NULL, *right = NULL, *expression_right = NULL;
zval *binary_expr, *unary_expr = NULL, *expression_group;
zval *sql_arguments, *arguments, *argument = NULL, *argument_expression = NULL;
zval *arguments_joined, *function_expression = NULL;
zval *sql_items, *items, *item = NULL, *item_expression = NULL;
zval *list_expression, *group_expression;
zval *exception_message;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &expression, &escape_char) == FAILURE) {
RETURN_MM_NULL();
}
if (!escape_char) {
PHALCON_INIT_VAR(escape_char);
} else {
PHALCON_SEPARATE_PARAM(escape_char);
}
if (PHALCON_GLOBAL(db).escape_identifiers) {
if (Z_TYPE_P(escape_char) == IS_NULL) {
PHALCON_OBS_NVAR(escape_char);
phalcon_read_property(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY_CC);
}
}
if (Z_TYPE_P(expression) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression");
return;
}
if (!phalcon_array_isset_string(expression, SS("type"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SQL expression");
return;
}
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, expression, SL("type"), PH_NOISY_CC);
/**
* Resolve qualified expressions
*/
if (PHALCON_IS_STRING(type, "qualified")) {
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY_CC);
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_VAR(escaped_name);
PHALCON_CONCAT_VVV(escaped_name, escape_char, name, escape_char);
} else {
PHALCON_CPY_WRT(escaped_name, name);
}
/**
* A domain could be a table/schema
*/
if (phalcon_array_isset_string(expression, SS("domain"))) {
PHALCON_OBS_VAR(domain);
phalcon_array_fetch_string(&domain, expression, SL("domain"), PH_NOISY_CC);
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_VAR(escaped_domain);
PHALCON_CONCAT_VVVSV(escaped_domain, escape_char, domain, escape_char, ".", escaped_name);
} else {
PHALCON_INIT_NVAR(escaped_domain);
PHALCON_CONCAT_VSV(escaped_domain, domain, ".", escaped_name);
}
RETURN_CTOR(escaped_domain);
}
RETURN_CCTOR(escaped_name);
}
/**
* Resolve literal expressions
*/
if (PHALCON_IS_STRING(type, "literal")) {
PHALCON_OBS_VAR(value);
phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY_CC);
RETURN_CCTOR(value);
}
/**
* Resolve binary operations expressions
*/
if (PHALCON_IS_STRING(type, "binary-op")) {
PHALCON_OBS_VAR(operator);
phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY_CC);
PHALCON_OBS_VAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC);
PHALCON_INIT_VAR(expression_left);
PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_OBS_VAR(right);
phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY_CC);
PHALCON_INIT_VAR(expression_right);
PHALCON_CALL_METHOD_PARAMS_2(expression_right, this_ptr, "getsqlexpression", right, escape_char);
PHALCON_INIT_VAR(binary_expr);
PHALCON_CONCAT_VSVSV(binary_expr, expression_left, " ", operator, " ", expression_right);
RETURN_CTOR(binary_expr);
}
/**
* Resolve unary operations expressions
*/
if (PHALCON_IS_STRING(type, "unary-op")) {
PHALCON_OBS_NVAR(operator);
phalcon_array_fetch_string(&operator, expression, SL("op"), PH_NOISY_CC);
/**
* Some unary operators uses the left operand...
*/
if (phalcon_array_isset_string(expression, SS("left"))) {
PHALCON_OBS_NVAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC);
PHALCON_INIT_NVAR(expression_left);
PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_INIT_VAR(unary_expr);
PHALCON_CONCAT_VV(unary_expr, expression_left, operator);
RETURN_CTOR(unary_expr);
}
/**
* ...Others uses the right operand
*/
if (phalcon_array_isset_string(expression, SS("right"))) {
PHALCON_OBS_NVAR(right);
phalcon_array_fetch_string(&right, expression, SL("right"), PH_NOISY_CC);
PHALCON_INIT_NVAR(expression_right);
PHALCON_CALL_METHOD_PARAMS_2(expression_right, this_ptr, "getsqlexpression", right, escape_char);
PHALCON_INIT_NVAR(unary_expr);
PHALCON_CONCAT_VV(unary_expr, operator, expression_right);
RETURN_CTOR(unary_expr);
}
}
/**
* Resolve placeholder
*/
if (PHALCON_IS_STRING(type, "placeholder")) {
PHALCON_OBS_NVAR(value);
phalcon_array_fetch_string(&value, expression, SL("value"), PH_NOISY_CC);
RETURN_CCTOR(value);
}
/**
* Resolve parentheses
*/
if (PHALCON_IS_STRING(type, "parentheses")) {
PHALCON_OBS_NVAR(left);
phalcon_array_fetch_string(&left, expression, SL("left"), PH_NOISY_CC);
PHALCON_INIT_NVAR(expression_left);
PHALCON_CALL_METHOD_PARAMS_2(expression_left, this_ptr, "getsqlexpression", left, escape_char);
PHALCON_INIT_VAR(expression_group);
PHALCON_CONCAT_SVS(expression_group, "(", expression_left, ")");
RETURN_CTOR(expression_group);
}
/**
* Resolve function calls
*/
if (PHALCON_IS_STRING(type, "functionCall")) {
PHALCON_OBS_NVAR(name);
phalcon_array_fetch_string(&name, expression, SL("name"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql_arguments);
array_init(sql_arguments);
if (phalcon_array_isset_string(expression, SS("arguments"))) {
PHALCON_OBS_VAR(arguments);
phalcon_array_fetch_string(&arguments, expression, SL("arguments"), PH_NOISY_CC);
if (!phalcon_is_iterable(arguments, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(argument);
PHALCON_INIT_NVAR(argument_expression);
PHALCON_CALL_METHOD_PARAMS_2(argument_expression, this_ptr, "getsqlexpression", argument, escape_char);
phalcon_array_append(&sql_arguments, argument_expression, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(arguments_joined);
phalcon_fast_join_str(arguments_joined, SL(", "), sql_arguments TSRMLS_CC);
PHALCON_INIT_VAR(function_expression);
PHALCON_CONCAT_VSVS(function_expression, name, "(", arguments_joined, ")");
} else {
PHALCON_INIT_NVAR(function_expression);
PHALCON_CONCAT_VS(function_expression, name, "()");
}
RETURN_CTOR(function_expression);
}
/**
* Resolve lists
*/
if (PHALCON_IS_STRING(type, "list")) {
PHALCON_INIT_VAR(sql_items);
array_init(sql_items);
PHALCON_OBS_VAR(items);
phalcon_array_fetch_long(&items, expression, 0, PH_NOISY_CC);
if (!phalcon_is_iterable(items, &ah1, &hp1, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_FOREACH_VALUE(item);
PHALCON_INIT_NVAR(item_expression);
PHALCON_CALL_METHOD_PARAMS_2(item_expression, this_ptr, "getsqlexpression", item, escape_char);
phalcon_array_append(&sql_items, item_expression, PH_SEPARATE TSRMLS_CC);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_VAR(list_expression);
phalcon_fast_join_str(list_expression, SL(", "), sql_items TSRMLS_CC);
PHALCON_INIT_VAR(group_expression);
PHALCON_CONCAT_SVS(group_expression, "(", list_expression, ")");
RETURN_CTOR(group_expression);
}
/**
* Resolve *
*/
if (PHALCON_IS_STRING(type, "all")) {
PHALCON_MM_RESTORE();
RETURN_STRING("*", 1);
}
/**
* Expression type wasn't found
*/
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Invalid SQL expression type '", type, "'");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message);
return;
}
/**
* Attach a listener to the events manager
*
* @param string $eventType
* @param object|callable $handler
* @param int $priority
*/
PHP_METHOD(Phalcon_Events_Manager, attach){
zval *event_type, *handler, *priority = NULL, *events = NULL;
zval *enable_priorities, *priority_queue = NULL;
zval *mode;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 1, &event_type, &handler, &priority);
if (!priority) {
PHALCON_INIT_VAR(priority);
ZVAL_LONG(priority, 100);
}
if (unlikely(Z_TYPE_P(event_type) != IS_STRING)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string");
return;
}
if (unlikely(Z_TYPE_P(handler) != IS_OBJECT)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event handler must be an Object");
return;
}
PHALCON_OBS_VAR(events);
phalcon_read_property_this(&events, this_ptr, SL("_events"), PH_NOISY_CC);
if (Z_TYPE_P(events) != IS_ARRAY) {
PHALCON_INIT_NVAR(events);
array_init(events);
}
if (!phalcon_array_isset(events, event_type)) {
PHALCON_OBS_VAR(enable_priorities);
phalcon_read_property_this(&enable_priorities, this_ptr, SL("_enablePriorities"), PH_NOISY_CC);
if (zend_is_true(enable_priorities)) {
/**
* Create a SplPriorityQueue to store the events with priorities
*/
PHALCON_INIT_VAR(priority_queue);
object_init_ex(priority_queue, spl_ce_SplPriorityQueue);
if (phalcon_has_constructor(priority_queue TSRMLS_CC)) {
phalcon_call_method_noret(priority_queue, "__construct");
}
/**
* Extract only the Data
*/
PHALCON_INIT_VAR(mode);
ZVAL_LONG(mode, 1);
/**
* Set extraction flags
*/
phalcon_call_method_p1_noret(priority_queue, "setextractflags", mode);
/**
* Append the events to the queue
*/
phalcon_array_update_zval(&events, event_type, &priority_queue, PH_COPY | PH_SEPARATE);
phalcon_update_property_this(this_ptr, SL("_events"), events TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(priority_queue);
array_init(priority_queue);
}
} else {
/**
* Get the current SplPriorityQueue
*/
PHALCON_OBS_NVAR(priority_queue);
phalcon_array_fetch(&priority_queue, events, event_type, PH_NOISY);
}
/**
* Insert the handler in the queue
*/
if (unlikely(Z_TYPE_P(priority_queue) == IS_OBJECT)) {
phalcon_call_method_p2_noret(priority_queue, "insert", handler, priority);
} else {
phalcon_array_append(&priority_queue, handler, PH_SEPARATE);
/**
* Append the events to the queue
*/
phalcon_array_update_zval(&events, event_type, &priority_queue, PH_COPY | PH_SEPARATE);
phalcon_update_property_this(this_ptr, SL("_events"), events TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}