db.class.php

Go to the documentation of this file.

<?php
abstract class spunQ_db implements spunQ_IDatabaseConnection {

    protected static $handlers = NULL;

    private static $connections = array();

    private static $listeners = array();

    public static function getConnection($name = 'default') {
        if (!isset(self::$connections[$name])) {
            $config = spunQ::getConfiguration()->getStringsForPrefix('spunQ.db.connection.' . $name);
            if ($config === NULL || !isset($config['dbms'])) {
                throw new spunQ_ConfigurationError('db.DbConfigurationNotFound', $name);
            }
            $dbms = $config['dbms'];
            if (self::$handlers === NULL || !self::$handlers->keyExists($dbms)) {
                throw new spunQ_InitializationError('db.DbmsFactoryNotFound', $dbms);
            }
            foreach (self::$listeners as $listener) {
                $listener->creatingDatabaseInstance($name);
            }
            self::$connections[$name] = self::$handlers->get($dbms)->createInstance($config, $name);
            foreach (self::$listeners as $listener) {
                $listener->createdDatabaseInstance($name, self::$connections[$name]);
            }
        }
        return self::$connections[$name];
    }

    public static function observeInitializations(spunQ_IDatabaseInstantiationListener $listener) {
        self::$listeners[] = $listener;
        return NULL;
    }

    public static function getDefaultConnection() {
        return self::getConnection('default');
    }

    public static function registerDbmsHandler($dbms, spunQ_IDatabaseConnectionFactory $factory) {
        if (self::$handlers === NULL) {
            self::$handlers = new spunQ_Map();
        }
        self::$handlers->add($dbms, $factory);
        return NULL;
    }

    protected static function sanityCheck($connection = NULL) {
        if ($connection === NULL) {
            $connection = self::getDefaultConnection();
        }
        $additionalTypes = self::getAdditionalTypes($connection);
        $missingTypes = self::getMissingTypes($connection);
        $changedTypes = self::getChangedTypes($connection);
        $additionalMembers = self::getAdditionalTypeMembers($connection);
        $missingMembers = self::getMissingTypeMembers($connection);
        $changedMembers = self::getChangedTypeMembers($connection);
        if (isset($additionalTypes[0])) {
            foreach ($additionalTypes as &$type) {
                $type = $type->getName();
            }
            throw new spunQ_InitializationError('db.AdditionalTypeStorages', $additionalTypes);
        }
        if (isset($missingTypes[0])) {
            foreach ($missingTypes as &$type) {
                $type = $type->getName();
            }
            throw new spunQ_InitializationError('db.MissingTypeStorages', $missingTypes);
        }
        if (isset($changedTypes[0])) {
            $array = array();
            foreach ($changedTypes->getKeys() as $type) {
                $array[] = $type->getName();
            }
            throw new spunQ_InitializationError('db.ChangedTypeStorages', $changedTypes);
        }
        if (isset($additionalMembers[0])) {
            foreach ($additionalMembers as &$member) {
                $member = $member->getMemberName();
            }
            throw new spunQ_InitializationError('db.AdditionalTypeMemberStorages', $additionalMembers);
        }
        if (isset($missingMembers[0])) {
            foreach ($missingMembers as &$member) {
                $member = $member->getName();
            }
            throw new spunQ_InitializationError('db.MissingTypeMemberStorages', $missingMembers);
        }
        if (!$changedMembers->isEmpty()) {
            $array = array();
            foreach ($changedMembers->getKeys() as $member) {
                $array[] = $member->getName() . '(' . $member->getType() . ' -> ' . $changedMembers->get($member) . ')';
            }
            throw new spunQ_InitializationError('db.ChangedTypeMemberStorages', $array);
        }
        return NULL;
    }

