Ubiquity\db\providers\pdo\PDOWrapper

Complexity

Total Complexity

43

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	1

35 Methods

Rating	Name	Duplication	Size	Complexity
A	getPrimaryKeys()	0	8	2
A	query()	0	2	1
A	pool()	0	2	1
A	executeStatement()	0	2	1
A	queryColumn()	0	2	1
A	savePoint()	0	2	1
A	_optPrepareAndExecute()	0	8	2
A	commit()	0	2	1
A	getFieldsInfos()	0	8	2
A	releasePoint()	0	2	1
A	rollbackPoint()	0	2	1
A	lastInsertId()	0	2	1
A	beginTransaction()	0	2	1
A	execute()	0	2	1
A	inTransaction()	0	2	1
A	freePool()	0	2	1
A	queryAll()	0	2	1
A	rollBack()	0	2	1
A	fetchOne()	0	7	2
A	prepareStatement()	0	2	1
A	getDSN()	0	2	1
A	getStatement()	0	4	1
A	statementRowCount()	0	2	1
A	fetchAllColumn()	0	7	2
A	getTablesName()	0	3	1
A	fetchAll()	0	7	2
A	bindValueFromStatement()	0	2	1
A	setPool()	0	2	1
A	fetchColumn()	0	5	2
A	nestable()	0	2	1
A	__construct()	0	2	1
A	connect()	0	3	1
A	getAvailableDrivers()	0	2	1
A	getForeignKeys()	0	9	1
A	ping()	0	2	2

<?php

namespace Ubiquity\db\providers\pdo;

use Ubiquity\db\providers\AbstractDbWrapper;
use Ubiquity\exceptions\DBException;

/**
 * Ubiquity\db\providers$PDOWrapper
 * This class is part of Ubiquity
 *
 * @author jcheron <myaddressmail@gmail.com>
 * @version 1.0.0
 * @property \PDO $dbInstance
 *
 */
class PDOWrapper extends AbstractDbWrapper {
	protected static $savepointsDrivers = [ 'pgsql' => true,'mysql' => true,'sqlite' => true ];
	private static $quotes = [ 'mysql' => '`','sqlite' => '"','pgsql' => '"' ];
	protected $transactionLevel = 0;

	public function __construct($dbType = 'mysql') {
		$this->quote = self::$quotes [$dbType] ?? '';
	}

	public function fetchAllColumn($statement, array $values = null, string $column = null) {
		$result = false;
		if ($statement->execute ( $values )) {
			$result = $statement->fetchAll ( \PDO::FETCH_COLUMN, $column );
		}
		$statement->closeCursor ();
		return $result;
	}

	public function lastInsertId() {
		return $this->dbInstance->lastInsertId ();
	}

	public function fetchAll($statement, array $values = null, $mode = null) {
		$result = false;
		if ($statement->execute ( $values )) {
			$result = $statement->fetchAll ( $mode );
		}
		$statement->closeCursor ();
		return $result;
	}

	public function fetchOne($statement, array $values = null, $mode = null) {
		$result = false;
		if ($statement->execute ( $values )) {
			$result = $statement->fetch ( $mode );
		}
		$statement->closeCursor ();
		return $result;
	}

	public static function getAvailableDrivers() {
		return \PDO::getAvailableDrivers ();
	}

	public function prepareStatement(string $sql) {
		return $this->dbInstance->prepare ( $sql );
	}

	public function fetchColumn($statement, array $values = null, int $columnNumber = null) {
		if ($statement->execute ( $values )) {
			return $statement->fetchColumn ( $columnNumber );
		}
		return false;
	}

	public function getStatement($sql) {
		$st = $this->dbInstance->prepare ( $sql );
		$st->setFetchMode ( \PDO::FETCH_ASSOC );
		return $st;
	}

	public function execute($sql) {
		return $this->dbInstance->exec ( $sql );
	}

	public function connect(string $dbType, $dbName, $serverName, string $port, string $user, string $password, array $options) {
		$options [\PDO::ATTR_ERRMODE] = \PDO::ERRMODE_EXCEPTION;
		$this->dbInstance = new \PDO ( $this->getDSN ( $serverName, $port, $dbName, $dbType ), $user, $password, $options );
	}

