DAOPreparedQuery.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\orm\core\prepared;
 
use Ubiquity\cache\database\DbCache;
use Ubiquity\db\SqlUtils;
use Ubiquity\orm\DAO;
use Ubiquity\orm\OrmUtils;
use Ubiquity\orm\parser\ConditionParser;
 
abstract class DAOPreparedQuery {
    protected $databaseOffset;
 
    protected $conditionParser;
    protected $included;
    protected $hasIncluded;
    protected $useCache;
    protected $className;
    protected $tableName;
    protected $invertedJoinColumns = null;
    protected $oneToManyFields = null;
    protected $manyToManyFields = null;
    protected $transformers;
    protected $propsKeys;
    protected $accessors;
    protected $fieldList;
    protected $memberList;
    protected $firstPropKey;
    protected $condition;
    protected $preparedCondition;
    protected $primaryKeys;
 
    protected $additionalMembers = false;
    protected $sqlAdditionalMembers = "";
    protected $allPublic = false;
    protected $statement;
 
    protected $db;
 
    public function __construct($className, $condition = null, $included = false, $cache = null) {
        $this->className = $className;
        $this->included = $included;
        $this->condition = $condition;
        $this->conditionParser = new ConditionParser ($condition);
        $this->prepare($cache);
    }
 
    public function getFirstPropKey() {
        return $this->firstPropKey;
    }
 
    public function getDb() {
        return $this->db;
    }
 
    public function getDatabaseOffset() {
        return $this->databaseOffset;
    }
 
    public function getConditionParser() {
        return $this->conditionParser;
    }
 
    public function getIncluded() {
        return $this->included;
    }
 
    public function getHasIncluded() {
        return $this->hasIncluded;
    }
 
    public function getUseCache() {
        return $this->useCache;
    }
 
    public function getClassName() {
        return $this->className;
    }
 
    public function getTableName() {
        return $this->tableName;
    }
 
    public function getInvertedJoinColumns() {
        return $this->invertedJoinColumns;
    }
 
    public function getOneToManyFields() {
        return $this->oneToManyFields;
    }
 
    public function getManyToManyFields() {
        return $this->manyToManyFields;
    }
 
    public function getTransformers() {
        return $this->transformers;
    }
 
    public function getPropsKeys() {
        return $this->propsKeys;
    }
 
    public function getAccessors() {
        return $this->accessors;
    }
 
    public function getFieldList() {
        return $this->fieldList;
    }
 
    public function getMemberList() {
        return $this->memberList;
    }
 
    protected function prepare(?DbCache $cache = null) {
        $this->db = DAO::getDb($this->className);
        if (isset ($cache)) {
            $this->db->setCacheInstance($cache);
        }
        $this->included = DAO::_getIncludedForStep($this->included);
 
        $metaDatas = OrmUtils::getModelMetadata($this->className);
        $this->tableName = $metaDatas ['#tableName'];
        $this->hasIncluded = $this->included || (\is_array($this->included) && \count($this->included) > 0);
        if ($this->hasIncluded) {
            DAO::_initRelationFields($this->included, $metaDatas, $this->invertedJoinColumns, $this->oneToManyFields, $this->manyToManyFields);
        }
        $this->transformers = $metaDatas ['#transformers'] [DAO::$transformerOp] ?? [];
        $this->fieldList = DAO::_getFieldList($this->tableName, $metaDatas);
        $this->memberList = \array_flip(\array_diff($metaDatas ['#fieldNames'], $metaDatas ['#notSerializable']));
        $this->propsKeys = OrmUtils::getPropKeys($this->className);
 
        $this->firstPropKey = OrmUtils::getFirstPropKey($this->className);
        $this->primaryKeys = OrmUtils::getPrimaryKeys($this->className);
        if (!($this->allPublic = OrmUtils::hasAllMembersPublic($this->className))) {
            $this->accessors = $metaDatas ['#accessors'];
        }
    }
 
    protected function updatePrepareStatement() {
        $this->preparedCondition = SqlUtils::checkWhere($this->conditionParser->getCondition());
        $this->statement = $this->db->getDaoPreparedStatement($this->tableName, $this->preparedCondition, $this->fieldList . $this->sqlAdditionalMembers);
    }
 
    protected function updateSqlAdditionalMembers() {
        if ($this->additionalMembers) {
            $this->sqlAdditionalMembers = ',' . $this->parseExpressions();
            $this->updatePrepareStatement();
        }
    }
 
    protected function parseExpressions() {
        return \implode(',', $this->additionalMembers);
    }
 
    protected function addAditionnalMembers($object, $row) {
        foreach ($this->additionalMembers as $member => $_) {
            $object->{$member} = $row [$member] ?? null;
            $object->_rest [$member] = $row [$member] ?? null;
        }
    }
 
    abstract public function execute($params = [], $useCache = false);
 
    public function addMember(string $sqlExpression, string $memberName): void {
        $this->additionalMembers [$memberName] = $sqlExpression . " AS '{$memberName}'";
        $this->updateSqlAdditionalMembers();
    }
 
    public function addMembers(array $expressionsNames): void {
        foreach ($expressionsNames as $member => $expression) {
            $this->additionalMembers [$member] = $expression . " AS '{$member}'";
        }
        $this->updateSqlAdditionalMembers();
    }
 
    public function storeDbCache() {
        $this->db->storeCache();
    }
}