Ego_Sql_oci.php

gehe zur Dokumentation dieser Datei

<?php
require_once('base/Ego_Sql_Abstract.php');
 
class Ego_Sql_oci extends Ego_Sql_Abstract
{
    static  $_staticOciHandle; 
    private  $_dbHandle; 
    private  $_queryHandle; 
    private  $_limit; 
    private  $_lobStm; 
    private  $_lobStmId; 
    private  $_mode=OCI_DEFAULT; 
    private  $_user; 
    function __destruct()
    {
        if ($this->_lobStm)
        {
            //echo " Dlob ";
            @oci_free_statement($this->_lobStm);
            unset($this->_lobStm);
        }
        if ($this->_queryHandle)
        {
            //echo " Dquery ";
            @oci_free_statement($this->_queryHandle);
            unset($this->_queryHandle);
        }
    }
 
    function connect($database='', $host='', $user='', $password='', $charset='AL32UTF8')
    {
        if (func_num_args()==0)
        {
            if ($GLOBALS['egotec_conf']['oci']) {
                $GLOBALS['egotec_conf']['db'] = $GLOBALS['egotec_conf']['oci'];
            }
            if (Ego_Sql_oci::$_staticOciHandle)
            { // Nur die EGOTEC Standardverbindung wird global gespeichert.
                $this->_dbHandle = Ego_Sql_oci::$_staticOciHandle;
                $this->_user = strtoupper($GLOBALS['egotec_conf']['db']['user']);
            } else {
                $this->_dbHandle = oci_pconnect( // Der pconnect erscheint instabil.
                    $GLOBALS['egotec_conf']['db']['user'],
                    $GLOBALS['egotec_conf']['db']['password'],
                    $GLOBALS['egotec_conf']['db']['database'],
                    'AL32UTF8' // UTF8 ist bei Oracle eigentlich CESU8 und soll nicht verwendet werden.
                );
                Ego_Sql_oci::$_staticOciHandle = $this->_dbHandle; // Nur die EGOTEC Standardverbindung wird global gespeichert.
                $this->_user = strtoupper($GLOBALS['egotec_conf']['db']['user']);
            }
        } else {
            $this->_dbHandle = oci_connect($user, $password, $database, $charset);
            $this->_user = strtoupper($user);
            if ( !$this->_dbHandle )
            { // abwärtskompatibilität bis 4.2.25, die Parameter wurden in der falschen Reihenfolge übergeben.
                $this->_dbHandle = oci_connect($host, $user, $password, $database);
                $this->_user = strtoupper($host);
            }
            if ( !$this->_dbHandle )
            { // Wenn der DB Handle nicht besteht wird eine Exception geworfen.
                throw new Ego_Sql_Exception( 'Konnte keine Datenbankverbindung herstellen.', Ego_Sql_Exception::CONNECT_ERROR );
            }
        }
    }
 
    function query($query, $appendCurrent = false)
    {
        // SQL compatibility
        if (strpos($query, 'LEFT(')!==false) {
            $query = preg_replace('#left\‍((.*?),(.*?)\‍)#i', 'substr($1,0,$2)', $query);
        }
 
        set_time_limit(0);
        if ($appendCurrent) {
            $this->currentQuery .= $query;
        } else {
            $this->currentQuery = $query;
        }
        $this->currentBind = array();
        $this->_queryHandle = oci_parse($this->_dbHandle, $query);
        if ($this->_queryHandle===false || !@oci_execute($this->_queryHandle, $this->_mode))
        { // Die Abfrage ist fehlgeschlagen.
            $this->_halt();
        }
        oci_set_prefetch($this->_queryHandle, 100); // So viele Ergebnisse wie möglich übertragen.
        if (!$this->_transaction) {
            oci_commit($this->_dbHandle);
        }
        $this->_currentRow = -1;
        return $this->_queryHandle;
    }
 
    private function _prepare($query)
    {
        $this->currentBind = array();
        $index = 0;
        while (($pos=strpos($query, '?'))!==false) // Das erste Fragezeichen suchen
        {
            $query = substr($query, 0, $pos).':'.($index++).substr($query, $pos+1); // und ersetzen.
        }
        $this->currentQuery = $query;
        return oci_parse($this->_dbHandle, $query);
    }
 
