ibase_query.c

/*
   +----------------------------------------------------------------------+
   | PHP Version 7, 8                                                     |
   +----------------------------------------------------------------------+
   | Copyright (c) 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.               |
   +----------------------------------------------------------------------+
   | Authors: Jouni Ahto <jouni.ahto@exdec.fi>                            |
   |          Andrew Avdeev <andy@simgts.mv.ru>                           |
   |          Ard Biesheuvel <a.k.biesheuvel@its.tudelft.nl>              |
   |          Martin Koeditz <martin.koeditz@it-syn.de>                   |
   |          Martins Lazdans <marrtins@dqdp.net>                         |
   |          others                                                      |
   +----------------------------------------------------------------------+
   | You'll find history on Github                                        |
   | https://github.com/FirebirdSQL/php-firebird/commits/master           |
   +----------------------------------------------------------------------+
 */

// #pragma GCC diagnostic error "-Wextra"
// #pragma GCC diagnostic error "-Wall"
// #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_ini.h"

#if HAVE_IBASE

#include "ext/standard/php_standard.h"
#include "ext/date/php_date.h"
#include "zend_interfaces.h"
#include "php_interbase.h"
#include "php_ibase_includes.h"
#include "firebird_utils.h"

#define ISC_LONG_MIN    INT_MIN
#define ISC_LONG_MAX    INT_MAX

#define QUERY_RESULT    1
#define EXECUTE_RESULT  2

#define FETCH_ROW       1
#define FETCH_ARRAY     2

#ifndef PHP_DATE_INIT_CTOR
#	define PHP_DATE_INIT_CTOR   0x01
#endif

#ifndef PHP_DATE_INIT_FORMAT
#	define PHP_DATE_INIT_FORMAT 0x02
#endif

/*
 * php_date_initialize()'s last argument changed meaning in PHP 8.0. Before that it is a
 * plain `int ctor` whose only effect is whether a failed parse warns -- parsing against a
 * format is selected by passing a non-NULL format, not by a flag. Passing the 8.x flag
 * there would warn on every parse we deliberately let fail.
 */
#if PHP_VERSION_ID >= 80000
#	define FBP_DATE_INIT_FORMAT PHP_DATE_INIT_FORMAT
#else
#	define FBP_DATE_INIT_FORMAT 0
#endif

static int le_query;

static void _php_ibase_alloc_xsqlda_vars(XSQLDA *sqlda, ISC_SHORT *nullinds);
static int _php_ibase_set_query_info(ibase_query *ib_query);
static int _php_ibase_fetch_query_res(zval *from, ibase_query **ib_query);
static int _php_ibase_alloc_ht_aliases(ibase_query *ib_query);
static void _php_ibase_alloc_ht_ind(ibase_query *ib_query);
static void _php_ibase_free_query_impl(INTERNAL_FUNCTION_PARAMETERS, int as_result);

static void _php_ibase_free_xsqlda(XSQLDA *sqlda) /* {{{ */
{
	int i;
	XSQLVAR *var;

	IBDEBUG("Free XSQLDA?");
	if (sqlda) {
		IBDEBUG("Freeing XSQLDA...");
		var = sqlda->sqlvar;
		for (i = 0; i < sqlda->sqld; i++, var++) {
			efree(var->sqldata);
		}
		efree(sqlda);
	}
}
/* }}} */

static void _php_ibase_free_query(ibase_query *ib_query) /* {{{ */
{
	IBDEBUG("Freeing query...");

	if (ib_query->stmt) {
		ISC_STATUS_ARRAY status;
		isc_dsql_free_statement(status, &ib_query->stmt, DSQL_drop);
	}

	if(ib_query->out_nullind)efree(ib_query->out_nullind);
	if(ib_query->out_sql_types)efree(ib_query->out_sql_types);
	if(ib_query->bind_buf)efree(ib_query->bind_buf);
	if(ib_query->in_sqlda)efree(ib_query->in_sqlda); // Note to myself: no need for _php_ibase_free_xsqlda()
	if(ib_query->out_sqlda)_php_ibase_free_xsqlda(ib_query->out_sqlda);
	if(ib_query->query)efree(ib_query->query);
	if(ib_query->ht_aliases)zend_array_destroy(ib_query->ht_aliases);
	if(ib_query->ht_ind)zend_array_destroy(ib_query->ht_ind);
	if(ib_query->date_scratch)OBJ_RELEASE(ib_query->date_scratch);
	if(ib_query->sql_types)efree(ib_query->sql_types);
	if(ib_query->sql_lens)efree(ib_query->sql_lens);

	efree(ib_query);
}
/* }}} */

static void php_ibase_free_query_rsrc(zend_resource *rsrc) /* {{{ */
{
	ibase_query *ib_query = (ibase_query *)rsrc->ptr;

	if (ib_query != NULL) {
		IBDEBUG("Preparing to free query by dtor...");
		_php_ibase_free_query(ib_query);
	}
}
/* }}} */

void php_ibase_query_minit(INIT_FUNC_ARGS) /* {{{ */
{
	(void)type;
	le_query = zend_register_list_destructors_ex(php_ibase_free_query_rsrc, NULL,
		LE_QUERY, module_number);
}
/* }}} */

/* allocate and prepare query */
static int _php_ibase_prepare(ibase_query **new_query, ibase_db_link *link, /* {{{ */
	ibase_trans *trans, zend_resource *trans_res, char *query)
{
	/* Return FAILURE, if querystring is empty */
	if (*query == '\0') {
		php_error_docref(NULL, E_WARNING, "Querystring empty.");
		return FAILURE;
	}

	ibase_query *ib_query = ecalloc(1, sizeof(ibase_query));

	ib_query->res = zend_register_resource(ib_query, le_query);
	ib_query->link = link;
	ib_query->trans = trans;
	ib_query->trans_res = trans_res;
	ib_query->dialect = link->dialect;
	ib_query->query = estrdup(query);

	if (isc_dsql_allocate_statement(IB_STATUS, &link->handle, &ib_query->stmt)) {
		_php_ibase_error();
		goto _php_ibase_alloc_query_error;
	}

	// TODO: provide query_len
	if (isc_dsql_prepare(IB_STATUS, &ib_query->trans->handle, &ib_query->stmt,
			0, query, link->dialect, NULL)) {
		IBDEBUG("isc_dsql_prepare() failed\n");
		_php_ibase_error();
		goto _php_ibase_alloc_query_error;
	}

	if(_php_ibase_set_query_info(ib_query)){
		goto _php_ibase_alloc_query_error;
	}

	if(ib_query->out_fields_count) {
		ib_query->out_sqlda = (XSQLDA *) emalloc(XSQLDA_LENGTH(ib_query->out_fields_count));
		ib_query->out_sqlda->sqln = ib_query->out_fields_count;
		ib_query->out_sqlda->version = SQLDA_CURRENT_VERSION;

		if (isc_dsql_describe(IB_STATUS, &ib_query->stmt, SQLDA_CURRENT_VERSION, ib_query->out_sqlda)) {
			IBDEBUG("isc_dsql_describe() failed\n");
			_php_ibase_error();
			goto _php_ibase_alloc_query_error;
		}

		assert(ib_query->out_sqlda->sqln == ib_query->out_sqlda->sqld);
		assert(ib_query->out_sqlda->sqld == ib_query->out_fields_count);

		ib_query->out_nullind = safe_emalloc(sizeof(*ib_query->out_nullind), ib_query->out_sqlda->sqld, 0);

		/* Remember what the server said before _php_ibase_alloc_xsqlda_vars() rewrites
		 * CHAR as VARCHAR, so ibase_field_info() can still report the declared type. */
		ib_query->out_sql_types = safe_emalloc(sizeof(*ib_query->out_sql_types), ib_query->out_sqlda->sqld, 0);
		for (int i = 0; i < ib_query->out_sqlda->sqld; i++) {
			ib_query->out_sql_types[i] = ib_query->out_sqlda->sqlvar[i].sqltype;
		}

		_php_ibase_alloc_xsqlda_vars(ib_query->out_sqlda, ib_query->out_nullind);
	}

	if(ib_query->in_fields_count) {
		ib_query->in_sqlda = emalloc(XSQLDA_LENGTH(ib_query->in_fields_count));
		ib_query->in_sqlda->sqln = ib_query->in_fields_count;
		ib_query->in_sqlda->version = SQLDA_CURRENT_VERSION;

		if (isc_dsql_describe_bind(IB_STATUS, &ib_query->stmt, SQLDA_CURRENT_VERSION, ib_query->in_sqlda)) {
			IBDEBUG("isc_dsql_describe_bind() failed\n");
			_php_ibase_error();
			goto _php_ibase_alloc_query_error;
		}

		ib_query->sql_types = emalloc(sizeof(*ib_query->sql_types) * ib_query->in_fields_count);
		ib_query->sql_lens = emalloc(sizeof(*ib_query->sql_lens) * ib_query->in_fields_count);

		for (int i = 0; i < ib_query->in_fields_count; i++) {
			ib_query->sql_types[i] = ib_query->in_sqlda->sqlvar[i].sqltype;
			ib_query->sql_lens[i] = ib_query->in_sqlda->sqlvar[i].sqllen;
		}

		assert(ib_query->in_sqlda->sqln == ib_query->in_sqlda->sqld);
		assert(ib_query->in_sqlda->sqld == ib_query->in_fields_count);

		ib_query->bind_buf = safe_emalloc(sizeof(BIND_BUF), ib_query->in_sqlda->sqld, 0);
	}

	*new_query = ib_query;

	return SUCCESS;

_php_ibase_alloc_query_error:
	zend_list_delete(ib_query->res);

	return FAILURE;
}
/* }}} */

/*
 * Scale a plain integer up to the representation a NUMERIC/DECIMAL column expects on the
 * wire: with sqlscale -2, the value 5 becomes 500 so that it reads back as 5.00. Returns
 * FAILURE if the scaled value would not fit the target integer type, in which case the
 * caller should fall back to letting Firebird parse and report on the value.
 */
