DAL.inc

<?php
// Matrix = Channels system not required
//require_once dirname(dirname(__FILE__)).'/Channels/Channels.inc';
require_once dirname(__FILE__).'/Exceptions/DALException.inc';
// We're in a different place here; we can't assume that we're starting from
// the root
//require_once 'DAL/Query.inc';
require_once dirname(__FILE__).'/Query.inc';

class DAL
{


    private static $_dbhPool = NULL;


    private static $_dbStack = Array();

    private static $_currentDbConnId = '';

    private static $_dbTypes = Array();

    private static $_inTransaction = FALSE;

    private static $_dbNames = array(
                                'db2'   => 'DB2',
                                'dblib' => 'SQLServer',
                                'mysql' => 'MySQL',
                                'oci'   => 'Oracle',
                                'pgsql' => 'PostgreSQL',
                               );

    private static $_currentDbName = NULL;

    private static $_transactionEnabled = FALSE;

    private static $_queryLog = array();

    private static $_logQueries = FALSE;

    private static $_currentQueryLog = NULL;

    private static $_ociCommitOnSuccess = FALSE;

    private function __construct()
    {

    }//end __construct()


    public static function getQuery($systemid, $queryid, $bindValues=TRUE)
    {
        // Work out the class and method name to call.
        $class    = $systemid.'Queries';
        $function = 'prepare'.$queryid.'Query';

        self::requireQueryClass($systemid);

        // Should we include the class here?
        if (method_exists($class, $function) === FALSE) {
            // Query not found. Throw DALException exception?
            throw new DALException('Could not load query '.$queryid.' in system '.$systemid);
        } else {
            // Get the event data for the current channel.
            $eventData = Channels::getCurrentEventBasketData();
            return call_user_func(array($class, $function), $eventData, $bindValues);
        }

    }//end getQuery()


    public static function getAssoc(Query $dalQuery, $col=NULL)
    {

        $query  = $dalQuery->prepare();
        $result = self::executePdoAssoc($query, $col);

        // OCI8: release any created LOB objects
        $dalQuery->releaseLobs();


        return $result;

    }//end getAssoc()


    public static function getAll(Query $dalQuery)
    {

        $query  = $dalQuery->prepare();
        $result = self::executePdoAll($query);

        // OCI8: release any created LOB objects
        $dalQuery->releaseLobs();


        return $result;

    }//end getAll()


    public static function getOne(Query $dalQuery)
    {

        $query = $dalQuery->prepare();
        $result = self::executePdoOne($query);

        // OCI8: release any created LOB objects
        $dalQuery->releaseLobs();


        return $result;

    }//end getOne()


    public static function getDALQuery($systemid, $queryid, $method)
    {
        $queryArray = self::getQuery($systemid, $queryid, FALSE);
        // Add the method data to the query array, as this will allow
        // methods that this is passed to to execute it.
        $queryArray->setExecMethod($method);
        return $queryArray;

    }//end getDALQuery()


    public static function getGrouped(Query $dalQuery)
    {

        $query  = $dalQuery->prepare();
        $result = self::executePdoGrouped($query);


        return $result;

    }//end getGrouped()


    public static function getGroupedAssoc(Query $dalQuery)
    {

        $query  = $dalQuery->prepare();
        $result = self::executePdoGroupedAssoc($query);


        return $result;

    }//end getGroupedAssoc()


    public static function executeGrouped($systemid, $queryid)
    {
        $query = self::getQuery($systemid, $queryid);
        $res = self::getGrouped($query);

        return $res;

    }//end executeGrouped()


    public static function executeGroupedAssoc($systemid, $queryid)
    {
        $query = self::getQuery($systemid, $queryid);
        $res = self::getGroupedAssoc($query);

        return $res;

    }//end executeGrouped()


    public static function executeAssoc($systemid, $queryid, $col=NULL)
    {
        $query = self::getQuery($systemid, $queryid);
        $res   = self::getAssoc($query, $col);

        return $res;

    }//end executeAssoc()


    public static function executeAll($systemid, $queryid)
    {
        $query = self::getQuery($systemid, $queryid);
        $res = self::getAll($query);

        return $res;

    }//end executeAll()


