/**
* Handles user-defined error
*
* @return boolean
*/
PHP_METHOD(Phalcon_Debug, onShutdown){
zval *error = NULL, *message, *type, *file, *line, *exception;
zend_class_entry *default_exception_ce;
PHALCON_MM_GROW();
PHALCON_CALL_FUNCTION(&error, "error_get_last");
if (
phalcon_array_isset_string_fetch(&message, error, SS("message")) &&
phalcon_array_isset_string_fetch(&type, error, SS("type")) &&
phalcon_array_isset_string_fetch(&file, error, SS("file")) &&
phalcon_array_isset_string_fetch(&line, error, SS("line"))
) {
default_exception_ce = zend_get_error_exception(TSRMLS_C);
ALLOC_INIT_ZVAL(exception);
object_init_ex(exception, default_exception_ce);
PHALCON_CALL_METHOD(NULL, exception, "__construct", message, PHALCON_GLOBAL(z_zero), type, file, line);
zend_throw_exception_object(exception TSRMLS_CC);
}
RETURN_MM_TRUE;
}
/**
* Phalcon\Translate\Adapter\Gettext constructor
*
* @param array $options
* @throws \Phalcon\Translate\Exception
*/
PHP_METHOD(Phalcon_Translate_Adapter_Gettext, __construct){
zval *options, *locale, *default_domain, *directory, *setting, *key = NULL, *value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &options);
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Invalid options");
return;
}
if (!phalcon_array_isset_string_fetch(&locale, options, SS("locale"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"locale\" is required");
return;
}
if (!phalcon_array_isset_string_fetch(&default_domain, options, SS("defaultDomain"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"defaultDomain\" is required");
return;
}
if (!phalcon_array_isset_string_fetch(&directory, options, SS("directory"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_translate_exception_ce, "Parameter \"directory\" is required");
return;
}
phalcon_update_property_this(this_ptr, SL("_locale"), locale TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_defaultDomain"), default_domain TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_directory"), directory TSRMLS_CC);
PHALCON_INIT_VAR(setting);
PHALCON_CONCAT_SV(setting, "LC_ALL=", locale);
PHALCON_CALL_FUNCTION(NULL, "putenv", setting);
setlocale(LC_ALL, Z_STRVAL_P(locale));
if (Z_TYPE_P(directory) == IS_ARRAY) {
phalcon_is_iterable(directory, &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);
bindtextdomain(Z_STRVAL_P(key), Z_STRVAL_P(value));
zend_hash_move_forward_ex(ah0, &hp0);
}
} else {
bindtextdomain(Z_STRVAL_P(default_domain), Z_STRVAL_P(directory));
}
textdomain(Z_STRVAL_P(default_domain));
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Annotations\Annotation constructor
*
* @param array $reflectionData
*/
PHP_METHOD(Phalcon_Annotations_Annotation, __construct){
zval *reflection_data, *name = NULL, *arguments, *expr_arguments;
zval *argument = NULL, *expr = NULL, *resolved_argument = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &reflection_data);
if (Z_TYPE_P(reflection_data) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "Reflection data must be an array");
return;
}
PHALCON_OBS_VAR(name);
phalcon_array_fetch_string(&name, reflection_data, SL("name"), PH_NOISY);
phalcon_update_property_this(this_ptr, SL("_name"), name TSRMLS_CC);
/**
* Process annotation arguments
*/
if (phalcon_array_isset_string_fetch(&expr_arguments, reflection_data, SS("arguments"))) {
phalcon_is_iterable(expr_arguments, &ah0, &hp0, 0, 0);
PHALCON_INIT_VAR(arguments);
array_init_size(arguments, zend_hash_num_elements(ah0));
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
zval *n;
PHALCON_GET_HVALUE(argument);
PHALCON_OBS_NVAR(expr);
phalcon_array_fetch_string(&expr, argument, SL("expr"), PH_NOISY);
PHALCON_CALL_METHOD(&resolved_argument, this_ptr, "getexpression", expr);
if (phalcon_array_isset_string_fetch(&n, argument, SS("name"))) {
phalcon_array_update_zval(&arguments, n, resolved_argument, PH_COPY);
} else {
phalcon_array_append(&arguments, resolved_argument, 0);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_update_property_this(this_ptr, SL("_arguments"), arguments TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_exprArguments"), expr_arguments TSRMLS_CC);
}
PHALCON_MM_RESTORE();
}
/**
* Returns the prefix for all the generated urls. By default /
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Url, getBaseUri){
zval *base_uri = NULL, *slash, *_SERVER, *php_self, *uri = NULL;
PHALCON_MM_GROW();
PHALCON_OBS_VAR(base_uri);
phalcon_read_property_this(&base_uri, this_ptr, SL("_baseUri"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(base_uri) == IS_NULL) {
PHALCON_INIT_VAR(slash);
ZVAL_STRING(slash, "/", 1);
_SERVER = phalcon_get_global(SS("_SERVER") TSRMLS_CC);
if (phalcon_array_isset_string_fetch(&php_self, _SERVER, SS("PHP_SELF"))) {
PHALCON_INIT_VAR(uri);
phalcon_get_uri(uri, php_self);
} else {
PHALCON_INIT_NVAR(uri);
}
if (!zend_is_true(uri)) {
PHALCON_CPY_WRT(base_uri, slash);
} else {
PHALCON_INIT_NVAR(base_uri);
PHALCON_CONCAT_VVV(base_uri, slash, uri, slash);
}
phalcon_update_property_this(this_ptr, SL("_baseUri"), base_uri TSRMLS_CC);
}
RETURN_CCTOR(base_uri);
}
/**
* This method is automatically called in Phalcon\Db\Adapter\Pdo constructor.
* Call it when you need to restore a database connection.
*
* Support set search_path after connectted if schema is specified in config.
*
* @param array $descriptor
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, connect){
zval *descriptor = NULL, *schema = NULL, *sql, *password;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &descriptor);
if (!descriptor) {
PHALCON_INIT_VAR(descriptor);
} else {
PHALCON_SEPARATE_PARAM(descriptor);
}
if (!zend_is_true(descriptor)) {
PHALCON_OBS_NVAR(descriptor);
phalcon_read_property_this(&descriptor, this_ptr, SL("_descriptor"), PH_NOISY TSRMLS_CC);
}
if (phalcon_array_isset_string(descriptor, SS("schema"))) {
PHALCON_OBS_VAR(schema);
phalcon_array_fetch_string(&schema, descriptor, SL("schema"), PH_NOISY);
phalcon_array_unset_string(&descriptor, SS("schema"), PH_COPY);
phalcon_update_property_this(this_ptr, SL("_schema"), schema TSRMLS_CC);
}
else {
PHALCON_INIT_VAR(schema);
}
if (phalcon_array_isset_string_fetch(&password, descriptor, SS("password"))) {
/* There is a bug in pdo_pgsql driver when the password is empty,
* the driver tries to access invalid memory:
*
* if (dbh->password[0] != '\'' && dbh->password[strlen(dbh->password) - 1] != '\'')
*
* To avoid this we set the password to null
*/
if (Z_TYPE_P(password) == IS_STRING && Z_STRLEN_P(password) == 0) {
phalcon_array_update_string(&descriptor, SL("password"), PHALCON_GLOBAL(z_null), PH_COPY);
}
}
PHALCON_CALL_PARENT(NULL, phalcon_db_adapter_pdo_postgresql_ce, this_ptr, "connect", descriptor);
/**
* Execute the search path in the after connect
*/
if (Z_TYPE_P(schema) == IS_STRING) {
PHALCON_INIT_VAR(sql);
PHALCON_CONCAT_SVS(sql, "SET search_path TO '", schema, "'");
PHALCON_CALL_METHOD(NULL, this_ptr, "execute", sql);
}
PHALCON_MM_RESTORE();
}
/**
* Phalcon\Mvc\Model\MetaData\Xcache constructor
*
* @param array $options
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Xcache, __construct){
zval *options = NULL, *prefix, *ttl, *empty_array;
phalcon_fetch_params(0, 0, 1, &options);
if (options && Z_TYPE_P(options) == IS_ARRAY) {
if (phalcon_array_isset_string_fetch(&prefix, options, SS("prefix"))) {
phalcon_update_property_this(this_ptr, SL("_prefix"), prefix TSRMLS_CC);
}
if (phalcon_array_isset_string_fetch(&ttl, options, SS("lifetime"))) {
phalcon_update_property_this(this_ptr, SL("_ttl"), ttl TSRMLS_CC);
}
}
PHALCON_ALLOC_GHOST_ZVAL(empty_array);
array_init(empty_array);
phalcon_update_property_this(this_ptr, SL("_metaData"), empty_array TSRMLS_CC);
}
/**
* Returns the DependencyInjector container
*
* @return Phalcon\DiInterface
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getDI){
zval *params, *dependency_injector;
params = phalcon_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset_string_fetch(&dependency_injector, params, SS("di"))) {
RETURN_ZVAL(dependency_injector, 1, 0);
}
RETURN_NULL();
}
/**
* Returns the order parameter in the criteria
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getOrder){
zval *params, *order;
params = phalcon_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset_string_fetch(&order, params, SS("order"))) {
RETURN_ZVAL(order, 1, 0);
}
RETURN_NULL();
}
/**
* Returns the limit parameter in the criteria
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getLimit){
zval *params, *limit;
params = phalcon_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset_string_fetch(&limit, params, SS("limit"))) {
RETURN_ZVAL(limit, 1, 0);
}
RETURN_NULL();
}
/**
* Returns the conditions parameter in the criteria
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Model_Criteria, getConditions){
zval *params, *conditions;
params = phalcon_fetch_nproperty_this(this_ptr, SL("_params"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset_string_fetch(&conditions, params, SS("conditions"))) {
RETURN_ZVAL(conditions, 1, 0);
}
RETURN_NULL();
}
/**
* Create internal connection to memcached
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, _connect)
{
zval *options, *memcache, *host, *port, *persistent;
zval *success = NULL;
zend_class_entry *ce0;
PHALCON_MM_GROW();
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
ce0 = zend_fetch_class(SL("Memcache"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(memcache);
object_init_ex(memcache, ce0);
if (phalcon_has_constructor(memcache TSRMLS_CC)) {
PHALCON_CALL_METHOD(NULL, memcache, "__construct");
}
if (
!phalcon_array_isset_string_fetch(&host, options, SS("host"))
|| !phalcon_array_isset_string_fetch(&port, options, SS("port"))
|| !phalcon_array_isset_string_fetch(&persistent, options, SS("persistent"))
) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
if (zend_is_true(persistent)) {
PHALCON_CALL_METHOD(&success, memcache, "pconnect", host, port);
} else {
PHALCON_CALL_METHOD(&success, memcache, "connect", host, port);
}
if (!zend_is_true(success)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cannot connect to Memcached server");
return;
}
phalcon_update_property_this(this_ptr, SL("_memcache"), memcache TSRMLS_CC);
RETURN_CTOR(memcache);
}
/**
* Restore a Phalcon\Db\Index object from export
*
* @param array $data
* @return Phalcon\Db\IndexInterface
*/
PHP_METHOD(Phalcon_Db_Index, __set_state){
zval *data, *index_name, *columns;
phalcon_fetch_params(0, 1, 0, &data);
if (!phalcon_array_isset_string_fetch(&index_name, data, SS("_indexName"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "_indexName parameter is required");
return;
}
if (!phalcon_array_isset_string_fetch(&columns, data, SS("_columns"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "_columns parameter is required");
return;
}
/**
* Return a Phalcon\Db\Index as part of the returning state
*/
object_init_ex(return_value, phalcon_db_index_ce);
PHALCON_CALL_METHODW(NULL, return_value, "__construct", index_name, columns);
}
/**
* Phalcon\Mvc\Model\MetaData\Files constructor
*
* @param array $options
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData_Files, __construct){
zval *options = NULL, *meta_data_dir, *empty_array;
phalcon_fetch_params(0, 0, 1, &options);
if (options && Z_TYPE_P(options) == IS_ARRAY) {
if (phalcon_array_isset_string_fetch(&meta_data_dir, options, SS("metaDataDir"))) {
phalcon_update_property_this(this_ptr, SL("_metaDataDir"), meta_data_dir TSRMLS_CC);
}
}
PHALCON_ALLOC_GHOST_ZVAL(empty_array);
array_init(empty_array);
phalcon_update_property_this(this_ptr, SL("_metaData"), empty_array TSRMLS_CC);
}
/**
* Returns the CSS collection of assets
*
* @return Phalcon\Assets\Collection
*/
PHP_METHOD(Phalcon_Assets_Manager, getJs){
zval *collections, *collection;
collections = phalcon_fetch_nproperty_this(this_ptr, SL("_collections"), PH_NOISY TSRMLS_CC);
/**
* Check if the collection does not exist and create an implicit collection
*/
if (!phalcon_array_isset_string_fetch(&collection, collections, SS("js"))) {
object_init_ex(return_value, phalcon_assets_collection_ce);
return;
}
RETURN_ZVAL(collection, 1, 0);
}
/**
* Returns a cached content
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, get){
zval *key_name, *lifetime = NULL, *frontend, *prefix, *prefixed_key;
zval *collection = NULL, *conditions, *document = NULL, *time_condition;
zval *cached_content;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &key_name, &lifetime);
frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, key_name);
phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
PHALCON_CALL_METHOD(&collection, this_ptr, "_getcollection");
PHALCON_INIT_VAR(conditions);
array_init_size(conditions, 2);
phalcon_array_update_string(&conditions, SL("key"), prefixed_key, PH_COPY);
MAKE_STD_ZVAL(time_condition);
array_init_size(time_condition, 1);
add_assoc_long_ex(time_condition, SS("$gt"), (long int)time(NULL));
add_assoc_zval_ex(conditions, SS("time"), time_condition);
PHALCON_CALL_METHOD(&document, collection, "findone", conditions);
if (Z_TYPE_P(document) == IS_ARRAY) {
if (likely(phalcon_array_isset_string_fetch(&cached_content, document, SS("data")))) {
if (phalcon_is_numeric(cached_content)) {
RETURN_CCTOR(cached_content);
} else {
PHALCON_RETURN_CALL_METHOD(frontend, "afterretrieve", cached_content);
RETURN_MM();
}
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache is corrupt");
return;
}
} else {
RETURN_MM_NULL();
}
}
/**
* Enables/disables options in the Database component
*
* @param array $options
*/
PHP_METHOD(Phalcon_Db, setup){
zval *options, *escape_identifiers;
phalcon_fetch_params(0, 1, 0, &options);
if (Z_TYPE_P(options) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "Options must be an array");
return;
}
/**
* Enables/Disables globally the escaping of SQL identifiers
*/
if (phalcon_array_isset_string_fetch(&escape_identifiers, options, SS("escapeSqlIdentifiers"))) {
PHALCON_GLOBAL(db).escape_identifiers = zend_is_true(escape_identifiers);
}
}
/**
* Handles user-defined error
*
* @param int $severity
* @param string $message
* @param string $file
* @param string $line
* @param array $context
* @return boolean
*/
PHP_METHOD(Phalcon_Debug, onUserDefinedError){
zval *severity, *message, *file = NULL, *line = NULL, *context = NULL, *e, *previous = NULL, *exception;
zend_class_entry *default_exception_ce;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 2, 3, &severity, &message, &file, &line, &context);
if (!file) {
file = PHALCON_GLOBAL(z_null);
}
if (!line) {
line = PHALCON_GLOBAL(z_null);
}
if (context && Z_TYPE_P(context) == IS_ARRAY) {
if (
phalcon_array_isset_string_fetch(&e, context, SS("e")) &&
Z_TYPE_P(e) == IS_OBJECT &&
instanceof_function_ex(Z_OBJCE_P(e), zend_exception_get_default(TSRMLS_C), 1 TSRMLS_CC)
) {
PHALCON_CPY_WRT(previous, e);
} else {
previous = PHALCON_GLOBAL(z_null);
}
} else {
previous = PHALCON_GLOBAL(z_null);
}
default_exception_ce = zend_get_error_exception(TSRMLS_C);
ALLOC_INIT_ZVAL(exception);
object_init_ex(exception, default_exception_ce);
PHALCON_CALL_METHOD(NULL, exception, "__construct", message, PHALCON_GLOBAL(z_zero), severity, file, line, previous);
zend_throw_exception_object(exception TSRMLS_CC);
RETURN_MM_TRUE;
}
/**
* Stores cached content into the file backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_File, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *cache_file, *cached_content = NULL, *prepared_content = NULL, *status, *is_buffering = NULL;
zval *last_key, *frontend, *options, *cache_dir;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC);
} else {
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(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;
}
frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, last_key);
if (!content || !zend_is_true(content)) {
PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent");
} else {
cached_content = content;
}
PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content);
/**
* We use file_put_contents to respect open-base-dir directive
*/
PHALCON_INIT_VAR(status);
if (!phalcon_is_numeric(cached_content)) {
phalcon_file_put_contents(status, cache_file, prepared_content TSRMLS_CC);
} else {
phalcon_file_put_contents(status, cache_file, cached_content TSRMLS_CC);
}
if (PHALCON_IS_FALSE(status)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cache directory is not writable");
return;
}
PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD(NULL, 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 a cached content
*
* @param int|string $keyName
* @param long $lifetime
* @return mixed
*/
PHP_METHOD(Phalcon_Cache_Backend_File, get){
zval *key_name, *lifetime = NULL;
zval *options, *prefix, *prefixed_key, *cache_dir;
zval *cache_file, *tmp = NULL;
zval *modified_time;
zval *cached_content, *exception_message;
long int now, ttl, mtime, diff;
int expired;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &key_name, &lifetime);
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, key_name);
phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
zval *frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
/**
* Check if the file has expired
*/
now = (long int)time(NULL);
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
zval *last_lifetime = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(last_lifetime) == IS_NULL) {
PHALCON_CALL_METHOD(&tmp, frontend, "getlifetime");
ttl = phalcon_get_intval(tmp);
} else {
ttl = phalcon_get_intval(last_lifetime);
}
} else {
ttl = phalcon_get_intval(lifetime);
}
PHALCON_INIT_VAR(modified_time);
phalcon_filemtime(modified_time, cache_file TSRMLS_CC);
if (unlikely(Z_TYPE_P(modified_time) != IS_LONG)) {
convert_to_long(modified_time);
}
mtime = Z_LVAL_P(modified_time);
diff = now - ttl;
expired = diff > mtime;
/**
* The content is only retrieved if the content has not expired
*/
if (!expired) {
/**
* Use file-get-contents to control that the openbase_dir can't be skipped
*/
PHALCON_INIT_VAR(cached_content);
phalcon_file_get_contents(cached_content, cache_file TSRMLS_CC);
if (PHALCON_IS_FALSE(cached_content)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Cache file ", cache_file, " could not be opened");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_cache_exception_ce, exception_message);
return;
}
if (phalcon_is_numeric(cached_content)) {
RETURN_CCTOR(cached_content);
} else {
/**
* Use the frontend to process the content of the cache
*/
PHALCON_RETURN_CALL_METHOD(frontend, "afterretrieve", cached_content);
}
RETURN_MM();
}
}
RETURN_MM_NULL();
}
/**
* Returns a MongoDb collection based on the backend parameters
*
* @return MongoCollection
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, _getCollection){
zval *mongo_collection, *mongo_database = NULL;
zend_class_entry *ce0;
PHALCON_MM_GROW();
mongo_collection = phalcon_fetch_nproperty_this(this_ptr, SL("_collection"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(mongo_collection) != IS_OBJECT) {
zval *options, *mongo;
zval *server = NULL, *database = NULL, *collection = NULL;
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
/**
* If mongo is defined a valid Mongo object must be passed
*/
if (phalcon_array_isset_string_fetch(&mongo, options, SS("mongo"))) {
if (Z_TYPE_P(mongo) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The 'mongo' parameter must be a valid Mongo instance");
return;
}
} else {
/**
* Server must be defined otherwise
*/
phalcon_array_isset_string_fetch(&server, options, SS("server"));
if (!server || Z_TYPE_P(server) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB connection string");
return;
}
ce0 = zend_fetch_class(SL("MongoClient"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(mongo);
object_init_ex(mongo, ce0);
assert(phalcon_has_constructor(mongo TSRMLS_CC));
PHALCON_CALL_METHOD(NULL, mongo, "__construct", server);
}
/**
* Check if the database name is a string
*/
phalcon_array_isset_string_fetch(&database, options, SS("db"));
if (!database || Z_TYPE_P(database) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB db");
return;
}
/**
* Retrieve the connection name
*/
phalcon_array_isset_string_fetch(&collection, options, SS("collection"));
if (!collection || Z_TYPE_P(collection) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB collection");
return;
}
/**
* Make the connection and get the collection
*/
PHALCON_CALL_METHOD(&mongo_database, mongo, "selectdb", database);
PHALCON_RETURN_CALL_METHOD(mongo_database, "selectcollection", collection);
}
else {
RETVAL_ZVAL(mongo_collection, 1, 0);
}
PHALCON_MM_RESTORE();
}
/**
* Builds a SELECT statement
*
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect, select){
zval *definition, *escape_char = NULL, *columns, *selected_columns, *distinct;
zval *column = NULL, *column_sql = NULL;
zval *column_domain_sql = 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 = NULL, *group_items, *group_fields;
zval *group_field = NULL, *group_expression = NULL, *group_sql;
zval *group_clause, *having_conditions, *having_expression = NULL;
zval *order_fields, *order_items, *order_item = NULL;
zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL;
zval *order_sql_item_type = NULL, *order_sql, *tmp1 = NULL, *tmp2 = NULL;
zval *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_fetch(&columns, 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 TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escape_char);
}
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) {
zval *column_item, *column_alias, *column_domain;
PHALCON_GET_HVALUE(column);
/**
* Escape column name
*/
if (
phalcon_array_isset_long_fetch(&column_item, column, 0)
|| phalcon_array_isset_string_fetch(&column_item, column, SS("column"))
) {
if (Z_TYPE_P(column_item) == IS_ARRAY) {
PHALCON_CALL_METHOD(&column_sql, this_ptr, "getsqlexpression", column_item, escape_char);
} else if (PHALCON_IS_STRING(column_item, "*")) {
PHALCON_CPY_WRT(column_sql, column_item);
} else if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_sql);
PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char);
} else {
PHALCON_CPY_WRT(column_sql, column_item);
}
}
else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid SELECT definition");
return;
}
/**
* Escape column domain
*/
if (phalcon_array_isset_long_fetch(&column_domain, column, 1)) {
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_fetch(&column_alias, column, 2)) {
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_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_VAR(tables_sql);
phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC);
} else {
PHALCON_CPY_WRT(tables_sql, tables);
}
PHALCON_INIT_VAR(sql);
if (phalcon_array_isset_string_fetch(&distinct, definition, SS("distinct"))) {
assert(Z_TYPE_P(distinct) == IS_LONG);
if (Z_LVAL_P(distinct) == 0) {
ZVAL_STRING(sql, "SELECT ALL ", 1);
}
else if (Z_LVAL_P(distinct) == 1) {
ZVAL_STRING(sql, "SELECT DISTINCT ", 1);
}
else {
ZVAL_STRING(sql, "SELECT ", 1);
}
}
else {
ZVAL_STRING(sql, "SELECT ", 1);
}
PHALCON_SCONCAT_VSV(sql, 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_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
PHALCON_INIT_NVAR(sql_join);
PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table);
/**
* Check if the join has conditions
*/
if (phalcon_array_isset_string(join, SS("conditions"))) {
PHALCON_OBS_NVAR(join_conditions_array);
phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY);
if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) {
PHALCON_INIT_NVAR(join_expressions);
array_init(join_expressions);
phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(join_condition);
PHALCON_CALL_METHOD(&join_expression, this_ptr, "getsqlexpression", join_condition, escape_char);
phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah3, &hp3);
}
PHALCON_INIT_NVAR(join_conditions);
phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC);
PHALCON_SCONCAT_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_fetch(&where_conditions, definition, SS("where"))) {
if (Z_TYPE_P(where_conditions) == IS_ARRAY) {
PHALCON_CALL_METHOD(&where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression);
} else {
PHALCON_SCONCAT_SV(sql, " WHERE ", where_conditions);
}
}
/* Check for a GROUP clause */
if (phalcon_array_isset_string_fetch(&group_fields, definition, SS("group"))) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0);
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_HVALUE(group_field);
PHALCON_CALL_METHOD(&group_expression, this_ptr, "getsqlexpression", group_field, escape_char);
phalcon_array_append(&group_items, group_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(group_sql);
phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC);
PHALCON_INIT_VAR(group_clause);
PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql);
phalcon_concat_self(&sql, group_clause TSRMLS_CC);
}
/* Check for a HAVING clause */
if (phalcon_array_isset_string_fetch(&having_conditions, definition, SS("having"))) {
PHALCON_CALL_METHOD(&having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression);
}
/* Check for a ORDER clause */
if (phalcon_array_isset_string_fetch(&order_fields, definition, SS("order"))) {
PHALCON_INIT_VAR(order_items);
array_init(order_items);
phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0);
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_HVALUE(order_item);
PHALCON_OBS_NVAR(order_expression);
phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY);
PHALCON_CALL_METHOD(&order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char);
/**
* In the numeric 1 position could be a ASC/DESC clause
*/
if (phalcon_array_isset_long(order_item, 1)) {
PHALCON_OBS_NVAR(sql_order_type);
phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY);
PHALCON_INIT_NVAR(order_sql_item_type);
PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type);
} else {
PHALCON_CPY_WRT(order_sql_item_type, order_sql_item);
}
phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE);
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_VAR(order_sql);
phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql);
}
/**
* Check for a LIMIT condition
*/
if (phalcon_array_isset_string_fetch(&limit_value, definition, SS("limit"))) {
if (likely(Z_TYPE_P(limit_value) == IS_ARRAY)) {
if (likely(phalcon_array_isset_string_fetch(&number, limit_value, SS("number")))) {
PHALCON_OBS_NVAR(tmp1);
phalcon_array_fetch_string(&tmp1, number, SL("value"), PH_NOISY);
/**
* Check for a OFFSET condition
*/
if (phalcon_array_isset_string_fetch(&offset, limit_value, SS("offset"))) {
PHALCON_OBS_NVAR(tmp2);
phalcon_array_fetch_string(&tmp2, offset, SL("value"), PH_NOISY);
PHALCON_SCONCAT_SVSV(sql, " LIMIT ", tmp1, " OFFSET ", tmp2);
} else {
PHALCON_SCONCAT_SV(sql, " LIMIT ", tmp1);
}
}
} else {
PHALCON_SCONCAT_SV(sql, " LIMIT ", limit_value);
}
}
RETURN_CTOR(sql);
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Curl, sendInternal){
zval *uri = NULL, *url = NULL, *method, *useragent, *data, *type, *files, *timeout, *curl, *username, *password, *authtype;
zval *file = NULL, *body, *uniqid = NULL, *boundary, *key = NULL, *value = NULL;
zval *path_parts = NULL, *filename, *basename, *filedata = NULL;
zval *constant, *header, *headers = NULL;
zval *content = NULL, *errorno = NULL, *error = NULL, *headersize = NULL, *httpcode = NULL, *headerstr, *bodystr, *response, *tmp = NULL;
zend_class_entry *curlfile_ce;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
PHALCON_CALL_SELF(&uri, "geturi");
PHALCON_CALL_METHOD(&url, uri, "build");
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
useragent = phalcon_fetch_nproperty_this(this_ptr, SL("_useragent"), PH_NOISY TSRMLS_CC);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
files = phalcon_fetch_nproperty_this(this_ptr, SL("_files"), PH_NOISY TSRMLS_CC);
timeout = phalcon_fetch_nproperty_this(this_ptr, SL("_timeout"), PH_NOISY TSRMLS_CC);
curl = phalcon_fetch_nproperty_this(this_ptr, SL("_curl"), PH_NOISY TSRMLS_CC);
username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC);
password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC);
authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(constant);
if (!zend_get_constant(SL("CURLOPT_URL"), constant TSRMLS_CC)) {
RETURN_MM_FALSE;
}
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, url);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_CONNECTTIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_TIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (PHALCON_IS_NOT_EMPTY(method) && zend_get_constant(SL("CURLOPT_CUSTOMREQUEST"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, method);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERAGENT"), constant TSRMLS_CC) && PHALCON_IS_NOT_EMPTY(useragent)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, useragent);
}
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_EMPTY(username)) {
if (PHALCON_IS_STRING(authtype, "any")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_ANY"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "basic")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_BASIC"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "digest")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_DIGEST"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
}
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_SAFE_UPLOAD"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, PHALCON_GLOBAL(z_true));
}
if (Z_TYPE_P(data) == IS_STRING && PHALCON_IS_NOT_EMPTY(data)) {
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
if (PHALCON_IS_EMPTY(type)) {
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "application/x-www-form-urlencoded", 1);
}
PHALCON_CALL_METHOD(NULL, header, "set", key, type);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else if (phalcon_class_exists(SL("CURLFile"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_INIT_NVAR(data);
array_init(data);
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
curlfile_ce = zend_fetch_class(SL("CURLFile"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_NVAR(tmp);
object_init_ex(tmp, curlfile_ce);
PHALCON_CALL_METHOD(NULL, tmp, "__construct", file);
phalcon_array_append(&data, tmp, PH_COPY);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else {
PHALCON_CALL_FUNCTION(&uniqid, "uniqid");
PHALCON_INIT_VAR(boundary);
PHALCON_CONCAT_SV(boundary, "--------------", uniqid);
PHALCON_INIT_VAR(body);
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_is_iterable(data, &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_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file);
if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) {
PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n");
PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n");
}
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
if (!PHALCON_IS_EMPTY(body)) {
PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n");
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Length", 1);
PHALCON_INIT_NVAR(value);
ZVAL_LONG(value, Z_STRLEN_P(body));
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_CALL_METHOD(&headers, header, "build");
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, body);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_HTTPHEADER"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, headers);
}
}
PHALCON_CALL_FUNCTION(&content, "curl_exec", curl);
PHALCON_CALL_FUNCTION(&errorno, "curl_errno", curl);
if (PHALCON_IS_TRUE(errorno)) {
PHALCON_CALL_FUNCTION(&error, "curl_error", curl);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_http_client_exception_ce, error);
return;
}
PHALCON_INIT_VAR(response);
object_init_ex(response, phalcon_http_client_response_ce);
PHALCON_CALL_METHOD(NULL, response, "__construct");
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HTTP_CODE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&httpcode, "curl_getinfo", curl, constant);
PHALCON_CALL_METHOD(NULL, response, "setstatuscode", httpcode);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HEADER_SIZE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&headersize, "curl_getinfo", curl, constant);
PHALCON_INIT_VAR(headerstr);
phalcon_substr(headerstr, content, 0 , Z_LVAL_P(headersize));
PHALCON_INIT_VAR(bodystr);
phalcon_substr(bodystr, content, Z_LVAL_P(headersize) , Z_STRLEN_P(content));
PHALCON_CALL_METHOD(NULL, response, "setheader", headerstr);
PHALCON_CALL_METHOD(NULL, response, "setbody", bodystr);
}
RETURN_CTOR(response);
}
/**
* 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, *scale, *dunsigned, *is_numeric;
zval *auto_increment, *first, *after, *bind_type, *default_value;
phalcon_fetch_params(0, 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_fetch(&type, definition, SS("type"))) {
phalcon_update_property_this(this_ptr, SL("_type"), type TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "Column type is required");
return;
}
/**
* Check if the field is nullable
*/
if (phalcon_array_isset_string_fetch(¬_null, definition, SS("notNull"))) {
phalcon_update_property_this(this_ptr, SL("_notNull"), not_null TSRMLS_CC);
}
/**
* Check if the field is primary key
*/
if (phalcon_array_isset_string_fetch(&primary, definition, SS("primary"))) {
phalcon_update_property_this(this_ptr, SL("_primary"), primary TSRMLS_CC);
}
if (phalcon_array_isset_string_fetch(&size, definition, SS("size"))) {
phalcon_update_property_this(this_ptr, SL("_size"), size TSRMLS_CC);
}
/**
* Check if the column has a decimal scale
*/
if (phalcon_array_isset_string_fetch(&scale, definition, SS("scale"))) {
int i_type = phalcon_get_intval(type);
int is_numeric = (i_type == 3 || i_type == 7 || i_type == 9);
if (is_numeric) {
phalcon_update_property_this(this_ptr, SL("_scale"), scale TSRMLS_CC);
}
}
/**
* Check if the field is unsigned (only MySQL)
*/
if (phalcon_array_isset_string_fetch(&dunsigned, definition, SS("unsigned"))) {
phalcon_update_property_this(this_ptr, SL("_unsigned"), dunsigned TSRMLS_CC);
}
/**
* Check if the field is numeric
*/
if (phalcon_array_isset_string_fetch(&is_numeric, definition, SS("isNumeric"))) {
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_fetch(&auto_increment, definition, SS("autoIncrement"))) {
if (PHALCON_IS_LONG(type, 0)) {
phalcon_update_property_this(this_ptr, SL("_autoIncrement"), auto_increment TSRMLS_CC);
} else {
PHALCON_THROW_EXCEPTION_STRW(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_fetch(&first, definition, SS("first"))) {
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_fetch(&after, definition, SS("after"))) {
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_fetch(&bind_type, definition, SS("bindType"))) {
phalcon_update_property_this(this_ptr, SL("_bindType"), bind_type TSRMLS_CC);
}
/**
* Default values
*/
if (phalcon_array_isset_string_fetch(&default_value, definition, SS("default"))) {
phalcon_update_property_this(this_ptr, SL("_default"), default_value TSRMLS_CC);
}
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Stream, sendInternal){
zval *stream, *http, *option = NULL, *header, *handler, *base_uri, *url = NULL, *method, *useragent, *timeout;
zval *fp = NULL, *meta = NULL, *wrapper_data, *bodystr = NULL, *response;
PHALCON_MM_GROW();
stream = phalcon_fetch_nproperty_this(this_ptr, SL("_stream"), PH_NOISY TSRMLS_CC);
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
base_uri = phalcon_fetch_nproperty_this(this_ptr, SL("_base_uri"), PH_NOISY TSRMLS_CC);
useragent = phalcon_fetch_nproperty_this(this_ptr, SL("_useragent"), PH_NOISY TSRMLS_CC);
timeout = phalcon_fetch_nproperty_this(this_ptr, SL("_timeout"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(http);
ZVAL_STRING(http, "http", 1);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "method", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, method);
if (PHALCON_IS_NOT_EMPTY(useragent)) {
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "User-Agent", 1);
PHALCON_CALL_METHOD(NULL, header, "set", option, useragent);
}
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, useragent);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "timeout", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, timeout);
PHALCON_CALL_METHOD(&url, base_uri, "build");
PHALCON_CALL_SELF(NULL, "buildBody");
PHALCON_INIT_VAR(handler);
array_init_size(handler, 2);
phalcon_array_append(&handler, this_ptr, PH_SEPARATE);
add_next_index_stringl(handler, SL("errorHandler"), 1);
PHALCON_CALL_FUNCTION(NULL, "set_error_handler", handler);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "r", 1);
PHALCON_CALL_FUNCTION(&fp, "fopen", url, option, PHALCON_GLOBAL(z_false), stream);
PHALCON_CALL_FUNCTION(NULL, "restore_error_handler");
PHALCON_CALL_FUNCTION(&meta, "stream_get_meta_data", fp);
PHALCON_CALL_FUNCTION(&bodystr, "stream_get_contents", fp);
PHALCON_CALL_FUNCTION(NULL, "fclose", fp);
PHALCON_INIT_VAR(response);
object_init_ex(response, phalcon_http_client_response_ce);
PHALCON_CALL_METHOD(NULL, response, "__construct");
if (phalcon_array_isset_string_fetch(&wrapper_data, meta, SS("wrapper_data"))) {
PHALCON_CALL_METHOD(NULL, response, "setHeader", wrapper_data);
}
PHALCON_CALL_METHOD(NULL, response, "setbody", bodystr);
RETURN_CTOR(response);
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Stream, buildBody){
zval *stream, *header, *data, *file, *username, *password, *authtype, *digest, *method, *entity_body;
zval *key = NULL, *value = NULL, *realm, *qop, *nonce, *nc, *cnonce, *qoc, *ha1 = NULL, *path = NULL, *md5_entity_body = NULL, *ha2 = NULL;
zval *http, *option = NULL, *body, *headers = NULL, *uniqid = NULL, *boundary;
zval *path_parts = NULL, *filename, *basename, *filedata = NULL, *tmp = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
stream = phalcon_fetch_nproperty_this(this_ptr, SL("_stream"), PH_NOISY TSRMLS_CC);
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
file = phalcon_fetch_nproperty_this(this_ptr, SL("_file"), PH_NOISY TSRMLS_CC);
username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC);
password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC);
authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC);
digest = phalcon_fetch_nproperty_this(this_ptr, SL("_digest"), PH_NOISY TSRMLS_CC);
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
entity_body = phalcon_fetch_nproperty_this(this_ptr, SL("_entity_body"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_EMPTY(username)) {
if (PHALCON_IS_STRING(authtype, "basic")) {
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Authorization", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SVSV(value, "Basic ", username, ":", password);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
} else if (PHALCON_IS_STRING(authtype, "digest") && PHALCON_IS_NOT_EMPTY(digest)) {
if (phalcon_array_isset_string_fetch(&realm, digest, SS("realm"))) {
PHALCON_INIT_VAR(realm);
ZVAL_NULL(realm);
}
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, username, ":", realm, ":", password);
PHALCON_CALL_FUNCTION(&ha1, "md5", tmp);
if (!phalcon_array_isset_string_fetch(&qop, digest, SS("qop"))) {
PHALCON_INIT_VAR(qop);
ZVAL_NULL(qop);
}
if (PHALCON_IS_EMPTY(qop) || phalcon_memnstr_str(qop, SL("auth"))) {
PHALCON_CALL_SELF(&path, "getpath");
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, method, ":", path);
PHALCON_CALL_FUNCTION(&ha2, "md5", tmp);
} else if (phalcon_memnstr_str(qop, SL("auth-int"))) {
PHALCON_CALL_SELF(&path, "getpath");
PHALCON_CALL_FUNCTION(&md5_entity_body, "md5", entity_body);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, method, ":", path, ":", md5_entity_body);
PHALCON_CALL_FUNCTION(&ha2, "md5", tmp);
}
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Authorization", 1);
if (phalcon_array_isset_string_fetch(&nonce, digest, SS("nonce"))) {
PHALCON_INIT_VAR(nonce);
ZVAL_NULL(nonce);
}
if (PHALCON_IS_EMPTY(qop)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, ha1, ":", nonce, ":", ha2);
PHALCON_CALL_FUNCTION(&value, "md5", tmp);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_SV(tmp, "Digest ", value);
PHALCON_CALL_METHOD(NULL, header, "set", key, tmp);
} else {
if (phalcon_array_isset_string_fetch(&nc, digest, SS("nc"))) {
PHALCON_INIT_VAR(nc);
ZVAL_NULL(nc);
}
if (phalcon_array_isset_string_fetch(&cnonce, digest, SS("cnonce"))) {
PHALCON_INIT_VAR(cnonce);
ZVAL_NULL(cnonce);
}
if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) {
PHALCON_INIT_VAR(qoc);
ZVAL_NULL(qoc);
}
if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) {
PHALCON_INIT_VAR(qoc);
ZVAL_NULL(qoc);
}
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSVS(tmp, ha1, ":", nonce, ":", nc, ":");
PHALCON_SCONCAT_VSVSV(tmp, cnonce, ":", qoc, ":", ha2);
PHALCON_CALL_FUNCTION(&value, "md5", tmp);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_SV(tmp, "Digest ", value);
PHALCON_CALL_METHOD(NULL, header, "set", key, tmp);
}
}
}
PHALCON_INIT_VAR(http);
ZVAL_STRING(http, "http", 1);
PHALCON_CALL_FUNCTION(&uniqid, "uniqid");
PHALCON_INIT_VAR(boundary);
PHALCON_CONCAT_SV(boundary, "--------------", uniqid);
PHALCON_INIT_VAR(body);
if (PHALCON_IS_NOT_EMPTY(data) && Z_TYPE_P(data) == IS_STRING){
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
ZVAL_STRING(value, "application/x-www-form-urlencoded", 1);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS);
PHALCON_CALL_METHOD(&headers, header, "build", option);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "header", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "content", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, data);
RETURN_MM();
}
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_is_iterable(data, &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_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (PHALCON_IS_NOT_EMPTY(file)) {
PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file);
if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) {
PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n");
PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n");
}
}
if (!PHALCON_IS_EMPTY(body)) {
PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n");
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Length", 1);
PHALCON_INIT_NVAR(value);
ZVAL_LONG(value, Z_STRLEN_P(body));
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS);
PHALCON_CALL_METHOD(&headers, header, "build", option);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "header", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "content", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, body);
}
PHALCON_MM_RESTORE();
}
/**
* Resolves an annotation expression
*
* @param array $expr
* @return mixed
*/
PHP_METHOD(Phalcon_Annotations_Annotation, getExpression){
zval *expr = NULL, *type, *items, *item = NULL;
zval *resolved_item = NULL, *exception_message;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &expr);
PHALCON_SEPARATE_PARAM(expr);
if (Z_TYPE_P(expr) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_annotations_exception_ce, "The expression is not valid");
return;
}
PHALCON_OBS_VAR(type);
phalcon_array_fetch_string(&type, expr, SL("type"), PH_NOISY);
switch (phalcon_get_intval(type)) {
case PHANNOT_T_INTEGER:
case PHANNOT_T_DOUBLE:
case PHANNOT_T_STRING:
case PHANNOT_T_IDENTIFIER:
if (return_value_ptr) {
zval_ptr_dtor(return_value_ptr);
phalcon_array_fetch_string(return_value_ptr, expr, SL("value"), PH_NOISY);
}
else {
phalcon_array_fetch_string(&return_value, expr, SL("value"), PH_NOISY);
}
RETURN_MM();
/* no break because of implicit return */
case PHANNOT_T_NULL:
RETURN_MM_NULL();
/* no break because of implicit return */
case PHANNOT_T_FALSE:
RETURN_MM_FALSE;
/* no break because of implicit return */
case PHANNOT_T_TRUE:
RETURN_MM_TRUE;
/* no break because of implicit return */
case PHANNOT_T_ARRAY:
PHALCON_OBS_VAR(items);
phalcon_array_fetch_string(&items, expr, SL("items"), PH_NOISY);
phalcon_is_iterable(items, &ah0, &hp0, 0, 0);
array_init_size(return_value, zend_hash_num_elements(ah0));
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
zval *name;
PHALCON_GET_HVALUE(item);
PHALCON_OBS_NVAR(expr);
phalcon_array_fetch_string(&expr, item, SL("expr"), PH_NOISY);
PHALCON_CALL_METHOD(&resolved_item, this_ptr, "getexpression", expr);
if (phalcon_array_isset_string_fetch(&name, item, SS("name"))) {
phalcon_array_update_zval(&return_value, name, resolved_item, PH_COPY);
} else {
phalcon_array_append(&return_value, resolved_item, 0);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_MM();
/* no break because of implicit return */
case PHANNOT_T_ANNOTATION:
object_init_ex(return_value, phalcon_annotations_annotation_ce);
PHALCON_CALL_METHOD(NULL, return_value, "__construct", expr);
RETURN_MM();
/* no break because of implicit return */
default:
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "The expression ", type, " is unknown");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_annotations_exception_ce, exception_message);
return;
}
PHALCON_MM_RESTORE();
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){
zval *type = NULL, *row = NULL, *underscore;
zval *empty_str, *active_row = NULL;
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;
zval *value = NULL, *sql_alias = NULL, *n_alias = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int i_type, is_partial;
PHALCON_MM_GROW();
type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
i_type = (Z_TYPE_P(type) == IS_LONG) ? Z_LVAL_P(type) : phalcon_get_intval(type);
is_partial = (i_type == PHALCON_MVC_MODEL_RESULTSET_TYPE_PARTIAL);
type = NULL;
PHALCON_INIT_VAR(row);
if (is_partial) {
/**
* The result is bigger than 32 rows so it's retrieved one by one
*/
zval *result = phalcon_fetch_nproperty_this(this_ptr, SL("_result"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_CALL_METHOD(&row, result, "fetch", result);
} else {
ZVAL_FALSE(row);
}
} else {
/**
* The full rows are dumped in this_ptr->rows
*/
zval *rows = phalcon_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(rows) == IS_ARRAY) {
phalcon_array_get_current(row, rows);
if (Z_TYPE_P(row) == IS_OBJECT) {
zend_hash_move_forward(Z_ARRVAL_P(rows));
}
} else {
ZVAL_FALSE(row);
}
}
/**
* 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 (is_partial) {
/**
* Get current hydration mode
*/
zval *hydrate_mode = phalcon_fetch_nproperty_this(this_ptr, SL("_hydrateMode"), PH_NOISY TSRMLS_CC);
zval *columns_types = phalcon_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY TSRMLS_CC);
int i_hydrate_mode = phalcon_get_intval(hydrate_mode);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_EMPTY_STRING(empty_str);
/**
* Each row in a complex result is a Phalcon\Mvc\Model\Row instance
*/
PHALCON_INIT_VAR(active_row);
switch (i_hydrate_mode) {
case 0:
object_init_ex(active_row, phalcon_mvc_model_row_ce);
break;
case 1:
array_init(active_row);
break;
case 2:
default:
object_init(active_row);
break;
}
/**
* Create every record according to the column types
*/
/**
* 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: {
zval *keep_snapshots, *instance;
/**
* Check if the resultset must keep snapshots
*/
if (!phalcon_array_isset_string_fetch(&keep_snapshots, column, SS("keepSnapshots"))) {
keep_snapshots = PHALCON_GLOBAL(z_false);
}
/**
* Get the base instance
*/
if (!phalcon_array_isset_string_fetch(&instance, column, SS("instance"))) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: instance");
instance = PHALCON_GLOBAL(z_null);
}
/**
* Assign the values to the attributes using a column map
*/
PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", instance, row_model, column_map, dirty_state, keep_snapshots);
break;
}
default:
/**
* Other kinds of hydrations
*/
PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "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);
if (phalcon_array_isset_string(column, SS("balias"))) {
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);
if (phalcon_array_isset(row, alias)) {
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);
}
assert(attribute != NULL);
}
/**
* Assign the instance according to the hydration type
*/
if (unlikely(!attribute)) {
zend_throw_exception_ex(phalcon_mvc_model_exception_ce, 0 TSRMLS_CC, "Unexpected inconsistency: attribute is NULL");
RETURN_MM();
}
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;
}
/**
* Restores the internal state of a Phalcon\Db\Column object
*
* @param array $data
* @return \Phalcon\Db\Column
*/
PHP_METHOD(Phalcon_Db_Column, __set_state){
zval *data, *definition, *column_name, *column_type = NULL;
zval *not_null, *primary, *size, *scale, *dunsigned, *after;
zval *is_numeric, *first, *bind_type, *default_value;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &data);
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column state must be an array");
return;
}
if (!phalcon_array_isset_string_fetch(&column_name, data, SS("_columnName"))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Column name is required");
return;
}
PHALCON_INIT_VAR(definition);
array_init(definition);
if (phalcon_array_isset_string_fetch(&column_type, data, SS("_type"))) {
phalcon_array_update_string(&definition, SL("type"), column_type, PH_COPY);
}
if (phalcon_array_isset_string_fetch(¬_null, data, SS("_notNull"))) {
phalcon_array_update_string(&definition, SL("notNull"), not_null, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&primary, data, SS("_primary"))) {
phalcon_array_update_string(&definition, SL("primary"), primary, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&size, data, SS("_size"))) {
phalcon_array_update_string(&definition, SL("size"), size, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&scale, data, SS("_scale"))) {
phalcon_array_update_string(&definition, SL("scale"), scale, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&dunsigned, data, SS("_unsigned"))) {
phalcon_array_update_string(&definition, SL("unsigned"), dunsigned, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&after, data, SS("_after"))) {
phalcon_array_update_string(&definition, SL("after"), after, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&is_numeric, data, SS("_isNumeric"))) {
phalcon_array_update_string(&definition, SL("isNumeric"), is_numeric, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&first, data, SS("_first"))) {
phalcon_array_update_string(&definition, SL("first"), first, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&bind_type, data, SS("_bindType"))) {
phalcon_array_update_string(&definition, SL("bindType"), bind_type, PH_COPY);
}
if (phalcon_array_isset_string_fetch(&default_value, data, SS("_default"))) {
phalcon_array_update_string(&definition, SL("default"), default_value, PH_COPY);
}
object_init_ex(return_value, phalcon_db_column_ce);
PHALCON_CALL_METHOD(NULL, return_value, "__construct", column_name, definition);
RETURN_MM();
}
/**
* Builds a SELECT statement
*
* @param array $definition
* @return string
*/
PHP_METHOD(Phalcon_Db_Dialect_Oracle, select){
zval *definition, *escape_char = NULL, *columns, *selected_columns, *distinct;
zval *column = NULL, *column_item = NULL, *column_sql = NULL, *columns_sql = NULL;
zval *column_domain = NULL, *column_domain_sql = NULL, *column_alias = NULL;
zval *column_alias_sql = NULL, *tables, *selected_tables;
zval *table = NULL, *sql_table = NULL, *tables_sql = NULL, *sql, *joins;
zval *join = NULL, *type = NULL, *sql_join = NULL, *join_conditions_array = NULL;
zval *join_expressions = NULL, *join_condition = NULL, *join_expression = NULL;
zval *join_conditions = NULL, *where_conditions;
zval *where_expression = NULL, *group_items, *group_fields;
zval *group_field = NULL, *group_expression = NULL, *group_sql;
zval *group_clause, *having_conditions, *having_expression = NULL;
zval *order_fields, *order_items, *order_item = NULL;
zval *order_expression = NULL, *order_sql_item = NULL, *sql_order_type = NULL;
zval *order_sql_item_type = NULL, *order_sql, *limit_value;
zval *number, *offset, *tmp1 = NULL, *tmp2 = NULL;
zval *z_one, *ini_range, *end_range = NULL, *sql_limit;
HashTable *ah0, *ah1, *ah2, *ah3, *ah4, *ah5;
HashPosition hp0, hp1, hp2, hp3, hp4, hp5;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &definition) == FAILURE) {
RETURN_NULL();
}
if (Z_TYPE_P(definition) != IS_ARRAY) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "Invalid SELECT definition");
return;
}
if (!phalcon_array_isset_string(definition, SS("tables"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'tables' is required in the definition array");
return;
}
if (!phalcon_array_isset_string(definition, SS("columns"))) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_db_exception_ce, "The index 'columns' is required in the definition array");
return;
}
PHALCON_MM_GROW();
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_OBS_VAR(escape_char);
phalcon_read_property_this(&escape_char, this_ptr, SL("_escapeChar"), PH_NOISY TSRMLS_CC);
} else {
PHALCON_INIT_NVAR(escape_char);
}
PHALCON_OBS_VAR(columns);
phalcon_array_fetch_string(&columns, definition, SL("columns"), PH_NOISY);
if (Z_TYPE_P(columns) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_columns);
array_init(selected_columns);
phalcon_is_iterable(columns, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(column);
/**
* Escape column name
*/
PHALCON_OBS_NVAR(column_item);
phalcon_array_fetch_long(&column_item, column, 0, PH_NOISY);
if (Z_TYPE_P(column_item) == IS_ARRAY) {
PHALCON_CALL_METHOD(&column_sql, this_ptr, "getsqlexpression", column_item, escape_char);
} else if (PHALCON_IS_STRING(column_item, "*")) {
PHALCON_CPY_WRT(column_sql, column_item);
} else if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_sql);
PHALCON_CONCAT_VVV(column_sql, escape_char, column_item, escape_char);
} else {
PHALCON_CPY_WRT(columns_sql, column_item);
}
/**
* Escape column domain
*/
if (phalcon_array_isset_long(column, 1)) {
PHALCON_OBS_NVAR(column_domain);
phalcon_array_fetch_long(&column_domain, column, 1, PH_NOISY);
if (zend_is_true(column_domain)) {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_domain_sql);
PHALCON_CONCAT_VVVSV(column_domain_sql, escape_char, column_domain, escape_char, ".", column_sql);
} else {
PHALCON_INIT_NVAR(column_domain_sql);
PHALCON_CONCAT_VSV(column_domain_sql, column_domain, ".", column_sql);
}
} else {
PHALCON_CPY_WRT(column_domain_sql, column_sql);
}
} else {
PHALCON_CPY_WRT(column_domain_sql, column_sql);
}
/**
* Escape column alias
*/
if (phalcon_array_isset_long(column, 2)) {
PHALCON_OBS_NVAR(column_alias);
phalcon_array_fetch_long(&column_alias, column, 2, PH_NOISY);
if (zend_is_true(column_alias)) {
if (PHALCON_GLOBAL(db).escape_identifiers) {
PHALCON_INIT_NVAR(column_alias_sql);
PHALCON_CONCAT_VSVVV(column_alias_sql, column_domain_sql, " ", escape_char, column_alias, escape_char);
} else {
PHALCON_INIT_NVAR(column_alias_sql);
PHALCON_CONCAT_VSV(column_alias_sql, column_domain_sql, " ", column_alias);
}
} else {
PHALCON_CPY_WRT(column_alias_sql, column_domain_sql);
}
} else {
PHALCON_CPY_WRT(column_alias_sql, column_domain_sql);
}
phalcon_array_append(&selected_columns, column_alias_sql, PH_SEPARATE);
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_VAR(columns_sql);
phalcon_fast_join_str(columns_sql, SL(", "), selected_columns TSRMLS_CC);
} else {
PHALCON_CPY_WRT(columns_sql, columns);
}
/**
* Check and escape tables
*/
PHALCON_OBS_VAR(tables);
phalcon_array_fetch_string(&tables, definition, SL("tables"), PH_NOISY);
if (Z_TYPE_P(tables) == IS_ARRAY) {
PHALCON_INIT_VAR(selected_tables);
array_init(selected_tables);
phalcon_is_iterable(tables, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(table);
PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
PHALCON_INIT_VAR(tables_sql);
phalcon_fast_join_str(tables_sql, SL(", "), selected_tables TSRMLS_CC);
} else {
PHALCON_CPY_WRT(tables_sql, tables);
}
PHALCON_INIT_VAR(sql);
if (phalcon_array_isset_string_fetch(&distinct, definition, SS("definition"))) {
assert(Z_TYPE_P(distinct) == IS_LONG);
if (Z_LVAL_P(distinct) == 0) {
ZVAL_STRING(sql, "SELECT ALL ", 1);
}
else if (Z_LVAL_P(distinct) == 1) {
ZVAL_STRING(sql, "SELECT DISTINCT ", 1);
}
else {
ZVAL_STRING(sql, "SELECT ", 1);
}
}
else {
ZVAL_STRING(sql, "SELECT ", 1);
}
/**
* Check for joins
*/
if (phalcon_array_isset_string(definition, SS("joins"))) {
PHALCON_OBS_VAR(joins);
phalcon_array_fetch_string(&joins, definition, SL("joins"), PH_NOISY);
phalcon_is_iterable(joins, &ah2, &hp2, 0, 0);
while (zend_hash_get_current_data_ex(ah2, (void**) &hd, &hp2) == SUCCESS) {
PHALCON_GET_HVALUE(join);
PHALCON_OBS_NVAR(type);
phalcon_array_fetch_string(&type, join, SL("type"), PH_NOISY);
PHALCON_OBS_NVAR(table);
phalcon_array_fetch_string(&table, join, SL("source"), PH_NOISY);
PHALCON_CALL_METHOD(&sql_table, this_ptr, "getsqltable", table, escape_char);
phalcon_array_append(&selected_tables, sql_table, PH_SEPARATE);
PHALCON_INIT_NVAR(sql_join);
PHALCON_CONCAT_SVSV(sql_join, " ", type, " JOIN ", sql_table);
/**
* Check if the join has conditions
*/
if (phalcon_array_isset_string(join, SS("conditions"))) {
PHALCON_OBS_NVAR(join_conditions_array);
phalcon_array_fetch_string(&join_conditions_array, join, SL("conditions"), PH_NOISY);
if (phalcon_fast_count_ev(join_conditions_array TSRMLS_CC)) {
PHALCON_INIT_NVAR(join_expressions);
array_init(join_expressions);
phalcon_is_iterable(join_conditions_array, &ah3, &hp3, 0, 0);
while (zend_hash_get_current_data_ex(ah3, (void**) &hd, &hp3) == SUCCESS) {
PHALCON_GET_HVALUE(join_condition);
PHALCON_CALL_METHOD(&join_expression, this_ptr, "getsqlexpression", join_condition, escape_char);
phalcon_array_append(&join_expressions, join_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah3, &hp3);
}
PHALCON_INIT_NVAR(join_conditions);
phalcon_fast_join_str(join_conditions, SL(" AND "), join_expressions TSRMLS_CC);
PHALCON_SCONCAT_SV(sql_join, " ON ", join_conditions);
}
}
phalcon_concat_self(&sql, sql_join TSRMLS_CC);
zend_hash_move_forward_ex(ah2, &hp2);
}
}
/**
* Check for a WHERE clause
*/
if (phalcon_array_isset_string(definition, SS("where"))) {
PHALCON_OBS_VAR(where_conditions);
phalcon_array_fetch_string(&where_conditions, definition, SL("where"), PH_NOISY);
if (Z_TYPE_P(where_conditions) == IS_ARRAY) {
PHALCON_CALL_METHOD(&where_expression, this_ptr, "getsqlexpression", where_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " WHERE ", where_expression);
} else {
PHALCON_SCONCAT_SV(sql, " WHERE ", where_conditions);
}
}
/**
* Check for a GROUP clause
*/
if (phalcon_array_isset_string(definition, SS("group"))) {
PHALCON_INIT_VAR(group_items);
array_init(group_items);
PHALCON_OBS_VAR(group_fields);
phalcon_array_fetch_string(&group_fields, definition, SL("group"), PH_NOISY);
phalcon_is_iterable(group_fields, &ah4, &hp4, 0, 0);
while (zend_hash_get_current_data_ex(ah4, (void**) &hd, &hp4) == SUCCESS) {
PHALCON_GET_HVALUE(group_field);
PHALCON_CALL_METHOD(&group_expression, this_ptr, "getsqlexpression", group_field, escape_char);
phalcon_array_append(&group_items, group_expression, PH_SEPARATE);
zend_hash_move_forward_ex(ah4, &hp4);
}
PHALCON_INIT_VAR(group_sql);
phalcon_fast_join_str(group_sql, SL(", "), group_items TSRMLS_CC);
PHALCON_INIT_VAR(group_clause);
PHALCON_CONCAT_SV(group_clause, " GROUP BY ", group_sql);
phalcon_concat_self(&sql, group_clause TSRMLS_CC);
}
/**
* Check for a HAVING clause
*/
if (phalcon_array_isset_string(definition, SS("having"))) {
PHALCON_OBS_VAR(having_conditions);
phalcon_array_fetch_string(&having_conditions, definition, SL("having"), PH_NOISY);
PHALCON_CALL_METHOD(&having_expression, this_ptr, "getsqlexpression", having_conditions, escape_char);
PHALCON_SCONCAT_SV(sql, " HAVING ", having_expression);
}
/**
* Check for a ORDER clause
*/
if (phalcon_array_isset_string(definition, SS("order"))) {
PHALCON_OBS_VAR(order_fields);
phalcon_array_fetch_string(&order_fields, definition, SL("order"), PH_NOISY);
PHALCON_INIT_VAR(order_items);
array_init(order_items);
phalcon_is_iterable(order_fields, &ah5, &hp5, 0, 0);
while (zend_hash_get_current_data_ex(ah5, (void**) &hd, &hp5) == SUCCESS) {
PHALCON_GET_HVALUE(order_item);
PHALCON_OBS_NVAR(order_expression);
phalcon_array_fetch_long(&order_expression, order_item, 0, PH_NOISY);
PHALCON_CALL_METHOD(&order_sql_item, this_ptr, "getsqlexpression", order_expression, escape_char);
/**
* In the numeric 1 position could be a ASC/DESC clause
*/
if (phalcon_array_isset_long(order_item, 1)) {
PHALCON_OBS_NVAR(sql_order_type);
phalcon_array_fetch_long(&sql_order_type, order_item, 1, PH_NOISY);
PHALCON_INIT_NVAR(order_sql_item_type);
PHALCON_CONCAT_VSV(order_sql_item_type, order_sql_item, " ", sql_order_type);
} else {
PHALCON_CPY_WRT(order_sql_item_type, order_sql_item);
}
phalcon_array_append(&order_items, order_sql_item_type, PH_SEPARATE);
zend_hash_move_forward_ex(ah5, &hp5);
}
PHALCON_INIT_VAR(order_sql);
phalcon_fast_join_str(order_sql, SL(", "), order_items TSRMLS_CC);
PHALCON_SCONCAT_SV(sql, " ORDER BY ", order_sql);
}
/**
* Oracle does not implement the LIMIT clause as some RDBMS do.
* We have to simulate it with subqueries and ROWNUM.
* Unfortunately because we use the column wildcard "*",
* this puts an extra column into the query result set.
*/
if (phalcon_array_isset_string_fetch(&limit_value, definition, SS("limit"))) {
if (likely(Z_TYPE_P(limit_value) == IS_ARRAY)) {
if (likely(phalcon_array_isset_string_fetch(&number, limit_value, SS("number")))) {
PHALCON_OBS_NVAR(tmp1);
phalcon_array_fetch_string(&tmp1, number, SL("value"), PH_NOISY);
if (phalcon_array_isset_string_fetch(&offset, limit_value, SS("offset"))) {
PHALCON_OBS_NVAR(tmp2);
phalcon_array_fetch_string(&tmp2, offset, SL("value"), PH_NOISY);
} else {
PHALCON_INIT_NVAR(tmp2);
ZVAL_LONG(tmp2, 0);
}
z_one = PHALCON_GLOBAL(z_one);
PHALCON_INIT_VAR(ini_range);
phalcon_add_function(ini_range, tmp2, z_one TSRMLS_CC);
PHALCON_INIT_VAR(end_range);
phalcon_add_function(end_range, tmp2, tmp1 TSRMLS_CC);
PHALCON_INIT_VAR(sql_limit);
PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range );
PHALCON_CPY_WRT(sql, sql_limit);
}
} else {
PHALCON_INIT_VAR(ini_range);
ZVAL_LONG(ini_range, 1);
PHALCON_CPY_WRT(end_range, limit_value);
PHALCON_INIT_VAR(sql_limit);
PHALCON_SCONCAT_SVSVSV(sql_limit,"SELECT Z2.* FROM (SELECT Z1.*, ROWNUM DB_ROWNUM FROM ( ", sql, " ) Z1 ) Z2 WHERE Z2.DB_ROWNUM BETWEEN ", ini_range , " AND ", end_range );
PHALCON_CPY_WRT(sql, sql_limit);
}
}
RETURN_CTOR(sql);
}
/**
* 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 *cached_content = NULL, *prepared_content = NULL, *ttl = NULL, *flags, *success = NULL;
zval *keys = NULL, *is_buffering = NULL;
zval *last_key, *frontend, *memcache, *options, *special_key;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC);
} else {
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(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;
}
frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
/**
* Check if a connection is created or make a new one
*/
memcache = phalcon_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
memcache = NULL;
PHALCON_CALL_METHOD(&memcache, this_ptr, "_connect");
}
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent");
} else {
cached_content = content;
}
/**
* Prepare the content in the frontend
*/
PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content);
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
zval *tmp = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(tmp) == IS_NULL) {
PHALCON_CALL_METHOD(&ttl, frontend, "getlifetime");
}
else {
ttl = tmp;
}
} else {
ttl = lifetime;
}
PHALCON_INIT_VAR(flags);
ZVAL_LONG(flags, 0);
/**
* We store without flags
*/
if (phalcon_is_numeric(cached_content)) {
PHALCON_CALL_METHOD(&success, memcache, "set", last_key, cached_content, flags, ttl);
} else {
PHALCON_CALL_METHOD(&success, memcache, "set", last_key, prepared_content, flags, ttl);
}
if (!zend_is_true(success)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Failed to store data in memcached");
return;
}
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&special_key, options, SS("statsKey")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
if (Z_TYPE_P(special_key) != IS_NULL) {
/* Update the stats key */
PHALCON_CALL_METHOD(&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);
PHALCON_CALL_METHOD(NULL, memcache, "set", special_key, keys);
}
}
PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD(NULL, 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();
}