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;
}
