/**
* Drops a table from a schema/database
*
* @param string $tableName
* @param string $schemaName
* @param boolean $ifExists
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, dropTable){
zval *table_name = NULL, *schema_name = NULL, *if_exists = NULL, *sql = NULL;
zval *t0 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &table_name, &schema_name, &if_exists) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!if_exists) {
PHALCON_ALLOC_ZVAL_MM(if_exists);
ZVAL_BOOL(if_exists, 1);
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_3(sql, t0, "droptable", table_name, schema_name, if_exists, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "execute", sql, PH_NO_CHECK);
RETURN_CTOR(r0);
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *message = NULL;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(t0)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(t1 TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(t1);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD(r0, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(r1);
PHALCON_CALL_METHOD(r1, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_METHOD(r2, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_METHOD_PARAMS_3(r3, this_ptr, "_applyformat", r0, r1, r2, PH_NO_CHECK);
PHALCON_INIT_VAR(t3);
zend_get_constant(SL("PHP_EOL"), t3 TSRMLS_CC);
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VV(r4, r3, t3);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", t2, r4);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Creates a table using MySQL SQL
*
* @param string $tableName
* @param string $schemaName
* @param array $definition
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, createTable){
zval *table_name = NULL, *schema_name = NULL, *definition = NULL;
zval *sql = NULL, *success = NULL;
zval *i0 = NULL;
zval *r0 = NULL, *r1 = NULL, *r2 = NULL;
zval *t0 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &definition) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (Z_TYPE_P(definition) != IS_ARRAY) {
PHALCON_ALLOC_ZVAL_MM(i0);
object_init_ex(i0, phalcon_db_exception_ce);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CONCAT_SVS(r0, "Invalid definition to create the table '", table_name, "'");
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", r0, PH_CHECK);
phalcon_throw_exception(i0 TSRMLS_CC);
return;
}
eval_int = phalcon_array_isset_string(definition, SL("columns")+1);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The table must contain at least one column");
return;
}
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch_string(&r1, definition, SL("columns"), PH_NOISY_CC);
PHALCON_ALLOC_ZVAL_MM(r2);
phalcon_fast_count(r2, r1 TSRMLS_CC);
if (!zend_is_true(r2)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The table must contain at least one column");
return;
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_3(sql, t0, "createtable", table_name, schema_name, definition, PH_NO_CHECK);
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_1(success, this_ptr, "execute", sql, PH_NO_CHECK);
RETURN_CCTOR(success);
}
/**
* Maps a route to a handler
*
* @param string $routePattern
* @param callable $handler
* @return Phalcon\Mvc\Router\RouteInterface
*/
PHP_METHOD(Phalcon_Mvc_Micro_Collection, map){
zval *route_pattern, *handler, *method, *route;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &route_pattern, &handler) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(method);
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_3(route, this_ptr, "_addmap", method, route_pattern, handler);
RETURN_CCTOR(route);
}
/**
* Adds a route to the router that only match if the HTTP method is HEAD
*
* @param string $pattern
* @param string/array $paths
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, addHead){
zval *pattern, *paths = NULL, *method, *route;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &pattern, &paths);
if (!paths) {
PHALCON_INIT_VAR(paths);
}
PHALCON_INIT_VAR(method);
ZVAL_STRING(method, "HEAD", 1);
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_3(route, this_ptr, "_addroute", pattern, paths, method);
RETURN_CCTOR(route);
}
/**
* Adds a route to the router on any HTTP method
*
*<code>
* $router->add('/about', 'About::index');
*</code>
*
* @param string $pattern
* @param string/array $paths
* @param string $httpMethods
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, add){
zval *pattern, *paths = NULL, *http_methods = NULL, *route;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &pattern, &paths, &http_methods);
if (!paths) {
PHALCON_INIT_VAR(paths);
}
if (!http_methods) {
PHALCON_INIT_VAR(http_methods);
}
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_3(route, this_ptr, "_addroute", pattern, paths, http_methods);
RETURN_CCTOR(route);
}
/**
* Adds a route to the router that only match if the HTTP method is HEAD
*
* @param string $pattern
* @param string/array $paths
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, addHead){
zval *pattern, *paths = NULL, *method, *route;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &pattern, &paths) == FAILURE) {
RETURN_MM_NULL();
}
if (!paths) {
PHALCON_INIT_VAR(paths);
}
PHALCON_INIT_VAR(method);
ZVAL_STRING(method, "HEAD", 1);
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_3(route, this_ptr, "_addroute", pattern, paths, method);
RETURN_CCTOR(route);
}
/**
* Modifies a table column based on a definition
*
* @param string $tableName
* @param string $schemaName
* @param Phalcon\Db\Column $column
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, modifyColumn){
zval *table_name = NULL, *schema_name = NULL, *column = NULL, *sql = NULL;
zval *t0 = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &table_name, &schema_name, &column) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_dialect"), PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CALL_METHOD_PARAMS_3(sql, t0, "modifycolumn", table_name, schema_name, column, PH_NO_CHECK);
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_1(r0, this_ptr, "execute", sql, PH_NO_CHECK);
RETURN_CTOR(r0);
}
/**
* Adds a route to the router on any HTTP method
*
*<code>
* $router->add('/about', 'About::index');
*</code>
*
* @param string $pattern
* @param string/array $paths
* @param string $httpMethods
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router_Group, add){
zval *pattern, *paths = NULL, *http_methods = NULL, *route;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &pattern, &paths, &http_methods) == FAILURE) {
RETURN_MM_NULL();
}
if (!paths) {
PHALCON_INIT_VAR(paths);
}
if (!http_methods) {
PHALCON_INIT_VAR(http_methods);
}
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_3(route, this_ptr, "_addroute", pattern, paths, http_methods);
RETURN_CCTOR(route);
}
/**
* Gets belongsTo related records from a model
*
* @param string $method
* @param string $modelName
* @param string $modelRelation
* @param Phalcon\Mvc\Model $record
* @return Phalcon\Mvc\Model\Resultset
*/
PHP_METHOD(Phalcon_Mvc_Model_Manager, getHasOneRecords){
zval *method = NULL, *model_name = NULL, *model_relation = NULL, *record = NULL;
zval *has_one = NULL, *relation = NULL, *records = NULL;
zval *r0 = NULL, *r1 = NULL;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzz", &method, &model_name, &model_relation, &record) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(has_one);
phalcon_read_property(&has_one, this_ptr, SL("_hasOne"), PH_NOISY_CC);
eval_int = phalcon_array_isset(has_one, model_name);
if (eval_int) {
PHALCON_ALLOC_ZVAL_MM(r0);
phalcon_array_fetch(&r0, has_one, model_name, PH_NOISY_CC);
eval_int = phalcon_array_isset(r0, model_relation);
if (!eval_int) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_ALLOC_ZVAL_MM(r1);
phalcon_array_fetch(&r1, has_one, model_name, PH_NOISY_CC);
PHALCON_INIT_VAR(relation);
phalcon_array_fetch(&relation, r1, model_relation, PH_NOISY_CC);
PHALCON_INIT_VAR(records);
PHALCON_CALL_METHOD_PARAMS_3(records, this_ptr, "_getrelationrecords", relation, method, record, PH_NO_CHECK);
RETURN_CCTOR(records);
}
/**
* Throws an internal exception
*
* @param string $message
* @param int $exceptionCode
*/
PHP_METHOD(Phalcon_CLI_Dispatcher, _throwDispatchException){
zval *message, *exception_code = NULL, *exception, *events_manager;
zval *event_name, *status;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &message, &exception_code) == FAILURE) {
RETURN_MM_NULL();
}
if (!exception_code) {
PHALCON_INIT_VAR(exception_code);
ZVAL_LONG(exception_code, 0);
}
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_cli_dispatcher_exception_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", message, exception_code);
PHALCON_OBS_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "dispatch:beforeException", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, exception);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_FALSE;
}
}
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
/**
* Add a route to the router that only match if the HTTP method is HEAD
*
* @param string $pattern
* @param string/array $paths
* @return Phalcon\Mvc\Router\Route
*/
PHP_METHOD(Phalcon_Mvc_Router, addHead){
zval *pattern = NULL, *paths = NULL, *route = NULL;
zval *c0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &pattern, &paths) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!paths) {
PHALCON_ALLOC_ZVAL_MM(paths);
ZVAL_NULL(paths);
}
PHALCON_INIT_VAR(c0);
ZVAL_STRING(c0, "HEAD", 1);
PHALCON_INIT_VAR(route);
PHALCON_CALL_METHOD_PARAMS_3(route, this_ptr, "add", pattern, paths, c0, PH_NO_CHECK);
RETURN_CCTOR(route);
}
/**
* Moves internal resulset cursor to another position letting us to fetch a certain row
*
*<code>
* $result = $connection->query("SELECT * FROM robots ORDER BY name");
* $result->dataSeek(2); // Move to third row on result
* $row = $result->fetch(); // Fetch third row
*</code>
*
* @param int $number
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, dataSeek){
long number = 0, n;
zval *connection, *pdo, *sql_statement;
zval *bind_params, *bind_types, *statement = NULL;
zval *temp_statement = NULL;
pdo_stmt_t *stmt;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &number) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(connection);
phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
PHALCON_INIT_VAR(pdo);
PHALCON_CALL_METHOD(pdo, connection, "getinternalhandler", PH_NO_CHECK);
PHALCON_INIT_VAR(sql_statement);
phalcon_read_property(&sql_statement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC);
PHALCON_INIT_VAR(bind_params);
phalcon_read_property(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY_CC);
/**
* PDO doesn't support scrollable cursors, so we need to re-execute the statement again
*/
if (Z_TYPE_P(bind_params) == IS_ARRAY) {
PHALCON_INIT_VAR(bind_types);
phalcon_read_property(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY_CC);
PHALCON_INIT_VAR(statement);
PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK);
if (Z_TYPE_P(statement) == IS_OBJECT) {
PHALCON_INIT_VAR(temp_statement);
PHALCON_CALL_METHOD_PARAMS_3(temp_statement, connection, "executeprepared", statement, bind_params, bind_types, PH_NO_CHECK);
PHALCON_CPY_WRT(statement, temp_statement);
}
} else {
PHALCON_INIT_NVAR(statement);
PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "query", sql_statement, PH_NO_CHECK);
}
phalcon_update_property_zval(this_ptr, SL("_pdoStatement"), statement TSRMLS_CC);
/**
* This a fetch scroll to reach the desired position, however with a big number of records
* maybe it may be very slow
*/
stmt = (pdo_stmt_t*) zend_object_store_get_object(statement TSRMLS_CC);
if (!stmt->dbh) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
n = -1;
number--;
while (n != number) {
if(!stmt->methods->fetcher(stmt, PDO_FETCH_ORI_NEXT, 0 TSRMLS_CC)) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
n++;
}
PHALCON_MM_RESTORE();
}
/**
* Resolves the service
*
* @param array $parameters
* @param Phalcon\DiInterface $dependencyInjector
* @return mixed
*/
PHP_METHOD(Phalcon_DI_Service, resolve){
zval *parameters = NULL, *dependency_injector = NULL, *shared;
zval *shared_instance, *found = NULL, *instance = NULL, *definition;
zval *builder, *name, *exception_message;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", ¶meters, &dependency_injector) == FAILURE) {
RETURN_MM_NULL();
}
if (!parameters) {
PHALCON_INIT_VAR(parameters);
}
if (!dependency_injector) {
PHALCON_INIT_VAR(dependency_injector);
}
PHALCON_OBS_VAR(shared);
phalcon_read_property(&shared, this_ptr, SL("_shared"), PH_NOISY_CC);
/**
* Check if the service is shared
*/
if (zend_is_true(shared)) {
PHALCON_OBS_VAR(shared_instance);
phalcon_read_property(&shared_instance, this_ptr, SL("_sharedInstance"), PH_NOISY_CC);
if (Z_TYPE_P(shared_instance) != IS_NULL) {
RETURN_CCTOR(shared_instance);
}
}
PHALCON_INIT_VAR(found);
ZVAL_BOOL(found, 1);
PHALCON_INIT_VAR(instance);
PHALCON_OBS_VAR(definition);
phalcon_read_property(&definition, this_ptr, SL("_definition"), PH_NOISY_CC);
if (Z_TYPE_P(definition) == IS_STRING) {
/**
* String definitions can be class names without implicit parameters
*/
if (phalcon_class_exists(definition TSRMLS_CC)) {
if (Z_TYPE_P(parameters) == IS_ARRAY) {
if (phalcon_fast_count_ev(parameters TSRMLS_CC)) {
if (phalcon_create_instance_params(instance, definition, parameters TSRMLS_CC) == FAILURE) {
return;
}
} else {
PHALCON_INIT_NVAR(instance);
if (phalcon_create_instance(instance, definition TSRMLS_CC) == FAILURE) {
return;
}
}
} else {
PHALCON_INIT_NVAR(instance);
if (phalcon_create_instance(instance, definition TSRMLS_CC) == FAILURE) {
return;
}
}
} else {
ZVAL_BOOL(found, 0);
}
} else {
/**
* Object definitions can be a Closure or an already resolved instance
*/
if (Z_TYPE_P(definition) == IS_OBJECT) {
if (phalcon_is_instance_of(definition, SL("Closure") TSRMLS_CC)) {
if (Z_TYPE_P(parameters) == IS_ARRAY) {
PHALCON_INIT_NVAR(instance);
PHALCON_CALL_USER_FUNC_ARRAY(instance, definition, parameters);
} else {
PHALCON_INIT_NVAR(instance);
PHALCON_CALL_USER_FUNC(instance, definition);
}
} else {
PHALCON_CPY_WRT(instance, definition);
}
} else {
/**
* Array definitions require a 'className' parameter
*/
if (Z_TYPE_P(definition) == IS_ARRAY) {
PHALCON_INIT_VAR(builder);
object_init_ex(builder, phalcon_di_service_builder_ce);
PHALCON_INIT_NVAR(instance);
PHALCON_CALL_METHOD_PARAMS_3(instance, builder, "build", dependency_injector, definition, parameters);
RETURN_CCTOR(instance);
} else {
ZVAL_BOOL(found, 0);
}
}
}
/**
* If the service can't be built, we must throw an exception
*/
if (PHALCON_IS_FALSE(found)) {
PHALCON_OBS_VAR(name);
phalcon_read_property(&name, this_ptr, SL("_name"), PH_NOISY_CC);
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Service '", name, "' cannot be resolved");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_di_exception_ce, exception_message);
return;
}
if (zend_is_true(shared)) {
phalcon_update_property_zval(this_ptr, SL("_sharedInstance"), instance TSRMLS_CC);
}
RETURN_CCTOR(instance);
}
/**
* Updates data on a table using custom RBDM SQL syntax
*
* <code>
* //Updating existing robot
* $success = $connection->update(
* "robots",
* array("name")
* array("New Astro Boy"),
* "id = 101"
* );
*
* //Next SQL sentence is sent to the database system
* UPDATE `robots` SET `name` = "Astro boy" WHERE id = 101
* </code>
*
* @param string $table
* @param array $fields
* @param array $values
* @param string $whereCondition
* @param array $dataTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, update){
zval *table, *fields, *values, *where_condition = NULL;
zval *data_types = NULL, *placeholders, *update_values;
zval *bind_data_types = NULL, *value = NULL, *position = NULL, *field = NULL;
zval *set_clause_part = NULL, *bind_type = NULL, *set_clause;
zval *update_sql = NULL, *success;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|zz", &table, &fields, &values, &where_condition, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!where_condition) {
PHALCON_INIT_NVAR(where_condition);
}
if (!data_types) {
PHALCON_INIT_NVAR(data_types);
}
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_INIT_VAR(update_values);
array_init(update_values);
if (Z_TYPE_P(data_types) == IS_ARRAY) {
PHALCON_INIT_VAR(bind_data_types);
array_init(bind_data_types);
} else {
PHALCON_CPY_WRT(bind_data_types, data_types);
}
if (!phalcon_valid_foreach(values TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(values);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(position, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
eval_int = phalcon_array_isset(fields, position);
if (eval_int) {
PHALCON_INIT_NVAR(field);
phalcon_array_fetch(&field, fields, position, PH_NOISY_CC);
if (Z_TYPE_P(value) == IS_OBJECT) {
PHALCON_INIT_NVAR(set_clause_part);
PHALCON_CONCAT_VSV(set_clause_part, field, " = ", value);
phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
PHALCON_INIT_NVAR(set_clause_part);
PHALCON_CONCAT_VS(set_clause_part, field, " = null");
} else {
PHALCON_INIT_NVAR(set_clause_part);
PHALCON_CONCAT_VS(set_clause_part, field, " = ?");
phalcon_array_append(&update_values, value, PH_SEPARATE TSRMLS_CC);
if (Z_TYPE_P(data_types) == IS_ARRAY) {
eval_int = phalcon_array_isset(data_types, position);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Incomplete number of bind types");
return;
}
PHALCON_INIT_NVAR(bind_type);
phalcon_array_fetch(&bind_type, data_types, position, PH_NOISY_CC);
phalcon_array_append(&bind_data_types, bind_type, PH_SEPARATE TSRMLS_CC);
}
}
phalcon_array_append(&placeholders, set_clause_part, PH_SEPARATE TSRMLS_CC);
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The number of values in the update is not the same as fields");
return;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(set_clause);
phalcon_fast_join_str(set_clause, SL(", "), placeholders TSRMLS_CC);
if (Z_TYPE_P(where_condition) != IS_NULL) {
PHALCON_INIT_VAR(update_sql);
PHALCON_CONCAT_SVSVSV(update_sql, "UPDATE ", table, " SET ", set_clause, " WHERE ", where_condition);
} else {
PHALCON_INIT_NVAR(update_sql);
PHALCON_CONCAT_SVSV(update_sql, "UPDATE ", table, " SET ", set_clause);
}
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_3(success, this_ptr, "execute", update_sql, update_values, bind_data_types, PH_NO_CHECK);
RETURN_CCTOR(success);
}
/**
* Inserts data into a table using custom RBDM SQL syntax
*
* <code>
* //Inserting a new robot
* $success = $connection->insert(
* "robots",
* array("Astro Boy", 1952),
* array("name", "year")
* );
*
* //Next SQL sentence is sent to the database system
* INSERT INTO `robots` (`name`, `year`) VALUES ("Astro boy", 1952);
* </code>
*
* @param string $table
* @param array $values
* @param array $fields
* @param array $dataTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db, insert){
zval *table, *values, *fields = NULL, *data_types = NULL, *exception_message;
zval *placeholders, *insert_values, *bind_data_types = NULL;
zval *value = NULL, *position = NULL, *str_value = NULL, *bind_type = NULL;
zval *joined_values, *joined_fields, *insert_sql = NULL;
zval *success;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &table, &values, &fields, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!fields) {
PHALCON_INIT_NVAR(fields);
}
if (!data_types) {
PHALCON_INIT_NVAR(data_types);
}
if (Z_TYPE_P(values) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "The second parameter for insert isn't an Array");
return;
}
if (!phalcon_fast_count_ev(values TSRMLS_CC)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Unable to insert into ", table, " without data");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_db_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(placeholders);
array_init(placeholders);
PHALCON_INIT_VAR(insert_values);
array_init(insert_values);
if (Z_TYPE_P(data_types) == IS_ARRAY) {
PHALCON_INIT_VAR(bind_data_types);
array_init(bind_data_types);
} else {
PHALCON_CPY_WRT(bind_data_types, data_types);
}
if (!phalcon_valid_foreach(values TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(values);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(position, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(value) == IS_OBJECT) {
PHALCON_INIT_NVAR(str_value);
PHALCON_CALL_FUNC_PARAMS_1(str_value, "strval", value);
phalcon_array_append(&placeholders, str_value, PH_SEPARATE TSRMLS_CC);
} else {
if (Z_TYPE_P(value) == IS_NULL) {
phalcon_array_append_string(&placeholders, SL("null"), PH_SEPARATE TSRMLS_CC);
} else {
phalcon_array_append_string(&placeholders, SL("?"), PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&insert_values, value, PH_SEPARATE TSRMLS_CC);
if (Z_TYPE_P(data_types) == IS_ARRAY) {
eval_int = phalcon_array_isset(data_types, position);
if (!eval_int) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Incomplete number of bind types");
return;
}
PHALCON_INIT_NVAR(bind_type);
phalcon_array_fetch(&bind_type, data_types, position, PH_NOISY_CC);
phalcon_array_append(&bind_data_types, bind_type, PH_SEPARATE TSRMLS_CC);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
PHALCON_INIT_VAR(joined_values);
phalcon_fast_join_str(joined_values, SL(", "), placeholders TSRMLS_CC);
if (Z_TYPE_P(fields) == IS_ARRAY) {
PHALCON_INIT_VAR(joined_fields);
phalcon_fast_join_str(joined_fields, SL(", "), fields TSRMLS_CC);
PHALCON_INIT_VAR(insert_sql);
PHALCON_CONCAT_SVSVSVS(insert_sql, "INSERT INTO ", table, " (", joined_fields, ") VALUES (", joined_values, ")");
} else {
PHALCON_INIT_NVAR(insert_sql);
PHALCON_CONCAT_SVSVS(insert_sql, "INSERT INTO ", table, " VALUES (", joined_values, ")");
}
PHALCON_INIT_VAR(success);
PHALCON_CALL_METHOD_PARAMS_3(success, this_ptr, "execute", insert_sql, insert_values, bind_data_types, PH_NO_CHECK);
RETURN_CCTOR(success);
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server don't return any row
*
*<code>
* //Inserting data
* $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
* $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
*</code>
*
* @param string $sqlStatement
* @param array $placeholders
* @param array $dataTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){
zval *sql_statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *events_manager = NULL, *event_name = NULL, *status = NULL, *pdo = NULL;
zval *statement = NULL, *affected_rows = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &sql_statement, &placeholders, &data_types) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!placeholders) {
PHALCON_ALLOC_ZVAL_MM(placeholders);
ZVAL_NULL(placeholders);
}
if (!data_types) {
PHALCON_ALLOC_ZVAL_MM(data_types);
ZVAL_NULL(data_types);
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:beforeQuery", 1);
phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, placeholders, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(placeholders) == IS_ARRAY) {
PHALCON_INIT_VAR(statement);
PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement, PH_NO_CHECK);
if (Z_TYPE_P(statement) == IS_OBJECT) {
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_CALL_METHOD_PARAMS_3(r0, this_ptr, "_executeprepared", statement, placeholders, data_types, PH_NO_CHECK);
PHALCON_CPY_WRT(statement, r0);
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD(affected_rows, statement, "rowcount", PH_NO_CHECK);
}
} else {
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement, PH_NO_CHECK);
}
if (Z_TYPE_P(affected_rows) == IS_LONG) {
phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:afterQuery", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, placeholders, PH_NO_CHECK);
}
}
PHALCON_MM_RESTORE();
RETURN_TRUE;
}
/**
* Checks whether view exists on registered extensions and render it
*
* @param array $engines
* @param string $viewPath
* @param boolean $silence
* @param boolean $mustClean
* @param Phalcon\Cache\Backend $cache
*/
PHP_METHOD(Phalcon_Mvc_View, _engineRender){
zval *engines, *view_path, *silence, *must_clean;
zval *cache, *not_exists = NULL, *view_params, *views_dir;
zval *base_path, *views_dir_path, *events_manager;
zval *render_level, *cache_level, *enter_cache;
zval *is_started, *key = NULL, *view_options, *cache_options;
zval *cached_view, *is_fresh, *engine = NULL, *extension = NULL;
zval *view_engine_path = NULL, *event_name = NULL, *status = NULL;
zval *exception_message;
HashTable *ah0;
HashPosition hp0;
zval **hd;
char *hash_index;
uint hash_index_len;
ulong hash_num;
int hash_type;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzzz", &engines, &view_path, &silence, &must_clean, &cache) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
PHALCON_INIT_VAR(not_exists);
ZVAL_BOOL(not_exists, 1);
PHALCON_INIT_VAR(view_params);
phalcon_read_property(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir);
phalcon_read_property(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC);
PHALCON_INIT_VAR(base_path);
phalcon_read_property(&base_path, this_ptr, SL("_basePath"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir_path);
PHALCON_CONCAT_VVV(views_dir_path, base_path, views_dir, view_path);
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_INIT_VAR(render_level);
phalcon_read_property(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
PHALCON_INIT_VAR(cache_level);
phalcon_read_property(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
PHALCON_INIT_VAR(enter_cache);
is_smaller_or_equal_function(enter_cache, cache_level, render_level TSRMLS_CC);
if (zend_is_true(enter_cache)) {
PHALCON_INIT_VAR(is_started);
PHALCON_CALL_METHOD(is_started, cache, "isstarted", PH_NO_CHECK);
if (PHALCON_IS_FALSE(is_started)) {
PHALCON_INIT_VAR(key);
PHALCON_INIT_VAR(view_options);
phalcon_read_property(&view_options, this_ptr, SL("_options"), PH_NOISY_CC);
if (Z_TYPE_P(view_options) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(view_options, SS("cache"));
if (eval_int) {
PHALCON_INIT_VAR(cache_options);
phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC);
if (Z_TYPE_P(cache_options) == IS_ARRAY) {
eval_int = phalcon_array_isset_string(cache_options, SS("key"));
if (eval_int) {
phalcon_array_fetch_string(&key, cache_options, SL("key"), PH_NOISY_CC);
}
}
}
}
if (Z_TYPE_P(key) == IS_NULL) {
PHALCON_INIT_NVAR(key);
PHALCON_CALL_FUNC_PARAMS_1(key, "md5", view_path);
}
PHALCON_INIT_VAR(cached_view);
PHALCON_CALL_METHOD_PARAMS_1(cached_view, cache, "start", key, PH_NO_CHECK);
if (Z_TYPE_P(cached_view) != IS_NULL) {
phalcon_update_property_zval(this_ptr, SL("_content"), cached_view TSRMLS_CC);
PHALCON_MM_RESTORE();
RETURN_NULL();
}
}
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh", PH_NO_CHECK);
if (!zend_is_true(is_fresh)) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
}
}
if (!phalcon_valid_foreach(engines TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(engines);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_KEY(extension, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(engine);
PHALCON_INIT_NVAR(view_engine_path);
PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension);
if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:beforeRenderView", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, view_engine_path, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
}
}
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(engine, "render", view_engine_path, view_params, must_clean, PH_NO_CHECK);
PHALCON_INIT_NVAR(not_exists);
ZVAL_BOOL(not_exists, 0);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRenderView", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_2(status, events_manager, "fire", event_name, this_ptr, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
}
}
goto ph_cycle_end_0;
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if (PHALCON_IS_TRUE(not_exists)) {
if (!zend_is_true(silence)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
}
PHALCON_MM_RESTORE();
}
/**
* Fires a event in the events manager causing that the acive listeners will be notified about it
*
* @param string $eventType
* @param object $source
* @param mixed $data
* @return mixed
*/
PHP_METHOD(Phalcon_Events_Manager, fire){
zval *event_type, *source, *data = NULL, *events, *exception_message;
zval *colon, *event_parts, *type, *event_name, *status = NULL;
zval *fire_events = NULL, *handler = NULL, *event = NULL, *arguments = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|z", &event_type, &source, &data) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!data) {
PHALCON_INIT_NVAR(data);
}
if (Z_TYPE_P(event_type) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_events_exception_ce, "Event type must be a string");
return;
}
PHALCON_INIT_VAR(events);
phalcon_read_property(&events, this_ptr, SL("_events"), PH_NOISY_CC);
if (Z_TYPE_P(events) != IS_ARRAY) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!phalcon_memnstr_str(event_type, SL(":") TSRMLS_CC)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid event type ", event_type);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_events_exception_ce, exception_message);
return;
}
PHALCON_INIT_VAR(colon);
ZVAL_STRING(colon, ":", 1);
PHALCON_INIT_VAR(event_parts);
phalcon_fast_explode(event_parts, colon, event_type TSRMLS_CC);
PHALCON_INIT_VAR(type);
phalcon_array_fetch_long(&type, event_parts, 0, PH_NOISY_CC);
PHALCON_INIT_VAR(event_name);
phalcon_array_fetch_long(&event_name, event_parts, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(status);
eval_int = phalcon_array_isset(events, type);
if (eval_int) {
PHALCON_INIT_VAR(fire_events);
phalcon_array_fetch(&fire_events, events, type, PH_NOISY_CC);
if (Z_TYPE_P(fire_events) == IS_ARRAY) {
if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(fire_events);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
ph_cycle_start_0:
if (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS) {
goto ph_cycle_end_0;
}
PHALCON_GET_FOREACH_VALUE(handler);
if (Z_TYPE_P(handler) == IS_OBJECT) {
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
} else {
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK);
}
}
}
zend_hash_move_forward_ex(ah0, &hp0);
goto ph_cycle_start_0;
ph_cycle_end_0:
if(0){}
}
}
eval_int = phalcon_array_isset(events, event_type);
if (eval_int) {
PHALCON_INIT_NVAR(fire_events);
phalcon_array_fetch(&fire_events, events, event_type, PH_NOISY_CC);
if (Z_TYPE_P(fire_events) == IS_ARRAY) {
if (!phalcon_valid_foreach(fire_events TSRMLS_CC)) {
return;
}
ah1 = Z_ARRVAL_P(fire_events);
zend_hash_internal_pointer_reset_ex(ah1, &hp1);
ph_cycle_start_1:
if (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) != SUCCESS) {
goto ph_cycle_end_1;
}
PHALCON_GET_FOREACH_VALUE(handler);
if (Z_TYPE_P(handler) == IS_OBJECT) {
if (phalcon_is_instance_of(handler, SL("Closure") TSRMLS_CC)) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(arguments);
array_init(arguments);
phalcon_array_append(&arguments, event, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, source, PH_SEPARATE TSRMLS_CC);
phalcon_array_append(&arguments, data, PH_SEPARATE TSRMLS_CC);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_USER_FUNC_ARRAY(status, handler, arguments);
} else {
if (phalcon_method_exists(handler, event_name TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_NVAR(event);
object_init_ex(event, phalcon_events_event_ce);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(event, "__construct", event_name, source, data, PH_CHECK);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, handler, Z_STRVAL_P(event_name), event, source, data, PH_NO_CHECK);
}
}
}
zend_hash_move_forward_ex(ah1, &hp1);
goto ph_cycle_start_1;
ph_cycle_end_1:
if(0){}
}
}
RETURN_CCTOR(status);
}
/**
* Checks whether view exists on registered extensions and render it
*
* @param array $engines
* @param string $viewPath
* @param boolean $silence
* @param boolean $mustClean
* @param Phalcon\Cache\BackendInterface $cache
*/
PHP_METHOD(Phalcon_Mvc_View, _engineRender){
zval *engines, *view_path, *silence, *must_clean;
zval *cache, *not_exists = NULL, *view_params, *views_dir;
zval *base_path, *views_dir_path, *events_manager;
zval *render_level, *cache_level, *enter_cache;
zval *is_started, *key = NULL, *lifetime = NULL, *view_options;
zval *cache_options, *cached_view, *is_fresh;
zval *engine = NULL, *extension = NULL, *view_engine_path = NULL;
zval *event_name = NULL, *status = NULL, *exception_message;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 5, 0, &engines, &view_path, &silence, &must_clean, &cache);
PHALCON_INIT_VAR(not_exists);
ZVAL_BOOL(not_exists, 1);
PHALCON_OBS_VAR(view_params);
phalcon_read_property_this(&view_params, this_ptr, SL("_viewParams"), PH_NOISY_CC);
PHALCON_OBS_VAR(views_dir);
phalcon_read_property_this(&views_dir, this_ptr, SL("_viewsDir"), PH_NOISY_CC);
PHALCON_OBS_VAR(base_path);
phalcon_read_property_this(&base_path, this_ptr, SL("_basePath"), PH_NOISY_CC);
PHALCON_INIT_VAR(views_dir_path);
PHALCON_CONCAT_VVV(views_dir_path, base_path, views_dir, view_path);
PHALCON_OBS_VAR(events_manager);
phalcon_read_property_this(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(cache) == IS_OBJECT) {
PHALCON_OBS_VAR(render_level);
phalcon_read_property_this(&render_level, this_ptr, SL("_renderLevel"), PH_NOISY_CC);
PHALCON_OBS_VAR(cache_level);
phalcon_read_property_this(&cache_level, this_ptr, SL("_cacheLevel"), PH_NOISY_CC);
/**
* Evaluate if we need to enter in 'cache' mode
*/
PHALCON_INIT_VAR(enter_cache);
is_smaller_or_equal_function(enter_cache, cache_level, render_level TSRMLS_CC);
if (zend_is_true(enter_cache)) {
/**
* 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(view_options);
phalcon_read_property_this(&view_options, this_ptr, SL("_options"), PH_NOISY_CC);
/**
* Check if the user has defined a different options to the default
*/
if (Z_TYPE_P(view_options) == IS_ARRAY) {
if (phalcon_array_isset_string(view_options, SS("cache"))) {
PHALCON_OBS_VAR(cache_options);
phalcon_array_fetch_string(&cache_options, view_options, SL("cache"), PH_NOISY_CC);
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_CC);
}
if (phalcon_array_isset_string(cache_options, SS("lifetime"))) {
PHALCON_OBS_NVAR(lifetime);
phalcon_array_fetch_string(&lifetime, cache_options, SL("lifetime"), PH_NOISY_CC);
}
}
}
}
/**
* 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_CALL_FUNC_PARAMS_1(key, "md5", view_path);
}
/**
* We start the cache using the key set
*/
PHALCON_INIT_VAR(cached_view);
PHALCON_CALL_METHOD_PARAMS_2(cached_view, cache, "start", key, lifetime);
if (Z_TYPE_P(cached_view) != IS_NULL) {
phalcon_update_property_this(this_ptr, SL("_content"), cached_view TSRMLS_CC);
RETURN_MM_NULL();
}
}
/**
* This method only returns true if the cache has not expired
*/
PHALCON_INIT_VAR(is_fresh);
PHALCON_CALL_METHOD(is_fresh, cache, "isfresh");
if (!zend_is_true(is_fresh)) {
RETURN_MM_NULL();
}
}
}
/**
* Views are rendered in each engine
*/
if (!phalcon_is_iterable(engines, &ah0, &hp0, 0, 0 TSRMLS_CC)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(extension, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(engine);
PHALCON_INIT_NVAR(view_engine_path);
PHALCON_CONCAT_VV(view_engine_path, views_dir_path, extension);
if (phalcon_file_exists(view_engine_path TSRMLS_CC) == SUCCESS) {
/**
* Call beforeRenderView if there is a events manager available
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:beforeRenderView", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, view_engine_path);
if (PHALCON_IS_FALSE(status)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
}
}
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(engine, "render", view_engine_path, view_params, must_clean);
/**
* Call afterRenderView if there is a events manager available
*/
PHALCON_INIT_NVAR(not_exists);
ZVAL_BOOL(not_exists, 0);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:afterRenderView", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
break;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
if (PHALCON_IS_TRUE(not_exists)) {
/**
* Notify about not found views
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_this(this_ptr, SL("_activeRenderPath"), view_engine_path TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "view:notFoundView", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(events_manager, "fire", event_name, this_ptr);
}
if (!zend_is_true(silence)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "View '", views_dir_path, "' was not found in the views directory");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_view_exception_ce, exception_message);
return;
}
}
PHALCON_MM_RESTORE();
}
/**
* Dispatches a controller action taking into account the routing parameters
*
* @param Phalcon_Request $request
* @param Phalcon_Response $response
* @param Phalcon_View $view
* @param Phalcon_Model_Manager $model
* @return Phalcon_Controller
*/
PHP_METHOD(Phalcon_Dispatcher, dispatch){
zval *request = NULL, *response = NULL, *view = NULL, *model = NULL, *controllers_dir = NULL;
zval *value = NULL, *controller = NULL, *number_dispatches = NULL;
zval *controller_name = NULL, *controllers = NULL, *controller_class = NULL;
zval *controller_path = NULL, *params = NULL, *action_name = NULL;
zval *action_method = 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;
zval *t0 = NULL, *t1 = NULL, *t2 = NULL, *t3 = NULL, *t4 = NULL, *t5 = NULL, *t6 = NULL;
zval *t7 = NULL, *t8 = NULL, *t9 = NULL, *t10 = NULL;
zval *c0 = NULL, *c1 = NULL, *c2 = NULL;
zval *i0 = NULL;
zval *a0 = NULL, *a1 = NULL;
zval *p0[] = { NULL, NULL, NULL, NULL, NULL };
int eval_int;
zend_class_entry *ce0;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|zz", &request, &response, &view, &model) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!view) {
PHALCON_INIT_VAR(view);
ZVAL_NULL(view);
}
if (!model) {
PHALCON_INIT_VAR(model);
ZVAL_NULL(model);
}
PHALCON_ALLOC_ZVAL_MM(r0);
PHALCON_ALLOC_ZVAL_MM(t0);
phalcon_read_property(&t0, this_ptr, SL("_basePath"), PHALCON_NOISY TSRMLS_CC);
PHALCON_ALLOC_ZVAL_MM(t1);
phalcon_read_property(&t1, this_ptr, SL("_controllersDir"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CONCAT_VV(r0, t0, t1);
PHALCON_CPY_WRT(controllers_dir, r0);
PHALCON_INIT_VAR(value);
ZVAL_NULL(value);
PHALCON_INIT_VAR(controller);
ZVAL_NULL(controller);
PHALCON_INIT_VAR(number_dispatches);
ZVAL_LONG(number_dispatches, 0);
phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC);
ws_e10f_0:
PHALCON_INIT_VAR(t2);
phalcon_read_property(&t2, this_ptr, SL("_finished"), PHALCON_NOISY TSRMLS_CC);
if (zend_is_true(t2)) {
goto we_e10f_0;
}
phalcon_update_property_bool(this_ptr, SL("_finished"), 1 TSRMLS_CC);
PHALCON_INIT_VAR(t3);
phalcon_read_property(&t3, this_ptr, SL("_controllerName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t3);
if (!zend_is_true(controller_name)) {
PHALCON_INIT_VAR(t4);
phalcon_read_property(&t4, this_ptr, SL("_defaultController"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller_name, t4);
phalcon_update_property_zval(this_ptr, SL("_controllerName"), controller_name TSRMLS_CC);
}
PHALCON_INIT_VAR(t5);
phalcon_read_property(&t5, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controllers, t5);
PHALCON_INIT_VAR(r1);
PHALCON_INIT_VAR(r2);
PHALCON_CALL_STATIC_PARAMS_1(r2, "phalcon_text", "camelize", controller_name);
PHALCON_CONCAT_VS(r1, r2, "Controller");
PHALCON_CPY_WRT(controller_class, r1);
eval_int = phalcon_array_isset(controllers, controller_class);
if (!eval_int) {
PHALCON_INIT_VAR(c0);
ZVAL_BOOL(c0, 0);
PHALCON_INIT_VAR(r3);
PHALCON_CALL_FUNC_PARAMS_2(r3, "class_exists", controller_class, c0);
if (!zend_is_true(r3)) {
PHALCON_INIT_VAR(r4);
PHALCON_CONCAT_VVS(r4, controllers_dir, controller_class, ".php");
PHALCON_CPY_WRT(controller_path, r4);
if (phalcon_file_exists(controller_path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(controller_path TSRMLS_CC) == FAILURE) {
return;
}
} else {
PHALCON_INIT_VAR(r5);
PHALCON_CONCAT_SVS(r5, "File for controller class ", controller_class, " doesn't exist");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r5, PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(c1);
ZVAL_BOOL(c1, 0);
PHALCON_INIT_VAR(r6);
PHALCON_CALL_FUNC_PARAMS_2(r6, "class_exists", controller_class, c1);
if (!zend_is_true(r6)) {
PHALCON_INIT_VAR(r7);
PHALCON_CONCAT_SVS(r7, "Class ", controller_class, " was not found on controller file");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r7, PHALCON_NO_CHECK);
}
}
ce0 = phalcon_fetch_class(controller_class TSRMLS_CC);
PHALCON_INIT_VAR(i0);
object_init_ex(i0, ce0);
p0[0] = this_ptr;
p0[1] = request;
p0[2] = response;
p0[3] = view;
p0[4] = model;
PHALCON_CALL_METHOD_PARAMS_NORETURN(i0, "__construct", 5, p0, PHALCON_CHECK);
PHALCON_CPY_WRT(controller, i0);
if (phalcon_method_exists_ex(controller, SL("initialize") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_NORETURN(controller, "initialize", PHALCON_NO_CHECK);
}
PHALCON_INIT_VAR(t6);
phalcon_read_property(&t6, this_ptr, SL("_controllers"), PHALCON_NOISY TSRMLS_CC);
phalcon_array_update(&t6, controller_class, &controller, PHALCON_NO_SEPARATE_THX, PHALCON_COPY, PHALCON_NO_CTOR TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_controllers"), t6 TSRMLS_CC);
} else {
PHALCON_INIT_VAR(r8);
phalcon_array_fetch(&r8, controllers, controller_class, PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(controller, r8);
}
PHALCON_INIT_VAR(t7);
phalcon_read_property(&t7, this_ptr, SL("_params"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(params, t7);
PHALCON_INIT_VAR(t8);
phalcon_read_property(&t8, this_ptr, SL("_actionName"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t8);
if (!zend_is_true(action_name)) {
PHALCON_INIT_VAR(t9);
phalcon_read_property(&t9, this_ptr, SL("_defaultAction"), PHALCON_NOISY TSRMLS_CC);
PHALCON_CPY_WRT(action_name, t9);
phalcon_update_property_zval(this_ptr, SL("_actionName"), action_name TSRMLS_CC);
}
if (phalcon_method_exists_ex(controller, SL("beforedispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(r9);
PHALCON_CALL_METHOD_PARAMS_3(r9, controller, "beforedispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
if (Z_TYPE_P(r9) == IS_BOOL && !Z_BVAL_P(r9)) {
PHALCON_INIT_VAR(value);
ZVAL_BOOL(value, 0);
goto we_e10f_0;
}
}
PHALCON_INIT_VAR(r10);
PHALCON_CONCAT_VS(r10, action_name, "Action");
PHALCON_CPY_WRT(action_method, r10);
if (phalcon_method_exists(controller, action_method TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a0);
array_init(a0);
phalcon_array_append(&a0, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
phalcon_array_append(&a0, action_method, PHALCON_SEPARATE_PLZ TSRMLS_CC);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a0, params);
} else {
if (phalcon_method_exists_ex(controller, SL("notfoundaction") TSRMLS_CC) == SUCCESS) {
PHALCON_INIT_VAR(a1);
array_init(a1);
phalcon_array_append(&a1, controller, PHALCON_SEPARATE_PLZ TSRMLS_CC);
add_next_index_stringl(a1, SL("notFoundAction"), 1);
PHALCON_INIT_VAR(value);
PHALCON_CALL_FUNC_PARAMS_2(value, "call_user_func_array", a1, params);
} else {
PHALCON_INIT_VAR(r11);
PHALCON_CONCAT_SVSVS(r11, "Action '", action_name, "' was not found on controller '", controller_name, "'");
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, r11, PHALCON_NO_CHECK);
}
}
if (phalcon_method_exists_ex(controller, SL("afterdispatch") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(controller, "afterdispatch", controller_name, action_name, params, PHALCON_NO_CHECK);
}
PHALCON_SEPARATE(number_dispatches);
increment_function(number_dispatches);
PHALCON_INIT_VAR(t10);
ZVAL_LONG(t10, 256);
PHALCON_INIT_VAR(r12);
is_smaller_function(r12, t10, number_dispatches TSRMLS_CC);
if (zend_is_true(r12)) {
PHALCON_INIT_VAR(c2);
ZVAL_STRING(c2, "Dispatcher has detected a cyclic routing causing stability problems", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(this_ptr, "_throwdispatchexception", response, c2, PHALCON_NO_CHECK);
}
goto ws_e10f_0;
we_e10f_0:
phalcon_update_property_zval(this_ptr, SL("_returnedValue"), value TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_lastController"), controller TSRMLS_CC);
RETURN_CHECK_CTOR(controller);
}
/**
* Gets number of rows returned by a resulset
*
*<code>
* $result = $connection->query("SELECT * FROM robots ORDER BY name");
* echo 'There are ', $result->numRows(), ' rows in the resulset';
*</code>
*
* @return int
*/
PHP_METHOD(Phalcon_Db_Result_Pdo, numRows){
zval *row_count = NULL, *connection, *type, *sql_statement;
zval *bind_params, *bind_types, *matches, *pattern;
zval *match, *else_clauses, *sql, *fetch_num, *result;
zval *row, *pdo_statement;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(row_count);
phalcon_read_property(&row_count, this_ptr, SL("_rowCount"), PH_NOISY_CC);
if (PHALCON_IS_FALSE(row_count)) {
PHALCON_INIT_VAR(connection);
phalcon_read_property(&connection, this_ptr, SL("_connection"), PH_NOISY_CC);
PHALCON_INIT_VAR(type);
PHALCON_CALL_METHOD(type, connection, "gettype", PH_NO_CHECK);
if (PHALCON_COMPARE_STRING(type, "sqlite")) {
/**
* SQLite returns resultsets that to the client eyes (PDO) has an arbitrary number
* of rows, so we need to perform an extra count to know that
*/
PHALCON_INIT_VAR(sql_statement);
phalcon_read_property(&sql_statement, this_ptr, SL("_sqlStatement"), PH_NOISY_CC);
PHALCON_INIT_VAR(bind_params);
phalcon_read_property(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY_CC);
PHALCON_INIT_VAR(bind_types);
phalcon_read_property(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY_CC);
PHALCON_INIT_VAR(matches);
PHALCON_INIT_VAR(pattern);
ZVAL_STRING(pattern, "/^SELECT\\s+(.*)$/i", 1);
Z_SET_ISREF_P(matches);
PHALCON_INIT_VAR(match);
PHALCON_CALL_FUNC_PARAMS_3(match, "preg_match", pattern, sql_statement, matches);
Z_UNSET_ISREF_P(matches);
if (zend_is_true(match)) {
PHALCON_INIT_VAR(else_clauses);
phalcon_array_fetch_long(&else_clauses, matches, 1, PH_NOISY_CC);
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "SELECT COUNT(*) FROM (SELECT ", else_clauses, ")");
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, 3);
PHALCON_INIT_VAR(result);
PHALCON_CALL_METHOD_PARAMS_3(result, connection, "query", sql, bind_params, bind_types, PH_NO_CHECK);
PHALCON_INIT_VAR(row);
PHALCON_CALL_METHOD(row, result, "fetch", PH_NO_CHECK);
PHALCON_INIT_NVAR(row_count);
phalcon_array_fetch_long(&row_count, row, 0, PH_NOISY_CC);
}
} else {
PHALCON_INIT_VAR(pdo_statement);
phalcon_read_property(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY_CC);
PHALCON_INIT_NVAR(row_count);
PHALCON_CALL_METHOD(row_count, pdo_statement, "rowcount", PH_NO_CHECK);
}
phalcon_update_property_zval(this_ptr, SL("_rowCount"), row_count TSRMLS_CC);
}
RETURN_CCTOR(row_count);
}
/**
* Throws an internal exception
*
* @param string $message
* @param int $exceptionCode
*/
PHP_METHOD(Phalcon_Mvc_Dispatcher, _throwDispatchException){
zval *message, *exception_code = NULL, *dependency_injector;
zval *exception_message, *exception = NULL, *service;
zval *response, *status_code, *status_message;
zval *events_manager, *event_name, *status;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &message, &exception_code) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!exception_code) {
PHALCON_INIT_NVAR(exception_code);
ZVAL_LONG(exception_code, 0);
} else {
PHALCON_SEPARATE_PARAM(exception_code);
}
PHALCON_INIT_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(exception_code);
ZVAL_LONG(exception_code, 0);
PHALCON_INIT_VAR(exception_message);
ZVAL_STRING(exception_message, "A dependency injection container is required to access the 'response' service", 1);
PHALCON_INIT_VAR(exception);
object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", exception_message, exception_code, PH_CHECK);
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "response", 1);
PHALCON_INIT_VAR(response);
PHALCON_CALL_METHOD_PARAMS_1(response, dependency_injector, "getshared", service, PH_NO_CHECK);
PHALCON_INIT_VAR(status_code);
ZVAL_LONG(status_code, 404);
PHALCON_INIT_VAR(status_message);
ZVAL_STRING(status_message, "Not Found", 1);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(response, "setstatuscode", status_code, status_message, PH_NO_CHECK);
PHALCON_INIT_NVAR(exception);
object_init_ex(exception, phalcon_mvc_dispatcher_exception_ce);
PHALCON_CALL_METHOD_PARAMS_2_NORETURN(exception, "__construct", message, exception_code, PH_CHECK);
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "dispatch:beforeException", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, exception, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
phalcon_throw_exception(exception TSRMLS_CC);
return;
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server doesn't return any row
*
*<code>
* //Inserting data
* $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
* $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
*</code>
*
* @param string $sqlStatement
* @param array $bindParams
* @param array $bindTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){
zval *sql_statement, *bind_params = NULL, *bind_types = NULL;
zval *events_manager, *event_name = NULL, *status, *pdo;
zval *statement = NULL, *affected_rows = NULL;
zval *r0 = NULL;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|zz", &sql_statement, &bind_params, &bind_types) == FAILURE) {
RETURN_MM_NULL();
}
if (!bind_params) {
PHALCON_INIT_VAR(bind_params);
}
if (!bind_types) {
PHALCON_INIT_VAR(bind_types);
}
/**
* Execute the beforeQuery event if a EventsManager is available
*/
PHALCON_OBS_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:beforeQuery", 1);
phalcon_update_property_zval(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_sqlVariables"), bind_params TSRMLS_CC);
phalcon_update_property_zval(this_ptr, SL("_sqlBindTypes"), bind_types TSRMLS_CC);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, bind_params);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_FALSE;
}
}
PHALCON_OBS_VAR(pdo);
phalcon_read_property(&pdo, this_ptr, SL("_pdo"), PH_NOISY_CC);
if (Z_TYPE_P(bind_params) == IS_ARRAY) {
PHALCON_INIT_VAR(statement);
PHALCON_CALL_METHOD_PARAMS_1(statement, pdo, "prepare", sql_statement);
if (Z_TYPE_P(statement) == IS_OBJECT) {
PHALCON_INIT_VAR(r0);
PHALCON_CALL_METHOD_PARAMS_3(r0, this_ptr, "executeprepared", statement, bind_params, bind_types);
PHALCON_CPY_WRT(statement, r0);
PHALCON_INIT_VAR(affected_rows);
PHALCON_CALL_METHOD(affected_rows, statement, "rowcount");
}
} else {
PHALCON_INIT_NVAR(affected_rows);
PHALCON_CALL_METHOD_PARAMS_1(affected_rows, pdo, "exec", sql_statement);
}
/**
* Execute the afterQuery event if a EventsManager is available
*/
if (Z_TYPE_P(affected_rows) == IS_LONG) {
phalcon_update_property_zval(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "db:afterQuery", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, bind_params);
}
}
RETURN_MM_TRUE;
}
/**
* Commits the internal transaction
*
*/
PHP_METHOD(Phalcon_Logger_Adapter_File, commit){
zval *transaction = NULL, *file_handler = NULL, *quenue = NULL, *message = NULL;
zval *message_str = NULL, *type = NULL, *time = NULL, *applied_format = NULL;
zval *applied_eol = NULL;
zval *t0 = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
PHALCON_INIT_VAR(transaction);
phalcon_read_property(&transaction, this_ptr, SL("_transaction"), PH_NOISY_CC);
if (!zend_is_true(transaction)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_logger_exception_ce, "There is no active transaction");
return;
}
phalcon_update_property_bool(this_ptr, SL("_transaction"), 0 TSRMLS_CC);
PHALCON_INIT_VAR(file_handler);
phalcon_read_property(&file_handler, this_ptr, SL("_fileHandler"), PH_NOISY_CC);
PHALCON_INIT_VAR(quenue);
phalcon_read_property(&quenue, this_ptr, SL("_quenue"), PH_NOISY_CC);
if (!phalcon_valid_foreach(quenue TSRMLS_CC)) {
return;
}
ah0 = Z_ARRVAL_P(quenue);
zend_hash_internal_pointer_reset_ex(ah0, &hp0);
fes_654f_1:
if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){
goto fee_654f_1;
}
PHALCON_INIT_VAR(message);
ZVAL_ZVAL(message, *hd, 1, 0);
PHALCON_INIT_VAR(message_str);
PHALCON_CALL_METHOD(message_str, message, "getmessage", PH_NO_CHECK);
PHALCON_INIT_VAR(type);
PHALCON_CALL_METHOD(type, message, "gettype", PH_NO_CHECK);
PHALCON_INIT_VAR(time);
PHALCON_CALL_METHOD(time, message, "gettime", PH_NO_CHECK);
PHALCON_INIT_VAR(applied_format);
PHALCON_CALL_METHOD_PARAMS_3(applied_format, this_ptr, "_applyformat", message_str, type, time, PH_NO_CHECK);
PHALCON_INIT_VAR(t0);
zend_get_constant(SL("PHP_EOL"), t0 TSRMLS_CC);
PHALCON_INIT_VAR(applied_eol);
PHALCON_CONCAT_VV(applied_eol, applied_format, t0);
PHALCON_CALL_FUNC_PARAMS_2_NORETURN("fputs", file_handler, applied_eol);
zend_hash_move_forward_ex(ah0, &hp0);
goto fes_654f_1;
fee_654f_1:
if(0){}
PHALCON_MM_RESTORE();
}
/**
* Handle the whole command-line tasks
*
* @param array $arguments
* @return mixed
*/
PHP_METHOD(Phalcon_CLI_Console, handle){
zval *arguments = NULL, *dependency_injector, *events_manager;
zval *service = NULL, *router, *module_name, *event_name = NULL;
zval *status = NULL, *modules, *exception_msg = NULL, *module;
zval *path, *class_name = NULL, *module_object, *task_name;
zval *action_name, *params, *dispatcher, *task;
int eval_int;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arguments) == FAILURE) {
PHALCON_MM_RESTORE();
RETURN_NULL();
}
if (!arguments) {
PHALCON_INIT_NVAR(arguments);
array_init(arguments);
}
PHALCON_INIT_VAR(dependency_injector);
phalcon_read_property(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependency_injector) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cli_console_exception_ce, "A dependency injection object is required to access internal services");
return;
}
PHALCON_INIT_VAR(events_manager);
phalcon_read_property(&events_manager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
PHALCON_INIT_VAR(service);
ZVAL_STRING(service, "router", 1);
PHALCON_INIT_VAR(router);
PHALCON_CALL_METHOD_PARAMS_1(router, dependency_injector, "getshared", service, PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(router, "handle", arguments, PH_NO_CHECK);
PHALCON_INIT_VAR(module_name);
PHALCON_CALL_METHOD(module_name, router, "getmodulename", PH_NO_CHECK);
if (zend_is_true(module_name)) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "console:beforeStartModule", 1);
PHALCON_INIT_VAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, module_name, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(modules);
phalcon_read_property(&modules, this_ptr, SL("_modules"), PH_NOISY_CC);
eval_int = phalcon_array_isset(modules, module_name);
if (!eval_int) {
PHALCON_INIT_VAR(exception_msg);
PHALCON_CONCAT_SVS(exception_msg, "Module '", module_name, "' isn't registered in the console container");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_cli_console_exception_ce, exception_msg);
return;
}
PHALCON_INIT_VAR(module);
phalcon_array_fetch(&module, modules, module_name, PH_NOISY_CC);
if (Z_TYPE_P(module) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cli_console_exception_ce, "Invalid module definition path");
return;
}
eval_int = phalcon_array_isset_string(module, SS("path"));
if (eval_int) {
PHALCON_INIT_VAR(path);
phalcon_array_fetch_string(&path, module, SL("path"), PH_NOISY_CC);
if (phalcon_file_exists(path TSRMLS_CC) == SUCCESS) {
if (phalcon_require(path TSRMLS_CC) == FAILURE) {
return;
}
} else {
PHALCON_INIT_NVAR(exception_msg);
PHALCON_CONCAT_SVS(exception_msg, "Module definition path '", path, "\" doesn't exist");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_cli_console_exception_ce, exception_msg);
return;
}
}
eval_int = phalcon_array_isset_string(module, SS("className"));
if (eval_int) {
PHALCON_INIT_VAR(class_name);
phalcon_array_fetch_string(&class_name, module, SL("className"), PH_NOISY_CC);
} else {
PHALCON_INIT_NVAR(class_name);
ZVAL_STRING(class_name, "Module", 1);
}
PHALCON_INIT_VAR(module_object);
PHALCON_CALL_METHOD_PARAMS_1(module_object, dependency_injector, "get", class_name, PH_NO_CHECK);
PHALCON_CALL_METHOD_NORETURN(module_object, "registerautoloaders", PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(module_object, "registerservices", dependency_injector, PH_NO_CHECK);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
phalcon_update_property_zval(this_ptr, SL("_moduleObject"), module_object TSRMLS_CC);
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "console:afterStartModule", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, module_name, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
}
PHALCON_INIT_VAR(task_name);
PHALCON_CALL_METHOD(task_name, router, "gettaskname", PH_NO_CHECK);
PHALCON_INIT_VAR(action_name);
PHALCON_CALL_METHOD(action_name, router, "getactionname", PH_NO_CHECK);
PHALCON_INIT_VAR(params);
PHALCON_CALL_METHOD(params, router, "getparams", PH_NO_CHECK);
PHALCON_INIT_NVAR(service);
ZVAL_STRING(service, "dispatcher", 1);
PHALCON_INIT_VAR(dispatcher);
PHALCON_CALL_METHOD_PARAMS_1(dispatcher, dependency_injector, "getshared", service, PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "settaskname", task_name, PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setactionname", action_name, PH_NO_CHECK);
PHALCON_CALL_METHOD_PARAMS_1_NORETURN(dispatcher, "setparams", params, PH_NO_CHECK);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "console:beforeHandleTask", 1);
PHALCON_INIT_NVAR(status);
PHALCON_CALL_METHOD_PARAMS_3(status, events_manager, "fire", event_name, this_ptr, dispatcher, PH_NO_CHECK);
if (PHALCON_IS_FALSE(status)) {
PHALCON_MM_RESTORE();
RETURN_FALSE;
}
}
PHALCON_INIT_VAR(task);
PHALCON_CALL_METHOD(task, dispatcher, "dispatch", PH_NO_CHECK);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "console:afterHandleTask", 1);
PHALCON_CALL_METHOD_PARAMS_3_NORETURN(events_manager, "fire", event_name, this_ptr, task, PH_NO_CHECK);
}
RETURN_CCTOR(task);
}