DatabaseOperationsTrait.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\db\traits;
 
use Ubiquity\cache\database\DbCache;
use Ubiquity\db\SqlUtils;
use Ubiquity\exceptions\CacheException;
use Ubiquity\log\Logger;
 
class DatabaseOperationsTrait {
 
    abstract public function getDSN();
 
    public function getDbObject() {
        return $this->wrapperObject->getDbInstance ();
    }
 
    public function _connect() {
        $this->wrapperObject->connect ( $this->dbType, $this->dbName, $this->serverName, $this->port, $this->user, $this->password, $this->options );
    }
 
    public function query($sql) {
        return $this->wrapperObject->query ( $sql );
    }
 
    public function prepareAndExecute($tableName, $condition, $fields, $parameters = null, $useCache = false, $one = false) {
        $result = false;
        if ($cache = ($useCache!==false && (DbCache::$active || $useCache))) {
            $result = $this->getCacheValue ( $tableName, $condition, $parameters, $cKey );
        }
        if ($result === false) {
            $quote = SqlUtils::$quote;
            $sql="SELECT {$fields} FROM {$quote}{$tableName}{$quote} {$condition}";
            Logger::info ( 'Database', $sql, 'prepareAndExecute', $parameters );
            $result = $this->wrapperObject->_optPrepareAndExecute ( $sql, $parameters, $one );
            if ($cache) {
                $this->cache->store ( $tableName, $cKey, $result );
            }
        }
        return $result;
    }
 
    private function getCacheValue($tableName, $condition, $parameters, &$cKey) {
        $cKey = $condition;
        if (\is_array ( $parameters )) {
            $cKey .= \implode ( ',', $parameters );
        }
        try {
            $result = $this->cache->fetch ( $tableName, $cKey );
            Logger::info ( 'Cache', "fetching cache for table {$tableName} with condition : {$condition}", 'Database::prepareAndExecute', $parameters );
        } catch ( \Exception $e ) {
            throw new CacheException ( "Cache is not created in Database constructor" );
        }
        return $result;
    }
 
    public function _optExecuteAndFetch($statement, $tableName, $condition, $parameters = null, $useCache = false, $one = false) {
        $result = false;
        if ($cache = ($useCache!==false && (DbCache::$active || $useCache))) {
            $result = $this->getCacheValue ( $tableName, $condition, $parameters, $cKey );
        }
        if ($result === false) {
            $result = $this->wrapperObject->_optExecuteAndFetch ( $statement, $parameters, $one );
            if ($cache) {
                $this->cache->store ( $tableName, $cKey, $result );
            }
        }
        return $result;
    }
 
    public function _optExecuteAndFetchNoCache($statement, $parameters = null, $one = false) {
        return $this->wrapperObject->_optExecuteAndFetch ( $statement, $parameters, $one );
    }
 
    public function getDaoPreparedStatement($tableName, $condition, $fields) {
        $quote = SqlUtils::$quote;
        return $this->wrapperObject->prepareStatement ( "SELECT {$fields} FROM {$quote}{$tableName}{$quote} {$condition}" );
    }
 
    public function prepareAndExecuteNoCache($tableName, $condition, $fields, $parameters = null) {
        $quote = SqlUtils::$quote;
        return $this->wrapperObject->_optPrepareAndExecute ( "SELECT {$fields} FROM {$quote}{$tableName}{$quote} {$condition}", $parameters );
    }
 
    public function storeCache() {
        $this->cache->storeDeferred ();
    }
 
    public function prepareAndFetchAll($sql, $parameters = null, $mode = null) {
        return $this->wrapperObject->fetchAll ( $this->wrapperObject->_getStatement ( $sql ), $parameters, $mode );
    }
 
    public function prepareAndFetchOne($sql, $parameters = null, $mode = null) {
        return $this->wrapperObject->fetchOne ( $this->wrapperObject->_getStatement ( $sql ), $parameters, $mode );
    }
 
    public function prepareAndFetchAllColumn($sql, $parameters = null, $column = null) {
        return $this->wrapperObject->fetchAllColumn ( $this->wrapperObject->_getStatement ( $sql ), $parameters, $column );
    }
 
    public function prepareAndFetchColumn($sql, $parameters = null, $columnNumber = 0) {
        $statement = $this->wrapperObject->_getStatement ( $sql );
        if ($statement->execute ( $parameters )) {
            Logger::info ( 'Database', $sql, 'prepareAndFetchColumn', $parameters );
            return $statement->fetchColumn ( $columnNumber );
        }
        return false;
    }
 
    private function getStatement($sql) {
        return $this->wrapperObject->_getStatement ( $sql );
    }
 
    public function getUpdateStatement($sql) {
        return $this->wrapperObject->_getStatement ( $sql );
    }
 
    public function prepareAndExecuteUpdate($sql, $parameters = null) {
        return $this->getUpdateStatement ( $sql )->execute ( $parameters );
    }
 
    public function execute($sql) {
        return $this->wrapperObject->execute ( $sql );
    }
 
    public function prepareStatement($sql) {
        return $this->wrapperObject->prepareStatement ( $sql );
    }
 
    public function prepareNamedStatement(string $name, string $sql) {
        return $this->wrapperObject->prepareNamedStatement ( $name, $sql );
    }
 
    public function getNamedStatement(string $name, ?string $sql = null) {
        return $this->wrapperObject->getNamedStatement ( $name, $sql );
    }
 
    public function bindValueFromStatement($statement, $parameter, $value) {
        return $this->wrapperObject->bindValueFromStatement ( $statement, $parameter, $value );
    }
 
    public function lastInserId($name = null) {
        return $this->wrapperObject->lastInsertId ( $name );
    }
 
    public function count($tableName, $condition = '') {
        if ($condition != ''){
            $condition = ' WHERE ' . $condition;
        }
        return $this->wrapperObject->queryColumn ( 'SELECT COUNT(*) FROM ' . $tableName . $condition );
    }
 
    public function queryColumn($query, $columnNumber = null) {
        return $this->wrapperObject->queryColumn ( $query, $columnNumber );
    }
 
    public function fetchAll($query, $mode = null) {
        return $this->wrapperObject->queryAll ( $query, $mode );
    }
 
    public function isConnected() {
        return ($this->wrapperObject !== null && $this->ping ());
    }
 
    public function ping() {
        return ($this->wrapperObject && $this->wrapperObject->ping ());
    }
}