static int _php_ibase_apply_scale(int64_t *val, int sqlscale, int64_t min, int64_t max) /* {{{ */
{
	if (sqlscale >= 0) {
		return SUCCESS;
	}

	int negative = (*val < 0);
	/* Magnitude of the limit on the side we are on; the negative range holds one more */
	uint64_t max_mag = negative ? (uint64_t)(-(min + 1)) + 1 : (uint64_t)max;
	uint64_t mag = negative ? 0 - (uint64_t)*val : (uint64_t)*val;

	for (int i = sqlscale; i < 0; i++) {
		if (mag > max_mag / 10) {
			return FAILURE;
		}
		mag *= 10;
	}

	*val = negative ? (int64_t)(0 - mag) : (int64_t)mag;

	return SUCCESS;
}
/* }}} */

static int _php_ibase_bind(ibase_query *ib_query, zval *b_vars) /* {{{ */
{
	int64_t long_val;
	struct tm t;
	const char *tformat = NULL;
	int64_t long_min, long_max;

	assert(ib_query->in_fields_count > 0);

	for (int i = 0; i < ib_query->in_sqlda->sqld; ++i) { /* bound vars */
		zval *b_var = &b_vars[i];
		XSQLVAR *var = &ib_query->in_sqlda->sqlvar[i];

		// We need keep track of original type because XSQLVAR type could get modified
		var->sqltype = ib_query->sql_types[i];
		var->sqllen = ib_query->sql_lens[i];

		BIND_BUF *buf = &ib_query->bind_buf[i];
		var->sqlind = &buf->nullind;
		var->sqldata = (void*)&buf->val;
		ISC_SHORT sqltype = var->sqltype & ~1;

		/* check if a NULL should be inserted */
		switch (Z_TYPE_P(b_var)) {
			int force_null;

			case IS_STRING:

				force_null = 0;

				/* for these types, an empty string can be handled like a NULL value */
				switch (sqltype) {
					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:
#if FB_API_VER >= 40
					case SQL_INT128:
					case SQL_DEC16:
					case SQL_DEC34:
					case SQL_TIMESTAMP_TZ:
					case SQL_TIME_TZ:
#endif
						force_null = (Z_STRLEN_P(b_var) == 0);
				}

				if (! force_null) break;

			case IS_NULL:
				/*
				 * The null indicator only exists for a nullable parameter: describe_bind
				 * clears the low bit of sqltype otherwise, and Firebird then ignores
				 * sqlind and reads sqldata literally -- which here is an unwritten slot,
				 * so the row would silently get whatever was on the heap. Refuse instead.
				 */
				if (!(var->sqltype & 1)) {
					_php_ibase_module_error("Parameter %d: cannot bind NULL to a NOT NULL column", i+1);
					return FAILURE;
				}
				*var->sqlind = -1;
				continue;
		}

		/* if we make it to this point, we must provide a value for the parameter */

		*var->sqlind = 0;

		// Type checks and conversations
		switch (sqltype)
		{
			case SQL_FLOAT:
			case SQL_DOUBLE:
				switch (Z_TYPE_P(b_var))
				{
					case IS_DOUBLE: break;
					case IS_LONG:
					case IS_TRUE:
					case IS_FALSE:
						convert_to_double(b_var);
						break;
					case IS_STRING:
						/*
						 * convert_to_double() would silently yield 0.0 for a non-numeric
						 * string, storing garbage instead of reporting it. Let Firebird
						 * parse the string and raise a conversion error, as before.
						 */
						goto cast_to_string;
					default:
						goto cast_to_string;
				}

				/*
				 * Firebird has no representation for infinity or NaN: every engine operation
				 * that would produce one raises an arithmetic exception instead, and the engine
				 * is documented not to let these values escape (FirebirdSQL/firebird#2991,
				 * #2917, #2992, #1780). Binding the raw IEEE754 bits bypasses all of that -- on
				 * 2.5 through 5.0 the value reaches the page unchecked, leaving a column the
				 * engine could never produce itself and where later arithmetic fails far from
				 * the INSERT responsible. Hand these to Firebird as a string so it rejects them
				 * the way it always has, with a recoverable error rather than a fatal one.
				 */
				if (zend_isinf(Z_DVAL_P(b_var)) || zend_isnan(Z_DVAL_P(b_var))) {
					goto cast_to_string;
				}

				/*
				 * A double larger than FLT_MAX would silently become infinity in the
				 * cast below, slipping past the guard above. Let Firebird report it.
				 */
				if (sqltype == SQL_FLOAT) {
					double d_val = Z_DVAL_P(b_var);
					if (d_val > (double)FLT_MAX || d_val < -(double)FLT_MAX) {
						goto cast_to_string;
					}
				}

				break;
			case SQL_TYPE_DATE:
			case SQL_TIMESTAMP:
			case SQL_TYPE_TIME:
#if FB_API_VER >= 40
			case SQL_TIMESTAMP_TZ:
			case SQL_TIME_TZ:
#endif
				switch (Z_TYPE_P(b_var))
				{
					case IS_LONG: {
						/* zend_long and time_t differ in width on 32-bit builds, so
						 * copy rather than aliasing the zval's storage. */
						time_t t_sec = (time_t) Z_LVAL_P(b_var);
						if (!php_gmtime_r(&t_sec, &t)) {
							_php_ibase_module_error("Argument %d: could not parse timestamp", i+1);
							return FAILURE;
						}
						break;
					}
					/* Parsed below against ibase.dateformat and friends, see parse_datetime */
					case IS_STRING:
						break;
					default:
						goto cast_to_string;
				}
				break;
#if FB_API_VER >= 40
			case SQL_DEC16:
			case SQL_DEC34:
			case SQL_INT128:
				goto cast_to_string;
#endif
			case SQL_SHORT:
			case SQL_LONG:
			case SQL_INT64:
				if (sqltype == SQL_SHORT) {
					long_min = INT16_MIN;
					long_max = INT16_MAX;
				} else if (sqltype == SQL_LONG) {
					long_min = INT32_MIN;
					long_max = INT32_MAX;
				} else if (sqltype == SQL_INT64) {
					long_min = INT64_MIN;
					long_max = INT64_MAX;
				} else {
					// Unreachable
				}

				switch (Z_TYPE_P(b_var))
				{
					case IS_LONG:
						long_val = Z_LVAL_P(b_var);
						break;
					case IS_TRUE:
						long_val = 1;
						break;
					case IS_FALSE:
						long_val = 0;
						break;
					default:
						goto cast_to_string;
				}

				/*
				 * NUMERIC/DECIMAL are described as SQL_SHORT/LONG/INT64 with a negative sqlscale
				 * and travel as a *scaled* integer: NUMERIC(10,2) value 5.00 is sent as 500.
				 */
				if (_php_ibase_apply_scale(&long_val, var->sqlscale, long_min, long_max) == FAILURE) {
					goto cast_to_string;
				}

				// Let firebird handle overflows
				if (long_val < long_min || long_val > long_max) {
					goto cast_to_string;
				}
				break;
		}

		// Setting the data
		switch (sqltype)
		{
			case SQL_SHORT:
				buf->val.lval = (ISC_SHORT)long_val;
				break;
			case SQL_LONG:
				buf->val.lval = (ISC_LONG)long_val;
				break;
			case SQL_INT64:
				buf->val.lval = (ISC_INT64)long_val;
				break;
			case SQL_FLOAT:
				buf->val.fval = (float)Z_DVAL_P(b_var);
				break;
			case SQL_DOUBLE:
				buf->val.dval = (double)Z_DVAL_P(b_var);
				break;
			case SQL_TYPE_DATE:
				switch (Z_TYPE_P(b_var))
				{
					case IS_LONG:
						isc_encode_sql_date(&t, &buf->val.dtval);
						break;
					case IS_STRING:
						tformat = IBG(dateformat);
						goto parse_datetime;
					default:
						fbp_fatal("BUG: unreachable - other zval types already went to cast_to_string");
				}
				break;
			case SQL_TIMESTAMP:
				switch (Z_TYPE_P(b_var))
				{
					case IS_LONG:
					{
						ISC_TIMESTAMP *ts = &buf->val.tsval;
						isc_encode_sql_date(&t, &ts->timestamp_date);
						isc_encode_sql_time(&t, &ts->timestamp_time);
					} break;
					case IS_STRING:
						tformat = IBG(timestampformat);
						goto parse_datetime;
					default:
						fbp_fatal("BUG: unreachable - other zval types already went to cast_to_string");
				}
				break;
			case SQL_TYPE_TIME:
				switch (Z_TYPE_P(b_var))
				{
					/* An integer binds as the time of day of that unix timestamp, as before
					 * the rewrite: 0 -> 00:00:00, -1 -> 23:59:59 */
					case IS_LONG:
						isc_encode_sql_time(&t, &buf->val.tmval);
						break;
					case IS_STRING:
						tformat = IBG(timeformat);
						goto parse_datetime;
					default:
						fbp_fatal("BUG: unreachable - other zval types already went to cast_to_string");
				}
				break;
#if FB_API_VER >= 40
			case SQL_TIMESTAMP_TZ:
				switch (Z_TYPE_P(b_var))
				{
					case IS_LONG:
					{
						ISC_TIMESTAMP_TZ *ts = &buf->val.tsval_tz;
						isc_encode_sql_date(&t, &ts->utc_timestamp.timestamp_date);
						isc_encode_sql_time(&t, &ts->utc_timestamp.timestamp_time);
						/* GMT: Firebird offset ids are minutes + 1439, so 0 means -23:59 */
						ts->time_zone = 1439;
					} break;
					case IS_STRING:
						tformat = IBG(timestampformat_tz);
						goto parse_datetime;
					default:
						fbp_fatal("BUG: unreachable - other zval types already went to cast_to_string");
				}
				break;
			case SQL_TIME_TZ:
				switch (Z_TYPE_P(b_var))
				{
					case IS_LONG:
						isc_encode_sql_time(&t, &buf->val.tmval_tz.utc_time);
						buf->val.tmval_tz.time_zone = 1439; /* GMT: offset ids are minutes + 1439, so 0 means -23:59 */
						break;
					case IS_STRING:
						tformat = IBG(timeformat_tz);
						goto parse_datetime;
					default:
						fbp_fatal("BUG: unreachable - other zval types already went to cast_to_string");
				}
				break;
#endif
			case SQL_BLOB:
				convert_to_string(b_var);

				if (Z_STRLEN_P(b_var) != BLOB_ID_LEN ||
					!_php_ibase_string_to_quad(Z_STRVAL_P(b_var), &buf->val.qval)) {

					ibase_blob ib_blob = { 0 };
					ib_blob.type = BLOB_INPUT;

					if (isc_create_blob(IB_STATUS, &ib_query->link->handle,
							&ib_query->trans->handle, &ib_blob.bl_handle, &ib_blob.bl_qd)) {
						_php_ibase_error();
						return FAILURE;
					}

					if (_php_ibase_blob_add(b_var, &ib_blob) != SUCCESS) {
						ISC_STATUS_ARRAY cancel_status;
						isc_cancel_blob(cancel_status, &ib_blob.bl_handle);
						return FAILURE;
					}

					if (isc_close_blob(IB_STATUS, &ib_blob.bl_handle)) {
						_php_ibase_error();
						return FAILURE;
					}
					buf->val.qval = ib_blob.bl_qd;
				}
			break;
#ifdef SQL_BOOLEAN
			case SQL_BOOLEAN:
				switch (Z_TYPE_P(b_var)) {
					case IS_LONG:
					case IS_DOUBLE:
					case IS_TRUE:
					case IS_FALSE:
						buf->val.bval = zend_is_true(b_var) ? FB_TRUE : FB_FALSE;
						break;
					case IS_STRING:
					{
						zend_long lval;
						double dval;

						if ((Z_STRLEN_P(b_var) == 0)) {
							buf->val.bval = FB_FALSE;
							break;
						}

						switch (is_numeric_string(Z_STRVAL_P(b_var), Z_STRLEN_P(b_var), &lval, &dval, 0)) {
							case IS_LONG:
								buf->val.bval = (lval != 0) ? FB_TRUE : FB_FALSE;
								break;
							case IS_DOUBLE:
								buf->val.bval = (dval != 0) ? FB_TRUE : FB_FALSE;
								break;
							default:
								if (!zend_binary_strncasecmp(Z_STRVAL_P(b_var), Z_STRLEN_P(b_var), "true", 4, 4)) {
									buf->val.bval = FB_TRUE;
								} else if (!zend_binary_strncasecmp(Z_STRVAL_P(b_var), Z_STRLEN_P(b_var), "false", 5, 5)) {
									buf->val.bval = FB_FALSE;
								} else {
									_php_ibase_module_error("Parameter %d: cannot convert string to boolean", i+1);
									return FAILURE;
								}
						}
						break;
					}
					default:
						_php_ibase_module_error("Parameter %d: must be boolean", i+1);
						return FAILURE;
				}
				break;
#endif
			case SQL_ARRAY:
				fbp_fatal("SQL_ARRAY type is not supported");
			default:
				fbp_warning("Unknown sqltype: %d %s:%d. Probably compiled against outdated fbclient library (%d)", sqltype, __FILE__, __LINE__, FB_API_VER);
			case SQL_TEXT:
			case SQL_VARYING:
cast_to_string:
				if (Z_TYPE_P(b_var) == IS_DOUBLE) {
					/*
					 * convert_to_string() formats with the `precision` ini -- 14 significant
					 * digits by default -- which silently drops digits the column could
					 * hold: 1234567.891234567 into NUMERIC(18,9) arrived as
					 * 1234567.891234600. Format with `serialize_precision` instead, the
					 * same call var_export() and json_encode() make; its default of -1
					 * selects the shortest text that reads back as the identical double.
					 * Firebird then rounds to the column's own scale.
					 */
					char dbuf[PHP_DOUBLE_MAX_LENGTH];
					php_gcvt(Z_DVAL_P(b_var), (int)PG(serialize_precision), '.', 'E', dbuf);
					ZVAL_STRING(b_var, dbuf);
				} else {
					convert_to_string(b_var);
				}
				if (Z_STRLEN_P(b_var) > SHRT_MAX - 2) {
					_php_ibase_module_error("Parameter %d: string buffer overflow (%zu bytes, max %d)", i+1, Z_STRLEN_P(b_var), SHRT_MAX - 2);
					return FAILURE;
				}
				var->sqltype = SQL_TEXT | (var->sqltype & 1);
				var->sqldata = Z_STRVAL_P(b_var);
				var->sqllen = (ISC_SHORT)Z_STRLEN_P(b_var);
				break;
		} /* switch */

		continue;

parse_datetime: {
		zval dateo;
		php_date_obj *obj;

		/*
		 * No format configured for this type: don't try to parse at all, just hand
		 * the string to Firebird, which accepts its own spellings and reports what
		 * it cannot read.
		 */
		if (tformat == NULL || *tformat == '\0') {
			goto cast_to_string;
		}

		php_date_instantiate(php_date_get_date_ce(), &dateo);
		obj = Z_PHPDATE_P(&dateo);

		// php_printf("  tformat: %s\n", tformat);
		/*
		 * A string that does not match the configured format is handed to Firebird to parse,
		 * as it was before the rewrite -- it accepts spellings of its own ('2025-11-06' for a
		 * TIMESTAMP, a trailing time on a DATE) and reports what it cannot read itself.
		 */
		if (!php_date_initialize(obj, Z_STRVAL_P(b_var), Z_STRLEN_P(b_var), tformat, NULL, FBP_DATE_INIT_FORMAT)) {
			zval_ptr_dtor(&dateo);
			goto cast_to_string;
		}

		switch (sqltype) {
			case SQL_TYPE_TIME:
				buf->val.tmval = fbu_encode_time(IBG(master_instance), (unsigned)obj->time->h, (unsigned)obj->time->i, (unsigned)obj->time->s, FB_USEC_TO_FRACTIONS(obj->time->us));
				break;
			case SQL_TYPE_DATE:
				buf->val.dtval = fbu_encode_date(IBG(master_instance), (unsigned)obj->time->y, (unsigned)obj->time->m, (unsigned)obj->time->d);
				break;
			case SQL_TIMESTAMP:
				ISC_TIMESTAMP *ts = &buf->val.tsval;
				ts->timestamp_date = fbu_encode_date(IBG(master_instance), (unsigned)obj->time->y, (unsigned)obj->time->m, (unsigned)obj->time->d);
				ts->timestamp_time = fbu_encode_time(IBG(master_instance), (unsigned)obj->time->h, (unsigned)obj->time->i, (unsigned)obj->time->s, FB_USEC_TO_FRACTIONS(obj->time->us));
				break;
#if FB_API_VER >= 40
			case SQL_TIME_TZ:
				fbu_encode_time_tz(IBG(master_instance), &buf->val.tmval_tz, (unsigned)obj->time->h, (unsigned)obj->time->i, (unsigned)obj->time->s, FB_USEC_TO_FRACTIONS(obj->time->us), obj->time->tz_info->name);
				break;
			case SQL_TIMESTAMP_TZ:
				fbu_encode_timestamp_tz(IBG(master_instance), &buf->val.tsval_tz,
					(unsigned)obj->time->y, (unsigned)obj->time->m, (unsigned)obj->time->d,
					(unsigned)obj->time->h, (unsigned)obj->time->i, (unsigned)obj->time->s, FB_USEC_TO_FRACTIONS(obj->time->us),
					obj->time->tz_info->name
				);
				break;
#endif
			default: fbp_fatal("BUG: unreachable - only date/time sqltypes goto parse_datetime");
		}
		zval_ptr_dtor(&dateo);
} // parse_datetime:
	} /* for */

	return SUCCESS;
}
/* }}} */