    public static function executeOne($systemid, $queryid)
    {
        $query  = self::getQuery($systemid, $queryid);
        $result = self::getOne($query);

        // Oracle returns resourceid for LOB fields.
        // If result is a resource then retreive its contents.
        if (is_resource($result) === TRUE) {
            $result = stream_get_contents($result);
        }

        return $result;

    }//end executeOne()


    public static function executeQuery($systemid, $queryid=NULL)
    {
        $query = NULL;
        if (($systemid instanceof Query) === TRUE) {
            $dalQuery = $systemid;
            $query = $dalQuery->prepare();
        } else if ($queryid === NULL) {
            throw new DALException('No queryid provided for executeQuery.');
        } else {
            $dalQuery = self::getQuery($systemid, $queryid);
            $query = $dalQuery->prepare();
        }

        try {
            self::execPdoQuery($query);
            $dalQuery->releaseLobs();
        } catch (PDOException $e) {
            throw new DALException($e->getMessage());
        }

        $rows = (int)$query->rowCount();

        // DB2 returns -1 rows if no rows were affected.
        if ($rows === -1) {
            $rows = 0;
        }


        return $rows;

    }//end executeQuery()


    public static function getExecuteQuery($systemid, $queryid=NULL)
    {
        return self::executeQuery($systemid, $queryid);

    }//end getExecuteQuery()


    public static function getExecuteAll($systemid, $queryid)
    {
        return self::executeAll($systemid, $queryid);

    }//end getExecuteAll()


    public static function executeDALQuery(Query $query, $execMethod=NULL)
    {

        if ($execMethod === NULL) {
            $execMethod = $query->getExecMethod();
        }

        $methodArray = array(
                        'self',
                        'get'.ucfirst($execMethod),
                       );
        $result = call_user_func($methodArray, $query);
        return $result;

    }//end executeDALQuery()


    public static function execPdoQuery($query)
    {
        $query_log = 'unknown query';
        if ($query instanceof PDOStatement) {
            $query_log = $query->queryString;
        }
        self::_startQueryTimer($query_log);

        $dbh = self::getDb();

        if (!((gettype($query) !== 'PDOStatement') || (is_resource($query) && (get_resource_type($query) === 'oci8 statement')))) {
            throw new Exception('Invalid parameter 1 given to '.__FUNCTION__.'()');
        }

        if (self::getDbType() === 'oci') {
            // OCI:
            if(self::$_ociCommitOnSuccess){
                $result = oci_execute($query, OCI_COMMIT_ON_SUCCESS);
            }
            else {
                $result = oci_execute($query, OCI_DEFAULT);
            }
            if ($result === FALSE) {
                $oci_error = oci_error($query);
                throw new DALException('Unable to execute query: '.$oci_error['message']);
            }
            $rows = oci_num_rows($query);
        } else {
            $query->execute();
            $rows = (int)$query->rowCount();
        }

        self::_endQueryTimer();

        return $rows;

    }//end execPdoQuery()


    public static function executePdoAssoc($query, $col=NULL)
    {
        if (!((gettype($query) !== 'PDOStatement') || (is_resource($query) && (get_resource_type($query) === 'oci8 statement')))) {
            throw new Exception('Invalid parameter 1 given to '.__FUNCTION__.'()');
        }

        try {
            self::execPdoQuery($query);
        } catch (PDOException $e) {
            throw new DALException($e->getMessage());
        }

        if (self::getDbType() === 'oci') {
            // OCI:
            $dbh = self::getDb();

            if ($col === NULL) {
                $result = Array();
                while ($current_row = oci_fetch_array($query, OCI_ASSOC | OCI_RETURN_LOBS | OCI_RETURN_NULLS)) {
                    $result[] = array_change_key_case($current_row, CASE_LOWER);
                }
            } else {
                $result = Array();
                while ($current_row = oci_fetch_array($query, OCI_NUM | OCI_RETURN_LOBS | OCI_RETURN_NULLS)) {
                    $result[] = $current_row[$col];
                }
            }
        } else {
            $result = NULL;
            if ($col !== NULL) {
                $result = $query->fetchAll(PDO::FETCH_COLUMN, $col);
            } else {
                $result = $query->fetchAll(PDO::FETCH_ASSOC);
            }
        }

        return $result;

    }//end executePdoAssoc()


