Returns a query string for approximately equals.

Produces: (field=value)

@param string $field
@param string $value

@return string
507513
private function buildApproximatelyEquals($field, $value)
    {
        return $this::$open.$field.Operator::$approximateEqual.$value.$this::$close;
    }
922801
private function buildDoesNotEqual($field, $value)
    {
        return $this::$open.Operator::$doesNotEqual.$this->buildEquals($field, $value).$this::$close;
    }
216805
public ZealotKhala orEqual(String field, Object value) {
        return this.doNormal(ZealotConst.OR_PREFIX, field, value, ZealotConst.EQUAL_SUFFIX, true);
    }
52306
private function equalsExpression($field, array $values)
    {
        return $this->queryBuilder->expression()->eq($field, $this->parameter($values));
    }
1150597
protected static function query($fields)
    {
        $result = Query::from(static::$table);

        $result = $result->where();

        foreach ($fields as $key => $value) {
            $result = $result->andWhere($key, '=', $value);
        }

        return $result->get();
    }
640859
public function equals($value) {
        if ($value instanceof PHPString) {
            $value = $value->getValue();
        }
        return strcmp($this->value, $value) === 0;
    }
975435
public function orWhereRegex($field, $value)
    {
        if (! $value instanceof MongoRegex) {
            $value = new MongoRegex($value);
        }

        return $this->formatWhere('$or', $field, $value);
    }
1091653
protected function parseValue($value, $field = '')
    {
        $pk = $this->connection->getConfig('pk');
        if ($pk == $field && 'ObjectID' == $this->connection->getConfig('pk_type') && is_string($value)) {
            return new ObjectId($value);
        }
        return $value;
    }
664179
public function fieldQuery($field)
    {
        $query = $this->dsql()->del('fields');
        if (is_string($field)) {
            $field = $this->getElement($field);
        }
        $field->updateSelectQuery($query);

        return $query;
    }
351665
public function whereNotEndsWith($field, $value)
    {
        foreach ($this->queries as $query) {
            $query->whereNotEndsWith($field, $value);
        }

        return $this;
    }
298219
public static Query notEquals(String field, Object value) {
        return new Query().notEquals(field, value);
    }
1124937
public function orWhere($field, $value)
    {
        $this->reloadQueryAdapter();
        $this->activeQuery->orWhere($field, $value);
        return $this;
    }
511926
public function whereEq($field, $value)
    {
        $this->_filters[] = [$field => $this->normalizeValue($field, $value)];

        return $this;
    }
12450
public static function eq($field, $value, $dqlAlias = null)
    {
        return new Comparison(Comparison::EQ, $field, $value, $dqlAlias);
    }
579253
protected function buildSingularFieldCondition($field, $value, $comparison)
    {
        $field = $this->model()->field($field);

        return $this->buildConditionString(
            $this->connection()->quoteIdentifier($field->mappedName()),
            $value === null ? null : $this->bindValues($field->mappedName(), $field->type(), $value),
            $comparison
        );
    }
749964
public function where($field, $operator, $value = null)
    {
        if (is_null($value)) {
            $value    = $operator;
            $operator = '=';
        }

        return $this->filter(function ($data) use ($field, $operator, $value) {
            if (strpos($field, '.')) {
                list($field, $relation) = explode('.', $field);

                $result = isset($data[$field][$relation]) ? $data[$field][$relation] : null;
            } else {
                $result = isset($data[$field]) ? $data[$field] : null;
            }

            switch ($operator) {
                case '===':
                    return $result === $value;
                case '!==':
                    return $result !== $value;
                case '!=':
                case '<>':
                    return $result != $value;
                case '>':
                    return $result > $value;
                case '>=':
                    return $result >= $value;
                case '<':
                    return $result < $value;
                case '<=':
                    return $result <= $value;
                case 'like':
                    return is_string($result) && false !== strpos($result, $value);
                case 'not like':
                    return is_string($result) && false === strpos($result, $value);
                case 'in':
                    return is_scalar($result) && in_array($result, $value, true);
                case 'not in':
                    return is_scalar($result) && !in_array($result, $value, true);
                case 'between':
                    list($min, $max) = is_string($value) ? explode(',', $value) : $value;
                    return is_scalar($result) && $result >= $min && $result <= $max;
                case 'not between':
                    list($min, $max) = is_string($value) ? explode(',', $value) : $value;
                    return is_scalar($result) && $result > $max || $result < $min;
                case '==':
                case '=':
                default:
                    return $result == $value;
            }
        });
    }
172943
public function where($field, $value)
    {
        if (strtolower($field) === "meta_query") {
            return $this->metaWhere($field, $value);
        } elseif (strtolower($field) === "tax_query") {
            return $this->taxWhere($field, $value);
        }

        $this->filters[$field] = $value;
        return $this;
    }