Database.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Driver\Exception\NoIdentityValue;
use Doctrine\DBAL\DriverManager;
use Doctrine\DBAL\Exception\DriverException;
use Doctrine\DBAL\Result;
use Elgg\Cache\QueryCache;
use Elgg\Database\DbConfig;
use Elgg\Database\QueryBuilder;
use Elgg\Exceptions\DatabaseException;
use Elgg\Exceptions\RuntimeException;
use Elgg\Traits\Debug\Profilable;
use Elgg\Traits\Loggable;
use Psr\Log\LogLevel;
 
class Database {
    
    use Profilable;
    use Loggable;
 
    const DELAYED_QUERY = 'q';
    const DELAYED_HANDLER = 'h';
 
    protected $table_prefix;
 
    protected array $connections = [];
 
    protected int $query_count = 0;
 
    protected array $delayed_queries = [];
 
    protected $db_config;
 
    public function __construct(DbConfig $db_config, protected QueryCache $query_cache, protected Config $config) {
        $this->resetConnections($db_config);
    }
 
    public function resetConnections(DbConfig $config): void {
        $this->closeConnections();
        
        $this->db_config = $config;
        $this->table_prefix = $config->getTablePrefix();
        $this->query_cache->enable();
        $this->query_cache->clear();
    }
    
    public function closeConnections(): void {
        foreach ($this->connections as $connection) {
            $connection->close();
        }
        
        $this->connections = [];
    }
 
    public function getConnection(string $type): Connection {
        if (isset($this->connections[$type])) {
            // type is configured
            return $this->connections[$type];
        } elseif (isset($this->connections[DbConfig::READ_WRITE])) {
            // fallback, for request of read/write but no split db
            return $this->connections[DbConfig::READ_WRITE];
        } elseif (isset($this->connections[DbConfig::READ])) {
            // split db configured, readwrite requested
            return $this->connections[DbConfig::READ];
        }
        
        $this->setupConnections();
        
        return $this->getConnection($type);
    }
 
    public function setupConnections(): void {
        if ($this->db_config->isDatabaseSplit()) {
            $this->connect(DbConfig::READ);
            $this->connect(DbConfig::WRITE);
        } else {
            $this->connect(DbConfig::READ_WRITE);
        }
    }
 
