connection.php

<?php
 
namespace Bitrix\Main\DB;
 
use Bitrix\Main;
use Bitrix\Main\ArgumentNullException;
use Bitrix\Main\Data;
use Bitrix\Main\Diag;
use Bitrix\Main\ORM\Fields\ScalarField;
 
abstract class Connection extends Data\Connection
{
    protected $sqlHelper;
 
    protected $sqlTracker;
    protected $trackSql = false;
 
    protected $version;
    protected $versionExpress;
 
    protected $host;
    protected $database;
    protected $login;
    protected $password;
    protected $initCommand = 0;
    protected $options = 0;
    protected $nodeId = 0;
    protected $utf8mb4 = array();
 
    protected $tableColumnsCache = array();
    protected $lastQueryResult;
 
    protected $queryExecutingEnabled = true;
 
    protected $disabledQueryExecutingDump;
 
    const PERSISTENT = 1;
    const DEFERRED = 2;
 
    const INDEX_UNIQUE = 'UNIQUE';
    const INDEX_FULLTEXT = 'FULLTEXT';
    const INDEX_SPATIAL = 'SPATIAL';
 
    public function __construct(array $configuration)
    {
        parent::__construct($configuration);
 
        $this->host = $configuration['host'] ?? '';
        $this->database = $configuration['database'] ?? '';
        $this->login = $configuration['login'] ?? '';
        $this->password = $configuration['password'] ?? '';
        $this->initCommand = $configuration['initCommand'] ?? '';
        $this->options = intval($configuration['options'] ?? 2);
        $this->utf8mb4 = (isset($configuration['utf8mb4']) && is_array($configuration['utf8mb4'])? $configuration['utf8mb4'] : []);
    }
 
    public function getDbName()
    {
        return $this->getDatabase();
    }
 
    public function getHost()
    {
        return $this->host;
    }
 
    public function getLogin()
    {
        return $this->login;
    }
 
    public function getPassword()
    {
        return $this->password;
    }
 
    public function getDatabase()
    {
        return $this->database;
    }
 
    public function disableQueryExecuting()
    {
        $this->queryExecutingEnabled = false;
    }
 
    public function enableQueryExecuting()
    {
        $this->queryExecutingEnabled = true;
    }
 
    public function isQueryExecutingEnabled()
    {
        return $this->queryExecutingEnabled;
    }
 
    public function getDisabledQueryExecutingDump()
    {
        $dump = $this->disabledQueryExecutingDump;
        $this->disabledQueryExecutingDump = null;
 
        return $dump;
    }
 
    /**********************************************************
     * SqlHelper
     **********************************************************/
 
    abstract protected function createSqlHelper();
 
    public function getSqlHelper()
    {
        if ($this->sqlHelper == null)
        {
            $this->sqlHelper = $this->createSqlHelper();
        }
 
        return $this->sqlHelper;
    }
 
    /***********************************************************
     * Connection and disconnection
     ***********************************************************/
 
    public function connect()
    {
        $this->isConnected = false;
 
        if (!$this->isDeferred())
        {
            parent::connect();
        }
    }
 
    public function disconnect()
    {
        if (!$this->isPersistent())
        {
            parent::disconnect();
        }
    }
 
    public function isDeferred()
    {
        return (($this->options & self::DEFERRED) !== 0);
    }
 
    public function isPersistent()
    {
        return (($this->options & self::PERSISTENT) !== 0);
    }
 
    /*********************************************************
     * Query
     *********************************************************/
 
    abstract protected function queryInternal($sql, array $binds = null, Diag\SqlTrackerQuery $trackerQuery = null);
 
    abstract protected function createResult($result, Diag\SqlTrackerQuery $trackerQuery = null);
 
    public function query($sql)
    {
        list($sql, $binds, $offset, $limit) = self::parseQueryFunctionArgs(func_get_args());
 
        if($limit > 0)
        {
            $sql = $this->getSqlHelper()->getTopSql($sql, $limit, $offset);
        }
 
        $trackerQuery = null;
 
        if ($this->queryExecutingEnabled)
        {
            $connection = Main\Application::getInstance()->getConnectionPool()->getSlaveConnection($sql);
            if($connection === null)
            {
                $connection = $this;
            }
 
            if ($this->trackSql)
            {
                $trackerQuery = $this->sqlTracker->getNewTrackerQuery();
                $trackerQuery->setNode($connection->getNodeId());
            }
 
            $result = $connection->queryInternal($sql, $binds, $trackerQuery);
        }
        else
        {
            if ($this->disabledQueryExecutingDump === null)
            {
                $this->disabledQueryExecutingDump = array();
            }
 
            $this->disabledQueryExecutingDump[] = $sql;
            $result = true;
        }
 
        return $this->createResult($result, $trackerQuery);
    }
 
