SilverStripe\ORM\Connect\NullDatabase

Complexity

Total Complexity

57

Size/Duplication

Total Lines	448
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

46 Methods

Rating	Name	Duplication	Size	Complexity
A	transactionEnd()	0	2	1
A	formattedDatetimeClause()	0	2	1
A	escapeIdentifier()	0	3	1
A	selectDatabase()	0	2	1
A	supportsExtensions()	0	3	1
A	random()	0	2	1
A	nullCheckClause()	0	6	2
A	datetimeDifferenceClause()	0	2	1
A	preparedQuery()	0	3	1
A	supportsCollations()	0	2	1
A	canLock()	0	3	1
A	getLock()	0	3	1
A	concatOperator()	0	2	1
A	getGeneratedID()	0	3	1
A	getVersion()	0	2	1
A	transactionStart()	0	2	1
A	__construct()	0	6	1
A	transactionSavepoint()	0	2	1
A	clearAllData()	0	3	1
A	affectedRows()	0	2	1
A	now()	0	2	1
A	supportsLocks()	0	3	1
A	comparisonClause()	0	8	1
A	supportsTransactionMode()	0	2	1
B	withTransaction()	0	26	8
A	transactionDepth()	0	7	2
A	transactionRollback()	0	2	1
A	getSelectedDatabase()	0	2	1
A	supportsTimezoneOverride()	0	2	1
A	getDatabaseServer()	0	2	1
A	dropSelectedDatabase()	0	2	1
A	supportsSavepoints()	0	2	1
A	searchEngine()	0	11	1
A	releaseLock()	0	3	1
A	connect()	0	15	3
A	escapeColumnKeys()	0	3	1
A	isActive()	0	3	1
A	clearTable()	0	3	1
A	quoteString()	0	3	1
A	escapeString()	0	3	1
A	supportsTransactions()	0	2	1
A	query()	0	3	1
A	datetimeIntervalClause()	0	2	1
A	databaseList()	0	3	1
A	manipulate()	0	3	1
A	databaseExists()	0	3	1

<?php

namespace SilverStripe\ORM\Connect;

use BadMethodCallException;
use Exception;

/**
 * Utility class required due to bad coupling in framework.
 * Not every framework execution should require a working database connection.
 * For example, when generating class and config manifests for deployment bundles,
 * or when generating code in a silverstripe/graphql schema build.
 *
 * This class creates the required no-ops to
 *
 * @internal
 */
class NullDatabase extends Database
{

    public function __construct()
    {
        $this->connector = new NullConnector();
        $this->schemaManager = new MySQLSchemaManager();
        $this->schemaManager->setDatabase($this);
        $this->queryBuilder = new MySQLQueryBuilder();
    }

    public function query($sql, $errorLevel = E_USER_ERROR)
    {
        throw new \Exception('cannot query');
    }

    public function preparedQuery($sql, $parameters, $errorLevel = E_USER_ERROR)
    {
        throw new \Exception('cannot query');
    }

    /**
     * Get the autogenerated ID from the previous INSERT query.
     *
     * @param string $table The name of the table to get the generated ID for
     * @return integer the most recently generated ID for the specified table
     */
    public function getGeneratedID($table)
    {
        return $this->connector->getGeneratedID($table);
    }

    /**
     * Determines if we are connected to a server AND have a valid database
     * selected.
     *
     * @return boolean Flag indicating that a valid database is connected
     */
    public function isActive()
    {
        return true;
    }

    /**
     * Returns an escaped string. This string won't be quoted, so would be suitable
     * for appending to other quoted strings.
     *
     * @param mixed $value Value to be prepared for database query
     * @return string Prepared string
     */
    public function escapeString($value)
    {
        return $value;
    }

    /**
     * Wrap a string into DB-specific quotes.
     *
     * @param mixed $value Value to be prepared for database query
     * @return string Prepared string
     */
    public function quoteString($value)
    {
        return $value;
    }

    public function escapeIdentifier($value, $separator = '.')
    {
        return $value;
    }

    protected function escapeColumnKeys($fieldValues)
    {
        return $fieldValues;
    }

    public function manipulate($manipulation)
    {
        throw new \Exception('cannot query');
    }

    /**
     * Clear all data out of the database
     */
    public function clearAllData()
    {
        throw new \Exception('cannot query');
    }

    /**
     * Clear all data in a given table
     *
     * @param string $table Name of table
     */
    public function clearTable($table)
    {
        throw new \Exception('cannot query');
    }

