terah / fluent-pdo-model

src/Drivers/OciStubPdo.php

<?php declare(strict_types=1);
/**
 * @package Terah\FluentPdoModel
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

namespace Terah\FluentPdoModel\Drivers;

use \PDO;
use \PDOException;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Terah\FluentPdoModel\Column;
use Terah\FluentPdoModel\ForeignKey;
use Terah\RedisCache\CacheInterface;
use function Terah\Assert\Assert;
use Terah\RedisCache\NullCache;

/**
 * PDOOCI
 *
 * PHP version 5.3
 *
 * @category OciStubPdo
 * @package  OciStubPdo
 * @author   Eustáquio Rangel <eustaquiorangel@gmail.com>
 * @license  http://www.gnu.org/licenses/gpl-2.0.html GPLv2
 * @link     http://github.com/taq/pdooci
 */

/**
 * Main class of OciStubPdo
 *
 * PHP version 5.3
 *
 * @category Connection
 * @package  OciStubPdo
 * @author   Eustáquio Rangel <eustaquiorangel@gmail.com>
 * @license  http://www.gnu.org/licenses/gpl-2.0.html GPLv2
 * @link     http://github.com/taq/pdooci
 */
class OciStubPdo extends AbstractPdo implements DriverInterface
{
    /**
     * @var resource
     */
    private $_con           = null;
    /**
     * @var bool
     */
    private $_autocommit    = true;
    /**
     * @var array
     */
    private $_last_error    = null;
    /**
     * @var string
     */
    private $_charset       = null;

    /**
     * OciStubPdo constructor.
     * @param string $dsn
     * @param string $username
     * @param string $password
     * @param array $options
     * @param LoggerInterface|null $logger
     * @param CacheInterface|null $cache
     */
    public function __construct(string $dsn, string $username='', string $password='', array $options=[], LoggerInterface $logger=null, CacheInterface $cache=null)
    {
        if (!function_exists("\\oci_parse")) {
            throw new PDOException(PHP_VERSION . " : No support for Oracle, please install the OCI driver");
        }

        // find charset
        $charset    = null;

$charset is not used, you could remove the assignment.

        $dsn        = preg_replace('/^oci:/', '', $dsn);
        $tokens     = preg_split('/;/', $dsn);
        $data       = $tokens[0];
        $charset    = $this->_getCharset($tokens);

        try {
            if (!is_null($options) && array_key_exists(\PDO::ATTR_PERSISTENT, $options)) {
                $this->_con = @\oci_pconnect($username, $password, $data, $charset);
                $this->setError();
            } else {
                $this->_con = @\oci_connect($username, $password, $data, $charset);
                $this->setError();
            }
            if (!$this->_con) {
                $error = oci_error();
                throw new \Exception($error['code'] . ': ' . $error['message']);
            }
        } catch ( \Exception $exception ) {
            throw new PDOException($exception->getMessage());
        }
        $this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_OBJ);
        $this->setConfig($options, 'oci:' . $data);

It seems like $options can also be of type null; however, Terah\FluentPdoModel\Drivers\AbstractPdo::setConfig() does only seem to accept array, maybe add an additional type check?