    private function _execute($queryHandle, $values, $blobs=array())
    {
        $this->currentBind = $values;
        $index = 0;
        foreach ($values as $key => $val)
        { // Da der letzte Parameter als Referenz übergeben wird, kann nicht $val angegeben werden.
            oci_bind_by_name($queryHandle, ':'.$index++, $values[$key]);
        }
        if (!$blobs)
        {
            if (!@oci_execute($queryHandle, $this->_mode))
            {
                $this->_halt();
            }
            if (!$this->_transaction)
            {
                oci_commit($this->_dbHandle);
            }
        } else {
            $descriptors = array();
            foreach ($blobs as $key => $val)
            { // LOBs binden.
                $descriptors[$key] = oci_new_descriptor($this->_dbHandle, OCI_D_LOB);
                oci_bind_by_name($queryHandle, ':'.$index++, $descriptors[$key], -1, OCI_B_CLOB);
            }
            if (!oci_execute($queryHandle, OCI_DEFAULT)) // Noch kein Commit, deswegen wird OCI_DEFAULT übergeben.
            {
                $this->_halt();
            }
            foreach ($blobs as $key => $val)
            { // LOBs Inhalte übertragen.
                $descriptors[$key]->write($val);
            }
            if (!$this->_transaction)
            {
                oci_commit($this->_dbHandle);
            }
            foreach ($descriptors as $descriptor)
            { // LOBs freigeben.
                $descriptor->free();
            }
        }
        $error = oci_error($queryHandle);
        if (!$queryHandle || $error)
        { // Die Abfrage ist fehlgeschlagen.
            $this->_halt();
        }
        $this->_currentRow = -1;
        return $queryHandle;
    }
 
    function dropTable($table)
    {
        $this->query('DROP TABLE "'.strtoupper($table).'"');
    }
 
    protected function _nextRecord()
    {
        if (!$this->_queryHandle)
        {
            return $this->Record = null;
        }
        $this->_currentRow++;
        if ($this->_limit<0 || $this->_limit--)
        { // Ein Limit beachten.
            $this->Record = oci_fetch_assoc($this->_queryHandle);
            if ($this->Record)
            {
                foreach ($this->Record as $key => $val)
                {
                    if (is_object($val))
                    {
                        $this->Record[$key] = $val->load();
                    }
                }
                if ($this->_lobStm)
                {
                    oci_bind_by_name($this->_lobStm, ':'.$this->_lobStmId, $this->Record[strtoupper($this->_lobStmId)]);
                    oci_execute($this->_lobStm, $this->_mode);
                    $lob_record = oci_fetch_assoc($this->_lobStm);
                    if (!$lob_record)
                    {
                        return $this->Record = array();
                    }
                    foreach ($lob_record as $key=>$val)
                    {
                        if (is_object($val))
                        {
                            $this->Record[$key] = $val->load();
                        }
                    }
                }
                return $this->Record = array_change_key_case($this->Record);
            }
        }
        return $this->Record = null;
    }
 
    protected function _numRecords()
    {
        if ($this->_queryHandle)
        { // Oracle kennt kein num_rows. Diese Funktion muss daher simuliert werden.
            $GLOBALS['stats']['db_select']++;
            $query = 'SELECT COUNT(*) FROM ('.$this->currentQuery.')';
            $statement = oci_parse($this->_dbHandle, $query);
            if ($this->currentBind)
            {
                foreach ($this->currentBind as $key => $val)
                {
                    oci_bind_by_name($statement, $key, $this->currentBind[$key]);
                }
            }
            oci_execute($statement, $this->_mode);
            $row = oci_fetch_row($statement);
            oci_free_statement($statement);
            return (int)$row[0];    // unter Oracle wird sonst ein String ausgegeben
        } else {
            return 0;
        }
    }
 
