TphpDb

Classe permettant la mise en cache mémoire

Fonction open

Ouvre une requête SQL.

Appel :

$cache->open($sql, $param_sql=[], $param_req=[]);

$sql : la requête sql exemple : SELECT id,name FROM user WHERE id=:id
$param_sql : Paramètres à transmettre à la requête SQL en sécuirisant par type de données.
$param_req : Paramètres à transmettre à la fon,ction open.

Retour :

statement : $stmt

Fonction fetch

Renvoie la prochaine ligne de données.

Appel :

$cache->fetch($stmt);

Retour :

mixed : $row

Fonction close

Ferme le statement.

Appel :

$cache->close($stmt);

Retour :

boolean : true | false

Fonction beginTransaction

Débute une transaction SQL.

Appel :

$cache->beginTransaction();

Retour :

boolean : true | false

Fonction commit

Valide une transaction SQL.

Appel :

$cache->commit();

Retour :

boolean : true | false

Fonction rollback

Annule une transaction SQL.

Appel :

$cache->rollback();

Retour :

boolean : true | false

Code source TphpDb :

<?php
class TphpDb {
    protected $driver;
    protected $name;
    
    private static $db=[];
    public static $conf=[];

    /**
     * @param array $conf
     *
     * @throws Exception
     */
    public function __construct($conf=[]) {
        $this->driver=(isset($conf['driver']))?$conf['driver']:'';
        $this->name=$conf['name'];
        switch($this->driver) {
            case 'mariadb':
            case 'mysql':
            case 'mysqli':
                $this->obj = new TphpDbMysqli($conf);
                break;
            case 'oracle':
                $this->obj = new TphpDbOracle($conf);
                break;
            case 'oracle-pdo':
                $this->obj = new TphpDbOraclePdo($conf);
                break;
            case 'postgres':
                $this->obj = new TphpDbPostgres($conf);
                break;
            case 'postgres-pdo':
                $this->obj = new TphpDbPostgrespdo($conf);
                break;
            default:
                throw new \Exception(__METHOD__.'['.$this->name.'].driver['.$this->driver.'].notSupported');break;
        }
    }
    
    public function __destruct() {$this->obj = null;}

    /**
     * @throws \Exception
     */
    public function connect() {return $this->obj->connect();}

    /**
     * @param       $sql
     * @param array $param_sql
     * @param array $param_req
     *
     * @return array|bool|false|int|resource
     * @throws Exception
     */
    public function open($sql,$param_sql=[],$param_req=[]) {return $this->obj->open($sql,$param_sql,$param_req);}
    
    public function fetch($stmt) {return $this->obj->fetch($stmt);}
    
    public function close($stmt) {return $this->obj->close($stmt);}
    
    public function disconnect() {return $this->obj->disconnect();}

    /**
     * @throws \Exception
     */
    public function isValid() {return $this->obj->isValid();}

    public function beginTransaction() {return $this->obj->beginTransaction();}
    
    public function commit() {return $this->obj->commit();}
    
    public function rollback() {return $this->obj->rollback();}
    
    public function getLastCmd() {return $this->obj->getLastCmd();}

    /**
     * @param       $sql
     * @param array $param_sql
     * @param array $param_req
     *
     * @return array|bool|false|int|resource
     * @throws Exception
     */
    public function exec($sql,$param_sql=[],$param_req=[]) {return $this->obj->open($sql,$param_sql,$param_req);}