        $this->setLogger($logger ? $logger : new NullLogger());
        $this->setCache($cache ? $cache : new NullCache());
    }


    /**
     * @param bool $include_views
     * @return array
     */
    public function getTables(bool $include_views=false) : array
    {
        return [];
    }

    /**
     * @param bool $include_views
     * @param string $table
     * @return Column[]
     */
    public function getColumns(bool $include_views=false, string $table='') : array
    {
        return [];
    }

    /**
     * @param string $table
     * @return ForeignKey[]
     */
    public function getForeignKeys(string $table='') : array
    {
        return [];
    }

    /**
     * @param bool|false $include_views
     * @param string $table
     * @return array
     */
    public function getTableCounts(bool $include_views=false, string $table='') : array
    {
        return [];
    }

    /**
     * Return the charset
     *
     * @return string charset
     */
    public function getCharset()
    {
        return $this->_charset;
    }

    /**
     * Find the charset
     *
     * @param array $charset charset
     *
     * @return string charset
     */
    private function _getCharset(array $charset = null)
    {
        if ( ! $charset )
        {
            $langs = array_filter([getenv("NLS_LANG")], "strlen");

            return array_shift($langs);
        }

        $expr   = '/^(charset=)(\w+)$/';
        $tokens = array_filter($charset, function ($token) use ($expr) {
            return preg_match($expr, $token, $matches);
        });
        $this->_charset = null;
        if ( sizeof($tokens) > 0 )
        {
            preg_match($expr, array_shift($tokens), $matches);
            $this->_charset = $matches[2];
        }

        return $this->_charset;
    }

    /**
     * Return the connection
     *
     * @return resource handle
     */
    public function getConnection()
    {
        return $this->_con;
    }

    /**
     * Execute a query
     *
     * @param string $statement sql query
     * @param int    $mode      PDO query() mode
     * @param int    $p1        PDO query() first parameter
     * @param int    $p2        PDO query() second parameter
     *
     * @return OciPdoStubStatement
     * @throws PDOException
     */
    public function query($statement, $mode = null, $p1 = null, $p2 = null)

The parameter $mode is not used and could be removed.

The parameter $p1 is not used and could be removed.