    protected function _selectString($query)
    {
        if ($query['bitand']) {
            if (empty($query['where'])) {
                $query['where'] = '1=1';
            }
            foreach ($query['bitand'] as $bit) {
                $query['where'] .= ' AND BITAND('.$bit[0].', '.$bit[1].') = '.$bit[2];
            }
        }
        return 'SELECT '.($query['distinct']?'DISTINCT ':'')
            .($query['fields']?:'*').(isset($query['fields2'])&&!empty($query['fields2'])?','.(is_array($query['fields2'])?implode(',',$query['fields2']):$query['fields2']):'')
            ."\nFROM ".($query['table']?:$query['from'])
            .($query['table2']?($query['table']?',':'').$query['table2']:'')
            .($query['inner']?' INNER JOIN '.(is_array($query['inner'])?
                implode(' INNER JOIN ', $query['inner']):$query['inner']):'')
            .($query['join']?"\nLEFT JOIN ".(is_array($query['join'])?
                implode("\nLEFT JOIN ", $query['join']):$query['join']):'')
            .($query['where']?"\nWHERE ".$query['where']:'')
            .($query['group']?"\nGROUP BY ".$query['group']:'')
            .($query['having']?' HAVING '.$query['having']:'')
            .($query['order']?"\nORDER BY ".$query['order']:'');
    }
 
