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 (count($this->query) == 0) {
                        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);
                }
        }
}