whereIn

@param string $column
@param array  $values

@return  Query

@since  3.4.5
500531
public function whereIn($column, array $values)
    {
        if ($values === []) {
            throw new \InvalidArgumentException('Values for IN() is empty');
        }

        return $this->where('%n %r', $column, new QueryElement('IN()', $this->quote($values)));
    }
871335
public function whereIn($column, $values, $boolean = 'and', $not = false)
	{
		$type = $not ? 'NotIn' : 'In';

		// If the value of the where in clause is actually a Closure, we will assume that
		// the developer is using a full sub-select for this "in" statement, and will
		// execute those Closures, then we can re-construct the entire sub-selects.
		if ($values instanceof Closure)
		{
			return $this->whereInSub($column, $values, $boolean, $not);
		}

		$this->wheres[] = compact('type', 'column', 'values', 'boolean');

		$this->addBinding($values, 'where');

		return $this;
	}
937593
public function in($column, array $values, $filter = false)
    {
        if (!$this->isFilterable($filter, $values)) {
            return $this;
        }

        $this->append(sprintf(' %s IN (%s) ', $this->quote($column), implode(', ', $values)));
        return $this;
    }
1245793
public function orWhereNotIn($column, $values, $filter = false)
    {
        return $this->whereInValues(__FUNCTION__, $column, $values, $filter);
    }
660754
public function where($column, $value = null)
    {
        // If the column is an array, we will assume it is an array of key-value pairs
        // and can add them each as a where clause.
        if (is_array($column)) {
            return $this->whereNested(function ($query) use ($column) {
                foreach ($column as $key => $value) {
                    $query->where($key, $value);
                }
            });
        }

        $this->wheres[] = compact('column', 'value');

        return $this;
    }
952155
public function findWhereNotIn($field, array $values, $columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();
        $model = $this->model->whereNotIn($field, $values)->get($columns);
        $this->resetModel();

        return $this->parserResult($model);
    }
680163
public function andWhereNotIn($column, $values, $filter = false)
    {
        return $this->whereInValues(__FUNCTION__, $column, $values, $filter);
    }
330737
public function orWhere($column, $expression = null, $value = null)
    {
        return $this->doWhere(self::OR_WHERE, $column, $expression, $value);
    }
207828
public function whereBetween($column, array $values, $boolean = 'and', $not = false)
    {
        $type = 'between';

        $this->wheres[] = compact('type', 'column', 'values', 'boolean', 'not');

        $this->addBinding($this->cleanBindings($values), 'where');

        return $this;
    }
264912
public function whereIntegerInRaw($column, $values, $boolean = 'and', $not = false)
    {
        $type = $not ? 'NotInRaw' : 'InRaw';

        if ($values instanceof Arrayable) {
            $values = $values->toArray();
        }

        foreach ($values as &$value) {
            $value = (int) $value;
        }

        $this->wheres[] = compact('type', 'column', 'values', 'boolean');

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

        return $this;
    }
1311740
public function where($column, $operator = '=', $value = null, $boolean = 'and', array $columns = ['*'])
    {
        return $this->mediator->transform($this->mediator(func_get_args()));
    }
732103
public function whereInStrict(string $key, $values): Collection
    {
        return $this->whereIn($key, $values, true);
    }
267655
protected function getWhereFrom(array $values)
    {
        $where = new Where();

        foreach ($values as $field => $value) {
            $where->andWhere(
                sprintf(
                    "%s = $*::%s",
                    $this->escapeIdentifier($field),
                    $this->getStructure()->getTypeFor($field)
                ),
                [$value]
            );
        }

        return $where;
    }
429077
public function filterBy($column, $value = null)
    {
        $value = in_array($value, ['true', 'false']) ? ($value === 'false' ? false : true) : $value;

        is_bool($value)
            ? $this->instance->where($column, $value)
            : $this->instance->where($column, $this->getLikeOperator(), "%$value%");

        return $this;
    }
414791
protected function select($columns=[])
    {
        $query = $this->model->newQuery()->getQuery();
        if ($columns) {
            $query->select($columns);
        }
        return $query;
    }
687656
public function whereIn(string $column, array $values, string $connector = self::LOGICAL_AND): self
    {
        if (!empty($values)) {
            $this->criteria($this->where, $column, $values, self::IN, $connector);
        }

        return $this;
    }