    public static function executePdoAll($query)
    {
        if (!((gettype($query) !== 'PDOStatement') || (is_resource($query) && (get_resource_type($query) === 'oci8 statement')))) {
            throw new Exception('Invalid parameter 1 given to '.__FUNCTION__.'()');
        }

        try {
            self::execPdoQuery($query);
        } catch (PDOException $e) {
            throw $e;
        }

        if (self::getDbType() === 'oci') {
            // OCI:
            $dbh = self::getDb();
            $result = Array();
            while ($current_row = oci_fetch_array($query, OCI_BOTH | OCI_RETURN_LOBS | OCI_RETURN_NULLS)) {
                $result[] = array_change_key_case($current_row, CASE_LOWER);
            }
        } else {
            $result = $query->fetchAll();
        }

        return $result;

    }//end executePdoAll()


    public static function executePdoGrouped($query)
    {
        if (!((gettype($query) !== 'PDOStatement') || (is_resource($query) && (get_resource_type($query) === 'oci8 statement')))) {
            throw new Exception('Invalid parameter 1 given to '.__FUNCTION__.'()');
        }

        $result = array();
        try {
            self::execPdoQuery($query);
        } catch (PDOException $e) {
            throw new DALException($e->getMessage());
        }

        while (TRUE) {
            if (self::getDbType() === 'oci') {
                // OCI:
                $row = oci_fetch_array($query, OCI_NUM | OCI_RETURN_LOBS | OCI_RETURN_NULLS);
                if (is_array($row)) {
                    $row = array_change_key_case($row, CASE_LOWER);
                }
            } else {
                $row = $query->fetch(PDO::FETCH_NUM);
            }

            if ($row === FALSE) break;

            if (isset($result[$row[0]]) === FALSE) {
                $result[$row[0]] = array();
            }

            $current = array();
            $i       = 1;
            while (isset($row[$i]) === TRUE) {
                $current[] = $row[$i];
                $i++;
            }

            $result[$row[0]][] = $current;
        }

        return $result;

    }//end executePdoGrouped()


    public static function executePdoGroupedAssoc($query)
    {
        if (!((gettype($query) !== 'PDOStatement') || (is_resource($query) && (get_resource_type($query) === 'oci8 statement')))) {
            throw new Exception('Invalid parameter 1 given to '.__FUNCTION__.'()');
        }

        $result = array();

        try {
            self::execPdoQuery($query);
        } catch (PDOException $e) {
            throw new DALException($e->getMessage());
        }

        while (TRUE) {
            if (self::getDbType() === 'oci') {
                // OCI:
                $row = oci_fetch_array($query, OCI_ASSOC | OCI_RETURN_LOBS | OCI_RETURN_NULLS);
                if (is_array($row)) {
                    $row = array_change_key_case($row, CASE_LOWER);
                }
            } else {
                $row = $query->fetch(PDO::FETCH_ASSOC);
            }

            if ($row === FALSE) break;

            // If we don't know the first field yet, find out what it is
            // because it should be the same for each row
            if (isset($first_field) === FALSE) {
                reset($row);
                $first_field = key($row);
            }
            $first_value = $row[$first_field];

            if (isset($result[$first_value]) === FALSE) {
                $result[$first_value] = array();
            }

            $current = $row;
            unset($current[$first_field]);
            $result[$first_value][] = $current;
            unset($row);
        }

        return $result;

    }//end executePdoGroupedAssoc()


    public static function executePdoOne($query)
    {
        if (!((gettype($query) !== 'PDOStatement') || (is_resource($query) && (get_resource_type($query) === 'oci8 statement')))) {
            throw new Exception('Invalid parameter 1 given to '.__FUNCTION__.'()');
        }

        try {
            self::execPdoQuery($query);
        } catch (PDOException $e) {
            throw new DALException($e->getMessage());
        }

        if (self::getDbType() === 'oci') {
            $result_row = oci_fetch_array($query, OCI_NUM | OCI_RETURN_LOBS | OCI_RETURN_NULLS);
            $result = $result_row[0];
        } else {
            $result = $query->fetchColumn();

            if (is_resource($result) === TRUE) {
                $result = stream_get_contents($result);
            }
        }

        return $result;

    }//end executePdoOne()


