Database.php

Go to the documentation of this file.

<?php
namespace Elgg;

use Doctrine\DBAL\DriverManager;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Driver\Statement;
use Doctrine\DBAL\Driver\ServerInfoAwareConnection;

class Database {
    use Profilable;

    const DELAYED_QUERY = 'q';
    const DELAYED_TYPE = 't';
    const DELAYED_HANDLER = 'h';
    const DELAYED_PARAMS = 'p';

    private $table_prefix;

    private $connections = [];

    private $query_count = 0;

    private $query_cache = null;

    private $query_cache_size = 50;

    private $delayed_queries = array();

    private $installed = false;

    private $config;

    private $logger;

    public function __construct(\Elgg\Database\Config $config, \Elgg\Logger $logger = null) {

        $this->logger = $logger;
        $this->config = $config;

        $this->table_prefix = $config->getTablePrefix();

        $this->enableQueryCache();
    }

    public function setLogger(Logger $logger) {
        $this->logger = $logger;
    }

    protected function getConnection($type) {
        if (isset($this->connections[$type])) {
            return $this->connections[$type];
        } else if (isset($this->connections['readwrite'])) {
            return $this->connections['readwrite'];
        } else {
            $this->setupConnections();
            return $this->getConnection($type);
        }
    }

    public function setupConnections() {
        if ($this->config->isDatabaseSplit()) {
            $this->connect('read');
            $this->connect('write');
        } else {
            $this->connect('readwrite');
        }
    }

    public function connect($type = "readwrite") {
        $conf = $this->config->getConnectionConfig($type);

        $params = [
            'dbname' => $conf['database'],
            'user' => $conf['user'],
            'password' => $conf['password'],
            'host' => $conf['host'],
            'charset' => 'utf8',
            'driver' => 'pdo_mysql',
        ];

        try {
            $this->connections[$type] = DriverManager::getConnection($params);
            $this->connections[$type]->setFetchMode(\PDO::FETCH_OBJ);

            // https://github.com/Elgg/Elgg/issues/8121
            $sub_query = "SELECT REPLACE(@@SESSION.sql_mode, 'ONLY_FULL_GROUP_BY', '')";
            $this->connections[$type]->exec("SET SESSION sql_mode=($sub_query);");

        } catch (\PDOException $e) {
            // @todo just allow PDO exceptions
            // http://dev.mysql.com/doc/refman/5.1/en/error-messages-server.html
            if ($e->getCode() == 1102 || $e->getCode() == 1049) {
                $msg = "Elgg couldn't select the database '{$conf['database']}'. "
                    . "Please check that the database is created and you have access to it.";
            } else {
                $msg = "Elgg couldn't connect to the database using the given credentials. Check the settings file.";
            }
            throw new \DatabaseException($msg);
        }
    }

    public function getData($query, $callback = null, array $params = []) {
        return $this->getResults($query, $callback, false, $params);
    }

    public function getDataRow($query, $callback = null, array $params = []) {
        return $this->getResults($query, $callback, true, $params);
    }

    public function insertData($query, array $params = []) {

        if ($this->logger) {
            $this->logger->info("DB query $query");
        }

        $connection = $this->getConnection('write');

        $this->invalidateQueryCache();

        $this->executeQuery($query, $connection, $params);
        return (int)$connection->lastInsertId();
    }

    public function updateData($query, $get_num_rows = false, array $params = []) {

        if ($this->logger) {
            $this->logger->info("DB query $query");
        }

        $this->invalidateQueryCache();

        $stmt = $this->executeQuery($query, $this->getConnection('write'), $params);
        if ($get_num_rows) {
            return $stmt->rowCount();
        } else {
            return true;
        }
    }

    public function deleteData($query, array $params = []) {

        if ($this->logger) {
            $this->logger->info("DB query $query");
        }

        $connection = $this->getConnection('write');

        $this->invalidateQueryCache();

        $stmt = $this->executeQuery("$query", $connection, $params);
        return (int)$stmt->rowCount();
    }

    public function fingerprintCallback($callback) {
        if (is_string($callback)) {
            return $callback;
        }
        if (is_object($callback)) {
            return spl_object_hash($callback) . "::__invoke";
        }
        if (is_array($callback)) {
            if (is_string($callback[0])) {
                return "{$callback[0]}::{$callback[1]}";
            }
            return spl_object_hash($callback[0]) . "::{$callback[1]}";
        }
        // this should not happen
        return "";
    }

    protected function getResults($query, $callback = null, $single = false, array $params = []) {

        // Since we want to cache results of running the callback, we need to
        // need to namespace the query with the callback and single result request.
        // https://github.com/elgg/elgg/issues/4049
        $query_id = (int)$single . $query . '|';
        if ($params) {
            $query_id .= serialize($params) . '|';
        }

        if ($callback) {
            if (!is_callable($callback)) {
                $inspector = new \Elgg\Debug\Inspector();
                throw new \RuntimeException('$callback must be a callable function. Given ' . $inspector->describeCallable($callback));
            }
            $query_id .= $this->fingerprintCallback($callback);
        }
        // MD5 yields smaller mem usage for cache and cleaner logs
        $hash = md5($query_id);

        // Is cached?
        if ($this->query_cache) {
            if (isset($this->query_cache[$hash])) {
                if ($this->logger) {
                    // TODO add params in $query here
                    $this->logger->info("DB query $query results returned from cache (hash: $hash)");
                }
                return $this->query_cache[$hash];
            }
        }

        $return = array();

        $stmt = $this->executeQuery($query, $this->getConnection('read'), $params);
        while ($row = $stmt->fetch()) {
            if ($callback) {
                $row = call_user_func($callback, $row);
            }

            if ($single) {
                $return = $row;
                break;
            } else {
                $return[] = $row;
            }
        }

        // Cache result
        if ($this->query_cache) {
            $this->query_cache[$hash] = $return;
            if ($this->logger) {
                // TODO add params in $query here
                $this->logger->info("DB query $query results cached (hash: $hash)");
            }
        }

        return $return;
    }