    public function queryScalar($sql, array $binds = null)
    {
        $result = $this->query($sql, $binds, 0, 1);
 
        if ($row = $result->fetch())
        {
            return array_shift($row);
        }
 
        return null;
    }
 
    public function queryExecute($sql, array $binds = null)
    {
        $this->query($sql, $binds);
    }
 
    protected static function parseQueryFunctionArgs($args)
    {
        /*
         * query($sql)
         * query($sql, $limit)
         * query($sql, $offset, $limit)
         * query($sql, $arBinds)
         * query($sql, $arBinds, $limit)
         * query($sql, $arBinds, $offset, $limit)
         */
        $numArgs = count($args);
        if ($numArgs < 1)
            throw new ArgumentNullException("sql");
 
        $binds = array();
        $offset = 0;
        $limit = 0;
 
        if ($numArgs == 1)
        {
            $sql = $args[0];
        }
        elseif ($numArgs == 2)
        {
            if (is_array($args[1]))
                list($sql, $binds) = $args;
            else
                list($sql, $limit) = $args;
        }
        elseif ($numArgs == 3)
        {
            if (is_array($args[1]))
                list($sql, $binds, $limit) = $args;
            else
                list($sql, $offset, $limit) = $args;
        }
        else
        {
            list($sql, $binds, $offset, $limit) = $args;
        }
 
        return array($sql, $binds, $offset, $limit);
    }
 
    public function add($tableName, array $data, $identity = "ID")
    {
        $insert = $this->getSqlHelper()->prepareInsert($tableName, $data);
 
        $sql =
            "INSERT INTO ".$this->getSqlHelper()->quote($tableName)."(".$insert[0].") ".
            "VALUES (".$insert[1].")";
 
        $this->queryExecute($sql);
 
        return $this->getInsertedId();
    }
 
    public function addMulti($tableName, $rows, $identity = "ID")
    {
        $uniqueColumns = [];
        $inserts = [];
 
        // prepare data
        foreach ($rows as $data)
        {
            $insert = $this->getSqlHelper()->prepareInsert($tableName, $data, true);
            $inserts[] = $insert;
 
            // and get unique column names
            foreach ($insert[0] as $column)
            {
                $uniqueColumns[$column] = true;
            }
        }
 
        // prepare sql
        $sqlValues = [];
 
        foreach ($inserts as $insert)
        {
 
            $columns = array_flip($insert[0]);
            $values = $insert[1];
 
            $finalValues = [];
 
            foreach (array_keys($uniqueColumns) as $column)
            {
                if (array_key_exists($column, $columns))
                {
                    // set real value
                    $finalValues[] = $values[$columns[$column]];
                }
                else
                {
                    // set default
                    $finalValues[] = 'DEFAULT';
                }
            }
 
            $sqlValues[] = '('.join(', ', $finalValues).')';
        }
 
        $sql = "INSERT INTO {$this->getSqlHelper()->quote($tableName)} (".join(', ', array_keys($uniqueColumns)).") ".
                "VALUES ".join(', ', $sqlValues);
 
        $this->queryExecute($sql);
 
        return $this->getInsertedId();
    }
 
    abstract public function getInsertedId();
 
    public function executeSqlBatch($sqlBatch, $stopOnError = false)
    {
        $result = [];
        foreach ($this->parseSqlBatch($sqlBatch) as $sql)
        {
            try
            {
                $this->queryExecute($sql);
            }
            catch (SqlException $ex)
            {
                $result[] = $ex->getMessage();
                if ($stopOnError)
                {
                    return $result;
                }
            }
        }
 
        return $result;
    }
 