static void _php_ibase_alloc_xsqlda_vars(XSQLDA *sqlda, ISC_SHORT *nullinds) /* {{{ */
{
	for (int i = 0; i < sqlda->sqld; i++) {
		XSQLVAR *var = &sqlda->sqlvar[i];

		// Convert CHAR to VARCHAR to avoid dealiong with padding with
		// multi character charsets

		if ((var->sqltype & ~1) == SQL_TEXT) {
			var->sqltype = SQL_VARYING | (var->sqltype & 1);
		}

		switch (var->sqltype & ~1) {
			case SQL_TEXT:
				var->sqldata = safe_emalloc(sizeof(char), var->sqllen, 0);
				break;
			case SQL_VARYING:
				var->sqldata = safe_emalloc(sizeof(char), var->sqllen + sizeof(short), 0);
				break;
#ifdef SQL_BOOLEAN
			case SQL_BOOLEAN:
				var->sqldata = emalloc(sizeof(FB_BOOLEAN));
				break;
#endif
			case SQL_SHORT:
				var->sqldata = emalloc(sizeof(ISC_SHORT));
				break;
			case SQL_LONG:
				var->sqldata = emalloc(sizeof(ISC_LONG));
				break;
			case SQL_FLOAT:
				var->sqldata = emalloc(sizeof(float));
				break;
			case SQL_DOUBLE:
				var->sqldata = emalloc(sizeof(double));
				break;
			case SQL_INT64:
				var->sqldata = emalloc(sizeof(ISC_INT64));
				break;
			case SQL_TIMESTAMP:
				var->sqldata = emalloc(sizeof(ISC_TIMESTAMP));
				break;
			case SQL_TYPE_DATE:
				var->sqldata = emalloc(sizeof(ISC_DATE));
				break;
			case SQL_TYPE_TIME:
				var->sqldata = emalloc(sizeof(ISC_TIME));
				break;
			case SQL_ARRAY:
				fbp_fatal("SQL_ARRAY type is not supported");
			case SQL_BLOB:
			case SQL_QUAD:
				var->sqldata = emalloc(sizeof(ISC_QUAD));
				break;
#if FB_API_VER >= 40
			// These are converted to VARCHAR via isc_dpb_set_bind tag at connect
			// case SQL_DEC16:
			// case SQL_DEC34:
			// case SQL_INT128:
			case SQL_TIMESTAMP_TZ:
				var->sqldata = emalloc(sizeof(ISC_TIMESTAMP_TZ));
				break;
			case SQL_TIME_TZ:
				var->sqldata = emalloc(sizeof(ISC_TIME_TZ));
				break;
#endif
			default:
				fbp_fatal("Unknown sqltype: %d for field %s %s:%d. Probably compiled against outdated fbclient library (%d)", var->sqltype, var->sqlname, __FILE__, __LINE__, FB_API_VER);
		} /* switch */

		if (var->sqltype & 1) { /* sql NULL flag */
			var->sqlind = &nullinds[i];
		} else {
			var->sqlind = NULL;
		}
	} /* for */
}
/* }}} */