    public function connect(string $type = DbConfig::READ_WRITE): void {
        $conf = $this->db_config->getConnectionConfig($type);
 
        $params = [
            'dbname' => $conf['database'],
            'user' => $conf['user'],
            'password' => $conf['password'],
            'host' => $conf['host'],
            'port' => $conf['port'],
            'charset' => $conf['encoding'],
            'driver' => 'pdo_mysql',
        ];
 
        try {
            $this->connections[$type] = DriverManager::getConnection($params);
 
            // https://github.com/Elgg/Elgg/issues/8121
            $sub_query = "SELECT REPLACE(@@SESSION.sql_mode, 'ONLY_FULL_GROUP_BY', '')";
            $this->connections[$type]->executeStatement("SET SESSION sql_mode=($sub_query);");
        } catch (\Exception $e) {
            // http://dev.mysql.com/doc/refman/5.1/en/error-messages-server.html
            $this->log(LogLevel::ERROR, $e);
 
            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(QueryBuilder $query, $callback = null) {
        return $this->getResults($query, $callback, false);
    }
 
    public function getDataRow(QueryBuilder $query, $callback = null) {
        return $this->getResults($query, $callback, true);
    }
 
    public function insertData(QueryBuilder $query): int {
 
        $params = $query->getParameters();
        $sql = $query->getSQL();
        
        $this->getLogger()->info("DB insert query {$sql} (params: " . print_r($params, true) . ')');
 
        $this->executeQuery($query);
        
        try {
            return (int) $query->getConnection()->lastInsertId();
        } catch (DriverException $e) {
            if ($e->getPrevious() instanceof NoIdentityValue) {
                return 0;
            }
            
            throw $e;
        }
    }
 
    public function updateData(QueryBuilder $query, bool $get_num_rows = false): bool|int {
        $params = $query->getParameters();
        $sql = $query->getSQL();
    
        $this->getLogger()->info("DB update query {$sql} (params: " . print_r($params, true) . ')');
 
        $result = $this->executeQuery($query);
        if (!$get_num_rows) {
            return true;
        }
 
        return ($result instanceof Result) ? (int) $result->rowCount() : $result;
    }
 
    public function deleteData(QueryBuilder $query): int {
        $params = $query->getParameters();
        $sql = $query->getSQL();
 
        $this->getLogger()->info("DB delete query {$sql} (params: " . print_r($params, true) . ')');
 
        $result = $this->executeQuery($query);
        return ($result instanceof Result) ? (int) $result->rowCount() : $result;
    }
 
    protected function fingerprintCallback($callback): string {
        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(QueryBuilder $query, $callback = null, bool $single = false) {
        $params = $query->getParameters();
        $sql = $query->getSQL();
        
        // Since we want to cache results of running the callback, we need to
        // namespace the query with the callback and single result request.
        // https://github.com/elgg/elgg/issues/4049
        $extras = (int) $single . '|';
        if ($callback) {
            if (!is_callable($callback)) {
                throw new RuntimeException('$callback must be a callable function. Given ' . _elgg_services()->handlers->describeCallable($callback));
            }
            
            $extras .= $this->fingerprintCallback($callback);
        }
        
        $hash = $this->getCacheHash($sql, $params, $extras);
 
        $cached_results = $this->query_cache->load($hash);
        if (isset($cached_results)) {
            return $cached_results;
        }
        
        $this->getLogger()->info("DB select query {$sql} (params: " . print_r($params, true) . ')');
        
        $return = [];
 
        $stmt = $this->executeQuery($query);
        
        while ($row = $stmt->fetchAssociative()) {
            $row_obj = (object) $row;
            if ($callback) {
                $row_obj = call_user_func($callback, $row_obj);
            }
 
            if ($single) {
                $return = $row_obj;
                break;
            } else {
                $return[] = $row_obj;
            }
        }
        
        $this->query_cache->save($hash, $return);
                
        return $return;
    }
 
    protected function executeQuery(QueryBuilder $query) {
        
        try {
            $result = $this->trackQuery($query, function() use ($query) {
                if ($query instanceof \Elgg\Database\Select) {
                    return $query->executeQuery();
                } else {
                    return $query->executeStatement();
                }
            });
        } catch (\Exception $e) {
            $ex = new DatabaseException($e->getMessage(), 0, $e);
            $ex->setParameters($query->getParameters());
            $ex->setQuery($query->getSQL());
 
            throw $ex;
        }
 
        return $result;
    }
    
    protected function getCacheHash(string $sql, array $params = [], string $extras = ''): string {
        $query_id = $sql . '|';
        if (!empty($params)) {
            $query_id .= serialize($params) . '|';
        }
        
        $query_id .= $extras;
        
        // MD5 yields smaller mem usage for cache
        return md5($query_id);
    }
    
    public function trackQuery(QueryBuilder $query, callable $callback) {
        $params = $query->getParameters();
        $sql = $query->getSQL();
 
        if ($this->config->db_enable_query_logging) {
            $this->getLogger()->notice($sql, ['params' => $params]);
        }
 
        $this->query_count++;
 
        $timer_key = preg_replace('~\\s+~', ' ', trim($sql . '|' . serialize($params)));
        $this->beginTimer(['SQL', $timer_key]);
        
        $stop_timer = function() use ($timer_key) {
            $this->endTimer(['SQL', $timer_key]);
        };
        
        try {
            $result = $callback();
        } catch (\Exception $e) {
            $stop_timer();
            
            throw $e;
        }
        
        $stop_timer();
        
        return $result;
    }
 
    public function registerDelayedQuery(QueryBuilder $query, $callback = null): void {
        if (Application::isCli() && !$this->config->testing_mode) {
            // during CLI execute delayed queries immediately (unless in testing mode, during PHPUnit)
            // this should prevent OOM during long-running jobs
            // @see Database::executeDelayedQueries()
            try {
                $stmt = $this->executeQuery($query);
                
                if (is_callable($callback)) {
                    call_user_func($callback, $stmt);
                }
            } catch (\Throwable $t) {
                // Suppress all exceptions to not allow the application to crash
                $this->getLogger()->error($t);
            }
            
            return;
        }
        
        $this->delayed_queries[] = [
            self::DELAYED_QUERY => $query,
            self::DELAYED_HANDLER => $callback,
        ];
    }
 
    public function executeDelayedQueries(): void {
 
        foreach ($this->delayed_queries as $set) {
            $query = $set[self::DELAYED_QUERY];
            $handler = $set[self::DELAYED_HANDLER];
 
            try {
                $stmt = $this->executeQuery($query);
 
                if (is_callable($handler)) {
                    call_user_func($handler, $stmt);
                }
            } catch (\Throwable $t) {
                // Suppress all exceptions since page already sent to requestor
                $this->getLogger()->error($t);
            }
        }
 
        $this->delayed_queries = [];
    }
 
    public function getQueryCount(): int {
        return $this->query_count;
    }
 
    public function getServerVersion(string $type = DbConfig::READ): string {
        return $this->getConnection($type)->getServerVersion();
    }
 
    public function isMariaDB(string $type = DbConfig::READ): bool {
        return $this->getConnection($type)->getDatabasePlatform() instanceof \Doctrine\DBAL\Platforms\MariaDBPlatform;
    }
    
    public function isMySQL(string $type = DbConfig::READ): bool {
        return $this->getConnection($type)->getDatabasePlatform() instanceof \Doctrine\DBAL\Platforms\MySQLPlatform;
    }
    
    public function __get($name) {
        if ($name === 'prefix') {
            return $this->table_prefix;
        }
 
        throw new RuntimeException("Cannot read property '{$name}'");
    }
 
    public function __set($name, $value): void {
        throw new RuntimeException("Cannot write property '{$name}'");
    }
}