/** * @dataProvider dataLiteral * * @param mixed $input * @param string|null $type */ public function testLiteral($input, $type) { /** @var \OC\DB\QueryBuilder\Literal $actual */ $actual = $this->expressionBuilder->literal($input, $type); $this->assertInstanceOf('\\OC\\DB\\QueryBuilder\\Literal', $actual); $this->assertEquals($this->doctrineExpressionBuilder->literal($input, $type), $actual->__toString()); }
/** * {@inheritdoc} */ protected function doWalkComparison($fieldName, $operator, $placeholder) { switch ($operator) { case Comparison::IN: return $this->expr->in($fieldName, $placeholder); case Comparison::NIN: return $this->expr->notIn($fieldName, $placeholder); case Comparison::EQ: case Comparison::IS: if ($placeholder === null) { return $this->expr->isNull($fieldName); } return $this->expr->eq($fieldName, $placeholder); case Comparison::NEQ: if ($placeholder === null) { return $this->expr->isNotNull($fieldName); } return $this->expr->neq($fieldName, $placeholder); case Comparison::CONTAINS: return $this->expr->like($fieldName, $placeholder); default: $operator = self::convertComparisonOperator($operator); if ($operator) { return $this->expr->comparison($fieldName, $operator, $placeholder); } throw new \RuntimeException("Unknown comparison operator: " . $operator); } }
/** * Filter field with `LIKE`. * * @param string $filterName * @param string $field */ protected function likeFilter($filterName, $field) { $info = $this->extract($filterName); $info['values'] = explode(',', str_replace('*', '%', $info['values'])); foreach ($info['values'] as $value) { if ($info['cond']) { $expr = $this->expr->like($field, "'%{$value}%'"); } else { $expr = $this->expr->notLike($field, "'%{$value}%'"); } } $this->builder->andWhere($expr); $this->filters[$filterName] = $info; }
/** * Quotes a given input parameter. * * @param mixed $input The parameter to be quoted. * @param string|null $type The type of the parameter. * * @return Literal */ public function literal($input, $type = null) { return new Literal($this->expressionBuilder->literal($input, $type)); }
/** * Initializes a new <tt>ExpressionBuilder</tt>. * * @param \Doctrine\DBAL\Connection $connection DBAL Connection */ public function __construct(Connection $connection) { parent::__construct($connection); $this->conn = $connection; }
/** * The default handler is the last to be run and handler simple value parsing. * * @param string $key * @param string $value * @param ExpressionBuilder $expr * * @return Filter */ public function defaultFilterHandler($key, $value, $expr) { $val = $this->parseValue($value); $placeholder = $key . '_1'; $exprMethod = $val['operator']; $filter = new Filter(); $filter->setKey($key); $filter->setExpression($expr->andX($expr->{$exprMethod}($this->alias . $key, ":{$placeholder}"))); $filter->setParameters([$placeholder => $val['value']]); return $filter; }
/** * Get list of entities for autopopulate fields. * * @param $type * @param $filter * @param $limit * @param $start * * @return array */ public function getLookupResults($type, $filter = '', $limit = 10, $start = 0) { $results = []; switch ($type) { case 'companyfield': case 'lead.company': $expr = null; if ('lead.company' === $type) { $column = 'companyname'; $filterVal = $filter; } else { if (is_array($filter)) { $column = $filter[0]; $filterVal = $filter[1]; } else { $column = $filter; } } $expr = new ExpressionBuilder($this->em->getConnection()); $composite = $expr->andX(); $composite->add($expr->like("comp.{$column}", ':filterVar')); // Validate owner permissions if (!$this->security->isGranted('lead:leads:viewother')) { $composite->add($expr->orX($expr->andX($expr->isNull('comp.owner_id'), $expr->eq('comp.created_by', (int) $this->userHelper->getUser()->getId())), $expr->eq('comp.owner_id', (int) $this->userHelper->getUser()->getId()))); } $results = $this->em->getRepository('MauticLeadBundle:Company')->getSimpleList($composite, ['filterVar' => $filterVal . '%'], $column); break; } return $results; }
/** * @param $queryBuilder * @param $expressionBuilder */ protected function addFilteredProperties(QueryBuilder &$queryBuilder, ExpressionBuilder $expressionBuilder) { if (!count($this->filteredProperties)) { return; } foreach ($this->filteredProperties as $index => $filteredProperty) { $property = 'm.' . $filteredProperty['membersPropertyFilter_property']; $comparator = $filteredProperty['membersPropertyFilter_comparator']; $value = $filteredProperty['membersPropertyFilter_value']; switch ($comparator) { case 'empty': $queryBuilder->andWhere($expressionBuilder->orX($expressionBuilder->eq($property, ':property' . $index), $expressionBuilder->isNull($property))); $value = ''; break; case 'not empty': $queryBuilder->andWhere($expressionBuilder->gt($property, ':property' . $index)); $value = ''; break; default: if (!method_exists($expressionBuilder, $comparator)) { continue; } $queryBuilder->andWhere($expressionBuilder->{$comparator}($property, ':property' . $index)); break; } $queryBuilder->setParameter(':property' . $index, $value); } }