static int _php_ibase_exec(INTERNAL_FUNCTION_PARAMETERS, ibase_query *ib_query, zval *args, int bind_n) /* {{{ */
{
	int i, rv = FAILURE;
	static char info_count[] = { isc_info_sql_records };
	char result[64];
	ISC_STATUS isc_result;
	int argc = ib_query->in_fields_count;

	(void)execute_data;

	RESET_ERRMSG;
	RETVAL_FALSE;

	if (bind_n != argc) {
		php_error_docref(NULL, (bind_n < argc) ? E_WARNING : E_NOTICE,
			"Statement expects %d arguments, %d given", argc, bind_n);

		if (bind_n < argc) {
			return FAILURE;
		}
	}

	/* Have we used this cursor before and it's still open (exec proc has no cursor) ? */
	if (ib_query->is_open && ib_query->statement_type != isc_info_sql_stmt_exec_procedure) {
		IBDEBUG("Implicitly closing a cursor");
		// TODO: ini configurable warning
		// php_error_docref(NULL, E_NOTICE, "Implicitly closing a cursor");
		if (isc_dsql_free_statement(IB_STATUS, &ib_query->stmt, DSQL_close)) {
			_php_ibase_error();
			return FAILURE;
		}
		ib_query->is_open = 0;
	}

	for (i = 0; i < argc; ++i) {
		SEPARATE_ZVAL(&args[i]);
	}

	switch (ib_query->statement_type) {
		isc_tr_handle tr;
		ibase_tr_list **l;
		ibase_trans *trans;

		case isc_info_sql_stmt_start_trans:

			/* a SET TRANSACTION statement should be executed with a NULL trans handle */
			tr = 0;

			if (isc_dsql_execute_immediate(IB_STATUS, &ib_query->link->handle, &tr, 0,
					ib_query->query, ib_query->dialect, NULL)) {
				_php_ibase_error();
				goto _php_ibase_ex_error;
			}

			trans = (ibase_trans *) emalloc(sizeof(ibase_trans));
			trans->handle = tr;
			trans->link_cnt = 1;
			trans->affected_rows = 0;
			trans->db_link[0] = ib_query->link;

			if (ib_query->link->tr_list == NULL) {
				ib_query->link->tr_list = (ibase_tr_list *) emalloc(sizeof(ibase_tr_list));
				ib_query->link->tr_list->trans = NULL;
				ib_query->link->tr_list->next = NULL;
			}

			/* link the transaction into the connection-transaction list */
			for (l = &ib_query->link->tr_list; *l != NULL; l = &(*l)->next);
			*l = (ibase_tr_list *) emalloc(sizeof(ibase_tr_list));
			(*l)->trans = trans;
			(*l)->next = NULL;

			RETVAL_RES(zend_register_resource(trans, le_trans));
			Z_TRY_ADDREF_P(return_value);

			return SUCCESS;

		case isc_info_sql_stmt_commit:
		case isc_info_sql_stmt_rollback:

			if (isc_dsql_execute_immediate(IB_STATUS, &ib_query->link->handle,
					&ib_query->trans->handle, 0, ib_query->query, ib_query->dialect, NULL)) {
				_php_ibase_error();
				goto _php_ibase_ex_error;
			}

			if (ib_query->trans->handle == 0 && ib_query->trans_res != NULL) {
				/* transaction was released by the query and was a registered resource,
				   so we have to release it */
				zend_list_delete(ib_query->trans_res);
				ib_query->trans_res = NULL;
			}

			RETVAL_TRUE;

			return SUCCESS;

		default:
			RETVAL_FALSE;
	}

	if (ib_query->in_fields_count) { /* has placeholders */
		IBDEBUG("Query wants XSQLDA for input");
		if (_php_ibase_bind(ib_query, args) == FAILURE) {
			IBDEBUG("Could not bind input XSQLDA");
			goto _php_ibase_ex_error;
		}
	}

	if (ib_query->statement_type == isc_info_sql_stmt_exec_procedure) {
		isc_result = isc_dsql_execute2(IB_STATUS, &ib_query->trans->handle,
			&ib_query->stmt, SQLDA_CURRENT_VERSION, ib_query->in_sqlda, ib_query->out_sqlda);
	} else {
		isc_result = isc_dsql_execute(IB_STATUS, &ib_query->trans->handle,
			&ib_query->stmt, SQLDA_CURRENT_VERSION, ib_query->in_sqlda);
	}

	if (isc_result) {
		IBDEBUG("Could not execute query");
		_php_ibase_error();
		goto _php_ibase_ex_error;
	}

	ib_query->trans->affected_rows = 0;

	if (ib_query->out_sqlda) { /* output variables in select, select for update */
		ib_query->has_more_rows = 1;
		ib_query->is_open = 1;

		RETVAL_RES(ib_query->res);
		Z_TRY_ADDREF_P(return_value);

		return SUCCESS;
	}

	switch (ib_query->statement_type) {

		unsigned long affected_rows;

		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(IB_STATUS, &ib_query->stmt, sizeof(info_count),
					info_count, sizeof(result), result)) {
				_php_ibase_error();
				goto _php_ibase_ex_error;
			}

			affected_rows = 0;

			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;
				}
			}

			ib_query->trans->affected_rows = affected_rows;

			if (!ib_query->out_sqlda) { /* no result set is being returned */
				if (affected_rows) {
					RETVAL_LONG(affected_rows);
				} else {
					RETVAL_TRUE;
				}
				break;
			}
		default:
			RETVAL_TRUE;
	}

	rv = SUCCESS;

_php_ibase_ex_error:
	return rv;
}
/* }}} */

/* {{{ proto mixed ibase_query([resource link_identifier, [ resource link_identifier, ]] string query [, mixed bind_arg [, mixed bind_arg [, ...]]])
   Execute a query */
PHP_FUNCTION(ibase_query)
{
	zval *zlink, *ztrans, *bind_args = NULL;
	char *query;
	size_t query_len;
	int bind_i, bind_num;
	zend_resource *trans_res = NULL;
	ibase_db_link *ib_link = NULL;
	ibase_trans *trans = NULL;

	RESET_ERRMSG;

	RETVAL_FALSE;

	switch (ZEND_NUM_ARGS()) {
		zend_long l;

		default:
			if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, 3, "rrs",
					&zlink, &ztrans, &query, &query_len)) {

				ib_link = (ibase_db_link*)zend_fetch_resource2_ex(zlink, LE_LINK, le_link, le_plink);
				trans = (ibase_trans*)zend_fetch_resource_ex(ztrans, LE_TRANS,	le_trans);

				trans_res = Z_RES_P(ztrans);
				bind_i = 3;
				break;
			}
		case 2:
			if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, 2, "rs",
					&zlink, &query, &query_len)) {
				_php_ibase_get_link_trans(INTERNAL_FUNCTION_PARAM_PASSTHRU, zlink, &ib_link, &trans);

				if (trans != NULL) {
					trans_res = Z_RES_P(zlink);
				}
				bind_i = 2;
				break;
			}

			/* the statement is 'CREATE DATABASE ...' if the link argument is IBASE_CREATE */
			if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(),
					 "ls", &l, &query, &query_len) && l == PHP_IBASE_CREATE) {
				isc_db_handle db = 0;
				isc_tr_handle trh = 0;

				if (((l = INI_INT("ibase.max_links")) != -1) && (IBG(num_links) >= l)) {
					_php_ibase_module_error("CREATE DATABASE is not allowed: maximum link count "
						"(" ZEND_LONG_FMT ") reached", l);

				} else if (isc_dsql_execute_immediate(IB_STATUS, &db, &trh, (short)query_len,
						query, SQL_DIALECT_CURRENT, NULL)) {
					_php_ibase_error();

				} else if (!db) {
					_php_ibase_module_error("Connection to created database could not be "
						"established");

				} else {

					/* register the link as a resource; unfortunately, we cannot register
					   it in the hash table, because we don't know the connection params */
					ib_link = (ibase_db_link *) emalloc(sizeof(ibase_db_link));
					ib_link->handle = db;
					ib_link->dialect = SQL_DIALECT_CURRENT;
					ib_link->tr_list = NULL;
					ib_link->event_head = NULL;

					RETVAL_RES(zend_register_resource(ib_link, le_link));
					Z_TRY_ADDREF_P(return_value);

					IBG(default_link) = Z_RES_P(return_value);
					Z_TRY_ADDREF_P(return_value);
				}
				return;
			}
		case 1:
		case 0:
			if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() ? 1 : 0, "s", &query,
					&query_len)) {
				ib_link = (ibase_db_link *)zend_fetch_resource2(IBG(default_link), LE_LINK, le_link, le_plink);

				bind_i = 1;
				break;
			}
			return;
	}

	/* open default transaction */
	if (ib_link == NULL || FAILURE == _php_ibase_def_trans(ib_link, &trans)){
		return;
	}

	ibase_query *ib_query;
	if(FAILURE == _php_ibase_prepare(&ib_query, ib_link, trans, trans_res, query)) {
		return;
	}

	{ // was while
		int bind_n = ZEND_NUM_ARGS() - bind_i;
		if (zend_parse_parameters(ZEND_NUM_ARGS(), "+", &bind_args, &bind_num) == FAILURE) {
			goto _php_ibase_query_error;
		}

		if (FAILURE == _php_ibase_exec(INTERNAL_FUNCTION_PARAM_PASSTHRU, ib_query, &bind_args[bind_i], bind_n)) {
			goto _php_ibase_query_error;
		}

		ib_query->was_result_once = 1;

		zend_list_delete(ib_query->res);

		return;
	}

	assert(false && "UNREACHABLE");