    public static function executeSql($sql)
    {

        $dbh  = self::getDb();

        if (self::getDbType() === 'oci') {
            // OCI:
            $query = oci_parse($dbh, $sql);
            if ($query === FALSE) {
                $oci_error = oci_error($query);
                throw new DALException('Unable to prepare query :'.$oci_error['code'].' '.$oci_error['message']);
            }

            self::execPdoQuery($query);
            $rows = oci_num_rows($query);

            if ($rows === FALSE) {

            }
        } else {
            try {
                self::_startQueryTimer($sql);
                $rows = $dbh->exec($sql);
                self::_endQueryTimer();
            } catch (PDOException $e) {
                throw new DALException('DBError!:'.$e->getMessage());
            }
        }
    

        return $rows;

    }//end executeSql()


    public static function executeSqlAssoc($sql, $col=NULL)
    {
        $dbh = self::getDb();

        if (self::getDbType() === 'oci') {
            // OCI:
            $query = oci_parse($dbh, $sql);
        } else {
            $query = $dbh->prepare($sql);
        }
        return self::executePdoAssoc($query, $col);

    }//end executeSqlAssoc()


    public static function executeSqlAll($sql)
    {
        $dbh = self::getDb();

        if (self::getDbType() === 'oci') {
            // OCI:
            $query = oci_parse($dbh, $sql);
        } else {
            $query = $dbh->prepare($sql);
        }
        $res = self::executePdoAll($query);

        return $res;

    }//end executeSqlAll()


    public static function executeSqlGrouped($sql)
    {
        $dbh = self::getDb();

        if (self::getDbType() === 'oci') {
            // OCI:
            $query = oci_parse($dbh, $sql);
        } else {
            $query = $dbh->prepare($sql);
        }
        $res = self::executePdoGrouped($query);

        return $res;

    }//end executeSqlGrouped()


    public static function executeSqlGroupedAssoc($sql)
    {
        $dbh = self::getDb();

        if (self::getDbType() === 'oci') {
            // OCI:
            $query = oci_parse($dbh, $sql);
        } else {
            $query = $dbh->prepare($sql);
        }
        $res = self::executePdoGroupedAssoc($query);

        return $res;

    }//end executeSqlGroupedAssoc()


    public static function executeSqlOne($sql)
    {
        $dbh = self::getDb();

        if (self::getDbType() === 'oci') {
            // OCI:
            $query = oci_parse($dbh, $sql);
        } else {
            $query = $dbh->prepare($sql);
        }
        $res = self::executePdoOne($query);

        return $res;

    }//end executeSqlOne()


    public static function executeQueries($sql)
    {
        // Split SQL statements.
        $queries = explode(';', $sql);
        if (empty($queries) === FALSE) {
            foreach ($queries as $query) {
                if (trim($query) !== '') {
                    self::executeSql($query);
                }
            }
        }

    }//end executeQueries()


    public static function query($sql)
    {
        $dbh    = self::getDb();
        self::_startQueryTimer($sql);
        $result = $dbh->query($sql);
        self::_endQueryTimer();
        return $result;

    }//end query()


    public static function beginTransaction()
    {
        $currentDb = self::$_currentDbConnId;
        $dbInfo    = self::$_dbhPool[$currentDb];

        if ($dbInfo['transactionSupport'] === TRUE) {
            $dbh = self::getDb();

            if (self::getDbType() === 'oci') {
                // OCI: Oracle does not require an explicit BEGIN statement.
                ;
            } else {
                $dbh->beginTransaction();
            }
            self::$_dbhPool[$currentDb]['inTransaction'] = TRUE;
        }

    }//end beginTransaction()


