*scope = old_scope;
return ret;
}
- }
+ }
ce = ce->parent;
} while (ce);
ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate) /* {{{ */
{
zval *tmp;
+ size_t _len = strlen(str);
+
+ if (UNEXPECTED(_len > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
MAKE_STD_ZVAL(tmp);
- ZVAL_STRING(tmp, str, duplicate);
+ ZVAL_STRINGL(tmp, str, _len, duplicate);
return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
}
{
zval *tmp;
+ if (UNEXPECTED(length > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
+
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, str, length, duplicate);
ZEND_API int add_index_string(zval *arg, ulong index, const char *str, int duplicate) /* {{{ */
{
zval *tmp;
+ size_t _len = strlen(str);
+
+ if (UNEXPECTED(_len > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
MAKE_STD_ZVAL(tmp);
ZVAL_STRING(tmp, str, duplicate);
{
zval *tmp;
+ if (UNEXPECTED(length > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
+
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, str, length, duplicate);
{
zval *tmp;
+ if (UNEXPECTED(length > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, str, length, duplicate);
ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate) /* {{{ */
{
zval *tmp;
+ size_t _len = strlen(str);
+
+ if (UNEXPECTED(_len > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
MAKE_STD_ZVAL(tmp);
- ZVAL_STRING(tmp, str, duplicate);
+ ZVAL_STRINGL(tmp, str, _len, duplicate);
return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
}
{
zval *tmp;
+ if (UNEXPECTED(length > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
+
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, str, length, duplicate);
{
zval *tmp;
zval *z_key;
+ size_t _len = strlen(str);
+
+ if (UNEXPECTED(_len > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
MAKE_STD_ZVAL(tmp);
- ZVAL_STRING(tmp, str, duplicate);
+ ZVAL_STRINGL(tmp, str, _len, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
zval *tmp;
zval *z_key;
+ if (UNEXPECTED(length > INT_MAX)) {
+ zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
+ }
+
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, str, length, duplicate);
module_post_deactivate_handlers = module_request_shutdown_handlers + shutdown_count + 1;
module_post_deactivate_handlers[post_deactivate_count] = NULL;
startup_count = 0;
-
+
for (zend_hash_internal_pointer_reset_ex(&module_registry, &pos);
zend_hash_get_current_data_ex(&module_registry, (void *) &module, &pos) == SUCCESS;
zend_hash_move_forward_ex(&module_registry, &pos)) {
}
if (ptr->arg_info) {
zend_internal_function_info *info = (zend_internal_function_info*)ptr->arg_info;
-
+
internal_function->arg_info = (zend_arg_info*)ptr->arg_info+1;
internal_function->num_args = ptr->num_args;
/* Currently you cannot denote that the function can accept less arguments than num_args */
}
ret = 1;
}
- } else if (name_len == sizeof("parent") - 1 &&
+ } else if (name_len == sizeof("parent") - 1 &&
!memcmp(lcname, "parent", sizeof("parent") - 1)) {
if (!EG(scope)) {
if (error) *error = estrdup("cannot access parent:: when no class scope is active");
if (error) {
*error = NULL;
}
-
+
fcc->initialized = 0;
fcc->calling_scope = NULL;
fcc->called_scope = NULL;
object_ptr = NULL;
}
if (object_ptr &&
- (!EG(objects_store).object_buckets ||
+ (!EG(objects_store).object_buckets ||
!EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(object_ptr)].valid)) {
return 0;
}
}
} else {
- if (!EG(objects_store).object_buckets ||
+ if (!EG(objects_store).object_buckets ||
!EG(objects_store).object_buckets[Z_OBJ_HANDLE_PP(obj)].valid) {
return 0;
}
*callable_name = emalloc(*callable_name_len + 1);
memcpy(*callable_name, ce->name, ce->name_length);
memcpy((*callable_name) + ce->name_length, "::__invoke", sizeof("::__invoke"));
- }
+ }
return 1;
}
/* break missing intentionally */
static void _php_pgsql_notice_handler(void *resource_id, const char *message)
{
php_pgsql_notice *notice;
-
+
TSRMLS_FETCH();
if (! PGG(ignore_notices)) {
notice = (php_pgsql_notice *)emalloc(sizeof(php_pgsql_notice));
/* {{{ _php_pgsql_notice_dtor
*/
-static void _php_pgsql_notice_ptr_dtor(void **ptr)
+static void _php_pgsql_notice_ptr_dtor(void **ptr)
{
php_pgsql_notice *notice = (php_pgsql_notice *)*ptr;
if (notice) {
PGresult *res;
int orig;
- if (Z_TYPE_P(rsrc) != le_plink)
+ if (Z_TYPE_P(rsrc) != le_plink)
return 0;
link = (PGconn *) rsrc->ptr;
php_error_docref("ref.pgsql" TSRMLS_CC, E_NOTICE, "Cannot set connection to blocking mode");
return -1;
}
-
+
while ((res = PQgetResult(link))) {
PQclear(res);
}
{
memset(pgsql_globals, 0, sizeof(zend_pgsql_globals));
/* Initilize notice message hash at MINIT only */
- zend_hash_init_ex(&pgsql_globals->notices, 0, NULL, PHP_PGSQL_NOTICE_PTR_DTOR, 1, 0);
+ zend_hash_init_ex(&pgsql_globals->notices, 0, NULL, PHP_PGSQL_NOTICE_PTR_DTOR, 1, 0);
}
/* }}} */
}
smart_str_appends(&str, "pgsql");
-
+
for (i = 0; i < ZEND_NUM_ARGS(); i++) {
/* make sure that the PGSQL_CONNECT_FORCE_NEW bit is not part of the hash so that subsequent connections
* can re-use this connection. Bug #39979
- */
+ */
if (i == 1 && ZEND_NUM_ARGS() == 2 && Z_TYPE_PP(args[i]) == IS_LONG) {
if (Z_LVAL_PP(args[1]) == PGSQL_CONNECT_FORCE_NEW) {
continue;
if (persistent && PGG(allow_persistent)) {
zend_rsrc_list_entry *le;
-
+
/* try to find if we already have this link in our persistent list */
if (zend_hash_find(&EG(persistent_list), str.c, str.len+1, (void **) &le)==FAILURE) { /* we don't */
zend_rsrc_list_entry new_le;
-
+
if (PGG(max_links)!=-1 && PGG(num_links)>=PGG(max_links)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Cannot create new link. Too many open links (%ld)", PGG(num_links));
PQsetNoticeProcessor(pgsql, _php_pgsql_notice_handler, (void*)Z_RESVAL_P(return_value));
}
php_pgsql_set_default_link(Z_LVAL_P(return_value) TSRMLS_CC);
-
+
cleanup:
smart_str_free(&str);
return;
/* }}} */
/* {{{ proto bool pg_close([resource connection])
- Close a PostgreSQL connection */
+ Close a PostgreSQL connection */
PHP_FUNCTION(pg_close)
{
zval *pgsql_link = NULL;
if (zend_parse_parameters(argc TSRMLS_CC, "|r", &pgsql_link) == FAILURE) {
return;
}
-
+
if (argc == 0) {
id = PGG(default_link);
CHECK_DEFAULT_LINK(id);
}
-
+
if (pgsql_link == NULL && id == -1) {
RETURN_FALSE;
}
/* }}} */
/* {{{ proto string pg_dbname([resource connection])
- Get the database name */
+ Get the database name */
PHP_FUNCTION(pg_dbname)
{
php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_DBNAME);
PGresult *pgsql_result;
ExecStatusType status;
pgsql_result_handle *pg_result;
-
+
if (argc == 2) {
if (zend_parse_parameters(argc TSRMLS_CC, "sa", &query, &query_len, &pv_param_arr) == FAILURE) {
return;
}
}
- pgsql_result = PQexecParams(pgsql, query, num_params,
+ pgsql_result = PQexecParams(pgsql, query, num_params,
NULL, (const char * const *)params, NULL, NULL, 0);
if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
PQclear(pgsql_result);
PQreset(pgsql);
- pgsql_result = PQexecParams(pgsql, query, num_params,
+ pgsql_result = PQexecParams(pgsql, query, num_params,
NULL, (const char * const *)params, NULL, NULL, 0);
}
} else {
status = (ExecStatusType) PQstatus(pgsql);
}
-
+
_php_pgsql_free_params(params, num_params);
switch (status) {
}
}
- pgsql_result = PQexecPrepared(pgsql, stmtname, num_params,
+ pgsql_result = PQexecPrepared(pgsql, stmtname, num_params,
(const char * const *)params, NULL, NULL, 0);
if ((PGG(auto_reset_persistent) & 2) && PQstatus(pgsql) != CONNECTION_OK) {
PQclear(pgsql_result);
PQreset(pgsql);
- pgsql_result = PQexecPrepared(pgsql, stmtname, num_params,
+ pgsql_result = PQexecPrepared(pgsql, stmtname, num_params,
(const char * const *)params, NULL, NULL, 0);
}
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &result) == FAILURE) {
return;
}
-
+
ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, &result, -1, "PostgreSQL result", le_result);
pgsql_result = pg_result->result;
/* {{{ proto string pg_last_notice(resource connection)
Returns the last notice set by the backend */
-PHP_FUNCTION(pg_last_notice)
+PHP_FUNCTION(pg_last_notice)
{
zval *pgsql_link;
PGconn *pg_link;
int id = -1;
php_pgsql_notice **notice;
-
+
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pgsql_link) == FAILURE) {
return;
}
if ((tmp_oid = PQgetvalue(result,i,oid_offset))==NULL) {
continue;
}
-
+
str.len = 0;
smart_str_appends(&str, "pgsql_oid_");
smart_str_appends(&str, tmp_oid);
ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, &result, -1, "PostgreSQL result", le_result);
pgsql_result = pg_result->result;
-
+
if (field < 0 || field >= PQnfields(pgsql_result)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad field offset specified");
RETURN_FALSE;
Z_TYPE_P(return_value) = IS_STRING;
break;
case PHP_PG_FIELD_TYPE_OID:
-
+
oid = PQftype(pgsql_result, field);
#if UINT_MAX > LONG_MAX
if (oid > LONG_MAX) {
/* }}} */
/* {{{ proto int pg_field_size(resource result, int field_number)
- Returns the internal size of the field */
+ Returns the internal size of the field */
PHP_FUNCTION(pg_field_size)
{
php_pgsql_get_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU,PHP_PG_FIELD_SIZE);
return;
}
}
-
+
ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, &result, -1, "PostgreSQL result", le_result);
pgsql_result = pg_result->result;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid result type");
RETURN_FALSE;
}
-
+
ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, &result, -1, "PostgreSQL result", le_result);
pgsql_result = pg_result->result;
- if (use_row) {
+ if (use_row) {
pgsql_row = row;
pg_result->row = pgsql_row;
if (pgsql_row < 0 || pgsql_row >= PQntuples(pgsql_result)) {
/* }}} */
/* {{{ proto array pg_fetch_row(resource result [, int row [, int result_type]])
- Get a row as an enumerated array */
+ Get a row as an enumerated array */
PHP_FUNCTION(pg_fetch_row)
{
php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, PGSQL_NUM, 0);
if (PQgetisnull(pgsql_result, pg_row, colno)) {
add_next_index_null(return_value);
} else {
- add_next_index_string(return_value, PQgetvalue(pgsql_result, pg_row, colno), 1);
+ add_next_index_string(return_value, PQgetvalue(pgsql_result, pg_row, colno), 1);
}
}
}
zval *pgsql_link = NULL;
int id = -1, argc = ZEND_NUM_ARGS();
PGconn *pgsql;
-
+
if (zend_parse_parameters(argc TSRMLS_CC, "|r", &pgsql_link) == FAILURE) {
return;
}
- if (argc == 0) {
+ if (argc == 0) {
id = PGG(default_link);
CHECK_DEFAULT_LINK(id);
}
oid = pgsql_link;
pgsql_link = NULL;
}
-
+
if (pgsql_link == NULL) {
id = PGG(default_link);
CHECK_DEFAULT_LINK(id);
}
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
-
+
if (oid) {
#ifndef HAVE_PG_LO_CREATE
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Passing OID value is not supported. Upgrade your PostgreSQL");
}
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
-
+
/* r/w/+ is little bit more PHP-like than INV_READ/INV_WRITE and a lot of
faster to type. Unfortunately, doesn't behave the same way as fopen()...
(Jouni)
}
ZEND_FETCH_RESOURCE(pgsql, pgLofp *, &pgsql_lofp, -1, "PostgreSQL large object", le_lofp);
-
+
if (lo_close((PGconn *)pgsql->conn, pgsql->lofd) < 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to close PostgreSQL large object descriptor %d", pgsql->lofd);
RETVAL_FALSE;
if (argc > 1) {
buf_len = len;
}
-
+
buf = (char *) safe_emalloc(sizeof(char), (buf_len+1), 0);
if ((nbytes = lo_read((PGconn *)pgsql->conn, pgsql->lofd, buf, buf_len))<0) {
efree(buf);
volatile int nbytes;
char buf[PGSQL_LO_READ_BUF_SIZE];
pgLofp *pgsql;
-
+
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pgsql_id) == FAILURE) {
return;
}
else {
WRONG_PARAM_COUNT;
}
-
+
if (php_check_open_basedir(file_in TSRMLS_CC)) {
RETURN_FALSE;
}
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Requires 2 or 3 arguments");
RETURN_FALSE;
}
-
+
if (php_check_open_basedir(file_out TSRMLS_CC)) {
RETURN_FALSE;
}
if (pgsql_link == NULL && id == -1) {
RETURN_FALSE;
- }
+ }
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
if (zend_parse_parameters(argc TSRMLS_CC, "|r", &pgsql_link) == FAILURE) {
return;
}
-
+
if (argc == 0) {
id = PGG(default_link);
CHECK_DEFAULT_LINK(id);
if (pgsql_link == NULL && id == -1) {
RETURN_FALSE;
- }
+ }
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
if (zend_parse_parameters(argc TSRMLS_CC, "|r", &pgsql_link) == FAILURE) {
return;
}
-
+
if (argc == 0) {
id = PGG(default_link);
CHECK_DEFAULT_LINK(id);
if (pgsql_link == NULL && id == -1) {
RETURN_FALSE;
- }
+ }
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
csv = (char *)erealloc(csv, strlen(csv) + sizeof(char)*(COPYBUFSIZ+1));
strcat(csv, copybuf);
}
-
+
switch (ret)
{
case EOF:
break;
}
- to = (char *) safe_emalloc(from_len, 2, 1);
+ to = (char *) safe_emalloc_string(from_len, 2, 1);
#ifdef HAVE_PQESCAPE_CONN
if (pgsql_link != NULL || id != -1) {
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
#endif
to = (char *)PQescapeBytea((unsigned char*)from, from_len, &to_len);
- RETVAL_STRINGL(to, to_len-1, 1); /* to_len includes additional '\0' */
+ RETVAL_STRINGL_CHECK(to, to_len-1, 1); /* to_len includes additional '\0' */
PQfreemem(to);
}
/* }}} */
if (isdigit(*sp)) /* state=4 */
{
unsigned char *start, *end, buf[4]; /* 000 + '\0' */
-
+
bp -= 3;
memcpy(buf, sp-2, 3);
buf[3] = '\0';
to = estrdup(tmp);
PGSQLfree(tmp);
- RETURN_STRING(to, 0);
+ RETVAL_STRINGL_CHECK(to, strlen(to), 0);
}
/* {{{ proto string pg_escape_literal([resource connection,] string data)
&result) == FAILURE) {
RETURN_FALSE;
}
-
+
ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, &result, -1, "PostgreSQL result", le_result);
pgsql_result = pg_result->result;
&result, &fieldcode) == FAILURE) {
RETURN_FALSE;
}
-
+
ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, &result, -1, "PostgreSQL result", le_result);
pgsql_result = pg_result->result;
zval *pgsql_link;
int id = -1;
PGconn *pgsql;
-
+
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "r",
&pgsql_link) == FAILURE) {
RETURN_FALSE;
}
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
-
+
PQreset(pgsql);
if (PQstatus(pgsql) == CONNECTION_BAD) {
RETURN_FALSE;
/* {{{ php_pgsql_flush_query
*/
-static int php_pgsql_flush_query(PGconn *pgsql TSRMLS_DC)
+static int php_pgsql_flush_query(PGconn *pgsql TSRMLS_DC)
{
PGresult *res;
int leftover = 0;
-
+
if (PQ_SETNONBLOCKING(pgsql, 1)) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE,"Cannot set connection to nonblocking mode");
return -1;
/* {{{ php_pgsql_do_async
*/
-static void php_pgsql_do_async(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
+static void php_pgsql_do_async(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
{
zval *pgsql_link;
int id = -1;
if (num_params > 0) {
int i = 0;
params = (char **)safe_emalloc(sizeof(char *), num_params, 0);
-
+
for(i = 0; i < num_params; i++) {
if (zend_hash_get_current_data(Z_ARRVAL_P(pv_param_arr), (void **) &tmp) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error getting parameter");
}
ZEND_FETCH_RESOURCE2(pgsql, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
-
+
pgsql_result = PQgetResult(pgsql);
if (!pgsql_result) {
/* no result */
if (result_type & PGSQL_NUM) {
add_index_string(return_value, 0, pgsql_notify->relname, 1);
add_index_long(return_value, 1, pgsql_notify->be_pid);
-#if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
+#if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
if (PQprotocolVersion(pgsql) >= 3 && atof(PQparameterStatus(pgsql, "server_version")) >= 9.0) {
-#else
+#else
if (atof(PG_VERSION) >= 9.0) {
-#endif
+#endif
#if HAVE_PQPARAMETERSTATUS
add_index_string(return_value, 2, pgsql_notify->extra, 1);
#endif
if (result_type & PGSQL_ASSOC) {
add_assoc_string(return_value, "message", pgsql_notify->relname, 1);
add_assoc_long(return_value, "pid", pgsql_notify->be_pid);
-#if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
+#if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS
if (PQprotocolVersion(pgsql) >= 3 && atof(PQparameterStatus(pgsql, "server_version")) >= 9.0) {
-#else
+#else
if (atof(PG_VERSION) >= 9.0) {
-#endif
+#endif
#if HAVE_PQPARAMETERSTATUS
add_assoc_string(return_value, "payload", pgsql_notify->extra, 1);
#endif
add_assoc_zval(meta, name, elem);
}
PQclear(pg_result);
-
+
return SUCCESS;
}
/* {{{ php_pgsql_add_quote
* add quotes around string.
*/
-static int php_pgsql_add_quotes(zval *src, zend_bool should_free TSRMLS_DC)
+static int php_pgsql_add_quotes(zval *src, zend_bool should_free TSRMLS_DC)
{
smart_str str = {0};
/* {{{ php_pgsql_convert
* check and convert array values (fieldname=>vlaue pair) for sql
*/
-PHP_PGSQL_API int php_pgsql_convert(PGconn *pg_link, const char *table_name, const zval *values, zval *result, ulong opt TSRMLS_DC)
+PHP_PGSQL_API int php_pgsql_convert(PGconn *pg_link, const char *table_name, const zval *values, zval *result, ulong opt TSRMLS_DC)
{
HashPosition pos;
char *field = NULL;
ZVAL_DOUBLE(new_val, Z_DVAL_PP(val));
convert_to_long_ex(&new_val);
break;
-
+
case IS_LONG:
ZVAL_LONG(new_val, Z_LVAL_PP(val));
break;
-
+
case IS_NULL:
ZVAL_STRINGL(new_val, "NULL", sizeof("NULL")-1, 1);
break;
}
}
break;
-
+
case IS_NULL:
ZVAL_STRINGL(new_val, "NULL", sizeof("NULL")-1, 1);
break;
interval values can be written with the following syntax:
[@] quantity unit [quantity unit...] [direction]
-
+
Where: quantity is a number (possibly signed); unit is second, minute, hour,
day, week, month, year, decade, century, millennium, or abbreviations or
plurals of these units [note not *all* abbreviations] ; direction can be
ago or empty. The at sign (@) is optional noise.
-
+
...
-
+
Quantities of days, hours, minutes, and seconds can be specified without explicit
unit markings. For example, '1 12:59:10' is read the same as '1 day 12 hours 59 min 10
sec'.
"decades|decade|dec|decs|"
"years|year|y|"
"months|month|mon|"
- "weeks|week|w|"
+ "weeks|week|w|"
"days|day|d|"
"hours|hour|hr|hrs|h|"
"minutes|minute|mins|min|m|"
"years|year|y|"
"months|month|mon|"
"weeks|week|w|"
- "days|day|d))+"
+ "days|day|d))+"
"([-+]?[ \\t]+"
"([0-9]+[ \\t]+)+" /* dd */
"(([0-9]{1,2}:){0,2}[0-9]{0,2})" /* hh:[mm:[ss]] */
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Expects NULL, string, long or double value for PostgreSQL '%s' (%s)", Z_STRVAL_PP(type), field);
}
break;
-
+
#endif
case PG_MACADDR:
switch(Z_TYPE_PP(val)) {
}
querystr.len--;
smart_str_appends(&querystr, ") VALUES (");
-
+
/* make values string */
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(var_array), &pos);
zend_hash_get_current_data_ex(Z_ARRVAL_P(var_array), (void **)&val, &pos) == SUCCESS;
zend_hash_move_forward_ex(Z_ARRVAL_P(var_array), &pos)) {
-
+
/* we can avoid the key_type check here, because we tested it in the other loop */
switch(Z_TYPE_PP(val)) {
case IS_STRING:
else if (opt & PGSQL_DML_STRING) {
ret = SUCCESS;
}
-
+
cleanup:
if (!(opt & PGSQL_DML_NO_CONV) && converted) {
zval_dtor(converted);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid option is specified");
RETURN_FALSE;
}
-
+
ZEND_FETCH_RESOURCE2(pg_link, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
if (php_pgsql_flush_query(pg_link TSRMLS_CC)) {
/* {{{ php_pgsql_update
*/
-PHP_PGSQL_API int php_pgsql_update(PGconn *pg_link, const char *table, zval *var_array, zval *ids_array, ulong opt, char **sql TSRMLS_DC)
+PHP_PGSQL_API int php_pgsql_update(PGconn *pg_link, const char *table, zval *var_array, zval *ids_array, ulong opt, char **sql TSRMLS_DC)
{
zval *var_converted = NULL, *ids_converted = NULL;
smart_str querystr = {0};
if (build_assignment_string(pg_link, &querystr, Z_ARRVAL_P(var_array), 0, ",", 1, opt TSRMLS_CC))
goto cleanup;
-
+
smart_str_appends(&querystr, " WHERE ");
-
+
if (build_assignment_string(pg_link, &querystr, Z_ARRVAL_P(ids_array), 1, " AND ", sizeof(" AND ")-1, opt TSRMLS_CC))
goto cleanup;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid option is specified");
RETURN_FALSE;
}
-
+
ZEND_FETCH_RESOURCE2(pg_link, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
if (php_pgsql_flush_query(pg_link TSRMLS_CC)) {
/* {{{ php_pgsql_delete
*/
-PHP_PGSQL_API int php_pgsql_delete(PGconn *pg_link, const char *table, zval *ids_array, ulong opt, char **sql TSRMLS_DC)
+PHP_PGSQL_API int php_pgsql_delete(PGconn *pg_link, const char *table, zval *ids_array, ulong opt, char **sql TSRMLS_DC)
{
zval *ids_converted = NULL;
smart_str querystr = {0};
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid option is specified");
RETURN_FALSE;
}
-
+
ZEND_FETCH_RESOURCE2(pg_link, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
if (php_pgsql_flush_query(pg_link TSRMLS_CC)) {
RETURN_STRING(sql, 0);
}
RETURN_TRUE;
-}
+}
/* }}} */
/* {{{ php_pgsql_result2array
*/
-PHP_PGSQL_API int php_pgsql_result2array(PGresult *pg_result, zval *ret_array TSRMLS_DC)
+PHP_PGSQL_API int php_pgsql_result2array(PGresult *pg_result, zval *ret_array TSRMLS_DC)
{
zval *row;
char *field_name;
data = safe_estrndup(element, element_len);
data_len = element_len;
-
+
field_name = PQfname(pg_result, i);
add_assoc_stringl(row, field_name, data, data_len, 0);
}
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid option is specified");
RETURN_FALSE;
}
-
+
ZEND_FETCH_RESOURCE2(pg_link, PGconn *, &pgsql_link, id, "PostgreSQL link", le_link, le_plink);
if (php_pgsql_flush_query(pg_link TSRMLS_CC)) {
projects / php / commitdiff