first commit

class/Query/QueryBuilder.php

@@ -0,0 +1,766 @@
+<?php
+
+namespace Query;
+
+use Doctrine\Bundle\DoctrineBundle\Twig\DoctrineExtension;
+use Doctrine\DBAL\Connection;
+use KupShop\KupShopBundle\Context\CountryContext;
+use KupShop\KupShopBundle\Context\VatContext;
+use KupShop\KupShopBundle\Util\Contexts;
+use KupShop\PricelistBundle\Context\PricelistContext;
+
+class QueryBuilderBase extends \Doctrine\DBAL\Query\QueryBuilder
+{
+    private $joins = [];
+
+    protected $calcRows = false;
+
+    protected $onDuplicateKeyUpdate = [];
+
+    protected $sendToMaster = false;
+
+    protected $forUpdate = false;
+
+    protected bool $multiInsert = false;
+
+    protected array $forceIndexes = [];
+
+    protected array $withExpressions = [];
+
+    /**
+     * @param mixed|null $selects
+     *
+     * @return $this
+     */
+    public function select($selects = null)
+    {
+        $selects = func_get_args();
+
+        return call_user_func_array([parent::class, __FUNCTION__], $this->evaluateClosures($selects));
+    }
+
+    public function from($from, $alias = null)
+    {
+        $from = $this->evaluateClosures([$from])[0];
+
+        return call_user_func_array([parent::class, __FUNCTION__], [$from, $alias]);
+    }
+
+    public function addSelect($selects = null)
+    {
+        $selects = func_get_args();
+
+        return call_user_func_array([parent::class, __FUNCTION__], $this->evaluateClosures($selects));
+    }
+
+    public function set($key, $value)
+    {
+        [$key, $value] = $this->evaluateClosures([$key, $value]);
+
+        return call_user_func_array([parent::class, __FUNCTION__], [$key, $value]);
+    }
+
+    /**
+     * @return $this
+     */
+    public function where($predicates)
+    {
+        $predicates = func_get_args();
+
+        if (isDevelopment()) {
+            if ($this->getQueryPart('where') !== null) {
+                /* @noinspection PhpUnhandledExceptionInspection */
+                throw new \Exception('This call of \'where\' method will reset where query part! Use \'andWhere\' instead.');
+            }
+        }
+
+        return call_user_func_array([parent::class, __FUNCTION__], $this->evaluateClosures($predicates));
+    }
+
+    /**
+     * @return $this
+     */
+    public function andWhere($where)
+    {
+        $where = func_get_args();
+
+        $where = $this->evaluateClosures($where);
+
+        // Remove null wheres - caused by specs
+        $where = array_filter($where, function ($x) {
+            return $x !== null;
+        });
+
+        if (!count($where)) {
+            return $this;
+        }
+
+        return call_user_func_array([parent::class, __FUNCTION__], $where);
+    }
+
+    /**
+     * @return $this
+     */
+    public function orWhere($where)
+    {
+        $where = func_get_args();
+
+        return call_user_func_array([parent::class, __FUNCTION__], $this->evaluateClosures($where));
+    }
+
+    /**
+     * @param string $productsAlias
+     *
+     * @return \Query\QueryBuilder
+     */
+    public function fromProducts($productsAlias = 'p')
+    {
+        return $this->from('products', $productsAlias);
+    }
+
+    /**
+     * @return array
+     *
+     * @internal
+     */
+    public function evaluateClosures(array $predicates)
+    {
+        foreach ($predicates as &$predicate) {
+            while ($predicate instanceof \Closure) {
+                $predicate = $predicate($this);
+            }
+        }
+
+        return $predicates;
+    }
+
+    public function add($sqlPartName, $sqlPart, $append = false)
+    {
+        if ($sqlPartName === 'join') {
+            return $this->addJoin(current($sqlPart)['joinAlias'], $sqlPart, $append);
+        }
+
+        if ($sqlPartName === 'select' && $append) {
+            $selects = $this->getQueryPart('select');
+            foreach ($sqlPart as $part) {
+                if (in_array($part, $selects)) {
+                    return $this;
+                }
+            }
+        }
+
+        return parent::add($sqlPartName, $sqlPart, $append);
+    }
+
+    public function addParameters(array $parameters, array $types = [])
+    {
+        foreach ($parameters as $name => $value) {
+            $this->setParameter($name, $value, $types[$name] ?? null);
+        }
+
+        return $this;
+    }
+
+    public function orderBySql($orderBySql)
+    {
+        return $this->add('orderBy', $orderBySql);
+    }
+
+    public function addSubselect(QueryBuilder $qb, $alias, $template = '{}')
+    {
+        $fields = str_replace('{}', "({$qb->getSQL()})", $template);
+
+        return $this->addSelect("{$fields} AS {$alias}")
+            ->addParameters($qb->getParameters(), $qb->getParameterTypes());
+    }
+
+    public function joinSubQuery($fromAlias, QueryBuilder $qb, $alias, $condition)
+    {
+        return $this->join($fromAlias, '('.$qb->getSQL().')', $alias, $condition)
+            ->addParameters($qb->getParameters(), $qb->getParameterTypes());
+    }
+
+    public function leftJoinSubQuery($fromAlias, QueryBuilder $qb, $alias, $condition)
+    {
+        return $this->leftJoin($fromAlias, '('.$qb->getSQL().')', $alias, $condition)
+            ->addParameters($qb->getParameters(), $qb->getParameterTypes());
+    }
+
+    public function crossJoin(string $fromAlias, string $table, string $alias): self
+    {
+        return $this->add('join', [
+            $fromAlias => [
+                'joinType' => 'cross',
+                'joinTable' => $table,
+                'joinAlias' => $alias,
+                'joinCondition' => null,
+            ],
+        ], true);
+    }
+
+    private function addJoin($joinAlias, $joinDeclaration, $append)
+    {
+        $normalizedJoin = mb_strtolower(preg_replace('/\s/', '', implode(current($joinDeclaration))));
+        if ($this->isJoinPresent($joinAlias, $normalizedJoin)) {
+            return $this;
+        }
+
+        $this->joins[$joinAlias] = $normalizedJoin;
+
+        return parent::add('join', $joinDeclaration, $append);
+    }
+
+    private function isJoinPresent($joinAlias, $normalizedJoin)
+    {
+        if (isset($this->joins[$joinAlias])) {
+            if ($this->joins[$joinAlias] !== $normalizedJoin) {
+                $existingNormalizedJoin = $this->joins[$joinAlias];
+                throw new \LogicException("Alias '{$joinAlias}' has already been set with the declaration '{$existingNormalizedJoin}'. Now trying: '{$normalizedJoin}'");
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public function isAliasPresent($alias)
+    {
+        $fromAlias = $this->getQueryPart('from')[0]['alias'] ?? $this->getQueryPart('from')['alias'] ?? '';
+
+        return ($fromAlias == $alias) || isset($this->joins[$alias]);
+    }
+
+    public function execute()
+    {
+        wpj_debug([$this->getSQL(), $this->getParameters()]);
+
+        return parent::execute();
+    }
+
+    public function setUnbufferedMode(): QueryBuilder
+    {
+        $this->getConnection()->getWrappedConnection()->setAttribute(\PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+
+        return $this;
+    }
+
+    public function joinVatsOnProducts()
+    {
+        $vatContext = Contexts::get(VatContext::class);
+
+        if ($vatContext->isCountryOssActive()) {
+            $countryContext = Contexts::get(CountryContext::class);
+            $defaultCn = \Settings::getDefault()['oss_vats']['default'] ?? null;
+            $this->leftJoin('p', 'vats_cns', 'vatcns', 'COALESCE(p.id_cn, :defaultCn) = vatcns.id_cn')
+                ->leftJoin('vatcns', 'vats', 'v', 'vatcns.id_vat = v.id')
+                ->andWhere(
+                    Operator::orX(
+                        Operator::equals(['v.id_country ' => $countryContext->getActiveId()]),
+                        'vatcns.id_cn IS NULL'
+                    )
+                )
+                ->setParameter('defaultCn', $defaultCn);
+        } else {
+            $this->leftJoin('p', 'vats', 'v', 'p.vat = v.id');
+        }
+
+        return $this;
+    }
+
+    public function joinVariationsOnProducts()
+    {
+        $this->leftJoin('p', 'products_variations', 'pv', 'p.id = pv.id_product');
+
+        return $this;
+    }
+
+    public function joinSectionsOnProducts()
+    {
+        $this->join('p', 'products_in_sections', 'ps', 'p.id = ps.id_product');
+
+        return $this;
+    }
+
+    public function joinProducersOnProducts()
+    {
+        $this->leftJoin('p', 'producers', 'pr', 'p.producer = pr.id');
+
+        return $this;
+    }
+
+    public function joinTemplatesOnProducts()
+    {
+        $this->leftJoin('p', 'templates_products', 'tp', 'p.id = tp.id_product');
+        $this->join('tp', 'templates', 't', 't.id = tp.id_template');
+
+        return $this;
+    }
+
+    public function joinVariationsLabelsAndValues()
+    {
+        $this->join('pv', 'products_variations_combination', 'pvc', 'pv.id = pvc.id_variation')
+            ->join('pvc', 'products_variations_choices_labels', 'pvcl', 'pvc.id_label=pvcl.id')
+            ->join('pvc', 'products_variations_choices_values', 'pvcv', 'pvc.id_value=pvcv.id')
+            ->join('pvc', 'products_variations_choices_categorization', 'pvcc', 'pvc.id_label=pvcc.id_label and pv.id_product=pvcc.id_product')
+            ->orderBy('pvcc.list_order')
+            ->addOrderBy('pvcv.sort');
+
+        return $this;
+    }
+
+    public function joinParametersOnProducts($parametersAlias = 'pap')
+    {
+        $this->join('p', 'parameters_products', $parametersAlias, "p.id = {$parametersAlias}.id_product");
+
+        return $this;
+    }
+
+    public function joinProductsOfSuppliers(string $productAlias = 'p')
+    {
+        // if the spaceship operator causes problems, return it to ((pv.id=pos.id_variation) OR (pv.id IS NULL and pos.id_variation IS NULL))
+        $this->leftJoin($productAlias, 'products_of_suppliers', 'pos', "{$productAlias}.id = pos.id_product AND pv.id <=> pos.id_variation");
+
+        return $this;
+    }
+
+    public function joinPriceListsProducts(?int $priceListId = null, string $productAlias = 'p', string $variationAlias = 'pv'): self
+    {
+        $priceListId ??= Contexts::get(PricelistContext::class)->getActiveId();
+
+        if ($priceListId) {
+            $priceListIds = \KupShop\PricelistBundle\Query\Product::getActivePriceLists((int) $priceListId);
+            $this->setParameter('id_pricelist', $priceListIds, Connection::PARAM_INT_ARRAY)
+                ->leftJoin('p', 'pricelists_products', 'prlp', "prlp.id_product = {$productAlias}.id AND prlp.id_variation IS null AND prlp.id_pricelist IN (:id_pricelist)")
+                ->leftJoin('p', 'pricelists_products', 'prlv', "prlv.id_product = {$productAlias}.id AND prlv.id_variation = {$variationAlias}.id AND prlv.id_pricelist IN (:id_pricelist)")
+                ->leftJoin('prlv', 'pricelists', 'prl', 'prlp.id_pricelist = prl.id')
+                ->leftJoin('prlv', 'pricelists', 'prl_v', 'prlv.id_pricelist = prl_v.id');
+
+            if (count($priceListIds) <= 1) {
+                $this->setForceIndexForJoin('prlp', 'pricelist_product')
+                    ->setForceIndexForJoin('prlv', 'pricelist_product');
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * @return QueryBuilder
+     *                      Specifies values for an multi insert query indexed by column names.
+     *                      Replaces any previous values, if any.
+     *
+     * <code>
+     *     $array =[
+     *              ['name' => '?',  'password' => '?'],
+     *              ['name' => '?',  'password' => '?']
+     *            ];
+     * </code>
+     */
+    public function multiValues(array $values): QueryBuilder
+    {
+        if ($this->getType() !== self::INSERT) {
+            throw new \InvalidArgumentException('multiValues without INSERT');
+        }
+        $this->setMultiInsert(true);
+
+        return $this->values($values);
+    }
+
+    /**
+     * @return QueryBuilder
+     *                      Specifies values for a multi insert query indexed by column names.
+     *                      One row insert per call
+     *                      <code>
+     *                      $values =['name' => '?',  'password' => '?']
+     *                      </code>
+     */
+    public function multiDirectValues(array $values, array $types = []): QueryBuilder
+    {
+        $sqlParts = $this->getQueryParts();
+        if ($this->getType() !== self::INSERT) {
+            throw new \InvalidArgumentException('multiValues without INSERT');
+        }
+        if (!$this->getMultiInsert()) {
+            $this->multiValues([]); // vyčistíme values
+        }
+        $pf = 'multi'.count($sqlParts['values']).'_';
+        $array = [];
+        foreach ($values as $param => $value) {
+            $key = ":{$pf}{$param}";
+            $this->setParameter($key, $value, isset($types[$param]) ? $types[$param] : null);
+            $array['`'.$param.'`'] = $key;
+        }
+        $sqlParts['values'][] = $array;
+
+        return $this->multiValues($sqlParts['values']);
+    }
+
+    protected function setMultiInsert(bool $multiInsert)
+    {
+        $this->multiInsert = $multiInsert;
+    }
+
+    protected function getMultiInsert(): bool
+    {
+        return $this->multiInsert;
+    }
+
+    /**
+     * Specifies values for an insert query indexed by column names
+     * without need to use parameters()
+     * Replaces any previous parameters with same name.
+     *
+     * <code>
+     * $qb = $conn->createQueryBuilder()
+     *     ->insert('users')
+     *     ->directValues(
+     *         array(
+     *             'name' => 'test',
+     *             'password' => 10
+     *         )
+     *     );
+     * </code>
+     *
+     * @param array $values the values to specify for the insert query indexed by column names
+     *
+     * @return $this
+     */
+    public function directValues(array $values, array $types = [])
+    {
+        if ($this->getMultiInsert()) {
+            throw new \InvalidArgumentException('directValues mixed with multiInsertValues');
+        }
+        foreach ($values as $param => $value) {
+            $key = ":{$param}";
+
+            if ($this->getType() == self::INSERT) {
+                $this->setValue('`'.$param.'`', $key);
+            } elseif ($this->getType() == self::UPDATE) {
+                $this->set('`'.$param.'`', $key);
+            } elseif ($this->getType() == self::DELETE) {
+                throw new \InvalidArgumentException('directValues with DELETE not implemented');
+            }
+
+            $this->setParameter($param, $value, isset($types[$param]) ? $types[$param] : null);
+        }
+
+        return $this;
+    }
+
+    public function getSQL()
+    {
+        $hasLimit = $this->getMaxResults() !== null && $this->getMaxResults() > 0;
+
+        // custom support for JOINs in UPDATE statements
+        if ($this->getType() == self::UPDATE && (!empty($this->getQueryPart('join')) || $hasLimit)) {
+            return $this->getSQLForUpdate();
+        }
+
+        if ($this->getType() === self::INSERT) {
+            return $this->getSQLForInsert();
+        }
+
+        // custom support for JOINs in DELETE statements
+        $tableAlias = $this->getQueryPart('from')[0]['alias'] ?? $this->getQueryPart('from')['alias'] ?? '';
+        // we should use custom supports in DELETE statements even if there is table alias without JOINs
+        if ($this->getType() == self::DELETE && (!empty($this->getQueryPart('join')) || !empty($tableAlias) || $hasLimit)) {
+            return $this->getSQLForDelete();
+        }
+
+        if ($this->getType() == self::SELECT && $this->calcRows) {
+            $selectPart = $this->getQueryPart('select');
+            if (!empty($selectPart) && strpos($selectPart[0], 'SQL_CALC_FOUND_ROWS') === false) {
+                $selectPart[0] = 'SQL_CALC_FOUND_ROWS '.$selectPart[0];
+                $this->select($selectPart);
+            }
+        }
+
+        $sql = parent::getSQL();
+
+        if ($this->forceIndexes) {
+            $sql = $this->modifySqlAddForceIndexes($sql);
+        }
+
+        if ($this->withExpressions) {
+            $sql = $this->modifySqlAddWithExpressions($sql);
+        }
+
+        return $sql.($this->forUpdate ? ' FOR UPDATE' : '').($this->sendToMaster ? ' -- maxscale route to master' : '');
+    }
+
+    private function getSQLForUpdate()
+    {
+        $sqlParts = $this->getQueryParts();
+
+        // Hack: Njncsdd, je to vsechno private a radsi reflection nez kopirovat pulku QB
+        $reflector = new \ReflectionClass(\Doctrine\DBAL\Query\QueryBuilder::class);
+        $method = $reflector->getMethod('getFromClauses');
+        $method->setAccessible(true);
+
+        // UPDATE has different "from" structure than SELECT
+        $from = $this->getQueryPart('from');
+        if (!isset($from[0])) {
+            $this->resetQueryPart('from')
+                ->add('from', $from, true);
+        }
+
+        $table = implode(', ', $method->invoke($this));
+
+        $query = 'UPDATE '.$table
+            .' SET '.implode(', ', $sqlParts['set'])
+            .($sqlParts['where'] !== null ? ' WHERE '.((string) $sqlParts['where']) : '');
+
+        if ($orderBy = $sqlParts['orderBy'] ?? []) {
+            $query .= ' ORDER BY '.implode(', ', $orderBy);
+        }
+
+        if (null !== ($limit = $this->getMaxResults()) && $limit > 0) {
+            $query .= ' LIMIT '.$limit;
+        }
+
+        return $query;
+    }
+
+    private function getSQLForDelete()
+    {
+        $sqlParts = $this->getQueryParts();
+
+        // Hack: Njncsdd, je to vsechno private a radsi reflection nez kopirovat pulku QB
+        $reflector = new \ReflectionClass(\Doctrine\DBAL\Query\QueryBuilder::class);
+        $method = $reflector->getMethod('getFromClauses');
+        $method->setAccessible(true);
+
+        $tableAlias = $this->getQueryPart('from')[0]['alias'] ?? '';
+        $isLimitQuery = $this->getMaxResults() !== null && $this->getMaxResults() > 0;
+
+        // https://mariadb.com/kb/en/delete/#description
+        if (($isLimitQuery || !empty($sqlParts['orderBy'])) && (
+            !empty($sqlParts['join'])
+            || $tableAlias
+            || (isset($from['table'], $from[0]) && $from['table'] !== $from[0]['table'])
+        )) {
+            throw new \Doctrine\DBAL\Exception('Cannot use multi-table syntax with LIMIT or ORDER BY. Remove any joins, multi-table expressions or table aliases in DELETE FROM.');
+        }
+
+        // UPDATE has different "from" structure than SELECT
+        $from = $this->getQueryPart('from');
+        if (!isset($from[0])) {
+            $this->resetQueryPart('from')
+                ->add('from', $from, true);
+        }
+
+        $fromTable = implode(', ', $method->invoke($this));
+
+        $query = 'DELETE'.($tableAlias ? " {$tableAlias}" : '').' FROM '.$fromTable.($sqlParts['where'] !== null ? ' WHERE '.((string) $sqlParts['where']) : '');
+
+        if ($orderBy = $sqlParts['orderBy'] ?? []) {
+            $query .= ' ORDER BY '.implode(', ', $orderBy);
+        }
+
+        if ($isLimitQuery) {
+            $query .= ' LIMIT '.$this->getMaxResults();
+        }
+
+        return $query;
+    }
+
+    private function getSQLForInsert()
+    {
+        $sqlParts = $this->getQueryParts();
+
+        return 'INSERT INTO '.$sqlParts['from']['table'].$this->getSQLForValues().$this->getSQLForOnDuplicateKeyUpdate();
+    }
+
+    /**
+     * Implements support for multi-insert.
+     *
+     * @return string
+     */
+    private function getSQLForValues()
+    {
+        $sqlParts = $this->getQueryParts();
+        $values = [];
+        $columnsToUpdate = [];
+        if ($this->getMultiInsert()) {
+            $first = reset($sqlParts['values']);
+            $columnsToUpdate = array_keys($first);
+            foreach ($sqlParts['values'] as $vls) {
+                $values[] = '('.implode(', ', $vls).')';
+            }
+        } else {
+            $columnsToUpdate = array_keys($sqlParts['values']);
+            $values[] = '('.implode(', ', $sqlParts['values']).')';
+        }
+
+        return ' ('.implode(',', $columnsToUpdate).') VALUES '.implode(',', $values).' ';
+    }
+
+    protected function modifySqlAddForceIndexes($sql)
+    {
+        $sqlParts = $this->getQueryParts()['join'];
+
+        $joinsToModify = [];
+
+        foreach ($sqlParts as $tableJoins) {
+            foreach ($tableJoins as $join) {
+                if (array_key_exists($join['joinAlias'], $this->forceIndexes)) {
+                    $joinsToModify[] = $join;
+                }
+            }
+        }
+
+        $getJoin = function ($join, $index = '') {
+            $sql = 'JOIN '.$join['joinTable'].' '.$join['joinAlias'];
+            if ($index) {
+                $sql .= " FORCE INDEX ({$index})";
+            }
+
+            return $sql.' ON';
+        };
+
+        foreach ($joinsToModify as $join) {
+            $replacedCount = 0;
+            $sql = str_replace($getJoin($join), $getJoin($join, $this->forceIndexes[$join['joinAlias']]), $sql, $replacedCount);
+
+            if ($replacedCount > 1) {
+                throw new \LogicException('QueryBuilder tried to add FORCE UPDATE clause to join, but multiple matching joins were found for the alias '.$join['joinAlias']);
+            }
+        }
+
+        return $sql;
+    }
+
+    public function setForceIndexForJoin($joinAlias, $indexName)
+    {
+        $this->forceIndexes[$joinAlias] = $indexName;
+
+        return $this;
+    }
+
+    public function withExpression(string $alias, QueryBuilder $qb, ?int $priority = null)
+    {
+        $data = [
+            'sql' => $qb->getSQL(),
+            'alias' => $alias,
+        ];
+
+        if ($priority) {
+            $this->withExpressions[$priority] = $data;
+        } else {
+            $this->withExpressions[] = $data;
+        }
+
+        $this->addParameters($qb->getParameters(), $qb->getParameterTypes());
+
+        return $this;
+    }
+
+    protected function modifySqlAddWithExpressions($sql): string
+    {
+        $withSql = 'WITH ';
+
+        foreach ($this->withExpressions as $with) {
+            $withSql .= $with['alias'].' AS ('.$with['sql'].')';
+            if (next($this->withExpressions)) {
+                $withSql .= ', ';
+            }
+        }
+
+        return $withSql.' '.$sql;
+    }
+
+    /**
+     * Implements support for ON DUPLICATE KEY UPDATE.
+     *
+     * @return string
+     */
+    private function getSQLForOnDuplicateKeyUpdate()
+    {
+        $onDuplicateKeyUpdate = '';
+        // build on duplicate key update
+        if ($this->onDuplicateKeyUpdate) {
+            $onDuplicateKeyUpdate = ' ON DUPLICATE KEY UPDATE ';
+            $duplicateKeyValues = [];
+            foreach ($this->onDuplicateKeyUpdate as $column => $value) {
+                $duplicateKeyValues[] = is_numeric($column) ? $value.'=VALUES('.$value.')' : $column.'='.$value;
+            }
+            $onDuplicateKeyUpdate .= implode(', ', $duplicateKeyValues).' ';
+        }
+
+        return $onDuplicateKeyUpdate;
+    }
+
+    /** Používat jen v krajní nouzi */
+    public function removeJoin($table, $table2)
+    {
+        unset($this->joins[$table2]);
+        $parts = $this->getQueryPart('join');
+        $this->resetQueryPart('join');
+        foreach ($parts as $tmp_table => $tmp_part) {
+            foreach ($tmp_part as $part) {
+                if ($part['joinAlias'] != $table2) {
+                    parent::add('join', [$tmp_table => $part], true);
+                }
+            }
+        }
+    }
+
+    public function addQueryBuilderParameters(QueryBuilder $qb): QueryBuilder
+    {
+        $this->addParameters($qb->getParameters(), $qb->getParameterTypes());
+
+        return $this;
+    }
+
+    public function addCalcRows()
+    {
+        $this->calcRows = true;
+
+        return $this;
+    }
+
+    public function onDuplicateKeyUpdate(array $values): QueryBuilder
+    {
+        if ($this->getType() !== self::INSERT) {
+            throw new \InvalidArgumentException('Call of "onDuplicateKeyUpdate" is allowed only with insert query');
+        }
+
+        $this->onDuplicateKeyUpdate = $values;
+
+        return $this;
+    }
+
+    public function sendToMaster()
+    {
+        $this->sendToMaster = true;
+
+        return $this;
+    }
+
+    public function forUpdate()
+    {
+        $this->forUpdate = true;
+
+        return $this;
+    }
+
+    /**
+     * Using on queries with ? may not work.
+     *
+     * @return string SQL with inserted params
+     */
+    public function getRunnableSQL(): string
+    {
+        $util = new DoctrineExtension();
+        $sql = $util->replaceQueryParameters($this->getSQL(), $this->getParameters());
+
+        return $util->formatSql($sql, false);
+    }
+}
+
+if (empty($subclass)) {
+    class QueryBuilder extends QueryBuilderBase
+    {
+    }
+}