src/Repository/BaseRepository.php line 558

Open in your IDE?
  1. <?php
  3. namespace App\Repository;
  5. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  6. use Doctrine\ORM\QueryBuilder;
  7. use Doctrine\ORM\Tools\Pagination\Paginator;
  8. use Doctrine\Persistence\ManagerRegistry;
  10. use Symfony\Component\HttpFoundation\Request;
  11. use Symfony\Component\DependencyInjection\ContainerInterface;
  12. use Symfony\Contracts\Cache\CacheInterface;
  14. use App\Misc\CustomEntityManager;
  15. use App\Service\CommonService;
  16. use AutoMapperPlus\AutoMapperInterface;
  17. use Gedmo\Translatable\Query\TreeWalker\TranslationWalker;
  19. /**
  20.  * @property AutoMapperInterface autoMapper
  21.  */
  22. class BaseRepository extends ServiceEntityRepository
  23. {
  24.     public function __construct(
  25.         ManagerRegistry $registry,
  26.         CustomEntityManager $customEntityManager,
  27.         CommonService $commonService,
  28.         CacheInterface $appCache,
  29.         AutoMapperInterface $autoMapper,
  30.         ContainerInterface $container
  31.     ) {
  32.         $this->commonService = $commonService;
  33.         $thisName = $this->commonService->getClassName($this, true);
  34.         if ($thisName !== 'Base') {
  35.             parent::__construct($registry, 'App\Entity\\' . $thisName);
  36.         }
  37.         $this->_em = $customEntityManager;
  38.         $this->autoMapper = $autoMapper;
  39.         $this->container = $container;
  40.         $this->cache = $appCache;
  41.     }
  43.     public function getEntityManager()
  44.     {
  45.         return $this->_em;
  46.     }
  48.     public function save($entity, $inTransaction = false)
  49.     {
  50.         $this->getEntityManager()->persist($entity);
  51.         if (!$inTransaction) {
  52.             $this->getEntityManager()->flush();
  53.         }
  54.         return $entity;
  55.     }
  57.     public function persist($entity)
  58.     {
  59.         $this->getEntityManager()->persist($entity);
  60.     }
  62.     public function flush()
  63.     {
  64.         $this->getEntityManager()->flush();
  65.     }
  67.     public function clear()
  68.     {
  69.         $this->getEntityManager()->clear();
  70.     }
  72.     public function delete($entities, $inTransaction = false)
  73.     {
  74.         if (!is_array($entities)) {
  75.             $entities = [$entities];
  76.         }
  77.         foreach ($entities as $entity) {
  78.             $this->getEntityManager()->remove($entity);
  79.         }
  80.         if (!$inTransaction) {
  81.             $this->getEntityManager()->flush();
  82.         }
  83.     }
  85.     /**
  86.      * @return \Doctrine\DBAL\Connection
  87.      */
  88.     public function getConnection()
  89.     {
  90.         return $this->getEntityManager()->getConnection();
  91.     }
  93.     public function __get($propertyName)
  94.     {
  95.         if($propertyName == '_entityName') {
  96.             return parent::__get('_entityName');
  97.         }
  98.         preg_match('/([a-zA-Z0-9]+)Service/i', $propertyName, $serviceMatches);
  99.         if (count($serviceMatches) > 0) {
  100.             return $this
  101.                 ->container
  102.                 ->get('App\Service\\' . ucfirst($serviceMatches[1]) . 'Service');
  103.         }
  105.         preg_match('/([a-zA-Z0-9]+)Repo/i', $propertyName, $repositoryMatches);
  106.         if (count($repositoryMatches) > 0) {
  107.             return $this
  108.                 ->container
  109.                 ->get('App\Service\\' . ucfirst($repositoryMatches[1]) . 'Service')
  110.                 ->repository;
  111.         }
  113.         $entityName = $this->commonService->getClassName($this, true);
  114.         $cacheKey = 'Const.' . $entityName . '.' . $propertyName;
  115.         $cachedConstantItem = $this->cache->getItem($cacheKey);
  117.         if ($cachedConstantItem->isHit()) {
  118.             return $cachedConstantItem->get();
  119.         }
  120.         if($propertyName !== '_entityName') {
  121.             $constant = null;
  122.             if(defined('App\Entity\\' . $entityName . '::' . $propertyName)) {
  123.                 $constant = constant('App\Entity\\' . $entityName . '::' . $propertyName);
  124.             }
  125.             if (!is_null($constant)) {
  126.                 $cachedConstantItem->set($constant);
  127.                 $this->cache->save($cachedConstantItem);
  128.                 return $constant;
  129.             }
  130.         }
  131.         
  133.         $metas = $this->_em->getMetadataFactory()->getAllMetadata();
  134.         foreach ($metas as $meta) {
  135.             $classPath = $meta->getName();
  136.             $name = strtoupper($this->commonService->toSnakeCase(str_replace('App\Entity\\', '', $classPath)));
  137.             preg_match('/(' . $name . ')_(.+)/i', $propertyName, $matches);
  138.             if (count($matches) > 0) {
  139.                 $prop = $matches[2];
  140.                 if(defined($classPath . '::' . $prop)) {
  141.                     $constant = @constant($classPath . '::' . $prop);
  142.                 }
  143.                 if (!is_null($constant)) {
  144.                     $cachedConstantItem->set($constant);
  145.                     $this->cache->save($cachedConstantItem);
  146.                     return $constant;
  147.                 }
  148.             }
  149.         }
  151.         trigger_error('Could not found property ' . $propertyName . ' in ' . $this->commonService->getClassName($this), E_USER_ERROR);
  152.     }
  154.     public function getPagingData($queryBuilder, $paging = null, $DTO = null, $fetchJoinCollection)
  155.     {
  156.         if (is_null($paging)) {
  157.             $paging = [
  158.                 'page' => 1,
  159.                 'limit' => 50
  160.             ];
  161.         }
  162.         if (!isset($paging['page'])) {
  163.             $paging['page'] = 1;
  164.         }
  165.         if (!isset($paging['limit'])) {
  166.             $paging['limit'] = 50;
  167.         } else if (((int)$paging['limit']) <= 0) {
  168.             $paging['limit'] = pow(10, 12);
  169.         }
  170.         $queryBuilder
  171.             ->setFirstResult(($paging['page'] - 1) * $paging['limit'])
  172.             ->setMaxResults($paging['limit']);
  174.         $paginator = new Paginator($queryBuilder, $fetchJoinCollection);
  176.         $paginatorQuery = $paginator->getQuery();
  178.         $this->addTranslationWalkerToQuery($paginatorQuery);
  180.         $total = count($paginator);
  181.         $list = [];
  182.         foreach ($paginator as $entity) {
  183.             if (is_null($DTO)) {
  184.                 $outputDTO = 'App\DTO\\' . $this->getEntityName() . '\\' . $this->getEntityName() . 'Output';
  185.                 if (class_exists($outputDTO)) {
  186.                     $DTO = $outputDTO;
  187.                 }
  188.             }
  189.             if (is_null($DTO) || $DTO === 'ENTITY') {
  190.                 $list[] = $entity;
  191.             } else {
  192.                 $array = (array)$this->autoMapper->map($entity, $DTO);
  193.                 foreach ($array as $key => $value) {
  194.                     if (is_string($value)) {
  195.                         $array[$key] = mb_convert_encoding($value, "UTF-8");
  196.                     }
  197.                 }
  198.                 $list[] = $array;
  199.             }
  200.         }
  201.         return [
  202.             'total' => $total,
  203.             'totalPages' => ceil($total / $paging['limit']),
  204.             'list' => $list,
  205.             'currentPage' => 1 * $paging['page']
  206.         ];
  207.     }
  209.     public function setFilter(QueryBuilder $queryBuilder, $requestData)
  210.     {
  211.         foreach ($requestData as $key => $value) {
  212.             if ($value === '') {
  213.                 continue;
  214.             }
  215.             if (strpos($key, 'filter_') === 0) {
  216.                 $filter = str_replace('filter_', '', $key);
  217.                 if (strpos($filter, '_like') !== false) {
  218.                     $filter = str_replace('_like', '', $filter);
  219.                     if ($filter === 'namefull') {
  220.                         $queryBuilder
  221.                             ->andWhere(
  222.                                 $queryBuilder
  223.                                     ->expr()
  224.                                     ->orX(
  225.                                         $queryBuilder
  226.                                             ->expr()
  227.                                             ->like($this->getEntityName() . '.firstName', ':firstName'),
  228.                                         $queryBuilder
  229.                                             ->expr()
  230.                                             ->like($this->getEntityName() . '.lastName', ':lastName')
  231.                                     )
  232.                             )
  233.                             ->setParameter(':firstName', $value)
  234.                             ->setParameter(':lastName', $value);
  235.                     } else {
  236.                         // or like
  237.                         if (strpos($filter, '_or_') !== -1) {
  238.                             $orx = $queryBuilder->expr()->orX();
  239.                             foreach (explode('_or_', $filter) as $orFilter) {
  240.                                 $orx->add(
  241.                                     $queryBuilder
  242.                                         ->expr()
  243.                                         ->like($this->getEntityName() . '.' . $orFilter, ':' . $orFilter)
  244.                                 );
  245.                                 $queryBuilder->setParameter($orFilter, '%' . $value . '%');
  246.                             }
  247.                             $queryBuilder->andWhere($orx);
  248.                         } else {
  249.                             $fieldName = $this->getEntityName() . '.' . $filter;
  250.                             $queryBuilder->andWhere(
  251.                                 $queryBuilder
  252.                                     ->expr()
  253.                                     ->like($fieldName, ':' . $filter)
  254.                             );
  255.                             $queryBuilder->setParameter($filter, '%' . $value . '%');
  256.                         }
  257.                     }
  258.                 } else {
  259.                     $fieldName = $this->getEntityName() . '.' . $filter;
  260.                     if (is_array($value)) {
  261.                         $queryBuilder
  262.                             ->andWhere(
  263.                                 $queryBuilder
  264.                                     ->expr()
  265.                                     ->in($fieldName, ':in' . $filter)
  266.                             )
  267.                             ->setParameter(
  268.                                 'in' . $filter,
  269.                                 $value,
  270.                                 \Doctrine\DBAL\Connection::PARAM_INT_ARRAY
  271.                             );
  272.                     } else if ($value === 'falseOrNull') {
  273.                         $queryBuilder->andWhere($fieldName . ' = 0 or ' . $fieldName . ' is NULL');
  274.                     } else if ($value === 'isNull') {
  275.                         $queryBuilder->andWhere($fieldName . ' is NULL');
  276.                     } else if ($value === 'true' || $value === 'false') {
  277.                         $queryBuilder->andWhere(
  278.                             $queryBuilder->expr()->eq($fieldName, ':' . $filter)
  279.                         );
  280.                         $queryBuilder->setParameter($filter, $value === 'true');
  281.                     } else if ($value === 'notNull') {
  282.                         $queryBuilder->andWhere(
  283.                             $queryBuilder->expr()->isNotNull($fieldName)
  284.                         );
  285.                     } else {
  286.                         $queryBuilder->andWhere(
  287.                             $queryBuilder->expr()->eq($fieldName, ':' . $filter)
  288.                         );
  289.                         $queryBuilder->setParameter($filter, $value);
  290.                     }
  291.                 }
  292.             } else if (strpos($key, 'except_') === 0) {
  293.                 $except = str_replace('except_', '', $key);
  294.                 $isInt = is_int(explode(',', $value)[0]);
  295.                 if ($isInt) {
  296.                     $value = array_map('intval', explode(',', $value));
  297.                 } else {
  298.                     $value = array_map('strval', explode(',', $value));
  299.                 }
  300.                 $fieldName = $this->getEntityName() . '.' . $except;
  302.                 $queryBuilder
  303.                     ->andWhere(
  304.                         $queryBuilder
  305.                             ->expr()
  306.                             ->orX(
  307.                                 $queryBuilder->expr()->isNull($fieldName),
  308.                                 $queryBuilder
  309.                                     ->expr()
  310.                                     ->notIn($fieldName, ':notIn' . $except)
  311.                             )
  312.                     )
  313.                     ->setParameter(
  314.                         'notIn' . $except,
  315.                         $value,
  316.                         $isInt
  317.                             ? \Doctrine\DBAL\Connection::PARAM_INT_ARRAY
  318.                             : \Doctrine\DBAL\Connection::PARAM_STR_ARRAY
  319.                     );
  320.             } else if (strpos($key, 'has_') === 0) {
  321.                 $paramName = 'p' . bin2hex(random_bytes(5));
  322.                 $has = str_replace('has_', '', $key);
  323.                 $relationName = explode('_', $has)[0];
  324.                 $relationProperty = explode('_', $has)[1];
  325.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  326.                 $queryBuilder
  327.                     ->leftJoin($fieldName, $paramName)
  328.                     ->andWhere($paramName . '.' . $relationProperty . ' = :' . $paramName)
  329.                     ->setParameter($paramName, $value);
  330.             } else if (strpos($key, 'hasAny_') === 0) {
  331.                 $paramName = 'p' . bin2hex(random_bytes(5));
  332.                 $has = str_replace('hasAny_', '', $key);
  333.                 $relationName = explode('_', $has)[0];
  334.                 $relationProperty = explode('_', $has)[1];
  335.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  336.                 $queryBuilder
  337.                     ->leftJoin($fieldName, $paramName)
  338.                     ->andWhere($paramName . '.' . $relationProperty . ' = :' . $paramName)
  339.                     ->setParameter($paramName, $value);
  340.             } else if (strpos($key, 'hasAny2_') === 0) {
  341.                 $paramName = 'p' . bin2hex(random_bytes(5));
  342.                 $has = str_replace('hasAny2_', '', $key);
  343.                 $relationName = explode('_', $has)[0];
  344.                 $relationProperty = explode('_', $has)[1];
  345.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  346.                 $queryBuilder
  347.                     ->leftJoin($fieldName, $paramName)
  348.                     ->andWhere(':' . $paramName . ' member of ' . $paramName . '.' . $relationProperty)
  349.                     ->setParameter($paramName, $value);
  350.             } else if (strpos($key, 'memberOf_') === 0) {
  351.                 $relationName = str_replace('memberOf_', '', $key);
  352.                 $paramName = 'p66' . $relationName;
  353.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  354.                 if ($value === 'isNull') {
  355.                     $queryBuilder->andWhere($fieldName . ' is empty');
  356.                 }elseif ($value === 'notNull') {
  357.                     $queryBuilder
  358.                         ->leftJoin($fieldName, $paramName);
  359.                     $queryBuilder->andWhere($queryBuilder->expr()->isNotNull($paramName));
  360.                 } else {
  361.                     $queryBuilder
  362.                         ->leftJoin($fieldName, $paramName)
  363.                         ->andWhere(':' . $paramName . ' member of ' . $fieldName)
  364.                         ->setParameter($paramName, $value);
  365.                 }
  366.             } else if (strpos($key, 'hasLike_') === 0) {
  367.                 $paramName = 'p' . bin2hex(random_bytes(5));
  368.                 $has = str_replace('hasLike_', '', $key);
  369.                 $relationName = explode('_', $has)[0];
  370.                 $relationProperty = explode('_', $has)[1];
  371.                 $fieldName = $this->getEntityName() . '.' . $relationName;
  372.                 $queryBuilder
  373.                     ->leftJoin($fieldName, $paramName)
  374.                     ->andWhere($paramName . '.' . $relationProperty . ' LIKE :' . $paramName)
  375.                     ->setParameter($paramName, '%' . $value . '%');
  376.             }
  377.         }
  378.     }
  380.     public function setSort(QueryBuilder $queryBuilder, $requestData)
  381.     {
  382.         foreach ($requestData as $key => $value) {
  383.             if (strpos($key, 'sort_') === false) {
  384.                 continue;
  385.             }
  387.             $direction = strpos($key, '_asc') !== false ? 'ASC' : 'DESC';
  388.             $value = str_replace('Text', '', $value);
  389.             $isRelation = strpos($value, 'Relation') !== false;
  390.             if ($isRelation) {
  391.                 $value = str_replace('Relation', '', $value);
  392.                 @list($rel1, $rel2, $rel3) = explode('.', $value);
  393.                 if (empty($rel3)) {
  394.                     $rel1Table = $this->getEntityName() . '.' . $rel1;
  395.                     $queryBuilder->leftJoin($rel1Table, $rel1);
  396.                     $queryBuilder->addOrderBy($value, $direction);
  397.                 } else {
  398.                     $rel1Table = $this->getEntityName() . '.' . $rel1;
  399.                     $queryBuilder->leftJoin($rel1Table, $rel1);
  400.                     $rel2Table = $rel1 . '.' . $rel2;
  401.                     $queryBuilder->leftJoin($rel2Table, $rel2);
  402.                     $queryBuilder->addOrderBy($rel2 . '.' . $rel3, $direction);
  403.                 }
  404.             } else {
  405.                 $fieldName = $this->getEntityName() . '.' . $value;
  406.                 $queryBuilder->addOrderBy($fieldName, $direction);
  407.             }
  408.         }
  409.     }
  411.     public function getList($requestData, $DTO = null, callable $extraFilter = null, $fetchJoinCollection = true)
  412.     {
  413.         if ($requestData instanceof Request) {
  414.             $requestData = $requestData->query->all();
  415.         }
  416.         $queryBuilder = $this->createQueryBuilder($this->getEntityName());
  417.         if (!is_null($extraFilter)) {
  418.             $extraFilter($queryBuilder);
  419.         }
  420.         $this->setFilter($queryBuilder, $requestData);
  421.         $this->setSort($queryBuilder, $requestData);
  422.         return $this->getPagingData($queryBuilder, $requestData, $DTO, $fetchJoinCollection);
  423.     }
  425.     public function getAll($requestData, $DTO = null, callable $extraFilter = null, $returnQuery = false)
  426.     {
  427.         if ($requestData instanceof Request) {
  428.             $requestData = $requestData->query->all();
  429.         }
  430.         $queryBuilder = $this->createQueryBuilder($this->getEntityName());
  431.         if (!is_null($extraFilter)) {
  432.             $extraFilter($queryBuilder);
  433.         }
  434.         $this->setFilter($queryBuilder, $requestData);
  435.         $this->setSort($queryBuilder, $requestData);
  436.         if ($returnQuery) {
  437.             return $queryBuilder->getQuery();
  438.         }
  439.         $entities = $queryBuilder->getQuery()->execute();
  441.         $list = [];
  442.         foreach ($entities as $entity) {
  443.             if (is_null($DTO)) {
  444.                 $outputDTO = 'App\DTO\\' . $this->getEntityName() . '\\' . $this->getEntityName() . 'Output';
  445.                 if (class_exists($outputDTO)) {
  446.                     $DTO = $outputDTO;
  447.                 }
  448.             }
  449.             if (is_null($DTO) || $DTO === 'ENTITY') {
  450.                 $list[] = $entity;
  451.             } else {
  452.                 $array = (array)$this->autoMapper->map($entity, $DTO);
  453.                 foreach ($array as $key => $value) {
  454.                     if (is_string($value)) {
  455.                         $array[$key] = mb_convert_encoding($value, "UTF-8");
  456.                     }
  457.                 }
  458.                 $list[] = $array;
  459.             }
  460.         }
  462.         return $list;
  463.     }
  465.     public function getDistinctAttributeOfList($requestData, $DTO = null, callable $extraFilter = null)
  466.     {
  467.         $entityName = $this->getEntityName();
  468.         if ($requestData instanceof Request) {
  469.             $requestData = $requestData->query->all();
  470.         }
  471.         if (isset($requestData['distinct_attribute'])) {
  472.             $attributeType = 'attribute';
  473.         } else if (isset($requestData['distinct_relation'])) {
  474.             $attributeType = 'relation';
  475.         } else return [];
  477.         $queryBuilder = $this->createQueryBuilder($entityName);
  478.         if (!is_null($extraFilter)) {
  479.             $extraFilter($queryBuilder);
  480.         }
  481.         $this->setFilter($queryBuilder, $requestData);
  482.         $this->setSort($queryBuilder, $requestData);
  484.         if ($attributeType == 'attribute') {
  485.             $queryBuilder
  486.                 ->select($entityName . '.' . $requestData['distinct_attribute'])
  487.                 ->groupBy($entityName . '.' . $requestData['distinct_attribute']);
  488.         } else if ($attributeType == 'relation') {
  489.             $queryBuilder
  490.                 ->join($entityName . '.' . $requestData['distinct_relation'], $requestData['distinct_relation'])
  491.                 ->addSelect($requestData['distinct_relation'])
  492.                 ->addSelect('COUNT(' . $entityName . ') as count')
  493.                 ->groupBy($requestData['distinct_relation']);
  494.         }
  495.         $result = $queryBuilder->getQuery()->getResult();
  496.         $attributeList = [];
  497.         foreach ($result as $entity) {
  498.             $attributeName = $requestData[$attributeType == 'attribute' ? 'distinct_attribute' : 'distinct_relation'];
  499.             $attribute = $entity[0]->{'get' . $attributeName}();
  500.             if ($attributeType == 'attribute') {
  501.                 $attributeList[] = [
  502.                     'value' => $attribute,
  503.                     'count' => (int)$entity['count'],
  504.                 ];
  505.             } else if ($attributeType == 'relation') {
  506.                 $array = !is_null($DTO)
  507.                     ? (array)$this->autoMapper->map($attribute, $DTO)
  508.                     : (array)$attribute;
  509.                 foreach ($array as $key => $value) {
  510.                     if (is_string($value)) {
  511.                         $array[$key] = mb_convert_encoding($value, "UTF-8");
  512.                     }
  513.                 }
  514.                 $array['count'] = (int)$entity['count'];
  515.                 $attributeList[] = $array;
  516.             }
  517.         }
  518.         return $attributeList;
  519.     }
  521.     public function entityToDtoArray($entity, $DTO = null)
  522.     {
  523.         $array = (array)$this->autoMapper->map($entity, $DTO);
  524.         foreach ($array as $key => $value) {
  525.             if (is_string($value)) {
  526.                 $array[$key] = mb_convert_encoding($value, "UTF-8");
  527.             }
  528.         }
  530.         return $array;
  531.     }
  533.     public function getEntityName()
  534.     {
  535.         return $this->commonService->getClassName($this, true);
  536.     }
  538.     public function checkExistSlug($entity, $value)
  539.     {
  540.         $id = $entity->getId();
  542.         $conn = $this->getEntityManager()->getConnection();
  543.         $stmt = $conn->executeQuery(
  544.             'select count(id) as id from news where id != :id and slug = :slug',
  545.             [
  546.                 'id' => $id,
  547.                 'slug' => $value
  548.             ]
  549.         );
  550.         $result = $stmt->fetchOne();
  551.         return (int) $result;
  552.     }
  554.     public function findOneBy(array $criteria, array $orderBy = null)
  555.     {
  556.         $qb = $this->createQueryBuilder('o');
  557.         foreach ($criteria as $criterion => $value) {
  558.             $qb
  559.                 ->andWhere('o.' . $criterion . ' = :' . $criterion)
  560.                 ->setParameter($criterion, $value);
  561.         }
  562.         $qb->setMaxResults(1);
  563.         $query = $qb->getQuery();
  565.         $this->addTranslationWalkerToQuery($query);
  567.         return $query->getOneOrNullResult();
  568.     }
  570.     public function addTranslationWalkerToQuery($query)
  571.     {
  572.         // News, Program
  573.         $translatableEntities = [];
  574.         if (!in_array($this->getEntityName(), $translatableEntities)) return;
  576.         $config = $this->_em->getConfiguration();
  577.         if ($config->getCustomHydrationMode(TranslationWalker::HYDRATE_OBJECT_TRANSLATION) === null) {
  578.             $config->addCustomHydrationMode(
  579.                 TranslationWalker::HYDRATE_OBJECT_TRANSLATION,
  580.                 'Gedmo\\Translatable\\Hydrator\\ORM\\ObjectHydrator'
  581.             );
  582.         }
  584.         $query->setHint(
  585.             \Doctrine\ORM\Query::HINT_CUSTOM_OUTPUT_WALKER,
  586.             'Gedmo\\Translatable\\Query\\TreeWalker\\TranslationWalker'
  587.         );
  588.         $query->setHint(
  589.             \Gedmo\Translatable\TranslatableListener::HINT_TRANSLATABLE_LOCALE,
  590.             $this->container->get('gedmo.listener.translatable')->getListenerLocale() // take locale from session or request etc.
  591.         );
  592.         $query->setHydrationMode(TranslationWalker::HYDRATE_OBJECT_TRANSLATION);
  593.         $query->setHint(\Doctrine\ORM\Query::HINT_REFRESH, true);
  594.     }
  595. }