    /**
     * @param       $sql
     * @param array $param_sql
     * @param array $param_req
     *
     * @return array
     * @throws Exception
     */
    public function req($sql,$param_sql=[],$param_req=[]) {
        $rs=[];
        if (!isset($param_req['no_exec']) || !$param_req['no_exec']) {
            $stmt=$this->obj->open($sql,$param_sql,$param_req);
            if ($this->obj->getErrorNum()) {
                throw new \Exception(__METHOD__.'.[ERROR].error_num['.$this->obj->getErrorNum().'].error_msg['.$this->obj->getErrorMsg().'].sql['.$sql.']');
            } else {
                if (isset($param_req['index_by_keys'])) {
                    $key_eval='';
                    $sep=isset($param_req['index_by_keys_sep'])?$param_req['index_by_keys_sep']:'-';
                    foreach($param_req['index_by_keys'] as $field) {
                        if ($key_eval!='') $key_eval.='.\''.$sep.'\'.';
                        $key_eval.='$row[\''.$field.'\']';
                    }
                    $key_eval='$key='.$key_eval.';';
                    while ($row=$this->obj->fetch($stmt)) {
                        eval($key_eval);
                        $rs[$key]=$row;
                    }
                } else if (isset($param_req['index_by_key'])) {
                    while ($row=$this->obj->fetch($stmt)) {
                        $rs[$row[$param_req['index_by_key']]]=$row;
                    }
                } else if (isset($param_req['index_by_key_array'])) {
                    while ($row=$this->obj->fetch($stmt)) {
                        $rs[$row[$param_req['index_by_key_array']]][]=$row;
                    }
                } else {
                    while ($row=$this->obj->fetch($stmt)) {
                        array_push($rs,$row);
                    }
                }
                $row=null;
                $this->obj->close($stmt);
                
                if (isset($param_req['in']) && is_array($param_req['in'])) {
                    $tmp=[];
                    foreach($rs as $row) {
                        $found=true;
                        foreach($param_req['in'] as $k=>$values) {
                            if (!in_array($row[$k],$values)) {
                                $found=false;
                                break;
                            }
                        }
                        if ($found) {
                            $tmp[]=$row;
                        }
                    }
                    $rs=$tmp;
                    unset($tmp);
                }
                if (isset($param_req['sort_by'])) {
                    $sort_func=(isset($param_req['index_by_keys']) || isset($param_req['index_by_key']))?'uasort':'usort';
                    TphpDb::usortMulti($rs,$param_req['sort_by'],$sort_func);
                }
                if (isset($param_req['limit'])) {
                    TphpDb::limit($rs,$param_req['limit'],'',isset($param_req['index_by_key']));
                }
                
                if (isset($param_req['index_multi_by_keys']) && isset($rs[0]) && isset($rs[0][$param_req['index_multi_by_keys'][0]])) {
                    TphpDb::indexMultiByKeys($rs,$param_req['index_multi_by_keys']);
                }
            }
        }
        return $rs;
    }
    
    public static function indexMultiByKeys(&$array,$fields) {
        if (count($array)>0) {
            foreach($fields as $field) {
                if (!isset($array[0][$field])) {
                    return;
                }
            }
            $data=[];
            foreach($array as $line) {
                $target=&$data;
                foreach($fields as $field) {
                    if (!isset($target[$line[$field]])) {
                        $target[$line[$field]]=[];
                    }
                    $target=&$target[$line[$field]];
                }
                $target=$line;
            }
            $array=$data;
        }
    }

    /**
     * @param null $name
     *
     * @return mixed
     * @throws Exception
     */
    public static function get($name=null) {
        if (!isset(self::$db[$name])) {
            self::loadDb($name);
        }
        if (isset(self::$db[$name])) {
            return self::$db[$name];
        }
        throw new \Exception(__METHOD__.'['.$name.'].unknow');
    }

    /**
     * @param $name
     *
     * @throws Exception
     */
    public static function loadDb($name) {
        if (!isset(self::$db[$name]) && $name!='' && isset(self::$conf[$name]) && !isset(self::$conf[$name]['loaded'])) {
            $conf=self::$conf[$name];
            $conf['name']=$name;
            self::$db[$name]=new TphpDb($conf);
        }
    }

    /**
     * @param       $name
     * @param array $conf
     *
     * @throws Exception
     */
    public static function setConf($name,$conf=[]) {
        if (!array_key_exists('driver',$conf)) {
            throw new \Exception(__METHOD__.'('.$name.',*CONF*)[driver].notSet', E_USER_ERROR);
        }
        if (isset(self::$db[$name])) {
            unset(self::$db[$name]);
        }
        $conf['name']=$name;
        self::$conf[$name]=$conf;
    }

