Terah\FluentPdoModel\Drivers\OciPdo

Complexity

Total Complexity

14

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	15	5
A	getTables()	0	4	1
A	getColumns()	0	4	1
A	getForeignKeys()	0	4	1
A	getTableCounts()	0	4	1
A	getFieldComment()	0	4	1
A	setLimit()	0	18	4

<?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 Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Terah\FluentPdoModel\Column;
use Terah\FluentPdoModel\ForeignKey;
use Terah\RedisCache\CacheInterface;
use Terah\RedisCache\NullCache;
use function Terah\Assert\Assert;

class OciPdo extends AbstractPdo implements DriverInterface
{
    /**
     * @param string          $dsn
     * @param string          $username
     * @param string          $password
     * @param array           $options
     * @param LoggerInterface $logger
     * @param CacheInterface   $cache
     */
    public function __construct(string $dsn, string $username='', string $password='', array $options=[], LoggerInterface $logger=null, CacheInterface $cache=null)
    {
        parent::__construct($dsn, $username, $password, $options);
        $this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
        $this->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_OBJ);
        $this->setAttribute(PDO::ATTR_CASE, PDO::CASE_LOWER);
        if ( array_key_exists('timeout', $options) && $options['timeout'] )
        {
            $this->setAttribute(PDO::ATTR_TIMEOUT, (int)$options['timeout']);
        }
        $this->setConfig($options, $dsn);
        $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 [];
    }

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

    /**
     * @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;
    }
}