Documentation TYPO3 par Ameos

Disponible dans d'autres versions de TYPO3 -> 3.7.0  3.8.1  4.0.0  4.0.1  4.1.0   <- Available in other TYPO3 versions

class.ux_t3lib_db.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 2004 Kasper Skaarhoj (kasper@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
require_once(PATH_t3lib.'class.t3lib_sqlengine.php');
require_once(PATH_t3lib.'class.t3lib_install.php');
//require_once(t3lib_extMgm::extPath('install').'mod/class.tx_install.php');

class ux_t3lib_DB extends t3lib_DB {

        // Internal, static:
        var $printErrors = FALSE;                       // Enable output of SQL errors after query executions. Set through TYPO3_CONF_VARS, see init()
        var $debug = FALSE;                                     // Enable debug mode. Set through TYPO3_CONF_VARS, see init()
        var $conf = array();                            // Configuration array, copied from TYPO3_CONF_VARS in constructor.

        var $mapping = array();                         // See manual.
        var $table2handlerKeys = array();       // See manual.
        var $handlerCfg = array (                       // See manual.
        '_DEFAULT' => array (
        'type' => 'native',
        'config' => array(
        'username' => '',               // Set by default (overridden)
        'password' => '',               // Set by default (overridden)
        'host' => '',                   // Set by default (overridden)
        'database' => '',               // Set by default (overridden)
        'driver' => '',                 // ONLY "adodb" type; eg. "mysql"
        )
        ),
        );


        // Internal, dynamic:
        var $handlerInstance = array();                         // Contains instance of the handler objects as they are created. Exception is the native mySQL calls which are registered as an array with keys "handlerType" = "native" and "link" pointing to the link resource for the connection.
        var $lastHandlerKey = '';                                       // Storage of the handler key of last ( SELECT) query - used for subsequent fetch-row calls etc.
        var $lastQuery = '';                                            // Storage of last SELECT query
        var $lastParsedAndMappedQueryArray=array();     // Query array, the last one parsed

        var $resourceIdToTableNameMap = array();        // Mapping of resource ids to table names.

        // Internal, caching:
        var $cache_handlerKeyFromTableList = array();                   // Caching handlerKeys for table lists
        var $cache_mappingFromTableList = array();                      // Caching mapping information for table lists
        var $cache_autoIncFields = array(); // parsed SQL from standard DB dump file
        var $cache_fieldType = array(); // field types for tables/fields
        var $cache_primaryKeys = array(); // primary keys





        function ux_t3lib_DB()  {

                // Set SQL parser object for internal use:
                $this->SQLparser = t3lib_div::makeInstance('t3lib_sqlengine');
                $this->Installer = t3lib_div::makeInstance('t3lib_install');

                // Set internal variables with configuration:
                $this->conf = $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['dbal'];
                $this->initInternalVariables();
        }

        function initInternalVariables()        {

                // Set outside configuration:
                if (isset($this->conf['mapping']))                              $this->mapping = $this->conf['mapping'];
                if (isset($this->conf['table2handlerKeys']))    $this->table2handlerKeys = $this->conf['table2handlerKeys'];
                if (isset($this->conf['handlerCfg']))                   $this->handlerCfg = $this->conf['handlerCfg'];

                $this->cacheFieldInfo();
                // Debugging settings:
                $this->printErrors = $this->conf['debugOptions']['printErrors'] ? TRUE : FALSE;
                $this->debug = $this->conf['debugOptions']['enabled'] ? TRUE : FALSE;
        }

        function clearCachedFieldInfo() {
                if(file_exists(PATH_typo3conf.'temp_fieldInfo.php'))
                unlink(PATH_typo3conf.'temp_fieldInfo.php');
        }

        function cacheFieldInfo() {
                global $TYPO3_LOADED_EXT;
                $extSQL = '';
                $parsedExtSQL = array();

                // try to fetch cached file first
                // file is removed when admin_query() is called
                if(file_exists(PATH_typo3conf.'temp_fieldInfo.php')) {
                        $fdata = unserialize(t3lib_div::getUrl(PATH_typo3conf.'temp_fieldInfo.php'));
                        $this->cache_autoIncFields = $fdata['incFields'];
                        $this->cache_fieldType = $fdata['fieldTypes'];
                        $this->cache_primaryKeys = $fdata['primaryKeys'];
                }
                else {
                                // handle stddb.sql, parse and analyze
                        $extSQL = t3lib_div::getUrl(PATH_site.'t3lib/stddb/tables.sql');
                        $parsedExtSQL = $this->Installer->getFieldDefinitions_sqlContent($extSQL);
                        $this->analyzeFields($parsedExtSQL);

                                // loop over all installed extensions
                        foreach($TYPO3_LOADED_EXT as $ext => $v)        {
                                if(!is_array($v) || !isset($v['ext_tables.sql']))
                                continue;

                                        // fetch db dump (if any) and parse it, then analyze
                                $extSQL = t3lib_div::getUrl($v['ext_tables.sql']);
                                $parsedExtSQL = $this->Installer->getFieldDefinitions_sqlContent($extSQL);
                                $this->analyzeFields($parsedExtSQL);
                        }

                        $cachedFieldInfo = array('incFields' => $this->cache_autoIncFields, 'fieldTypes' => $this->cache_fieldType, 'primaryKeys' => $this->cache_primaryKeys);
                        $cachedFieldInfo = serialize($this->mapCachedFieldInfo($cachedFieldInfo));

                                // write serialized content to file
                        t3lib_div::writeFile(PATH_typo3conf."temp_fieldInfo.php", $cachedFieldInfo);

                        if (strcmp(t3lib_div::getUrl(PATH_typo3conf."temp_fieldInfo.php"), $cachedFieldInfo))   {
                                die('typo3temp/temp_incfields.php was NOT updated properly (written content didn\'t match file content) - maybe write access problem?');
                        }
                }
        }

        function analyzeFields($parsedExtSQL) {
                foreach($parsedExtSQL as $table => $tdef) {
                        foreach($tdef['fields'] as $field => $fdef) {
                                $fdef = $this->SQLparser->parseFieldDef($fdef);
                                $this->cache_fieldType[$table][$field]['type'] = $fdef['fieldType'];
                                $this->cache_fieldType[$table][$field]['metaType'] = $this->MySQLMetaType($fdef['fieldType']);
                                $this->cache_fieldType[$table][$field]['notnull'] = (isset($fdef['featureIndex']['NOTNULL']) && !$this->SQLparser->checkEmptyDefaultValue($fdef['featureIndex'])) ? 1 : 0;
                                if(isset($fdef['featureIndex']['AUTO_INCREMENT'])) {
                                        $this->cache_autoIncFields[$table] = $field;
                                }
                                if(isset($tdef['keys']['PRIMARY'])) {
                                        $this->cache_primaryKeys[$table] = substr($tdef['keys']['PRIMARY'], 13, -1);
                                }
                        }
                }
        }

        function mapCachedFieldInfo($fieldInfo){
                global $TYPO3_CONF_VARS;

                if(is_array($TYPO3_CONF_VARS['EXTCONF']['dbal']['mapping'])) {
                        foreach($TYPO3_CONF_VARS['EXTCONF']['dbal']['mapping'] as $mappedTable => $mappedConf){
                                if(array_key_exists($mappedTable, $fieldInfo['incFields'])) {
                                        $mappedTableAlias = $mappedConf['mapTableName'];
                                        $fieldInfo['incFields'][$mappedTableAlias] = isset($mappedConf['mapFieldNames'][$fieldInfo['incFields'][$mappedTable]]) ? $mappedConf['mapFieldNames'][$fieldInfo['incFields'][$mappedTable]] : $fieldInfo['incFields'][$mappedTable];
                                }

                                if(array_key_exists($mappedTable, $fieldInfo['fieldTypes'])) {
                                        foreach($fieldInfo['fieldTypes'][$mappedTable] as $field => $fieldConf){
                                                $tempMappedFieldConf[$mappedConf['mapFieldNames'][$field]] = $fieldConf;
                                        }

                                        $fieldInfo['fieldTypes'][$mappedConf['mapTableName']] = $tempMappedFieldConf;
                                }

                                if(array_key_exists($mappedTable, $fieldInfo['primaryKeys'])) {
                                        $mappedTableAlias = $mappedConf['mapTableName'];
                                        $fieldInfo['primaryKeys'][$mappedTableAlias] = isset($mappedConf['mapFieldNames'][$fieldInfo['primaryKeys'][$mappedTable]]) ? $mappedConf['mapFieldNames'][$fieldInfo['primaryKeys'][$mappedTable]] : $fieldInfo['primaryKeys'][$mappedTable];
                                }

                        }
                }

                return $fieldInfo;
        }


        /************************************
        *
        * Query Building (Overriding parent methods)
        * These functions are extending counterparts in the parent class.
        *
        **************************************/

        /* From the ADOdb documentation, this is what we do (_Execute for SELECT, _query for the other actions)

        Execute() is the default way to run queries. You can use the low-level functions _Execute() and _query() to reduce query overhead.
        Both these functions share the same parameters as Execute().

        If you do not have any bind parameters or your database supports binding (without emulation), then you can call _Execute() directly.
        Calling this function bypasses bind emulation. Debugging is still supported in _Execute().

        If you do not require debugging facilities nor emulated binding, and do not require a recordset to be returned, then you can call _query.
        This is great for inserts, updates and deletes. Calling this function bypasses emulated binding, debugging, and recordset handling. Either
        the resultid, true or false are returned by _query().
        */

        function exec_INSERTquery($table,$fields_values,$no_quote_fields='')    {

                if ($this->debug)       $pt = t3lib_div::milliseconds();

                // Do field mapping if needed:
                $ORIG_tableName = $table;
                if ($tableArray = $this->map_needMapping($table))       {

                        // Field mapping of array:
                        $fields_values = $this->map_assocArray($fields_values,$tableArray);

                        // Table name:
                        if ($this->mapping[$table]['mapTableName'])     {
                                $table = $this->mapping[$table]['mapTableName'];
                        }
                }
                // Select API:
                $this->lastHandlerKey = $this->handler_getFromTableList($ORIG_tableName);
                switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $this->lastQuery = $this->INSERTquery($table,$fields_values,$no_quote_fields);
                                if(is_string($this->lastQuery)) {
                                        $sqlResult = mysql_query($this->lastQuery, $this->handlerInstance[$this->lastHandlerKey]['link']);
                                }
                                else {
                                        $sqlResult = mysql_query($this->lastQuery[0], $this->handlerInstance[$this->lastHandlerKey]['link']);
                                        foreach($this->lastQuery[1] as $field => $content) {
                                                mysql_query('UPDATE '.$this->quoteFromTables($table).' SET '.$this->quoteFromTables($field).'='.$this->fullQuoteStr($content,$table).' WHERE '.$this->quoteWhereClause($where), $this->handlerInstance[$this->lastHandlerKey]['link']);
                                        }
                                }
                                break;
                        case 'adodb':
                                // auto generate ID for auto_increment fields if not present (static import needs this!)
                                // should we check the table name here (static_*)?
                                if(isset($this->cache_autoIncFields[$table])) {
                                        if(isset($fields_values[$this->cache_autoIncFields[$table]])) {
                                                $new_id = $fields_values[$this->cache_autoIncFields[$table]];
                                                if($table !== 'tx_dbal_debuglog') {
                                                        $this->handlerInstance[$this->lastHandlerKey]->last_insert_id = $new_id;
                                                }
                                        } else {
                                                $new_id = $this->handlerInstance[$this->lastHandlerKey]->GenID($table.'_'.$this->cache_autoIncFields[$table]);
                                                $fields_values[$this->cache_autoIncFields[$table]] = $new_id;
                                                if($table !== 'tx_dbal_debuglog') {
                                                        $this->handlerInstance[$this->lastHandlerKey]->last_insert_id = $new_id;
                                                }
                                        }
                                }

                                $this->lastQuery = $this->INSERTquery($table,$fields_values,$no_quote_fields);
                                if(is_string($this->lastQuery)) {
                                        $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->_query($this->lastQuery,false);
                                } else {
                                        $this->handlerInstance[$this->lastHandlerKey]->StartTrans();
                                        $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->_query($this->lastQuery[0],false);
                                        foreach($this->lastQuery[1] as $field => $content) {
                                                if(empty($content)) continue;

                                                if(isset($this->cache_autoIncFields[$table]) && isset($new_id)) {
                                                        $this->handlerInstance[$this->lastHandlerKey]->UpdateBlob($this->quoteFromTables($table),$field,$content,$this->quoteWhereClause($this->cache_autoIncFields[$table].'='.$new_id));
                                                } elseif(isset($this->cache_primaryKeys[$table])) {
                                                        $pks = explode(',', $this->cache_primaryKeys[$table]);
                                                        foreach ($pks as $pk) {
                                                                if(isset($fields_values[$pk]))
                                                                $where .= $pk.'='.$this->fullQuoteStr($fields_values[$pk], $table).' AND ';
                                                        }
                                                        $where = $this->quoteWhereClause($where.'1=1');
                                                        $this->handlerInstance[$this->lastHandlerKey]->UpdateBlob($this->quoteFromTables($table),$field,$content,$where);
                                                } else {
                                                        $this->handlerInstance[$this->lastHandlerKey]->CompleteTrans(false);
                                                        die('Could not update BLOB >>>> no WHERE clause found!'); // should never ever happen
                                                }
                                        }
                                        $this->handlerInstance[$this->lastHandlerKey]->CompleteTrans();
                                }
                                break;
                        case 'userdefined':
                                $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->exec_INSERTquery($table,$fields_values,$no_quote_fields);
                                break;
                }

                if ($this->printErrors && $this->sql_error())   {
                        debug(array($this->lastQuery, $this->sql_error()));
                }

                if ($this->debug)       {
                        $this->debugHandler(
                        'exec_INSERTquery',
                        t3lib_div::milliseconds()-$pt,
                        array(
                        'handlerType' => $hType,
                        'args' => array($table,$fields_values),
                        'ORIG_tablename' => $ORIG_tableName
                        )
                        );
                }
                // Return output:
                return $sqlResult;
        }

        function exec_UPDATEquery($table,$where,$fields_values,$no_quote_fields='')     {

                if ($this->debug)       $pt = t3lib_div::milliseconds();

                // Do table/field mapping:
                $ORIG_tableName = $table;
                if ($tableArray = $this->map_needMapping($table))       {

                        // Field mapping of array:
                        $fields_values = $this->map_assocArray($fields_values,$tableArray);

                        // Where clause table and field mapping:
                        $whereParts = $this->SQLparser->parseWhereClause($where);
                        $this->map_sqlParts($whereParts,$tableArray[0]['table']);
                        $where = $this->SQLparser->compileWhereClause($whereParts);

                        // Table name:
                        if ($this->mapping[$table]['mapTableName'])     {
                                $table = $this->mapping[$table]['mapTableName'];
                        }
                }

                // Select API
                $this->lastHandlerKey = $this->handler_getFromTableList($ORIG_tableName);
                switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $this->lastQuery = $this->UPDATEquery($table,$where,$fields_values,$no_quote_fields);
                                if(is_string($this->lastQuery)) {
                                        $sqlResult = mysql_query($this->lastQuery, $this->handlerInstance[$this->lastHandlerKey]['link']);
                                }
                                else {
                                        $sqlResult = mysql_query($this->lastQuery[0], $this->handlerInstance[$this->lastHandlerKey]['link']);
                                        foreach($this->lastQuery[1] as $field => $content) {
                                                mysql_query('UPDATE '.$this->quoteFromTables($table).' SET '.$this->quoteFromTables($field).'='.$this->fullQuoteStr($content,$table).' WHERE '.$this->quoteWhereClause($where), $this->handlerInstance[$this->lastHandlerKey]['link']);
                                        }
                                }
                        break;
                        case 'adodb':
                                $this->lastQuery = $this->UPDATEquery($table,$where,$fields_values,$no_quote_fields);
                                if(is_string($this->lastQuery)) {
                                        $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->_query($this->lastQuery,false);
                                } else {
                                        $this->handlerInstance[$this->lastHandlerKey]->StartTrans();
                                        $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->_query($this->lastQuery[0],false);
                                        foreach($this->lastQuery[1] as $field => $content) {
                                                $this->handlerInstance[$this->lastHandlerKey]->UpdateBlob($this->quoteFromTables($table),$field,$content,$this->quoteWhereClause($where));
                                        }
                                        $this->handlerInstance[$this->lastHandlerKey]->CompleteTrans();
                                }
                                break;
                        case 'userdefined':
                                $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->exec_UPDATEquery($table,$where,$fields_values,$no_quote_fields);
                                break;
                }

                if ($this->printErrors && $this->sql_error())   {
                        debug(array($this->lastQuery, $this->sql_error()));
                }

                if ($this->debug)       {
                        $this->debugHandler(
                        'exec_UPDATEquery',
                        t3lib_div::milliseconds()-$pt,
                        array(
                        'handlerType' => $hType,
                        'args' => array($table,$where, $fields_values),
                        'ORIG_from_table' => $ORIG_tableName
                        )
                        );
                }

                // Return result:
                return $sqlResult;
        }

        function exec_DELETEquery($table,$where)        {

                if ($this->debug)       $pt = t3lib_div::milliseconds();

                // Do table/field mapping:
                $ORIG_tableName = $table;
                if ($tableArray = $this->map_needMapping($table))       {

                        // Where clause:
                        $whereParts = $this->SQLparser->parseWhereClause($where);
                        $this->map_sqlParts($whereParts,$tableArray[0]['table']);
                        $where = $this->SQLparser->compileWhereClause($whereParts);

                        // Table name:
                        if ($this->mapping[$table]['mapTableName'])     {
                                $table = $this->mapping[$table]['mapTableName'];
                        }
                }

                // Select API
                $this->lastHandlerKey = $this->handler_getFromTableList($ORIG_tableName);
                switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $this->lastQuery = $this->DELETEquery($table,$where);
                                $sqlResult = mysql_query($this->lastQuery, $this->handlerInstance[$this->lastHandlerKey]['link']);
                                break;
                        case 'adodb':
                                $this->lastQuery = $this->DELETEquery($table,$where);
                                $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->_query($this->lastQuery,false);
                                break;
                        case 'userdefined':
                                $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->exec_DELETEquery($table,$where);
                                break;
                }

                if ($this->printErrors && $this->sql_error())   {
                        debug(array($this->lastQuery, $this->sql_error()));
                }

                if ($this->debug)       {
                        $this->debugHandler(
                        'exec_DELETEquery',
                        t3lib_div::milliseconds()-$pt,
                        array(
                        'handlerType' => $hType,
                        'args' => array($table,$where),
                        'ORIG_from_table' => $ORIG_tableName
                        )
                        );
                }

                // Return result:
                return $sqlResult;
        }

        function exec_SELECTquery($select_fields,$from_table,$where_clause,$groupBy='',$orderBy='',$limit='')   {

                if ($this->debug)       $pt = t3lib_div::milliseconds();

                // Map table / field names if needed:
                $ORIG_tableName = $from_table;  // Saving table names in $ORIG_from_table since $from_table is transformed beneath:
                if ($tableArray = $this->map_needMapping($ORIG_tableName))      {
                        $this->map_remapSELECTQueryParts($select_fields,$from_table,$where_clause,$groupBy,$orderBy);   // Variables passed by reference!
                }

                // Get handler key and select API:
                $this->lastHandlerKey = $this->handler_getFromTableList($ORIG_tableName);
                $hType = (string)$this->handlerCfg[$this->lastHandlerKey]['type'];
                switch($hType)  {
                        case 'native':
                                $this->lastQuery = $this->SELECTquery($select_fields,$from_table,$where_clause,$groupBy,$orderBy,$limit);
                                $sqlResult = mysql_query($this->lastQuery, $this->handlerInstance[$this->lastHandlerKey]['link']);
                                $this->resourceIdToTableNameMap[(string)$sqlResult] = $ORIG_tableName;
                                break;
                        case 'adodb':
                                if ($limit!='') {
                                        $splitLimit = t3lib_div::intExplode(',',$limit);                // Splitting the limit values:
                                        if ($splitLimit[1])     {       // If there are two parameters, do mapping differently than otherwise:
                                                $numrows = $splitLimit[1];
                                                $offset = $splitLimit[0];
                                        } else {
                                                $numrows = $splitLimit[0];
                                                $offset = 0;
                                        }

                                        $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->SelectLimit($this->SELECTquery($select_fields,$from_table,$where_clause,$groupBy,$orderBy), $numrows, $offset);
                                        $this->lastQuery = $sqlResult->sql;
                                } else {
                                        $this->lastQuery = $this->SELECTquery($select_fields,$from_table,$where_clause,$groupBy,$orderBy);
                                        $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->_Execute($this->lastQuery);
                                }
                                $sqlResult->TYPO3_DBAL_handlerType = 'adodb';   // Setting handler type in result object (for later recognition!)
                                $sqlResult->TYPO3_DBAL_tableList = $ORIG_tableName;
                                break;
                        case 'userdefined':
                                $sqlResult = $this->handlerInstance[$this->lastHandlerKey]->exec_SELECTquery($select_fields,$from_table,$where_clause,$groupBy,$orderBy,$limit);
                                if (is_object($sqlResult))      {
                                        $sqlResult->TYPO3_DBAL_handlerType = 'userdefined';     // Setting handler type in result object (for later recognition!)
                                        $sqlResult->TYPO3_DBAL_tableList = $ORIG_tableName;
                                }
                                break;
                }

                if ($this->printErrors && $this->sql_error())   {
                        debug(array($this->lastQuery, $this->sql_error()));
                }

                if ($this->debug)       {
                        $this->debugHandler(
                        'exec_SELECTquery',
                        t3lib_div::milliseconds()-$pt,
                        array(
                        'handlerType' => $hType,
                        'args' => array($from_table,$select_fields,$where_clause,$groupBy,$orderBy,$limit),
                        'ORIG_from_table' => $ORIG_tableName
                        )
                        );
                }

                // Return result handler.
                return $sqlResult;
        }



        /**************************************
        *
        * Query building
        *
        **************************************/

        function INSERTquery($table,$fields_values,$no_quote_fields='') {
                // Table and fieldnames should be "SQL-injection-safe" when supplied to this function (contrary to values in the arrays which may be insecure).
                if (is_array($fields_values) && count($fields_values))  {

                        if (is_string($no_quote_fields))        {
                                $no_quote_fields = explode(',',$no_quote_fields);
                        } elseif (!is_array($no_quote_fields))  {
                                $no_quote_fields = array();
                        }

                        $blobfields = array();
                        $nArr = array();
                        foreach($fields_values as $k => $v)     {
                                if($this->sql_field_metatype($table,$k) == 'B') {
                                        /* // is this really needed for Oracle?
                                        if($this->handlerInstance[$this->lastHandlerKey]->databaseType == 'oci8')
                                        $nArr[$this->quoteFieldNames($k)] = 'empty_blob()';
                                        else
                                        $nArr[$this->quoteFieldNames($k)] = 'null';
                                        */
                                        $nArr[$this->quoteFieldNames($k)] = 'null';
                                        $blobfields[$this->quoteFieldNames($k)] = $v;
                                }
                                else {
                                        // Add slashes old-school:
                                        // cast numerical values
                                        $mt = $this->sql_field_metatype($table,$k);
                                        $v = (($mt{0}=='I')||($mt{0}=='F')) ? (int)$v : $v;

                                        $nArr[$this->quoteFieldNames($k)] = (!in_array($k,$no_quote_fields)) ? $this->fullQuoteStr($v, $table) : $v;
                                }
                        }
                        if(((string)$this->handlerCfg[$this->lastHandlerKey]['type']!=='native') && count($blobfields)) {
                                $query[0] = 'INSERT INTO '.$this->quoteFromTables($table).'
                                (
                                        '.implode(',
                                        ',array_keys($nArr)).'
                                ) VALUES (
                                        '.implode(',
                                        ',$nArr).'
                                )';
                                $query[1] = $blobfields;
                                if ($this->debugOutput) $this->debug_lastBuiltQuery = $query[0];
                        }
                        else {
                                $query = 'INSERT INTO '.$this->quoteFromTables($table).'
                                (
                                        '.implode(',
                                        ',array_keys($nArr)).'
                                ) VALUES (
                                        '.implode(',
                                        ',$nArr).'
                                )';

                                if ($this->debugOutput) $this->debug_lastBuiltQuery = $query;
                        }

                        return $query;
                }
        }

        function UPDATEquery($table,$where,$fields_values,$no_quote_fields='')  {
                // Table and fieldnames should be "SQL-injection-safe" when supplied to this function (contrary to values in the arrays which may be insecure).
                if (is_string($where))  {
                        if (is_array($fields_values) && count($fields_values))  {

                                if (is_string($no_quote_fields))        {
                                        $no_quote_fields = explode(',',$no_quote_fields);
                                } elseif (!is_array($no_quote_fields))  {
                                        $no_quote_fields = array();
                                }

                                $blobfields = array();
                                $nArr = array();
                                foreach($fields_values as $k => $v)     {
                                        if($this->sql_field_metatype($table,$k) == 'B') {
                                                // do we need empty_blob() for Oracle? see also INSERTquery()
                                                $nArr[] = $this->quoteFieldNames($k).'=NULL';
                                                $blobfields[$this->quoteFieldNames($k)] = $v;
                                        }
                                        else {
                                                // Add slashes old-school:
                                                // cast numeric values
                                                $mt = $this->sql_field_metatype($table,$k);
                                                $v = (($mt{0}=='I')||($mt{0}=='F')) ? (int)$v : $v;
                                                $nArr[] = $this->quoteFieldNames($k).'='.((!in_array($k,$no_quote_fields)) ? $this->fullQuoteStr($v, $table) : $v);
                                        }
                                }

                                if(count($blobfields)) {
                                        $query[0] = 'UPDATE '.$this->quoteFromTables($table).'
                                        SET
                                                '.implode(',
                                                ',$nArr).
                                                (strlen($where)>0 ? '
                                        WHERE
                                                '.$this->quoteWhereClause($where) : '');
                                                $query[1] = $blobfields;
                                                if ($this->debugOutput) $this->debug_lastBuiltQuery = $query[0];
                                }
                                else {
                                        $query = 'UPDATE '.$this->quoteFromTables($table).'
                                        SET
                                                '.implode(',
                                                ',$nArr).
                                                (strlen($where)>0 ? '
                                        WHERE
                                                '.$this->quoteWhereClause($where) : '');

                                                if ($this->debugOutput) $this->debug_lastBuiltQuery = $query;
                                }

                                return $query;
                        }
                }
                else {
                        die('<strong>TYPO3 Fatal Error:</strong> "Where" clause argument for UPDATE query was not a string in $this->UPDATEquery() !');
                }
        }

        function DELETEquery($table,$where)     {
                if (is_string($where))  {
                        $table = $this->quoteFromTables($table);
                        $where = $this->quoteWhereClause($where);

                        $query = parent::DELETEquery($table, $where);

                        if ($this->debugOutput) $this->debug_lastBuiltQuery = $query;
                        return $query;
                } else {
                        die('<strong>TYPO3 Fatal Error:</strong> "Where" clause argument for DELETE query was not a string in $this->DELETEquery() !');
                }
        }

        function SELECTquery($select_fields,$from_table,$where_clause,$groupBy='',$orderBy='',$limit='')        {

                $select_fields = $this->quoteFieldNames($select_fields);
                $from_table = $this->quoteFromTables($from_table);
                $where_clause = $this->quoteWhereClause($where_clause);
                $groupBy = $this->quoteGroupBy($groupBy);
                $orderBy = $this->quoteOrderBy($orderBy);

                // call parent method to build actual query
                $query = parent::SELECTquery($select_fields,$from_table,$where_clause,$groupBy,$orderBy,$limit);

                if ($this->debugOutput) $this->debug_lastBuiltQuery = $query;

                return $query;
        }


        /**************************************
        *
        * Functions for quoting table/field names
        *
        **************************************/

        function quoteSelectFields($select_fields) {
                $this->quoteFieldNames($select_fields);
        }

        function quoteFieldNames($select_fields) {
                if($select_fields == '') return '';

                $select_fields = $this->SQLparser->parseFieldList($select_fields);
                foreach($select_fields as $k => $v)     {
                        if($select_fields[$k]['field'] != '' && $select_fields[$k]['field'] != '*') {
                                $select_fields[$k]['field'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$select_fields[$k]['field'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        }
                        if($select_fields[$k]['table'] != '') {
                                $select_fields[$k]['table'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$select_fields[$k]['table'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        }
                        if($select_fields[$k]['as'] != '') {
                                $select_fields[$k]['as'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$select_fields[$k]['as'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        }
                        if(isset($select_fields[$k]['func_content.']) && $select_fields[$k]['func_content.'][0]['func_content'] != '*'){
                                if(strstr($select_fields[$k]['func_content.'][0]['func_content'],'.')) {
                                        $select_fields[$k]['func_content.'][0]['func_content'] = $this->quoteFieldNames($select_fields[$k]['func_content.'][0]['func_content']);
                                        $select_fields[$k]['func_content'] = $this->quoteFieldNames($select_fields[$k]['func_content']);
                                }
                                else {
                                        $select_fields[$k]['func_content.'][0]['func_content'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$select_fields[$k]['func_content.'][0]['func_content'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                                        $select_fields[$k]['func_content'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$select_fields[$k]['func_content'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                                }
                        }
                }

                return $this->SQLparser->compileFieldList($select_fields);
        }

        function quoteFromTables($from_table) {
                if($from_table == '') return '';

                $from_table = $this->SQLparser->parseFromTables($from_table);
                foreach($from_table as $k => $v)        {
                        $from_table[$k]['table'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$from_table[$k]['table'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        if($from_table[$k]['as'] != '') {
                                $from_table[$k]['as'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$from_table[$k]['as'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        }
                        if (is_array($v['JOIN']))       {
                                $from_table[$k]['JOIN']['withTable'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$from_table[$k]['JOIN']['withTable'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                                $from_table[$k]['JOIN']['ON'][0]['table'] = ($from_table[$k]['JOIN']['ON'][0]['table']) ? $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$from_table[$k]['JOIN']['ON'][0]['table'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote : '';
                                $from_table[$k]['JOIN']['ON'][0]['field'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$from_table[$k]['JOIN']['ON'][0]['field'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                                $from_table[$k]['JOIN']['ON'][1]['table'] = ($from_table[$k]['JOIN']['ON'][1]['table']) ? $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$from_table[$k]['JOIN']['ON'][1]['table'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote : '';
                                $from_table[$k]['JOIN']['ON'][1]['field'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$from_table[$k]['JOIN']['ON'][1]['field'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        }
                }
                return $this->SQLparser->compileFromTables($from_table);
        }

        function quoteWhereClause($where_clause) {
                if($where_clause == '') return '';

                $where_clause = $this->SQLparser->parseWhereClause($where_clause);
                $where_clause = $this->_quoteWhereClause($where_clause);
                $where_clause = $this->SQLparser->compileWhereClause($where_clause);

                return $where_clause;
        }

        function _quoteWhereClause($where_clause) {
                foreach($where_clause as $k => $v)      {
                        // Look for sublevel:
                        if (is_array($where_clause[$k]['sub'])) {
                                $where_clause[$k]['sub'] = $this->_quoteWhereClause($where_clause[$k]['sub']);
                        } else {
                                if($where_clause[$k]['table'] != '') {
                                        $where_clause[$k]['table'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$where_clause[$k]['table'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                                }
                                if(!is_numeric($where_clause[$k]['field'])) {
                                        $where_clause[$k]['field'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$where_clause[$k]['field'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                                }
                        }
                        if ($where_clause[$k]['comparator'])    {
                                // Detecting value type; list or plain:
                                if ((!isset($where_clause[$k]['value'][1]) || $where_clause[$k]['value'][1] == '') && is_string($where_clause[$k]['value'][0]) && strstr($where_clause[$k]['value'][0], '.') && !t3lib_div::inList('NOTIN,IN',strtoupper(str_replace(array(" ","\n","\r","\t"),'',$where_clause[$k]['comparator']))))   {
                                        $where_clause[$k]['value'][0] = $this->quoteFieldNames($where_clause[$k]['value'][0]);
                                }
                        }
                }

                return $where_clause;
        }

        function quoteGroupBy($groupBy) {
                if($groupBy == '') return '';

                $groupBy = $this->SQLparser->parseFieldList($groupBy);
                foreach($groupBy as $k => $v)   {
                        $groupBy[$k]['field'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$groupBy[$k]['field'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        if($groupBy[$k]['table'] != '') {
                                $groupBy[$k]['table'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$groupBy[$k]['table'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        }
                }
                return $this->SQLparser->compileFieldList($groupBy);
        }

        function quoteOrderBy($orderBy) {
                if($orderBy == '') return '';

                $orderBy = $this->SQLparser->parseFieldList($orderBy);
                foreach($orderBy as $k => $v)   {
                        $orderBy[$k]['field'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$orderBy[$k]['field'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        if($orderBy[$k]['table'] != '') {
                                $orderBy[$k]['table'] = $this->handlerInstance[$this->lastHandlerKey]->nameQuote.$orderBy[$k]['table'].$this->handlerInstance[$this->lastHandlerKey]->nameQuote;
                        }
                }
                return $this->SQLparser->compileFieldList($orderBy);
        }



        /**************************************
        *
        * Various helper functions
        *
        **************************************/

        function fullQuoteStr($str,$table) {
                return '\''.$this->quoteStr($str, $table).'\'';
        }

        function quoteStr($str, $table) {
                $this->lastHandlerKey = $this->handler_getFromTableList($table);
                switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $str = mysql_real_escape_string($str, $this->handlerInstance[$this->lastHandlerKey]['link']);
                                break;
                        case 'adodb':
                                $str = substr($this->handlerInstance[$this->lastHandlerKey]->qstr($str),1,-1);
                                break;
                        case 'userdefined':
                                $str = $this->handlerInstance[$this->lastHandlerKey]->quoteStr($str);
                                break;
                        default:
                                die('No handler found!!!');
                                break;
                }

                return $str;
        }


        function MetaType($type,$table,$max_length=-1)  {
                $this->lastHandlerKey = $this->handler_getFromTableList($table);
                switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'adodb':
                        $rs = $this->handlerInstance[$this->lastHandlerKey]->SelectLimit('SELECT * FROM '.$this->quoteFromTables($table),1);
                        $str = $rs->MetaType($type, $max_length);
                        break;
                        default:
                        die('No handler found!!!');
                        break;
                }

                return $str;
        }


        function MySQLMetaType($t) {

                switch (strtoupper($t)) {
                        case 'STRING':
                        case 'CHAR':
                        case 'VARCHAR':
                        case 'TINYBLOB':
                        case 'TINYTEXT':
                        case 'ENUM':
                        case 'SET':
                        return 'C';

                        case 'TEXT':
                        case 'LONGTEXT':
                        case 'MEDIUMTEXT':
                        return 'X';

                        // php_mysql extension always returns 'blob' even if 'text'
                        // so we have to check whether binary...
                        case 'IMAGE':
                        case 'LONGBLOB':
                        case 'BLOB':
                        case 'MEDIUMBLOB':
                        return 'B';

                        case 'YEAR':
                        case 'DATE': return 'D';

                        case 'TIME':
                        case 'DATETIME':
                        case 'TIMESTAMP': return 'T';

                        case 'FLOAT':
                        case 'DOUBLE':
                        return 'F';

                        case 'INT':
                        case 'INTEGER': return 'I';
                        case 'TINYINT': // MS SQL Server allows only 0..255 for tinyint, so we do not map to I1
                        case 'SMALLINT': return 'I2';
                        case 'MEDIUMINT': return 'I4';
                        case 'BIGINT': return 'I8';

                        default: return 'N';
                }
        }

        function MySQLActualType($meta) {
                switch(strtoupper($meta)) {
                        case 'C': return 'VARCHAR';
                        case 'XL':
                        case 'X': return 'LONGTEXT';

                        case 'C2': return 'VARCHAR';
                        case 'X2': return 'LONGTEXT';

                        case 'B': return 'LONGBLOB';

                        case 'D': return 'DATE';
                        case 'T': return 'DATETIME';
                        case 'L': return 'TINYINT';

                        case 'I': return 'INT';
                        case 'I1': // MS SQL Server allows only 0..255 for tinyint, so we do not map to TINYINT
                        case 'I2': return 'SMALLINT';
                        case 'I4': return 'MEDIUMINT';
                        case 'I8': return 'BIGINT';

                        case 'F': return 'DOUBLE';
                        case 'N': return 'NUMERIC';
                        default:
                        return $meta;
                }
        }




        /**************************************
        *
        * SQL wrapper functions (Overriding parent methods)
        * (For use in your applications)
        *
        **************************************/

        function sql_error()    {

                switch($this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $output = mysql_error($this->handlerInstance[$this->lastHandlerKey]['link']);
                                break;
                        case 'adodb':
                                $output = $this->handlerInstance[$this->lastHandlerKey]->ErrorMsg();
                                break;
                        case 'userdefined':
                                $output = $this->handlerInstance[$this->lastHandlerKey]->sql_error();
                                break;
                }
                return $output;
        }

        function sql_num_rows(&$res)    {

                $handlerType = is_object($res) ? $res->TYPO3_DBAL_handlerType : 'native';
                switch($handlerType)    {
                        case 'native':
                                $output = mysql_num_rows($res);
                                break;
                        case 'adodb':
                                $output = method_exists($res, 'RecordCount') ? $res->RecordCount() : 0;
                                break;
                        case 'userdefined':
                                $output = $res->sql_num_rows();
                                break;
                }
                return $output;
        }

        function sql_fetch_assoc(&$res) {
                $output = array();

                $handlerType = is_object($res) ? $res->TYPO3_DBAL_handlerType : (is_resource($res) ? 'native' : false);
                switch($handlerType)    {
                        case 'native':
                                $output = mysql_fetch_assoc($res);
                                $tableList = $this->resourceIdToTableNameMap[(string)$res];     // Reading list of tables from SELECT query:
                                break;
                        case 'adodb':
                                        // Check if method exists for the current $res object.
                                        // If a table exists in TCA but not in the db, a error
                                        // occured because $res is not a valid object.
                                if(method_exists($res, 'FetchRow')) {
                                        $output = $res->FetchRow();
                                        $tableList = $res->TYPO3_DBAL_tableList;        // Reading list of tables from SELECT query:

                                                // Removing all numeric/integer keys.
                                                // A workaround because in ADOdb we would need to know what we want before executing the query...
                                        if (is_array($output))  {
                                                foreach($output as $key => $value)      {
                                                        if (is_integer($key))   unset($output[$key]);
                                                        elseif($value===' ' && strstr($GLOBALS['TYPO3_DB']->handlerCfg[$GLOBALS['TYPO3_DB']->lastHandlerKey]['config']['driver'],'mssql')) $output[$key]=''; // MSSQL does not know such thing as an empty string. So it returns one space instead, which we must fix.
                                                }
                                        }
                                }
                                break;
                        case 'userdefined':
                                $output = $res->sql_fetch_assoc();
                                $tableList = $res->TYPO3_DBAL_tableList;        // Reading list of tables from SELECT query:
                                break;
                }

                // Table/Fieldname mapping:
                if (is_array($output))  {
                        if ($tables = $this->map_needMapping($tableList,TRUE))  {
                                $output = $this->map_assocArray($output,$tables,1);
                        }
                }

                // Return result:
                return $output;
        }

        function sql_fetch_row(&$res)   {
                $handlerType = is_object($res) ? $res->TYPO3_DBAL_handlerType :  'native';
                switch($handlerType)    {
                        case 'native':
                                $output = mysql_fetch_row($res);
                                break;
                        case 'adodb':
                                        // Check if method exists for the current $res object.
                                        // If a table exists in TCA but not in the db, a error
                                        // occured because $res is not a valid object.
                                if(method_exists($res, 'FetchRow')) {
                                        $output = $res->FetchRow();

                                                // Removing all assoc. keys.
                                                // A workaround because in ADOdb we would need to know what we want before executing the query...
                                        if (is_array($output))  {
                                                foreach($output as $key => $value)      {
                                                        if (!is_integer($key))  unset($output[$key]);
                                                        elseif($value===' ' && strstr($GLOBALS['TYPO3_DB']->handlerCfg[$GLOBALS['TYPO3_DB']->lastHandlerKey]['config']['driver'],'mssql')) $output[$key]=''; // MSSQL does not know such thing as an empty string. So it returns one space instead, which we must fix.
                                                }
                                        }
                                }
                                break;
                        case 'userdefined':
                                $output = $res->sql_fetch_row();
                                break;
                }
                return $output;
        }

        function sql_free_result(&$res) {

                $handlerType = is_object($res) ? $res->TYPO3_DBAL_handlerType :  'native';
                switch($handlerType)    {
                        case 'native':
                                $output = mysql_free_result($res);
                                break;
                        case 'adodb':
                                if(method_exists($res, 'Close')) {
                                        $res->Close();
                                        unset($res);
                                        $output = true;
                                } else {
                                        $output = false;
                                }
                                break;
                        case 'userdefined':
                                unset($res);
                                break;
                }
                return $output;
        }

        function sql_insert_id()        {

                switch($this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $output = mysql_insert_id($this->handlerInstance[$this->lastHandlerKey]['link']);
                                break;
                        case 'adodb':
                                $output = $this->handlerInstance[$this->lastHandlerKey]->last_insert_id;
                                break;
                        case 'userdefined':
                                $output = $this->handlerInstance[$this->lastHandlerKey]->sql_insert_id();
                                break;
                }
                return $output;
        }

        function sql_affected_rows()    {

                switch($this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $output = mysql_affected_rows();
                                break;
                        case 'adodb':
                                $output = $this->handlerInstance[$this->lastHandlerKey]->Affected_Rows();
                                break;
                        case 'userdefined':
                                $output = $this->handlerInstance[$this->lastHandlerKey]->sql_affected_rows();
                                break;
                }
                return $output;
        }

        function sql_data_seek(&$res,$seek)     {

                $handlerType = is_object($res) ? $res->TYPO3_DBAL_handlerType :  'native';
                switch($handlerType)    {
                        case 'native':
                                $output = mysql_data_seek($res,$seek);
                                break;
                        case 'adodb':
                                $output = $res->Move($seek);
                                break;
                        case 'userdefined':
                                $output = $res->sql_data_seek($seek);
                                break;
                }
                return $output;
        }

        function sql_field_metatype($table,$field)      {
                return $this->cache_fieldType[$table][$field]['metaType'];
        }

        function sql_field_type(&$res,$pointer) {
                if($res === null) {
                        debug(array('no res in sql_field_type!'));
                        return 'text';
                }
                else if(is_string($res)){
                        if($res == 'tx_dbal_debuglog') return 'text';
                        $handlerType = 'adodb';
                }
                else {
                        $handlerType = is_object($res) ? $res->TYPO3_DBAL_handlerType :  'native';
                }

                switch($handlerType)    {
                        case 'native':
                                $output = mysql_field_type($res,$pointer);
                                break;
                        case 'adodb':
                                if(is_string($pointer)){
                                        $output = $this->cache_fieldType[$res][$pointer]['type'];
                                }

                                break;
                        case 'userdefined':
                                $output = $res->sql_field_type($pointer);
                                break;
                }

                return $output;
        }








        /**********
        *
        * Legacy functions, bound to _DEFAULT handler. (Overriding parent methods)
        * Depreciated.
        *
        **********/

        function sql($db,$query)        {
                return $this->sql_query($query);
        }

        function sql_query($query)      {

                switch($this->handlerCfg['_DEFAULT']['type'])   {
                        case 'native':
                                $sqlResult = mysql_query($query, $this->handlerInstance['_DEFAULT']['link']);
                                break;
                        case 'adodb':
                                $sqlResult = $this->handlerInstance['_DEFAULT']->Execute($query);
                                $sqlResult->TYPO3_DBAL_handlerType = 'adodb';
                                break;
                        case 'userdefined':
                                $sqlResult = $this->handlerInstance['_DEFAULT']->sql_query($query);
                                $sqlResult->TYPO3_DBAL_handlerType = 'userdefined';
                                break;
                }

                if ($this->printErrors && $this->sql_error())   {
                        debug(array($this->lastQuery, $this->sql_error()));
                }

                return $sqlResult;
        }

        function sql_pconnect($TYPO3_db_host, $TYPO3_db_username, $TYPO3_db_password)   {
                // Overriding the _DEFAULT handler configuration of username, password, localhost and database name:
                $this->handlerCfg['_DEFAULT']['config']['username'] = $TYPO3_db_username;
                $this->handlerCfg['_DEFAULT']['config']['password'] = $TYPO3_db_password;
                $this->handlerCfg['_DEFAULT']['config']['host'] = $TYPO3_db_host;
                $this->handlerCfg['_DEFAULT']['config']['database'] = TYPO3_db;

                // Initializing and output value:
                $sqlResult = $this->handler_init('_DEFAULT');
                return $sqlResult;
        }

        function sql_select_db($TYPO3_db)       {
                return TRUE;
        }















        /**************************************
        *
        * SQL admin functions
        * (For use in the Install Tool and Extension Manager)
        *
        **************************************/

        function admin_get_dbs()        {
                $dbArr = array();
                switch($this->handlerCfg['_DEFAULT']['type'])   {
                        case 'native':
                                $db_list = mysql_list_dbs($this->link);
                                while ($row = mysql_fetch_object($db_list)) {
                                        if ($this->sql_select_db($row->Database))       {
                                                $dbArr[] = $row->Database;
                                        }
                                }
                                break;
                        case 'adodb':
                                        // check needed for install tool - otherwise it will just die because the call to
                                        // MetaDatabases is done on a stdClass instance
                                if(method_exists($this->handlerInstance['_DEFAULT'],'MetaDatabases')) {
                                        $sqlDBs = $this->handlerInstance['_DEFAULT']->MetaDatabases();
                                        if(is_array($sqlDBs)) {
                                                foreach($sqlDBs as $k => $theDB) {
                                                        $dbArr[] = $theDB;
                                                }
                                        }
                                }
                                break;
                        case 'userdefined':
                                $dbArr = $this->handlerInstance['_DEFAULT']->admin_get_tables();
                                break;
                }

                return $dbArr;
        }

        function admin_get_tables()     {
                $whichTables = array();

                // Getting real list of tables:
                switch($this->handlerCfg['_DEFAULT']['type'])   {
                        case 'native':
                                $tables_result = mysql_list_tables(TYPO3_db, $this->handlerInstance['_DEFAULT']['link']);
                                if (!$this->sql_error())        {
                                        while ($theTable = $this->sql_fetch_assoc($tables_result)) {
                                                $whichTables[current($theTable)] = current($theTable);
                                        }
                                }
                                break;
                        case 'adodb':
                                $sqlTables = $this->handlerInstance['_DEFAULT']->MetaTables('TABLES');
                                while (list($k, $theTable) = each($sqlTables)) {
                                        $whichTables[$theTable] = $theTable;
                                }
                                break;
                        case 'userdefined':
                                $whichTables = $this->handlerInstance['_DEFAULT']->admin_get_tables();
                                break;
                }

                // Check mapping:
                if (is_array($this->mapping))   {

                        // Mapping table names in reverse, first getting list of real table names:
                        $tMap = array();
                        foreach($this->mapping as $tN => $tMapInfo)     {
                                if (isset($tMapInfo['mapTableName']))   $tMap[$tMapInfo['mapTableName']]=$tN;
                        }

                        // Do mapping:
                        $newList=array();
                        foreach($whichTables as $tN)    {
                                if (isset($tMap[$tN]))  $tN = $tMap[$tN];
                                $newList[$tN] = $tN;
                        }

                        $whichTables = $newList;
                }

                // Adding tables configured to reside in other DBMS (handler by other handlers than the default):
                if (is_array($this->table2handlerKeys)) {
                        foreach($this->table2handlerKeys as $key => $handlerKey)        {
                                $whichTables[$key] = $key;
                        }
                }

                return $whichTables;
        }

        function admin_get_fields($tableName)   {
                $output = array();

                // Do field mapping if needed:
                $ORIG_tableName = $tableName;
                if ($tableArray = $this->map_needMapping($tableName))   {

                        // Table name:
                        if ($this->mapping[$tableName]['mapTableName']) {
                                $tableName = $this->mapping[$tableName]['mapTableName'];
                        }
                }

                // Find columns
                $this->lastHandlerKey = $this->handler_getFromTableList($ORIG_tableName);
                switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                                $columns_res = mysql_query('SHOW columns FROM '.$tableName, $this->handlerInstance[$this->lastHandlerKey]['link']);
                                while($fieldRow = mysql_fetch_assoc($columns_res))      {
                                        $output[$fieldRow['Field']] = $fieldRow;
                                }
                                break;
                        case 'adodb':
                                $fieldRows = $this->handlerInstance[$this->lastHandlerKey]->MetaColumns($tableName, false);
                                foreach($fieldRows as $k => $fieldRow) {
                                        settype($fieldRow, 'array');
                                        $fieldRow['Field'] = $fieldRow['name'];
                                        $ntype = $this->MySQLActualType($this->MetaType($fieldRow['type'],$tableName));
                                        $ntype .= (($fieldRow['max_length'] != -1) ? (($ntype == 'INT') ? '(11)' :'('.$fieldRow['max_length'].')') : '');
                                        $fieldRow['Type'] = strtolower($ntype);
                                        $fieldRow['Null'] = '';
                                        $fieldRow['Key'] = '';
                                        $fieldRow['Default'] = $fieldRow['default_value'];
                                        $fieldRow['Extra'] = '';
                                        $output[$fieldRow['name']] = $fieldRow;
                                }
                                break;
                        case 'userdefined':
                                $output = $this->handlerInstance[$this->lastHandlerKey]->admin_get_fields($tableName);
                                break;
                }

                // mapping should be done:
                if (is_array($tableArray) && is_array($this->mapping[$ORIG_tableName]['mapFieldNames']))        {
                        $revFields = array_flip($this->mapping[$ORIG_tableName]['mapFieldNames']);

                        $newOutput = array();
                        foreach($output as $fN => $fInfo)       {
                                if (isset($revFields[$fN]))     {
                                        $fN = $revFields[$fN];
                                        $fInfo['Field'] = $fN;
                                }
                                $newOutput[$fN] = $fInfo;
                        }
                        $output = $newOutput;
                }

                return $output;
        }

        function admin_get_keys($tableName)     {
                $output = array();

                // Do field mapping if needed:
                $ORIG_tableName = $tableName;
                if ($tableArray = $this->map_needMapping($tableName))   {

                        // Table name:
                        if ($this->mapping[$tableName]['mapTableName']) {
                                $tableName = $this->mapping[$tableName]['mapTableName'];
                        }
                }

                // Find columns
                $this->lastHandlerKey = $this->handler_getFromTableList($ORIG_tableName);
                switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                        case 'native':
                        $keyRes = mysql_query('SHOW keys FROM '.$tableName, $this->handlerInstance[$this->lastHandlerKey]['link']);
                        while($keyRow = mysql_fetch_assoc($keyRes))     {
                                $output[] = $keyRow;
                        }
                        break;
                        case 'adodb':
                        $keyRows = $this->handlerInstance[$this->lastHandlerKey]->MetaIndexes($tableName);
                        if($keyRows !== false) {
                                while (list($k, $theKey) = each($keyRows)) {
                                        $theKey['Table'] = $tableName;
                                        $theKey['Non_unique'] = (int) !$theKey['unique'];
                                        $theKey['Key_name'] = str_replace($tableName.'_','',$k);

                                        // the following are probably not needed anyway...
                                        $theKey['Collation'] = '';
                                        $theKey['Cardinality'] = '';
                                        $theKey['Sub_part'] = '';
                                        $theKey['Packed'] = '';
                                        $theKey['Null'] = '';
                                        $theKey['Index_type'] = '';
                                        $theKey['Comment'] = '';

                                        // now map multiple fields into multiple rows (we mimic MySQL, remember...)
                                        $keycols = $theKey['columns'];
                                        while (list($c, $theCol) = each($keycols)) {
                                                $theKey['Seq_in_index'] = $c+1;
                                                $theKey['Column_name'] = $theCol;
                                                $output[] = $theKey;
                                        }
                                }
                        }
                        $priKeyRow = $this->handlerInstance[$this->lastHandlerKey]->MetaPrimaryKeys($tableName);
                        $theKey = array();
                        $theKey['Table'] = $tableName;
                        $theKey['Non_unique'] = 0;
                        $theKey['Key_name'] = 'PRIMARY';

                        // the following are probably not needed anyway...
                        $theKey['Collation'] = '';
                        $theKey['Cardinality'] = '';
                        $theKey['Sub_part'] = '';
                        $theKey['Packed'] = '';
                        $theKey['Null'] = '';
                        $theKey['Index_type'] = '';
                        $theKey['Comment'] = '';

                        // now map multiple fields into multiple rows (we mimic MySQL, remember...)
                        if($priKeyRow !== false) {
                                while (list($c, $theCol) = each($priKeyRow)) {
                                        $theKey['Seq_in_index'] = $c+1;
                                        $theKey['Column_name'] = $theCol;
                                        $output[] = $theKey;
                                }
                        }
                        break;
                        case 'userdefined':
                        $output = $this->handlerInstance[$this->lastHandlerKey]->admin_get_keys($tableName);
                        break;
                }

                // mapping should be done:
                if (is_array($tableArray) && is_array($this->mapping[$ORIG_tableName]['mapFieldNames']))        {
                        $revFields = array_flip($this->mapping[$ORIG_tableName]['mapFieldNames']);

                        $newOutput = array();
                        foreach($output as $kN => $kInfo)       {
                                // Table:
                                $kInfo['Table'] = $ORIG_tableName;

                                // Column
                                if (isset($revFields[$kInfo['Column_name']]))   {
                                        $kInfo['Column_name'] = $revFields[$kInfo['Column_name']];
                                }

                                // Write it back:
                                $newOutput[$kN] = $kInfo;
                        }
                        $output = $newOutput;
                }

                return $output;
        }

        function admin_query($query)    {
                $parsedQuery = $this->SQLparser->parseSQL($query);
                $ORIG_table = $parsedQuery['TABLE'];

                if (is_array($parsedQuery))     {

                        // Process query based on type:
                        switch($parsedQuery['type'])    {
                                case 'CREATETABLE':
                                case 'ALTERTABLE':
                                case 'DROPTABLE':
                                        if(file_exists(PATH_typo3conf.'temp_fieldInfo.php')) unlink(PATH_typo3conf.'temp_fieldInfo.php');
                                        $this->map_genericQueryParsed($parsedQuery);
                                        break;
                                case 'INSERT':
                                        $this->map_genericQueryParsed($parsedQuery);
                                        break;
                                case 'CREATEDATABASE':
                                        die('Creating a database with DBAL is not supported. Did you really read the manual?');
                                        break;
                                default:
                                        die('ERROR: Invalid Query type ('.$parsedQuery['type'].') for ->admin_query() function!: "'.htmlspecialchars($query).'"');
                                        break;
                        }

                        // Setting query array (for other applications to access if needed)
                        $this->lastParsedAndMappedQueryArray = $parsedQuery;

                        // Execute query (based on handler derived from the TABLE name which we actually know for once!)
                        $this->lastHandlerKey = $this->handler_getFromTableList($ORIG_table);
                        switch((string)$this->handlerCfg[$this->lastHandlerKey]['type'])        {
                                case 'native':
                                        // Compiling query:
                                        $compiledQuery =  $this->SQLparser->compileSQL($this->lastParsedAndMappedQueryArray);

                                        return mysql_query($compiledQuery[0], $this->link);
                                        break;
                                case 'adodb':
                                        // Compiling query:
                                        $compiledQuery =  $this->SQLparser->compileSQL($this->lastParsedAndMappedQueryArray);
                                        if($this->lastParsedAndMappedQueryArray['type']=='INSERT') {
                                                return $this->exec_INSERTquery($this->lastParsedAndMappedQueryArray['TABLE'],$compiledQuery);
                                        }
                                        return $this->handlerInstance[$this->lastHandlerKey]->DataDictionary->ExecuteSQLArray($compiledQuery);
                                        break;
                                case 'userdefined':
                                        // Compiling query:
                                        $compiledQuery =  $this->SQLparser->compileSQL($this->lastParsedAndMappedQueryArray);

                                        return $this->handlerInstance[$this->lastHandlerKey]->admin_query($compiledQuery);
                                        break;
                        }
                } else die('ERROR: Query could not be parsed: "'.htmlspecialchars($parsedQuery).'". Query: "'.htmlspecialchars($query).'"');
        }










        /************************************
        *
        * Handler management
        *
        **************************************/

        function handler_getFromTableList($tableList)   {

                $key = $tableList;

                if (!isset($this->cache_handlerKeyFromTableList[$key])) {

                        // Get tables separated:
                        $_tableList = $tableList;
                        $tableArray = $this->SQLparser->parseFromTables($_tableList);

                        // If success, traverse the tables:
                        if (is_array($tableArray) && count($tableArray))        {
                                foreach($tableArray as $vArray) {

                                        // Find handler key, select "_DEFAULT" if none is specifically configured:
                                        $handlerKey = $this->table2handlerKeys[$vArray['table']] ? $this->table2handlerKeys[$vArray['table']] : '_DEFAULT';

                                        // In case of separate handler keys for joined tables:
                                        if ($outputHandlerKey && $handlerKey != $outputHandlerKey)      {
                                                die('DBAL fatal error: Tables in this list "'.$tableList.'" didn\'t use the same DB handler!');
                                        }

                                        $outputHandlerKey = $handlerKey;
                                }

                                // Check initialized state; if handler is NOT initialized (connected) then we will connect it!
                                if (!isset($this->handlerInstance[$outputHandlerKey]))  {
                                        $this->handler_init($outputHandlerKey);
                                }

                                // Return handler key:
                                $this->cache_handlerKeyFromTableList[$key] = $outputHandlerKey;
                        } else {
                                die('DBAL fatal error: No tables found: "'.$tableList.'"');
                        }
                }

                return $this->cache_handlerKeyFromTableList[$key];
        }

        function handler_init($handlerKey)      {

                // Find handler configuration:
                $cfgArray = $this->handlerCfg[$handlerKey];
                $handlerType = (string)$cfgArray['type'];
                $output = FALSE;

                if (is_array($cfgArray))        {
                        switch($handlerType)    {
                                case 'native':
                                $link = mysql_pconnect($cfgArray['config']['host'].(isset($cfgArray['config']['port']) ? ':'.$cfgArray['config']['port'] : ''), $cfgArray['config']['username'], $cfgArray['config']['password']);

                                // Set handler instance:
                                $this->handlerInstance[$handlerKey] = array('handlerType' => 'native', 'link' => $link);

                                // If link succeeded:
                                if ($link)      {
                                        // For default, set ->link (see t3lib_DB)
                                        if ($handlerKey == '_DEFAULT') {
                                                $this->link = $link;
                                        }

                                        // Select database as well:
                                        if (mysql_select_db($cfgArray['config']['database'], $link))    {
                                                $output = TRUE;
                                        }
                                        $setDBinit = t3lib_div::trimExplode(chr(10), $GLOBALS['TYPO3_CONF_VARS']['SYS']['setDBinit']);
                                        foreach ($setDBinit as $v)      {
                                                if (mysql_query($v, $this->link) === FALSE)     {
                                                        t3lib_div::sysLog('Could not initialize DB connection with query "'.$v.'".','Core',3);
                                                }
                                        }
                                }
                                break;
                                case 'adodb':
                                $output = true;
                                require_once(t3lib_extMgm::extPath('adodb').'adodb/adodb.inc.php');
                                if(!defined('ADODB_FORCE_NULLS')) define('ADODB_FORCE_NULLS', 1);
                                $GLOBALS['ADODB_FORCE_TYPE'] = ADODB_FORCE_VALUE;
                                $GLOBALS['ADODB_FETCH_MODE'] = ADODB_FETCH_BOTH;

                                $this->handlerInstance[$handlerKey] = &ADONewConnection($cfgArray['config']['driver']);
                                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['no_pconnect'])  {
                                        $this->handlerInstance[$handlerKey]->Connect($cfgArray['config']['host'].(isset($cfgArray['config']['port']) ? ':'.$cfgArray['config']['port'] : ''),$cfgArray['config']['username'],$cfgArray['config']['password'],$cfgArray['config']['database']);
                                } else {
                                        $this->handlerInstance[$handlerKey]->PConnect($cfgArray['config']['host'].(isset($cfgArray['config']['port']) ? ':'.$cfgArray['config']['port'] : ''),$cfgArray['config']['username'],$cfgArray['config']['password'],$cfgArray['config']['database']);
                                }
                                if(!$this->handlerInstance[$handlerKey]->isConnected()) {
                                        $dsn = $cfgArray['config']['driver'].'://'.$cfgArray['config']['username'].
                                                (strlen($cfgArray['config']['password']) ? ':XXXX@' : '').
                                                $cfgArray['config']['host'].(isset($cfgArray['config']['port']) ? ':'.$cfgArray['config']['port'] : '').'/'.$cfgArray['config']['database'].
                                                ($GLOBALS['TYPO3_CONF_VARS']['SYS']['no_pconnect'] ? '' : '?persistent=1');
                                        error_log('DBAL error: Connection to '.$dsn.' failed. Maybe PHP doesn\'t support the database?');
                                        $output = false;
                                } else {
                                        $this->handlerInstance[$handlerKey]->DataDictionary  = NewDataDictionary($this->handlerInstance[$handlerKey]);
                                        $this->handlerInstance[$handlerKey]->last_insert_id = 0;
                                }
                                break;
                                case 'userdefined':
                                // Find class file:
                                $fileName = t3lib_div::getFileAbsFileName($cfgArray['config']['classFile']);
                                if (@is_file($fileName))        {
                                        require_once($fileName);
                                } else die('DBAL error: "'.$fileName.'" was not a file to include.');

                                // Initialize:
                                $this->handlerInstance[$handlerKey] = t3lib_div::makeInstance($cfgArray['config']['class']);
                                $this->handlerInstance[$handlerKey]->init($cfgArray,$this);

                                if (is_object($this->handlerInstance[$handlerKey]))             {
                                        $output = TRUE;
                                }
                                break;
                                default:
                                die('ERROR: Invalid handler type: "'.$cfgArray['type'].'"');
                                break;
                        }

                        return $output;
                } else die('ERROR: No handler for key "'.$handlerKey.'"');
        }














        /************************************
        *
        * Table/Field mapping
        *
        **************************************/

        function map_needMapping($tableList,$fieldMappingOnly=FALSE)    {

                $key = $tableList.'|'.$fieldMappingOnly;
                if (!isset($this->cache_mappingFromTableList[$key]))    {
                        $this->cache_mappingFromTableList[$key] = FALSE;        // Default:

                        $tables = $this->SQLparser->parseFromTables($tableList);
                        if (is_array($tables))  {
                                foreach($tables as $tableCfg)   {
                                        if ($fieldMappingOnly)  {
                                                if (is_array($this->mapping[$tableCfg['table']]['mapFieldNames']))      {
                                                        $this->cache_mappingFromTableList[$key] = $tables;
                                                }
                                        } else {
                                                if (is_array($this->mapping[$tableCfg['table']]))       {
                                                        $this->cache_mappingFromTableList[$key] = $tables;
                                                }
                                        }
                                }
                        }
                }

                return $this->cache_mappingFromTableList[$key];
        }

        function map_assocArray($input,$tables,$rev=FALSE)      {

                // Traverse tables from query (hopefully only one table):
                foreach($tables as $tableCfg)   {
                        if (is_array($this->mapping[$tableCfg['table']]['mapFieldNames']))      {

                                // Get the map (reversed if needed):
                                if ($rev)       {
                                        $theMap = array_flip($this->mapping[$tableCfg['table']]['mapFieldNames']);
                                } else {
                                        $theMap = $this->mapping[$tableCfg['table']]['mapFieldNames'];
                                }

                                // Traverse selected record, map fieldnames:
                                $output = array();
                                foreach($input as $fN => $value)        {

                                        // Set the field name, change it if found in mapping array:
                                        if ($theMap[$fN])       {
                                                $newKey = $theMap[$fN];
                                        } else {
                                                $newKey = $fN;
                                        }

                                        // Set value to fieldname:
                                        $output[$newKey] = $value;
                                }

                                // When done, override the $input array with the result:
                                $input = $output;
                        }
                }

                // Return input array (which might have been altered in the mean time)
                return $input;
        }

        function map_remapSELECTQueryParts(&$select_fields,&$from_table,&$where_clause,&$groupBy,&$orderBy)     {

                // Tables:
                $tables = $this->SQLparser->parseFromTables($from_table);
                $defaultTable = $tables[0]['table'];
                foreach($tables as $k => $v)    {
                        if ($this->mapping[$v['table']]['mapTableName'])        {
                                $tables[$k]['table'] = $this->mapping[$v['table']]['mapTableName'];
                        }
                }
                $from_table = $this->SQLparser->compileFromTables($tables);

                // Where clause:
                $whereParts = $this->SQLparser->parseWhereClause($where_clause);
                $this->map_sqlParts($whereParts,$defaultTable);
                $where_clause = $this->SQLparser->compileWhereClause($whereParts);

                // Select fields:
                $expFields = $this->SQLparser->parseFieldList($select_fields);
                $this->map_sqlParts($expFields,$defaultTable);
                $select_fields = $this->SQLparser->compileFieldList($expFields);

                // Group By fields
                $expFields = $this->SQLparser->parseFieldList($groupBy);
                $this->map_sqlParts($expFields,$defaultTable);
                $groupBy = $this->SQLparser->compileFieldList($expFields);

                // Order By fields
                $expFields = $this->SQLparser->parseFieldList($orderBy);
                $this->map_sqlParts($expFields,$defaultTable);
                $orderBy = $this->SQLparser->compileFieldList($expFields);
        }

        function map_sqlParts(&$sqlPartArray, $defaultTable)    {

                // Traverse sql Part array:
                if (is_array($sqlPartArray))    {
                        foreach($sqlPartArray as $k => $v)      {

                                // Look for sublevel (WHERE parts only)
                                if (is_array($sqlPartArray[$k]['sub'])) {
                                        $this->map_sqlParts($sqlPartArray[$k]['sub'], $defaultTable);   // Call recursively!
                                } else {
                                        // For the field, look for table mapping (generic):
                                        $t = $sqlPartArray[$k]['table'] ? $sqlPartArray[$k]['table'] : $defaultTable;

                                        // Mapping field name, if set:
                                        if (is_array($this->mapping[$t]['mapFieldNames']) && $this->mapping[$t]['mapFieldNames'][$sqlPartArray[$k]['field']])   {
                                                $sqlPartArray[$k]['field'] = $this->mapping[$t]['mapFieldNames'][$sqlPartArray[$k]['field']];
                                        }

                                        // Map table?
                                        if ($sqlPartArray[$k]['table'] && $this->mapping[$sqlPartArray[$k]['table']]['mapTableName'])   {
                                                $sqlPartArray[$k]['table'] = $this->mapping[$sqlPartArray[$k]['table']]['mapTableName'];
                                        }
                                }
                        }
                }
        }

        function map_genericQueryParsed(&$parsedQuery)  {

                // Getting table - same for all:
                $table = $parsedQuery['TABLE'];
                if ($table)     {
                        // Do field mapping if needed:
                        if ($tableArray = $this->map_needMapping($table))       {

                                // Table name:
                                if ($this->mapping[$table]['mapTableName'])     {
                                        $parsedQuery['TABLE'] = $this->mapping[$table]['mapTableName'];
                                }

                                // Based on type, do additional changes:
                                switch($parsedQuery['type'])    {
                                        case 'ALTERTABLE':

                                        // Changing field name:
                                        $newFieldName = $this->mapping[$table]['mapFieldNames'][$parsedQuery['FIELD']];
                                        if ($newFieldName)      {
                                                if ($parsedQuery['FIELD'] == $parsedQuery['newField'])  {
                                                        $parsedQuery['FIELD'] = $parsedQuery['newField'] = $newFieldName;
                                                } else $parsedQuery['FIELD'] = $newFieldName;
                                        }

                                        // Changing key field names:
                                        if (is_array($parsedQuery['fields']))   {
                                                $this->map_fieldNamesInArray($table,$parsedQuery['fields']);
                                        }
                                        break;
                                        case 'CREATETABLE':
                                        // Remapping fields:
                                        if (is_array($parsedQuery['FIELDS']))   {
                                                $newFieldsArray = array();
                                                foreach($parsedQuery['FIELDS'] as $fN => $fInfo)        {
                                                        if ($this->mapping[$table]['mapFieldNames'][$fN])       {
                                                                $fN = $this->mapping[$table]['mapFieldNames'][$fN];
                                                        }
                                                        $newFieldsArray[$fN] = $fInfo;
                                                }
                                                $parsedQuery['FIELDS'] = $newFieldsArray;
                                        }

                                        // Remapping keys:
                                        if (is_array($parsedQuery['KEYS']))     {
                                                foreach($parsedQuery['KEYS'] as $kN => $kInfo)  {
                                                        $this->map_fieldNamesInArray($table,$parsedQuery['KEYS'][$kN]);
                                                }
                                        }
                                        break;




                                }
                        }
                } else die('ERROR, mapping: No table found in parsed Query array...');
        }

        function map_fieldNamesInArray($table,&$fieldArray)     {
                if (is_array($this->mapping[$table]['mapFieldNames']))  {
                        foreach($fieldArray as $k => $v)        {
                                if ($this->mapping[$table]['mapFieldNames'][$v])        {
                                        $fieldArray[$k] = $this->mapping[$table]['mapFieldNames'][$v];
                                }
                        }
                }
        }

















        /**************************************
        *
        * Debugging
        *
        **************************************/

        function debugHandler($function,$execTime,$inData)      {
                // we don't want to log our own log/debug SQL
                $script = substr(PATH_thisScript,strlen(PATH_site));

                if (substr($script,-strlen('dbal/mod1/index.php'))!='dbal/mod1/index.php' &&
                !strstr($inData['args'][0], 'tx_dbal_debuglog'))        {
                        $data = array();
                        $errorFlag = 0;
                        $joinTable = '';

                        if ($this->sql_error()) {
                                $data['sqlError'] = $this->sql_error();
                                $errorFlag|=1;
                        }

                        // if lastQuery is empty (for whatever reason) at least log inData.args
                        if(empty($this->lastQuery))
                        $query = implode(' ',$inData['args']);
                        else
                        $query = $this->lastQuery;

                        switch($function)       {
                                case 'exec_INSERTquery':
                                case 'exec_UPDATEquery':
                                case 'exec_DELETEquery':
                                $this->debug_log($query,$execTime,$data,$joinTable,$errorFlag, $script);
                                break;

                                case 'exec_SELECTquery':
                                // Get explain data:
                                if ($this->conf['debugOptions']['EXPLAIN'] && t3lib_div::inList('adodb,native',$inData['handlerType'])) {
                                        $data['EXPLAIN'] = $this->debug_explain($this->lastQuery);
                                }

                                // Check parsing of Query:
                                if ($this->conf['debugOptions']['parseQuery'])  {
                                        $parseResults = array();
                                        $parseResults['SELECT'] = $this->SQLparser->debug_parseSQLpart('SELECT',$inData['args'][1]);
                                        $parseResults['FROM'] = $this->SQLparser->debug_parseSQLpart('FROM',$inData['args'][0]);
                                        $parseResults['WHERE'] = $this->SQLparser->debug_parseSQLpart('WHERE',$inData['args'][2]);
                                        $parseResults['GROUPBY'] = $this->SQLparser->debug_parseSQLpart('SELECT',$inData['args'][3]);   // Using select field list syntax
                                        $parseResults['ORDERBY'] = $this->SQLparser->debug_parseSQLpart('SELECT',$inData['args'][4]);   // Using select field list syntax

                                        foreach($parseResults as $k => $v)      {
                                                if (!strlen($parseResults[$k])) unset($parseResults[$k]);
                                        }
                                        if (count($parseResults))       {
                                                $data['parseError'] = $parseResults;
                                                $errorFlag|=2;
                                        }
                                }

                                // Checking joinTables:
                                if ($this->conf['debugOptions']['joinTables'])  {
                                        if (count(explode(',', $inData['ORIG_from_table']))>1)          {
                                                $joinTable = $inData['args'][0];
                                        }
                                }

                                // Logging it:
                                $this->debug_log($query,$execTime,$data,$joinTable,$errorFlag, $script);
                                if(!empty($inData['args'][2]))
                                $this->debug_WHERE($inData['args'][0], $inData['args'][2], $script);
                                break;
                        }
                }
        }

        function debug_WHERE($table,$where, $script='') {
                $insertArray = array (
                'tstamp' => $GLOBALS['EXEC_TIME'],
                'beuser_id' => intval($GLOBALS['BE_USER']->user['uid']),
                'script' => $script,
                'tablename' => $table,
                'whereclause' => $where
                );

                $this->exec_INSERTquery('tx_dbal_debuglog_where', $insertArray);
        }

        function debug_log($query,$ms,$data,$join,$errorFlag, $script='')       {
                $insertArray = array (
                'tstamp' => $GLOBALS['EXEC_TIME'],
                'beuser_id' => intval($GLOBALS['BE_USER']->user['uid']),
                'script' => $script,
                'exec_time' => $ms,
                'table_join' => $join,
                'serdata' => serialize($data),
                'query' => (is_array($query) ? $query[0].' WITH '.count($query[1]).' BLOB FIELDS: '.implode(', ',array_keys($query[1])) : $query),
                'errorFlag' => $errorFlag
                );

                $this->exec_INSERTquery('tx_dbal_debuglog', $insertArray);
        }

        function debug_explain($query)  {
                $res = $this->sql_query('EXPLAIN '.$query);

                $output = array();
                while($row = $this->sql_fetch_assoc($res))      {
                        $output[] = $row;
                }
                return $output;
        }
}


if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/dbal/class.ux_t3lib_db.php'])  {
        include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/dbal/class.ux_t3lib_db.php']);
}
?>

---