    public static function getReturnType(&$sql) {
        $sql=trim($sql);

        preg_match('/\b[a-zA-Z]+\b/i', $sql, $result);
        $type = $result[0];

        switch( $type ){
            case 'SELECT':
            case 'INSERT':
            case 'UPDATE':
                return $type;

            case 'REPLACE':
            case 'LOAD':
                return 'INSERT';

            case 'SET':
            case 'DELETE':
                return 'UPDATE';

            case 'SHOW':
            case 'EXPLAIN':
            case 'WITH':
            case 'DESCRIBE':
                return 'SELECT';

            case 'TRUNCATE':
            case 'DROP':
            case 'KILL':
            case 'LOCK':
            case 'UNLOCK':
            case 'CREATE':
            case 'OPTIMIZE':
            case 'ALTER':
            case 'VACUUM':
            case 'REINDEX':
            case 'ANALYZE':
            case 'IMPORT':
            case 'CALL':
                return 'NO_RETURN';

            default:
                return 'UNKNOW';
        }
    }
    
    public static function mergeSqlParam(&$sql,$param,$string_delimiter,$string_delimiter_replaced_by,$other_replace,$other_replace_replaced_by) {
        uksort($param,'self::paramCmp');
        if (is_array($param) && count($param)>0) {
            foreach($param as $k =>$v) {
                $tab=explode('-',$k);
                if (count($tab)==1) {
                    $sql=str_replace(':'.$tab[0],$string_delimiter.str_replace($string_delimiter,$string_delimiter_replaced_by,str_replace($other_replace,$other_replace_replaced_by,$v)).$string_delimiter,$sql);
                } else {
                    switch ($tab[0]) {
                        case 'ad': //array of date
                        case 'as': //array of string
                            if (is_array($v) && count($v)>0) {
                                $sql_tmp='';
                                foreach ($v as $kt=>$vt) {
                                    if ($sql_tmp!='') {
                                        $sql_tmp.=',';
                                    }
                                    if (is_null($vt)) {
                                        $sql_tmp.='null';
                                    } else {
                                        $sql_tmp.=$string_delimiter.str_replace($string_delimiter,$string_delimiter_replaced_by,str_replace($other_replace,$other_replace_replaced_by,$vt)).$string_delimiter;
                                    }
                                }
                                $sql=str_replace(':'.$tab[1],$sql_tmp,$sql);
                                unset($sql_tmp);
                            } else {
                                $sql=str_replace(':'.$tab[1],'\'\'',$sql);
                            }
                            break;
                        case 'af':  //array of float
                        case 'ai':  //array of integer
                            if (is_array($v) && count($v)>0) {
                                $sql_tmp='';
                                foreach ($v as $kt=>$vt) {
                                    if ($sql_tmp!='') {
                                        $sql_tmp.=',';
                                    }
                                    if (is_null($vt)) {
                                        $sql_tmp.='null';
                                    } else {
                                        $vt=(int)$vt;
                                        $sql_tmp.=$vt;
                                    }
                                }
                                $sql=str_replace(':'.$tab[1],$sql_tmp,$sql);
                                unset($sql_tmp);
                            } else {
                                $sql=str_replace(':'.$tab[1],'0',$sql);
                            }
                            break;
                        case 'd': //date
                        case 's': //string
                            if (is_null($v)) {
                                $sql=str_replace(':'.$tab[1],'null',$sql);
                            } else {
                                $sql=str_replace(':'.$tab[1],$string_delimiter.str_replace($string_delimiter,$string_delimiter_replaced_by,str_replace($other_replace,$other_replace_replaced_by,$v)).$string_delimiter,$sql);
                            }
                            break;
                        case 'b':
                            if (is_null($v)) {
                                $sql=str_replace(':'.$tab[1],'null',$sql);
                            } else if (is_bool($v)) {
                                if ($v) {
                                    $sql=str_replace(':'.$tab[1],'true',$sql);
                                } else {
                                    $sql=str_replace(':'.$tab[1],'false',$sql);
                                }
                            } else if (in_array($v,['0','1'])) {
                                if ($v==1) {
                                    $sql=str_replace(':'.$tab[1],'true',$sql);
                                } else {
                                    $sql=str_replace(':'.$tab[1],'false',$sql);
                                }
                            } else {
                                $sql=str_replace(':'.$tab[1],$string_delimiter.str_replace($string_delimiter,$string_delimiter_replaced_by,str_replace($other_replace,$other_replace_replaced_by,$v)).$string_delimiter,$sql);
                            }
                        case 'f': //float
                        case 'i': //integer
                            if (is_null($v)) {
                                $sql=str_replace(':'.$tab[1],'null',$sql);
                            } else if (is_numeric($v)) {
                                $sql=str_replace(':'.$tab[1],$v,$sql);
                            } else {
                                $sql=str_replace(':'.$tab[1],$string_delimiter.str_replace($string_delimiter,$string_delimiter_replaced_by,str_replace($other_replace,$other_replace_replaced_by,$v)).$string_delimiter,$sql);
                            }
                            break;
                        default:
                            $sql=str_replace(':'.$tab[1],$string_delimiter.str_replace($string_delimiter,$string_delimiter_replaced_by,str_replace($other_replace,$other_replace_replaced_by,$v)).$string_delimiter,$sql);
                            break;
                    }
                }
            }
        }
    }
    