    protected function _select($query)
    {
        if ($query['field_as'])
        {
            foreach ($query['field_as'] as $k=>$v)
            {
                if ($query['field_as_bitand'][$k]) {
                    foreach ($query['field_as_bitand'][$k] as $bit) {
                        $v .= ' AND BITAND('.$bit[0].','.$bit[1].')='.$bit[2];
                    }
                }
                $query['fields2'][] = '('.$v.') AS '.$k;
            }
            unset($query['field_as']);
        }
 
        unset($this->_lobStm);
        if (($query['fields']=='id' || substr($query['fields'], 0, 3)=='id,') && $query['table'])
        { // LOBs Umgehung.
            $tables = explode(',', $query['table']);
            $query['fields'] = $tables[sizeof($tables)-1].'.*';
        }
        if ($query['fields'] && $query['fields'][strlen($query['fields'])-5]=='_'
            && substr($query['fields'], strlen($query['fields'])-2)=='.*')
        {
            $lob_table = substr($query['fields'], 0, strlen($query['fields'])-2);
            $query['fields'] = $lob_table.'.id,'.$lob_table.'.name,'.$lob_table.'.title,'.$lob_table.'.url,'.$lob_table.'.short,'.
                $lob_table.'.a_date,'.$lob_table.'.c_date,'.$lob_table.'.m_date,'.$lob_table.'.a_user,'.$lob_table.'.c_user,'.$lob_table.'.m_user,'.
                $lob_table.'.type,'.$lob_table.'.children_order,'.$lob_table.'.order_field,'.
                $lob_table.'.nav_hide,'.$lob_table.'.inactive,'.$lob_table.'.cache,'.$lob_table.'.release_from,'.$lob_table.'.release_until,'.
                $lob_table.'.workflow,'.$lob_table.'.workflow_state,'.$lob_table.'.deleted';
            $lob_query = 'select content, extra from '.$lob_table.' where id=:id';
            $this->_lobStm = oci_parse($this->_dbHandle, $lob_query);
            $this->_lobStmId = 'id';
        }
        if (
            strpos($query['fields'], 'egotec_user.*')===0 ||
            ( $query['union'] && $query['union'][0]['fields']=='egotec_user.*' )
        ) {
            $lob_table='egotec_user';
            if ($query['union'])
            {
                for($i=0; $i<sizeof($query['union']); $i++)
                {
                    $query['union'][$i]['fields'] = $lob_table.'.user_id,'.$lob_table.'.username,'.
                        $lob_table.'.email,'.$lob_table.'.sid,'.
                        $lob_table.'.multiple_login,'.$lob_table.'.last_login,'.$lob_table.'.no_admin,'.$lob_table.'.user_c_date';
                }
            } else {
                $add_fields = substr($query['fields'], strlen('egotec_user.*'));
                $query['fields'] = $lob_table.'.user_id,'.$lob_table.'.username,'.
                    $lob_table.'.email,'.$lob_table.'.sid,'.
                    $lob_table.'.multiple_login,'.$lob_table.'.last_login,'.$lob_table.'.no_admin,'.$lob_table.'.user_c_date'.
                    $add_fields;
            }
            $lob_query = 'select extra from '.$lob_table.' where user_id=:user_id';
            $this->_lobStm = oci_parse($this->_dbHandle, $lob_query);
            $this->_lobStmId = 'user_id';
        }
 
        $query['where'] = str_replace("\\'", "''", $query['where']); // @todo Diese Zeile wird mit prepared Statements unnötig.
 
        $this->_cached = false;
        if ($query['union'])
        {
            $unions = array();
            $order = $query['order'];
            unset($query['order']); // Oracle erlaubt kein order in den selects.
            if (!$query['fields'] || $query['fields']=='*' || $query['fields']==$query['table'].'.*')
            {
                $order = str_replace(
                    array('id', 'name', 'a_date', 'c_date', 'type', 'order_field', 'workflow_state'),
                    array(0, 2, 6, 7, 10, 12, 19),
                    $order
                );
            } elseif ($order) {
                $fields = $query['fields'].($query['fields2']?(is_array($query['fields2'])?implode(',',$query['fields2']):','.$query['fields2']):'');
                $fields = preg_replace('#\‍(SELECT.*?\‍) AS ([^,]+)#ims', "\\1", $fields);
                $fields = explode(',', $fields);
                array_unshift($fields, '#####'); // Zählung beginnt bei 1 und Indizes in Arrays bei 0.
                $order = str_replace(array_values($fields), array_keys($fields), $order);
            }
            foreach ($query['union'] as $union)
            {
                $union_join = $union['join']; // Falls union[join] leer ist,
                $union = array_merge($query, $union); // steht nach dem array_merge das query[join] drin und dann wird das verdoppelt. Das darf nicht sein.
                $union['join'] = $union_join?$union_join:array();
                $union['where'] = $query['where']?'('.$query['where'].') AND ('.$union['where'].')':$union['where'];
                $union['join'] = $query['join']?array_merge_recursive($query['join'], $union['join']):$union['join'];
                $unions[] = $this->_selectString($union);
            }
            $s = implode("\nUNION\n", $unions).($order?"\nORDER BY ".$order:'');
        } else {
            $s = $this->_selectString($query);
        }
 
        if ($query['bind'])
        {
            foreach ($query['bind'] as $k=>$v)
            {
                $s = str_replace(':'.$k, (!in_array($k, ['name','path','s','u','username','dir']) && is_numeric($v))?$v:'\''.str_replace(array('\\', '\''), array('\\\\', '\'\''), $v).'\'', $s);
            }
            $return = $this->query($s);
        } else {
            $return = $this->query($s);
        }
 
        if ($query['limit'])
        { // Limitbehandlung
            $limit = explode(',', $query['limit']);
            if (sizeof($limit)>1)
            {
                $offset = $limit[0];
                while ($offset>0)
                { // Die ersten $offset Einträge ignorieren.
                    if (!oci_fetch($this->_queryHandle))
                    {
                        unset($this->_queryHandle);
                        $return = false;
                        break;
                    }
                    $offset--;
                }
                $this->_limit = $limit[1];
            } else {
                $this->_limit = $limit[0];
            }
        } else {
            $this->_limit = -1;
        }
        return $return;
    }
 
    function delete($query)
    {
        assert($query['table']||$query['from']);
        $s = 'DELETE '
            .($query['fields']?$query['fields'].' ':'')
            .'FROM '
            .($query['table']?$query['table']:$query['from'])
            .($query['inner']?' INNER JOIN '.(is_array($query['inner'])?
                    implode(' INNER JOIN ', $query['inner']):$query['inner']):'')
            .($query['join']?' LEFT JOIN '.(is_array($query['join'])?
                    implode(' LEFT JOIN ', $query['join']):$query['join']):'')
            .($query['where']?' WHERE '.$query['where']:'');
        if ($query['bind'])
        {
            foreach ($query['bind'] as $k=>$v)
            {
                $s = str_replace(':'.$k, ($k!='name' && $k!='u' && $k!='s' && $k != 'dir' && is_numeric($v))?$v:'\''.str_replace(array('\\', '\''), array('\\\\', '\'\''), $v).'\'', $s);
            }
        }
        return $this->query($s);
    }
 
