Sets the expression objects.

@param MW_Common_Criteria_Expression_Interface $conditions Expression object
@return MW_Common_Criteria_Interface Object instance for fluent interface
550807
public function setConditions( MW_Common_Criteria_Expression_Interface $conditions )
	{
		if( $conditions instanceof MW_Common_Criteria_Expression_Sort_Interface ) {
			throw new MW_Common_Exception( 'Sortation objects are not allowed' );
		}

		$this->_conditions = $conditions;
		return $this;
	}
636238
private function _prepareCondition(ConditionInterface $condition = null)
	{
		$this->condition = $this->expressionBuilderFactory->create($condition)->build();
	}
394683
final public function setConditions(array $conditions)
    {
        if ($this->hasRun) {
            throw new \RuntimeException("Cursor query has already run");
        }

        $this->conditions = $this->applyConditions($conditions);
    }
1049725
public function setFilters(array $expressions): CopyDictionaryJob
    {
        $this->filters = [];
        foreach ($expressions as $expression) {
            $this->addFilter($expression);
        }

        return $this;
    }
329693
public function where(array $condition = null): Select
    {
        if (!\is_array($condition)) {
            throw new InvalidArgumentException('$condition has to be an array');
        }
        $this->where = (new Condition($this->namesClass->getAliases()))->parse($condition);

        return $this;
    }
848737
public function findOneBy($conditions)
	{
		debug_assert( false, 'Function findOneBy is scheduled for deletion, replace with Model::getBy($conditions)' );
		$instance = static::getBy( $conditions, array_keys($this->schemaColumnsGet()) );
		$this->fromArray( $instance->toArray() );
		$this->changedColumnsReset();
		return $this;
	}
302295
public function where($conditions, ...$parameters)
    {
        if (is_array($conditions)) {
            $this->where = array_merge($this->where, array_map(function ($value, $field) {
                $field = $this->connection->quoteIdentifier($field);
                if ($value === null) {
                    return $field . ' IS NULL';
                }

                return $field . '=' . $this->connection->quote($value);
            }, $conditions, array_keys($conditions)));
        } else {
            if ($parameters) {
                $conditions = $this->connection->merge($conditions, $parameters);
            }
            $this->where[] = $conditions;
        }

        return $this;
    }
456461
public function add(array $conditions)
    {
        $this->conditions = array_merge($this->conditions, $conditions);

        return $this->conditions;
    }
989415
public function addCondition($condition)
    {
        if (!$this->conditions->contains($condition)) {
            $this->conditions[] = $condition;
        }

        return $this;
    }
440069
protected function _prepareQueryConditions(&$conditions) {
		if (empty($conditions) || !is_array($conditions)) {
			return;
		}

		$bindFields = $this->_getListFieldsUpdateQueryConditions();
		$newConditions = [];
		foreach ($conditions as $field => &$value) {
			if (ctype_digit((string)$field)) {
				$field = $value;
			}

			if (in_array($field, ['AND', 'OR', 'NOT']) && is_array($value)) {
				$this->_prepareQueryConditions($value);
				continue;
			}

			if (!is_string($field)) {
				continue;
			}

			foreach ($bindFields as $bindField => $bindFieldInfo) {
				$fieldName = $field;
				if (strpos($fieldName, ' ') !== false) {
					$fieldName = explode(' ', $fieldName, 2);
					$fieldName = array_shift($fieldName);
				}
				if ($fieldName !== $this->alias . '.' . $bindField) {
					continue;
				}

				unset($conditions[$field]);
				$field = str_replace($this->alias . '.' . $bindField, $bindFieldInfo['replace'], $field);
				if (!isset($bindFieldInfo['subQuery'])) {
					$newConditions[$field] = $value;
					continue;
				}

				$conditionsSubQuery = [$field => $value];
				$db = $this->getDataSource();
				$subQuery = $db->buildStatement(
					[
						'limit' => null,
						'offset' => null,
						'joins' => [],
						'conditions' => $conditionsSubQuery,
						'order' => null,
						'group' => null
					] + $bindFieldInfo['subQuery'],
					$this
				);
				$subQuery = 'Employee.id IN (' . $subQuery . ') ';
				$subQueryExpression = $db->expression($subQuery);

				$newConditions[] = $subQueryExpression;
			}
		}
		$conditions = array_merge($conditions, $newConditions);
	}
1116658
public function setExpressions(array $expressions)
    {
        foreach ($expressions as $expression) {
            if (! $expression instanceof AbstractExpression) {
                throw new \InvalidArgumentException(
                    'Error: Expected array of AbstractExpression but got something else'
                );
            }
        }

        $this->expressions = $expressions;
    }
356662
public function addConditions(array $conditions = array())
    {
        foreach ($conditions as $key => $condition) {
            if (is_array($condition)) {
                call_user_func_array(array($this, 'addCondition'), $condition);
            } elseif (!$this->getBuilder()->getHelper()->isNumber($key)) {
                call_user_func_array(array($this, 'addCondition'), array($key, $condition));
            } else {
                $this->addCondition($condition);
            }
        }

        return $this;
    }
355111
public function andHaving(...$conditions) : self
    {
        $this->havingConditions = $this->conditionalQueryBuilder->addConditionToClause(
            $this->havingConditions, 'AND', ...$this->createConditionExpressions($conditions)
        );

        return $this;
    }
271773
public function filterConditions(
        array $conditions,
        string $matchType = CollectionUtility::MATCH_TYPE_LOOSE,
        $preserveKeys = false
    ): ArrayObjectInterface {
        return new static(CollectionUtility::filterWhere($this->isCollection() ? $this->data : [$this->data],
            $conditions, $matchType, $preserveKeys));
    }
618484
protected function createExpression(Condition $condition, $fieldDescriptor)
    {
        $value = $this->getValue($condition);

        // relative date for cases like "within a week" or "within this month"
        if ('between' === $condition->getOperator() && DataTypes::DATETIME_TYPE === $condition->getType()) {
            $this->expressions[] = $this->listBuilder->createBetweenExpression($fieldDescriptor, [$value, new \DateTime()]);
        } else {
            $this->expressions[] = $this->listBuilder->createWhereExpression(
                $fieldDescriptor,
                $value,
                $condition->getOperator()
            );
        }
    }
20472
public function whereGroup($conditions, $logic = 'AND')
    {
        $whereGroup = $this->_append('Where_Group', $conditions, $logic);
        if ($group = $whereGroup->__toString()) {
            $this->where('(' . $group . ')', null, $logic);
        }

        return $this;
    }
154108
protected function addConditions($query, $conditions)
    {
        foreach ($conditions as $key => $value) {
            $this->addWhere($query, $key, $value);
        }

        return $query;
    }