vendor/doctrine/orm/lib/Doctrine/ORM/Query.php line 232

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM;
  7. use Doctrine\Common\Cache\Cache;
  8. use Doctrine\Common\Cache\Psr6\CacheAdapter;
  9. use Doctrine\Common\Cache\Psr6\DoctrineProvider;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Doctrine\DBAL\Cache\QueryCacheProfile;
  12. use Doctrine\DBAL\LockMode;
  13. use Doctrine\DBAL\Types\Type;
  14. use Doctrine\Deprecations\Deprecation;
  15. use Doctrine\ORM\Internal\Hydration\IterableResult;
  16. use Doctrine\ORM\Mapping\ClassMetadata;
  17. use Doctrine\ORM\Query\AST\DeleteStatement;
  18. use Doctrine\ORM\Query\AST\SelectStatement;
  19. use Doctrine\ORM\Query\AST\UpdateStatement;
  20. use Doctrine\ORM\Query\Exec\AbstractSqlExecutor;
  21. use Doctrine\ORM\Query\Parameter;
  22. use Doctrine\ORM\Query\ParameterTypeInferer;
  23. use Doctrine\ORM\Query\Parser;
  24. use Doctrine\ORM\Query\ParserResult;
  25. use Doctrine\ORM\Query\QueryException;
  26. use Doctrine\ORM\Query\ResultSetMapping;
  27. use Doctrine\ORM\Utility\HierarchyDiscriminatorResolver;
  28. use Psr\Cache\CacheItemPoolInterface;
  30. use function array_keys;
  31. use function array_values;
  32. use function assert;
  33. use function count;
  34. use function get_debug_type;
  35. use function in_array;
  36. use function is_int;
  37. use function ksort;
  38. use function md5;
  39. use function method_exists;
  40. use function reset;
  41. use function serialize;
  42. use function sha1;
  43. use function stripos;
  45. /**
  46.  * A Query object represents a DQL query.
  47.  */
  48. final class Query extends AbstractQuery
  49. {
  50.     /**
  51.      * A query object is in CLEAN state when it has NO unparsed/unprocessed DQL parts.
  52.      */
  53.     public const STATE_CLEAN = 1;
  55.     /**
  56.      * A query object is in state DIRTY when it has DQL parts that have not yet been
  57.      * parsed/processed. This is automatically defined as DIRTY when addDqlQueryPart
  58.      * is called.
  59.      */
  60.     public const STATE_DIRTY = 2;
  62.     /* Query HINTS */
  64.     /**
  65.      * The refresh hint turns any query into a refresh query with the result that
  66.      * any local changes in entities are overridden with the fetched values.
  67.      */
  68.     public const HINT_REFRESH = 'doctrine.refresh';
  70.     public const HINT_CACHE_ENABLED = 'doctrine.cache.enabled';
  72.     public const HINT_CACHE_EVICT = 'doctrine.cache.evict';
  74.     /**
  75.      * Internal hint: is set to the proxy entity that is currently triggered for loading
  76.      */
  77.     public const HINT_REFRESH_ENTITY = 'doctrine.refresh.entity';
  79.     /**
  80.      * The forcePartialLoad query hint forces a particular query to return
  81.      * partial objects.
  82.      *
  83.      * @todo Rename: HINT_OPTIMIZE
  84.      */
  85.     public const HINT_FORCE_PARTIAL_LOAD = 'doctrine.forcePartialLoad';
  87.     /**
  88.      * The includeMetaColumns query hint causes meta columns like foreign keys and
  89.      * discriminator columns to be selected and returned as part of the query result.
  90.      *
  91.      * This hint does only apply to non-object queries.
  92.      */
  93.     public const HINT_INCLUDE_META_COLUMNS = 'doctrine.includeMetaColumns';
  95.     /**
  96.      * An array of class names that implement \Doctrine\ORM\Query\TreeWalker and
  97.      * are iterated and executed after the DQL has been parsed into an AST.
  98.      */
  99.     public const HINT_CUSTOM_TREE_WALKERS = 'doctrine.customTreeWalkers';
  101.     /**
  102.      * A string with a class name that implements \Doctrine\ORM\Query\TreeWalker
  103.      * and is used for generating the target SQL from any DQL AST tree.
  104.      */
  105.     public const HINT_CUSTOM_OUTPUT_WALKER = 'doctrine.customOutputWalker';
  107.     /**
  108.      * Marks queries as creating only read only objects.
  109.      *
  110.      * If the object retrieved from the query is already in the identity map
  111.      * then it does not get marked as read only if it wasn't already.
  112.      */
  113.     public const HINT_READ_ONLY = 'doctrine.readOnly';
  115.     public const HINT_INTERNAL_ITERATION = 'doctrine.internal.iteration';
  117.     public const HINT_LOCK_MODE = 'doctrine.lockMode';
  119.     /**
  120.      * The current state of this query.
  121.      *
  122.      * @var int
  123.      * @psalm-var self::STATE_*
  124.      */
  125.     private $_state = self::STATE_DIRTY;
  127.     /**
  128.      * A snapshot of the parameter types the query was parsed with.
  129.      *
  130.      * @var array<string,Type>
  131.      */
  132.     private $parsedTypes = [];
  134.     /**
  135.      * Cached DQL query.
  136.      *
  137.      * @var string|null
  138.      */
  139.     private $dql = null;
  141.     /**
  142.      * The parser result that holds DQL => SQL information.
  143.      *
  144.      * @var ParserResult
  145.      */
  146.     private $parserResult;
  148.     /**
  149.      * The first result to return (the "offset").
  150.      *
  151.      * @var int
  152.      */
  153.     private $firstResult = 0;
  155.     /**
  156.      * The maximum number of results to return (the "limit").
  157.      *
  158.      * @var int|null
  159.      */
  160.     private $maxResults = null;
  162.     /**
  163.      * The cache driver used for caching queries.
  164.      *
  165.      * @var CacheItemPoolInterface|null
  166.      */
  167.     private $queryCache;
  169.     /**
  170.      * Whether or not expire the query cache.
  171.      *
  172.      * @var bool
  173.      */
  174.     private $expireQueryCache = false;
  176.     /**
  177.      * The query cache lifetime.
  178.      *
  179.      * @var int|null
  180.      */
  181.     private $queryCacheTTL;
  183.     /**
  184.      * Whether to use a query cache, if available. Defaults to TRUE.
  185.      *
  186.      * @var bool
  187.      */
  188.     private $useQueryCache = true;
  190.     /**
  191.      * Gets the SQL query/queries that correspond to this DQL query.
  192.      *
  193.      * @return list<string>|string The built sql query or an array of all sql queries.
  194.      */
  195.     public function getSQL()
  196.     {
  197.         return $this->parse()->getSqlExecutor()->getSqlStatements();
  198.     }
  200.     /**
  201.      * Returns the corresponding AST for this DQL query.
  202.      *
  203.      * @return SelectStatement|UpdateStatement|DeleteStatement
  204.      */
  205.     public function getAST()
  206.     {
  207.         $parser = new Parser($this);
  209.         return $parser->getAST();
  210.     }
  212.     /**
  213.      * {@inheritdoc}
  214.      *
  215.      * @return ResultSetMapping
  216.      */
  217.     protected function getResultSetMapping()
  218.     {
  219.         // parse query or load from cache
  220.         if ($this->_resultSetMapping === null) {
  221.             $this->_resultSetMapping = $this->parse()->getResultSetMapping();
  222.         }
  224.         return $this->_resultSetMapping;
  225.     }
  227.     /**
  228.      * Parses the DQL query, if necessary, and stores the parser result.
  229.      *
  230.      * Note: Populates $this->_parserResult as a side-effect.
  231.      */
  232.     private function parse(): ParserResult
  233.     {
  234.         $types = [];
  236.         foreach ($this->parameters as $parameter) {
  237.             /** @var Query\Parameter $parameter */
  238.             $types[$parameter->getName()] = $parameter->getType();
  239.         }
  241.         // Return previous parser result if the query and the filter collection are both clean
  242.         if ($this->_state === self::STATE_CLEAN && $this->parsedTypes === $types && $this->_em->isFiltersStateClean()) {
  243.             return $this->parserResult;
  244.         }
  246.         $this->_state      = self::STATE_CLEAN;
  247.         $this->parsedTypes = $types;
  249.         $queryCache = $this->queryCache ?? $this->_em->getConfiguration()->getQueryCache();
  250.         // Check query cache.
  251.         if (! ($this->useQueryCache && $queryCache)) {
  252.             $parser = new Parser($this);
  254.             $this->parserResult = $parser->parse();
  256.             return $this->parserResult;
  257.         }
  259.         $cacheItem = $queryCache->getItem($this->getQueryCacheId());
  261.         if (! $this->expireQueryCache && $cacheItem->isHit()) {
  262.             $cached = $cacheItem->get();
  263.             if ($cached instanceof ParserResult) {
  264.                 // Cache hit.
  265.                 $this->parserResult = $cached;
  267.                 return $this->parserResult;
  268.             }
  269.         }
  271.         // Cache miss.
  272.         $parser = new Parser($this);
  274.         $this->parserResult = $parser->parse();
  276.         $queryCache->save($cacheItem->set($this->parserResult)->expiresAfter($this->queryCacheTTL));
  278.         return $this->parserResult;
  279.     }
  281.     /**
  282.      * {@inheritdoc}
  283.      */
  284.     protected function _doExecute()
  285.     {
  286.         $executor = $this->parse()->getSqlExecutor();
  288.         if ($this->_queryCacheProfile) {
  289.             $executor->setQueryCacheProfile($this->_queryCacheProfile);
  290.         } else {
  291.             $executor->removeQueryCacheProfile();
  292.         }
  294.         if ($this->_resultSetMapping === null) {
  295.             $this->_resultSetMapping = $this->parserResult->getResultSetMapping();
  296.         }
  298.         // Prepare parameters
  299.         $paramMappings = $this->parserResult->getParameterMappings();
  300.         $paramCount    = count($this->parameters);
  301.         $mappingCount  = count($paramMappings);
  303.         if ($paramCount > $mappingCount) {
  304.             throw QueryException::tooManyParameters($mappingCount, $paramCount);
  305.         }
  307.         if ($paramCount < $mappingCount) {
  308.             throw QueryException::tooFewParameters($mappingCount, $paramCount);
  309.         }
  311.         // evict all cache for the entity region
  312.         if ($this->hasCache && isset($this->_hints[self::HINT_CACHE_EVICT]) && $this->_hints[self::HINT_CACHE_EVICT]) {
  313.             $this->evictEntityCacheRegion();
  314.         }
  316.         [$sqlParams, $types] = $this->processParameterMappings($paramMappings);
  318.         $this->evictResultSetCache(
  319.             $executor,
  320.             $sqlParams,
  321.             $types,
  322.             $this->_em->getConnection()->getParams()
  323.         );
  325.         return $executor->execute($this->_em->getConnection(), $sqlParams, $types);
  326.     }
  328.     /**
  329.      * @param array<string,mixed> $sqlParams
  330.      * @param array<string,Type>  $types
  331.      * @param array<string,mixed> $connectionParams
  332.      */
  333.     private function evictResultSetCache(
  334.         AbstractSqlExecutor $executor,
  335.         array $sqlParams,
  336.         array $types,
  337.         array $connectionParams
  338.     ): void {
  339.         if ($this->_queryCacheProfile === null || ! $this->getExpireResultCache()) {
  340.             return;
  341.         }
  343.         $cache = method_exists(QueryCacheProfile::class, 'getResultCache')
  344.             ? $this->_queryCacheProfile->getResultCache()
  345.             : $this->_queryCacheProfile->getResultCacheDriver();
  347.         assert($cache !== null);
  349.         $statements = (array) $executor->getSqlStatements(); // Type casted since it can either be a string or an array
  351.         foreach ($statements as $statement) {
  352.             $cacheKeys = $this->_queryCacheProfile->generateCacheKeys($statement, $sqlParams, $types, $connectionParams);
  354.             $cache instanceof CacheItemPoolInterface
  355.                 ? $cache->deleteItem(reset($cacheKeys))
  356.                 : $cache->delete(reset($cacheKeys));
  357.         }
  358.     }
  360.     /**
  361.      * Evict entity cache region
  362.      */
  363.     private function evictEntityCacheRegion(): void
  364.     {
  365.         $AST = $this->getAST();
  367.         if ($AST instanceof SelectStatement) {
  368.             throw new QueryException('The hint "HINT_CACHE_EVICT" is not valid for select statements.');
  369.         }
  371.         $className = $AST instanceof DeleteStatement
  372.             ? $AST->deleteClause->abstractSchemaName
  373.             : $AST->updateClause->abstractSchemaName;
  375.         $this->_em->getCache()->evictEntityRegion($className);
  376.     }
  378.     /**
  379.      * Processes query parameter mappings.
  380.      *
  381.      * @param array<list<int>> $paramMappings
  382.      *
  383.      * @return mixed[][]
  384.      * @psalm-return array{0: list<mixed>, 1: array}
  385.      *
  386.      * @throws Query\QueryException
  387.      */
  388.     private function processParameterMappings(array $paramMappings): array
  389.     {
  390.         $sqlParams = [];
  391.         $types     = [];
  393.         foreach ($this->parameters as $parameter) {
  394.             $key = $parameter->getName();
  396.             if (! isset($paramMappings[$key])) {
  397.                 throw QueryException::unknownParameter($key);
  398.             }
  400.             [$value, $type] = $this->resolveParameterValue($parameter);
  402.             foreach ($paramMappings[$key] as $position) {
  403.                 $types[$position] = $type;
  404.             }
  406.             $sqlPositions = $paramMappings[$key];
  408.             // optimized multi value sql positions away for now,
  409.             // they are not allowed in DQL anyways.
  410.             $value      = [$value];
  411.             $countValue = count($value);
  413.             for ($i = 0, $l = count($sqlPositions); $i < $l; $i++) {
  414.                 $sqlParams[$sqlPositions[$i]] = $value[$i % $countValue];
  415.             }
  416.         }
  418.         if (count($sqlParams) !== count($types)) {
  419.             throw QueryException::parameterTypeMismatch();
  420.         }
  422.         if ($sqlParams) {
  423.             ksort($sqlParams);
  424.             $sqlParams = array_values($sqlParams);
  426.             ksort($types);
  427.             $types = array_values($types);
  428.         }
  430.         return [$sqlParams, $types];
  431.     }
  433.     /**
  434.      * @return mixed[] tuple of (value, type)
  435.      * @psalm-return array{0: mixed, 1: mixed}
  436.      */
  437.     private function resolveParameterValue(Parameter $parameter): array
  438.     {
  439.         if ($parameter->typeWasSpecified()) {
  440.             return [$parameter->getValue(), $parameter->getType()];
  441.         }
  443.         $key           = $parameter->getName();
  444.         $originalValue = $parameter->getValue();
  445.         $value         = $originalValue;
  446.         $rsm           = $this->getResultSetMapping();
  448.         if ($value instanceof ClassMetadata && isset($rsm->metadataParameterMapping[$key])) {
  449.             $value = $value->getMetadataValue($rsm->metadataParameterMapping[$key]);
  450.         }
  452.         if ($value instanceof ClassMetadata && isset($rsm->discriminatorParameters[$key])) {
  453.             $value = array_keys(HierarchyDiscriminatorResolver::resolveDiscriminatorsForClass($value, $this->_em));
  454.         }
  456.         $processedValue = $this->processParameterValue($value);
  458.         return [
  459.             $processedValue,
  460.             $originalValue === $processedValue
  461.                 ? $parameter->getType()
  462.                 : ParameterTypeInferer::inferType($processedValue),
  463.         ];
  464.     }
  466.     /**
  467.      * Defines a cache driver to be used for caching queries.
  468.      *
  469.      * @deprecated Call {@see setQueryCache()} instead.
  470.      *
  471.      * @param Cache|null $queryCache Cache driver.
  472.      *
  473.      * @return $this
  474.      */
  475.     public function setQueryCacheDriver($queryCache): self
  476.     {
  477.         Deprecation::trigger(
  478.             'doctrine/orm',
  479.             'https://github.com/doctrine/orm/pull/9004',
  480.             '%s is deprecated and will be removed in Doctrine 3.0. Use setQueryCache() instead.',
  481.             __METHOD__
  482.         );
  484.         $this->queryCache = $queryCache ? CacheAdapter::wrap($queryCache) : null;
  486.         return $this;
  487.     }
  489.     /**
  490.      * Defines a cache driver to be used for caching queries.
  491.      *
  492.      * @return $this
  493.      */
  494.     public function setQueryCache(?CacheItemPoolInterface $queryCache): self
  495.     {
  496.         $this->queryCache = $queryCache;
  498.         return $this;
  499.     }
  501.     /**
  502.      * Defines whether the query should make use of a query cache, if available.
  503.      *
  504.      * @param bool $bool
  505.      *
  506.      * @return $this
  507.      */
  508.     public function useQueryCache($bool): self
  509.     {
  510.         $this->useQueryCache = $bool;
  512.         return $this;
  513.     }
  515.     /**
  516.      * Returns the cache driver used for query caching.
  517.      *
  518.      * @deprecated
  519.      *
  520.      * @return Cache|null The cache driver used for query caching or NULL, if
  521.      * this Query does not use query caching.
  522.      */
  523.     public function getQueryCacheDriver(): ?Cache
  524.     {
  525.         Deprecation::trigger(
  526.             'doctrine/orm',
  527.             'https://github.com/doctrine/orm/pull/9004',
  528.             '%s is deprecated and will be removed in Doctrine 3.0 without replacement.',
  529.             __METHOD__
  530.         );
  532.         $queryCache = $this->queryCache ?? $this->_em->getConfiguration()->getQueryCache();
  534.         return $queryCache ? DoctrineProvider::wrap($queryCache) : null;
  535.     }
  537.     /**
  538.      * Defines how long the query cache will be active before expire.
  539.      *
  540.      * @param int|null $timeToLive How long the cache entry is valid.
  541.      *
  542.      * @return $this
  543.      */
  544.     public function setQueryCacheLifetime($timeToLive): self
  545.     {
  546.         if ($timeToLive !== null) {
  547.             $timeToLive = (int) $timeToLive;
  548.         }
  550.         $this->queryCacheTTL = $timeToLive;
  552.         return $this;
  553.     }
  555.     /**
  556.      * Retrieves the lifetime of resultset cache.
  557.      */
  558.     public function getQueryCacheLifetime(): ?int
  559.     {
  560.         return $this->queryCacheTTL;
  561.     }
  563.     /**
  564.      * Defines if the query cache is active or not.
  565.      *
  566.      * @param bool $expire Whether or not to force query cache expiration.
  567.      *
  568.      * @return $this
  569.      */
  570.     public function expireQueryCache($expire = true): self
  571.     {
  572.         $this->expireQueryCache = $expire;
  574.         return $this;
  575.     }
  577.     /**
  578.      * Retrieves if the query cache is active or not.
  579.      */
  580.     public function getExpireQueryCache(): bool
  581.     {
  582.         return $this->expireQueryCache;
  583.     }
  585.     public function free(): void
  586.     {
  587.         parent::free();
  589.         $this->dql    = null;
  590.         $this->_state = self::STATE_CLEAN;
  591.     }
  593.     /**
  594.      * Sets a DQL query string.
  595.      *
  596.      * @param string|null $dqlQuery DQL Query.
  597.      */
  598.     public function setDQL($dqlQuery): self
  599.     {
  600.         if ($dqlQuery === null) {
  601.             Deprecation::trigger(
  602.                 'doctrine/orm',
  603.                 'https://github.com/doctrine/orm/pull/9784',
  604.                 'Calling %s with null is deprecated and will result in a TypeError in Doctrine 3.0',
  605.                 __METHOD__
  606.             );
  608.             return $this;
  609.         }
  611.         $this->dql    = $dqlQuery;
  612.         $this->_state = self::STATE_DIRTY;
  614.         return $this;
  615.     }
  617.     /**
  618.      * Returns the DQL query that is represented by this query object.
  619.      */
  620.     public function getDQL(): ?string
  621.     {
  622.         return $this->dql;
  623.     }
  625.     /**
  626.      * Returns the state of this query object
  627.      * By default the type is Doctrine_ORM_Query_Abstract::STATE_CLEAN but if it appears any unprocessed DQL
  628.      * part, it is switched to Doctrine_ORM_Query_Abstract::STATE_DIRTY.
  629.      *
  630.      * @see AbstractQuery::STATE_CLEAN
  631.      * @see AbstractQuery::STATE_DIRTY
  632.      *
  633.      * @return int The query state.
  634.      * @psalm-return self::STATE_* The query state.
  635.      */
  636.     public function getState(): int
  637.     {
  638.         return $this->_state;
  639.     }
  641.     /**
  642.      * Method to check if an arbitrary piece of DQL exists
  643.      *
  644.      * @param string $dql Arbitrary piece of DQL to check for.
  645.      */
  646.     public function contains($dql): bool
  647.     {
  648.         return stripos($this->getDQL(), $dql) !== false;
  649.     }
  651.     /**
  652.      * Sets the position of the first result to retrieve (the "offset").
  653.      *
  654.      * @param int|null $firstResult The first result to return.
  655.      *
  656.      * @return $this
  657.      */
  658.     public function setFirstResult($firstResult): self
  659.     {
  660.         if (! is_int($firstResult)) {
  661.             Deprecation::trigger(
  662.                 'doctrine/orm',
  663.                 'https://github.com/doctrine/orm/pull/9809',
  664.                 'Calling %s with %s is deprecated and will result in a TypeError in Doctrine 3.0. Pass an integer.',
  665.                 __METHOD__,
  666.                 get_debug_type($firstResult)
  667.             );
  669.             $firstResult = (int) $firstResult;
  670.         }
  672.         $this->firstResult = $firstResult;
  673.         $this->_state      = self::STATE_DIRTY;
  675.         return $this;
  676.     }
  678.     /**
  679.      * Gets the position of the first result the query object was set to retrieve (the "offset").
  680.      * Returns NULL if {@link setFirstResult} was not applied to this query.
  681.      *
  682.      * @return int|null The position of the first result.
  683.      */
  684.     public function getFirstResult(): ?int
  685.     {
  686.         return $this->firstResult;
  687.     }
  689.     /**
  690.      * Sets the maximum number of results to retrieve (the "limit").
  691.      *
  692.      * @param int|null $maxResults
  693.      *
  694.      * @return $this
  695.      */
  696.     public function setMaxResults($maxResults): self
  697.     {
  698.         if ($maxResults !== null) {
  699.             $maxResults = (int) $maxResults;
  700.         }
  702.         $this->maxResults = $maxResults;
  703.         $this->_state     = self::STATE_DIRTY;
  705.         return $this;
  706.     }
  708.     /**
  709.      * Gets the maximum number of results the query object was set to retrieve (the "limit").
  710.      * Returns NULL if {@link setMaxResults} was not applied to this query.
  711.      *
  712.      * @return int|null Maximum number of results.
  713.      */
  714.     public function getMaxResults(): ?int
  715.     {
  716.         return $this->maxResults;
  717.     }
  719.     /**
  720.      * Executes the query and returns an IterableResult that can be used to incrementally
  721.      * iterated over the result.
  722.      *
  723.      * @deprecated
  724.      *
  725.      * @param ArrayCollection|mixed[]|null $parameters    The query parameters.
  726.      * @param string|int                   $hydrationMode The hydration mode to use.
  727.      * @psalm-param ArrayCollection<int, Parameter>|array<string, mixed>|null $parameters
  728.      * @psalm-param string|AbstractQuery::HYDRATE_*|null                      $hydrationMode
  729.      */
  730.     public function iterate($parameters = null, $hydrationMode = self::HYDRATE_OBJECT): IterableResult
  731.     {
  732.         $this->setHint(self::HINT_INTERNAL_ITERATION, true);
  734.         return parent::iterate($parameters, $hydrationMode);
  735.     }
  737.     /** {@inheritDoc} */
  738.     public function toIterable(iterable $parameters = [], $hydrationMode = self::HYDRATE_OBJECT): iterable
  739.     {
  740.         $this->setHint(self::HINT_INTERNAL_ITERATION, true);
  742.         return parent::toIterable($parameters, $hydrationMode);
  743.     }
  745.     /**
  746.      * {@inheritdoc}
  747.      */
  748.     public function setHint($name, $value): self
  749.     {
  750.         $this->_state = self::STATE_DIRTY;
  752.         return parent::setHint($name, $value);
  753.     }
  755.     /**
  756.      * {@inheritdoc}
  757.      */
  758.     public function setHydrationMode($hydrationMode): self
  759.     {
  760.         $this->_state = self::STATE_DIRTY;
  762.         return parent::setHydrationMode($hydrationMode);
  763.     }
  765.     /**
  766.      * Set the lock mode for this Query.
  767.      *
  768.      * @see \Doctrine\DBAL\LockMode
  769.      *
  770.      * @param int $lockMode
  771.      * @psalm-param LockMode::* $lockMode
  772.      *
  773.      * @return $this
  774.      *
  775.      * @throws TransactionRequiredException
  776.      */
  777.     public function setLockMode($lockMode): self
  778.     {
  779.         if (in_array($lockMode, [LockMode::NONE, LockMode::PESSIMISTIC_READ, LockMode::PESSIMISTIC_WRITE], true)) {
  780.             if (! $this->_em->getConnection()->isTransactionActive()) {
  781.                 throw TransactionRequiredException::transactionRequired();
  782.             }
  783.         }
  785.         $this->setHint(self::HINT_LOCK_MODE, $lockMode);
  787.         return $this;
  788.     }
  790.     /**
  791.      * Get the current lock mode for this query.
  792.      *
  793.      * @return int|null The current lock mode of this query or NULL if no specific lock mode is set.
  794.      */
  795.     public function getLockMode(): ?int
  796.     {
  797.         $lockMode = $this->getHint(self::HINT_LOCK_MODE);
  799.         if ($lockMode === false) {
  800.             return null;
  801.         }
  803.         return $lockMode;
  804.     }
  806.     /**
  807.      * Generate a cache id for the query cache - reusing the Result-Cache-Id generator.
  808.      */
  809.     protected function getQueryCacheId(): string
  810.     {
  811.         ksort($this->_hints);
  813.         return md5(
  814.             $this->getDQL() . serialize($this->_hints) .
  815.             '&platform=' . get_debug_type($this->getEntityManager()->getConnection()->getDatabasePlatform()) .
  816.             ($this->_em->hasFilters() ? $this->_em->getFilters()->getHash() : '') .
  817.             '&firstResult=' . $this->firstResult . '&maxResult=' . $this->maxResults .
  818.             '&hydrationMode=' . $this->_hydrationMode . '&types=' . serialize($this->parsedTypes) . 'DOCTRINE_QUERY_CACHE_SALT'
  819.         );
  820.     }
  822.     protected function getHash(): string
  823.     {
  824.         return sha1(parent::getHash() . '-' . $this->firstResult . '-' . $this->maxResults);
  825.     }
  827.     /**
  828.      * Cleanup Query resource when clone is called.
  829.      */
  830.     public function __clone()
  831.     {
  832.         parent::__clone();
  834.         $this->_state = self::STATE_DIRTY;
  835.     }
  836. }