vendor/doctrine/dbal/src/Query/QueryBuilder.php line 271

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Query;
  5. use Doctrine\DBAL\Cache\QueryCacheProfile;
  6. use Doctrine\DBAL\Connection;
  7. use Doctrine\DBAL\Exception;
  8. use Doctrine\DBAL\ParameterType;
  9. use Doctrine\DBAL\Query\Expression\CompositeExpression;
  10. use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
  11. use Doctrine\DBAL\Query\ForUpdate\ConflictResolutionMode;
  12. use Doctrine\DBAL\Result;
  13. use Doctrine\DBAL\Statement;
  14. use Doctrine\DBAL\Types\Type;
  15. use Doctrine\Deprecations\Deprecation;
  17. use function array_key_exists;
  18. use function array_keys;
  19. use function array_unshift;
  20. use function count;
  21. use function func_get_arg;
  22. use function func_get_args;
  23. use function func_num_args;
  24. use function implode;
  25. use function is_array;
  26. use function is_object;
  27. use function key;
  28. use function method_exists;
  29. use function strtoupper;
  30. use function substr;
  31. use function ucfirst;
  33. /**
  34.  * QueryBuilder class is responsible to dynamically create SQL queries.
  35.  *
  36.  * Important: Verify that every feature you use will work with your database vendor.
  37.  * SQL Query Builder does not attempt to validate the generated SQL at all.
  38.  *
  39.  * The query builder does no validation whatsoever if certain features even work with the
  40.  * underlying database vendor. Limit queries and joins are NOT applied to UPDATE and DELETE statements
  41.  * even if some vendors such as MySQL support it.
  42.  *
  43.  * @method $this distinct(bool $distinct = true) Adds or removes DISTINCT to/from the query.
  44.  */
  45. class QueryBuilder
  46. {
  47.     /** @deprecated */
  48.     public const SELECT = 0;
  50.     /** @deprecated */
  51.     public const DELETE = 1;
  53.     /** @deprecated */
  54.     public const UPDATE = 2;
  56.     /** @deprecated */
  57.     public const INSERT = 3;
  59.     /** @deprecated */
  60.     public const STATE_DIRTY = 0;
  62.     /** @deprecated */
  63.     public const STATE_CLEAN = 1;
  65.     /**
  66.      * The DBAL Connection.
  67.      */
  68.     private Connection $connection;
  70.     /*
  71.      * The default values of SQL parts collection
  72.      */
  73.     private const SQL_PARTS_DEFAULTS = [
  74.         'select'     => [],
  75.         'distinct'   => false,
  76.         'from'       => [],
  77.         'join'       => [],
  78.         'set'        => [],
  79.         'where'      => null,
  80.         'groupBy'    => [],
  81.         'having'     => null,
  82.         'orderBy'    => [],
  83.         'values'     => [],
  84.         'for_update' => null,
  85.     ];
  87.     /**
  88.      * The array of SQL parts collected.
  89.      *
  90.      * @var mixed[]
  91.      */
  92.     private array $sqlParts = self::SQL_PARTS_DEFAULTS;
  94.     /**
  95.      * The complete SQL string for this query.
  96.      */
  97.     private ?string $sql = null;
  99.     /**
  100.      * The query parameters.
  101.      *
  102.      * @var list<mixed>|array<string, mixed>
  103.      */
  104.     private $params = [];
  106.     /**
  107.      * The parameter type map of this query.
  108.      *
  109.      * @var array<int, int|string|Type|null>|array<string, int|string|Type|null>
  110.      */
  111.     private array $paramTypes = [];
  113.     /**
  114.      * The type of query this is. Can be select, update or delete.
  115.      *
  116.      * @psalm-var self::SELECT|self::DELETE|self::UPDATE|self::INSERT
  117.      */
  118.     private int $type = self::SELECT;
  120.     /**
  121.      * The state of the query object. Can be dirty or clean.
  122.      *
  123.      * @psalm-var self::STATE_*
  124.      */
  125.     private int $state = self::STATE_CLEAN;
  127.     /**
  128.      * The index of the first result to retrieve.
  129.      */
  130.     private int $firstResult = 0;
  132.     /**
  133.      * The maximum number of results to retrieve or NULL to retrieve all results.
  134.      */
  135.     private ?int $maxResults = null;
  137.     /**
  138.      * The counter of bound parameters used with {@see bindValue).
  139.      */
  140.     private int $boundCounter = 0;
  142.     /**
  143.      * The query cache profile used for caching results.
  144.      */
  145.     private ?QueryCacheProfile $resultCacheProfile = null;
  147.     /**
  148.      * Initializes a new <tt>QueryBuilder</tt>.
  149.      *
  150.      * @param Connection $connection The DBAL Connection.
  151.      */
  152.     public function __construct(Connection $connection)
  153.     {
  154.         $this->connection = $connection;
  155.     }
  157.     /**
  158.      * Gets an ExpressionBuilder used for object-oriented construction of query expressions.
  159.      * This producer method is intended for convenient inline usage. Example:
  160.      *
  161.      * <code>
  162.      *     $qb = $conn->createQueryBuilder()
  163.      *         ->select('u')
  164.      *         ->from('users', 'u')
  165.      *         ->where($qb->expr()->eq('u.id', 1));
  166.      * </code>
  167.      *
  168.      * For more complex expression construction, consider storing the expression
  169.      * builder object in a local variable.
  170.      *
  171.      * @return ExpressionBuilder
  172.      */
  173.     public function expr()
  174.     {
  175.         return $this->connection->getExpressionBuilder();
  176.     }
  178.     /**
  179.      * Gets the type of the currently built query.
  180.      *
  181.      * @deprecated If necessary, track the type of the query being built outside of the builder.
  182.      *
  183.      * @return int
  184.      */
  185.     public function getType()
  186.     {
  187.         Deprecation::trigger(
  188.             'doctrine/dbal',
  189.             'https://github.com/doctrine/dbal/pull/5551',
  190.             'Relying on the type of the query being built is deprecated.'
  191.                 . ' If necessary, track the type of the query being built outside of the builder.',
  192.         );
  194.         return $this->type;
  195.     }
  197.     /**
  198.      * Gets the associated DBAL Connection for this query builder.
  199.      *
  200.      * @deprecated Use the connection used to instantiate the builder instead.
  201.      *
  202.      * @return Connection
  203.      */
  204.     public function getConnection()
  205.     {
  206.         Deprecation::trigger(
  207.             'doctrine/dbal',
  208.             'https://github.com/doctrine/dbal/pull/5780',
  209.             '%s is deprecated. Use the connection used to instantiate the builder instead.',
  210.             __METHOD__,
  211.         );
  213.         return $this->connection;
  214.     }
  216.     /**
  217.      * Gets the state of this query builder instance.
  218.      *
  219.      * @deprecated The builder state is an internal concern.
  220.      *
  221.      * @return int Either QueryBuilder::STATE_DIRTY or QueryBuilder::STATE_CLEAN.
  222.      * @psalm-return self::STATE_*
  223.      */
  224.     public function getState()
  225.     {
  226.         Deprecation::trigger(
  227.             'doctrine/dbal',
  228.             'https://github.com/doctrine/dbal/pull/5551',
  229.             'Relying on the query builder state is deprecated as it is an internal concern.',
  230.         );
  232.         return $this->state;
  233.     }
  235.     /**
  236.      * Prepares and executes an SQL query and returns the first row of the result
  237.      * as an associative array.
  238.      *
  239.      * @return array<string, mixed>|false False is returned if no rows are found.
  240.      *
  241.      * @throws Exception
  242.      */
  243.     public function fetchAssociative()
  244.     {
  245.         return $this->executeQuery()->fetchAssociative();
  246.     }
  248.     /**
  249.      * Prepares and executes an SQL query and returns the first row of the result
  250.      * as a numerically indexed array.
  251.      *
  252.      * @return array<int, mixed>|false False is returned if no rows are found.
  253.      *
  254.      * @throws Exception
  255.      */
  256.     public function fetchNumeric()
  257.     {
  258.         return $this->executeQuery()->fetchNumeric();
  259.     }
  261.     /**
  262.      * Prepares and executes an SQL query and returns the value of a single column
  263.      * of the first row of the result.
  264.      *
  265.      * @return mixed|false False is returned if no rows are found.
  266.      *
  267.      * @throws Exception
  268.      */
  269.     public function fetchOne()
  270.     {
  271.         return $this->executeQuery()->fetchOne();
  272.     }
  274.     /**
  275.      * Prepares and executes an SQL query and returns the result as an array of numeric arrays.
  276.      *
  277.      * @return array<int,array<int,mixed>>
  278.      *
  279.      * @throws Exception
  280.      */
  281.     public function fetchAllNumeric(): array
  282.     {
  283.         return $this->executeQuery()->fetchAllNumeric();
  284.     }
  286.     /**
  287.      * Prepares and executes an SQL query and returns the result as an array of associative arrays.
  288.      *
  289.      * @return array<int,array<string,mixed>>
  290.      *
  291.      * @throws Exception
  292.      */
  293.     public function fetchAllAssociative(): array
  294.     {
  295.         return $this->executeQuery()->fetchAllAssociative();
  296.     }
  298.     /**
  299.      * Prepares and executes an SQL query and returns the result as an associative array with the keys
  300.      * mapped to the first column and the values mapped to the second column.
  301.      *
  302.      * @return array<mixed,mixed>
  303.      *
  304.      * @throws Exception
  305.      */
  306.     public function fetchAllKeyValue(): array
  307.     {
  308.         return $this->executeQuery()->fetchAllKeyValue();
  309.     }
  311.     /**
  312.      * Prepares and executes an SQL query and returns the result as an associative array with the keys mapped
  313.      * to the first column and the values being an associative array representing the rest of the columns
  314.      * and their values.
  315.      *
  316.      * @return array<mixed,array<string,mixed>>
  317.      *
  318.      * @throws Exception
  319.      */
  320.     public function fetchAllAssociativeIndexed(): array
  321.     {
  322.         return $this->executeQuery()->fetchAllAssociativeIndexed();
  323.     }
  325.     /**
  326.      * Prepares and executes an SQL query and returns the result as an array of the first column values.
  327.      *
  328.      * @return array<int,mixed>
  329.      *
  330.      * @throws Exception
  331.      */
  332.     public function fetchFirstColumn(): array
  333.     {
  334.         return $this->executeQuery()->fetchFirstColumn();
  335.     }
  337.     /**
  338.      * Executes an SQL query (SELECT) and returns a Result.
  339.      *
  340.      * @throws Exception
  341.      */
  342.     public function executeQuery(): Result
  343.     {
  344.         return $this->connection->executeQuery(
  345.             $this->getSQL(),
  346.             $this->params,
  347.             $this->paramTypes,
  348.             $this->resultCacheProfile,
  349.         );
  350.     }
  352.     /**
  353.      * Executes an SQL statement and returns the number of affected rows.
  354.      *
  355.      * Should be used for INSERT, UPDATE and DELETE
  356.      *
  357.      * @return int The number of affected rows.
  358.      *
  359.      * @throws Exception
  360.      */
  361.     public function executeStatement(): int
  362.     {
  363.         return $this->connection->executeStatement($this->getSQL(), $this->params, $this->paramTypes);
  364.     }
  366.     /**
  367.      * Executes this query using the bound parameters and their types.
  368.      *
  369.      * @deprecated Use {@see executeQuery()} or {@see executeStatement()} instead.
  370.      *
  371.      * @return Result|int|string
  372.      *
  373.      * @throws Exception
  374.      */
  375.     public function execute()
  376.     {
  377.         if ($this->type === self::SELECT) {
  378.             Deprecation::trigger(
  379.                 'doctrine/dbal',
  380.                 'https://github.com/doctrine/dbal/pull/4578',
  381.                 'QueryBuilder::execute() is deprecated, use QueryBuilder::executeQuery() for SQL queries instead.',
  382.             );
  384.             return $this->executeQuery();
  385.         }
  387.         Deprecation::trigger(
  388.             'doctrine/dbal',
  389.             'https://github.com/doctrine/dbal/pull/4578',
  390.             'QueryBuilder::execute() is deprecated, use QueryBuilder::executeStatement() for SQL statements instead.',
  391.         );
  393.         return $this->connection->executeStatement($this->getSQL(), $this->params, $this->paramTypes);
  394.     }
  396.     /**
  397.      * Gets the complete SQL string formed by the current specifications of this QueryBuilder.
  398.      *
  399.      * <code>
  400.      *     $qb = $em->createQueryBuilder()
  401.      *         ->select('u')
  402.      *         ->from('User', 'u')
  403.      *     echo $qb->getSQL(); // SELECT u FROM User u
  404.      * </code>
  405.      *
  406.      * @return string The SQL query string.
  407.      */
  408.     public function getSQL()
  409.     {
  410.         if ($this->sql !== null && $this->state === self::STATE_CLEAN) {
  411.             return $this->sql;
  412.         }
  414.         switch ($this->type) {
  415.             case self::INSERT:
  416.                 $sql = $this->getSQLForInsert();
  417.                 break;
  419.             case self::DELETE:
  420.                 $sql = $this->getSQLForDelete();
  421.                 break;
  423.             case self::UPDATE:
  424.                 $sql = $this->getSQLForUpdate();
  425.                 break;
  427.             case self::SELECT:
  428.                 $sql = $this->getSQLForSelect();
  429.                 break;
  430.         }
  432.         $this->state = self::STATE_CLEAN;
  433.         $this->sql   = $sql;
  435.         return $sql;
  436.     }
  438.     /**
  439.      * Sets a query parameter for the query being constructed.
  440.      *
  441.      * <code>
  442.      *     $qb = $conn->createQueryBuilder()
  443.      *         ->select('u')
  444.      *         ->from('users', 'u')
  445.      *         ->where('u.id = :user_id')
  446.      *         ->setParameter('user_id', 1);
  447.      * </code>
  448.      *
  449.      * @param int|string           $key   Parameter position or name
  450.      * @param mixed                $value Parameter value
  451.      * @param int|string|Type|null $type  Parameter type
  452.      *
  453.      * @return $this This QueryBuilder instance.
  454.      */
  455.     public function setParameter($key, $value, $type = ParameterType::STRING)
  456.     {
  457.         if ($type !== null) {
  458.             $this->paramTypes[$key] = $type;
  459.         } else {
  460.             Deprecation::trigger(
  461.                 'doctrine/dbal',
  462.                 'https://github.com/doctrine/dbal/pull/5550',
  463.                 'Using NULL as prepared statement parameter type is deprecated.'
  464.                     . 'Omit or use ParameterType::STRING instead',
  465.             );
  466.         }
  468.         $this->params[$key] = $value;
  470.         return $this;
  471.     }
  473.     /**
  474.      * Sets a collection of query parameters for the query being constructed.
  475.      *
  476.      * <code>
  477.      *     $qb = $conn->createQueryBuilder()
  478.      *         ->select('u')
  479.      *         ->from('users', 'u')
  480.      *         ->where('u.id = :user_id1 OR u.id = :user_id2')
  481.      *         ->setParameters(array(
  482.      *             'user_id1' => 1,
  483.      *             'user_id2' => 2
  484.      *         ));
  485.      * </code>
  486.      *
  487.      * @param list<mixed>|array<string, mixed>                                     $params Parameters to set
  488.      * @param array<int, int|string|Type|null>|array<string, int|string|Type|null> $types  Parameter types
  489.      *
  490.      * @return $this This QueryBuilder instance.
  491.      */
  492.     public function setParameters(array $params, array $types = [])
  493.     {
  494.         $this->paramTypes = $types;
  495.         $this->params     = $params;
  497.         return $this;
  498.     }
  500.     /**
  501.      * Gets all defined query parameters for the query being constructed indexed by parameter index or name.
  502.      *
  503.      * @return list<mixed>|array<string, mixed> The currently defined query parameters
  504.      */
  505.     public function getParameters()
  506.     {
  507.         return $this->params;
  508.     }
  510.     /**
  511.      * Gets a (previously set) query parameter of the query being constructed.
  512.      *
  513.      * @param mixed $key The key (index or name) of the bound parameter.
  514.      *
  515.      * @return mixed The value of the bound parameter.
  516.      */
  517.     public function getParameter($key)
  518.     {
  519.         return $this->params[$key] ?? null;
  520.     }
  522.     /**
  523.      * Gets all defined query parameter types for the query being constructed indexed by parameter index or name.
  524.      *
  525.      * @return array<int, int|string|Type|null>|array<string, int|string|Type|null> The currently defined
  526.      *                                                                              query parameter types
  527.      */
  528.     public function getParameterTypes()
  529.     {
  530.         return $this->paramTypes;
  531.     }
  533.     /**
  534.      * Gets a (previously set) query parameter type of the query being constructed.
  535.      *
  536.      * @param int|string $key The key of the bound parameter type
  537.      *
  538.      * @return int|string|Type The value of the bound parameter type
  539.      */
  540.     public function getParameterType($key)
  541.     {
  542.         return $this->paramTypes[$key] ?? ParameterType::STRING;
  543.     }
  545.     /**
  546.      * Sets the position of the first result to retrieve (the "offset").
  547.      *
  548.      * @param int $firstResult The first result to return.
  549.      *
  550.      * @return $this This QueryBuilder instance.
  551.      */
  552.     public function setFirstResult($firstResult)
  553.     {
  554.         $this->state       = self::STATE_DIRTY;
  555.         $this->firstResult = $firstResult;
  557.         return $this;
  558.     }
  560.     /**
  561.      * Gets the position of the first result the query object was set to retrieve (the "offset").
  562.      *
  563.      * @return int The position of the first result.
  564.      */
  565.     public function getFirstResult()
  566.     {
  567.         return $this->firstResult;
  568.     }
  570.     /**
  571.      * Sets the maximum number of results to retrieve (the "limit").
  572.      *
  573.      * @param int|null $maxResults The maximum number of results to retrieve or NULL to retrieve all results.
  574.      *
  575.      * @return $this This QueryBuilder instance.
  576.      */
  577.     public function setMaxResults($maxResults)
  578.     {
  579.         $this->state      = self::STATE_DIRTY;
  580.         $this->maxResults = $maxResults;
  582.         return $this;
  583.     }
  585.     /**
  586.      * Gets the maximum number of results the query object was set to retrieve (the "limit").
  587.      * Returns NULL if all results will be returned.
  588.      *
  589.      * @return int|null The maximum number of results.
  590.      */
  591.     public function getMaxResults()
  592.     {
  593.         return $this->maxResults;
  594.     }
  596.     /**
  597.      * Locks the queried rows for a subsequent update.
  598.      *
  599.      * @return $this
  600.      */
  601.     public function forUpdate(int $conflictResolutionMode = ConflictResolutionMode::ORDINARY): self
  602.     {
  603.         $this->state = self::STATE_DIRTY;
  605.         $this->sqlParts['for_update'] = new ForUpdate($conflictResolutionMode);
  607.         return $this;
  608.     }
  610.     /**
  611.      * Either appends to or replaces a single, generic query part.
  612.      *
  613.      * The available parts are: 'select', 'from', 'set', 'where',
  614.      * 'groupBy', 'having' and 'orderBy'.
  615.      *
  616.      * @param string $sqlPartName
  617.      * @param mixed  $sqlPart
  618.      * @param bool   $append
  619.      *
  620.      * @return $this This QueryBuilder instance.
  621.      */
  622.     public function add($sqlPartName, $sqlPart, $append = false)
  623.     {
  624.         $isArray    = is_array($sqlPart);
  625.         $isMultiple = is_array($this->sqlParts[$sqlPartName]);
  627.         if ($isMultiple && ! $isArray) {
  628.             $sqlPart = [$sqlPart];
  629.         }
  631.         $this->state = self::STATE_DIRTY;
  633.         if ($append) {
  634.             if (
  635.                 $sqlPartName === 'orderBy'
  636.                 || $sqlPartName === 'groupBy'
  637.                 || $sqlPartName === 'select'
  638.                 || $sqlPartName === 'set'
  639.             ) {
  640.                 foreach ($sqlPart as $part) {
  641.                     $this->sqlParts[$sqlPartName][] = $part;
  642.                 }
  643.             } elseif ($isArray && is_array($sqlPart[key($sqlPart)])) {
  644.                 $key                                  = key($sqlPart);
  645.                 $this->sqlParts[$sqlPartName][$key][] = $sqlPart[$key];
  646.             } elseif ($isMultiple) {
  647.                 $this->sqlParts[$sqlPartName][] = $sqlPart;
  648.             } else {
  649.                 $this->sqlParts[$sqlPartName] = $sqlPart;
  650.             }
  652.             return $this;
  653.         }
  655.         $this->sqlParts[$sqlPartName] = $sqlPart;
  657.         return $this;
  658.     }
  660.     /**
  661.      * Specifies an item that is to be returned in the query result.
  662.      * Replaces any previously specified selections, if any.
  663.      *
  664.      * USING AN ARRAY ARGUMENT IS DEPRECATED. Pass each value as an individual argument.
  665.      *
  666.      * <code>
  667.      *     $qb = $conn->createQueryBuilder()
  668.      *         ->select('u.id', 'p.id')
  669.      *         ->from('users', 'u')
  670.      *         ->leftJoin('u', 'phonenumbers', 'p', 'u.id = p.user_id');
  671.      * </code>
  672.      *
  673.      * @param string|string[]|null $select The selection expression. USING AN ARRAY OR NULL IS DEPRECATED.
  674.      *                                     Pass each value as an individual argument.
  675.      *
  676.      * @return $this This QueryBuilder instance.
  677.      */
  678.     public function select($select = null/*, string ...$selects*/)
  679.     {
  680.         $this->type = self::SELECT;
  682.         if ($select === null) {
  683.             return $this;
  684.         }
  686.         if (is_array($select)) {
  687.             Deprecation::trigger(
  688.                 'doctrine/dbal',
  689.                 'https://github.com/doctrine/dbal/issues/3837',
  690.                 'Passing an array for the first argument to QueryBuilder::select() is deprecated, ' .
  691.                 'pass each value as an individual variadic argument instead.',
  692.             );
  693.         }
  695.         $selects = is_array($select) ? $select : func_get_args();
  697.         return $this->add('select', $selects);
  698.     }
  700.     /**
  701.      * Adds or removes DISTINCT to/from the query.
  702.      *
  703.      * <code>
  704.      *     $qb = $conn->createQueryBuilder()
  705.      *         ->select('u.id')
  706.      *         ->distinct()
  707.      *         ->from('users', 'u')
  708.      * </code>
  709.      *
  710.      * @return $this This QueryBuilder instance.
  711.      */
  712.     public function distinct(/* bool $distinct = true */): self
  713.     {
  714.         $this->sqlParts['distinct'] = func_num_args() < 1 || func_get_arg(0);
  715.         $this->state                = self::STATE_DIRTY;
  717.         return $this;
  718.     }
  720.     /**
  721.      * Adds an item that is to be returned in the query result.
  722.      *
  723.      * USING AN ARRAY ARGUMENT IS DEPRECATED. Pass each value as an individual argument.
  724.      *
  725.      * <code>
  726.      *     $qb = $conn->createQueryBuilder()
  727.      *         ->select('u.id')
  728.      *         ->addSelect('p.id')
  729.      *         ->from('users', 'u')
  730.      *         ->leftJoin('u', 'phonenumbers', 'u.id = p.user_id');
  731.      * </code>
  732.      *
  733.      * @param string|string[]|null $select The selection expression. USING AN ARRAY OR NULL IS DEPRECATED.
  734.      *                                     Pass each value as an individual argument.
  735.      *
  736.      * @return $this This QueryBuilder instance.
  737.      */
  738.     public function addSelect($select = null/*, string ...$selects*/)
  739.     {
  740.         $this->type = self::SELECT;
  742.         if ($select === null) {
  743.             return $this;
  744.         }
  746.         if (is_array($select)) {
  747.             Deprecation::trigger(
  748.                 'doctrine/dbal',
  749.                 'https://github.com/doctrine/dbal/issues/3837',
  750.                 'Passing an array for the first argument to QueryBuilder::addSelect() is deprecated, ' .
  751.                 'pass each value as an individual variadic argument instead.',
  752.             );
  753.         }
  755.         $selects = is_array($select) ? $select : func_get_args();
  757.         return $this->add('select', $selects, true);
  758.     }
  760.     /**
  761.      * Turns the query being built into a bulk delete query that ranges over
  762.      * a certain table.
  763.      *
  764.      * <code>
  765.      *     $qb = $conn->createQueryBuilder()
  766.      *         ->delete('users', 'u')
  767.      *         ->where('u.id = :user_id')
  768.      *         ->setParameter(':user_id', 1);
  769.      * </code>
  770.      *
  771.      * @param string $delete The table whose rows are subject to the deletion.
  772.      * @param string $alias  The table alias used in the constructed query.
  773.      *
  774.      * @return $this This QueryBuilder instance.
  775.      */
  776.     public function delete($delete = null, $alias = null)
  777.     {
  778.         $this->type = self::DELETE;
  780.         if ($delete === null) {
  781.             return $this;
  782.         }
  784.         return $this->add('from', [
  785.             'table' => $delete,
  786.             'alias' => $alias,
  787.         ]);
  788.     }
  790.     /**
  791.      * Turns the query being built into a bulk update query that ranges over
  792.      * a certain table
  793.      *
  794.      * <code>
  795.      *     $qb = $conn->createQueryBuilder()
  796.      *         ->update('counters', 'c')
  797.      *         ->set('c.value', 'c.value + 1')
  798.      *         ->where('c.id = ?');
  799.      * </code>
  800.      *
  801.      * @param string $update The table whose rows are subject to the update.
  802.      * @param string $alias  The table alias used in the constructed query.
  803.      *
  804.      * @return $this This QueryBuilder instance.
  805.      */
  806.     public function update($update = null, $alias = null)
  807.     {
  808.         $this->type = self::UPDATE;
  810.         if ($update === null) {
  811.             return $this;
  812.         }
  814.         return $this->add('from', [
  815.             'table' => $update,
  816.             'alias' => $alias,
  817.         ]);
  818.     }
  820.     /**
  821.      * Turns the query being built into an insert query that inserts into
  822.      * a certain table
  823.      *
  824.      * <code>
  825.      *     $qb = $conn->createQueryBuilder()
  826.      *         ->insert('users')
  827.      *         ->values(
  828.      *             array(
  829.      *                 'name' => '?',
  830.      *                 'password' => '?'
  831.      *             )
  832.      *         );
  833.      * </code>
  834.      *
  835.      * @param string $insert The table into which the rows should be inserted.
  836.      *
  837.      * @return $this This QueryBuilder instance.
  838.      */
  839.     public function insert($insert = null)
  840.     {
  841.         $this->type = self::INSERT;
  843.         if ($insert === null) {
  844.             return $this;
  845.         }
  847.         return $this->add('from', ['table' => $insert]);
  848.     }
  850.     /**
  851.      * Creates and adds a query root corresponding to the table identified by the
  852.      * given alias, forming a cartesian product with any existing query roots.
  853.      *
  854.      * <code>
  855.      *     $qb = $conn->createQueryBuilder()
  856.      *         ->select('u.id')
  857.      *         ->from('users', 'u')
  858.      * </code>
  859.      *
  860.      * @param string      $from  The table.
  861.      * @param string|null $alias The alias of the table.
  862.      *
  863.      * @return $this This QueryBuilder instance.
  864.      */
  865.     public function from($from, $alias = null)
  866.     {
  867.         return $this->add('from', [
  868.             'table' => $from,
  869.             'alias' => $alias,
  870.         ], true);
  871.     }
  873.     /**
  874.      * Creates and adds a join to the query.
  875.      *
  876.      * <code>
  877.      *     $qb = $conn->createQueryBuilder()
  878.      *         ->select('u.name')
  879.      *         ->from('users', 'u')
  880.      *         ->join('u', 'phonenumbers', 'p', 'p.is_primary = 1');
  881.      * </code>
  882.      *
  883.      * @param string $fromAlias The alias that points to a from clause.
  884.      * @param string $join      The table name to join.
  885.      * @param string $alias     The alias of the join table.
  886.      * @param string $condition The condition for the join.
  887.      *
  888.      * @return $this This QueryBuilder instance.
  889.      */
  890.     public function join($fromAlias, $join, $alias, $condition = null)
  891.     {
  892.         return $this->innerJoin($fromAlias, $join, $alias, $condition);
  893.     }
  895.     /**
  896.      * Creates and adds a join to the query.
  897.      *
  898.      * <code>
  899.      *     $qb = $conn->createQueryBuilder()
  900.      *         ->select('u.name')
  901.      *         ->from('users', 'u')
  902.      *         ->innerJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
  903.      * </code>
  904.      *
  905.      * @param string $fromAlias The alias that points to a from clause.
  906.      * @param string $join      The table name to join.
  907.      * @param string $alias     The alias of the join table.
  908.      * @param string $condition The condition for the join.
  909.      *
  910.      * @return $this This QueryBuilder instance.
  911.      */
  912.     public function innerJoin($fromAlias, $join, $alias, $condition = null)
  913.     {
  914.         return $this->add('join', [
  915.             $fromAlias => [
  916.                 'joinType'      => 'inner',
  917.                 'joinTable'     => $join,
  918.                 'joinAlias'     => $alias,
  919.                 'joinCondition' => $condition,
  920.             ],
  921.         ], true);
  922.     }
  924.     /**
  925.      * Creates and adds a left join to the query.
  926.      *
  927.      * <code>
  928.      *     $qb = $conn->createQueryBuilder()
  929.      *         ->select('u.name')
  930.      *         ->from('users', 'u')
  931.      *         ->leftJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
  932.      * </code>
  933.      *
  934.      * @param string $fromAlias The alias that points to a from clause.
  935.      * @param string $join      The table name to join.
  936.      * @param string $alias     The alias of the join table.
  937.      * @param string $condition The condition for the join.
  938.      *
  939.      * @return $this This QueryBuilder instance.
  940.      */
  941.     public function leftJoin($fromAlias, $join, $alias, $condition = null)
  942.     {
  943.         return $this->add('join', [
  944.             $fromAlias => [
  945.                 'joinType'      => 'left',
  946.                 'joinTable'     => $join,
  947.                 'joinAlias'     => $alias,
  948.                 'joinCondition' => $condition,
  949.             ],
  950.         ], true);
  951.     }
  953.     /**
  954.      * Creates and adds a right join to the query.
  955.      *
  956.      * <code>
  957.      *     $qb = $conn->createQueryBuilder()
  958.      *         ->select('u.name')
  959.      *         ->from('users', 'u')
  960.      *         ->rightJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
  961.      * </code>
  962.      *
  963.      * @param string $fromAlias The alias that points to a from clause.
  964.      * @param string $join      The table name to join.
  965.      * @param string $alias     The alias of the join table.
  966.      * @param string $condition The condition for the join.
  967.      *
  968.      * @return $this This QueryBuilder instance.
  969.      */
  970.     public function rightJoin($fromAlias, $join, $alias, $condition = null)
  971.     {
  972.         return $this->add('join', [
  973.             $fromAlias => [
  974.                 'joinType'      => 'right',
  975.                 'joinTable'     => $join,
  976.                 'joinAlias'     => $alias,
  977.                 'joinCondition' => $condition,
  978.             ],
  979.         ], true);
  980.     }
  982.     /**
  983.      * Sets a new value for a column in a bulk update query.
  984.      *
  985.      * <code>
  986.      *     $qb = $conn->createQueryBuilder()
  987.      *         ->update('counters', 'c')
  988.      *         ->set('c.value', 'c.value + 1')
  989.      *         ->where('c.id = ?');
  990.      * </code>
  991.      *
  992.      * @param string $key   The column to set.
  993.      * @param string $value The value, expression, placeholder, etc.
  994.      *
  995.      * @return $this This QueryBuilder instance.
  996.      */
  997.     public function set($key, $value)
  998.     {
  999.         return $this->add('set', $key . ' = ' . $value, true);
  1000.     }
  1002.     /**
  1003.      * Specifies one or more restrictions to the query result.
  1004.      * Replaces any previously specified restrictions, if any.
  1005.      *
  1006.      * <code>
  1007.      *     $qb = $conn->createQueryBuilder()
  1008.      *         ->select('c.value')
  1009.      *         ->from('counters', 'c')
  1010.      *         ->where('c.id = ?');
  1011.      *
  1012.      *     // You can optionally programmatically build and/or expressions
  1013.      *     $qb = $conn->createQueryBuilder();
  1014.      *
  1015.      *     $or = $qb->expr()->orx();
  1016.      *     $or->add($qb->expr()->eq('c.id', 1));
  1017.      *     $or->add($qb->expr()->eq('c.id', 2));
  1018.      *
  1019.      *     $qb->update('counters', 'c')
  1020.      *         ->set('c.value', 'c.value + 1')
  1021.      *         ->where($or);
  1022.      * </code>
  1023.      *
  1024.      * @param mixed $predicates The restriction predicates.
  1025.      *
  1026.      * @return $this This QueryBuilder instance.
  1027.      */
  1028.     public function where($predicates)
  1029.     {
  1030.         if (! (func_num_args() === 1 && $predicates instanceof CompositeExpression)) {
  1031.             $predicates = CompositeExpression::and(...func_get_args());
  1032.         }
  1034.         return $this->add('where', $predicates);
  1035.     }
  1037.     /**
  1038.      * Adds one or more restrictions to the query results, forming a logical
  1039.      * conjunction with any previously specified restrictions.
  1040.      *
  1041.      * <code>
  1042.      *     $qb = $conn->createQueryBuilder()
  1043.      *         ->select('u')
  1044.      *         ->from('users', 'u')
  1045.      *         ->where('u.username LIKE ?')
  1046.      *         ->andWhere('u.is_active = 1');
  1047.      * </code>
  1048.      *
  1049.      * @see where()
  1050.      *
  1051.      * @param mixed $where The query restrictions.
  1052.      *
  1053.      * @return $this This QueryBuilder instance.
  1054.      */
  1055.     public function andWhere($where)
  1056.     {
  1057.         $args  = func_get_args();
  1058.         $where = $this->getQueryPart('where');
  1060.         if ($where instanceof CompositeExpression && $where->getType() === CompositeExpression::TYPE_AND) {
  1061.             $where = $where->with(...$args);
  1062.         } else {
  1063.             array_unshift($args, $where);
  1064.             $where = CompositeExpression::and(...$args);
  1065.         }
  1067.         return $this->add('where', $where, true);
  1068.     }
  1070.     /**
  1071.      * Adds one or more restrictions to the query results, forming a logical
  1072.      * disjunction with any previously specified restrictions.
  1073.      *
  1074.      * <code>
  1075.      *     $qb = $em->createQueryBuilder()
  1076.      *         ->select('u.name')
  1077.      *         ->from('users', 'u')
  1078.      *         ->where('u.id = 1')
  1079.      *         ->orWhere('u.id = 2');
  1080.      * </code>
  1081.      *
  1082.      * @see where()
  1083.      *
  1084.      * @param mixed $where The WHERE statement.
  1085.      *
  1086.      * @return $this This QueryBuilder instance.
  1087.      */
  1088.     public function orWhere($where)
  1089.     {
  1090.         $args  = func_get_args();
  1091.         $where = $this->getQueryPart('where');
  1093.         if ($where instanceof CompositeExpression && $where->getType() === CompositeExpression::TYPE_OR) {
  1094.             $where = $where->with(...$args);
  1095.         } else {
  1096.             array_unshift($args, $where);
  1097.             $where = CompositeExpression::or(...$args);
  1098.         }
  1100.         return $this->add('where', $where, true);
  1101.     }
  1103.     /**
  1104.      * Specifies a grouping over the results of the query.
  1105.      * Replaces any previously specified groupings, if any.
  1106.      *
  1107.      * USING AN ARRAY ARGUMENT IS DEPRECATED. Pass each value as an individual argument.
  1108.      *
  1109.      * <code>
  1110.      *     $qb = $conn->createQueryBuilder()
  1111.      *         ->select('u.name')
  1112.      *         ->from('users', 'u')
  1113.      *         ->groupBy('u.id');
  1114.      * </code>
  1115.      *
  1116.      * @param string|string[] $groupBy The grouping expression. USING AN ARRAY IS DEPRECATED.
  1117.      *                                 Pass each value as an individual argument.
  1118.      *
  1119.      * @return $this This QueryBuilder instance.
  1120.      */
  1121.     public function groupBy($groupBy/*, string ...$groupBys*/)
  1122.     {
  1123.         if (is_array($groupBy) && count($groupBy) === 0) {
  1124.             return $this;
  1125.         }
  1127.         if (is_array($groupBy)) {
  1128.             Deprecation::trigger(
  1129.                 'doctrine/dbal',
  1130.                 'https://github.com/doctrine/dbal/issues/3837',
  1131.                 'Passing an array for the first argument to QueryBuilder::groupBy() is deprecated, ' .
  1132.                 'pass each value as an individual variadic argument instead.',
  1133.             );
  1134.         }
  1136.         $groupBy = is_array($groupBy) ? $groupBy : func_get_args();
  1138.         return $this->add('groupBy', $groupBy, false);
  1139.     }
  1141.     /**
  1142.      * Adds a grouping expression to the query.
  1143.      *
  1144.      * USING AN ARRAY ARGUMENT IS DEPRECATED. Pass each value as an individual argument.
  1145.      *
  1146.      * <code>
  1147.      *     $qb = $conn->createQueryBuilder()
  1148.      *         ->select('u.name')
  1149.      *         ->from('users', 'u')
  1150.      *         ->groupBy('u.lastLogin')
  1151.      *         ->addGroupBy('u.createdAt');
  1152.      * </code>
  1153.      *
  1154.      * @param string|string[] $groupBy The grouping expression. USING AN ARRAY IS DEPRECATED.
  1155.      *                                 Pass each value as an individual argument.
  1156.      *
  1157.      * @return $this This QueryBuilder instance.
  1158.      */
  1159.     public function addGroupBy($groupBy/*, string ...$groupBys*/)
  1160.     {
  1161.         if (is_array($groupBy) && count($groupBy) === 0) {
  1162.             return $this;
  1163.         }
  1165.         if (is_array($groupBy)) {
  1166.             Deprecation::trigger(
  1167.                 'doctrine/dbal',
  1168.                 'https://github.com/doctrine/dbal/issues/3837',
  1169.                 'Passing an array for the first argument to QueryBuilder::addGroupBy() is deprecated, ' .
  1170.                 'pass each value as an individual variadic argument instead.',
  1171.             );
  1172.         }
  1174.         $groupBy = is_array($groupBy) ? $groupBy : func_get_args();
  1176.         return $this->add('groupBy', $groupBy, true);
  1177.     }
  1179.     /**
  1180.      * Sets a value for a column in an insert query.
  1181.      *
  1182.      * <code>
  1183.      *     $qb = $conn->createQueryBuilder()
  1184.      *         ->insert('users')
  1185.      *         ->values(
  1186.      *             array(
  1187.      *                 'name' => '?'
  1188.      *             )
  1189.      *         )
  1190.      *         ->setValue('password', '?');
  1191.      * </code>
  1192.      *
  1193.      * @param string $column The column into which the value should be inserted.
  1194.      * @param string $value  The value that should be inserted into the column.
  1195.      *
  1196.      * @return $this This QueryBuilder instance.
  1197.      */
  1198.     public function setValue($column, $value)
  1199.     {
  1200.         $this->sqlParts['values'][$column] = $value;
  1202.         return $this;
  1203.     }
  1205.     /**
  1206.      * Specifies values for an insert query indexed by column names.
  1207.      * Replaces any previous values, if any.
  1208.      *
  1209.      * <code>
  1210.      *     $qb = $conn->createQueryBuilder()
  1211.      *         ->insert('users')
  1212.      *         ->values(
  1213.      *             array(
  1214.      *                 'name' => '?',
  1215.      *                 'password' => '?'
  1216.      *             )
  1217.      *         );
  1218.      * </code>
  1219.      *
  1220.      * @param mixed[] $values The values to specify for the insert query indexed by column names.
  1221.      *
  1222.      * @return $this This QueryBuilder instance.
  1223.      */
  1224.     public function values(array $values)
  1225.     {
  1226.         return $this->add('values', $values);
  1227.     }
  1229.     /**
  1230.      * Specifies a restriction over the groups of the query.
  1231.      * Replaces any previous having restrictions, if any.
  1232.      *
  1233.      * @param mixed $having The restriction over the groups.
  1234.      *
  1235.      * @return $this This QueryBuilder instance.
  1236.      */
  1237.     public function having($having)
  1238.     {
  1239.         if (! (func_num_args() === 1 && $having instanceof CompositeExpression)) {
  1240.             $having = CompositeExpression::and(...func_get_args());
  1241.         }
  1243.         return $this->add('having', $having);
  1244.     }
  1246.     /**
  1247.      * Adds a restriction over the groups of the query, forming a logical
  1248.      * conjunction with any existing having restrictions.
  1249.      *
  1250.      * @param mixed $having The restriction to append.
  1251.      *
  1252.      * @return $this This QueryBuilder instance.
  1253.      */
  1254.     public function andHaving($having)
  1255.     {
  1256.         $args   = func_get_args();
  1257.         $having = $this->getQueryPart('having');
  1259.         if ($having instanceof CompositeExpression && $having->getType() === CompositeExpression::TYPE_AND) {
  1260.             $having = $having->with(...$args);
  1261.         } else {
  1262.             array_unshift($args, $having);
  1263.             $having = CompositeExpression::and(...$args);
  1264.         }
  1266.         return $this->add('having', $having);
  1267.     }
  1269.     /**
  1270.      * Adds a restriction over the groups of the query, forming a logical
  1271.      * disjunction with any existing having restrictions.
  1272.      *
  1273.      * @param mixed $having The restriction to add.
  1274.      *
  1275.      * @return $this This QueryBuilder instance.
  1276.      */
  1277.     public function orHaving($having)
  1278.     {
  1279.         $args   = func_get_args();
  1280.         $having = $this->getQueryPart('having');
  1282.         if ($having instanceof CompositeExpression && $having->getType() === CompositeExpression::TYPE_OR) {
  1283.             $having = $having->with(...$args);
  1284.         } else {
  1285.             array_unshift($args, $having);
  1286.             $having = CompositeExpression::or(...$args);
  1287.         }
  1289.         return $this->add('having', $having);
  1290.     }
  1292.     /**
  1293.      * Specifies an ordering for the query results.
  1294.      * Replaces any previously specified orderings, if any.
  1295.      *
  1296.      * @param string $sort  The ordering expression.
  1297.      * @param string $order The ordering direction.
  1298.      *
  1299.      * @return $this This QueryBuilder instance.
  1300.      */
  1301.     public function orderBy($sort, $order = null)
  1302.     {
  1303.         return $this->add('orderBy', $sort . ' ' . ($order ?? 'ASC'), false);
  1304.     }
  1306.     /**
  1307.      * Adds an ordering to the query results.
  1308.      *
  1309.      * @param string $sort  The ordering expression.
  1310.      * @param string $order The ordering direction.
  1311.      *
  1312.      * @return $this This QueryBuilder instance.
  1313.      */
  1314.     public function addOrderBy($sort, $order = null)
  1315.     {
  1316.         return $this->add('orderBy', $sort . ' ' . ($order ?? 'ASC'), true);
  1317.     }
  1319.     /**
  1320.      * Gets a query part by its name.
  1321.      *
  1322.      * @deprecated The query parts are implementation details and should not be relied upon.
  1323.      *
  1324.      * @param string $queryPartName
  1325.      *
  1326.      * @return mixed
  1327.      */
  1328.     public function getQueryPart($queryPartName)
  1329.     {
  1330.         Deprecation::triggerIfCalledFromOutside(
  1331.             'doctrine/dbal',
  1332.             'https://github.com/doctrine/dbal/pull/6179',
  1333.             'Getting query parts is deprecated as they are implementation details.',
  1334.         );
  1336.         return $this->sqlParts[$queryPartName];
  1337.     }
  1339.     /**
  1340.      * Gets all query parts.
  1341.      *
  1342.      * @deprecated The query parts are implementation details and should not be relied upon.
  1343.      *
  1344.      * @return mixed[]
  1345.      */
  1346.     public function getQueryParts()
  1347.     {
  1348.         Deprecation::trigger(
  1349.             'doctrine/dbal',
  1350.             'https://github.com/doctrine/dbal/pull/6179',
  1351.             'Getting query parts is deprecated as they are implementation details.',
  1352.         );
  1354.         return $this->sqlParts;
  1355.     }
  1357.     /**
  1358.      * Resets SQL parts.
  1359.      *
  1360.      * @deprecated Use the dedicated reset*() methods instead.
  1361.      *
  1362.      * @param string[]|null $queryPartNames
  1363.      *
  1364.      * @return $this This QueryBuilder instance.
  1365.      */
  1366.     public function resetQueryParts($queryPartNames = null)
  1367.     {
  1368.         Deprecation::trigger(
  1369.             'doctrine/dbal',
  1370.             'https://github.com/doctrine/dbal/pull/6193',
  1371.             '%s() is deprecated, instead use dedicated reset methods for the parts that shall be reset.',
  1372.             __METHOD__,
  1373.         );
  1375.         $queryPartNames ??= array_keys($this->sqlParts);
  1377.         foreach ($queryPartNames as $queryPartName) {
  1378.             $this->sqlParts[$queryPartName] = self::SQL_PARTS_DEFAULTS[$queryPartName];
  1379.         }
  1381.         $this->state = self::STATE_DIRTY;
  1383.         return $this;
  1384.     }
  1386.     /**
  1387.      * Resets a single SQL part.
  1388.      *
  1389.      * @deprecated Use the dedicated reset*() methods instead.
  1390.      *
  1391.      * @param string $queryPartName
  1392.      *
  1393.      * @return $this This QueryBuilder instance.
  1394.      */
  1395.     public function resetQueryPart($queryPartName)
  1396.     {
  1397.         if ($queryPartName === 'distinct') {
  1398.             Deprecation::trigger(
  1399.                 'doctrine/dbal',
  1400.                 'https://github.com/doctrine/dbal/pull/6193',
  1401.                 'Calling %s() with "distinct" is deprecated, call distinct(false) instead.',
  1402.                 __METHOD__,
  1403.             );
  1405.             return $this->distinct(false);
  1406.         }
  1408.         $newMethodName = 'reset' . ucfirst($queryPartName);
  1409.         if (array_key_exists($queryPartName, self::SQL_PARTS_DEFAULTS) && method_exists($this, $newMethodName)) {
  1410.             Deprecation::trigger(
  1411.                 'doctrine/dbal',
  1412.                 'https://github.com/doctrine/dbal/pull/6193',
  1413.                 'Calling %s() with "%s" is deprecated, call %s() instead.',
  1414.                 __METHOD__,
  1415.                 $queryPartName,
  1416.                 $newMethodName,
  1417.             );
  1419.             return $this->$newMethodName();
  1420.         }
  1422.         Deprecation::trigger(
  1423.             'doctrine/dbal',
  1424.             'https://github.com/doctrine/dbal/pull/6193',
  1425.             'Calling %s() with "%s" is deprecated without replacement.',
  1426.             __METHOD__,
  1427.             $queryPartName,
  1428.             $newMethodName,
  1429.         );
  1431.         $this->sqlParts[$queryPartName] = self::SQL_PARTS_DEFAULTS[$queryPartName];
  1433.         $this->state = self::STATE_DIRTY;
  1435.         return $this;
  1436.     }
  1438.     /**
  1439.      * Resets the WHERE conditions for the query.
  1440.      *
  1441.      * @return $this This QueryBuilder instance.
  1442.      */
  1443.     public function resetWhere(): self
  1444.     {
  1445.         $this->sqlParts['where'] = self::SQL_PARTS_DEFAULTS['where'];
  1447.         $this->state = self::STATE_DIRTY;
  1449.         return $this;
  1450.     }
  1452.     /**
  1453.      * Resets the grouping for the query.
  1454.      *
  1455.      * @return $this This QueryBuilder instance.
  1456.      */
  1457.     public function resetGroupBy(): self
  1458.     {
  1459.         $this->sqlParts['groupBy'] = self::SQL_PARTS_DEFAULTS['groupBy'];
  1461.         $this->state = self::STATE_DIRTY;
  1463.         return $this;
  1464.     }
  1466.     /**
  1467.      * Resets the HAVING conditions for the query.
  1468.      *
  1469.      * @return $this This QueryBuilder instance.
  1470.      */
  1471.     public function resetHaving(): self
  1472.     {
  1473.         $this->sqlParts['having'] = self::SQL_PARTS_DEFAULTS['having'];
  1475.         $this->state = self::STATE_DIRTY;
  1477.         return $this;
  1478.     }
  1480.     /**
  1481.      * Resets the ordering for the query.
  1482.      *
  1483.      * @return $this This QueryBuilder instance.
  1484.      */
  1485.     public function resetOrderBy(): self
  1486.     {
  1487.         $this->sqlParts['orderBy'] = self::SQL_PARTS_DEFAULTS['orderBy'];
  1489.         $this->state = self::STATE_DIRTY;
  1491.         return $this;
  1492.     }
  1494.     /** @throws Exception */
  1495.     private function getSQLForSelect(): string
  1496.     {
  1497.         return $this->connection->getDatabasePlatform()
  1498.             ->createSelectSQLBuilder()
  1499.             ->buildSQL(
  1500.                 new SelectQuery(
  1501.                     $this->sqlParts['distinct'],
  1502.                     $this->sqlParts['select'],
  1503.                     $this->getFromClauses(),
  1504.                     $this->sqlParts['where'],
  1505.                     $this->sqlParts['groupBy'],
  1506.                     $this->sqlParts['having'],
  1507.                     $this->sqlParts['orderBy'],
  1508.                     new Limit($this->maxResults, $this->firstResult),
  1509.                     $this->sqlParts['for_update'],
  1510.                 ),
  1511.             );
  1512.     }
  1514.     /**
  1515.      * @return string[]
  1516.      *
  1517.      * @throws QueryException
  1518.      */
  1519.     private function getFromClauses(): array
  1520.     {
  1521.         $fromClauses  = [];
  1522.         $knownAliases = [];
  1524.         // Loop through all FROM clauses
  1525.         foreach ($this->sqlParts['from'] as $from) {
  1526.             if ($from['alias'] === null) {
  1527.                 $tableSql       = $from['table'];
  1528.                 $tableReference = $from['table'];
  1529.             } else {
  1530.                 $tableSql       = $from['table'] . ' ' . $from['alias'];
  1531.                 $tableReference = $from['alias'];
  1532.             }
  1534.             $knownAliases[$tableReference] = true;
  1536.             $fromClauses[$tableReference] = $tableSql . $this->getSQLForJoins($tableReference, $knownAliases);
  1537.         }
  1539.         $this->verifyAllAliasesAreKnown($knownAliases);
  1541.         return $fromClauses;
  1542.     }
  1544.     /**
  1545.      * @param array<string,true> $knownAliases
  1546.      *
  1547.      * @throws QueryException
  1548.      */
  1549.     private function verifyAllAliasesAreKnown(array $knownAliases): void
  1550.     {
  1551.         foreach ($this->sqlParts['join'] as $fromAlias => $joins) {
  1552.             if (! isset($knownAliases[$fromAlias])) {
  1553.                 throw QueryException::unknownAlias($fromAlias, array_keys($knownAliases));
  1554.             }
  1555.         }
  1556.     }
  1558.     /**
  1559.      * Converts this instance into an INSERT string in SQL.
  1560.      */
  1561.     private function getSQLForInsert(): string
  1562.     {
  1563.         return 'INSERT INTO ' . $this->sqlParts['from']['table'] .
  1564.         ' (' . implode(', ', array_keys($this->sqlParts['values'])) . ')' .
  1565.         ' VALUES(' . implode(', ', $this->sqlParts['values']) . ')';
  1566.     }
  1568.     /**
  1569.      * Converts this instance into an UPDATE string in SQL.
  1570.      */
  1571.     private function getSQLForUpdate(): string
  1572.     {
  1573.         $table = $this->sqlParts['from']['table']
  1574.             . ($this->sqlParts['from']['alias'] ? ' ' . $this->sqlParts['from']['alias'] : '');
  1576.         return 'UPDATE ' . $table
  1577.             . ' SET ' . implode(', ', $this->sqlParts['set'])
  1578.             . ($this->sqlParts['where'] !== null ? ' WHERE ' . ((string) $this->sqlParts['where']) : '');
  1579.     }
  1581.     /**
  1582.      * Converts this instance into a DELETE string in SQL.
  1583.      */
  1584.     private function getSQLForDelete(): string
  1585.     {
  1586.         $table = $this->sqlParts['from']['table']
  1587.             . ($this->sqlParts['from']['alias'] ? ' ' . $this->sqlParts['from']['alias'] : '');
  1589.         return 'DELETE FROM ' . $table
  1590.             . ($this->sqlParts['where'] !== null ? ' WHERE ' . ((string) $this->sqlParts['where']) : '');
  1591.     }
  1593.     /**
  1594.      * Gets a string representation of this QueryBuilder which corresponds to
  1595.      * the final SQL query being constructed.
  1596.      *
  1597.      * @return string The string representation of this QueryBuilder.
  1598.      */
  1599.     public function __toString()
  1600.     {
  1601.         return $this->getSQL();
  1602.     }
  1604.     /**
  1605.      * Creates a new named parameter and bind the value $value to it.
  1606.      *
  1607.      * This method provides a shortcut for {@see Statement::bindValue()}
  1608.      * when using prepared statements.
  1609.      *
  1610.      * The parameter $value specifies the value that you want to bind. If
  1611.      * $placeholder is not provided createNamedParameter() will automatically
  1612.      * create a placeholder for you. An automatic placeholder will be of the
  1613.      * name ':dcValue1', ':dcValue2' etc.
  1614.      *
  1615.      * Example:
  1616.      * <code>
  1617.      * $value = 2;
  1618.      * $q->eq( 'id', $q->createNamedParameter( $value ) );
  1619.      * $stmt = $q->executeQuery(); // executed with 'id = 2'
  1620.      * </code>
  1621.      *
  1622.      * @link http://www.zetacomponents.org
  1623.      *
  1624.      * @param mixed                $value
  1625.      * @param int|string|Type|null $type
  1626.      * @param string               $placeHolder The name to bind with. The string must start with a colon ':'.
  1627.      *
  1628.      * @return string the placeholder name used.
  1629.      */
  1630.     public function createNamedParameter($value, $type = ParameterType::STRING, $placeHolder = null)
  1631.     {
  1632.         if ($placeHolder === null) {
  1633.             $this->boundCounter++;
  1634.             $placeHolder = ':dcValue' . $this->boundCounter;
  1635.         }
  1637.         $this->setParameter(substr($placeHolder, 1), $value, $type);
  1639.         return $placeHolder;
  1640.     }
  1642.     /**
  1643.      * Creates a new positional parameter and bind the given value to it.
  1644.      *
  1645.      * Attention: If you are using positional parameters with the query builder you have
  1646.      * to be very careful to bind all parameters in the order they appear in the SQL
  1647.      * statement , otherwise they get bound in the wrong order which can lead to serious
  1648.      * bugs in your code.
  1649.      *
  1650.      * Example:
  1651.      * <code>
  1652.      *  $qb = $conn->createQueryBuilder();
  1653.      *  $qb->select('u.*')
  1654.      *     ->from('users', 'u')
  1655.      *     ->where('u.username = ' . $qb->createPositionalParameter('Foo', ParameterType::STRING))
  1656.      *     ->orWhere('u.username = ' . $qb->createPositionalParameter('Bar', ParameterType::STRING))
  1657.      * </code>
  1658.      *
  1659.      * @param mixed                $value
  1660.      * @param int|string|Type|null $type
  1661.      *
  1662.      * @return string
  1663.      */
  1664.     public function createPositionalParameter($value, $type = ParameterType::STRING)
  1665.     {
  1666.         $this->setParameter($this->boundCounter, $value, $type);
  1667.         $this->boundCounter++;
  1669.         return '?';
  1670.     }
  1672.     /**
  1673.      * @param string             $fromAlias
  1674.      * @param array<string,true> $knownAliases
  1675.      *
  1676.      * @throws QueryException
  1677.      */
  1678.     private function getSQLForJoins($fromAlias, array &$knownAliases): string
  1679.     {
  1680.         $sql = '';
  1682.         if (isset($this->sqlParts['join'][$fromAlias])) {
  1683.             foreach ($this->sqlParts['join'][$fromAlias] as $join) {
  1684.                 if (array_key_exists($join['joinAlias'], $knownAliases)) {
  1685.                     throw QueryException::nonUniqueAlias((string) $join['joinAlias'], array_keys($knownAliases));
  1686.                 }
  1688.                 $sql .= ' ' . strtoupper($join['joinType'])
  1689.                     . ' JOIN ' . $join['joinTable'] . ' ' . $join['joinAlias'];
  1690.                 if ($join['joinCondition'] !== null) {
  1691.                     $sql .= ' ON ' . $join['joinCondition'];
  1692.                 }
  1694.                 $knownAliases[$join['joinAlias']] = true;
  1695.             }
  1697.             foreach ($this->sqlParts['join'][$fromAlias] as $join) {
  1698.                 $sql .= $this->getSQLForJoins($join['joinAlias'], $knownAliases);
  1699.             }
  1700.         }
  1702.         return $sql;
  1703.     }
  1705.     /**
  1706.      * Deep clone of all expression objects in the SQL parts.
  1707.      *
  1708.      * @return void
  1709.      */
  1710.     public function __clone()
  1711.     {
  1712.         foreach ($this->sqlParts as $part => $elements) {
  1713.             if (is_array($this->sqlParts[$part])) {
  1714.                 foreach ($this->sqlParts[$part] as $idx => $element) {
  1715.                     if (! is_object($element)) {
  1716.                         continue;
  1717.                     }
  1719.                     $this->sqlParts[$part][$idx] = clone $element;
  1720.                 }
  1721.             } elseif (is_object($elements)) {
  1722.                 $this->sqlParts[$part] = clone $elements;
  1723.             }
  1724.         }
  1726.         foreach ($this->params as $name => $param) {
  1727.             if (! is_object($param)) {
  1728.                 continue;
  1729.             }
  1731.             $this->params[$name] = clone $param;
  1732.         }
  1733.     }
  1735.     /**
  1736.      * Enables caching of the results of this query, for given amount of seconds
  1737.      * and optionally specified which key to use for the cache entry.
  1738.      *
  1739.      * @return $this
  1740.      */
  1741.     public function enableResultCache(QueryCacheProfile $cacheProfile): self
  1742.     {
  1743.         $this->resultCacheProfile = $cacheProfile;
  1745.         return $this;
  1746.     }
  1748.     /**
  1749.      * Disables caching of the results of this query.
  1750.      *
  1751.      * @return $this
  1752.      */
  1753.     public function disableResultCache(): self
  1754.     {
  1755.         $this->resultCacheProfile = null;
  1757.         return $this;
  1758.     }
  1759. }