_php_ibase_query_error:
	zend_list_delete(ib_query->res);
}
/* }}} */

/* {{{ proto int ibase_affected_rows( [ resource link_identifier ] )
   Returns the number of rows affected by the previous INSERT, UPDATE or DELETE statement */
PHP_FUNCTION(ibase_affected_rows)
{
	ibase_trans *trans = NULL;
	ibase_db_link *ib_link;
	zval *arg = NULL;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|r", &arg) == FAILURE) {
		return;
	}

	if (!arg) {
		ib_link = (ibase_db_link *)zend_fetch_resource2(IBG(default_link), LE_LINK, le_link, le_plink);
		if (ib_link == NULL || ib_link->tr_list == NULL || ib_link->tr_list->trans == NULL) {
			RETURN_FALSE;
		}
		trans = ib_link->tr_list->trans;
	} else {
		/* one id was passed, could be db or trans id */
		_php_ibase_get_link_trans(INTERNAL_FUNCTION_PARAM_PASSTHRU, arg, &ib_link, &trans);
		if (trans == NULL) {
			ib_link = (ibase_db_link *)zend_fetch_resource2_ex(arg, LE_LINK, le_link, le_plink);

			if (ib_link == NULL || ib_link->tr_list == NULL || ib_link->tr_list->trans == NULL) {
				RETURN_FALSE;
			}
			trans = ib_link->tr_list->trans;
		}
	}
	RETURN_LONG(trans->affected_rows);
}
/* }}} */

static int _php_ibase_var_zval(ibase_query *ib_query, zval *val, void *data, int type, int len, /* {{{ */
	int scale, size_t flag)
{
	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)
	};

	const char *t_format = NULL;
	unsigned t_year, t_month, t_day, t_hours, t_minutes, t_seconds, t_fractions;
	char t_zone_buff[40] = "UTC";
	php_date_obj *t_date_obj;
	int date_bearing, legacy_unixtime;
	ISC_SHORT sqltype = type & ~1;

	switch (sqltype) {
		unsigned short l;
		zend_long n;
		char string_data[255];

		case SQL_VARYING:
			len = ((IBVARY *) data)->vary_length;
			data = ((IBVARY *) data)->vary_string;
			/* no break */
		case SQL_TEXT:
			ZVAL_STRINGL(val, (char*)data, len);
			break;
#ifdef SQL_BOOLEAN
		case SQL_BOOLEAN:
			ZVAL_BOOL(val, *(FB_BOOLEAN *) data);
			break;
#endif
		case SQL_SHORT:
			n = *(short *) data;
			goto _sql_long;
		case SQL_INT64:
// TODO: do tests cover these cases?
#if (SIZEOF_ZEND_LONG >= 8)
			n = *(zend_long *) data;
			goto _sql_long;
#else
			if (scale == 0) {
				l = slprintf(string_data, sizeof(string_data), "%" LL_MASK "d", *(ISC_INT64 *) data);
				ZVAL_STRINGL(val,string_data,l);
			} else {
				ISC_INT64 n = *(ISC_INT64 *) data, f = scales[-scale];

				if (n >= 0) {
					l = slprintf(string_data, sizeof(string_data), "%" LL_MASK "d.%0*" LL_MASK "d", n / f, -scale, n % f);
				} else if (n <= -f) {
					l = slprintf(string_data, sizeof(string_data), "%" LL_MASK "d.%0*" LL_MASK "d", n / f, -scale, -n % f);
				 } else {
					l = slprintf(string_data, sizeof(string_data), "-0.%0*" LL_MASK "d", -scale, -n % f);
				}
				ZVAL_STRINGL(val,string_data,l);
			}
			break;
#endif
		case SQL_LONG:
			n = *(ISC_LONG *) data;
		_sql_long:
			if (scale == 0) {
				ZVAL_LONG(val,n);
			} else {
				zend_long f = (zend_long) scales[-scale];

				if (n >= 0) {
					l = slprintf(string_data, sizeof(string_data), ZEND_LONG_FMT ".%0*" ZEND_LONG_FMT_SPEC, n / f, -scale,  n % f);
				} else if (n <= -f) {
					l = slprintf(string_data, sizeof(string_data), ZEND_LONG_FMT ".%0*" ZEND_LONG_FMT_SPEC, n / f, -scale,  -n % f);
				} else {
					l = slprintf(string_data, sizeof(string_data), "-0.%0*" ZEND_LONG_FMT_SPEC, -scale, -n % f);
				}
				ZVAL_STRINGL(val, string_data, l);
			}
			break;
		case SQL_FLOAT:
			ZVAL_DOUBLE(val, *(float *) data);
			break;
		case SQL_DOUBLE:
			ZVAL_DOUBLE(val, *(double *) data);
			break;
		case SQL_TYPE_DATE: {
			t_format = IBG(dateformat);
			t_hours = t_minutes = t_seconds = t_fractions = 0;
			fbu_decode_date(IBG(master_instance), *(ISC_DATE *)data, &t_year, &t_month, &t_day);
			goto _set_datetime;
		}
		case SQL_TYPE_TIME:
			t_format = IBG(timeformat);
			t_year = t_month = t_day = 0;
			fbu_decode_time(IBG(master_instance), *(ISC_TIME *)data, &t_hours, &t_minutes, &t_seconds, &t_fractions);
			goto _set_datetime;
		case SQL_TIMESTAMP: {
			t_format = IBG(timestampformat);
			ISC_TIMESTAMP *ts = (ISC_TIMESTAMP *) data;
			fbu_decode_date(IBG(master_instance), ts->timestamp_date, &t_year, &t_month, &t_day);
			fbu_decode_time(IBG(master_instance), ts->timestamp_time, &t_hours, &t_minutes, &t_seconds, &t_fractions);
			// php_printf("ISC_TIMESTAMP: %zd, %zu\n", ts->timestamp_date, ts->timestamp_time);
			goto _set_datetime;
		}

#if FB_API_VER >= 40
		// These are converted to VARCHAR via isc_dpb_set_bind tag at connect
		// case SQL_DEC16:
		// case SQL_DEC34:
		// case SQL_INT128:
		case SQL_TIME_TZ:
			t_format = IBG(timeformat_tz);
			t_year = t_month = t_day = 0;
			fbu_decode_time_tz(IBG(master_instance), (ISC_TIME_TZ *)data, &t_hours, &t_minutes, &t_seconds, &t_fractions, sizeof(t_zone_buff), t_zone_buff);
			goto _set_datetime;

		case SQL_TIMESTAMP_TZ:
			t_format = IBG(timestampformat_tz);
			fbu_decode_timestamp_tz(IBG(master_instance), (ISC_TIMESTAMP_TZ *)data, &t_year, &t_month, &t_day, &t_hours,
				&t_minutes, &t_seconds, &t_fractions, sizeof(t_zone_buff), t_zone_buff);
			goto _set_datetime;
#endif

_set_datetime:
			/*
			 * TIME and TIME WITH TIME ZONE carry no date, so IBASE_UNIXTIME has nothing
			 * sensible to return for them and is ignored. The pre-refactor build converted
			 * them anyway, with a zero date, giving a negative timestamp in 1969-1970.
			 */
			date_bearing = (sqltype == SQL_TYPE_DATE || sqltype == SQL_TIMESTAMP
#if FB_API_VER >= 40
				|| sqltype == SQL_TIMESTAMP_TZ
#endif
			);
			legacy_unixtime = (IBG(legacy_flags) & PHP_IBASE_LEGACY_UNIXTIME) != 0;

			if ((flag & PHP_IBASE_UNIXTIME) && legacy_unixtime) {
				/*
				 * Pre-refactor (buggy) behaviour, kept for BC: convert via mktime() against the
				 * process's system timezone instead of PHP's date.timezone. Reported as buggy
				 * because the result silently depends on the server OS timezone configuration.
				 *
				 * No PHP date object is read on this path, so none is built.
				 */
				struct tm legacy_tm = {0};

				if (date_bearing) {
					legacy_tm.tm_year = (int) t_year - 1900;
					legacy_tm.tm_mon = (int) t_month - 1;
					legacy_tm.tm_mday = (int) t_day;
				}
				/* A date-less column left the old build's struct tm zeroed, which mktime()
				 * reads as day 0 of January 1900, i.e. 1899-12-31. Keep that, don't
				 * subtract from a zero date and land in year 0 instead. */
				legacy_tm.tm_hour = (int) t_hours;
				legacy_tm.tm_min = (int) t_minutes;
				legacy_tm.tm_sec = (int) t_seconds;
				legacy_tm.tm_isdst = -1;

				ZVAL_LONG(val, (zend_long) mktime(&legacy_tm));
				break;
			}

#if SIZEOF_ZEND_LONG >= 8
			if ((flag & PHP_IBASE_UNIXTIME) && date_bearing) {
				/*
				 * Straight from the wire: ISC_DATE counts days from 1858-11-17, so day
				 * 40587 is 1970-01-01, and ISC_TIME counts ten-thousandths of a second.
				 * The zoned type carries its instant as UTC already. No object, no
				 * method call, and the decode above was not even needed.
				 *
				 * 32-bit builds are excluded on purpose: a PHP integer cannot hold an
				 * epoch outside 1901..2038 there, and getTimestamp() reports that as a
				 * DateRangeError. Silently wrapping would be worse than slow, so those
				 * builds take the object path below.
				 */
				ISC_DATE w_date;
				ISC_TIME w_time;

				switch (sqltype) {
					case SQL_TYPE_DATE:
						w_date = *(ISC_DATE *) data;
						w_time = 0;
						break;
#if FB_API_VER >= 40
					case SQL_TIMESTAMP_TZ:
						w_date = ((ISC_TIMESTAMP_TZ *) data)->utc_timestamp.timestamp_date;
						w_time = ((ISC_TIMESTAMP_TZ *) data)->utc_timestamp.timestamp_time;
						break;
#endif
					default: /* SQL_TIMESTAMP */
						w_date = ((ISC_TIMESTAMP *) data)->timestamp_date;
						w_time = ((ISC_TIMESTAMP *) data)->timestamp_time;
				}

				ZVAL_LONG(val, ((zend_long) w_date - 40587) * 86400 + (zend_long) (w_time / 10000));
				break;
			}
#endif

			/*
			 * Everything below needs a DateTime. Building one costs a DateTimeZone
			 * construction and a parse of "now", so one is kept per result and reused;
			 * only a zoned column that changes zone between rows rebuilds it.
			 */
			if (!ib_query->date_scratch || strcmp(ib_query->date_scratch_zone, t_zone_buff) != 0) {
				zval scratch;

				if (ib_query->date_scratch) {
					OBJ_RELEASE(ib_query->date_scratch);
				}
				fbu_init_date_object(t_zone_buff, &scratch);
				ib_query->date_scratch = Z_OBJ(scratch);
				strlcpy(ib_query->date_scratch_zone, t_zone_buff, sizeof(ib_query->date_scratch_zone));
			}
			t_date_obj = php_date_obj_from_obj(ib_query->date_scratch);

			/*
			 * DateTime always holds a date, so a date-less column needs one filled in. Use
			 * the epoch, as DateTime::createFromFormat('!H:i:s') does, rather than an
			 * invalid 0000-00-00.
			 */
			t_date_obj->time->y = date_bearing ? t_year : 1970;
			t_date_obj->time->m = date_bearing ? t_month : 1;
			t_date_obj->time->d = date_bearing ? t_day : 1;
			t_date_obj->time->h = t_hours;
			t_date_obj->time->i = t_minutes;
			t_date_obj->time->s = t_seconds;
			t_date_obj->time->us = FB_FRACTIONS_TO_USEC(t_fractions);
			t_date_obj->time->sse_uptodate = 0;

			if (flag & PHP_IBASE_PHPDATE) {
				/* The object escapes to the caller, so it cannot be the shared scratch.
				 * Cloning it still beats re-running the zone construction and the parse. */
				#if PHP_MAJOR_VERSION >= 8
					ZVAL_OBJ(val, t_date_obj->std.handlers->clone_obj(&t_date_obj->std));
				#else
					zval scratch_zv;
					ZVAL_OBJ(&scratch_zv, &t_date_obj->std);
					ZVAL_OBJ(val, Z_OBJ_HT(scratch_zv)->clone_obj(&scratch_zv));
				#endif
#if SIZEOF_ZEND_LONG < 8
			} else if ((flag & PHP_IBASE_UNIXTIME) && date_bearing) {
				/* 32-bit only, see the shortcut above. Date-less columns ignore the
				 * flag, as they always have. */
				zval scratch_zv, retval;

				ZVAL_OBJ(&scratch_zv, &t_date_obj->std);
				GC_ADDREF(&t_date_obj->std);

				#if PHP_MAJOR_VERSION >= 8
					zend_call_method_with_0_params(Z_OBJ(scratch_zv), php_date_get_date_ce(), NULL, "getTimestamp", &retval);
				#else
					zend_call_method_with_0_params(&scratch_zv, NULL, NULL, "getTimestamp", &retval);
				#endif

				/* getTimestamp() throws DateRangeError when the epoch does not fit a
				 * PHP integer, which happens on 32-bit builds outside 1901..2038.
				 * retval is then undefined, so check before reading it. */
				if (Z_TYPE(retval) == IS_LONG) {
					ZVAL_LONG(val, Z_LVAL(retval));
				} else {
					zval_ptr_dtor(&retval);
					ZVAL_NULL(val);
				}
				zval_ptr_dtor(&scratch_zv);
#endif
			} else if (!t_format) {
				/* no format configured for this type */
				ZVAL_EMPTY_STRING(val);
			} else {
				#if PHP_VERSION_ID >= 80400
					ZVAL_STR(val, php_format_date_obj(t_format, strlen(t_format), t_date_obj));
				#else
					zval scratch_zv, format_zval, retval;

					ZVAL_OBJ(&scratch_zv, &t_date_obj->std);
					GC_ADDREF(&t_date_obj->std);
					ZVAL_STRING(&format_zval, t_format);
					#if PHP_MAJOR_VERSION >= 8
						zend_call_method_with_1_params(Z_OBJ(scratch_zv), php_date_get_date_ce(), NULL, "format", &retval, &format_zval);
					#else
						zend_call_method_with_1_params(&scratch_zv, php_date_get_date_ce(), NULL, "format", &retval, &format_zval);
					#endif
					zval_ptr_dtor(&format_zval);
					zval_ptr_dtor(&scratch_zv);
					ZVAL_STR(val, Z_STR(retval));
				#endif
			}
			break;

		default:
			fbp_fatal("Unknown sqltype: %d %s:%d. Probably compiled against outdated fbclient library (%d)", sqltype, __FILE__, __LINE__, FB_API_VER);
	} /* switch (sqltype) */
	return SUCCESS;
}
/* }}}	*/