    function insert($query)
    {
        if (isset($query['key']))
        {
            $query['set'] = array_combine($query['key'], $query['val']);
        }
        $keys = array();
        $values = array();
        $names = array();
        if (isset($query['set']))
        {
            foreach ($query['set'] as $k => $v)
            {
                switch ($k)
                {
                    case 'content':
                    case 'extra':
                        $keys[] = strtoupper($k);
                        $names[] = 'EMPTY_CLOB()';
                        $blobs[$k] = $v;
                        break;
                    default:
                        $names[] = '?';
                        $keys[] = strtoupper($k);
                        $values[] = $v;
                }
            }
        }
        if ($query['replace'])
        { // Einen eventuell vorhandenen Eintrag löschen.
            if (empty($query['primary'])) {
                $query['primary'] = array_keys($this->getPrimary($query['table']));
            }
            $where = array();
            foreach ($keys as $key)
            {
                if (in_array(strtolower($key), $query['primary']))
                {
                    $val = $query['set'][strtolower($key)];
                    $where[] = $key.'='.(strtolower($key)!='dir' && is_numeric($val)?$val:"'$val'");
                }
            }
            $this->delete(array('table' => $query['table'], 'where' => implode(' AND ', $where)));
        }
        $insert_table = $query['table'].'-'.sizeof($keys).'-'.$query['replace'];
        if ($this->_insertTable != $insert_table) {
            $this->currentQuery = $query;
            $s = 'INSERT INTO '.$query['table'].' ("'.implode('","', $keys).'") VALUES ('.implode(',', $names).')';
            if ($blobs) {
                $s.= ' RETURNING '.implode(',', array_keys($blobs)).' INTO ?'.str_repeat(',?', sizeof($blobs)-1);
            }
            $this->_insertstmt = $this->_prepare($s);
            $this->_insertTable = $insert_table;
        }
        $this->currentQuery = print_r($query, true);
        return $this->_execute($this->_insertstmt, $values, $blobs);
    }
 
    function update($query)
    {
        if (isset($query['key']))
        {
            $query['set'] = array_combine($query['key'], $query['val']);
        }
        $set = array();
        $set2 = array();
        $values = array();
        if (isset($query['set']))
        {
            foreach ($query['set'] as $k => $v)
            {
                switch ($k)
                {
                    case 'content':
                    case 'extra':
                        $set2[] = $k.'=EMPTY_CLOB()';
                        $blobs[$k] = $v;
                        break;
                    default:
                        $set[] = $k.'=?';
                        $values[] = $v;
                }
            }
        }
        if (isset($query['set_f']))
        {
            foreach ($query['set_f'] as $k => $v)
            {
                $set[] = $k.'='.$v;
            }
        }
        $set = array_merge($set, $set2);
        $s = 'UPDATE '.$query['table'].' SET '.implode(',', $set).($query['where']?' WHERE '.$query['where']:'');
        if ($blobs)
        {
            $s.= ' RETURNING '.implode(',', array_keys($blobs)).' INTO ?'.str_repeat(',?', sizeof($blobs)-1);
        }
        if ($query['bind'])
        {
            foreach ($query['bind'] as $k=>$v)
            {
                $s = str_replace(':'.$k, ($k!='name' && $k!='u' && $k!='s' && $k!='dir' && is_numeric($v))?$v:'\''.str_replace(array('\\', '\''), array('\\\\', '\'\''), $v).'\'', $s);
            }
        }
        $this->_queryHandle = $this->_prepare($s);
        return $this->_execute($this->_queryHandle, $values, $blobs);
    }
 
    private function _changeType($type)
    {
        $type = str_replace('/*bin*/', '', $type);
        $type_array = explode(' ', $type);
 
        switch ($type_array[0])
        { // Typkonvertierung
            case 'bigint':
            case 'tinyint':
                $type = 'int';
                break;
            case 'datetime':
                $type = 'char(19)';
                break;
            case 'enum':
                $type = 'varchar2(255)';
                break;
            case 'varchar(255)':
                $type = 'varchar2(500)'; // Oracle zählt auch in UTF-8 in Bytes!
                break;
            case 'smalltext':
                $type = 'varchar2(3900)';
                break;
            case 'text':
                $type = 'clob';
        }
        return $type;
    }
 