    public static function paramCmp($a,$b) {
        return mb_strlen($a)<mb_strlen($b);
    }
    
    public static function usortMulti(&$array,$fields=null,$sort_func='usort') {
        if ($fields && is_string($fields)) {
            $fields = preg_split('`\s*,\s*`Usi', trim($fields));
        }
        if (!$fields || !is_array($fields)) {
            return $array;
        }

        $max = count($fields);
        $params = [];
        for ($i=$max-1;$i>=0;--$i) {
            $field = trim($fields[$i]);
            $direction = (strpos($field, ' DESC') === false) ? SORT_ASC : SORT_DESC;
            $field = trim(strtr($field, array(' DESC'=>'', ' ASC'=>'')));
            $params[] = array_column($array, $field);
            $params[] = $direction;
        }
        $params[] = $array;

        call_user_func_array("array_multisort", $params);
    }
    
    public static function prepareInsert($tbl_name,$cols=[],$param=[]) {
        $param_sql=[];
        $sql_val=$sql_col=$sql_update='';
        foreach($cols as $col=>$meta) {
            if (array_key_exists($col,$param) && !isset($meta['primary'])) {
                if ($sql_update!='') {
                    $sql_update.=',';
                }
                $sql_update.=$col.'=:'.$col;
            }
            if (!array_key_exists($col,$param) && isset($meta['default'])) {
                $param[$col]=$meta['default'];
            }
            if (array_key_exists($col,$param)) {
                if ($sql_col!='') {
                    $sql_col.=',';
                    $sql_val.=',';
                }
                $sql_col.=$col;
                $sql_val.=':'.$col;
                $param_sql[((isset($meta['type']))?($meta['type'].'-'):'').$col]=$param[$col];
            }
        }
        return array($tbl_name,$sql_col,$sql_val,$param_sql,$sql_update);
    }
    
    public static function prepareUpdate($tbl_name,$cols=[],$param=[]) {
        $param_sql=[];
        $sql_where=$sql_update='';
        foreach($cols as $col=>$meta) {
            if (array_key_exists($col,$param)) {
                if (isset($meta['primary'])) {
                    if ($sql_where!='') {$sql_where.=' AND ';}
                    $sql_where.=$col.'=:'.$col;
                } else {
                    if ($sql_update!='') {$sql_update.=',';}
                    $sql_update.=$col.'=:'.$col;
                }
                $param_sql[((isset($meta['type']))?($meta['type'].'-'):'').$col]=$param[$col];
            }
        }
        return array($tbl_name,$sql_update,$sql_where,$param_sql);
    }
    