    public function parseSqlBatch($sqlBatch)
    {
        $delimiter = $this->getSqlHelper()->getQueryDelimiter();
 
        $sqlBatch = trim($sqlBatch);
 
        $statements = [];
        $sql = "";
 
        do
        {
            if (preg_match("%^(.*?)(['\"`#]|--|\\$\\$|".$delimiter.")%is", $sqlBatch, $match))
            {
                //Found string start
                if ($match[2] == "\"" || $match[2] == "'" || $match[2] == "`")
                {
                    $sqlBatch = mb_substr($sqlBatch, mb_strlen($match[0]));
                    $sql .= $match[0];
                    //find a quote not preceded by \
                    if (preg_match("%^(.*?)(?<!\\\\‍)".$match[2]."%s", $sqlBatch, $stringMatch))
                    {
                        $sqlBatch = mb_substr($sqlBatch, mb_strlen($stringMatch[0]));
                        $sql .= $stringMatch[0];
                    }
                    else
                    {
                        //String foll beyond end of file
                        $sql .= $sqlBatch;
                        $sqlBatch = "";
                    }
                }
                //Comment found
                elseif ($match[2] == "#" || $match[2] == "--")
                {
                    //Take that was before comment as part of sql
                    $sqlBatch = mb_substr($sqlBatch, mb_strlen($match[1]));
                    $sql .= $match[1];
                    //And cut the rest
                    $p = mb_strpos($sqlBatch, "\n");
                    if ($p === false)
                    {
                        $p1 = mb_strpos($sqlBatch, "\r");
                        if ($p1 === false)
                        {
                            $sqlBatch = "";
                        }
                        elseif ($p < $p1)
                        {
                            $sqlBatch = mb_substr($sqlBatch, $p);
                        }
                        else
                        {
                            $sqlBatch = mb_substr($sqlBatch, $p1);
                        }
                    }
                    else
                    {
                        $sqlBatch = mb_substr($sqlBatch, $p);
                    }
                }
                //$$ plpgsql body
                elseif ($match[2] == '$$')
                {
                    //Take that was before delimiter as part of sql
                    $sqlBatch = mb_substr($sqlBatch, mb_strlen($match[0]));
                    //Including $$
                    $sql .= $match[0];
                    //Find closing $$
                    $p = mb_strpos($sqlBatch, '$$');
                    if ($p === false)
                    {
                        $sql .= $sqlBatch;
                        $sqlBatch = '';
                    }
                    else
                    {
                        $sql .= mb_substr($sqlBatch, 0, $p + 2);
                        $sqlBatch = mb_substr($sqlBatch, $p + 2);
                    }
                }
                //Delimiter!
                else
                {
                    //Take that was before delimiter as part of sql
                    $sqlBatch = mb_substr($sqlBatch, mb_strlen($match[0]));
                    $sql .= $match[1];
                    //Delimiter must be followed by whitespace
                    if (preg_match("%^[\n\r\t ]%", $sqlBatch))
                    {
                        $sql = trim($sql);
                        if (!empty($sql))
                        {
                            $statements[] = str_replace("\r\n", "\n", $sql);
                            $sql = "";
                        }
                    }
                    //It was not delimiter!
                    elseif (!empty($sqlBatch))
                    {
                        $sql .= $match[2];
                    }
                }
            }
            else //End of file is our delimiter
            {
                $sql .= $sqlBatch;
                $sqlBatch = "";
            }
        }
        while (!empty($sqlBatch));
 
        $sql = trim($sql, " \t\n\r");
        if (!empty($sql))
        {
            $statements[] = str_replace("\r\n", "\n", $sql);
        }
 
        return $statements;
    }
 
    abstract public function getAffectedRowsCount();
 
    /*********************************************************
     * DDL
     *********************************************************/
 
    abstract public function isTableExists($tableName);
 
    abstract public function isIndexExists($tableName, array $columns);
 
    abstract public function getIndexName($tableName, array $columns, $strict = false);
 
    abstract public function getTableFields($tableName);
 
    abstract public function createTable($tableName, $fields, $primary = array(), $autoincrement = array());
 
    public function createPrimaryIndex($tableName, $columnNames)
    {
        if (!is_array($columnNames))
        {
            $columnNames = array($columnNames);
        }
 
        foreach ($columnNames as &$columnName)
        {
            $columnName = $this->getSqlHelper()->quote($columnName);
        }
 
        $sql = 'ALTER TABLE '.$this->getSqlHelper()->quote($tableName).' ADD PRIMARY KEY('.join(', ', $columnNames).')';
 
        return $this->query($sql);
    }
 