The parameter $p2 is not used and could be removed.

    {
        // TODO: use mode and parameters
        $stmt = null;
        try {
            $stmt = new OciPdoStubStatement($this, $statement);
            $stmt->execute();
            $this->setError();
            return $stmt;
        } catch ( \Exception $e ) {
            throw new PDOException($e->getMessage());
        }
    }

    /**
     * Execute query
     *
     * @param string $sql query
     *
     * @return integer of affected rows
     * @throws PDOException
     */
    public function exec($sql)
    {
        try {
            $stmt = $this->query($sql);
            $rows = $stmt->rowCount();
            $stmt->closeCursor();
            return $rows;
        } catch ( \Exception $e ) {
            throw new PDOException($e->getMessage());
        }
    }

    /**
     * Set an attribute
     *
     * @param int   $attr  attribute
     * @param mixed $value value
     *
     * @return boolean|null if set was ok
     */
    public function setAttribute($attr, $value)
    {
        switch ($attr)
        {
            case \PDO::ATTR_AUTOCOMMIT:
                $this->_autocommit = ( is_bool($value) && $value ) || in_array(strtolower($value), ["on", "true"]);
                return;
        }

        return;
    }

    /**
     * Return an attribute
     *
     * @param int $attr attribute
     *
     * @return mixed attribute value
     */
    public function getAttribute($attr)
    {
        switch ($attr) {
            case \PDO::ATTR_AUTOCOMMIT:
                return $this->_autocommit;
            case \PDO::ATTR_DRIVER_NAME:
                return 'oci';
        }
        return null;
    }

    /**
     * Return the auto commit flag
     *
     * @return boolean auto commit flag
     */
    public function getAutoCommit()
    {
        return $this->_autocommit;
    }

    /**
     * Commit connection
     *
     * @return bool if commit was executed
     */
    public function commit() : bool
    {
        \oci_commit($this->_con);
        $this->setError();

        return true;
    }

    /**
     * Rollback connection
     *
     * @return bool if rollback was executed
     */
    public function rollBack() : bool
    {
        \oci_rollback($this->_con);
        $this->setError();

        return true;
    }

    /**
     * Start a transaction, setting auto commit to off
     *
     * @return bool
     */
    public function beginTransaction() : bool
    {
        $this->setAttribute(\PDO::ATTR_AUTOCOMMIT, false);

        return true;
    }

    /**
     * @param string $query
     * @param integer $limit
     * @param null|integer $offset
     * @return string
     */
    public function setLimit(string $query, int $limit=0, int $offset=0) : string
    {
        Assert($query)->string()->notEmpty();
        Assert($limit)->nullOr()->integer();
        Assert($offset)->nullOr()->integer();
        if ( $offset )
        {
            $limit  = $limit ?: 1;
            $limit  = $limit + $offset;
            return "SELECT * FROM ({$query}) WHERE ROWNUM between {$offset} AND {$limit}";
        }
        if ( $limit  )
        {
            return "SELECT * FROM ({$query}) WHERE ROWNUM <= {$limit}";
        }

        return $query;
    }

    /**
     * Prepare a statement
     *
     * @param string $query   for statement
     * @param mixed  $options for driver
     *
     * @return OciPdoStubStatement
     * @throws PDOException
     */
    public function prepare($query, $options = null)
    {
        $stmt = null;

$stmt is not used, you could remove the assignment.

        try {
            return new OciPdoStubStatement($this, $query);
        } catch ( \Exception $e ) {
            throw new PDOException($e->getMessage());
        }
    }

    /**
     * Sets the last error found
     *
     * @param resource $obj optional object to extract error from
     *
     * @return null
     */
    public function setError($obj = null)
    {
        $obj = $obj ? $obj : $this->_con;
        if (!is_resource($obj)) {
            return;
        }
        $error = \oci_error($obj);
        if (!$error) {

The expression $error of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return null;
        }
        $this->_last_error = $error;

        return null;
    }

    /**
     * Returns the last error found
     *
     * @return int error code
     */
    public function errorCode()
    {
        if (!$this->_last_error) {

The expression $this->_last_error of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return null;
        }
        return intval($this->_last_error["code"]);
    }

    /**
     * Returns the last error info
     *
     * @return array error info
     */
    public function errorInfo()
    {
        if (!$this->_last_error) {

The expression $this->_last_error of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return null;
        }
        return [
            $this->_last_error["code"],
            $this->_last_error["code"],
            $this->_last_error["message"]
        ];
    }

    /**
     * Close connection
     *
     * @return null
     */
    public function close()
    {
        if (is_null($this->_con)) {
            return;
        }
        \oci_close($this->_con);
        $this->_con = null;

        return null;
    }

    /**
     * Trigger stupid errors who should be exceptions
     *
     * @param int    $errno   error number
     * @param string $errstr  error message
     * @param mixed  $errfile error file
     * @param int    $errline error line
     *
     * @return null
     */
    public function errorHandler($errno, $errstr, $errfile, $errline)
    {
        unset($errno, $errfile, $errline);
        preg_match('/(ORA-)(\d+)/', $errstr, $ora_error);
        if ($ora_error) {

The expression $ora_error of type string[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->_last_error = intval($ora_error[2]);

It seems like intval($ora_error[2]) of type integer is incompatible with the declared type array of property $_last_error.

        } else {
            $this->setError($this->_con);
        }

        return null;
    }

    /**
     * Return available drivers
     * Will insert the OCI driver on the list, if not exist
     *
     * @return array with drivers
     */
    public static function getAvailableDrivers()
    {
        $drivers = \PDO::getAvailableDrivers();
        if (!in_array("oci", $drivers)) {
            array_push($drivers, "oci");
        }
        return $drivers;
    }

    /**
     * Return if is on a transaction
     *
     * @return boolean on a transaction
     */
    public function inTransaction()
    {
        return !$this->_autocommit;
    }

    /**
     * Quote a string
     *
     * @param string $string to be quoted
     * @param int    $type   parameter type
     *
     * @return string quoted
     */
    public function quote($string, $type = null)
    {
        $string = preg_replace('/\'/', "''", $string);
        $string = "'$string'";
        return $string;
    }

    /**
     * Return the last inserted id
     * If the sequence name is not sent, throws an exception
     *
     * @param string $sequence name
     *
     * @return integer last id
     * @throws PDOException
     */
    public function lastInsertId($sequence = null)
    {
        if (!$sequence) {

The expression $sequence of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            throw new PDOException("SQLSTATE[IM001]: Driver does not support this function: driver does not support getting attributes in system_requirements");
        }
        $id = 0;
        try {
            $stmt = $this->query("select $sequence.currval from dual");
            $data = $stmt->fetch(\PDO::FETCH_ASSOC);
            $id   = intval($data["CURRVAL"]);
        } catch ( PDOException $e ) {

Consider adding a comment why this CATCH block is empty.

        }
        return $id;
    }

    /**
     * @param string $table
     * @param string $column
     * @return string
     */
    public function getFieldComment(string $table, string $column) : string
    {
        return '';
    }
}