class.ilAtomQueryBase.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
abstract class ilAtomQueryBase
{
    protected const ITERATIONS = 10;
    protected static array $available_isolations_levels = [
        ilAtomQuery::ISOLATION_READ_UNCOMMITED,
        ilAtomQuery::ISOLATION_READ_COMMITED,
        ilAtomQuery::ISOLATION_REPEATED_READ,
        ilAtomQuery::ISOLATION_SERIALIZABLE,
    ];
    protected static array $possible_anomalies = [
        ilAtomQuery::ANO_LOST_UPDATES,
        ilAtomQuery::ANO_DIRTY_READ,
        ilAtomQuery::ANO_NON_REPEATED_READ,
        ilAtomQuery::ANO_PHANTOM,
    ];
    protected static array $anomalies_map = [
        ilAtomQuery::ISOLATION_READ_UNCOMMITED => [
            ilAtomQuery::ANO_LOST_UPDATES,
            ilAtomQuery::ANO_DIRTY_READ,
            ilAtomQuery::ANO_NON_REPEATED_READ,
            ilAtomQuery::ANO_PHANTOM,
        ],
        ilAtomQuery::ISOLATION_READ_COMMITED => [
            ilAtomQuery::ANO_NON_REPEATED_READ,
            ilAtomQuery::ANO_PHANTOM,
        ],
        ilAtomQuery::ISOLATION_REPEATED_READ => [
            ilAtomQuery::ANO_PHANTOM,
        ],
        ilAtomQuery::ISOLATION_SERIALIZABLE => [],
    ];
    protected int $isolation_level = ilAtomQuery::ISOLATION_SERIALIZABLE;
    protected array $tables = [];
    protected $query;
 
    public function __construct(protected \ilDBInterface $ilDBInstance, int $isolation_level = ilAtomQuery::ISOLATION_SERIALIZABLE)
    {
        static::checkIsolationLevel($isolation_level);
        $this->isolation_level = $isolation_level;
    }
 
    //
    //
    //
    public function getRisks(): array
    {
        return static::getPossibleAnomalies($this->getIsolationLevel());
    }
 
    public function addTableLock(string $table_name): ilTableLockInterface
    {
        $ilTableLock = new ilTableLock($table_name, $this->ilDBInstance);
        $ilTableLock->setLockLevel($this->getDeterminedLockLevel());
        $this->tables[] = $ilTableLock;
 
        return $ilTableLock;
    }
 
    protected function getDeterminedLockLevel(): int
    {
        return ilAtomQuery::LOCK_WRITE;
    }
 
    public function addQueryCallable(callable $query): void
    {
        if ($this->query) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_CLOSURE_ALREADY_SET);
        }
        if (!$this->checkCallable($query)) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_CLOSURE_WRONG_FORMAT);
        }
        $this->query = $query;
    }
 
    public function replaceQueryCallable(callable $query): void
    {
        if (!$this->checkCallable($query)) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_CLOSURE_WRONG_FORMAT);
        }
        $this->query = $query;
    }
 
    abstract public function run(): void;
 
    public function getIsolationLevel(): int
    {
        return $this->isolation_level;
    }
 
    public static function isThereRiskThat(int $isolation_level, int $anomaly): bool
    {
        static::checkIsolationLevel($isolation_level);
        static::checkAnomaly($anomaly);
 
        return in_array($anomaly, static::getPossibleAnomalies($isolation_level));
    }
 
    public static function getPossibleAnomalies(int $isolation_level): array
    {
        static::checkIsolationLevel($isolation_level);
 
        return self::$anomalies_map[$isolation_level];
    }
 
    public static function checkIsolationLevel(int $isolation_level): void
    {
        // The following Isolations are currently not supported
        if (in_array($isolation_level, [
            ilAtomQuery::ISOLATION_READ_UNCOMMITED,
            ilAtomQuery::ISOLATION_READ_COMMITED,
            ilAtomQuery::ISOLATION_REPEATED_READ,
        ])) {
            throw new ilAtomQueryException('Level: ' . $isolation_level, ilAtomQueryException::DB_ATOM_ISO_WRONG_LEVEL);
        }
        // Check if a available Isolation level is selected
        if (!in_array($isolation_level, self::$available_isolations_levels)) {
            throw new ilAtomQueryException('Level: ' . $isolation_level, ilAtomQueryException::DB_ATOM_ISO_WRONG_LEVEL);
        }
    }
 
    public static function checkAnomaly(int $anomaly): void
    {
        if (!in_array($anomaly, self::$possible_anomalies)) {
            throw new ilAtomQueryException('Anomaly: ' . $anomaly, ilAtomQueryException::DB_ATOM_ANO_NOT_AVAILABLE);
        }
    }
 
    protected function checkQueries(): void
    {
        if (!($this->query instanceof \Traversable) && (is_array($this->query) && [] === $this->query)) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_CLOSURE_NONE);
        }
 
        foreach ($this->query as $query) {
            if (!$this->checkCallable($query)) {
                throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_CLOSURE_WRONG_FORMAT);
            }
        }
    }
 
    public function checkCallable(callable $query): bool
    {
        if (!is_callable($query)) {
            return false; // Won't be triggered sidn type-hinting already checks this
        }
        if (is_array($query)) {
            return false;
        }
        if (is_string($query)) {
            return false;
        }
 
        $is_a_closure = ($query instanceof Closure);
        if (!$is_a_closure) {
            $ref = new ReflectionClass($query);
            foreach ($ref->getMethods() as $method) {
                if ($method->getName() === '__invoke') {
                    return true;
                }
            }
 
            return false;
        }
        if ($is_a_closure) {
            $ref = new ReflectionFunction($query);
            $parameters = $ref->getParameters();
            if (count($parameters) !== 1) {
                return false;
            }
            $reflectionClass = $parameters[0]->getType();
            return $reflectionClass && $reflectionClass->getName() === ilDBInterface::class;
        }
 
        return true;
    }
 
    protected function hasWriteLocks(): bool
    {
        $has_write_locks = false;
        foreach ($this->tables as $table) {
            if ($table->getLockLevel() === ilAtomQuery::LOCK_WRITE) {
                $has_write_locks = true;
            }
        }
 
        return $has_write_locks;
    }
 
    protected function runQueries(): void
    {
        $query = $this->query;
        $query($this->ilDBInstance);
    }
 
    protected function checkBeforeRun(): void
    {
        $this->checkQueries();
 
        if ($this->hasWriteLocks() && $this->getIsolationLevel() != ilAtomQuery::ISOLATION_SERIALIZABLE) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_LOCK_WRONG_LEVEL);
        }
 
        if ($this->tables === []) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_LOCK_NO_TABLE);
        }
    }
}