    public static function commit()
    {
        $currentDb = self::$_currentDbConnId;

        if (self::$_dbhPool[$currentDb]['inTransaction'] === TRUE) {
            $dbh = self::getDb();

            if (self::getDbType() === 'oci') {
                // OCI:
                $return = oci_commit($dbh);
                if ($return === FALSE) {
                    $oci_error = oci_error($dbh);
                    throw new DALException('Unable to commit on connection ID "'.$currentDb.'": '.$oci_error['code'].' '.$oci_error['message']);
                }
            } else {
                $dbh->commit();
            }
            self::$_dbhPool[$currentDb]['inTransaction'] = FALSE;
        }

    }//end commit()


    public static function rollBack()
    {
        $currentDb = self::$_currentDbConnId;

        if (self::$_dbhPool[$currentDb]['inTransaction'] === TRUE) {
            $dbh = self::getDb();

            if (self::getDbType() === 'oci') {
                // OCI:
                $return = oci_rollback($dbh);
                if ($return === FALSE) {
                    $oci_error = oci_error($dbh);
                    throw new DALException('Unable to roll back on connection ID "'.$currentDb.'": '.$oci_error['code'].' '.$oci_error['message']);
                }
            } else {
                $dbh->rollBack();
            }
            self::$_dbhPool[$currentDb]['inTransaction'] = FALSE;
        }

    }//end rollBack()


    public static function lastInsertId($sequenceName)
    {
        $dbh = self::getDb();
        return (int)$dbh->lastInsertId($sequenceName);

    }//end lastInsertId()


    /*
        Database Connection
    */


