diff options
Diffstat (limited to 'ext/pdo_firebird/firebird_statement.c')
| -rw-r--r-- | ext/pdo_firebird/firebird_statement.c | 710 |
1 files changed, 710 insertions, 0 deletions
diff --git a/ext/pdo_firebird/firebird_statement.c b/ext/pdo_firebird/firebird_statement.c new file mode 100644 index 0000000..5c3e435 --- /dev/null +++ b/ext/pdo_firebird/firebird_statement.c @@ -0,0 +1,710 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2013 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 3.01 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.php.net/license/3_01.txt | + | If you did not receive a copy of the PHP license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Author: Ard Biesheuvel <abies@php.net> | + +----------------------------------------------------------------------+ +*/ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "php.h" +#include "php_ini.h" +#include "ext/standard/info.h" +#include "pdo/php_pdo.h" +#include "pdo/php_pdo_driver.h" +#include "php_pdo_firebird.h" +#include "php_pdo_firebird_int.h" + +#include <time.h> + +#define RECORD_ERROR(stmt) _firebird_error(NULL, stmt, __FILE__, __LINE__ TSRMLS_CC) + +/* free the allocated space for passing field values to the db and back */ +static void free_sqlda(XSQLDA const *sqlda) /* {{{ */ +{ + int i; + + for (i = 0; i < sqlda->sqld; ++i) { + XSQLVAR const *var = &sqlda->sqlvar[i]; + + if (var->sqlind) { + efree(var->sqlind); + } + } +} +/* }}} */ + +/* called by PDO to clean up a statement handle */ +static int firebird_stmt_dtor(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + int result = 1, i; + + /* release the statement */ + if (isc_dsql_free_statement(S->H->isc_status, &S->stmt, DSQL_drop)) { + RECORD_ERROR(stmt); + result = 0; + } + + /* clean up the fetch buffers if they have been used */ + for (i = 0; i < S->out_sqlda.sqld; ++i) { + if (S->fetch_buf[i]) { + efree(S->fetch_buf[i]); + } + } + efree(S->fetch_buf); + + zend_hash_destroy(S->named_params); + FREE_HASHTABLE(S->named_params); + + /* clean up the input descriptor */ + if (S->in_sqlda) { + free_sqlda(S->in_sqlda); + efree(S->in_sqlda); + } + + free_sqlda(&S->out_sqlda); + efree(S); + + return result; +} +/* }}} */ + +/* called by PDO to execute a prepared query */ +static int firebird_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + pdo_firebird_db_handle *H = S->H; + unsigned long affected_rows = 0; + static char info_count[] = {isc_info_sql_records}; + char result[64]; + + do { + /* named or open cursors should be closed first */ + if ((*S->name || S->cursor_open) && isc_dsql_free_statement(H->isc_status, &S->stmt, DSQL_close)) { + break; + } + S->cursor_open = 0; + /* assume all params have been bound */ + + if (isc_dsql_execute(H->isc_status, &H->tr, &S->stmt, PDO_FB_SQLDA_VERSION, S->in_sqlda)) { + break; + } + + /* Determine how many rows have changed. In this case we are + * only interested in rows changed, not rows retrieved. That + * should be handled by the client when fetching. */ + stmt->row_count = affected_rows; + + switch (S->statement_type) { + case isc_info_sql_stmt_insert: + case isc_info_sql_stmt_update: + case isc_info_sql_stmt_delete: + case isc_info_sql_stmt_exec_procedure: + if (isc_dsql_sql_info(H->isc_status, &S->stmt, sizeof ( info_count), + info_count, sizeof(result), result)) { + break; + } + if (result[0] == isc_info_sql_records) { + unsigned i = 3, result_size = isc_vax_integer(&result[1], 2); + while (result[i] != isc_info_end && i < result_size) { + short len = (short) isc_vax_integer(&result[i + 1], 2); + if (result[i] != isc_info_req_select_count) { + affected_rows += isc_vax_integer(&result[i + 3], len); + } + i += len + 3; + } + stmt->row_count = affected_rows; + } + default: + ; + } + + /* commit? */ + if (stmt->dbh->auto_commit && isc_commit_retaining(H->isc_status, &H->tr)) { + break; + } + + *S->name = 0; + S->cursor_open = (S->out_sqlda.sqln > 0); /* A cursor is opened, when more than zero columns returned */ + S->exhausted = !S->cursor_open; + + return 1; + } while (0); + + RECORD_ERROR(stmt); + + return 0; +} +/* }}} */ + +/* called by PDO to fetch the next row from a statement */ +static int firebird_stmt_fetch(pdo_stmt_t *stmt, /* {{{ */ + enum pdo_fetch_orientation ori, long offset TSRMLS_DC) +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + pdo_firebird_db_handle *H = S->H; + + if (!stmt->executed) { + strcpy(stmt->error_code, "HY000"); + H->last_app_error = "Cannot fetch from a closed cursor"; + } else if (!S->exhausted) { + if (isc_dsql_fetch(H->isc_status, &S->stmt, PDO_FB_SQLDA_VERSION, &S->out_sqlda)) { + if (H->isc_status[0] && H->isc_status[1]) { + RECORD_ERROR(stmt); + } + S->exhausted = 1; + return 0; + } + if (S->statement_type == isc_info_sql_stmt_exec_procedure) { + S->exhausted = 1; + } + stmt->row_count++; + return 1; + } + return 0; +} +/* }}} */ + +/* called by PDO to retrieve information about the fields being returned */ +static int firebird_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC) /* {{{ */ +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + struct pdo_column_data *col = &stmt->columns[colno]; + XSQLVAR *var = &S->out_sqlda.sqlvar[colno]; + int colname_len; + char *cp; + + /* allocate storage for the column */ + var->sqlind = (void*)ecalloc(1, var->sqllen + 2*sizeof(short)); + var->sqldata = &((char*)var->sqlind)[sizeof(short)]; + + colname_len = (S->H->fetch_table_names && var->relname_length) + ? (var->aliasname_length + var->relname_length + 1) + : (var->aliasname_length); + col->precision = -var->sqlscale; + col->maxlen = var->sqllen; + col->namelen = colname_len; + col->name = cp = emalloc(colname_len + 1); + if (colname_len > var->aliasname_length) { + memmove(cp, var->relname, var->relname_length); + cp += var->relname_length; + *cp++ = '.'; + } + memmove(cp, var->aliasname, var->aliasname_length); + *(cp+var->aliasname_length) = '\0'; + col->param_type = PDO_PARAM_STR; + + return 1; +} +/* }}} */ + +#define FETCH_BUF(buf,type,len,lenvar) ((buf) = (buf) ? (buf) : \ + emalloc((len) ? (len * sizeof(type)) : ((*(unsigned long*)lenvar) = sizeof(type)))) + +#define CHAR_BUF_LEN 24 + +/* fetch a blob into a fetch buffer */ +static int firebird_fetch_blob(pdo_stmt_t *stmt, int colno, char **ptr, /* {{{ */ + unsigned long *len, ISC_QUAD *blob_id TSRMLS_DC) +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + pdo_firebird_db_handle *H = S->H; + isc_blob_handle blobh = NULL; + char const bl_item = isc_info_blob_total_length; + char bl_info[20]; + unsigned short i; + int result = *len = 0; + + if (isc_open_blob(H->isc_status, &H->db, &H->tr, &blobh, blob_id)) { + RECORD_ERROR(stmt); + return 0; + } + + if (isc_blob_info(H->isc_status, &blobh, 1, const_cast(&bl_item), + sizeof(bl_info), bl_info)) { + RECORD_ERROR(stmt); + goto fetch_blob_end; + } + + /* find total length of blob's data */ + for (i = 0; i < sizeof(bl_info); ) { + unsigned short item_len; + char item = bl_info[i++]; + + if (item == isc_info_end || item == isc_info_truncated || item == isc_info_error + || i >= sizeof(bl_info)) { + H->last_app_error = "Couldn't determine BLOB size"; + goto fetch_blob_end; + } + + item_len = (unsigned short) isc_vax_integer(&bl_info[i], 2); + + if (item == isc_info_blob_total_length) { + *len = isc_vax_integer(&bl_info[i+2], item_len); + break; + } + i += item_len+2; + } + + /* we've found the blob's length, now fetch! */ + + if (*len) { + unsigned long cur_len; + unsigned short seg_len; + ISC_STATUS stat; + + *ptr = S->fetch_buf[colno] = erealloc(*ptr, *len+1); + + for (cur_len = stat = 0; (!stat || stat == isc_segment) && cur_len < *len; cur_len += seg_len) { + + unsigned short chunk_size = (*len-cur_len) > USHRT_MAX ? USHRT_MAX + : (unsigned short)(*len-cur_len); + + stat = isc_get_segment(H->isc_status, &blobh, &seg_len, chunk_size, &(*ptr)[cur_len]); + } + + (*ptr)[*len++] = '\0'; + + if (H->isc_status[0] == 1 && (stat != 0 && stat != isc_segstr_eof && stat != isc_segment)) { + H->last_app_error = "Error reading from BLOB"; + goto fetch_blob_end; + } + } + result = 1; + +fetch_blob_end: + if (isc_close_blob(H->isc_status, &blobh)) { + RECORD_ERROR(stmt); + return 0; + } + return result; +} +/* }}} */ + +static int firebird_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, /* {{{ */ + unsigned long *len, int *caller_frees TSRMLS_DC) +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + XSQLVAR const *var = &S->out_sqlda.sqlvar[colno]; + + if (*var->sqlind == -1) { + /* A NULL value */ + *ptr = NULL; + *len = 0; + } else { + if (var->sqlscale < 0) { + static ISC_INT64 const scales[] = { 1, 10, 100, 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + LL_LIT(10000000000), + LL_LIT(100000000000), + LL_LIT(1000000000000), + LL_LIT(10000000000000), + LL_LIT(100000000000000), + LL_LIT(1000000000000000), + LL_LIT(10000000000000000), + LL_LIT(100000000000000000), + LL_LIT(1000000000000000000) + }; + ISC_INT64 n, f = scales[-var->sqlscale]; + + switch (var->sqltype & ~1) { + case SQL_SHORT: + n = *(short*)var->sqldata; + break; + case SQL_LONG: + n = *(ISC_LONG*)var->sqldata; + break; + case SQL_INT64: + n = *(ISC_INT64*)var->sqldata; + } + + *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); + + if (n >= 0) { + *len = slprintf(*ptr, CHAR_BUF_LEN, "%" LL_MASK "d.%0*" LL_MASK "d", + n / f, -var->sqlscale, n % f); + } else if (n < -f) { + *len = slprintf(*ptr, CHAR_BUF_LEN, "%" LL_MASK "d.%0*" LL_MASK "d", + n / f, -var->sqlscale, -n % f); + } else { + *len = slprintf(*ptr, CHAR_BUF_LEN, "-0.%0*" LL_MASK "d", -var->sqlscale, -n % f); + } + } else { + switch (var->sqltype & ~1) { + struct tm t; + char *fmt; + + case SQL_VARYING: + *ptr = &var->sqldata[2]; + *len = *(short*)var->sqldata; + break; + case SQL_TEXT: + *ptr = var->sqldata; + *len = var->sqllen; + break; + case SQL_SHORT: + *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); + *len = slprintf(*ptr, CHAR_BUF_LEN, "%d", *(short*)var->sqldata); + break; + case SQL_LONG: + *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); + *len = slprintf(*ptr, CHAR_BUF_LEN, "%ld", *(ISC_LONG*)var->sqldata); + break; + case SQL_INT64: + *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); + *len = slprintf(*ptr, CHAR_BUF_LEN, "%" LL_MASK "d", *(ISC_INT64*)var->sqldata); + break; + case SQL_FLOAT: + *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); + *len = slprintf(*ptr, CHAR_BUF_LEN, "%F", *(float*)var->sqldata); + break; + case SQL_DOUBLE: + *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); + *len = slprintf(*ptr, CHAR_BUF_LEN, "%F" , *(double*)var->sqldata); + break; + case SQL_TYPE_DATE: + isc_decode_sql_date((ISC_DATE*)var->sqldata, &t); + fmt = S->H->date_format ? S->H->date_format : PDO_FB_DEF_DATE_FMT; + if (0) { + case SQL_TYPE_TIME: + isc_decode_sql_time((ISC_TIME*)var->sqldata, &t); + fmt = S->H->time_format ? S->H->time_format : PDO_FB_DEF_TIME_FMT; + } else if (0) { + case SQL_TIMESTAMP: + isc_decode_timestamp((ISC_TIMESTAMP*)var->sqldata, &t); + fmt = S->H->timestamp_format ? S->H->timestamp_format : PDO_FB_DEF_TIMESTAMP_FMT; + } + /* convert the timestamp into a string */ + *len = 80; + *ptr = FETCH_BUF(S->fetch_buf[colno], char, *len, NULL); + *len = strftime(*ptr, *len, fmt, &t); + break; + case SQL_BLOB: + return firebird_fetch_blob(stmt,colno,ptr,len, + (ISC_QUAD*)var->sqldata TSRMLS_CC); + } + } + } + return 1; +} +/* }}} */ + +static int firebird_bind_blob(pdo_stmt_t *stmt, ISC_QUAD *blob_id, zval *param TSRMLS_DC) +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + pdo_firebird_db_handle *H = S->H; + isc_blob_handle h = NULL; + unsigned long put_cnt = 0, rem_cnt; + unsigned short chunk_size; + int result = 1; + + if (isc_create_blob(H->isc_status, &H->db, &H->tr, &h, blob_id)) { + RECORD_ERROR(stmt); + return 0; + } + + SEPARATE_ZVAL(¶m); + + convert_to_string_ex(¶m); + + for (rem_cnt = Z_STRLEN_P(param); rem_cnt > 0; rem_cnt -= chunk_size) { + + chunk_size = rem_cnt > USHRT_MAX ? USHRT_MAX : (unsigned short)rem_cnt; + + if (isc_put_segment(H->isc_status, &h, chunk_size, &Z_STRVAL_P(param)[put_cnt])) { + RECORD_ERROR(stmt); + result = 0; + break; + } + put_cnt += chunk_size; + } + + zval_dtor(param); + + if (isc_close_blob(H->isc_status, &h)) { + RECORD_ERROR(stmt); + return 0; + } + return result; +} + +static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, /* {{{ */ + enum pdo_param_event event_type TSRMLS_DC) +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + XSQLDA *sqlda = param->is_param ? S->in_sqlda : &S->out_sqlda; + XSQLVAR *var; + + if (event_type == PDO_PARAM_EVT_FREE) { /* not used */ + return 1; + } + + if (!sqlda || param->paramno >= sqlda->sqld) { + strcpy(stmt->error_code, "HY093"); + S->H->last_app_error = "Invalid parameter index"; + return 0; + } + if (param->is_param && param->paramno == -1) { + long *index; + + /* try to determine the index by looking in the named_params hash */ + if (SUCCESS == zend_hash_find(S->named_params, param->name, param->namelen+1, (void*)&index)) { + param->paramno = *index; + } else { + /* ... or by looking in the input descriptor */ + int i; + + for (i = 0; i < sqlda->sqld; ++i) { + XSQLVAR *var = &sqlda->sqlvar[i]; + + if ((var->aliasname_length && !strncasecmp(param->name, var->aliasname, + min(param->namelen, var->aliasname_length))) + || (var->sqlname_length && !strncasecmp(param->name, var->sqlname, + min(param->namelen, var->sqlname_length)))) { + param->paramno = i; + break; + } + } + if (i >= sqlda->sqld) { + strcpy(stmt->error_code, "HY093"); + S->H->last_app_error = "Invalid parameter name"; + return 0; + } + } + } + + var = &sqlda->sqlvar[param->paramno]; + + switch (event_type) { + char *value; + unsigned long value_len; + int caller_frees; + + case PDO_PARAM_EVT_ALLOC: + if (param->is_param) { + /* allocate the parameter */ + if (var->sqlind) { + efree(var->sqlind); + } + var->sqlind = (void*)emalloc(var->sqllen + 2*sizeof(short)); + var->sqldata = &((char*)var->sqlind)[sizeof(short)]; + } + break; + + case PDO_PARAM_EVT_EXEC_PRE: + if (!param->is_param) { + break; + } + + *var->sqlind = 0; + + switch (var->sqltype & ~1) { + case SQL_ARRAY: + strcpy(stmt->error_code, "HY000"); + S->H->last_app_error = "Cannot bind to array field"; + return 0; + + case SQL_BLOB: + return firebird_bind_blob(stmt, (ISC_QUAD*)var->sqldata, + param->parameter TSRMLS_CC); + } + + /* check if a NULL should be inserted */ + switch (Z_TYPE_P(param->parameter)) { + int force_null; + + case IS_LONG: + var->sqltype = sizeof(long) == 8 ? SQL_INT64 : SQL_LONG; + var->sqldata = (void*)&Z_LVAL_P(param->parameter); + var->sqllen = sizeof(long); + break; + case IS_DOUBLE: + var->sqltype = SQL_DOUBLE; + var->sqldata = (void*)&Z_DVAL_P(param->parameter); + var->sqllen = sizeof(double); + break; + case IS_STRING: + force_null = 0; + + /* for these types, an empty string can be handled like a NULL value */ + switch (var->sqltype & ~1) { + case SQL_SHORT: + case SQL_LONG: + case SQL_INT64: + case SQL_FLOAT: + case SQL_DOUBLE: + case SQL_TIMESTAMP: + case SQL_TYPE_DATE: + case SQL_TYPE_TIME: + force_null = (Z_STRLEN_P(param->parameter) == 0); + } + if (!force_null) { + var->sqltype = SQL_TEXT; + var->sqldata = Z_STRVAL_P(param->parameter); + var->sqllen = Z_STRLEN_P(param->parameter); + break; + } + case IS_NULL: + /* complain if this field doesn't allow NULL values */ + if (~var->sqltype & 1) { + strcpy(stmt->error_code, "HY105"); + S->H->last_app_error = "Parameter requires non-null value"; + return 0; + } + *var->sqlind = -1; + break; + default: + strcpy(stmt->error_code, "HY105"); + S->H->last_app_error = "Binding arrays/objects is not supported"; + return 0; + } + break; + + case PDO_PARAM_EVT_FETCH_POST: + if (param->paramno == -1) { + return 0; + } + if (param->is_param) { + break; + } + value = NULL; + value_len = 0; + caller_frees = 0; + + if (firebird_stmt_get_col(stmt, param->paramno, &value, &value_len, &caller_frees TSRMLS_CC)) { + switch (PDO_PARAM_TYPE(param->param_type)) { + case PDO_PARAM_STR: + if (value) { + ZVAL_STRINGL(param->parameter, value, value_len, 1); + break; + } + case PDO_PARAM_INT: + if (value) { + ZVAL_LONG(param->parameter, *(long*)value); + break; + } + case PDO_PARAM_EVT_NORMALIZE: + if (!param->is_param) { + char *s = param->name; + while (*s != '\0') { + *s = toupper(*s); + s++; + } + } + break; + default: + ZVAL_NULL(param->parameter); + } + if (value && caller_frees) { + efree(value); + } + return 1; + } + return 0; + default: + ; + } + return 1; +} +/* }}} */ + +static int firebird_stmt_set_attribute(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC) /* {{{ */ +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + + switch (attr) { + default: + return 0; + case PDO_ATTR_CURSOR_NAME: + convert_to_string(val); + + if (isc_dsql_set_cursor_name(S->H->isc_status, &S->stmt, Z_STRVAL_P(val),0)) { + RECORD_ERROR(stmt); + return 0; + } + strlcpy(S->name, Z_STRVAL_P(val), sizeof(S->name)); + break; + } + return 1; +} +/* }}} */ + +static int firebird_stmt_get_attribute(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC) /* {{{ */ +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + + switch (attr) { + default: + return 0; + case PDO_ATTR_CURSOR_NAME: + if (*S->name) { + ZVAL_STRING(val,S->name,1); + } else { + ZVAL_NULL(val); + } + break; + } + return 1; +} +/* }}} */ + +static int firebird_stmt_cursor_closer(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ +{ + pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; + + /* close the statement handle */ + if ((*S->name || S->cursor_open) && isc_dsql_free_statement(S->H->isc_status, &S->stmt, DSQL_close)) { + RECORD_ERROR(stmt); + return 0; + } + *S->name = 0; + S->cursor_open = 0; + return 1; +} +/* }}} */ + + +struct pdo_stmt_methods firebird_stmt_methods = { /* {{{ */ + firebird_stmt_dtor, + firebird_stmt_execute, + firebird_stmt_fetch, + firebird_stmt_describe, + firebird_stmt_get_col, + firebird_stmt_param_hook, + firebird_stmt_set_attribute, + firebird_stmt_get_attribute, + NULL, /* get_column_meta_func */ + NULL, /* next_rowset_func */ + firebird_stmt_cursor_closer +}; +/* }}} */ + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim600: noet sw=4 ts=4 fdm=marker + * vim<600: noet sw=4 ts=4 + */ |