class.ilAtomQueryBase.php

Go to the documentation of this file.

<?php
require_once('./Services/Database/interfaces/interface.ilAtomQuery.php');
require_once('./Services/Database/classes/Atom/class.ilTableLock.php');
 
abstract class ilAtomQueryBase implements ilAtomQuery
{
    const ITERATIONS = 10;
    protected static $available_isolations_levels = array(
        ilAtomQuery::ISOLATION_READ_UNCOMMITED,
        ilAtomQuery::ISOLATION_READ_COMMITED,
        ilAtomQuery::ISOLATION_REPEATED_READ,
        ilAtomQuery::ISOLATION_SERIALIZABLE,
    );
    protected static $possible_anomalies = array(
        ilAtomQuery::ANO_LOST_UPDATES,
        ilAtomQuery::ANO_DIRTY_READ,
        ilAtomQuery::ANO_NON_REPEATED_READ,
        ilAtomQuery::ANO_PHANTOM,
    );
    protected static $anomalies_map = array(
        ilAtomQuery::ISOLATION_READ_UNCOMMITED => array(
            ilAtomQuery::ANO_LOST_UPDATES,
            ilAtomQuery::ANO_DIRTY_READ,
            ilAtomQuery::ANO_NON_REPEATED_READ,
            ilAtomQuery::ANO_PHANTOM,
        ),
        ilAtomQuery::ISOLATION_READ_COMMITED   => array(
            ilAtomQuery::ANO_NON_REPEATED_READ,
            ilAtomQuery::ANO_PHANTOM,
        ),
        ilAtomQuery::ISOLATION_REPEATED_READ   => array(
            ilAtomQuery::ANO_PHANTOM,
        ),
        ilAtomQuery::ISOLATION_SERIALIZABLE    => array(),
    );
    protected $isolation_level = ilAtomQuery::ISOLATION_SERIALIZABLE;
    protected $tables = array();
    protected $query = null;
    protected $ilDBInstance;
 
 
    public function __construct(ilDBInterface $ilDBInstance, $isolation_level = ilAtomQuery::ISOLATION_SERIALIZABLE)
    {
        static::checkIsolationLevel($isolation_level);
        $this->ilDBInstance = $ilDBInstance;
        $this->isolation_level = $isolation_level;
    }
 
    //
    //
    //
    public function getRisks()
    {
        return static::getPossibleAnomalies($this->getIsolationLevel());
    }
 
 
    public function addTableLock($table_name)
    {
        $ilTableLock = new ilTableLock($table_name, $this->ilDBInstance);
        $ilTableLock->setLockLevel($this->getDeterminedLockLevel());
        $this->tables[] = $ilTableLock;
 
        return $ilTableLock;
    }
 
 
    protected function getDeterminedLockLevel()
    {
        switch ($this->getIsolationLevel()) {
            case ilAtomQuery::ISOLATION_SERIALIZABLE:
                return ilAtomQuery::LOCK_WRITE;
            // Currently only ISOLATION_SERIALIZABLE is allowed
        }
 
        return ilAtomQuery::LOCK_WRITE;
    }
 
 
    public function addQueryCallable(callable $query)
    {
        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)
    {
        if (!$this->checkCallable($query)) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_CLOSURE_WRONG_FORMAT);
        }
        $this->query = $query;
    }
 
 
    abstract public function run();
    //
    //
    //
    public function getIsolationLevel()
    {
        return $this->isolation_level;
    }
 
 
    public static function isThereRiskThat($isolation_level, $anomaly)
    {
        static::checkIsolationLevel($isolation_level);
        static::checkAnomaly($anomaly);
 
        return in_array($anomaly, static::getPossibleAnomalies($isolation_level));
    }
 
 
    public static function getPossibleAnomalies($isolation_level)
    {
        static::checkIsolationLevel($isolation_level);
 
        return self::$anomalies_map[$isolation_level];
    }
 
 
    public static function checkIsolationLevel($isolation_level)
    {
        // The following Isolations are currently not supported
        if (in_array($isolation_level, array(
            ilAtomQuery::ISOLATION_READ_UNCOMMITED,
            ilAtomQuery::ISOLATION_READ_COMMITED,
            ilAtomQuery::ISOLATION_REPEATED_READ,
        ))) {
            throw new ilAtomQueryException($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($isolation_level, ilAtomQueryException::DB_ATOM_ISO_WRONG_LEVEL);
        }
    }
 
 
    public static function checkAnomaly($anomalie)
    {
        if (!in_array($anomalie, self::$possible_anomalies)) {
            throw new ilAtomQueryException($anomalie, ilAtomQueryException::DB_ATOM_ANO_NOT_AVAILABLE);
        }
    }
 
 
    protected function checkQueries()
    {
        if ((is_array($this->query) && 0 === count($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)
    {
        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;
        }
        $classname = get_class($query);
        $is_a_closure = $classname == '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]->getClass();
            if ($reflectionClass && $reflectionClass->getName() == 'ilDBInterface') {
                return true;
            }
 
            return false;
        }
 
        return true;
    }
 
 
    protected function hasWriteLocks()
    {
        $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()
    {
        $query = $this->query;
        $query($this->ilDBInstance);
    }
 
 
    protected function checkBeforeRun()
    {
        $this->checkQueries();
 
        if ($this->hasWriteLocks() && $this->getIsolationLevel() != ilAtomQuery::ISOLATION_SERIALIZABLE) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_LOCK_WRONG_LEVEL);
        }
 
        if (count($this->tables) === 0) {
            throw new ilAtomQueryException('', ilAtomQueryException::DB_ATOM_LOCK_NO_TABLE);
        }
    }
}