public function testOrWhere() { $expr = new Comparison("field", "=", "value"); $criteria = new Criteria(); $criteria->where($expr); $expr = $criteria->getWhereExpression(); $criteria->orWhere($expr); $where = $criteria->getWhereExpression(); $this->assertInstanceOf('Doctrine\\Common\\Collections\\Expr\\CompositeExpression', $where); $this->assertEquals(CompositeExpression::TYPE_OR, $where->getType()); $this->assertSame(array($expr, $expr), $where->getExpressionList()); }
public function testWhere() { $expr = new Comparison("field", "=", "value"); $criteria = new Criteria(); $criteria->where($expr); $this->assertSame($expr, $criteria->getWhereExpression()); }
public function testMatchingAcceptsCriteriaWithNullWhereExpression() { $repository = $this->dm->getRepository('Documents\\User'); $criteria = new Criteria(); $this->assertNull($criteria->getWhereExpression()); $this->assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $repository->matching($criteria)); }
/** * Gets search result * * @param int $page Page number * @param int $limit Number of items per page * @param string $search The search string. * @param Criteria|null $criteria * * @return array */ public function getSearchResult($page = 1, $limit = 10, $search = '', $criteria = null) { $searchQuery = $this->searchIndexer->getSimpleSearchQuery($search, $this->getOffset($page, $limit), $limit, $this->getCustomerSearchAliases()); if ($criteria && ($expression = $criteria->getWhereExpression())) { $searchQuery->getCriteria()->andWhere($expression); } $searchResult = $this->searchIndexer->query($searchQuery); $result = ['result' => [], 'totalCount' => function () use($searchResult) { return $searchResult->getRecordsCount(); }]; if ($searchResult->count() > 0) { $customers = $this->getCustomerListQueryBuilder($searchResult)->getQuery()->getResult(); $result['result'] = $this->mergeResults($searchResult, $customers); } return $result; }
/** * @param QueryBuilder $qb * @param Criteria $criteria */ public static function addCriteria(QueryBuilder $qb, Criteria $criteria) { $rootAlias = $qb->getRootAlias(); $visitor = new QueryExpressionVisitor($rootAlias); if ($whereExpression = $criteria->getWhereExpression()) { $qb->andWhere($visitor->dispatch($whereExpression)); foreach ($visitor->getParameters() as $parameter) { $qb->getParameters()->add($parameter); } } if ($criteria->getOrderings()) { foreach ($criteria->getOrderings() as $sort => $order) { $qb->addOrderBy($rootAlias . '.' . $sort, $order); } } // Overwrite limits only if they was set in criteria if (($firstResult = $criteria->getFirstResult()) !== null) { $qb->setFirstResult($firstResult); } if (($maxResults = $criteria->getMaxResults()) !== null) { $qb->setMaxResults($maxResults); } }
/** * Add criteria to query. * Add where expressions with AND operator. * Add orderings. * Override firstResult and maxResults if they set. * * @param Criteria $criteria * @return QueryBuilder */ public function addCriteria(Criteria $criteria) { $visitor = new QueryExpressionVisitor(); if ($whereExpression = $criteria->getWhereExpression()) { $this->andWhere($visitor->dispatch($whereExpression)); foreach ($visitor->getParameters() as $parameter) { $this->parameters->add($parameter); } } if ($criteria->getOrderings()) { foreach ($criteria->getOrderings() as $sort => $order) { $this->addOrderBy($sort, $order); } } // Overwrite limits only if they was set in criteria if (($firstResult = $criteria->getFirstResult()) !== null) { $this->setFirstResult($firstResult); } if (($maxResults = $criteria->getMaxResults()) !== null) { $this->setMaxResults($maxResults); } return $this; }
/** * @todo handle more criteria, only where can be used * @param Criteria $criteria * @param ClassMetadata $classMetadata * @return array * @internal param int $limit */ public function findBy(Criteria $criteria, ClassMetadata $classMetadata) { $expression = $criteria->getWhereExpression()->visit(new QueryBuilder(), $classMetadata); $tokens = isset($expression['tokens']) ? $expression['tokens'] : []; $tokens = array_map(function ($item) use($classMetadata) { $type = $this->mapTypeField($classMetadata->getTypeOfField($item['field'])); $value = $item['value']; if ($type === 'N') { $value = (string) $value; } return [$type => $value]; }, $tokens); $request = ['TableName' => $this->getTableName($classMetadata), 'FilterExpression' => $expression['expression'], 'ExpressionAttributeValues' => $tokens]; $result = $this->commit('scan', $request); return array_map(function ($item) { return $this->strategy->extract($item); }, $result->get('Items')); }
/** * {@inheritDoc} */ public function matching(Criteria $criteria) { $expr = $criteria->getWhereExpression(); $filtered = $this->elements; if ($expr) { $visitor = new ClosureExpressionVisitor(); $filter = $visitor->dispatch($expr); $filtered = array_filter($filtered, $filter); } if ($orderings = $criteria->getOrderings()) { foreach (array_reverse($orderings) as $field => $ordering) { $next = ClosureExpressionVisitor::sortByField($field, $ordering == Criteria::DESC ? -1 : 1); } usort($filtered, $next); } $offset = $criteria->getFirstResult(); $length = $criteria->getMaxResults(); if ($offset || $length) { $filtered = array_slice($filtered, (int) $offset, $length); } return new static($filtered); }
/** * Gets the Select Where Condition from a Criteria object. * * @param \Doctrine\Common\Collections\Criteria $criteria * * @return string */ protected function getSelectConditionCriteriaSQL(Criteria $criteria) { $expression = $criteria->getWhereExpression(); if ($expression === null) { return ''; } $visitor = new SqlExpressionVisitor($this, $this->class); return $visitor->dispatch($expression); }
/** * @covers \DoctrineModule\Paginator\Adapter\Selectable::count */ public function testReturnsCorrectCount() { $selectable = $this->getMock('Doctrine\\Common\\Collections\\Selectable'); $expression = Criteria::expr()->eq('foo', 'bar'); $criteria = new Criteria($expression, array('baz' => Criteria::DESC), 10, 20); $adapter = new SelectableAdapter($selectable, $criteria); $selectable->expects($this->once())->method('matching')->with($this->callback(function (Criteria $criteria) use($expression) { return $criteria->getWhereExpression() == $expression && array('baz' => Criteria::DESC) === $criteria->getOrderings() && null === $criteria->getFirstResult() && null === $criteria->getMaxResults(); }))->will($this->returnValue(new ArrayCollection(range(1, 101)))); $this->assertEquals(101, $adapter->count()); $this->assertSame(10, $criteria->getFirstResult(), 'Original criteria was not modified'); $this->assertSame(20, $criteria->getMaxResults(), 'Original criteria was not modified'); }
/** * Select all elements from a selectable that match the criteria and * return a new collection containing these elements. * * @param Criteria $criteria * @return Collection2 */ public function matching(Criteria $criteria) { $this->initialize(); $expr = $criteria->getWhereExpression(); $filtered = $this->entities; if ($expr) { $visitor = new ClosureExpressionVisitor(); $filter = $visitor->dispatch($expr); $filtered = array_filter($filtered, $filter); } if (null !== ($orderings = $criteria->getOrderings())) { $next = null; foreach (array_reverse($orderings) as $field => $ordering) { $next = ClosureExpressionVisitor::sortByField($field, $ordering == 'DESC' ? -1 : 1, $next); } usort($filtered, $next); } $offset = $criteria->getFirstResult(); $length = $criteria->getMaxResults(); if ($offset || $length) { $filtered = array_slice($filtered, (int) $offset, $length); } return new ArrayCollection($filtered); }
/** * Makes a clone of the given Criteria * * @param Criteria $criteria * * @return Criteria */ protected function cloneCriteria(Criteria $criteria) { return new Criteria($criteria->getWhereExpression(), $criteria->getOrderings(), $criteria->getFirstResult(), $criteria->getMaxResults()); }
/** * {@inheritdoc} */ public function exists($entity, Criteria $extraConditions = null) { $criteria = $this->class->getIdentifierValues($entity); if (!$criteria) { return false; } $alias = $this->getSQLTableAlias($this->class->name); $sql = 'SELECT 1 ' . $this->getLockTablesSql(null) . ' WHERE ' . $this->getSelectConditionSQL($criteria); list($params, $types) = $this->expandParameters($criteria); if (null !== $extraConditions && null !== $extraConditions->getWhereExpression()) { $sql .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions); list($criteriaParams, $criteriaTypes) = $this->expandCriteriaParameters($extraConditions); $params = array_merge($params, $criteriaParams); $types = array_merge($types, $criteriaTypes); } if ($filterSql = $this->generateFilterConditionSQL($this->class, $alias)) { $sql .= ' AND ' . $filterSql; } return (bool) $this->conn->fetchColumn($sql, $params, 0, $types); }
/** * {@inheritdoc} */ public function expandCriteriaParameters(Criteria $criteria) { $expression = $criteria->getWhereExpression(); $sqlParams = array(); $sqlTypes = array(); if ($expression === null) { return array($sqlParams, $sqlTypes); } $valueVisitor = new SqlValueVisitor(); $valueVisitor->dispatch($expression); list($params, $types) = $valueVisitor->getParamsAndTypes(); foreach ($params as $param) { $sqlParams = array_merge($sqlParams, $this->getValues($param)); } foreach ($types as $type) { list($field, $value) = $type; $sqlTypes = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class)); } return array($sqlParams, $sqlTypes); }
/** * Serializes a the given criteria to a PHP serialized format. * * @param Criteria $criteria The criteria to serialize. * @return string */ public function serialize(Criteria $criteria) { $structure = array('whereExpression' => $this->dispatch($criteria->getWhereExpression()), 'firstResult' => $criteria->getFirstResult(), 'maxResults' => $criteria->getMaxResults(), 'orderings' => $criteria->getOrderings()); return serialize($structure); }
/** * Adds criteria to the query. * * Adds where expressions with AND operator. * Adds orderings. * Overrides firstResult and maxResults if they're set. * * @param Criteria $criteria * @return QueryBuilder * @throws Query\QueryException */ public function addCriteria(Criteria $criteria) { $allAliases = $this->getAllAliases(); if (!isset($allAliases[0])) { throw new Query\QueryException('No aliases are set before invoking addCriteria().'); } $visitor = new QueryExpressionVisitor($this->getAllAliases()); if ($whereExpression = $criteria->getWhereExpression()) { $this->andWhere($visitor->dispatch($whereExpression)); foreach ($visitor->getParameters() as $parameter) { $this->parameters->add($parameter); } } if ($criteria->getOrderings()) { foreach ($criteria->getOrderings() as $sort => $order) { $hasValidAlias = false; foreach ($allAliases as $alias) { if (strpos($sort . '.', $alias . '.') === 0) { $hasValidAlias = true; break; } } if (!$hasValidAlias) { $sort = $allAliases[0] . '.' . $sort; } $this->addOrderBy($sort, $order); } } // Overwrite limits only if they was set in criteria if (($firstResult = $criteria->getFirstResult()) !== null) { $this->setFirstResult($firstResult); } if (($maxResults = $criteria->getMaxResults()) !== null) { $this->setMaxResults($maxResults); } return $this; }
/** * Selects all elements from a selectable that match the expression and * returns a new collection containing these elements. * * @see Selectable::matching() * @param Criteria $criteria * @return Collection */ public function matching(Criteria $criteria) { $visitor = new QueryExpressionVisitor($this->createQueryBuilder()); $queryBuilder = $this->createQueryBuilder(); if ($criteria->getWhereExpression() !== null) { $expr = $visitor->dispatch($criteria->getWhereExpression()); $queryBuilder->setQueryArray($expr->getQuery()); } if ($criteria->getMaxResults() !== null) { $queryBuilder->limit($criteria->getMaxResults()); } if ($criteria->getFirstResult() !== null) { $queryBuilder->skip($criteria->getFirstResult()); } if ($criteria->getOrderings() !== null) { $queryBuilder->sort($criteria->getOrderings()); } // @TODO: wrap around a specialized Collection for efficient count on large collections return new ArrayCollection($queryBuilder->getQuery()->execute()->toArray()); }
/** * Expands Criteria Parameters by walking the expressions and grabbing all * parameters and types from it. * * @param \Doctrine\Common\Collections\Criteria $criteria * * @return array */ private function expandCriteriaParameters(Criteria $criteria) { $expression = $criteria->getWhereExpression(); if ($expression === null) { return array(); } $valueVisitor = new SqlValueVisitor(); $valueVisitor->dispatch($expression); list($values, $types) = $valueVisitor->getParamsAndTypes(); return $types; }
/** * @param Criteria $criteria * @param bool $hydrate * @return Resultset A collection of entities */ public function getAll(Criteria $criteria = null, $hydrate = true) : Resultset { $collection = $this->getCollectionInstance(); $query = $criteria !== null ? $criteria->getWhereExpression()->visit(new MongoDbExpressionVisitor()) : []; $hydrator = $hydrate === true ? $this->hydrator : null; $className = $this->getModelClass(); $users = new MongodbResultset($collection->find($query), function (array $data) use($hydrator, $className) { return $hydrator ? $hydrator->hydrate($className, $data, true) : $data; }); $users->appendFilter(new MongoIdResultsetFilter()); return $users; }