    public static function dbConnect(array &$dsn=NULL, $conn_id='db', $oci_force_new = FALSE)
    {
        try {
            if ($dsn === NULL) {
                // If DSN is not specified, get our DSN list; if a config entry
                // does not exist for this connection, there is a problem.
                $dsn = self::getDsnFromConfig($conn_id);
            }

            // Add the DSN which can be a single DSN or a DSN array (pool) to the DSN Manager's list
            require_once dirname(__FILE__).'/DSNManager.inc';
            DSNManager::addDSN($conn_id, $dsn);

            $new_dbh = FALSE;
            do {
                // Get a single DSN from the DSN Manager
                $dsn = DSNManager::getDSN($conn_id);
                // If we can not get a single DSN from the DSN Pool, throw an exception
                if (is_null($dsn) && DSNManager::isDSNPool($conn_id)) {
                    throw new Exception("Unable to connect to database '$conn_id': Fail to connect to any DB in the DSN Pool.");
                }

                $user = NULL;
                $pass = NULL;
                if (isset($dsn['user']) === TRUE) {
                    $user = $dsn['user'];
                }

                if (isset($dsn['password']) === TRUE) {
                    $pass = $dsn['password'];
                }

                $persistent = false;
                if (isset($dsn['persistent']) && $dsn['persistent'] == true) {
                    $persistent = true;
                }

                if ($dsn['type'] === 'oci') {
                    // OCI: Oracle in PDO is far too buggy to be considered usable (tested
                    // in 5.1.x to 5.3dev). Therefore we'll be resigned to using
                    // legacy OCI8 extension functions.
                    // use @ to suppress warning/error messages, it will be handled by ourself.

                    $oci_connect_fn = 'oci_connect';
                    if ($persistent) {
                        $oci_connect_fn = 'oci_pconnect';
                    }
                    if($oci_force_new){
                            $oci_connect_fn = 'oci_new_connect';
                    }
                    // Connect to the database with the specified character encoding (if supplied).
                    if (isset($dsn['encoding'])) {
                        $new_dbh = @$oci_connect_fn($dsn['user'], $dsn['password'], $dsn['DSN'], $dsn['encoding']);
                    } else {
                        $new_dbh = @$oci_connect_fn($dsn['user'], $dsn['password'], $dsn['DSN']);
                    }

                    if ($new_dbh === FALSE) {
                        $oci_error = oci_error();

                        $err_msg = 'Unable to connect to database "'.$conn_id.'": '.$oci_error['code'].' '.$oci_error['message'];
                        // If we can not connect to the DB specified by the single DSN in the DSN pool, log the error and try another DSN
                        if (DSNManager::isDSNPool($conn_id)) {
                            log_error($err_msg, E_USER_WARNING);
                            DSNManager::registerDSNFailure($conn_id); // Mark the current DSN so that it will not be selected by the DSN Pool again
                            continue;
                        } else {
                            // Throw exception immediately if this connection only has a single DSN
                            throw new Exception($err_msg);
                        }
                    }
                } else {

                    $extra_params = array();

                    if ($persistent) {
                        $extra_params[PDO::ATTR_PERSISTENT] = true;
                    }

                    if (isset($dsn['timeout']) && is_int($dsn['timeout'])) {
                        $extra_params[PDO::ATTR_TIMEOUT] = (int)$dsn['timeout'];
                    }
                    
                    try {
                        $new_dbh = new PDO($dsn['DSN'], $user, $pass, $extra_params);
                    } catch (Exception $conn_e) {
                        // If we can not connect to the DB specified by the single DSN in the DSN pool, log the error and try another DSN
                        if (DSNManager::isDSNPool($conn_id)) {
                            log_error("Unable to connect to database '$conn_id': ".$conn_e->getMessage(), E_USER_WARNING);
                            DSNManager::registerDSNFailure($conn_id); // Mark the current DSN so that it will not be selected by the DSN Pool again
                            continue;
                        } else {
                            // Throw exception immediately if this connection only has a single DSN
                            throw $conn_e;
                        }
                    }

                    $new_dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                    $new_dbh->setAttribute(PDO::ATTR_CASE, PDO::CASE_LOWER);
                    $new_dbh->setAttribute(PDO::ATTR_ORACLE_NULLS, PDO::NULL_EMPTY_STRING);

                    if ($dsn['type'] === 'mysql') {
                        $new_dbh->setAttribute(PDO::ATTR_EMULATE_PREPARES, TRUE);
                        $new_dbh->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, TRUE);
                    }

                }
            } while ($new_dbh === FALSE);
            
            self::$_dbhPool[$conn_id] = array(
                                             'dbh'      => $new_dbh,
                                             'dsn'      => $dsn['DSN'],
                                             'dbType'   => $dsn['type'],
                                             'userName' => $user,
                                             'password' => $pass,
                                        );

            // Check if this database supports db transactions.
            // We need to change first because transaction functions won't
            // like no current database
            #self::changeDb($conn_id);

            #if (self::transactionSupport($conn_id) === TRUE) {
                self::$_dbhPool[$conn_id]['transactionSupport'] = TRUE;
            #} else {
            #    self::$_dbhPool[$conn_id]['transactionSupport'] = FALSE;
            #}

            #self::restoreDb();

            self::$_dbhPool[$conn_id]['inTransaction'] = FALSE;

        } catch (PDOException $e) {
            throw new DALException('DBError!:'.$e->getMessage());
        }