    public function createIndex($tableName, $indexName, $columnNames)
    {
        if (!is_array($columnNames))
        {
            $columnNames = array($columnNames);
        }
 
        $sqlHelper = $this->getSqlHelper();
 
        foreach ($columnNames as &$columnName)
        {
            $columnName = $sqlHelper->quote($columnName);
        }
        unset($columnName);
 
        $sql = 'CREATE INDEX '.$sqlHelper->quote($indexName).' ON '.$sqlHelper->quote($tableName).' ('.join(', ', $columnNames).')';
 
        return $this->query($sql);
    }
 
    public function getTableField($tableName, $columnName)
    {
        $tableFields = $this->getTableFields($tableName);
 
        return ($tableFields[$columnName] ?? null);
    }
 
    public function truncateTable($tableName)
    {
        return $this->query('TRUNCATE TABLE '.$this->getSqlHelper()->quote($tableName));
    }
 
    abstract public function renameTable($currentName, $newName);
 
    public function dropColumn($tableName, $columnName)
    {
        $this->query('ALTER TABLE '.$this->getSqlHelper()->quote($tableName).' DROP COLUMN '.$this->getSqlHelper()->quote($columnName));
    }
 
    abstract public function dropTable($tableName);
 
    /*********************************************************
     * Transaction
     *********************************************************/
 
    abstract public function startTransaction();
 
    abstract public function commitTransaction();
 
    abstract public function rollbackTransaction();
 
    /*********************************************************
     * Global named lock
     *********************************************************/
 
    public function lock($name, $timeout = 0)
    {
        return true;
    }
 
    public function unlock($name)
    {
        return true;
    }
 
    /*********************************************************
     * Tracker
     *********************************************************/
 
    public function startTracker($reset = false)
    {
        if ($this->sqlTracker == null)
            $this->sqlTracker = new Diag\SqlTracker();
        if ($reset)
            $this->sqlTracker->reset();
 
        $this->trackSql = true;
        return $this->sqlTracker;
    }
 
    public function stopTracker()
    {
        $this->trackSql = false;
    }
 
    public function getTracker()
    {
        return $this->sqlTracker;
    }
 
    public function setTracker(Diag\SqlTracker $sqlTracker = null)
    {
        $this->sqlTracker = $sqlTracker;
    }
 
    /*********************************************************
     * Type, version, cache, etc.
     *********************************************************/
 
    abstract public function getType();
 
    abstract public function getVersion();
 
    abstract public function getErrorMessage();
 
    public function clearCaches()
    {
        $this->tableColumnsCache = array();
    }
 
    public function setNodeId($nodeId)
    {
        $this->nodeId = $nodeId;
    }
 
    public function getNodeId()
    {
        return $this->nodeId;
    }
 
    protected function afterConnected()
    {
        if(isset($this->configuration["include_after_connected"]) && $this->configuration["include_after_connected"] <> '')
        {
            include($this->configuration["include_after_connected"]);
        }
    }
 
    public function isUtf8mb4($table = null, $column = null)
    {
        if(isset($this->utf8mb4["global"]) && $this->utf8mb4["global"] === true)
        {
            return true;
        }
 
        if($table !== null && isset($this->utf8mb4["tables"][$table]) && $this->utf8mb4["tables"][$table] === true)
        {
            return true;
        }
 
        if($table !== null && $column !== null && isset($this->utf8mb4["tables"][$table][$column]) && $this->utf8mb4["tables"][$table][$column] === true)
        {
            return true;
        }
 
        return false;
    }
 
    protected static function findIndex(array $indexes, array $columns, $strict)
    {
        $columnsList = implode(",", $columns);
 
        foreach ($indexes as $indexName => $indexColumns)
        {
            ksort($indexColumns);
            $indexColumnList = implode(",", $indexColumns);
            if ($strict)
            {
                if ($indexColumnList === $columnsList)
                {
                    return $indexName;
                }
            }
            else
            {
                if (str_starts_with($indexColumnList, $columnsList))
                {
                    return $indexName;
                }
            }
        }
 
        return null;
    }
}