    public static function getMissingTypes($connection = NULL) {
        if ($connection === NULL) {
            $connection = self::getDefaultConnection();
        }
        $missing = array();
        $storages = $connection->getAllTypeStorages();
        foreach (spunQ_LocalUserType::getAll() as $name => $type) {
            if (!$type->inheritsFrom(spunQ_UserType::getByName('spunQ.db.StorableObject'))) {
                continue;
            }
            if (!isset($storages[$name])) {
                $missing[] = $type;
            }
        }
        return $missing;
    }

    public static function getAdditionalTypes($connection = NULL) {
        if ($connection === NULL) {
            $connection = self::getDefaultConnection();
        }
        $additional = array();
        foreach ($connection->getAllTypeStorages() as $name => $storage) {
            try {
                spunQ_UserType::getByName($name);
            } catch (spunQ_UndefinedTypeError $e) {
                $additional[] = $storage;
            }
        }
        return $additional;
    }

    public static function getChangedTypes($connection = NULL) {
        if ($connection === NULL) {
            $connection = self::getDefaultConnection();
        }
        $changed = new spunQ_Map();
        $storages = $connection->getAllTypeStorages();
        foreach (spunQ_LocalUserType::getAll() as $name => $type) {
            if (!$type->inheritsFrom(spunQ_UserType::getByName('spunQ.db.StorableObject'))) {
                continue;
            }
            if (!isset($storages[$name])) {
                continue;
            }
            if ($storages[$name]->getParent() === NULL) {
                continue;
            }
            if ($storages[$name]->getParent()->getTypeName() !== $type->getParent()->getName()) {
                $changed->add($type, spunQ_Type::getByName($storages[$name]->getParent()->getTypeName()));
            }
        }
        return $changed;
    }

    public static function getMissingTypeMembers($connection = NULL) {
        if ($connection === NULL) {
            $connection = self::getDefaultConnection();
        }
        $missing = array();
        $storages = $connection->getAllTypeStorages();
        foreach (spunQ_LocalUserType::getAll() as $name => $type) {
            if (!$type->inheritsFrom(spunQ_UserType::getByName('spunQ.db.StorableObject'))) {
                continue;
            }
            if (!isset($storages[$name])) {
                continue;
            }
            $memberStorages = $storages[$name]->getMemberStorages();
            foreach ($type->getOwnMembers() as $member) {
                if (!isset($memberStorages[$member->getName()])) {
                    $missing[] = $member;
                }
            }
        }
        return $missing;
    }

    public static function getAdditionalTypeMembers($connection = NULL) {
        if ($connection === NULL) {
            $connection = self::getDefaultConnection();
        }
        $additional = array();
        foreach ($connection->getAllTypeStorages() as $name => $storage) {
            try {
                $type = spunQ_UserType::getByName($name);
                foreach ($storage->getMemberStorages() as $name => $memberStorage) {
                    if (!$type->memberExists($name)) {
                        $additional[] = $memberStorage;
                    }
                }
            } catch (spunQ_UndefinedTypeError $e) {
            }
        }
        return $additional;
    }

    public static function getChangedTypeMembers($connection = NULL) {
        if ($connection === NULL) {
            $connection = self::getDefaultConnection();
        }
        $changed = new spunQ_Map();
        $storages = $connection->getAllTypeStorages();
        foreach (spunQ_LocalUserType::getAll() as $name => $type) {
            if (!$type->inheritsFrom(spunQ_UserType::getByName('spunQ.db.StorableObject'))) {
                continue;
            }
            if (!isset($storages[$name])) {
                continue;
            }
            $memberStorages = $storages[$name]->getMemberStorages();
            foreach ($type->getOwnMembers() as $member) {
                if (!isset($memberStorages[$member->getName()])) {
                    continue;
                }
                $memberStorage = $memberStorages[$member->getName()];
                if ($memberStorage->getTypeString() !== $member->getType()->getName()) {
                    vdebug($memberStorage->getType());
                    $changed->add($member, $memberStorage->getType());
                    continue;
                }
            }
        }
        return $changed;
    }

}

---