    /**
     * Generates a WHERE clause for null comparison check
     *
     * @param string $field Quoted field name
     * @param bool $isNull Whether to check for NULL or NOT NULL
     * @return string Non-parameterised null comparison clause
     */
    public function nullCheckClause($field, $isNull)
    {
        $clause = $isNull
            ? "%s IS NULL"
            : "%s IS NOT NULL";
        return sprintf($clause, $field);
    }

    public function comparisonClause(
        $field,
        $value,
        $exact = false,
        $negate = false,
        $caseSensitive = null,
        $parameterised = false
    ) {
        // no-op
    }

    public function formattedDatetimeClause($date, $format)
    {
        // no-op
    }

    public function datetimeIntervalClause($date, $interval)
    {
        // no-op
    }

    public function datetimeDifferenceClause($date1, $date2)
    {
        // no-op
    }

    public function concatOperator()
    {
        // no-op
    }

    public function supportsCollations()
    {
        // no-op
    }

    public function supportsTimezoneOverride()
    {
        // no-op
    }

    public function getVersion()
    {
        // no-op
    }

    public function getDatabaseServer()
    {
        // no-op
    }

    public function affectedRows()
    {
        // no-op
    }

    public function searchEngine(
        $classesToSearch,
        $keywords,
        $start,
        $pageLength,
        $sortBy = "Relevance DESC",
        $extraFilter = "",
        $booleanSearch = false,
        $alternativeFileFilter = "",
        $invertedMatch = false
    ) {
        // no-op
    }

    public function supportsTransactions()
    {
        // no-op
    }

    public function supportsSavepoints()
    {
        // no-op
    }


    public function supportsTransactionMode(string $mode): bool
    {
        // no-op
    }

    /**
     * Invoke $callback within a transaction
     *
     * @param callable $callback Callback to run
     * @param callable $errorCallback Optional callback to run after rolling back transaction.
     * @param bool|string $transactionMode Optional transaction mode to use
     * @param bool $errorIfTransactionsUnsupported If true, this method will fail if transactions are unsupported.
     * Otherwise, the $callback will potentially be invoked outside of a transaction.
     * @throws Exception
     */
    public function withTransaction(
        $callback,
        $errorCallback = null,
        $transactionMode = false,
        $errorIfTransactionsUnsupported = false
    ) {
        $supported = $this->supportsTransactions();

Are you sure the assignment to $supported is correct as $this->supportsTransactions() targeting SilverStripe\ORM\Connect\NullDatabase::supportsTransactions() seems to always return null.

        if (!$supported && $errorIfTransactionsUnsupported) {

$supported is defined implicitly as null, thus it is always evaluated to false.

            throw new BadMethodCallException("Transactions not supported by this database.");
        }
        if ($supported) {

$supported is defined implicitly as null, thus it is always evaluated to false.

            $this->transactionStart($transactionMode);
        }
        try {
            call_user_func($callback);
        } catch (Exception $ex) {
            if ($supported) {

$supported is defined implicitly as null, thus it is always evaluated to false.

                $this->transactionRollback();
            }
            if ($errorCallback) {
                call_user_func($errorCallback);
            }
            throw $ex;
        }
        if ($supported) {

$supported is defined implicitly as null, thus it is always evaluated to false.

            $this->transactionEnd();
        }
    }

    /*
     * Determines if the current database connection supports a given list of extensions
     *
     * @param array $extensions List of extensions to check for support of. The key of this array
     * will be an extension name, and the value the configuration for that extension. This
     * could be one of partitions, tablespaces, or clustering
     * @return boolean Flag indicating support for all of the above
     * @todo Write test cases
     */
    public function supportsExtensions($extensions)
    {
        return false;
    }

    /**
     * Start a prepared transaction
     * See http://developer.postgresql.org/pgdocs/postgres/sql-set-transaction.html for details on
     * transaction isolation options
     *
     * @param string|boolean $transactionMode Transaction mode, or false to ignore
     * @param string|boolean $sessionCharacteristics Session characteristics, or false to ignore
     */
    public function transactionStart($transactionMode = false, $sessionCharacteristics = false)
    {
        // no-op
    }

    /**
     * Create a savepoint that you can jump back to if you encounter problems
     *
     * @param string $savepoint Name of savepoint
     */
    public function transactionSavepoint($savepoint)
    {
        // no-op
    }

    /**
     * Rollback or revert to a savepoint if your queries encounter problems
     * If you encounter a problem at any point during a transaction, you may
     * need to rollback that particular query, or return to a savepoint
     *
     * @param string|boolean $savepoint Name of savepoint, or leave empty to rollback
     * to last savepoint
     * @return bool|null Boolean is returned if success state is known, or null if
     * unknown. Note: For error checking purposes null should not be treated as error.
     */
    public function transactionRollback($savepoint = false)
    {
        // no-op
    }