	public function getDSN(string $serverName, string $port, string $dbName, string $dbType = 'mysql') {
		return $dbType . ':dbname=' . $dbName . ';host=' . $serverName . ';charset=UTF8;port=' . $port;
	}

	public function bindValueFromStatement($statement, $parameter, $value) {
		return $statement->bindValue ( ":" . $parameter, $value );
	}

	public function query(string $sql) {
		return $this->dbInstance->query ( $sql );
	}

	public function queryAll(string $sql, int $fetchStyle = null) {
		return $this->dbInstance->query ( $sql )->fetchAll ( $fetchStyle );
	}

	public function queryColumn(string $sql, int $columnNumber = null) {
		return $this->dbInstance->query ( $sql )->fetchColumn ( $columnNumber );
	}

	public function executeStatement($statement, array $values = null) {
		return $statement->execute ( $values );
	}

	public function getTablesName() {
		$query = $this->dbInstance->query ( 'SHOW TABLES' );
		return $query->fetchAll ( \PDO::FETCH_COLUMN );
	}

	public function statementRowCount($statement) {
		return $statement->rowCount ();
	}

	public function inTransaction() {
		return $this->dbInstance->inTransaction ();
	}

	public function commit() {
		return $this->dbInstance->commit ();
	}

	public function rollBack() {
		return $this->dbInstance->rollBack ();
	}

	public function beginTransaction() {
		return $this->dbInstance->beginTransaction ();
	}

	public function savePoint($level) {
		$this->dbInstance->exec ( 'SAVEPOINT LEVEL' . $level );
	}

	public function releasePoint($level) {
		$this->dbInstance->exec ( 'RELEASE SAVEPOINT LEVEL' . $level );
	}

	public function rollbackPoint($level) {
		$this->dbInstance->exec ( 'ROLLBACK TO SAVEPOINT LEVEL' . $level );
	}

	public function nestable() {
		return isset ( self::$savepointsDrivers [$this->dbInstance->getAttribute ( \PDO::ATTR_DRIVER_NAME )] );
	}

	public function ping() {
		return ($this->dbInstance != null) && (1 === \intval ( $this->queryColumn ( 'SELECT 1', 0 ) ));
	}

	public function getPrimaryKeys($tableName) {
		$fieldkeys = array ();
		$recordset = $this->dbInstance->query ( "SHOW KEYS FROM `{$tableName}` WHERE Key_name = 'PRIMARY'" );
		$keys = $recordset->fetchAll ( \PDO::FETCH_ASSOC );
		foreach ( $keys as $key ) {
			$fieldkeys [] = $key ['Column_name'];
		}
		return $fieldkeys;
	}

	public function getForeignKeys($tableName, $pkName, $dbName = null) {
		$recordset = $this->dbInstance->query ( "SELECT *
												FROM
												 information_schema.KEY_COLUMN_USAGE
												WHERE
												 REFERENCED_TABLE_NAME = '" . $tableName . "'
												 AND REFERENCED_COLUMN_NAME = '" . $pkName . "'
												 AND TABLE_SCHEMA = '" . $dbName . "';" );
		return $recordset->fetchAll ( \PDO::FETCH_ASSOC );
	}

	public function getFieldsInfos($tableName) {
		$fieldsInfos = array ();
		$recordset = $this->dbInstance->query ( "SHOW COLUMNS FROM `{$tableName}`" );
		$fields = $recordset->fetchAll ( \PDO::FETCH_ASSOC );
		foreach ( $fields as $field ) {
			$fieldsInfos [$field ['Field']] = [ "Type" => $field ['Type'],"Nullable" => $field ["Null"] ];
		}
		return $fieldsInfos;
	}

	public function pool() {
		throw new DBException ( 'PDO does not accept connection pooling' );
	}

	public function freePool($db) {
		throw new DBException ( 'PDO does not accept connection pooling' );
	}

	public function setPool($pool) {
		throw new DBException ( 'PDO does not accept connection pooling' );
	}

	public function _optPrepareAndExecute($sql, array $values = null) {
		$statement = $this->_getStatement ( $sql );
		$result = false;
		if ($statement->execute ( $values )) {
			$result = $statement->fetchAll ( \PDO::FETCH_ASSOC );
		}
		$statement->closeCursor ();
		return $result;
	}
}