    function createTable($table, $struct, $drop_flag=true, $notexists_flag=false)
    {
        if ($drop_flag && $this->tableExists($table)) // Wenn die Tabelle existiert,
        {
            $this->query('DROP TABLE '.strtoupper($table)); // dann wird diese gelöscht.
        }
 
        if ($notexists_flag && $this->tableExists($table)) // Wenn die Tabelle existiert,
        {
            return; // dann wird nichts gemacht.
        }
 
        $query = array();
        $index = array();
        foreach ($struct as $name => $type)
        {
            $key = explode(' ', $name);
            $type = $this->_changeType($type);
            if (sizeof($key)==1)
            { // Ein Feld erzeugen.
                $query[] = '"'.$name.'" '.$type;
            } else {
                $val = preg_replace('/\‍([^)]+\‍)/', '', $type);
 
                if ($table=='egotec_url' && $key[0]=='PRIMARY') {
                    $key[0] = 'KEY'; // Bei der egotec_url kann bei Oracle kein Primary Key gesetzt werden, da dir auch leer sein kann.
                }
 
                switch ($key[0])
                {
                    case 'PRIMARY':
                        $query[] = 'PRIMARY KEY ("'.str_replace(',', '","', $val).'")';
                        break;
                    case 'KEY':
                        $index_name = $table.'_'.$key[1];
                        if (strlen($index_name)>24)
                        { // Namen von Indizes dürfen in Oracle höchstens 24 Zeichen lang sein.
                            $index_name_array = explode('_', $index_name);
                            $index_name_short = '';
                            $part_length = (integer)(24/sizeof($index_name_array));
                            foreach ($index_name_array as $index_name_part)
                            {
                                $index_name_short.= substr($index_name_part, 0, $part_length);
                            }
                            $index_name = $index_name_short.substr(md5($index_name), 0, 24-strlen($index_name_short));
                        }
                        $index[] = 'CREATE INDEX '.$index_name.' ON '.$table.' ("'.str_replace(',', '","', $val).'") NOLOGGING'; // testImport 18.6s > 16.3s
                        break;
                    case 'UNIQUE':
                        $query[] = 'UNIQUE ("'.$type.'")';
                }
            }
        }
        $s = strtoupper('create table '.$table.' ('.implode(',', $query).')');
        $this->query($s);
        foreach ($index as $query)
        {
            $this->query(strtoupper($query));
        }
    }
 
    function alterTable($table, $struct)
    {
        $query = array();
        foreach ($struct as $name => $type)
        {
            $key = explode(' ', $name);
            $type = $this->_changeType($type);
            if (sizeof($key)==1)
            { // Ein Feld erzeugen.
                $query[] = 'ADD '.$name.' '.$type;
            } else {
                switch ($key[0])
                {
                    case 'PRIMARY':
                        $query[] = 'ADD PRIMARY KEY ('.$type.')';
                        break;
                    case 'KEY':
                        $query[] = 'ADD KEY '.$key[1].' ('.$type.')';
                        break;
                    case 'UNIQUE':
                        $query[] = 'ADD UNIQUE KEY '.$key[1].' ('.$type.')';
                        break;
                    case 'CHANGE':
                        if ($key[1] == $key[2]) {
                            $query[] = 'MODIFY '.$key[1].' ('.$type.')';
                        } else {
                            $query[] = 'RENAME '.$key[1].' TO '.$key[2];
                        }
                }
            }
        }
        foreach ($query as $q) {
            $q = 'ALTER TABLE '.$table.' '.$q;
            $this->query($q);
        }
        return true;
    }
 
    private function _halt()
    {
        if ($this->_queryHandle)
        {
            $error = oci_error($this->_queryHandle);
        } else {
            $error = oci_error();
        }
        $error_str = print_r($error, true);
        throw new Ego_Sql_Exception($this->currentQuery."\n".$error_str, Ego_Sql_Exception::QUERY_ERROR);
    }
 
    function begin()
    {
        oci_commit($this->_dbHandle);
        $this->_transaction = true;
    }
 