void _php_ibase_insert_alias(HashTable *ht, const char *alias)
{
	char buf[METADATALENGTH + 3 + 1]; // _00 + \0
	zval t2;
	int i = 0, n;
	char const *base = "FIELD"; /* use 'FIELD' if name is empty */

	size_t alias_len = strlen(alias);

	switch (*alias) {
		default:
			i = 1;
			base = alias;

			while (zend_hash_str_exists(ht, alias, alias_len)) {

		case '\0':
				n = snprintf(buf, sizeof(buf), "%s_%02d", base, i++);
				alias = buf;
				alias_len = (n > 0 && (size_t) n < sizeof(buf)) ? (size_t) n : sizeof(buf) - 1;
			}
	}

	ZVAL_NULL(&t2);
	zend_hash_str_add_new(ht, alias, alias_len, &t2);
}

static void _php_ibase_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int fetch_type) /* {{{ */
{
	zval *res_arg, *result;
	zend_long flag = 0;
	ibase_query *ib_query;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &res_arg, &flag)) {
		RETURN_FALSE;
	}

	if(_php_ibase_fetch_query_res(res_arg, &ib_query)) {
		RETURN_FALSE;
	}

	if (ib_query->out_sqlda == NULL || !ib_query->has_more_rows || !ib_query->is_open) {
		RETURN_FALSE;
	}

	assert(ib_query->out_fields_count > 0);

	if (ib_query->statement_type != isc_info_sql_stmt_exec_procedure) {
		if (isc_dsql_fetch(IB_STATUS, &ib_query->stmt, 1, ib_query->out_sqlda)) {
			ib_query->has_more_rows = 0;
			ib_query->is_open = 0;

			if (IB_STATUS[0] && IB_STATUS[1]) { /* error in fetch */
				_php_ibase_error();
			}

			if(isc_dsql_free_statement(IB_STATUS, &ib_query->stmt, DSQL_close)){
				_php_ibase_error();
			}

			RETURN_FALSE;
		}
	} else {
		ib_query->has_more_rows = 0;
		ib_query->is_open = 0;
	}

	assert(ib_query->out_fields_count == ib_query->out_sqlda->sqld);

	HashTable *ht_ret;
	ibase_blob blob_handle = { 0 };

	if(!(fetch_type & FETCH_ROW)) {
		if(!ib_query->ht_aliases){
			if(_php_ibase_alloc_ht_aliases(ib_query)){
				_php_ibase_error();
				RETURN_FALSE;
			}
		}
		ht_ret = zend_array_dup(ib_query->ht_aliases);
	} else {
		if(!ib_query->ht_ind)_php_ibase_alloc_ht_ind(ib_query);
		ht_ret = zend_array_dup(ib_query->ht_ind);
	}

	for(zend_long i = 0; i < ib_query->out_fields_count; ++i) {
		XSQLVAR *var = &ib_query->out_sqlda->sqlvar[i];

		// NULLs are already set
		if ((var->sqltype & 1) && *var->sqlind < 0) {
			zend_hash_move_forward(ht_ret);
			continue;
		}

		result = zend_hash_get_current_data(ht_ret);

		switch (var->sqltype & ~1) {

			default:
				_php_ibase_var_zval(ib_query, result, var->sqldata, var->sqltype, var->sqllen,
					var->sqlscale, flag);
				break;
			case SQL_BLOB:
				if (flag & PHP_IBASE_FETCH_BLOBS) { /* fetch blob contents into hash */

					zend_ulong max_len = 0;
					static char bl_items[] = {isc_info_blob_total_length};
					char bl_info[20];
					unsigned short i;

					blob_handle.bl_handle = 0;
					blob_handle.bl_qd = *(ISC_QUAD *) var->sqldata;

					if (isc_open_blob(IB_STATUS, &ib_query->link->handle, &ib_query->trans->handle,
							&blob_handle.bl_handle, &blob_handle.bl_qd)) {
						_php_ibase_error();
						goto _php_ibase_fetch_error;
					}

					if (isc_blob_info(IB_STATUS, &blob_handle.bl_handle, sizeof(bl_items),
							bl_items, sizeof(bl_info), bl_info)) {
						_php_ibase_error();
						goto _php_ibase_fetch_error;
					}

					/* 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)) {

							_php_ibase_module_error("Could not determine BLOB size (internal error)"
								);
							goto _php_ibase_fetch_error;
						}

						item_len = (unsigned short) isc_vax_integer(&bl_info[i], 2);

						if (item == isc_info_blob_total_length) {
							max_len = isc_vax_integer(&bl_info[i+2], item_len);
							break;
						}
						i += item_len+2;
					}

					if (max_len == 0) {
						ZVAL_STRING(result, "");
					} else if (SUCCESS != _php_ibase_blob_get(result, &blob_handle,
							max_len)) {
						goto _php_ibase_fetch_error;
					}

					if (isc_close_blob(IB_STATUS, &blob_handle.bl_handle)) {
						_php_ibase_error();
						goto _php_ibase_fetch_error;
					}

				} else { /* blob id only */
					ISC_QUAD bl_qd = *(ISC_QUAD *) var->sqldata;
					ZVAL_NEW_STR(result, _php_ibase_quad_to_string(bl_qd));
				}
				break;
			case SQL_ARRAY:
				fbp_fatal("SQL_ARRAY type is not supported");
			_php_ibase_fetch_error:
				if (blob_handle.bl_handle) {
					ISC_STATUS_ARRAY close_status;
					isc_close_blob(close_status, &blob_handle.bl_handle);
				}
				zend_array_destroy(ht_ret);
				RETURN_FALSE;
		} /* switch */

		zend_hash_move_forward(ht_ret);
	}

	RETVAL_ARR(ht_ret);
}
/* }}} */