    /**
     * Commit everything inside this transaction so far
     *
     * @param bool $chain
     * @return bool|null Boolean is returned if success state is known, or null if
     * unknown. Note: For error checking purposes null should not be treated as error.
     */
    public function transactionEnd($chain = false)
    {
        // no-op
    }

    /**
     * Return depth of current transaction
     *
     * @return int Nesting level, or 0 if not in a transaction
     */
    public function transactionDepth()
    {
        // Placeholder error for transactional DBs that don't expose depth
        if ($this->supportsTransactions()) {

Are you sure the usage of $this->supportsTransactions() targeting SilverStripe\ORM\Connect\NullDatabase::supportsTransactions() seems to always return null.

            user_error(get_class($this) . " does not support transactionDepth", E_USER_WARNING);
        }
        return 0;
    }

    /**
     * Determines if the used database supports application-level locks,
     * which is different from table- or row-level locking.
     * See {@link getLock()} for details.
     *
     * @return bool Flag indicating that locking is available
     */
    public function supportsLocks()
    {
        return false;
    }

    /**
     * Returns if the lock is available.
     * See {@link supportsLocks()} to check if locking is generally supported.
     *
     * @param string $name Name of the lock
     * @return bool
     */
    public function canLock($name)
    {
        return false;
    }

    /**
     * Sets an application-level lock so that no two processes can run at the same time,
     * also called a "cooperative advisory lock".
     *
     * Return FALSE if acquiring the lock fails; otherwise return TRUE, if lock was acquired successfully.
     * Lock is automatically released if connection to the database is broken (either normally or abnormally),
     * making it less prone to deadlocks than session- or file-based locks.
     * Should be accompanied by a {@link releaseLock()} call after the logic requiring the lock has completed.
     * Can be called multiple times, in which case locks "stack" (PostgreSQL, SQL Server),
     * or auto-releases the previous lock (MySQL).
     *
     * Note that this might trigger the database to wait for the lock to be released, delaying further execution.
     *
     * @param string $name Name of lock
     * @param integer $timeout Timeout in seconds
     * @return bool
     */
    public function getLock($name, $timeout = 5)
    {
        return false;
    }

    /**
     * Remove an application-level lock file to allow another process to run
     * (if the execution aborts (e.g. due to an error) all locks are automatically released).
     *
     * @param string $name Name of the lock
     * @return bool Flag indicating whether the lock was successfully released
     */
    public function releaseLock($name)
    {
        return false;
    }

    /**
     * Instruct the database to generate a live connection
     *
     * @param array $parameters An map of parameters, which should include:
     *  - server: The server, eg, localhost
     *  - username: The username to log on with
     *  - password: The password to log on with
     *  - database: The database to connect to
     *  - charset: The character set to use. Defaults to utf8
     *  - timezone: (optional) The timezone offset. For example: +12:00, "Pacific/Auckland", or "SYSTEM"
     *  - driver: (optional) Driver name
     */
    public function connect($parameters)
    {
        // Ensure that driver is available (required by PDO)
        if (empty($parameters['driver'])) {
            $parameters['driver'] = $this->getDatabaseServer();

Are you sure the assignment to $parameters['driver'] is correct as $this->getDatabaseServer() targeting SilverStripe\ORM\Connect\NullDatabase::getDatabaseServer() seems to always return null.

        }

        // Notify connector of parameters
        $this->connector->connect($parameters);

        // SS_Database subclass maintains responsibility for selecting database
        // once connected in order to correctly handle schema queries about
        // existence of database, error handling at the correct level, etc
        if (!empty($parameters['database'])) {
            $this->selectDatabase($parameters['database'], false, false);
        }
    }

    /**
     * Determine if the database with the specified name exists
     *
     * @param string $name Name of the database to check for
     * @return bool Flag indicating whether this database exists
     */
    public function databaseExists($name)
    {
        return $this->schemaManager->databaseExists($name);
    }

    /**
     * Retrieves the list of all databases the user has access to
     *
     * @return array List of database names
     */
    public function databaseList()
    {
        return $this->schemaManager->databaseList();
    }

    public function selectDatabase($name, $create = false, $errorLevel = E_USER_ERROR)
    {
        // no-op
    }

    public function dropSelectedDatabase()
    {
        // no-op
    }

    public function getSelectedDatabase()
    {
        // no-op
    }

    public function now()
    {
        // no-op
    }

    public function random()
    {
        // no-op
    }
}