/**
* Add "WHERE" parameter
*
* @deprecated Since 1.8 use criteria to add conditions
*
* @param string $keyWord
* @param string $fieldName
* @param string $condition
* @param string $fieldValue
* @param string $fieldType
*
* @return Query
*/
public function where($keyWord, $fieldName, $condition, $fieldValue, $fieldType = self::TYPE_TEXT)
{
$expr = Criteria::expr();
$fieldName = Criteria::implodeFieldTypeName($fieldType, $fieldName);
switch ($condition) {
case self::OPERATOR_CONTAINS:
$expr = $expr->contains($fieldName, $fieldValue);
break;
case self::OPERATOR_NOT_CONTAINS:
$expr = $expr->notContains($fieldName, $fieldValue);
break;
case self::OPERATOR_EQUALS:
$expr = $expr->eq($fieldName, $fieldValue);
break;
case self::OPERATOR_NOT_EQUALS:
$expr = $expr->neq($fieldName, $fieldValue);
break;
case self::OPERATOR_GREATER_THAN:
$expr = $expr->gt($fieldName, $fieldValue);
break;
case self::OPERATOR_GREATER_THAN_EQUALS:
$expr = $expr->gte($fieldName, $fieldValue);
break;
case self::OPERATOR_LESS_THAN:
$expr = $expr->lt($fieldName, $fieldValue);
break;
case self::OPERATOR_LESS_THAN_EQUALS:
$expr = $expr->lte($fieldName, $fieldValue);
break;
case self::OPERATOR_IN:
$expr = $expr->in($fieldName, $fieldValue);
break;
case self::OPERATOR_NOT_IN:
$expr = $expr->notIn($fieldName, $fieldValue);
break;
default:
throw new ExpressionSyntaxError(sprintf('Unsupported operator "%s"', $condition));
}
if ($keyWord === self::KEYWORD_AND) {
$this->criteria->andWhere($expr);
} else {
$this->criteria->orWhere($expr);
}
return $this;
}
/**
* @param string $arrayFields
* @param string $additionalField
*
* @return string
*/
protected function combineFieldNames($arrayFields, $additionalField)
{
list($type, $field) = Criteria::explodeFieldTypeName($additionalField);
$fieldsString = implode('|', array_merge(explode('|', Criteria::explodeFieldTypeName($arrayFields)[1]), [$field]));
return Criteria::implodeFieldTypeName($type, $fieldsString);
}
/**
* @param null|string $whereType can be 'and' | 'or' | 'null'
*
* @return array
* key 0 -> type
* key 1 -> expression
*/
protected function parseSimpleCondition($whereType = null)
{
$expr = Criteria::expr();
if (null === $whereType) {
$whereType = 'andWhere';
} else {
$whereType = sprintf('%sWhere', $this->stream->expect(Token::OPERATOR_TYPE, [Query::KEYWORD_AND, Query::KEYWORD_OR])->value);
}
if ($this->stream->current->test(Token::PUNCTUATION_TYPE)) {
return [$whereType, $this->parseCompositeCondition()];
}
/**
* We expecting that both field type and field name will be specified
*/
$fieldTypeToken = $this->stream->expect(Token::STRING_TYPE, null, null, false);
$fieldNameToken = $this->stream->expect(Token::STRING_TYPE, null, null, false);
$fieldType = Query::TYPE_TEXT;
if (!$fieldNameToken) {
/**
* If field type is not specified we got field name in first expect ($fieldTypeToken)
*/
$fieldName = Criteria::implodeFieldTypeName($fieldType, $fieldTypeToken->value);
} else {
$fieldType = $fieldTypeToken->value;
$fieldName = Criteria::implodeFieldTypeName($fieldType, $fieldNameToken->value);
}
/** @var Token $operatorToken */
$operatorToken = $this->stream->expect(Token::OPERATOR_TYPE, $this->typeOperators[$fieldType], 'Not allowed operator');
switch ($operatorToken->value) {
case Query::OPERATOR_CONTAINS:
$expr = $expr->contains($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_NOT_CONTAINS:
$expr = $expr->notContains($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_EQUALS:
$expr = $expr->eq($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_NOT_EQUALS:
$expr = $expr->neq($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_GREATER_THAN:
$expr = $expr->gt($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_GREATER_THAN_EQUALS:
$expr = $expr->gte($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_LESS_THAN:
$expr = $expr->lt($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_LESS_THAN_EQUALS:
$expr = $expr->lte($fieldName, $this->stream->current->value);
break;
case Query::OPERATOR_IN:
return [$whereType, $expr->in($fieldName, $this->parseArguments())];
case Query::OPERATOR_NOT_IN:
return [$whereType, $expr->notIn($fieldName, $this->parseArguments())];
default:
throw new ExpressionSyntaxError(sprintf('Unsupported operator "%s"', $operatorToken->value), $operatorToken->cursor);
}
$this->stream->next();
return [$whereType, $expr];
}
