{@inheritDoc}

@return \Cpliakas\DynamoDb\ODM\Conditions
19801
public function addCondition($attribute, $values, $operator = ComparisonOperator::EQ)
    {
        $this->conditions[$attribute] = array(
            'values' => (array) $values,
            'operator' => $operator,
        );

        return $this;
    }
1266062
protected function getOnConditionSQL($mapping)
    {
        $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
        $association = ( ! $mapping['isOwningSide'])
            ? $targetClass->associationMappings[$mapping['mappedBy']]
            : $mapping;

        $joinColumns = $mapping['isOwningSide']
            ? $association['joinTable']['inverseJoinColumns']
            : $association['joinTable']['joinColumns'];

        $conditions = array();

        foreach ($joinColumns as $joinColumn) {
            $joinColumnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
            $refColumnName  = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);

            $conditions[] = ' t.' . $joinColumnName . ' = ' . 'te.' . $refColumnName;
        }

        return $conditions;
    }
997959
protected function processConditions(array $conditions) {
		foreach($cp=$conditions as $k=>$v) {
			if(is_numeric($k) || in_array(strtolower($k), ['and', 'or', 'xor', 'not'])) {
				$newK = $k;
				if(is_array($v))
					$v = $this->processConditions($v);
				else
					$v = $this->replaceTable($v);
			}
			else
				$newK = $this->replaceTable($k);

			if($newK != $k)
				unset($conditions[$k]);
			$conditions[$newK] = $v;
		}

		return $conditions;
	}
466462
protected function _conditions($entity, $slug)
    {
        /** @var string $primaryKey */
        $primaryKey = $this->_table->getPrimaryKey();
        $field = $this->_table->aliasField($this->getConfig('field'));

        $conditions = [$field => $slug];

        if (is_callable($this->getConfig('scope'))) {
            $scope = $this->getConfig('scope');
            $conditions += $scope($entity);
        } else {
            $conditions += $this->getConfig('scope');
        }

        if ($id = $entity->{$primaryKey}) {
            $conditions['NOT'][$this->_table->aliasField($primaryKey)] = $id;
        }

        return $conditions;
    }
1079518
public function where($key, $constraint = null, $value = null, $condition = 'AND')
    {
        $handle = $this->getHandle();

        $this->_internal_query->where($key, $constraint, $value, $condition);

        if (!isset($this->_parent_query->where[$handle])) {
            $this->_parent_query->where[$handle] = array('clause' => $this, 'condition' => $this->_condition);
        }

        return $this;
    }
715350
public function strict($condition) {
      $query = $this->buildStrategyCondition($condition, Strict::create());
      return $this->process($query);
    }
1222579
public function filter( $condition ) {
		$elements = array();

		foreach ( $this->elements as $element ) {
			if ( call_user_func( $condition, $element ) ) {
				$elements[] = $element;
			}
		}

		return $this->new_from_trusted( $elements );
	}
406233
public function condition()
    {
        $cond = new Condition\Condition();
        $cond->from($this->getTableName());
        $cond->setModel($this);
        return $cond;
    }
51128
protected function getConditions()
    {
        $conditionLoader = $this->loader->getConditions();
        $conditions = [];
        for ($number = 1; $number <= 4; $number++) {
            $element = 'gcon_condition_text' . $number;
            $conditionId = (int) $this->_data[$element];
            if ($conditionId >0) {
                $conditions[] = $conditionLoader->loadCondition($conditionId);
            }
        }

        return $conditions;
    }
749672
protected function getCondition()
    {
        $condition = ['and'];
        foreach ((array)$this->conditionAttributes as $attribute) {
            if ($this->owner->hasAttribute($attribute)) {
                $condition[] = [$attribute => $this->owner->$attribute];
            }
        }
        return $condition;
    }
347331
protected function arrayToConditions($conditions)
    {
        $ret = [];

        foreach ($conditions as $key => $value) {
            if ($value instanceof Condition) {
                $ret[] = $value;
                continue;
            }

            $propertyOperator = explode('-', $key);

            if (in_array(count($propertyOperator), [1, 2])) {
                $ret[] = new Condition($propertyOperator[0], $value, $propertyOperator[1] ?? null);
            }
        }

        return $ret;
    }
1051488
public static function findAll($condition = '1=1', $params = array())
    {
        /* @var $condition \mpf\datasources\sql\ModelCondition */
        if (!is_a($condition, '\\mpf\\datasources\\sql\\ModelCondition')) {
            $condition = ModelCondition::getFrom($condition, get_called_class());
        } else {
            $condition->model = $condition->model ? $condition->model : get_called_class();
        }
        $condition->setParams($params);
        $searchedRelations = [];
        if (is_array($condition->with)) {
            foreach ($condition->with as $k) {
                $searchedRelations[$k] = $k;
            }
        }
        $models = static::getDb()->queryClass($condition, get_called_class(), $condition->getParams(), [
            [
                '_columns' => static::getDb()->getTableColumns(static::getTableName()),
                '_pk' => static::getDb()->getTablePk(static::getTableName()),
                '_isNewRecord' => false,
                '_action' => 'update',
                '_tableName' => static::getTableName(),
                '_db' => static::getDb(),
                '_searchedRelations' => $searchedRelations
            ]
        ]);
        if (!$models) {
            return [];
        }
        $condition->getExtraRelations($models);
        return $models;
    }
437286
public function condition_matches() {
        $match = false; // By default no match
        $param = $this->procconditionparam;
        if ($param instanceof base_atom && $param->is_set()) {
            $match = ($param->get_value() == $this->conditionvalue); // blame $DB for not having === !
        } else {
            $match = ($param == $this->conditionvalue);
        }
        return $match;
    }
1305647
public function where( $condition ) {
		if ( ! $condition instanceof ConditionInterface ) {
			$condition = func_get_args();
		}

		$condition = $this->router->mergeConditionAttribute(
			$this->getAttribute( 'condition' ),
			$condition
		);

		return $this->attribute( 'condition', $condition );
	}
1143923
public function getConditions()
    {
        $conditions = array();
        for ($i = 0; $i < $this->count; $i++) {
            $conditions[] = array(
                'left'     => $this->getLeftColumn($i),
                'operator' => $this->getOperator($i),
                'right'    => $this->getRightColumn($i)
            );
        }

        return $conditions;
    }
607333
public function any($condition)
    {
        $this->filter($condition);

        $tmp = new \stdClass();

        return $this->getFirst($tmp) !== $tmp;
    }
478302
protected function whereStatement(): array
    {
        return [
            $this->key(Record::OUTER_KEY) => $this->parent->getField($this->key(Record::INNER_KEY))
        ];
    }