        return self::$_dbhPool[$conn_id]['dbh'];

    }//end dbConnect()


    public static function changeDb($conn_id)
    {
        if (self::dbConnected($conn_id) === FALSE) {
            throw new DALException('Connection "'.$conn_id.'" must be connected before it can be changed to.');
        }

        array_push(self::$_dbStack, $conn_id);
        self::$_currentDbConnId = $conn_id;

    }//end changeDb()


    public static function restoreDb()
    {
        if (empty(self::$_dbStack) === TRUE) {
            throw new DALException('The database connection stack is empty; there is no previous connection to restore.');
        }

        array_pop(self::$_dbStack);

        if (empty(self::$_dbStack) === TRUE) {
            self::$_currentDbConnId = '';
        } else {
            self::$_currentDbConnId = self::$_dbStack[count(self::$_dbStack) - 1];
        }

    }//end restoreDb()


    public static function getCurrentDbId()
    {
        if (empty(self::$_dbStack) === TRUE) {
            throw new DALException('The database connection stack is empty.');
        }

        return self::$_currentDbConnId;

    }//end getCurrentDbId()


    public static function transactionSupport($conn_id=NULL)
    {
        try {
            // Test if db transactions work.
            $dbh = self::getDb($conn_id);
            $dbh->beginTransaction();
            self::$_dbhPool[$conn_id]['inTransaction'] = TRUE;
        } catch (PDOException $e) {
            return FALSE;
        }

        // Close dbt.
        self::rollBack();
        return TRUE;

    }//end transactionSupport()


    public static function dbClose($conn_id)
    {
        if (isset(self::$_dbhPool[$conn_id]) === FALSE) {
            // Can't close a connection that isn't open...
            throw new DALException('Connection with ID "'.$conn_id.'" cannot be closed because a connection of that ID is not open.');
        } else if (array_search($conn_id, self::$_dbStack) !== FALSE) {
            // If this connection is still in the database stack, we should not
            // allow them to close the connection.
            throw new DALException('Connection with ID "'.$conn_id.'" cannot be closed because it still exists in the stack.');
        } else {
            if (self::getDbType(FALSE, $conn_id) === 'oci') {
                // OCI: Must close Oracle connections first
                $return = oci_close(self::$_dbhPool[$conn_id]['dbh']);
                if ($return === FALSE) {
                    $oci_error = oci_error(self::$_dbhPool[$conn_id]['dbh']);
                    throw new DALException('Unable to close connection ID "'.$currentDb.'": '.$oci_error['code'].' '.$oci_error['message']);
                }
            }

            unset(self::$_dbhPool[$conn_id]);
        }

    }//end dbClose()


    public static function dbConnected($conn_id=NULL)
    {
        if ($conn_id === NULL) {
            return !empty(self::$_dbhPool);
        } else {
            return isset(self::$_dbhPool[$conn_id]);
        }

    }//end dbConnected()


    public static function getDsn($conn_id=NULL)
    {
        if ($conn_id === NULL) {
            $conn_id = self::$_currentDbConnId;
        }

        if (isset(self::$_dbhPool[$conn_id]) === FALSE) {
            $error = 'DAL configuration not defined for connection ID "'.$conn_id.'".';
            throw new DALException($error);
        } else {
            $dsn = self::$_dbhPool[$conn_id];
        }

        return $dsn;

    }//end getDsn()



    public static function getDsnFromConfig($conn_id)
    {
        $dsn = include dirname(__FILE__).'/DALConf.inc';
        if (isset($dsn[$conn_id]) === FALSE) {
            $error = 'DAL configuration not defined for connection ID "'.$conn_id.'".';
            throw new DALException($error);
        } else if (isset($dsn[$conn_id]['DSN']) === FALSE) {
            $error = 'DAL configuration for connection ID "'.$conn_id.'" does not define a DSN.';
            throw new DALException($error);
        }

        return $dsn[$conn_id];

    }//end getDsnFromConfig()


    public static function getDbName($conn_id)
    {
        if (self::$_[$conn_id] === NULL) {
            // Try to get the database name from DSN string.
            $dsn = self::getDsn();
            if (isset($dsn['DSN']) === TRUE) {
                $matches = array();
                $reg     = '/.*dbname=([a-zA-Z0-9_]+)[;]?/i';
                preg_match($reg, $dsn['DSN'], $matches);
                if (isset($matches[1]) === TRUE) {
                    self::$_currentDbName = $matches[1];
                }
            }
        }

        return self::$_currentDbName;

    }//end getDbName()


    public static function getDb($conn_id=NULL)
    {
        if ($conn_id === NULL) {
            if (empty(self::$_dbStack) === TRUE) {
                throw new DALException('Cannot get current database because no current database exists.');
            } else {
                $conn_id = self::$_currentDbConnId;
            }
        }

        // If we were provided a connection ID and it doesn't exist, try
        // connecting to it using DALConf settings; otherwise, fail.
        if (isset(self::$_dbhPool[$conn_id]) === FALSE) {
            try {
                $dsn = NULL;
                self::dbConnect($dsn, $conn_id);
            } catch (DALException $e) {
                throw new DALException($e->getMessage());
            }
        }

        return self::$_dbhPool[$conn_id]['dbh'];

    }//end getDb()


    public static function getDbType($readable=FALSE, $conn_id=NULL)
    {
        if ($conn_id === NULL) {
            $conn_id = self::$_currentDbConnId;
        }

        if (isset(self::$_dbTypes[$conn_id]) === FALSE) {
            //$conf = include dirname(__FILE__).'/DALConf.inc';
            $dbInfo = self::$_dbhPool[$conn_id];
            $dbh = $dbInfo['dbh'];

            $oci_connection_types = array (
                'oci8 connection',
                'oci8 persistent connection'
            );

            if (is_resource($dbh) && in_array(get_resource_type($dbh), $oci_connection_types, true)) {
                // OCI: The connection handle for OCI is a resource and not an object
                $dbType = 'oci';
            } else {
                $dbType = $dbh->getAttribute(PDO::ATTR_DRIVER_NAME);
            }

            self::$_dbTypes[$conn_id] = $dbType;
        } else {
            $dbType = self::$_dbTypes[$conn_id];
        }

        if ($readable === TRUE) {
            return self::$_dbNames[$dbType];
        } else {
            return $dbType;
        }

    }//end getDbType()


    public static function requireQueryClass($systemid)
    {
        $classFile = $systemid.'Queries.inc';
        $path      = self::getOvenPath($systemid).'/'.$classFile;

        require_once($path);

    }//end requireQueryClass()


    public static function getOvenPath($system=NULL)
    {
        $path = dirname(__FILE__).'/Oven';

        if ($system !== '') {
            $path .= '/'.$system;
        }

        return $path;

    }//end getOvenPath()


    public static function getQueryStorePath()
    {
        $path = dirname(__FILE__).'/QueryStore';
        return $path;

    }//end getQueryStorePath()


    public static function getQueryObject($id)
    {
        $queryStore = self::getQueryStorePath();
        $path       = $queryStore.'/'.$id.'.qob';
        if (file_exists($path) === FALSE) {
            $msg = 'Query object doesn\'t exist';
            throw new DALException($msg);
        }

        $content  = file_get_contents($path);
        $queryObj = unserialize($content);
        return $queryObj;

    }//end getQueryObject()


    public static function getSqlQueriesFromFile($path)
    {
        $queries = array();
        if (file_exists($path) === TRUE) {
            $fileContents = file_get_contents($path);
            $queries      = explode('--$$', $fileContents);
        }

        return $queries;

    }//end getSqlQueriesFromFile()


    public static function isDALQuery($query)
    {
        if (($query instanceof Query) === TRUE) {
            return TRUE;
        }

        return FALSE;

    }//end isDALQuery()


    protected static function _startQueryTimer($query)
    {
        if (self::$_logQueries === TRUE || defined('SQ_IN_PERFORMANCE_TIMING')) {
            self::$_currentQueryLog = array();
            if (is_string($query) === true) {
                self::$_currentQueryLog['id']  = 'sql';
                self::$_currentQueryLog['sql'] = $query;
            } else {
                self::$_currentQueryLog['id']  = $query->getQueryid();
                self::$_currentQueryLog['sql'] = $query->getSql();
            }
            self::$_currentQueryLog['start'] = microtime(TRUE);
        }

    }//end _startQueryTimer()


    protected static function _endQueryTimer()
    {
        if (self::$_currentQueryLog !== NULL || defined('SQ_IN_PERFORMANCE_TIMING')) {
            self::$_queryLog[] = (microtime(TRUE) - self::$_currentQueryLog['start']);
            if (isset($GLOBALS['THE_CONSTRUCT']) === TRUE) {
                $GLOBALS['THE_CONSTRUCT']->recordDatabaseQuery(self::$_currentQueryLog['sql'], self::$_currentQueryLog['start'], microtime(TRUE));
            }
        }
        self::$_currentQueryLog = NULL;

    }//end _endQueryTimer()


    public static function getLoggedQueries()
    {
        return self::$_queryLog;

    }//end getLoggedQueries()
    
    public static function clearLoggedQueries()
    {
        self::$_queryLog = Array();
        return;

    }//end getLoggedQueries()


    public static function setOciCommitOnSuccess ($switch) {
        self::$_ociCommitOnSuccess = $switch;
    }

}//end class


?>