Database.php

Go to the documentation of this file.

<?php
namespace Elgg;

class Database {

    private $tablePrefix;

    private $dbLinks = array();

    private $queryCount = 0;

    private $queryCache = null;

    private $queryCacheSize = 50;

    private $delayedQueries = array();

    private $installed = false;

    private $config;

    private $logger;

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

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

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

        $this->enableQueryCache();
    }

    public function getLink($type) {
        if (isset($this->dbLinks[$type])) {
            return $this->dbLinks[$type];
        } else if (isset($this->dbLinks['readwrite'])) {
            return $this->dbLinks['readwrite'];
        } else {
            $this->setupConnections();
            return $this->getLink($type);
        }
    }

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


    public function establishLink($dblinkname = "readwrite") {

        $conf = $this->config->getConnectionConfig($dblinkname);

        // Connect to database
        $this->dbLinks[$dblinkname] = mysql_connect($conf['host'], $conf['user'], $conf['password'], true);
        if (!$this->dbLinks[$dblinkname]) {
            $msg = "Elgg couldn't connect to the database using the given credentials. Check the settings file.";
            throw new \DatabaseException($msg);
        }

        if (!mysql_select_db($conf['database'], $this->dbLinks[$dblinkname])) {
            $msg = "Elgg couldn't select the database '{$conf['database']}'. Please check that the database is created and you have access to it.";
            throw new \DatabaseException($msg);
        }

        // Set DB for UTF8
        mysql_query("SET NAMES utf8");
    }

    public function getData($query, $callback = '') {
        return $this->getResults($query, $callback, false);
    }

    public function getDataRow($query, $callback = '') {
        return $this->getResults($query, $callback, true);
    }

    public function insertData($query) {

        $this->logger->log("DB query $query", \Elgg\Logger::INFO);

        $dblink = $this->getLink('write');

        $this->invalidateQueryCache();

        if ($this->executeQuery("$query", $dblink)) {
            return mysql_insert_id($dblink);
        }

        return false;
    }

    public function updateData($query, $getNumRows = false) {

        $this->logger->log("DB query $query", \Elgg\Logger::INFO);

        $dblink = $this->getLink('write');

        $this->invalidateQueryCache();

        if ($this->executeQuery("$query", $dblink)) {
            if ($getNumRows) {
                return mysql_affected_rows($dblink);
            } else {
                return true;
            }
        }

        return false;
    }

    public function deleteData($query) {

        $this->logger->log("DB query $query", \Elgg\Logger::INFO);

        $dblink = $this->getLink('write');

        $this->invalidateQueryCache();

        if ($this->executeQuery("$query", $dblink)) {
            return mysql_affected_rows($dblink);
        }

        return false;
    }

    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) {

        // 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 ($callback) {
            $is_callable = is_callable($callback);
            if ($is_callable) {
                $query_id .= $this->fingerprintCallback($callback);
            } else {
                // TODO do something about invalid callbacks
                $callback = null;
            }
        } else {
            $is_callable = false;
        }
        // MD5 yields smaller mem usage for cache and cleaner logs
        $hash = md5($query_id);

        // Is cached?
        if ($this->queryCache) {
            if (isset($this->queryCache[$hash])) {
                $this->logger->log("DB query $query results returned from cache (hash: $hash)", \Elgg\Logger::INFO);
                return $this->queryCache[$hash];
            }
        }

        $dblink = $this->getLink('read');
        $return = array();

        if ($result = $this->executeQuery("$query", $dblink)) {
            while ($row = mysql_fetch_object($result)) {
                if ($is_callable) {
                    $row = call_user_func($callback, $row);
                }

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

        if (empty($return)) {
            $this->logger->log("DB query $query returned no results.", \Elgg\Logger::INFO);
        }

        // Cache result
        if ($this->queryCache) {
            $this->queryCache[$hash] = $return;
            $this->logger->log("DB query $query results cached (hash: $hash)", \Elgg\Logger::INFO);
        }

        return $return;
    }

    public function executeQuery($query, $dblink) {

        if ($query == null) {
            throw new \DatabaseException("Query cannot be null");
        }

        if (!is_resource($dblink)) {
            throw new \DatabaseException("Connection to database was lost.");
        }

        $this->queryCount++;

        $result = mysql_query($query, $dblink);

        if (mysql_errno($dblink)) {
            throw new \DatabaseException(mysql_error($dblink) . "\n\n QUERY: $query");
        }

        return $result;
    }

    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->tablePrefix, $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, $handler = "") {

        if (!is_resource($type) && $type != 'read' && $type != 'write') {
            return false;
        }

        // Construct delayed query
        $delayed_query = array();
        $delayed_query['q'] = $query;
        $delayed_query['l'] = $type;
        $delayed_query['h'] = $handler;

        $this->delayedQueries[] = $delayed_query;

        return true;
    }


    public function executeDelayedQueries() {

        foreach ($this->delayedQueries as $query_details) {
            try {
                $link = $query_details['l'];

                if ($link == 'read' || $link == 'write') {
                    $link = $this->getLink($link);
                } elseif (!is_resource($link)) {
                    $msg = "Link for delayed query not valid resource or db_link type. Query: {$query_details['q']}";
                    $this->logger->log($msg, \Elgg\Logger::WARNING);
                }

                $result = $this->executeQuery($query_details['q'], $link);

                if ((isset($query_details['h'])) && (is_callable($query_details['h']))) {
                    $query_details['h']($result);
                }
            } catch (\DatabaseException $e) {
                // Suppress all exceptions since page already sent to requestor
                $this->logger->log($e, \Elgg\Logger::ERROR);
            }
        }
    }

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

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

    protected function invalidateQueryCache() {
        if ($this->queryCache) {
            $this->queryCache->clear();
            $this->logger->log("Query cache invalidated", \Elgg\Logger::INFO);
        }
    }

    public function assertInstalled() {

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

        try {
            $dblink = $this->getLink('read');
            mysql_query("SELECT value FROM {$this->tablePrefix}datalists WHERE name = 'installed'", $dblink);
            if (mysql_errno($dblink) > 0) {
                throw new \DatabaseException();
            }
        } 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->queryCount;
    }

    public function getTablePrefix() {
        return $this->tablePrefix;
    }

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

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

        return $value;
    }

    public function sanitizeString($value) {
        return mysql_real_escape_string($value);
    }
}