<?php
/**
 * Firebird driver.
 *
 * Requires firebird client. Works on Windows and Unix.
 *
 * This file is part of ADOdb, a Database Abstraction Layer library for PHP.
 *
 * @package ADOdb
 * @link https://adodb.org Project's web site and documentation
 * @link https://github.com/ADOdb/ADOdb Source code and issue tracker
 *
 * The ADOdb Library is dual-licensed, released under both the BSD 3-Clause
 * and the GNU Lesser General Public Licence (LGPL) v2.1 or, at your option,
 * any later version. This means you can use it in proprietary products.
 * See the LICENSE.md file distributed with this source code for details.
 * @license BSD-3-Clause
 * @license LGPL-2.1-or-later
 *
 * @copyright 2000-2013 John Lim
 * @copyright 2014 Damien Regad, Mark Newnham and the ADOdb community

>  *
 */
>  * Driver was cloned from Interbase, so there's quite a lot of duplicated code

>  * @noinspection DuplicatedCode
// security - hide paths
>  * @noinspection PhpUnused


if (!defined('ADODB_DIR')) die();

class ADODB_firebird extends ADOConnection {
	var $databaseType = "firebird";
	var $dataProvider = "firebird";
	var $replaceQuote = "''"; // string to use to replace quotes
	var $fbird_datefmt = '%Y-%m-%d'; // For hours,mins,secs change to '%Y-%m-%d %H:%M:%S';
	var $fmtDate = "'Y-m-d'";
	var $fbird_timestampfmt = "%Y-%m-%d %H:%M:%S";
	var $fbird_timefmt = "%H:%M:%S";
	var $fmtTimeStamp = "'Y-m-d, H:i:s'";
	var $concat_operator='||';
	var $_transactionID;

< 	var $metaTablesSQL = "select lower(rdb\$relation_name) from rdb\$relations where rdb\$relation_name not like 'RDB\$%'";



> 
> 	public $metaTablesSQL = "SELECT LOWER(rdb\$relation_name) FROM rdb\$relations";


	//OPN STUFF start

> 


	var $metaColumnsSQL = "select lower(a.rdb\$field_name), a.rdb\$null_flag, a.rdb\$default_source, b.rdb\$field_length, b.rdb\$field_scale, b.rdb\$field_sub_type, b.rdb\$field_precision, b.rdb\$field_type from rdb\$relation_fields a, rdb\$fields b where a.rdb\$field_source = b.rdb\$field_name and a.rdb\$relation_name = '%s' order by a.rdb\$field_position asc";
	//OPN STUFF end

< 	var $ibasetrans;



> 
> 	public $_genSeqSQL = "CREATE SEQUENCE %s START WITH %s";
> 
> 	public $_dropSeqSQL = "DROP SEQUENCE %s";
> 


	var $hasGenID = true;
	var $_bindInputArray = true;

< 	var $buffers = 0;
< 	var $dialect = 3;


	var $sysDate = "cast('TODAY' as timestamp)";
	var $sysTimeStamp = "CURRENT_TIMESTAMP"; //"cast('NOW' as timestamp)";
	var $ansiOuter = true;
	var $hasAffectedRows = true;
	var $poorAffectedRows = false;
	var $blobEncodeType = 'C';

< 	var $role = false;



> 	/*
> 	* firebird custom optionally specifies the user role
> 	*/
> 	public $role = false;
> 	/*
> 	* firebird custom optionally specifies the connection buffers
> 	*/
> 	public $buffers = 0;
> 
> 	/*
> 	* firebird custom optionally specifies database dialect
> 	*/
> 	public $dialect = 3;
> 


	var $nameQuote = '';		/// string to use to quote identifiers and names

	function __construct()
	{

< 	// Ignore IBASE_DEFAULT we want a more practical transaction!
< 	//	if (defined('IBASE_DEFAULT')) $this->ibasetrans = IBASE_DEFAULT;
< 	//	else
< 		$this->ibasetrans = IBASE_WAIT | IBASE_REC_VERSION | IBASE_COMMITTED;



> 		parent::__construct();
> 		$this->setTransactionMode('');


	}


> 	/**

> 	 * Sets the isolation level of a transaction.
	// returns true or false
> 	 *
	function _connect($argHostname, $argUsername, $argPassword, $argDatabasename,$persist=false)
> 	 * The default behavior is a more practical IBASE_WAIT | IBASE_REC_VERSION | IBASE_COMMITTED
	{
> 	 * instead of IBASE_DEFAULT
		if (!function_exists('fbird_pconnect')) return null;
> 	 *
		if ($argDatabasename) $argHostname .= ':'.$argDatabasename;
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:settransactionmode
		$fn = ($persist) ? 'fbird_pconnect':'fbird_connect';
> 	 *
		if ($this->role)
> 	 * @param string $transaction_mode The transaction mode to set.
			$this->_connectionID = $fn($argHostname,$argUsername,$argPassword,
> 	 *
					$this->charSet,$this->buffers,$this->dialect,$this->role);
> 	 * @return void
		else
> 	 */
			$this->_connectionID = $fn($argHostname,$argUsername,$argPassword,
> 	public function setTransactionMode($transaction_mode)
					$this->charSet,$this->buffers,$this->dialect);
> 	{

> 		$this->_transmode = $transaction_mode;



< 	// returns true or false
< 	function _connect($argHostname, $argUsername, $argPassword, $argDatabasename,$persist=false)



> 		if (empty($transaction_mode)) {
> 			$this->_transmode = IBASE_WAIT | IBASE_REC_VERSION | IBASE_COMMITTED;
> 		}
> 
> 	}
> 
> 	/**
> 	 * Connect to a database.
> 	 *
> 	 * @todo add: parameter int $port, parameter string $socket
> 	 *
> 	 * @param string|null $argHostname (Optional) The host to connect to.
> 	 * @param string|null $argUsername (Optional) The username to connect as.
> 	 * @param string|null $argPassword (Optional) The password to connect with.
> 	 * @param string|null $argDatabasename (Optional) The name of the database to start in when connected.
> 	 * @param bool $persist (Optional) Whether or not to use a persistent connection.
> 	 *
> 	 * @return bool|null True if connected successfully, false if connection failed, or null if the mysqli extension
> 	 * isn't currently loaded.
> 	 */
> 	public function _connect($argHostname, $argUsername, $argPassword, $argDatabasename,$persist=false)



< 		if (!function_exists('fbird_pconnect')) return null;
< 		if ($argDatabasename) $argHostname .= ':'.$argDatabasename;



> 		if (!function_exists('fbird_pconnect'))
> 			return null;
> 
> 		if ($argDatabasename)
> 			$argHostname .= ':'.$argDatabasename;
> 