/* {{{ proto array ibase_fetch_row(resource result [, int fetch_flags])
   Fetch a row  from the results of a query */
PHP_FUNCTION(ibase_fetch_row)
{
	_php_ibase_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, FETCH_ROW);
}
/* }}} */

/* {{{ proto array ibase_fetch_assoc(resource result [, int fetch_flags])
   Fetch a row  from the results of a query */
PHP_FUNCTION(ibase_fetch_assoc)
{
	_php_ibase_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, FETCH_ARRAY);
}
/* }}} */

/* {{{ proto object ibase_fetch_object(resource result [, int fetch_flags])
   Fetch a object from the results of a query */
PHP_FUNCTION(ibase_fetch_object)
{
	_php_ibase_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, FETCH_ARRAY);

	if (Z_TYPE_P(return_value) == IS_ARRAY) {
		convert_to_object(return_value);
	}
}
/* }}} */


/* {{{ proto bool ibase_name_result(resource result, string name)
   Assign a name to a result for use with ... WHERE CURRENT OF <name> statements */
PHP_FUNCTION(ibase_name_result)
{
	zval *result_arg;
	char *name_arg;
	size_t name_arg_len;
	ibase_query *ib_query;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &result_arg, &name_arg, &name_arg_len) == FAILURE) {
		return;
	}

	if(_php_ibase_fetch_query_res(result_arg, &ib_query)) {
		return;
	}

	if (isc_dsql_set_cursor_name(IB_STATUS, &ib_query->stmt, name_arg, 0)) {
		_php_ibase_error();
		RETURN_FALSE;
	}

	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool ibase_free_result(resource result)
   Free the memory used by a result */
PHP_FUNCTION(ibase_free_result)
{
	_php_ibase_free_query_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */

/* {{{ proto resource ibase_prepare(resource link_identifier[, string query [, resource trans_identifier ]])
   Prepare a query for later execution */
PHP_FUNCTION(ibase_prepare)
{
	zval *link_arg, *trans_arg;
	ibase_db_link *ib_link;
	ibase_trans *trans = NULL;
	size_t query_len;
	zend_resource *trans_res = NULL;
	ibase_query *ib_query;
	char *query;

	RESET_ERRMSG;

	if (ZEND_NUM_ARGS() == 1) {
		if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &query, &query_len) == FAILURE) {
			return;
		}
		ib_link = (ibase_db_link *)zend_fetch_resource2(IBG(default_link), LE_LINK, le_link, le_plink);
	} else if (ZEND_NUM_ARGS() == 2) {
		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &link_arg, &query, &query_len) == FAILURE) {
			return;
		}
		_php_ibase_get_link_trans(INTERNAL_FUNCTION_PARAM_PASSTHRU, link_arg, &ib_link, &trans);

		if (trans != NULL) {
			trans_res = Z_RES_P(link_arg);
		}
	} else {
		if (zend_parse_parameters(ZEND_NUM_ARGS(), "rrs", &link_arg, &trans_arg, &query, &query_len) == FAILURE) {
			return;
		}
		ib_link = (ibase_db_link *)zend_fetch_resource2_ex(link_arg, LE_LINK, le_link, le_plink);
		trans = (ibase_trans *)zend_fetch_resource_ex(trans_arg, LE_TRANS, le_trans);
		trans_res = Z_RES_P(trans_arg);
	}

	if (FAILURE == _php_ibase_def_trans(ib_link, &trans)) {
		RETURN_FALSE;
	}

	if(FAILURE == _php_ibase_prepare(&ib_query, ib_link, trans, trans_res, query)){
		RETURN_FALSE;
	}

	RETVAL_RES(ib_query->res);
	// Z_TRY_ADDREF_P(return_value);
}
/* }}} */

/* {{{ proto mixed ibase_execute(resource query [, mixed bind_arg [, mixed bind_arg [, ...]]])
   Execute a previously prepared query */
PHP_FUNCTION(ibase_execute)
{
	zval *query, *args = NULL;
	ibase_query *ib_query;
	int bind_n = 0;

	RESET_ERRMSG;

	RETVAL_FALSE;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r*", &query, &args, &bind_n)) {
		return;
	}

	if(_php_ibase_fetch_query_res(query, &ib_query)) {
		return;
	}

	// was do {
		_php_ibase_exec(INTERNAL_FUNCTION_PARAM_PASSTHRU, ib_query, args, bind_n);

		/*
		 * No addref here: _php_ibase_exec() already took the reference that the
		 * returned result owns. The query resource arrives holding one reference of
		 * its own (the caller's $q from ibase_prepare), so after exec the count is
		 * 2 -- one per live variable -- which is what lets the statement be dropped
		 * when both go out of scope. Taking a third one here left it permanently at
		 * 1, so the destructor never ran and the statement stayed open until request
		 * shutdown. ibase_query() differs: it owns the resource itself and releases
		 * that reference with zend_list_delete() once exec has taken its own.
		 */
	// } while (0);
}
/* }}} */

/* {{{ proto bool ibase_free_query(resource query)
   Free memory used by a query */
PHP_FUNCTION(ibase_free_query)
{
	_php_ibase_free_query_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */

/* {{{ proto int ibase_num_fields(resource query_result)
   Get the number of fields in result */
PHP_FUNCTION(ibase_num_fields)
{
	zval *result;
	XSQLDA *sqlda;
	ibase_query *ib_query;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &result) == FAILURE) {
		return;
	}

	if(_php_ibase_fetch_query_res(result, &ib_query)) {
		return;
	}

	sqlda = ib_query->out_sqlda;

	if (sqlda == NULL) {
		RETURN_LONG(0);
	} else {
		RETURN_LONG(sqlda->sqld);
	}
}
/* }}} */

static void _php_ibase_field_info(zval *return_value, ibase_query *ib_query, int is_outvar, zend_long num) /* {{{ */
{
	unsigned short len;
	char buf[16], *s = buf;
	XSQLDA *sqlda;
	XSQLVAR *var;
	ISC_SHORT sqltype;

	if(is_outvar){
		sqlda = ib_query->out_sqlda;
		if (sqlda == NULL) {
			_php_ibase_module_error("Trying to get field info from a non-select query");
			RETURN_FALSE;
		}
	} else {
		sqlda = ib_query->in_sqlda;
		if (sqlda == NULL) {
			// TODO: Add warning? Remove above warning?
			RETURN_FALSE;
		}
	}

	var = sqlda->sqlvar;

	if (!var || num < 0 || num >= sqlda->sqld)RETURN_FALSE;

	var += num;

	/*
	 * Report the type the server described, not the one we fetch with: output CHAR is
	 * read as VARCHAR so Firebird itself handles the character padding, see
	 * _php_ibase_alloc_xsqlda_vars().
	 */
	sqltype = (is_outvar && ib_query->out_sql_types) ? ib_query->out_sql_types[num] : var->sqltype;

	array_init(return_value);

	// AFAIK describe bind does not set sqlname, aliasname, relname?
	// Confirmation needed so I leave this as is. After that we can check
	// is_outvar

#if FB_API_VER >= 40
	if(IBG(master_instance) && IBG(get_statement_interface)) {
		void *statement = NULL;
		if(((fb_get_statement_interface_t)IBG(get_statement_interface))(IB_STATUS, &statement, &ib_query->stmt)){
			fbu_release_statement(statement);
			_php_ibase_error();
			zval_ptr_dtor(return_value);
			RETURN_FALSE;
		}

		if(fbu_insert_field_info(IBG(master_instance), IB_STATUS, is_outvar, (unsigned int)num, return_value, statement)){
			fbu_release_statement(statement);
			_php_ibase_error();
			zval_ptr_dtor(return_value);
			RETURN_FALSE;
		}

		fbu_release_statement(statement);
	} else {
#endif
		// Old API
		add_index_stringl(return_value, 0, var->sqlname, strlen(var->sqlname));
		add_assoc_stringl(return_value, "name", var->sqlname, strlen(var->sqlname));

		add_index_stringl(return_value, 1, var->aliasname, strlen(var->aliasname));
		add_assoc_stringl(return_value, "alias", var->aliasname, strlen(var->aliasname));

		add_index_stringl(return_value, 2, var->relname, strlen(var->relname));
		add_assoc_stringl(return_value, "relation", var->relname, strlen(var->relname));
#if FB_API_VER >= 40
	}
#endif

	len = slprintf(buf, 16, "%d", var->sqllen);
	add_index_stringl(return_value, 3, buf, len);
	add_assoc_stringl(return_value, "length", buf, len);

	/*
	* SQL_ consts are part of Firebird-API.
	*/

	if (var->sqlscale < 0) {
		unsigned short precision = 0;

		switch (sqltype & ~1) {
#ifdef SQL_BOOLEAN
			case SQL_BOOLEAN:
				precision = 1;
				break;
#endif
			case SQL_SHORT:
				precision = 4;
				break;
			case SQL_LONG:
				precision = 9;
				break;
			case SQL_INT64:
				precision = 18;
				break;
		}
		len = slprintf(buf, 16, "NUMERIC(%d,%d)", precision, -var->sqlscale);
		add_index_stringl(return_value, 4, s, len);
		add_assoc_stringl(return_value, "type", s, len);
	} else {
		switch (sqltype & ~1) {
			case SQL_TEXT:
				s = "CHAR";
				break;
			case SQL_VARYING:
				s = "VARCHAR";
				break;
			case SQL_SHORT:
				s = "SMALLINT";
				break;
#ifdef SQL_BOOLEAN
			case SQL_BOOLEAN:
				s = "BOOLEAN";
				break;
#endif
			case SQL_LONG:
				s = "INTEGER";
				break;
			case SQL_FLOAT:
				s = "FLOAT"; break;
			case SQL_DOUBLE:
			case SQL_D_FLOAT:
				s = "DOUBLE PRECISION"; break;
			case SQL_INT64:
				s = "BIGINT";
				break;
			case SQL_TIMESTAMP:
				s = "TIMESTAMP";
				break;
			case SQL_TYPE_DATE:
				s = "DATE";
				break;
			case SQL_TYPE_TIME:
				s = "TIME";
				break;
			case SQL_BLOB:
				s = "BLOB";
				break;
			case SQL_ARRAY:
				s = "ARRAY";
				break;
				/* FIXME: provide more detailed information about the field type, field size
				 * and array dimensions */
			case SQL_QUAD:
				s = "QUAD";
				break;
#if FB_API_VER >= 40
			// These are converted to VARCHAR via isc_dpb_set_bind tag at
			// connect and will appear to clients as VARCHAR
			// case SQL_DEC16:
			// case SQL_DEC34:
			// case SQL_INT128:
			case SQL_TIMESTAMP_TZ:
				s = "TIMESTAMP WITH TIME ZONE";
				break;
			case SQL_TIME_TZ:
				s = "TIME WITH TIME ZONE";
				break;
#endif
		}
		add_index_string(return_value, 4, s);
		add_assoc_string(return_value, "type", s);
	}
}
/* }}} */

