@param string $column
@param array  $values

@return BaseQueryRelateContract
547334
public function whereNotIn(string $column, array $values): BaseQueryRelateContract
    {
        $this->query->whereNotIn($column, $values);

        return $this;
    }
453994
public function whereIn($column, $values, $boolean = 'and', $not = false)
    {
        $type = $not ? 'NotIn' : 'In';

        // If the value is a query builder instance we will assume the developer wants to
        // look for any values that exists within this given query. So we will add the
        // query accordingly so that this query is properly executed when it is run.
        if ($values instanceof static) {
            return $this->whereInExistingQuery(
                $column,
                $values,
                $boolean,
                $not
            );
        }

        // 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);
        }

        // Next, if the value is Arrayable we need to cast it to its raw array form so we
        // have the underlying array value instead of an Arrayable object which is not
        // able to be added as a binding, etc. We will then add to the wheres array.
        if ($values instanceof Arrayable) {
            $values = $values->toArray();
        }

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

        // Finally we'll add a binding for each values unless that value is an expression
        // in which case we will just skip over it since it will be the query as a raw
        // string and not as a parameterized place-holder to be replaced by the PDO.
        foreach ($values as $value) {
            if (!$value instanceof Expression) {
                $this->addBinding($value, 'where');
            }
        }

        return $this;
    }
1126141
public function columns($columns) {
		foreach ($columns as $property => $definition) {
			if (is_bool($definition)) {
				$this->_properties[$property] = $definition;
				continue;
			}
			
			$this->addAccumulator($property, $definition);
		}
		
		return $this;
	}
687738
public function findManyBy($attribute, array $values = [], $columns = [])
    {
        $query = $this->select($columns);

        foreach ($values as $value) {
            $query->orWhere([$attribute => $value]);
        }

        return $query->get();
    }
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;
    }
1168586
public function orHaving($column, $operator = null, $value = null): BaseQueryRelateContract
    {
        $this->query->orHaving($column, $operator, $value);

        return $this;
    }
533874
public function orderBy(string $column, string $sort = 'desc'): BaseQueryRelateContract
    {
        $this->query->orderBy($column, $sort);

        return $this;
    }
1204008
public function values($values)
    {
        if(!$values instanceof DatabaseQuerySelect)
        {
            if (!$this->columns && !is_numeric(key($values))) {
                $this->columns(array_keys($values));
            }

            $this->values[] = array_values($values);
        }
        else $this->values = $values;

        return $this;
    }
291265
public function addWhereIn(string $column, array $values)
    {
        foreach ($values as $value) {  // pour bindValue(s)
            $this->wheresIn[][2] = $value;
        }

        $this->sql['where'] .= " ".$this->logicOperator." ".$column." IN ".$this->addConditionsToSqlWhithWhereIn()." ";

        $this->logicOperator = " AND ";
    }
221253
public function whereIn($column, $values, $table = null)
    {
        $this->db()->whereIn($column, $values, $table);
        return $this;
    }
1145196
final public function whereIn(string $column, array $values)
    {
        $this->query->addWhereIn($column, $values);

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

        return $this;
    }
429510
public function update(array $values)
    {
        $result = parent::update($values);

        $this->handler->setBuilder($this)
            ->invalidateQuery(Reflector::QUERY_TYPE_UPDATE, $values);

        return $result;
    }
1207085
public function where($column, $value = '')
    {
        if (is_array($column)) {
            foreach ($column as $key => $val) {
                $this->whereNeedAddAndOrOr > 0 && ($value === false ? $this->_or() : $this->_and());
                $this->conditionFactory($key, $val, '=');
            }
        } else {
            $this->conditionFactory($column, $value, '=');
        }
        return $this;
    }
514767
public function havingBetween($column, array $values, $boolean = 'and', $not = false)
    {
        $type = 'between';

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

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

        return $this;
    }
1334229
public function whereNotIn(string $column, array $values, string $connector = self::LOGICAL_AND): self
    {
        if (!empty($values)) {
            $this->criteria($this->where, $column, $values, self::NOT_IN, $connector);
        }

        return $this;
    }
335961
public function sql($sql, array $values = array())
    {
        $this->whereSqlConditions[] = $sql;
        $this->arguments = array_merge($this->arguments, $values);
        return $this;
    }