			$this->_handleerror();

> 
			return false;
> 		/*
		}
> 		* Now merge in the standard connection parameters setting

> 		*/
		// PHP5 change.
> 		foreach ($this->connectionParameters as $options)
		if (function_exists('fbird_timefmt')) {
> 		{
			fbird_timefmt($this->fbird_datefmt,fbird_DATE );
> 			foreach($options as $k=>$v)
			if ($this->dialect == 1) {
> 			{
				fbird_timefmt($this->fbird_datefmt,fbird_TIMESTAMP );
> 				switch($k){
			} else {
> 				case 'role':
				fbird_timefmt($this->fbird_timestampfmt,fbird_TIMESTAMP );
> 					$this->role = $v;
			}
> 					break;
			fbird_timefmt($this->fbird_timefmt,fbird_TIME );
> 				case 'dialect':

> 					$this->dialect = $v;
		} else {
> 					break;
			ini_set("ibase.timestampformat", $this->fbird_timestampfmt);
> 				case 'buffers':
			ini_set("ibase.dateformat", $this->fbird_datefmt);
> 					$this->buffers = $v;
			ini_set("ibase.timeformat", $this->fbird_timefmt);
> 				}
		}
> 			}
		return true;
> 		}
	}
> 



< 		if ($this->dialect != 1) { // http://www.ibphoenix.com/ibp_60_del_id_ds.html
< 			$this->replaceQuote = "''";



> 		if ($this->dialect == 1) { // http://www.ibphoenix.com/ibp_60_del_id_ds.html
> 			$this->replaceQuote = "";



< 			$this->_handleerror();



> 			$this->_handleError();



< 		// PHP5 change.
< 		if (function_exists('fbird_timefmt')) {
< 			fbird_timefmt($this->fbird_datefmt,fbird_DATE );
< 			if ($this->dialect == 1) {
< 				fbird_timefmt($this->fbird_datefmt,fbird_TIMESTAMP );
< 			} else {
< 				fbird_timefmt($this->fbird_timestampfmt,fbird_TIMESTAMP );
< 			}
< 			fbird_timefmt($this->fbird_timefmt,fbird_TIME );
< 
< 		} else {



< 		}



> 



< 	// returns true or false



> 	/**
> 	 * Connect to a database with a persistent connection.
> 	 *
> 	 * @param string|null $argHostname The host to connect to.
> 	 * @param string|null $argUsername The username to connect as.
> 	 * @param string|null $argPassword The password to connect with.
> 	 * @param string|null $argDatabasename The name of the database to start in when connected.
> 	 *
> 	 * @return bool|null True if connected successfully, false if connection failed, or null if the mysqli extension
> 	 * isn't currently loaded.
> 	 */



< 	function MetaPrimaryKeys($table,$owner_notused=false,$internalKey=false)



> 	public function metaPrimaryKeys($table,$owner_notused=false,$internalKey=false)


	FROM RDB$INDICES I JOIN RDB$INDEX_SEGMENTS S ON I.RDB$INDEX_NAME=S.RDB$INDEX_NAME
	WHERE I.RDB$RELATION_NAME=\''.$table.'\' and I.RDB$INDEX_NAME like \'RDB$PRIMARY%\'
	ORDER BY I.RDB$INDEX_NAME,S.RDB$FIELD_POSITION';

		$a = $this->GetCol($sql,false,true);
		if ($a && sizeof($a)>0) return $a;
		return false;
	}


< 	function ServerInfo()



> 	/**
> 	 * Get information about the current Firebird server.
> 	 *
> 	 * @return array
> 	 */
> 	public function serverInfo()


	{
		$arr['dialect'] = $this->dialect;
		switch($arr['dialect']) {
		case '':

< 		case '1': $s = 'Firebird Dialect 1'; break;
< 		case '2': $s = 'Firebird Dialect 2'; break;



> 			case '1':
> 				$s = 'Firebird Dialect 1';
> 				break;
> 			case '2':
> 				$s = 'Firebird Dialect 2';
> 				break;


		default:

< 		case '3': $s = 'Firebird Dialect 3'; break;



> 			case '3':
> 				$s = 'Firebird Dialect 3';
> 				break;


		}
		$arr['version'] = ADOConnection::_findvers($s);
		$arr['description'] = $s;
		return $arr;
	}


< 	function BeginTrans()



> 	/**
> 	 * Begin a Transaction. Must be followed by CommitTrans() or RollbackTrans().
> 	 *
> 	 * @return bool true if succeeded or false if database does not support transactions
> 	 */
> 	public function beginTrans()


	{
		if ($this->transOff) return true;
		$this->transCnt += 1;
		$this->autoCommit = false;

< 		$this->_transactionID = fbird_trans( $this->ibasetrans, $this->_connectionID );



> 		/*
> 		* We manage the transaction mode via fbird_trans
> 		*/
> 		$this->_transactionID = fbird_trans( $this->_transmode, $this->_connectionID );


		return $this->_transactionID;
	}


< 	function CommitTrans($ok=true)



> 
> 	/**
> 	 * Commits a transaction.
> 	 *
> 	 * @param bool $ok  false to rollback transaction, true to commit
> 	 *
> 	 * @return bool
> 	 */
> 	public function commitTrans($ok=true)


	{
		if (!$ok) {
			return $this->RollbackTrans();
		}
		if ($this->transOff) {
			return true;
		}
		if ($this->transCnt) {
			$this->transCnt -= 1;
		}
		$ret = false;
		$this->autoCommit = true;
		if ($this->_transactionID) {

< 			//print ' commit ';


			$ret = fbird_commit($this->_transactionID);
		}
		$this->_transactionID = false;
		return $ret;
	}

	function _affectedrows()
	{

< 			return fbird_affected_rows( $this->_transactionID ? $this->_transactionID : $this->_connectionID );



> 		return fbird_affected_rows($this->_transactionID ?: $this->_connectionID);


	}


< 	// there are some compat problems with ADODB_COUNTRECS=false and $this->_logsql currently.
< 	// it appears that ibase extension cannot support multiple concurrent queryid's
< 	function _Execute($sql,$inputarr=false) {
< 	global $ADODB_COUNTRECS;
< 
< 		if ($this->_logsql) {
< 			$savecrecs = $ADODB_COUNTRECS;
< 			$ADODB_COUNTRECS = true; // force countrecs
< 			$ret =& ADOConnection::_Execute($sql,$inputarr);
< 			$ADODB_COUNTRECS = $savecrecs;
< 		} else {
< 			$ret = ADOConnection::_Execute($sql,$inputarr);
< 		}
< 		return $ret;
< 	}
< 
< 	function RollbackTrans()



> 	/**
> 	 * Rollback a smart transaction.
> 	 *
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:rollbacktrans
> 	 *
> 	 * @return bool
> 	 */
> 	public function rollbackTrans()


	{

< 		if ($this->transOff) return true;
< 		if ($this->transCnt) $this->transCnt -= 1;



> 		if ($this->transOff)
> 			return true;
> 		if ($this->transCnt)
> 			$this->transCnt -= 1;
> 


		$ret = false;
		$this->autoCommit = true;

> 


		if ($this->_transactionID) {
			$ret = fbird_rollback($this->_transactionID);
		}
		$this->_transactionID = false;

		return $ret;
	}


< 	function &MetaIndexes ($table, $primary = FALSE, $owner=false)



> 	/**
> 	 * Get a list of indexes on the specified table.
> 	 *
> 	 * @param string $table The name of the table to get indexes for.
> 	 * @param bool $primary (Optional) Whether or not to include the primary key.
> 	 * @param bool $owner (Optional) Unused.
> 	 *
> 	 * @return array|bool An array of the indexes, or false if the query to get the indexes failed.
> 	 */
> 	public function metaIndexes($table, $primary = false, $owner = false)


	{
		// save old fetch mode
		global $ADODB_FETCH_MODE;

< 		$false = false;


		$save = $ADODB_FETCH_MODE;
		$ADODB_FETCH_MODE = ADODB_FETCH_NUM;

> 


		if ($this->fetchMode !== FALSE) {
				$savem = $this->SetFetchMode(FALSE);
		}

> 


		$table = strtoupper($table);
		$sql = "SELECT * FROM RDB\$INDICES WHERE RDB\$RELATION_NAME = '".$table."'";
		if (!$primary) {
			$sql .= " AND RDB\$INDEX_NAME NOT LIKE 'RDB\$%'";
		} else {
			$sql .= " AND RDB\$INDEX_NAME NOT LIKE 'RDB\$FOREIGN%'";
		}
		// get index details

< 		$rs = $this->Execute($sql);



> 		$rs = $this->execute($sql);


		if (!is_object($rs)) {
			// restore fetchmode
			if (isset($savem)) {
				$this->SetFetchMode($savem);
			}
			$ADODB_FETCH_MODE = $save;

< 			return $false;



> 			return false;


		}

< 


		$indexes = array();
		while ($row = $rs->FetchRow()) {

< 			$index = $row[0];



> 
> 			$index = trim($row[0]);


			if (!isset($indexes[$index])) {
				if (is_null($row[3])) {
					$row[3] = 0;
				}
				$indexes[$index] = array(
					'unique' => ($row[3] == 1),
					'columns' => array()
				);
			}

< 			$sql = "SELECT * FROM RDB\$INDEX_SEGMENTS WHERE RDB\$INDEX_NAME = '".$index."' ORDER BY RDB\$FIELD_POSITION ASC";
< 			$rs1 = $this->Execute($sql);



> 			$sql = sprintf("SELECT * FROM RDB\$INDEX_SEGMENTS WHERE RDB\$INDEX_NAME = '%s' ORDER BY RDB\$FIELD_POSITION ASC",$index);
> 			$rs1 = $this->execute($sql);


			while ($row1 = $rs1->FetchRow()) {

< 				$indexes[$index]['columns'][$row1[2]] = $row1[1];



> 				$indexes[$index]['columns'][$row1[2]] = trim($row1[1]);


			}
		}

> 


		// restore fetchmode
		if (isset($savem)) {
			$this->SetFetchMode($savem);
		}
		$ADODB_FETCH_MODE = $save;

		return $indexes;
	}


< 
< 	// See http://community.borland.com/article/0,1410,25844,00.html
< 	function RowLock($tables,$where,$col=false)



> 	/**
> 	 * Lock a table row for a duration of a transaction.
> 	 *
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:rowlock
> 	 * @link https://firebirdsql.org/refdocs/langrefupd21-notes-withlock.html
> 	 *
> 	 * @param string $table The table(s) to lock rows for.
> 	 * @param string $where (Optional) The WHERE clause to use to determine which rows to lock.
> 	 * @param string $col (Optional) The columns to select.
> 	 *
> 	 * @return bool True if the locking SQL statement executed successfully, otherwise false.
> 	 */
> 	public function rowLock($table,$where,$col=false)


	{

< 		if ($this->autoCommit) {
< 			$this->BeginTrans();
< 		}
< 		$this->Execute("UPDATE $table SET $col=$col WHERE $where "); // is this correct - jlim?
< 		return 1;
< 	}
< 



> 		if ($this->transCnt==0)
> 			$this->beginTrans();




< 	function CreateSequence($seqname = 'adodbseq', $startID = 1)
< 	{
< 		$ok = $this->Execute(("CREATE GENERATOR $seqname" ));
< 		if (!$ok) return false;
< 		return $this->Execute("SET GENERATOR $seqname TO ".($startID-1));



> 		if ($where) $where = ' where '.$where;
> 		$rs = $this->execute("SELECT $col FROM $table $where FOR UPDATE WITH LOCK");
> 		return !empty($rs);


	}


< 	function DropSequence($seqname = 'adodbseq')



> 	/**
> 	 * Creates a sequence in the database.
> 	 *
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:createsequence
> 	 *
> 	 * @param string $seqname The sequence name.
> 	 * @param int $startID The start id.
> 	 *
> 	 * @return ADORecordSet|bool A record set if executed successfully, otherwise false.
> 	 */
> 	public function createSequence($seqname='adodbseq', $startID = 1)


	{

< 		$seqname = strtoupper($seqname);
< 		return $this->Execute("DROP GENERATOR $seqname");



> 		$sql = sprintf($this->_genSeqSQL,$seqname,$startID);
> 		return $this->execute($sql);


	}


< 	function GenID($seqname='adodbseq',$startID=1)



> 	/**
> 	 * A portable method of creating sequence numbers.
> 	 *
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:genid
> 	 *
> 	 * @param string $seqname (Optional) The name of the sequence to use.
> 	 * @param int $startID (Optional) The point to start at in the sequence.
> 	 *
> 	 * @return int
> 	 */
> 	public function genID($seqname='adodbseq',$startID=1)


	{
		$getnext = ("SELECT Gen_ID($seqname,1) FROM RDB\$DATABASE");
		$rs = @$this->Execute($getnext);
		if (!$rs) {

< 			$this->Execute(("CREATE GENERATOR $seqname" ));
< 			$this->Execute("SET GENERATOR $seqname TO ".($startID-1).';');



> 			$this->Execute("CREATE SEQUENCE $seqname START WITH $startID");


			$rs = $this->Execute($getnext);
		}
		if ($rs && !$rs->EOF) {
			$this->genID = (integer) reset($rs->fields);
		}
		else {
			$this->genID = 0; // false
		}

		if ($rs) {
			$rs->Close();
		}

		return $this->genID;
	}


< 	function SelectDB($dbName)



> 	function selectDB($dbName)


	{
		return false;
	}


< 	function _handleerror()



> 	function _handleError()


	{

> 		$this->_errorCode = fbird_errcode();


		$this->_errorMsg = fbird_errmsg();
	}


< 	function ErrorNo()



> 
> 	public function errorNo()


	{

< 		if (preg_match('/error code = ([\-0-9]*)/i', $this->_errorMsg,$arr)) return (integer) $arr[1];
< 		else return 0;



> 		return (integer) $this->_errorCode;


	}


< 	function ErrorMsg()



> 	function errorMsg()


	{
			return $this->_errorMsg;
	}


< 	function Prepare($sql)



> 	/**
> 	 * Prepares an SQL statement and returns a handle to use.
> 	 * This is not used by bound parameters anymore
> 	 *
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:prepare
> 	 * @todo update this function to handle prepared statements correctly
> 	 *
> 	 * @param string $sql The SQL to prepare.
> 	 *
> 	 * @return bool|array The SQL that was provided and the prepared parameters,
> 	 *                    or false if the preparation fails
> 	 */
> 	public function prepare($sql)


	{
		$stmt = fbird_prepare($this->_connectionID,$sql);

< 		if (!$stmt) return false;



> 		if (!$stmt)
> 			return false;


		return array($sql,$stmt);
	}


< 	   // returns query ID if successful, otherwise false
< 	   // there have been reports of problems with nested queries - the code is probably not re-entrant?



> 	/**
> 	* Return the query id.
> 	*
> 	* @param string|array $sql
> 	* @param array $iarr
> 	*
> 	* @return bool|object
> 	*/


	function _query($sql,$iarr=false)
	{

< 		if ( !$this->isConnected() ) return false;



> 		if (!$this->isConnected()) {
> 			return false;
> 		}
> 


		if (!$this->autoCommit && $this->_transactionID) {
			$conn = $this->_transactionID;
			$docommit = false;
		} else {
			$conn = $this->_connectionID;
			$docommit = true;
		}

> 


		if (is_array($sql)) {

> 			// Prepared statement


			$fn = 'fbird_execute';

< 			$sql = $sql[1];
< 			if (is_array($iarr)) {
< 				if ( !isset($iarr[0]) ) 
< 					$iarr[0] = ''; // PHP5 compat hack
< 				$fnarr = array_merge( array($sql) , $iarr);
< 				$ret = call_user_func_array($fn,$fnarr);
< 			}
< 			else {
< 				$ret = $fn($sql);
< 			}



> 			$args = [$sql[1]];


		} else {
			$fn = 'fbird_query';

< 			if (is_array($iarr)) 
< 			{
< 				if (sizeof($iarr) == 0) 
< 					$iarr[0] = ''; // PHP5 compat hack
< 				$fnarr = array_merge( array($conn,$sql) , $iarr);
< 				$ret = call_user_func_array($fn,$fnarr);



> 			$args = [$conn, $sql];


			}

< 			else {
< 				$ret = $fn($conn, $sql);



> 		if (is_array($iarr)) {
> 			$args = array_merge($args, $iarr);


			}

> 		$ret = call_user_func_array($fn, $args);
		}
> 
		if ($docommit && $ret === true) {
> 		// fbird_query() and fbird_execute() return number of affected rows
			fbird_commit($this->_connectionID);
> 		// ADOConnection::_Execute() expects true for INSERT/UPDATE/DELETE
		}
> 		if (is_numeric($ret)) {

> 			$ret = true;


		$this->_handleerror();

> 



< 		$this->_handleerror();



> 		$this->_handleError();


	}

	// returns true or false
	function _close()
	{
		if (!$this->autoCommit) {
			@fbird_rollback($this->_connectionID);
		}
		return @fbird_close($this->_connectionID);
	}

	//OPN STUFF start
	function _ConvertFieldType(&$fld, $ftype, $flen, $fscale, $fsubtype, $fprecision, $dialect3)
	{
		$fscale = abs($fscale);
		$fld->max_length = $flen;
		$fld->scale = null;
		switch($ftype){
			case 7:
			case 8:
				if ($dialect3) {
					switch($fsubtype){
						case 0:
							$fld->type = ($ftype == 7 ? 'smallint' : 'integer');
							break;
						case 1:
							$fld->type = 'numeric';
							$fld->max_length = $fprecision;
							$fld->scale = $fscale;
							break;
						case 2:
							$fld->type = 'decimal';
							$fld->max_length = $fprecision;
							$fld->scale = $fscale;
							break;
					} // switch
				} else {
					if ($fscale !=0) {
						$fld->type = 'decimal';
						$fld->scale = $fscale;
						$fld->max_length = ($ftype == 7 ? 4 : 9);
					} else {
						$fld->type = ($ftype == 7 ? 'smallint' : 'integer');
					}
				}
				break;
			case 16:
				if ($dialect3) {
					switch($fsubtype){
						case 0:
							$fld->type = 'decimal';
							$fld->max_length = 18;
							$fld->scale = 0;
							break;
						case 1:
							$fld->type = 'numeric';
							$fld->max_length = $fprecision;
							$fld->scale = $fscale;
							break;
						case 2:
							$fld->type = 'decimal';
							$fld->max_length = $fprecision;
							$fld->scale = $fscale;
							break;
					} // switch
				}
				break;
			case 10:
				$fld->type = 'float';
				break;
			case 14:
				$fld->type = 'char';
				break;
			case 27:
				if ($fscale !=0) {
					$fld->type = 'decimal';
					$fld->max_length = 15;
					$fld->scale = 5;
				} else {
					$fld->type = 'double';
				}
				break;
			case 35:
				if ($dialect3) {
					$fld->type = 'timestamp';
				} else {
					$fld->type = 'date';
				}
				break;
			case 12:
				$fld->type = 'date';
				break;
			case 13:
				$fld->type = 'time';
				break;
			case 37:
				$fld->type = 'varchar';
				break;
			case 40:
				$fld->type = 'cstring';
				break;
			case 261:
				$fld->type = 'blob';
				$fld->max_length = -1;
				break;
		} // switch
	}
	//OPN STUFF end


< 	// returns array of ADOFieldObjects for current table
< 	function MetaColumns($table, $normalize=true)



> 	/**
> 	 * Return an array of information about a table's columns.
> 	 *
> 	 * @param string $table The name of the table to get the column info for.
> 	 * @param bool $normalize (Optional) Unused.
> 	 *
> 	 * @return ADOFieldObject[]|bool An array of info for each column,
> 	 * or false if it could not determine the info.
> 	 */
> 	public function metaColumns($table, $normalize = true)


	{

> 


	global $ADODB_FETCH_MODE;

		$save = $ADODB_FETCH_MODE;
		$ADODB_FETCH_MODE = ADODB_FETCH_NUM;


< 		$rs = $this->Execute(sprintf($this->metaColumnsSQL,strtoupper($table)));



> 		$rs = $this->execute(sprintf($this->metaColumnsSQL,strtoupper($table)));



		$ADODB_FETCH_MODE = $save;

< 		$false = false;



> 


		if ($rs === false) {

< 			return $false;



> 			return false;


		}

		$retarr = array();
		//OPN STUFF start

< 		$dialect3 = ($this->dialect==3 ? true : false);



> 		$dialect3 = $this->dialect == 3;


		//OPN STUFF end
		while (!$rs->EOF) { //print_r($rs->fields);
			$fld = new ADOFieldObject();
			$fld->name = trim($rs->fields[0]);
			//OPN STUFF start

< 			$this->_ConvertFieldType($fld, $rs->fields[7], $rs->fields[3], $rs->fields[4], $rs->fields[5], $rs->fields[6], $dialect3);



> 				//print_r($rs->fields);
> 			$this->_ConvertFieldType(
> 				$fld, $rs->fields[7], $rs->fields[3], $rs->fields[4], $rs->fields[5], $rs->fields[6], $dialect3);


			if (isset($rs->fields[1]) && $rs->fields[1]) {
				$fld->not_null = true;
			}
			if (isset($rs->fields[2])) {

				$fld->has_default = true;
				$d = substr($rs->fields[2],strlen('default '));

< 				switch ($fld->type)
< 				{



> 				switch ($fld->type) {


				case 'smallint':

< 				case 'integer': $fld->default_value = (int) $d; break;



> 					case 'integer':
> 						$fld->default_value = (int)$d;
> 						break;


				case 'char':
				case 'blob':
				case 'text':

< 				case 'varchar': $fld->default_value = (string) substr($d,1,strlen($d)-2); break;



> 					case 'varchar':
> 						$fld->default_value = (string)substr($d, 1, strlen($d) - 2);
> 						break;


				case 'double':

< 				case 'float': $fld->default_value = (float) $d; break;
< 				default: $fld->default_value = $d; break;



> 					case 'float':
> 						$fld->default_value = (float)$d;
> 						break;
> 					default:
> 						$fld->default_value = $d;
> 						break;


				}
		//	case 35:$tt = 'TIMESTAMP'; break;
			}
			if ((isset($rs->fields[5])) && ($fld->type == 'blob')) {
				$fld->sub_type = $rs->fields[5];
			} else {
				$fld->sub_type = null;
			}
			//OPN STUFF end
			if ($ADODB_FETCH_MODE == ADODB_FETCH_NUM) $retarr[] = $fld;
			else $retarr[strtoupper($fld->name)] = $fld;

			$rs->MoveNext();
		}
		$rs->Close();

< 		if ( empty($retarr)) return $false;



> 		if ( empty($retarr))
> 			return false;


		else return $retarr;
	}


< 	function BlobEncode( $blob )



> 	/**
> 	 * Retrieves a list of tables based on given criteria
> 	 *
> 	 * @param string|bool $ttype (Optional) Table type = 'TABLE', 'VIEW' or false=both (default)
> 	 * @param string|bool $showSchema (Optional) schema name, false = current schema (default)
> 	 * @param string|bool $mask (Optional) filters the table by name
> 	 *
> 	 * @return array list of tables
> 	 */
> 	public function metaTables($ttype = false, $showSchema = false, $mask = false)
> 	{
> 		$save = $this->metaTablesSQL;
> 		if (!$showSchema) {
> 			$this->metaTablesSQL .= " WHERE (rdb\$relation_name NOT LIKE 'RDB\$%' AND rdb\$relation_name NOT LIKE 'MON\$%' AND rdb\$relation_name NOT LIKE 'SEC\$%')";
> 		} elseif (is_string($showSchema)) {
> 			$this->metaTablesSQL .= $this->qstr($showSchema);
> 		}
> 
> 		if ($mask) {
> 			$mask = $this->qstr($mask);
> 			$this->metaTablesSQL .= " AND table_name LIKE $mask";
> 		}
> 		$ret = ADOConnection::metaTables($ttype,$showSchema);
> 
> 		$this->metaTablesSQL = $save;
> 		return $ret;
> 	}
> 
> 	/**
> 	 * Encodes a blob, then assigns an id ready to be used
> 	 *
> 	 * @param string $blob The blob to be encoded
> 	 *
> 	 * @return bool success
> 	 */
> 	public function blobEncode( $blob )


	{
		$blobid = fbird_blob_create( $this->_connectionID);
		fbird_blob_add( $blobid, $blob );
		return fbird_blob_close( $blobid );
	}


< 	// since we auto-decode all blob's since 2.42,
< 	// BlobDecode should not do any transforms
< 	function BlobDecode($blob)



> 	/**
> 	 * Manually decode a blob
> 	 *
> 	 * since we auto-decode all blob's since 2.42,
> 	 * BlobDecode should not do any transforms
> 	 *
> 	 * @param string $blob
> 	 *
> 	 * @return string the same blob
> 	 */
> 	public function blobDecode($blob)


	{
		return $blob;
	}


< 	// old blobdecode function
< 	// still used to auto-decode all blob's
< 	function _BlobDecode_old( $blob )



> 	/**
> 	 * Auto function called on read of blob to decode
> 	 *
> 	 * @param string $blob Value to decode
> 	 *
> 	 * @return string Decoded blob
> 	 */
> 	public function _blobDecode($blob)


	{

< 		$blobid = fbird_blob_open($this->_connectionID, $blob );
< 		$realblob = fbird_blob_get( $blobid,$this->maxblobsize); // 2nd param is max size of blob -- Kevin Boillet <kevinboillet@yahoo.fr>
< 		while($string = fbird_blob_get($blobid, 8192)){
< 			$realblob .= $string;



> 		if ($blob === null) {
> 			return '';


		}

< 		fbird_blob_close( $blobid );




< 		return( $realblob );
< 	}
< 
< 	function _BlobDecode( $blob )
< 	{


		$blob_data = fbird_blob_info($this->_connectionID, $blob );

< 		$blobid    = fbird_blob_open($this->_connectionID, $blob );



> 		$blobId = fbird_blob_open($this->_connectionID, $blob);



		if( $blob_data[0] > $this->maxblobsize ) {

< 			$realblob = fbird_blob_get($blobid, $this->maxblobsize);
< 
< 			while($string = fbird_blob_get($blobid, 8192)) {
< 				$realblob .= $string;



> 			$realBlob = fbird_blob_get($blobId, $this->maxblobsize);
> 			while ($string = fbird_blob_get($blobId, 8192)) {
> 				$realBlob .= $string;


			}
		} else {

< 			$realblob = fbird_blob_get($blobid, $blob_data[0]);



> 			$realBlob = fbird_blob_get($blobId, $blob_data[0]);


		}


< 		fbird_blob_close( $blobid );
< 		return( $realblob );



> 		fbird_blob_close($blobId);
> 		return $realBlob;


	}


< 	function UpdateBlobFile($table,$column,$path,$where,$blobtype='BLOB')



> 	/**
> 	 * Insert blob data into a database column directly
> 	 * from file
> 	 *
> 	 * @param string $table table to insert
> 	 * @param string $column column to insert
> 	 * @param string $path  physical file name
> 	 * @param string $where string to find unique record
> 	 * @param string $blobtype BLOB or CLOB
> 	 *
> 	 * @return bool success
> 	 */
> 	public function updateBlobFile($table,$column,$path,$where,$blobtype='BLOB')


	{
		$fd = fopen($path,'rb');

< 		if ($fd === false) return false;



> 		if ($fd === false)
> 			return false;
> 


		$blob_id = fbird_blob_create($this->_connectionID);

		/* fill with data */

		while ($val = fread($fd,32768)){
			fbird_blob_add($blob_id, $val);
		}

		/* close and get $blob_id_str for inserting into table */
		$blob_id_str = fbird_blob_close($blob_id);

		fclose($fd);
		return $this->Execute("UPDATE $table SET $column=(?) WHERE $where",array($blob_id_str)) != false;
	}


< 	/*
< 		Insert a null into the blob field of the table first.
< 		Then use UpdateBlob to store the blob.
< 
< 		Usage:
< 
< 		$conn->Execute('INSERT INTO blobtable (id, blobcol) VALUES (1, null)');
< 		$conn->UpdateBlob('blobtable','blobcol',$blob,'id=1');



> 	/**
> 	 * Insert blob data into a database column
> 	 *
> 	 * @param string $table table to insert
> 	 * @param string $column column to insert
> 	 * @param string $val    value to insert
> 	 * @param string $where string to find unique record
> 	 * @param string $blobtype BLOB or CLOB
> 	 *
> 	 * @return bool success


	*/

< 	function UpdateBlob($table,$column,$val,$where,$blobtype='BLOB')



> 	public function updateBlob($table,$column,$val,$where,$blobtype='BLOB')


	{
	$blob_id = fbird_blob_create($this->_connectionID);

	// fbird_blob_add($blob_id, $val);

	// replacement that solves the problem by which only the first modulus 64K /
	// of $val are stored at the blob field ////////////////////////////////////
	// Thx Abel Berenstein  aberenstein#afip.gov.ar
	$len = strlen($val);
	$chunk_size = 32768;
	$tail_size = $len % $chunk_size;
	$n_chunks = ($len - $tail_size) / $chunk_size;

	for ($n = 0; $n < $n_chunks; $n++) {
		$start = $n * $chunk_size;
		$data = substr($val, $start, $chunk_size);
		fbird_blob_add($blob_id, $data);
	}

	if ($tail_size) {
		$start = $n_chunks * $chunk_size;
		$data = substr($val, $start, $tail_size);
		fbird_blob_add($blob_id, $data);
	}
	// end replacement /////////////////////////////////////////////////////////

	$blob_id_str = fbird_blob_close($blob_id);


< 	return $this->Execute("UPDATE $table SET $column=(?) WHERE $where",array($blob_id_str)) != false;



> 		return $this->execute("UPDATE $table SET $column=(?) WHERE $where",array($blob_id_str)) != false;



	}



< 	function OldUpdateBlob($table,$column,$val,$where,$blobtype='BLOB')



> 	/**
> 	 * Returns a portably-formatted date string from a timestamp database column.
> 	 *
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:sqldate
> 	 *
> 	 * Firebird does not support an AM/PM format, so the A indicator always shows AM
> 	 *
> 	 * @param string $fmt The date format to use.
> 	 * @param string|bool $col (Optional) The table column to date format, or if false, use NOW().
> 	 *
> 	 * @return string The SQL DATE_FORMAT() string, or empty if the provided date format was empty.
> 	 */
> 	public function sqlDate($fmt, $col=false)


	{

< 		$blob_id = fbird_blob_create($this->_connectionID);
< 		fbird_blob_add($blob_id, $val);
< 		$blob_id_str = fbird_blob_close($blob_id);
< 		return $this->Execute("UPDATE $table SET $column=(?) WHERE $where",array($blob_id_str)) != false;
< 	}



> 		if (!$col)
> 			$col = 'CURRENT_TIMESTAMP';




< 	// Format date column in sql string given an input format that understands Y M D
< 	// Only since Interbase 6.0 - uses EXTRACT
< 	// problem - does not zero-fill the day and month yet
< 	function SQLDate($fmt, $col=false)
< 	{
< 		if (!$col) $col = $this->sysDate;


		$s = '';

		$len = strlen($fmt);
		for ($i=0; $i < $len; $i++) {
			if ($s) $s .= '||';
			$ch = $fmt[$i];

< 			switch($ch) {



> 			$choice = strtoupper($ch);
> 			switch($choice) {


			case 'Y':

< 			case 'y':
< 				$s .= "extract(year from $col)";



> 				$s .= "EXTRACT(YEAR FROM $col)";


				break;
			case 'M':

< 			case 'm':
< 				$s .= "extract(month from $col)";



> 				$s .= "RIGHT('0' || TRIM(EXTRACT(MONTH FROM $col)),2)";


				break;
			case 'W':

< 			case 'w':


				// The more accurate way of doing this is with a stored procedure
				// See http://wiki.firebirdsql.org/wiki/index.php?page=DATE+Handling+Functions for details

< 				$s .= "((extract(yearday from $col) - extract(weekday from $col - 1) + 7) / 7)";



> 				$s .= "((EXTRACT(YEARDAY FROM $col) - EXTRACT(WEEKDAY FROM $col - 1) + 7) / 7)";


				break;
			case 'Q':

< 			case 'q':
< 				$s .= "cast(((extract(month from $col)+2) / 3) as integer)";



> 				$s .= "CAST(((EXTRACT(MONTH FROM $col)+2) / 3) AS INTEGER)";


				break;
			case 'D':

< 			case 'd':
< 				$s .= "(extract(day from $col))";



> 				$s .= "RIGHT('0' || TRIM(EXTRACT(DAY FROM $col)),2)";


				break;
			case 'H':

< 			case 'h':
< 				$s .= "(extract(hour from $col))";



> 				$s .= "RIGHT('0' || TRIM(EXTRACT(HOUR FROM $col)),2)";


				break;
			case 'I':

< 			case 'i':
< 				$s .= "(extract(minute from $col))";



> 				$s .= "RIGHT('0' || TRIM(EXTRACT(MINUTE FROM $col)),2)";


				break;
			case 'S':

< 			case 's':
< 				$s .= "CAST((extract(second from $col)) AS INTEGER)";



> 				//$s .= "CAST((EXTRACT(SECOND FROM $col)) AS INTEGER)";
> 				$s .= "RIGHT('0' || TRIM(EXTRACT(SECOND FROM $col)),2)";
> 				break;
> 			case 'A':
> 				$s .= $this->qstr('AM');


				break;

< 


			default:
				if ($ch == '\\') {
					$i++;
					$ch = substr($fmt,$i,1);
				}
				$s .= $this->qstr($ch);
				break;
			}
		}
		return $s;
	}


> 	/**
	// Note that Interbase 6.5 uses this ROWS instead - don't you love forking wars!
> 	 * Creates a portable date offset field, for use in SQL statements.
	// 		SELECT col1, col2 FROM table ROWS 5 -- get 5 rows
> 	 *
	//		SELECT col1, col2 FROM TABLE ORDER BY col1 ROWS 3 TO 7 -- first 5 skip 2
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:offsetdate
	function &SelectLimit($sql,$nrows=-1,$offset=-1,$inputarr=false, $secs=0)
> 	 *
	{
> 	 * @param float $dayFraction A day in floating point
		$nrows = (integer) $nrows;
> 	 * @param string|bool $date (Optional) The date to offset. If false, uses CURDATE()
		$offset = (integer) $offset;
> 	 *
		$str = 'SELECT ';
> 	 * @return string
		if ($nrows >= 0) $str .= "FIRST $nrows ";
> 	 */
		$str .=($offset>=0) ? "SKIP $offset " : '';
> 	public function offsetDate($dayFraction, $date=false)

> 	{
		$sql = preg_replace('/^[ \t]*select/i',$str,$sql);
> 		if (!$date)
		if ($secs)
> 			$date = $this->sysTimeStamp;
			$rs = $this->CacheExecute($secs,$sql,$inputarr);
> 
		else
> 		$fraction = $dayFraction * 24 * 3600;
			$rs = $this->Execute($sql,$inputarr);
> 		return sprintf("DATEADD (second, %s, %s)  FROM RDB\$DATABASE",$fraction,$date);

> 	}
		return $rs;
> 
	}
> 



< 	function &SelectLimit($sql,$nrows=-1,$offset=-1,$inputarr=false, $secs=0)



> 	/**
> 	 * Executes a provided SQL statement and returns a handle to the result, with the ability to supply a starting
> 	 * offset and record count.
> 	 *
> 	 * @link https://adodb.org/dokuwiki/doku.php?id=v5:reference:connection:selectlimit
> 	 *
> 	 * @param string $sql The SQL to execute.
> 	 * @param int $nrows (Optional) The limit for the number of records you want returned. By default, all results.
> 	 * @param int $offset (Optional) The offset to use when selecting the results. By default, no offset.
> 	 * @param array|bool $inputarr (Optional) Any parameter values required by the SQL statement, or false if none.
> 	 * @param int $secs2cache (Optional) If greater than 0, perform a cached execute. By default, normal execution.
> 	 *
> 	 * @return ADORecordSet|false The query results, or false if the query failed to execute.
> 	 */
> 	public function selectLimit($sql,$nrows=-1,$offset=-1,$inputarr=false, $secs2cache=0)



< 		if ($secs)
< 			$rs = $this->CacheExecute($secs,$sql,$inputarr);



> 		if ($secs2cache)
> 			$rs = $this->cacheExecute($secs2cache,$sql,$inputarr);



< 			$rs = $this->Execute($sql,$inputarr);



> 			$rs = $this->execute($sql,$inputarr);



< /*--------------------------------------------------------------------------------------
< 		 Class Name: Recordset
< --------------------------------------------------------------------------------------*/
< 



> /**
>  * Class ADORecordset_firebird
>  */


{

< 


	var $databaseType = "firebird";
	var $bind=false;

< 	var $_cacheType;



> 
> 	/**
> 	 * @var ADOFieldObject[] Holds a cached version of the metadata
> 	 */
> 	private $fieldObjects = false;
> 
> 	/**
> 	 * @var bool Flags if we have retrieved the metadata
> 	 */
> 	private $fieldObjectsRetrieved = false;
> 
> 	/**
> 	 * @var array Cross-reference the objects by name for easy access
> 	 */
> 	private $fieldObjectsIndex = array();
> 
> 	/**
> 	 * @var bool Flag to indicate if the result has a blob
> 	 */
> 	private $fieldObjectsHaveBlob = false;



	function __construct($id,$mode=false)
	{
	global $ADODB_FETCH_MODE;

			$this->fetchMode = ($mode === false) ? $ADODB_FETCH_MODE : $mode;
			parent::__construct($id);
	}


> 


	/**

< 	 * Get column information in the Recordset object.
< 	 * fetchField() can be used in order to obtain information about fields in
< 	 * a certain query result. If the field offset isn't specified, the next
< 	 * field that wasn't yet retrieved by fetchField() is retrieved.
< 	 * @return object containing field information.



> 	 * Returns: an object containing field information.
> 	 *
> 	 * Get column information in the Recordset object. fetchField()
> 	 * can be used in order to obtain information about fields in a
> 	 * certain query result. If the field offset isn't specified,
> 	 * the next field that wasn't yet retrieved by fetchField()
> 	 * is retrieved.
> 	 *
> 	 * $param int $fieldOffset (optional default=-1 for all
> 	 * @return mixed an ADOFieldObject, or array of objects


	*/

< 	function FetchField($fieldOffset = -1)



> 	private function _fetchField($fieldOffset = -1)


	{

> 		if ($this->fieldObjectsRetrieved) {
			$fld = new ADOFieldObject;
> 			if ($this->fieldObjects) {
			 $ibf = fbird_field_info($this->_queryID,$fieldOffset);
> 				// Already got the information

> 				if ($fieldOffset == -1) {
			$name = empty($ibf['alias']) ? $ibf['name'] : $ibf['alias'];
> 					return $this->fieldObjects;

> 				} else {
			switch (ADODB_ASSOC_CASE) {
> 					return $this->fieldObjects[$fieldOffset];
				case ADODB_ASSOC_CASE_UPPER:
> 				}
					$fld->name = strtoupper($name);
> 			} else {
					break;
> 				// No metadata available
				case ADODB_ASSOC_CASE_LOWER:
> 				return false;
					$fld->name = strtolower($name);
> 			}
					break;
> 		}
				case ADODB_ASSOC_CASE_NATIVE:
> 
				default:
> 		// Populate the field objects cache
					$fld->name = $name;
> 		$this->fieldObjectsRetrieved = true;
					break;
> 		$this->fieldObjectsHaveBlob = false;
			}
> 		$this->_numOfFields = fbird_num_fields($this->_queryID);

> 		for ($fieldIndex = 0; $fieldIndex < $this->_numOfFields; $fieldIndex++) {



< 			 $ibf = fbird_field_info($this->_queryID,$fieldOffset);



> 			$ibf = fbird_field_info($this->_queryID, $fieldIndex);


			$fld->max_length = $ibf['length'];


< 			/*       This needs to be populated from the metadata */



> 			// This needs to be populated from the metadata


			$fld->not_null = false;
			$fld->has_default = false;
			$fld->default_value = 'null';

< 			return $fld;



> 
> 			$this->fieldObjects[$fieldIndex] = $fld;
> 			$this->fieldObjectsIndex[$fld->name] = $fieldIndex;
> 
> 			if ($fld->type == 'BLOB') {
> 				$this->fieldObjectsHaveBlob = true;
> 			}
> 		}
> 
> 		if ($fieldOffset == -1) {
> 			return $this->fieldObjects;
> 		}
> 
> 		return $this->fieldObjects[$fieldOffset];
> 	}
> 
> 	/**
> 	 * Fetchfield copies the oracle method, it loads the field information
> 	 * into the _fieldobjs array once, to save multiple calls to the
> 	 * fbird_ function
> 	 *
> 	 * @param int $fieldOffset (optional)
> 	 *
> 	 * @return adoFieldObject|false
> 	 */
> 	public function fetchField($fieldOffset = -1)
> 	{
> 		if ($fieldOffset == -1) {
> 			return $this->fieldObjects;
> 		}
> 
> 		return $this->fieldObjects[$fieldOffset];


	}

	function _initrs()
	{
		$this->_numOfRows = -1;

< 		$this->_numOfFields = @fbird_num_fields($this->_queryID);




< 		// cache types for blob decode check
< 		for ($i=0, $max = $this->_numOfFields; $i < $max; $i++) {
< 			$f1 = $this->FetchField($i);
< 			$this->_cacheType[] = $f1->type;
< 		}



> 		/*
> 		* Retrieve all of the column information first. We copy
> 		* this method from oracle
> 		*/
> 		$this->_fetchField();
> 


	}

	function _seek($row)
	{
		return false;
	}


< 	function _fetch()



> 	public function _fetch()


	{

> 		// Case conversion function for use in Closure defined below
		$f = @fbird_fetch_row($this->_queryID);
> 		$localFnCaseConv = null;
		if ($f === false) {
> 
			$this->fields = false;
> 		if ($this->fetchMode & ADODB_FETCH_ASSOC) {
			return false;
> 			// Handle either associative or fetch both
		}
> 			$localNumeric = false;
		// OPN stuff start - optimized
> 
		// fix missing nulls and decode blobs automatically
> 			$f = @fbird_fetch_assoc($this->_queryID);

> 			if (is_array($f)) {
		global $ADODB_ANSI_PADDING_OFF;
> 				// Optimally do the case_upper or case_lower
		//$ADODB_ANSI_PADDING_OFF=1;
> 				if (ADODB_ASSOC_CASE == ADODB_ASSOC_CASE_LOWER) {
		$rtrim = !empty($ADODB_ANSI_PADDING_OFF);
> 					$f = array_change_key_case($f, CASE_LOWER);

> 					$localFnCaseConv = 'strtolower';
		for ($i=0, $max = $this->_numOfFields; $i < $max; $i++) {
> 				} elseif (ADODB_ASSOC_CASE == ADODB_ASSOC_CASE_UPPER) {
			if ($this->_cacheType[$i]=="BLOB") {
> 					$f = array_change_key_case($f, CASE_UPPER);
				if (isset($f[$i])) {
> 					$localFnCaseConv = 'strtoupper';
					$f[$i] = $this->connection->_BlobDecode($f[$i]);
> 				}
				} else {
> 			}
					$f[$i] = null;
> 		} else {
				}
> 			// Numeric fetch mode
			} else {
> 			$localNumeric = true;


				if (!isset($f[$i])) {

> 		}
					$f[$i] = null;
> 


				} else if ($rtrim && is_string($f[$i])) {

> 



< 



< 		//$ADODB_ANSI_PADDING_OFF=1;



< 		for ($i=0, $max = $this->_numOfFields; $i < $max; $i++) {
< 			if ($this->_cacheType[$i]=="BLOB") {
< 				if (isset($f[$i])) {
< 					$f[$i] = $this->connection->_BlobDecode($f[$i]);



> 		// For optimal performance, only process if there is a possibility of something to do
> 		if ($this->fieldObjectsHaveBlob || $rtrim) {
> 			$localFieldObjects = $this->fieldObjects;
> 			$localFieldObjectIndex = $this->fieldObjectsIndex;
> 			/** @var ADODB_firebird $localConnection */
> 			$localConnection = &$this->connection;
> 
> 			/**
> 			 * Closure for an efficient method of iterating over the elements.
> 			 * @param mixed      $value
> 			 * @param string|int $key
> 			 * @return void
> 			 */
> 			$rowTransform = function ($value, $key) use (
> 				&$f,
> 				$rtrim,
> 				$localFieldObjects,
> 				$localConnection,
> 				$localNumeric,
> 				$localFnCaseConv,
> 				$localFieldObjectIndex
> 			) {
> 				if ($localNumeric) {
> 					$localKey = $key;



< 					$f[$i] = null;



> 					// Cross-reference the associative key back to numeric
> 					// with appropriate case conversion
> 					$index = $localFnCaseConv ? $localFnCaseConv($key) : $key;
> 					$localKey = $localFieldObjectIndex[$index];


		if ($this->fetchMode == ADODB_FETCH_ASSOC) {

> 
			$this->fields = $this->GetRowAssoc();
> 				// As we iterate the elements check for blobs and padding
		} else if ($this->fetchMode == ADODB_FETCH_BOTH) {
> 				if ($localFieldObjects[$localKey]->type == 'BLOB') {
			$this->fields = array_merge($this->fields,$this->GetRowAssoc());
> 					$f[$key] = $localConnection->_BlobDecode($value);



< 				if (!isset($f[$i])) {
< 					$f[$i] = null;
< 				} else if ($rtrim && is_string($f[$i])) {
< 					$f[$i] = rtrim($f[$i]);



> 					if ($rtrim && is_string($value)) {
> 						$f[$key] = rtrim($value);


	/* Use associative array to get fields array */

> 
	function Fields($colname)
> 			};
	{
> 
		if ($this->fetchMode & ADODB_FETCH_ASSOC) return $this->fields[$colname];
> 			// Walk the array, applying the above closure
		if (!$this->bind) {
> 			array_walk($f, $rowTransform);



< 		// OPN stuff end



< 		$this->fields = $f;
< 		if ($this->fetchMode == ADODB_FETCH_ASSOC) {
< 			$this->fields = $this->GetRowAssoc();
< 		} else if ($this->fetchMode == ADODB_FETCH_BOTH) {
< 			$this->fields = array_merge($this->fields,$this->GetRowAssoc());



> 		if (!$localNumeric && $this->fetchMode & ADODB_FETCH_NUM) {
> 			// Creates a fetch both
> 			$fNum = array_values($f);
> 			$f = array_merge($f, $fNum);




> 
		return $this->fields[$this->bind[strtoupper($colname)]];
> 		$this->fields = $f;

> 



< 	/* Use associative array to get fields array */
< 	function Fields($colname)



> 	/**
> 	 * Get the value of a field in the current row by column name.
> 	 * Will not work if ADODB_FETCH_MODE is set to ADODB_FETCH_NUM.
> 	 *
> 	 * @param string $colname is the field to access
> 	 *
> 	 * @return mixed the value of $colname column
> 	 */
> 	public function fields($colname)



< 		if ($this->fetchMode & ADODB_FETCH_ASSOC) return $this->fields[$colname];
< 		if (!$this->bind) {
< 			$this->bind = array();
< 			for ($i=0; $i < $this->_numOfFields; $i++) {
< 				$o = $this->FetchField($i);
< 				$this->bind[strtoupper($o->name)] = $i;



> 		if ($this->fetchMode & ADODB_FETCH_ASSOC) {
> 			return $this->fields[$colname];


	function MetaType($t,$len=-1,$fieldobj=false)

> 
	{
> 		if (!$this->bind) {
		if (is_object($t)) {
> 			// fieldsObjectIndex populated by the recordset load
			$fieldobj = $t;
> 			$this->bind = array_change_key_case($this->fieldObjectsIndex, CASE_UPPER);



< 



< 	function MetaType($t,$len=-1,$fieldobj=false)



> 	public function metaType($t, $len = -1, $fieldObj = false)



< 			$fieldobj = $t;
< 			$t = $fieldobj->type;
< 			$len = $fieldobj->max_length;



> 			$fieldObj = $t;
> 			$t = $fieldObj->type;
> 			$len = $fieldObj->max_length;



< 		switch (strtoupper($t)) {



> 
> 		$t = strtoupper($t);
> 
> 		if (array_key_exists($t, $this->connection->customActualTypes)) {
> 			return $this->connection->customActualTypes[$t];
> 		}
> 
> 		switch ($t) {



		case 'TEXT':
		case 'VARCHAR':
		case 'VARYING':

< 		if ($len <= $this->blobSize) return 'C';



> 				if ($len <= $this->blobSize) {
> 					return 'C';
> 				}


			return 'X';
		case 'BLOB':
			return 'B';

		case 'TIMESTAMP':

< 		case 'DATE': return 'D';
< 		case 'TIME': return 'T';



> 			case 'DATE':
> 				return 'D';
> 			case 'TIME':
> 				return 'T';


				//case 'T': return 'T';

				//case 'L': return 'L';
		case 'INT':
		case 'SHORT':

< 		case 'INTEGER': return 'I';
< 		default: return ADODB_DEFAULT_METATYPE;



> 			case 'INTEGER':
> 				return 'I';
> 			default:
> 				return ADODB_DEFAULT_METATYPE;


		}
	}

}

>