DAO.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\orm;
 
use Ubiquity\db\Database;
use Ubiquity\log\Logger;
use Ubiquity\db\SqlUtils;
use Ubiquity\orm\traits\DAOUpdatesTrait;
use Ubiquity\orm\traits\DAORelationsTrait;
use Ubiquity\orm\parser\ConditionParser;
use Ubiquity\orm\traits\DAOUQueries;
use Ubiquity\orm\traits\DAOCoreTrait;
use Ubiquity\orm\traits\DAORelationsPrepareTrait;
use Ubiquity\exceptions\DAOException;
use Ubiquity\orm\traits\DAORelationsAssignmentsTrait;
use Ubiquity\orm\traits\DAOTransactionsTrait;
use Ubiquity\controllers\Startup;
use Ubiquity\cache\CacheManager;
use Ubiquity\orm\traits\DAOPooling;
use Ubiquity\orm\traits\DAOBulkUpdatesTrait;
use Ubiquity\orm\traits\DAOPreparedTrait;
use Ubiquity\cache\dao\AbstractDAOCache;
 
class DAO  extends  DAOCoreTrait,DAOUpdatesTrait,DAORelationsTrait,DAORelationsPrepareTrait,DAORelationsAssignmentsTrait,
    DAOUQueries,DAOTransactionsTrait,DAOPooling,DAOBulkUpdatesTrait,DAOPreparedTrait  {
 
    public static $db;
    public static $useTransformers = false;
    public static $transformerOp = 'transform';
    private static $conditionParsers = [ ];
    protected static $modelsDatabase = [ ];
 
    protected static $cache;
 
    public static function getDb($model) {
        return self::getDatabase ( self::$modelsDatabase [$model] ?? 'default');
    }
 
    public static function getAll($className, $condition = '', $included = true, $parameters = null, $useCache = NULL) {
        $db = self::getDb ( $className );
        return static::_getAll ( $db, $className, new ConditionParser ( $condition, null, $parameters ), $included, $useCache );
    }
 
    public static function getAllByIds($className, $keyValues = [ ], $included = true, $condition = '', $useCache = NULL): array {
        $db = self::getDb ( $className );
        $key = OrmUtils::getFirstKey ( $className );
        $countK = \count ( $keyValues );
        if ($countK > 0) {
            $nCondition = $key . ' IN (' . \str_repeat ( '?,', $countK - 1 ) . '?)';
            if ($condition != null) {
                $nCondition .= ' AND ' . $condition;
            }
            return static::_getAll ( $db, $className, new ConditionParser ( $nCondition, null, $keyValues ), $included, $useCache );
        }
        return [];
        
    }
 
    public static function paginate($className, $page = 1, $rowsPerPage = 20, $condition = null, $included = true) {
        return self::getAll ( $className, ($condition ?? '1=1') . ' LIMIT ' . $rowsPerPage . ' OFFSET ' . (($page - 1) * $rowsPerPage), $included );
    }
 
    public static function orderBy(string $className, string $field, string $order = 'ASC', string $condition = '', bool $included = true, $parameters = null, $useCache = NULL): array {
        return self::getAll ( $className, ($condition ?? '1=1') . ' ORDER BY ' . $field . ' ' . $order, $included, $parameters, $useCache );
    }
 
    public static function getRownum($className, $ids) {
        $tableName = OrmUtils::getTableName ( $className );
        $db = self::getDb ( $className );
        $quote = $db->quote;
        self::parseKey ( $ids, $className, $quote );
        $condition = SqlUtils::getCondition ( $ids, $className );
        $keyFields = OrmUtils::getKeyFields ( $className );
        if (\is_array ( $keyFields )) {
            $keys = \implode ( ',', $keyFields );
        } else {
            $keys = '1';
        }
        return $db->getRowNum ( $tableName, $keys, $condition );
    }
 
    public static function count($className, $condition = '', $parameters = null) {
        $tableName = OrmUtils::getTableName ( $className );
        if ($condition != '') {
            $condition = SqlUtils::checkWhere($condition);
        }
        $db = self::getDb ( $className );
        $quote = $db->quote;
        return $db->prepareAndFetchColumn ( 'SELECT COUNT(*) FROM ' . $quote . $tableName . $quote . $condition, $parameters );
    }
 
    public static function exists($className, $condition = '', $parameters = null): bool {
        $tableName = OrmUtils::getTableName ( $className );
        if ($condition != '') {
            $condition = SqlUtils::checkWhere($condition);
        }
        $db = self::getDb ( $className );
        $quote = $db->quote;
        return (1 == $db->prepareAndFetchColumn ( "SELECT EXISTS(SELECT 1 FROM {$quote}{$tableName}{$quote}{$condition})", $parameters ));
    }
 
    public static function getOne($className, $condition, $included = true, $parameters = null, $useCache = NULL) {
        $db = self::getDb ( $className );
        $conditionParser = new ConditionParser ();
        if (! isset ( $parameters )) {
            $conditionParser->addKeyValues ( $condition, $className );
        } elseif (! is_array ( $condition )) {
            $conditionParser->setCondition ( $condition );
            $conditionParser->setParams ( $parameters );
        } else {
            throw new DAOException ( "The \$condition parameter should not be an array if \$parameters is not null" );
        }
        return static::_getOne ( $db, $className, $conditionParser, $included, $useCache );
    }
 
    public static function getById($className, $keyValues, $included = true, $useCache = NULL) {
        return static::_getOne ( self::getDatabase ( self::$modelsDatabase [$className] ?? 'default'), $className, self::getConditionParser ( $className, $keyValues ), $included, $useCache );
    }
 
    protected static function getConditionParser($className, $keyValues): ConditionParser {
        if (! isset ( self::$conditionParsers [$className] )) {
            $conditionParser = new ConditionParser ();
            $conditionParser->addKeyValues ( $keyValues, $className );
            self::$conditionParsers [$className] = $conditionParser;
        } else {
            self::$conditionParsers [$className]->setKeyValues ( $keyValues );
        }
        return self::$conditionParsers [$className];
    }
 
    public static function connect($offset, $wrapper, $dbType, $dbName, $serverName = '127.0.0.1', $port = '3306', $user = 'root', $password = '', $options = [ ], $cache = false) {
        self::$db [$offset] = new Database ( $wrapper, $dbType, $dbName, $serverName, $port, $user, $password, $options, $cache, self::$pool );
        try {
            self::$db [$offset]->connect ();
        } catch ( \Exception $e ) {
            Logger::error ( "DAO", $e->getMessage () );
            throw new DAOException ( $e->getMessage (), $e->getCode (), $e->getPrevious () );
        }
    }
 
    public static function startDatabase(&$config, $offset = null) {
        $db = $offset ? ($config ['database'] [$offset] ?? ($config ['database'] ?? [ ])) : ($config ['database'] ['default'] ?? $config ['database']);
        if ($db ['dbName'] !== '') {
            self::connect ( $offset ?? 'default', $db ['wrapper'] ?? \Ubiquity\db\providers\pdo\PDOWrapper::class, $db ['type'], $db ['dbName'], $db ['serverName'] ?? '127.0.0.1', $db ['port'] ?? 3306, $db ['user'] ?? 'root', $db ['password'] ?? '', $db ['options'] ?? [ ], $db ['cache'] ?? false);
        }
    }
 
    public static function getDbOffset(&$config, $offset = null) {
        return $offset ? ($config ['database'] [$offset] ?? ($config ['database'] ?? [ ])) : ($config ['database'] ['default'] ?? $config ['database']);
    }
 
    public static function isConnected($offset = 'default'): bool {
        $db = self::$db [$offset] ?? false;
        return ($db instanceof Database) && $db->isConnected ();
    }
 
    public static function setTransformerOp(string $op) {
        self::$transformerOp = $op;
    }
 
    public static function closeDb($offset = 'default') {
        $db = self::$db [$offset] ?? false;
        if ($db !== false) {
            $db->close ();
        }
    }
 
    public static function setModelDatabase($model, $database = 'default') {
        self::$modelsDatabase [$model] = $database;
    }
 
    public static function setModelsDatabases($modelsDatabase) {
        self::$modelsDatabase = $modelsDatabase;
    }
 
    public static function getDatabase($offset = 'default') {
        if (! isset ( self::$db [$offset] )) {
            self::startDatabase ( Startup::$config, $offset );
        }
        SqlUtils::$quote = self::$db [$offset]->quote??'';
        return self::$db [$offset]??null;
    }
 
    public static function getDatabases(): array {
        $config = Startup::getConfig ();
        if (isset ( $config ['database'] )) {
            if (isset ( $config ['database'] ['dbName'] )) {
                return [ 'default' ];
            } else {
                return \array_keys ( $config ['database'] );
            }
        }
        return [ ];
    }
 
    public static function updateDatabaseParams(array &$config, array $parameters, $offset = 'default') {
        if ($offset === 'default') {
            if (isset ( $config ['database'] [$offset] )) {
                foreach ( $parameters as $k => $param ) {
                    $config ['database'] [$offset] [$k] = $param;
                }
            } else {
                foreach ( $parameters as $k => $param ) {
                    $config ['database'] [$k] = $param;
                }
            }
        } else {
            if (isset ( $config ['database'] [$offset] )) {
                foreach ( $parameters as $k => $param ) {
                    $config ['database'] [$offset] [$k] = $param;
                }
            }
        }
    }
 
    public static function start() {
        self::$modelsDatabase = CacheManager::getModelsDatabases ();
    }
 
    public static function getDbCacheInstance($model) {
        $db = static::$db [self::$modelsDatabase [$model] ?? 'default'];
        return $db->getCacheInstance ();
    }
 
    public static function warmupCache($className, $condition = '', $included = false, $parameters = [ ]) {
        $objects = self::getAll ( $className, $condition, $included, $parameters );
        foreach ( $objects as $o ) {
            self::$cache->store ( $className, OrmUtils::getKeyValues ( $o ), $o );
        }
        self::$cache->optimize ();
        $offset = self::$modelsDatabase [$className] ?? 'default';
        $db = self::$db [$offset];
        $db->close ();
        unset ( self::$db [$offset] );
    }
 
    public static function setCache(AbstractDAOCache $cache) {
        self::$cache = $cache;
    }
 
    public static function getCache() {
        return static::$cache;
    }
 
    public static function getModelsDatabase(): array {
        return self::$modelsDatabase;
    }
}