/* {{{ proto array ibase_field_info(resource query_result, int field_number)
   Get information about a field */
PHP_FUNCTION(ibase_field_info)
{
	zval *result_arg;
	zend_long field_arg;
	ibase_query *ib_query;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &result_arg, &field_arg) == FAILURE) {
		return;
	}

	if(_php_ibase_fetch_query_res(result_arg, &ib_query)) {
		return;
	}

	_php_ibase_field_info(return_value, ib_query, 1, field_arg);
}
/* }}} */

/* {{{ proto int ibase_num_params(resource query)
   Get the number of params in a prepared query */
PHP_FUNCTION(ibase_num_params)
{
	zval *result;
	ibase_query *ib_query;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &result) == FAILURE) {
		return;
	}

	if(_php_ibase_fetch_query_res(result, &ib_query)) {
		return;
	}

	if (ib_query->in_sqlda == NULL) {
		RETURN_LONG(0);
	} else {
		RETURN_LONG(ib_query->in_sqlda->sqld);
	}
}
/* }}} */

/* {{{ proto array ibase_param_info(resource query, int field_number)
   Get information about a parameter */
PHP_FUNCTION(ibase_param_info)
{
	zval *result_arg;
	zend_long field_arg;
	ibase_query *ib_query;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &result_arg, &field_arg) == FAILURE) {
		return;
	}

	if(_php_ibase_fetch_query_res(result_arg, &ib_query)) {
		return;
	}

	_php_ibase_field_info(return_value, ib_query, 0, field_arg);
}
/* }}} */

static int _php_ibase_set_query_info(ibase_query *ib_query)
{
	int rv = FAILURE;
	// size_t buf_size = 128;
	// ISC_UCHAR *buf = emalloc(buf_size);

	ISC_UCHAR buf[64] = {0};
	size_t buf_size = sizeof(buf);

	size_t pos;

	static ISC_UCHAR info_req[] = {
		isc_info_sql_stmt_type,
		isc_info_sql_select,
			isc_info_sql_num_variables,
		isc_info_sql_bind,
			isc_info_sql_num_variables,
	};
// _php_ibase_parse_info_retry:
// 	memset(buf, 0, buf_size);
	pos = 0;

	// Assume buf will be tagged with `isc_info_truncated` and later in parsing
	// we will catch that. Until `isc_info_truncated` is reached assume pos +=
	// 2, etc are safe.
	if (isc_dsql_sql_info(IB_STATUS, &ib_query->stmt, sizeof(info_req), (ISC_SCHAR *)info_req, (short)buf_size, (ISC_SCHAR *)buf)) {
		_php_ibase_error();
		goto _php_ibase_parse_info_fail;
	}

	int ctx = 0;
	while((pos < buf_size) && (buf[pos] != isc_info_end))
	{
		const ISC_UCHAR tag = buf[pos++];
		switch(tag) {
			case isc_info_sql_stmt_type: {
				const ISC_USHORT size = (ISC_USHORT)isc_portable_integer(&buf[pos], 2); pos += 2;
				ib_query->statement_type = (ISC_UCHAR)isc_portable_integer(&buf[pos], size); pos += size;
			} break;
			case isc_info_sql_select: ctx = 1; break;
			case isc_info_sql_bind: ctx = 2; break;
			case isc_info_sql_num_variables: {
				const ISC_USHORT size = (ISC_USHORT)isc_portable_integer(&buf[pos], 2); pos += 2;
				const ISC_USHORT count = (ISC_USHORT)isc_portable_integer(&buf[pos], size); pos += size;
				if(ctx == 1) {
					ib_query->out_fields_count = count;
				} else if(ctx == 2) {
					ib_query->in_fields_count = count;
				} else {
					fbp_fatal("isc_info_sql_num_variables: unknown ctx %d", ctx);
				}
				ctx = 0;
			} break;
			case isc_info_truncated: {
				fbp_fatal("BUG: sql_info buffer truncated, current capacity: %ld", buf_size);
				// fbp_notice("BUG: sql_info buffer truncated, current capacity: %ld", buf_size);
				// Dynamic resize
				// buf_size *= 2;
				// buf = erealloc(buf, buf_size);
				// goto _php_ibase_parse_info_retry;
			} break;
			case isc_info_error: {
				fbp_fatal("sql_info buffer error, pos: %lu", pos);
				goto _php_ibase_parse_info_fail;
			} break;
			default: {
				fbp_fatal("BUG: unrecognized sql_info entry: %d, pos: %lu", tag, pos);
				goto _php_ibase_parse_info_fail;
			} break;
		}
	}

	if(buf[pos] != isc_info_end) {
		fbp_fatal("BUG: sql_info unexpected end of buffer at pos: %lu", pos);
		goto _php_ibase_parse_info_fail;
	}

	rv = SUCCESS;

_php_ibase_parse_info_fail:
	// efree(buf);
	return rv;
}

static int _php_ibase_fetch_query_res(zval *from, ibase_query **ib_query)
{
	*ib_query = zend_fetch_resource_ex(from, LE_QUERY, le_query);

	if(*ib_query == NULL) {
		// TODO: throw something or not? notice? warning?
		// fbp_notice("query already freed");
		return FAILURE;
	}

	return SUCCESS;
}

// We can't rely on aliasname coming from XSQLVAR if we want long field names
// (>31). We also can't rely on parsing buffer from isc_dsql_sql_info() because
// it's 32KB limit can be easily overflown with combination of long field names
// and large amounts of fields. So I added wrapper to use newer API but that
// also require runtime fbclient > 40 hence the runtime checks. Ideally rewrite
// everything using newer API but that's a bit of work.
static int _php_ibase_alloc_ht_aliases(ibase_query *ib_query)
{
	ALLOC_HASHTABLE(ib_query->ht_aliases);
	zend_hash_init(ib_query->ht_aliases, ib_query->out_fields_count, NULL, ZVAL_PTR_DTOR, 0);

#if FB_API_VER >= 40
	if(IBG(master_instance) && IBG(get_statement_interface)) {
		void *statement = NULL;
		if(((fb_get_statement_interface_t)IBG(get_statement_interface))(IB_STATUS, &statement, &ib_query->stmt)){
			fbu_release_statement(statement);
			return FAILURE;
		}

		if(fbu_insert_aliases(IBG(master_instance), IB_STATUS, ib_query, statement)){
			fbu_release_statement(statement);
			return FAILURE;
		}

		fbu_release_statement(statement);
	} else {
#endif
		// Old API
		for(size_t i = 0; i < ib_query->out_fields_count; i++){
			XSQLVAR *var = &ib_query->out_sqlda->sqlvar[i];

			_php_ibase_insert_alias(ib_query->ht_aliases, var->aliasname);
		}
#if FB_API_VER >= 40
	}
#endif

	return SUCCESS;
}

static void _php_ibase_alloc_ht_ind(ibase_query *ib_query)
{
	ALLOC_HASHTABLE(ib_query->ht_ind);
	zend_hash_init(ib_query->ht_ind, ib_query->out_fields_count, NULL, ZVAL_PTR_DTOR, 0);

	zval t2;
	ZVAL_NULL(&t2);

	for(size_t i = 0; i < ib_query->out_fields_count; i++) {
		zend_hash_index_add(ib_query->ht_ind, i, &t2);
	}
}

static void _php_ibase_free_query_impl(INTERNAL_FUNCTION_PARAMETERS, int as_result)
{
	zval *query_arg;
	ibase_query *ib_query;

	RESET_ERRMSG;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &query_arg) == FAILURE) {
		RETURN_FALSE;
	}

	if(_php_ibase_fetch_query_res(query_arg, &ib_query)) {
		RETURN_FALSE;
	}

	if(!as_result || ib_query->was_result_once) {
		zend_list_close(Z_RES_P(query_arg));
	}

	RETURN_TRUE;
}

#endif /* HAVE_IBASE */