    public static function prepareQuery($tbl_name,$tbl_alias=null,$cols=[],$param=[]) {
        $sql_select='';
        $sql_where='';
        $sql_order='';
        $param_sql=[];
        if (isset($param['from_dual']) && $param['from_dual']==true) {
            $tbl='dual';
            if (isset($param['cache_ttl'])) {
                unset($param['cache_ttl']);
            }
            if (isset($param['ttl'])) {
                unset($param['ttl']);
            }
            foreach($cols as $col=>$meta) {
                if ($sql_select!='') {
                    $sql_select.=',';
                }
                if (array_key_exists($col,$param)) {
                    $sql_select.=':'.$col.' AS '.$col;
                    $param_sql[$meta['type'].'-'.$col]=$param[$col];
                } else if (array_key_exists('default',$meta)) {
                    $sql_select.=':'.$col.' AS '.$col;
                    $param_sql[$meta['type'].'-'.$col]=$meta['default'];
                } else {
                    $sql_select.='\'\' AS '.$col;
                }
            }
        } else {
            $tbl=$tbl_name.(is_null($tbl_alias)?'':(' '.$tbl_alias));
            $col_alias=(is_null($tbl_alias)?'':($tbl_alias.'.'));
            foreach($cols as $col=>$meta) {
                if ($sql_select!='') {
                    $sql_select.=',';
                }
                $sql_select.=$col_alias.$col;
                if (array_key_exists($col,$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.'=:'.$col;
                    $param_sql[$meta['type'].'-'.$col]=$param[$col];
                }
                if (array_key_exists($col.'_like',$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.' LIKE :'.$col.'_like';
                    $param_sql['s-'.$col.'_like']=$param[$col.'_like'];
                }
                if (array_key_exists($col.'_dif',$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.'!=:'.$col.'_dif';
                    $param_sql[$meta['type'].'-'.$col.'_dif']=$param[$col.'_dif'];
                }
                if (array_key_exists($col.'_sup',$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.'>:'.$col.'_sup';
                    $param_sql[$meta['type'].'-'.$col.'_sup']=$param[$col.'_sup'];
                }
                if (array_key_exists($col.'_supeq',$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.'>=:'.$col.'_supeq';
                    $param_sql[$meta['type'].'-'.$col.'_supeq']=$param[$col.'_supeq'];
                }
                if (array_key_exists($col.'_inf',$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.'<:'.$col.'_inf';
                    $param_sql[$meta['type'].'-'.$col.'_inf']=$param[$col.'_inf'];
                }
                if (array_key_exists($col.'_infeq',$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.'<=:'.$col.'_infeq';
                    $param_sql[$meta['type'].'-'.$col.'_infeq']=$param[$col.'_infeq'];
                }
                if (array_key_exists($col.'_in',$param)) {
                    if ($sql_where!='') {
                        $sql_where.=' AND ';
                    }
                    $sql_where.=$col_alias.$col.' IN (:'.$col.'_in)';
                    $param_sql['a'.$meta['type'].'-'.$col.'_in']=$param[$col.'_in'];
                }
            }
            
            if (isset($param['where']) && is_array($param['where']) && count($param['where'])>0) {
                foreach($param['where'] as $where) {
                    if ($sql_where!='') {$sql_where.=' AND ';}
                    $sql_where.=$col_alias.$where;
                }
            }
            if (isset($param['select']) && is_array($param['select']) && count($param['select'])>0) {
                $sql_select='';
                foreach($param['select'] as $select) {
                    if ($sql_select!='') {$sql_select.=',';}
                    $sql_select.=$col_alias.$select;
                }
            }
            if (isset($param['order']) && is_array($param['order']) && count($param['order'])>0) {
                foreach($param['order'] as $order) {
                    if ($sql_order!='') {$sql_order.=',';}
                    $sql_order.=$col_alias.$order;
                }
            }
        }
        return array($tbl,$sql_select,$sql_where,$sql_order,$param_sql);
    }

    public static function limit(&$array,$start,$nb='',$preserve_key=false) {
        if ($nb=='') {
            $tmp=explode(',',$start);
            $start=trim($tmp[0]);
            $nb=trim($tmp[1]);
            unset($tmp);
        }
        $array=array_slice($array,$start,$nb,$preserve_key);
    }
    
    public static function removeAlias($fields_list) {
        $ret='';
        $tmp_comma=explode(',',$fields_list);
        foreach($tmp_comma as $tmp) {
            $tmp=str_ireplace([' as '], '##AS##', $tmp);
            if (strpos($tmp,'##AS##')!==false) {
                $tmp=substr($tmp,0,strpos($tmp,'##AS##'));
            }
            
            if ($ret!='') {
                $ret.=',';
            }
            $ret.=$tmp;
        }
        
        return $ret;
    }
}

Driver code source TphpDbOracle :

<?php
class TphpDbOracle {
	protected $conn=null;
	protected $stmt=null;
	protected $charset;
	protected $host;
	protected $login;
	protected $password;
	protected $servicename;
	protected $instancename;
	protected $transaction=false;
	protected $port;
	protected $schema;
	protected $cmd_last=null;
	protected $debug_sql;

	public function __construct($param) {
		$this->name=isset($param['name'])?$param['name']:'no_name';
		$this->host=isset($param['host'])?$param['host']:'';
		$this->port=isset($param['port'])?$param['port']:'';
		$this->login=isset($param['login'])?$param['login']:'';
		$this->charset=isset($param['charset'])?$param['charset']:'';
		$this->password=isset($param['password'])?$param['password']:'';
		$this->servicename=isset($param['servicename'])?$param['servicename']:'';
		$this->instancename=isset($param['instancename'])?$param['instancename']:'';
		$this->schema=isset($param['schema'])?$param['schema']:'';
		$this->debug_sql=isset($param['debug_sql'])?$param['debug_sql']:false;
	}

    /**
     * @param bool $check_conn
     *
     * @throws Exception
     */
	public function connect($check_conn=true) {
		if (!is_resource($this->conn)) {
		    //:[//]host_name[:port][/service_name][:server_type][/instance_name]
		    $dsn=$this->host.':'.$this->port;
		    if ($this->servicename.''!='') {
		        $dsn.='/'.$this->servicename;
		        
		        if ($this->instancename.''!='') {
		            $dsn.='/'.$this->instancename;
		        }
		        
		    }
		    $this->conn=oci_new_connect($this->login,$this->password, $dsn, $this->charset, OCI_DEFAULT);
		    
		}
		if ($check_conn) {
            if (!$this->conn) {
                throw new \Exception(__METHOD__.'['.$this->name.'].noConnection.');
            }
		}
	}
	
	public function disconnect() {
	    if (is_resource($this->conn)) {oci_close($this->conn);}
		$this->conn=null;
	}

    /**
     * @throws \Exception
     */
	public function isValid() {
		if (!is_resource($this->conn)) {
			$this->connect(false);
		}
		if (!is_resource($this->conn)) {
			return false;
		}
//         $stmt=pg_query($this->conn,'SELECT table_name FROM information_schema.tables WHERE schema=\''.pg_escape_string($this->dbname).'\'');
//         if (!in_array(pg_result_status($stmt),array(PGSQL_COMMAND_OK, PGSQL_TUPLES_OK))) {
//             return false;
//         }
//        $this->close($stmt);
        return true;
	}

    /**
     * @param       $sql
     * @param array $param_sql
     * @param array $param_req
     *
     * @return array|bool|false|int|resource
     * @throws Exception
     */
	public function open($sql,$param_sql=array(),$param_req=array()) {
		if (!is_resource($this->conn)) {
		    $this->connect();
		}
		TphpDb::mergeSqlParam($sql,$param_sql,'\'','\'\'','','');
		if (isset($param_req['query_print']) && $param_req['query_print']) {
		    echo "\n".'SQL='.$sql."\n";
		}
        if (isset($param_req['query_discord']) && $param_req['query_discord'] || $this->debug_sql) {
            \Discord::forcePieceJointeNameForNextSend('piece_jointe.sql');
            \Discord::sendDump($sql);
            \Discord::forcePieceJointeNameForNextSend('piece_jointe.log');
        }
		if (isset($param_req['query_aff']) && $param_req['query_aff']) {
		    echo '<hr>SQL='.nl2br($sql).'<hr>'."\n";
		}
		if (isset($param_req['query_print_die']) && $param_req['query_print_die']) {
		    echo "\n".'SQL='.$sql."\n";die();
		}
		if (isset($param_req['query_aff_die']) && $param_req['query_aff_die']) {
		    echo '<hr>SQL='.nl2br($sql).'<hr>'."\n";die();
		}
		$return_type=TphpDb::getReturnType($sql);
		if ('UNKNOW'==$return_type) {
			throw new Exception(__METHOD__.'.return_type[UNKNOW].sql['.$sql.']');
		}
        if ('SELECT'==$return_type) {
		    $this->cmd_last=$sql;
		    $stmt_id=oci_parse($this->conn,$sql);
		    oci_execute($stmt_id, OCI_NO_AUTO_COMMIT);
		    return $stmt_id;
		}
        if (isset($param_req['no_exec']) && $param_req['no_exec']) {
            return true;
        }

        $this->cmd_last=$sql;
        $stmt_id=oci_parse($this->conn,$sql);
        oci_execute($stmt_id, (($this->transaction)?OCI_NO_AUTO_COMMIT:OCI_COMMIT_ON_SUCCESS));
        
        if (!$stmt_id) {
            //throw new Exception(__METHOD__.'.error.num['.$this->getErrorNum().'].msg['.$this->getErrorMsg().'].return_type['.$return_type.'].sql['.$sql.']');
        }
        if ('UPDATE'==$return_type) {
            return oci_num_rows($stmt_id);
        }
        if ('INSERT'==$return_type) {
            return $this->fetch($stmt_id);
        }
        if ('NO_RETURN'==$return_type) {
            return true;
        }
	}

    /**
     * @throws \Exception
     */
	public function beginTransaction() {
	    if (!is_resource($this->conn)) {
	        $this->connect();
	    }
	    $stmt_id=oci_parse($this->conn, "START TRANSACTION;");
	    $this->transaction=true;
	    return oci_execute($stmt_id, OCI_NO_AUTO_COMMIT);
	}
	
	public function commit() {
	    $stmt_id=oci_parse($this->conn, "COMMIT;");
	    $this->transaction=false;
	    return oci_execute($stmt_id, OCI_COMMIT_ON_SUCCESS);
	}
	
	public function rollback() {
	    $stmt_id=oci_parse($this->conn, "ROLLBACK;");
	    $this->transaction=false;
	    return oci_execute($stmt_id, OCI_COMMIT_ON_SUCCESS);
	}

	public function fetch($stmt_id) {
	    return oci_fetch_assoc($stmt_id);
	}
	
	public function close($stmt_id) {
	    oci_free_statement($stmt_id);
	}
		
	public function getErrorMsg() {
	    return pg_last_error($this->conn);
	}
	
	public function getErrorNum() {
	    return false;
// 	    $result=pg_get_result($this->conn);
// 	    return (!$result)?$result:pg_result_error_field(pg_get_result($this->conn), PGSQL_DIAG_SQLSTATE);
	}
	
	public function __destruct() {
		$this->disconnect();
	}
	
	public function getLastCmd() {
	    return $this->cmd_last;
	}
}

Driver code source TphpDbPostgres :

<?php
class TphpDbPostgres {
	protected $conn=null;
	protected $stmt=null;
	protected $charset;
	protected $host;
	protected $login;
	protected $password;
	protected $dbname;
	protected $port;
	protected $schema;
	protected $cmd_last=null;
	protected $debug_sql;
	
	public function __construct($param) {
		$this->name=isset($param['name'])?$param['name']:'no_name';
		$this->host=isset($param['host'])?$param['host']:'';
		$this->port=isset($param['port'])?$param['port']:'';
		$this->login=isset($param['login'])?$param['login']:'';
		$this->charset=isset($param['charset'])?$param['charset']:'';
		$this->password=isset($param['password'])?$param['password']:'';
		$this->dbname=isset($param['dbname'])?$param['dbname']:'';
		$this->schema=isset($param['schema'])?$param['schema']:'';
		$this->debug_sql=isset($param['debug_sql'])?$param['debug_sql']:false;
	}

    /**
     * @param bool $check_conn
     *
     * @throws Exception
     */
	public function connect($check_conn=true) {
		if (!is_resource($this->conn)) {
		    $dsn='';
		    if ($this->host!='') {
		        $dsn.=' host='.$this->host;
		    }
		    if ($this->port!='') {
		        $dsn.=' port='.$this->port;
		    }
		    if ($this->dbname!='') {
		        $dsn.=' dbname='.$this->dbname;
		    }
		    if ($this->login!='') {
		        $dsn.=' user='.$this->login;
		    }
		    if ($this->password!='') {
		        $dsn.=' password='.$this->password;
		    }
		    if ($this->charset!='') {
		        $dsn.=' options=\'--client_encoding='.$this->charset.'\'';
		    }
		    $this->conn=pg_connect($dsn);
		    
		    if ($this->schema.''!='') {
		        pg_query($this->conn,'SET search_path TO '.$this->schema);
		    }
		}
		if ($check_conn) {
            if (!$this->conn) {
                throw new \Exception(__METHOD__.'['.$this->name.'].noConnection.');
            }
		}
	}
	
	public function disconnect() {
	    if (is_resource($this->conn)) {pg_close($this->conn);}
		$this->conn=null;
	}

    /**
     * @throws \Exception
     */
	public function isValid() {
		if (!is_resource($this->conn)) {
			$this->connect(false);
		}
		if (!is_resource($this->conn)) {
			return false;
		}
        $stmt=pg_query($this->conn,'SELECT table_name FROM information_schema.tables WHERE schema=\''.pg_escape_string($this->dbname).'\'');
        if (!in_array(pg_result_status($stmt),array(PGSQL_COMMAND_OK, PGSQL_TUPLES_OK))) {
            return false;
        }
        $this->close($stmt);
        return true;
	}

    /**
     * @param       $sql
     * @param array $param_sql
     * @param array $param_req
     *
     * @return array|bool|false|int|resource
     * @throws Exception
     */
	public function open($sql,$param_sql=array(),$param_req=array()) {
		if (!is_resource($this->conn)) {
		    $this->connect();
		}
		TphpDb::mergeSqlParam($sql,$param_sql,'\'','\'\'','','');
		if (isset($param_req['query_print']) && $param_req['query_print']) {
		    echo "\n".'SQL='.$sql."\n";
		}
        if (isset($param_req['query_discord']) && $param_req['query_discord'] || $this->debug_sql) {
            \Discord::forcePieceJointeNameForNextSend('piece_jointe.sql');
            \Discord::sendDump($sql);
            \Discord::forcePieceJointeNameForNextSend('piece_jointe.log');
        }
		if (isset($param_req['query_aff']) && $param_req['query_aff']) {
		    echo '<hr>SQL='.nl2br($sql).'<hr>'."\n";
		}
		if (isset($param_req['query_print_die']) && $param_req['query_print_die']) {
		    echo "\n".'SQL='.$sql."\n";die();
		}
		if (isset($param_req['query_aff_die']) && $param_req['query_aff_die']) {
		    echo '<hr>SQL='.nl2br($sql).'<hr>'."\n";die();
		}
		$return_type=TphpDb::getReturnType($sql);
		if ('UNKNOW'==$return_type) {
			throw new Exception(__METHOD__.'.return_type[UNKNOW].sql['.$sql.']');
		}
        if ('SELECT'==$return_type) {
		    $this->cmd_last=$sql;
		    $result=@pg_query($this->conn,$sql);
		    if ($result==false) {
		        throw new Exception(__METHOD__.'.error.num['.$this->getErrorNum().'].msg['.$this->getErrorMsg().'].return_type['.$return_type.'].sql['.$sql.']');
		    }
		    return $result;
		}
        if (isset($param_req['no_exec']) && $param_req['no_exec']) {
            return true;
        }

        $this->cmd_last=$sql;
        $stmt=@pg_query($this->conn, $sql);
        if (!$stmt) {
            throw new Exception(__METHOD__.'.error.num['.$this->getErrorNum().'].msg['.$this->getErrorMsg().'].return_type['.$return_type.'].sql['.$sql.']');
        }
        if ('UPDATE'==$return_type) {
            return pg_affected_rows($stmt);
        }
        if ('INSERT'==$return_type) {
            return $this->fetch($stmt);
        }
        if ('NO_RETURN'==$return_type) {
            return true;
        }
	}

    /**
     * @throws \Exception
     */
	public function beginTransaction() {
	    if (!is_resource($this->conn)) {
	        $this->connect();
	    }
	    return pg_query($this->conn,'BEGIN');
	}
	
	public function commit() {
	    return pg_query($this->conn,'COMMIT');
	}
	
	public function rollback() {
	    return pg_query($this->conn,'ROLLBACK');
	}

	public function fetch($stmt) {
		return pg_fetch_assoc($stmt);
	}
	
	public function close($stmt) {
		pg_free_result($stmt);
	}
		
	public function getErrorMsg() {
	    return pg_last_error($this->conn);
	}
	
	public function getErrorNum() {
	    $result=pg_get_result($this->conn);
	    return (!$result)?$result:pg_result_error_field(pg_get_result($this->conn), PGSQL_DIAG_SQLSTATE);
	}
	
	public function __destruct() {
		$this->disconnect();
	}
	
	public function getLastCmd() {
	    return $this->cmd_last;
	}
}