    function commit()
    {
        $this->_transaction = false;
        oci_commit($this->_dbHandle);
    }
 
    function rollback()
    {
        if ($this->_transaction) { // Die Transaktion nur zurücksetzen wenn eine gestartet wurde.
            oci_rollback($this->_dbHandle);
            $this->_transaction = false;
        }
    }
 
    public function showColumns($table)
    {
        if (!$table) return array();
        $table = strtoupper($table);
        $stmt = $this->query("SELECT COLUMN_NAME, DATA_TYPE FROM user_tab_columns WHERE TABLE_NAME ='$table'");
        $cols = array();
        while($record = oci_fetch_assoc($stmt))
        {
            $type = strtolower($record['DATA_TYPE']);
            switch ($type) {
                case 'number':
                    $type = 'int(11)';
                    break;
                case 'varchar2':
                    $type = 'varchar(255)';
                    break;
                case 'char':
                    $type = 'char(32)';
                    break;
            }
            $cols[] = array(
                'field' => strtolower($record['COLUMN_NAME']),
                'type' => $type
            );
        }
        oci_free_statement($stmt);
        return $cols;
    }
 
    public function tableExists($table)
    {
        if (!$table) {
            return false;
        }
        /*$this->select(array(
            'table' => 'all_tables',
            'where' => 'table_name=:table AND owner=:owner',
            'bind'  => array(
                'table' => strtoupper($table),
                'owner' => $this->_user
            )
        ));*/
        $this->select(array(
            'table' => 'all_tables',
            'where' => 'table_name=:table',
            'bind'  => array(
                'table' => strtoupper($table)
            )
        ));
        return (bool)$this->nextRecord();
    }
 
    function getPrimary($table)
    {
        $db = clone $this;
        $db->select(array(
            'fields'    => 'cols.column_name,cols2.data_type',
            'table' => 'all_constraints cons, all_cons_columns cols, all_tab_columns cols2',
            'where' => 'cols.table_name=\''.strtoupper($table).'\' '.
                'AND cons.constraint_type=\'P\' '.
                'AND cons.constraint_name = cols.constraint_name '.
                'AND cons.owner = cols.owner '.
                'AND cols2.table_name=cols.table_name AND cols2.column_name=cols.column_name',
            'order' => 'cols.position'
        ));
        $primary = array();
        while ($db->nextRecord())
        {
            if (strpos($db->Record['data_type'], 'INT')!==false || $db->Record['data_type']=='NUMBER')
            {
                $type = 'int';
            } else {
                $type = 'string';
            }
            $primary[strtolower($db->Record['column_name'])] = $type;
        }
        return $primary;
    }
 
    function optimize($table)
    {
        require_once('base/Ego_System.php');
        Ego_System::eternalCache(true);
        $s = 'ANALYZE TABLE '.$table.' COMPUTE STATISTICS';
        $handle = oci_parse($this->_dbHandle, $s);
        oci_execute($handle);
        Ego_System::eternalCache(false);
    }
 
 
    public function getTables($like = '') {
        if ($like) {
            /*$this->select(array(
                'table' => 'all_tables',
                'where' => "TABLE_NAME LIKE :whatnames AND owner=:owner",
                'bind'  => array(
                    'owner' => $this->_user,
                    'whatnames' => strtoupper($like.'%')
                )
            ));*/
            $this->select(array(
                'table' => 'all_tables',
                'where' => "TABLE_NAME LIKE :whatnames",
                'bind'  => array(
                    'whatnames' => strtoupper($like.'%')
                )
            ));
        } else {
            /*$this->select(array(
                'table' => 'all_tables',
                'where' => "owner=:owner",
                'bind'  => array(
                    'owner' => $this->_user
                )
            ));*/
            $this->select(array(
                'table' => 'all_tables'
            ));
        }
 
        $all_table = array();
        $count = 0;
 
        while($table = $this->nextRecord()) {
            $all_table[$count++] = array_pop($this->Record);
        }
        return $all_table;
    }
 
    protected function _rewind()
    {
        $this->query($this->currentQuery);
    }
 
    function getVersion() {
        return oci_server_version($this->_dbHandle);
    }
}
?>