@param $column
@param array $between

@return BaseQueryRelateContract
160097
public function orWhereNotBetween($column, array $between): BaseQueryRelateContract
    {
        $this->query->orWhereNotBetween($column, $between);

        return $this;
    }
960904
public function havingBetween(string $column, int $min, int $max)
    {
        $instance = $this->havingStrategyInstance();

        $instance->havingStrategy()->havingBetween($column, $min, $max);

        return $instance;
    }
359641
public function andWhereIn($column, array $values)
    {
        $this->where[] = [self::AND_WHERE_IN, $column, $values];

        return $this;
    }
1077747
public function between($between, $error) {
        if ($this->_exist) {
            array_push($this->_constraints, ['type' => self::BETWEEN, 'value' => $between, 'message' => $error]);
        }

        return $this;
    }
1113277
public function related($relation, $column, $operator = null, $value = null, $boolean = 'and')
    {
        if ($column instanceof \Closure) {
            return $this->addRelated($relation, $column);
        }

        // If there is no value it is a where = ? query and we set the appropriate params
        if ($value === null) {
            $value = $operator;
            $operator = '=';
        }

        return $this->addRelated($relation, function ($query) use ($column, $operator, $value, $boolean) {
            return $query->where($column, $operator, $value, $boolean);
        });
    }
842257
public function havingRaw(string $sql, array $bindings = []): BaseQueryRelateContract
    {
        $this->query->havingRaw($sql, $bindings, 'and');

        return $this;
    }
141368
public function like($column, $pattern)
    {
        $this->conditions = [$this->grammar->buildId($column) . ' LIKE ' . $pattern];

        return $this;
    }
294811
public function whereRelation($column1, $operator, $column2 = null)
    {
        $instance = $this->whereStrategyInstance();

        $instance->whereStrategy()->whereRelation(...func_get_args());

        return $instance;
    }
400431
public function getRelationExistenceQuery(Builder $query, Builder $parentQuery, $columns = ['*'])
    {
        if ($query->getQuery()->from == $parentQuery->getQuery()->from) {
            return $this->getRelationExistenceQueryForSelfRelation($query, $parentQuery, $columns);
        }

        return parent::getRelationExistenceQuery($query, $parentQuery, $columns);
    }
325899
public function using($column)
	{
		/** @var ColumnInterface $columnObj */
		$columnObj = $this->factory->references('Column', $column);
		$this->join->using($columnObj);

		return $this;
	}
981208
final public function orWhereIn(string $column, array $values)
    {
        $this->query->addOrWhereIn($column, $values);

        return $this;
    }
185109
public function selectFrom($table, string $column, string ...$columns)
    {
        $instance = $this->selectQueryInstance();

        $instance->selectQuery()->columnsFrom($table, $column, ...$columns);

        return $instance;
    }
558014
public function andNotBetween($column, $left, $right)
    {
        $this->conditions[] = 'AND ' . $this->grammar->buildId($column) . ' NOT BETWEEN ' . $left . ' AND ' . $right;

        return $this;
    }
1152883
protected function column(Column $column) : ColumnExpr
    {
        return Expr::column($this->relatedTable->getName(), $column);
    }
237971
public function whereIn($column, $params)
    {
        $this->prepareWhereInStatement($column, $params, false);
        $this->addParams($params);

        return $this;
    }
1093874
public function orWhereIsNot(string $column)
    {
        $instance = $this->whereStrategyInstance();

        $instance->whereStrategy()->orWhereIsNot($column);

        return $instance;
    }
31976
public function whereNotIn($column, array $values)
    {
        return $this->where(function ($query) use ($column, $values) {
            $query->whereNotIn($column, $values);
        });
    }