    protected function executeQuery($query, Connection $connection, array $params = []) {
        if ($query == null) {
            throw new \DatabaseException("Query cannot be null");
        }

        $this->query_count++;

        if ($this->timer) {
            $timer_key = preg_replace('~\\s+~', ' ', trim($query . '|' . serialize($params)));
            $this->timer->begin(['SQL', $timer_key]);
        }

        try {
            if ($params) {
                $value = $connection->executeQuery($query, $params);
            } else {
                // faster
                $value = $connection->query($query);
            }
        } catch (\Exception $e) {
            throw new \DatabaseException($e->getMessage() . "\n\n"
                    . "QUERY: $query \n\n"
                    . "PARAMS: " . print_r($params, true),
                null,
                $e);
        }

        if ($this->timer) {
            $this->timer->end(['SQL', $timer_key]);
        }

        return $value;
    }

    public function runSqlScript($scriptlocation) {
        $script = file_get_contents($scriptlocation);
        if ($script) {

            $errors = array();

            // Remove MySQL '-- ' and '# ' style comments
            $script = preg_replace('/^(?:--|#) .*$/m', '', $script);

            // Statements must end with ; and a newline
            $sql_statements = preg_split('/;[\n\r]+/', "$script\n");

            foreach ($sql_statements as $statement) {
                $statement = trim($statement);
                $statement = str_replace("prefix_", $this->table_prefix, $statement);
                if (!empty($statement)) {
                    try {
                        $this->updateData($statement);
                    } catch (\DatabaseException $e) {
                        $errors[] = $e->getMessage();
                    }
                }
            }
            if (!empty($errors)) {
                $errortxt = "";
                foreach ($errors as $error) {
                    $errortxt .= " {$error};";
                }

                $msg = "There were a number of issues: " . $errortxt;
                throw new \DatabaseException($msg);
            }
        } else {
            $msg = "Elgg couldn't find the requested database script at " . $scriptlocation . ".";
            throw new \DatabaseException($msg);
        }
    }

    public function registerDelayedQuery($query, $type, $callback = null, array $params = []) {
        if ($type != 'read' && $type != 'write') {
            return false;
        }

        $this->delayed_queries[] = [
            self::DELAYED_QUERY => $query,
            self::DELAYED_TYPE => $type,
            self::DELAYED_HANDLER => $callback,
            self::DELAYED_PARAMS => $params,
        ];

        return true;
    }

    public function executeDelayedQueries() {

        foreach ($this->delayed_queries as $set) {
            $query = $set[self::DELAYED_QUERY];
            $type = $set[self::DELAYED_TYPE];
            $handler = $set[self::DELAYED_HANDLER];
            $params = $set[self::DELAYED_PARAMS];

            try {

                $stmt = $this->executeQuery($query, $this->getConnection($type), $params);

                if (is_callable($handler)) {
                    call_user_func($handler, $stmt);
                }
            } catch (\Exception $e) {
                if ($this->logger) {
                    // Suppress all exceptions since page already sent to requestor
                    $this->logger->error($e);
                }
            }
        }
    }

    public function enableQueryCache() {
        if ($this->config->isQueryCacheEnabled() && $this->query_cache === null) {
            // @todo if we keep this cache, expose the size as a config parameter
            $this->query_cache = new \Elgg\Cache\LRUCache($this->query_cache_size);
        }
    }

    public function disableQueryCache() {
        $this->query_cache = null;
    }

    protected function invalidateQueryCache() {
        if ($this->query_cache) {
            $this->query_cache->clear();
            if ($this->logger) {
                $this->logger->info("Query cache invalidated");
            }
        }
    }

    public function assertInstalled() {

        if ($this->installed) {
            return;
        }

        try {
            $sql = "SELECT value FROM {$this->table_prefix}datalists WHERE name = 'installed'";
            $this->getConnection('read')->query($sql);
        } catch (\DatabaseException $e) {
            throw new \InstallationException("Unable to handle this request. This site is not configured or the database is down.");
        }

        $this->installed = true;
    }

    public function getQueryCount() {
        return $this->query_count;
    }

    public function getTablePrefix() {
        if (function_exists('elgg_deprecated_notice')) {
            elgg_deprecated_notice(__METHOD__ . ' is deprecated. Read the "prefix" property', '2.3');
        }
        return $this->table_prefix;
    }

    public function sanitizeInt($value, $signed = true) {
        $value = (int) $value;

        if ($signed === false) {
            if ($value < 0) {
                $value = 0;
            }
        }

        return $value;
    }

    public function sanitizeString($value) {
        if (is_array($value)) {
            throw new \DatabaseException(__METHOD__ . '() and serialize_string() cannot accept arrays.');
        }
        $quoted = $this->getConnection('read')->quote($value);
        if ($quoted[0] !== "'" || substr($quoted, -1) !== "'") {
            throw new \DatabaseException("PDO::quote did not return surrounding single quotes.");
        }
        return substr($quoted, 1, -1);
    }

    public function getServerVersion($type) {
        $driver = $this->getConnection($type)->getWrappedConnection();
        if ($driver instanceof ServerInfoAwareConnection) {
            return $driver->getServerVersion();
        }

        return null;
    }

    public function __get($name) {
        if ($name === 'prefix') {
            return $this->table_prefix;
        }

        throw new \RuntimeException("Cannot read property '$name'");
    }

    public function __set($name, $value) {
        throw new \RuntimeException("Cannot write property '$name'");
    }
}