/**
* Executes the validation
*
* @param string $value
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Regex, valid){
zval *value, *pattern;
zval *matches, *match_pattern, *match_zero, *valid;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 0, &value, &pattern);
PHALCON_INIT_VAR(matches);
/* Check if the value match using preg_match in the PHP userland */
PHALCON_INIT_VAR(match_pattern);
RETURN_MM_ON_FAILURE(phalcon_preg_match(match_pattern, pattern, value, matches));
if (zend_is_true(match_pattern)) {
PHALCON_OBS_VAR(match_zero);
phalcon_array_fetch_long(&match_zero, matches, 0, PH_NOISY);
PHALCON_INIT_VAR(valid);
is_not_equal_function(valid, match_zero, value);
if (PHALCON_IS_FALSE(valid)) {
RETURN_MM_TRUE;
}
}
RETURN_MM_FALSE;
}
/**
* Executes the validator
*
* @return boolean
*/
PHP_METHOD(Phalcon_Model_Validator_Email, validate){
zval *regs = NULL, *field_name = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD(r0, this_ptr, "isrequired", PHALCON_NO_CHECK);
if (zend_is_true(r0)) {
PHALCON_INIT_VAR(regs);
ZVAL_NULL(regs);
PHALCON_ALLOC_ZVAL_MM(r1);
PHALCON_CALL_METHOD(r1, this_ptr, "getfieldname", PHALCON_NO_CHECK);
PHALCON_CPY_WRT(field_name, r1);
PHALCON_ALLOC_ZVAL_MM(r2);
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "/^[a-zA-Z0-9_\\.\\+]+@[a-zA-Z0-9_]+(\\.[a-zA-Z0-9_]+)*$/", 1);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CALL_METHOD(r3, this_ptr, "getvalue", PHALCON_NO_CHECK);
Z_SET_ISREF_P(regs);
PHALCON_CALL_FUNC_PARAMS_3(r2, "preg_match", c0, r3, regs, 0x006);
Z_UNSET_ISREF_P(regs);
if (zend_is_true(r2)) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_long(&r4, regs, 0, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
PHALCON_CALL_METHOD(r5, this_ptr, "getvalue", PHALCON_NO_CHECK);
PHALCON_INIT_VAR(r6);
is_not_equal_function(r6, r4, r5 TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_ALLOC_ZVAL_MM(r7);
PHALCON_CONCAT_SVS(r7, "Value of field '", field_name, "' should be a valid e-mail");
PHALCON_INIT_VAR(c1);
ZVAL_STRING(c1, "email", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r7, field_name, c1, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
} else {
PHALCON_ALLOC_ZVAL_MM(r8);
PHALCON_CONCAT_SVS(r8, "Value of field '", field_name, "' should be a valid e-mail");
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "email", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", r8, field_name, c2, PHALCON_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Moves internal resulset cursor to another position letting us to fetch a certain row
*
* @param int $number
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, dataSeek) {
zval *number = NULL, *n = NULL, *pdo_statement = NULL, *result = NULL;
zval *r0 = NULL, *r1 = NULL;
zval *t0 = NULL, *t1 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &number) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(number);
PHALCON_INIT_VAR(t1);
ZVAL_LONG(t1, 1);
PHALCON_INIT_VAR(t0);
ZVAL_LONG(t0, -1);
PHALCON_ALLOC_ZVAL_MM(r0);
mul_function(r0, t0, t1 TSRMLS_CC);
PHALCON_CPY_WRT(n, r0);
decrement_function(number);
PHALCON_INIT_VAR(pdo_statement);
phalcon_read_property(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
PHALCON_CALL_METHOD_NORETURN(pdo_statement, "execute", PH_NO_CHECK);
ws_a5eb_0:
PHALCON_INIT_VAR(r1);
is_not_equal_function(r1, n, number TSRMLS_CC);
if (!zend_is_true(r1)) {
goto we_a5eb_0;
}
PHALCON_INIT_VAR(result);
PHALCON_CALL_METHOD(result, pdo_statement, "fetch", PH_NO_CHECK);
if (Z_TYPE_P(result) != IS_ARRAY) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE(n);
increment_function(n);
goto ws_a5eb_0;
we_a5eb_0:
if(0) {}
PHALCON_MM_RESTORE();
}
/**
* Executes the validation
*
* @param string $value
* @return boolean
*/
PHP_METHOD(Phalcon_Validation_Validator_Regex, valid){
zval *value, *pattern, matches = {}, match_pattern = {}, match_zero = {}, valid = {};
phalcon_fetch_params(0, 2, 0, &value, &pattern);
/* Check if the value match using preg_match in the PHP userland */
ZVAL_NULL(&matches);
ZVAL_MAKE_REF(&matches);
RETURN_ON_FAILURE(phalcon_preg_match(&match_pattern, pattern, value, &matches));
ZVAL_UNREF(&matches);
if (zend_is_true(&match_pattern)) {
phalcon_array_fetch_long(&match_zero, &matches, 0, PH_NOISY);
is_not_equal_function(&valid, &match_zero, value);
if (PHALCON_IS_FALSE(&valid)) {
RETURN_TRUE;
}
}
RETURN_FALSE;
}
/**
* Changes internal pointer to a specific position in the resultset
*
* @param int $position
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset, seek){
long i;
zval *type, *result, *rows, *position;
zval *pointer, *is_different;
HashTable *ah0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &position) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_OBS_VAR(pointer);
phalcon_read_property(&pointer, this_ptr, SL("_pointer"), PH_NOISY_CC);
/**
* We only seek the records if the current position is diferent than the passed one
*/
PHALCON_INIT_VAR(is_different);
is_not_equal_function(is_different, pointer, position TSRMLS_CC);
if (PHALCON_IS_TRUE(is_different)) {
PHALCON_OBS_VAR(type);
phalcon_read_property(&type, this_ptr, SL("_type"), PH_NOISY_CC);
if (zend_is_true(type)) {
/**
* Here, the resultset is fetched one by one because is large
*/
PHALCON_OBS_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
phalcon_call_method_p1_noret(result, "dataseek", position);
} else {
/**
* Here, the resultset is a small array
*/
PHALCON_OBS_VAR(rows);
phalcon_read_property(&rows, this_ptr, SL("_rows"), PH_NOISY_CC);
/**
* We need to fetch the records because rows is null
*/
if (Z_TYPE_P(rows) == IS_NULL) {
PHALCON_OBS_VAR(result);
phalcon_read_property(&result, this_ptr, SL("_result"), PH_NOISY_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_INIT_NVAR(rows);
phalcon_call_method(rows, result, "fetchall");
phalcon_update_property_zval(this_ptr, SL("_rows"), rows TSRMLS_CC);
}
}
convert_to_long(position);
if(Z_TYPE_P(rows) == IS_ARRAY){
ah0 = Z_ARRVAL_P(rows);
zend_hash_internal_pointer_reset(ah0);
i = 0;
while (1) {
if (i >= Z_LVAL_P(position)) {
break;
}
zend_hash_move_forward(ah0);
i++;
}
}
phalcon_update_property_zval(this_ptr, SL("_pointer"), position TSRMLS_CC);
}
}
PHALCON_MM_RESTORE();}
/**
* Setup a relation 1-n between two models
*
* @param Phalcon\Mvc\Model $model
* @param mixed $fields
* @param string $referenceModel
* @param mixed $referencedFields
* @param array $options
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, addHasMany){
zval *model = NULL, *fields = NULL, *reference_model = NULL, *referenced_fields = NULL;
zval *options = NULL, *entity_name = NULL, *has_many = NULL, *number_fields = NULL;
zval *number_referenced = NULL, *diferent_fields = NULL;
zval *relation = NULL;
zval *a0 = NULL;
zval *r0 = NULL;
zval *t0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz|z", &model, &fields, &reference_model, &referenced_fields, &options) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!options) {
PHALCON_INIT_VAR(options);
array_init(options);
}
PHALCON_INIT_VAR(entity_name);
phalcon_get_class(entity_name, model TSRMLS_CC);
PHALCON_INIT_VAR(has_many);
phalcon_read_property(&has_many, this_ptr, SL("_hasMany"), PH_NOISY_CC);
eval_int = phalcon_array_isset(has_many, entity_name);
if (!eval_int) {
PHALCON_ALLOC_ZVAL_MM(a0);
array_init(a0);
phalcon_array_update_zval(&has_many, entity_name, &a0, PH_COPY | PH_SEPARATE TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch(&r0, has_many, entity_name, PH_NOISY_CC);
eval_int = phalcon_array_isset(r0, reference_model);
if (!eval_int) {
if (Z_TYPE_P(referenced_fields) == IS_ARRAY) {
PHALCON_INIT_VAR(number_fields);
phalcon_fast_count(number_fields, fields TSRMLS_CC);
PHALCON_INIT_VAR(number_referenced);
phalcon_fast_count(number_referenced, referenced_fields TSRMLS_CC);
PHALCON_INIT_VAR(diferent_fields);
is_not_equal_function(diferent_fields, number_fields, number_referenced TSRMLS_CC);
if (zend_is_true(diferent_fields)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Number of referenced fields are not the same");
return;
}
}
PHALCON_INIT_VAR(relation);
array_init(relation);
phalcon_array_update_string(&relation, SL("fi"), &fields, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&relation, SL("rt"), &reference_model, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&relation, SL("rf"), &referenced_fields, PH_COPY | PH_SEPARATE TSRMLS_CC);
phalcon_array_update_string(&relation, SL("op"), &options, PH_COPY | PH_SEPARATE TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_hasMany"), PH_NOISY_CC);
phalcon_array_update_multi_2(&t0, entity_name, reference_model, &relation, 0 TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_hasMany"), t0 TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
/**
* Phalcon\Db\Reference constructor
*
* @param string $referenceName
* @param array $definition
*/
PHP_METHOD(Phalcon_Db_Reference, __construct){
zval *reference_name = NULL, *definition = NULL, *referenced_table = NULL;
zval *columns = NULL, *referenced_columns = NULL, *schema = NULL;
zval *referenced_schema = NULL, *number_columns = NULL;
zval *number_referenced_columns = NULL;
zval *r0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &reference_name, &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_update_property_zval(this_ptr, SL("_referenceName"), reference_name TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, SL("referencedTable")+1);
if (eval_int) {
PHALCON_INIT_VAR(referenced_table);
phalcon_array_fetch_string(&referenced_table, definition, SL("referencedTable"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_referencedTable"), referenced_table TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced table is required");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("columns")+1);
if (eval_int) {
PHALCON_INIT_VAR(columns);
phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_columns"), columns TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Foreign key columns are required");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("referencedColumns")+1);
if (eval_int) {
PHALCON_INIT_VAR(referenced_columns);
phalcon_array_fetch_string(&referenced_columns, definition, SL("referencedColumns"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_referencedColumns"), referenced_columns TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced columns of the foreign key are required");
return;
}
eval_int = phalcon_array_isset_string(definition, SL("schema")+1);
if (eval_int) {
PHALCON_INIT_VAR(schema);
phalcon_array_fetch_string(&schema, definition, SL("schema"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_schema"), schema TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, SL("referencedSchema")+1);
if (eval_int) {
PHALCON_INIT_VAR(referenced_schema);
phalcon_array_fetch_string(&referenced_schema, definition, SL("referencedSchema"), PH_NOISY_CC);
phalcon_update_property_zval(this_ptr, SL("_referencedSchema"), referenced_schema TSRMLS_CC);
}
PHALCON_INIT_VAR(number_columns);
phalcon_fast_count(number_columns, columns TSRMLS_CC);
PHALCON_INIT_VAR(number_referenced_columns);
phalcon_fast_count(number_referenced_columns, referenced_columns TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r0);
is_not_equal_function(r0, number_columns, number_referenced_columns TSRMLS_CC);
if (zend_is_true(r0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Number of columns is not equals than the number of columns referenced");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\ModelInterface $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Regex, validate) {
zval *record, *option = NULL, *field_name, *is_set, *value;
zval *failed = NULL, *matches, *pattern, *match_pattern;
zval *match_zero, *message = NULL, *type;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field_name);
PHALCON_CALL_METHOD_PARAMS_1(field_name, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field_name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
/**
* The 'pattern' option must be a valid regular expression
*/
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "pattern", 1);
PHALCON_INIT_VAR(is_set);
PHALCON_CALL_METHOD_PARAMS_1(is_set, this_ptr, "issetoption", option, PH_NO_CHECK);
if (!zend_is_true(is_set)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Validator requires a perl-compatible regex pattern");
return;
}
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field_name, PH_NO_CHECK);
PHALCON_INIT_VAR(failed);
ZVAL_BOOL(failed, 0);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(pattern);
PHALCON_CALL_METHOD_PARAMS_1(pattern, this_ptr, "getoption", option, PH_NO_CHECK);
/**
* Check if the value match using preg_match in the PHP userland
*/
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(match_pattern);
PHALCON_CALL_FUNC_PARAMS_3(match_pattern, "preg_match", pattern, value, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(match_pattern)) {
PHALCON_INIT_VAR(match_zero);
phalcon_array_fetch_long(&match_zero, matches, 0, PH_NOISY_CC);
is_not_equal_function(failed, match_zero, value TSRMLS_CC);
} else {
ZVAL_BOOL(failed, 1);
}
if (PHALCON_IS_TRUE(failed)) {
/**
* 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_PARAMS_1(message, this_ptr, "getoption", option, PH_NO_CHECK);
if (!zend_is_true(message)) {
PHALCON_INIT_NVAR(message);
PHALCON_CONCAT_SVS(message, "Value of field '", field_name, "' doesn't match regular expression");
}
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "Regex", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field_name, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Executes the validator
*
* @param Phalcon\Mvc\Model $record
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Validator_Email, validate){
zval *record, *option, *field_name, *regs, *invalid = NULL;
zval *value, *pattern, *match_pattern, *match_zero;
zval *type, *message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(option);
ZVAL_STRING(option, "field", 1);
PHALCON_INIT_VAR(field_name);
PHALCON_CALL_METHOD_PARAMS_1(field_name, this_ptr, "getoption", option, PH_NO_CHECK);
if (Z_TYPE_P(field_name) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_model_exception_ce, "Field name must be a string");
return;
}
PHALCON_INIT_VAR(regs);
PHALCON_INIT_VAR(invalid);
ZVAL_BOOL(invalid, 0);
PHALCON_INIT_VAR(value);
PHALCON_CALL_METHOD_PARAMS_1(value, record, "readattribute", field_name, PH_NO_CHECK);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^[a-zA-Z0-9\\-_\\.\\+]+@[a-zA-Z0-9_]+(\\.[a-zA-Z0-9_]+)*$/", 1);
Z_SET_ISREF_P(regs);
PHALCON_INIT_VAR(match_pattern);
PHALCON_CALL_FUNC_PARAMS_3(match_pattern, "preg_match", pattern, value, regs);
Z_UNSET_ISREF_P(regs);
if (zend_is_true(match_pattern)) {
PHALCON_INIT_VAR(match_zero);
phalcon_array_fetch_long(&match_zero, regs, 0, PH_NOISY_CC);
is_not_equal_function(invalid, match_zero, value TSRMLS_CC);
} else {
ZVAL_BOOL(invalid, 1);
}
if (PHALCON_IS_TRUE(invalid)) {
PHALCON_INIT_VAR(type);
ZVAL_STRING(type, "email", 1);
PHALCON_INIT_VAR(message);
PHALCON_CONCAT_SVS(message, "Value of field '", field_name, "' must have a valid e-mail format");
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(this_ptr, "appendmessage", message, field_name, type, PH_NO_CHECK);
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Phalcon_Db_Reference constructor
*
* @param string $referenceName
* @param array $definition
*/
PHP_METHOD(Phalcon_Db_Reference, __construct){
zval *reference_name = NULL, *definition = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL;
zval *t0 = NULL, *t1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &reference_name, &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
phalcon_update_property_zval(this_ptr, "_referenceName", strlen("_referenceName"), reference_name TSRMLS_CC);
eval_int = phalcon_array_isset_string(definition, "referencedTable", strlen("referencedTable")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch_string(&r0, definition, "referencedTable", strlen("referencedTable"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_referencedTable", strlen("_referencedTable"), r0 TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced table is required");
return;
}
eval_int = phalcon_array_isset_string(definition, "columns", strlen("columns")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, "columns", strlen("columns"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_columns", strlen("_columns"), r1 TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Foreign key columns are required");
return;
}
eval_int = phalcon_array_isset_string(definition, "referencedColumns", strlen("referencedColumns")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_array_fetch_string(&r2, definition, "referencedColumns", strlen("referencedColumns"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_referencedColumns", strlen("_referencedColumns"), r2 TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Referenced columns of the foreign key are required");
return;
}
eval_int = phalcon_array_isset_string(definition, "schema", strlen("schema")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r3);
phalcon_array_fetch_string(&r3, definition, "schema", strlen("schema"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_schema", strlen("_schema"), r3 TSRMLS_CC);
}
eval_int = phalcon_array_isset_string(definition, "referencedSchema", strlen("referencedSchema")+1);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r4);
phalcon_array_fetch_string(&r4, definition, "referencedSchema", strlen("referencedSchema"), PHALCON_NOISY TSRMLS_CC);
phalcon_update_property_zval(this_ptr, "_referencedSchema", strlen("_referencedSchema"), r4 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, "_columns", sizeof("_columns")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r5);
phalcon_fast_count(r5, t0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, "_referencedColumns", sizeof("_referencedColumns")-1, PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r6);
phalcon_fast_count(r6, t1 TSRMLS_CC);
PHALCON_INIT_VAR(r7);
is_not_equal_function(r7, r5, r6 TSRMLS_CC);
if (zend_is_true(r7)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Number of columns is not equals than the number of columns referenced");
return;
}
PHALCON_MM_RESTORE();
}
/**
* Updates data on a table using custom RBDM SQL syntax
*
*
*
* @param string $table
* @param array $fields
* @param array $values
* @param string $whereCondition
* @param boolean $automaticQuotes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, update){
zval *table = NULL, *fields = NULL, *values = NULL, *where_condition = NULL;
zval *automatic_quotes = NULL, *i = NULL, *update_values = NULL, *update_sql = NULL;
zval *field = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL;
zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL, *r13 = NULL;
zval *r14 = NULL, *r15 = NULL, *r16 = NULL, *r17 = NULL, *r18 = NULL;
zval *a0 = NULL;
zval *c0 = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|zz", &table, &fields, &values, &where_condition, &automatic_quotes) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_SEPARATE_PARAM(values);
if (!where_condition) {
PHALCON_INIT_VAR(where_condition);
ZVAL_NULL(where_condition);
}
if (!automatic_quotes) {
PHALCON_INIT_VAR(automatic_quotes);
ZVAL_BOOL(automatic_quotes, 0);
}
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_fast_count(r0, fields TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_fast_count(r1, values TSRMLS_CC);
PHALCON_INIT_VAR(r2);
is_not_equal_function(r2, r0, r1 TSRMLS_CC);
if (zend_is_true(r2)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values to update is not the same as fields");
return;
}
PHALCON_INIT_VAR(i);
ZVAL_LONG(i, 0);
PHALCON_INIT_VAR(a0);
array_init(a0);
PHALCON_CPY_WRT(update_values, a0);
PHALCON_ALLOC_ZVAL_MM(r3);
PHALCON_CONCAT_SVS(r3, "UPDATE ", table, " SET ");
PHALCON_CPY_WRT(update_sql, r3);
if (phalcon_valid_foreach(fields TSRMLS_CC)) {
ah0 = Z_ARRVAL_P(fields);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_e7f0_2:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_e7f0_2;
}
PHALCON_INIT_VAR(field);
ZVAL_ZVAL(field, *hd, 1, 0);
if (zend_is_true(automatic_quotes)) {
PHALCON_INIT_VAR(r4);
phalcon_array_fetch(&r4, values, i, PHALCON_NOISY TSRMLS_CC);
if (Z_TYPE_P(r4) == IS_OBJECT) {
PHALCON_INIT_VAR(r5);
phalcon_array_fetch(&r5, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(r6);
phalcon_instance_of(r6, r5, phalcon_db_rawvalue_ce TSRMLS_CC);
if (zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_INIT_VAR(r8);
PHALCON_INIT_VAR(r9);
phalcon_array_fetch(&r9, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(r8, r9, "getvalue", PHALCON_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1(r7, this_ptr, "escapestring", r8, PHALCON_NO_CHECK);
phalcon_array_update(&values, i, &r7, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
goto fes_e7f0_2;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_INIT_VAR(r11);
PHALCON_INIT_VAR(r12);
phalcon_array_fetch(&r12, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD_PARAMS_1(r11, this_ptr, "escapestring", r12, PHALCON_NO_CHECK);
PHALCON_CONCAT_SVS(r10, "'", r11, "'");
phalcon_array_update(&values, i, &r10, PHALCON_SEPARATE_PLZ, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
}
PHALCON_INIT_VAR(r13);
PHALCON_INIT_VAR(r14);
phalcon_array_fetch(&r14, values, i, PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VSV(r13, field, " = ", r14);
phalcon_array_append(&update_values, r13, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_SEPARATE(i);
increment_function(i);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_e7f0_2;
fee_e7f0_2:
if(0){}
} else {
return;
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, ", ", 1);
PHALCON_ALLOC_ZVAL_MM(r15);
phalcon_fast_join(r15, c0, update_values TSRMLS_CC);
phalcon_concat_self(&update_sql, r15 TSRMLS_CC);
PHALCON_INIT_VAR(t0);
ZVAL_NULL(t0);
PHALCON_INIT_VAR(r16);
is_not_equal_function(r16, where_condition, t0 TSRMLS_CC);
if (zend_is_true(r16)) {
PHALCON_ALLOC_ZVAL_MM(r17);
PHALCON_CONCAT_SV(r17, " WHERE ", where_condition);
phalcon_concat_self(&update_sql, r17 TSRMLS_CC);
}
PHALCON_ALLOC_ZVAL_MM(r18);
PHALCON_CALL_METHOD_PARAMS_1(r18, this_ptr, "query", update_sql, PHALCON_NO_CHECK);
PHALCON_RETURN_DZVAL(r18);
}