Class Illuminate\Database\Query\Builder

`implements`	`Builder`
`uses`	`BuildsWhereDateClauses, BuildsQueries, ExplainsQueries, ForwardsCalls, Macroable`


					
	public

__construct(ConnectionInterface $connection, ?Grammar $grammar = null, ?Processor $processor = null): void

Create a new query builder instance.

Overriden by

Illuminate\Database\Query\JoinClause::__construct()

#


					
	public

select(array|mixed $columns = ['*']): $this

Set the columns to be selected.

#


					
	public

selectSub(Closure|Builder|Builder<*>|string $query, string $as): $this

Add a subselect expression to the query.

Throws

InvalidArgumentException

#


					
	public

selectRaw(string $expression, array $bindings = []): $this

Add a new "raw" select expression to the query.

#


					
	public

fromSub(Closure|Builder|Builder<*>|string $query, string $as): $this

Makes "from" fetch from a subquery.

Throws

InvalidArgumentException

#


					
	public

fromRaw(string $expression, mixed $bindings = []): $this

Add a raw from clause to the query.

#


					
	protected

createSub(Closure|Builder|Builder<*>|string $query): array

Creates a subquery and parse it.

#


					
	protected

parseSub(mixed $query): array

Parse the subquery into SQL and bindings.

Throws

InvalidArgumentException

#


					
	protected

prependDatabaseNameIfCrossDatabaseQuery(mixed $query): mixed

Prepend the database name if the given query is on another database.

#


					
	public

addSelect(array|mixed $column): $this

Add a new select column to the query.

#


					
	public

distinct(): $this

Force the query to only return distinct results.

#


					
	public

Set the table which the query is targeting.

#


					
	public

useIndex(string $index): $this

Add an index hint to suggest a query index.

#


					
	public

forceIndex(string $index): $this

Add an index hint to force a query index.

#


					
	public

ignoreIndex(string $index): $this

Add an index hint to ignore a query index.

#


					
	public

join(
	Expression|string $table,
	Closure|Expression|string $first,
	string|null $operator = null,
	Expression|string|null $second = null,
	string $type = 'inner',
	bool $where = false,
): $this

Add a join clause to the query.

#


					
	public

joinWhere(
	Expression|string $table,
	Closure|Expression|string $first,
	string $operator,
	Expression|string $second,
	string $type = 'inner',
): $this

Add a "join where" clause to the query.

#


					
	public

joinSub(
	Closure|Builder|Builder<*>|string $query,
	string $as,
	Closure|Expression|string $first,
	string|null $operator = null,
	Expression|string|null $second = null,
	string $type = 'inner',
	bool $where = false,
): $this

Add a subquery join clause to the query.

Throws

InvalidArgumentException

#


					
	public

joinLateral(Closure|Builder|Builder<*>|string $query, string $as, string $type = 'inner'): $this

Add a lateral join clause to the query.

#


					
	public

leftJoinLateral(Closure|Builder|Builder<*>|string $query, string $as): $this

Add a lateral left join to the query.

#


					
	public

leftJoin(
	Expression|string $table,
	Closure|Expression|string $first,
	string|null $operator = null,
	Expression|string|null $second = null,
): $this

Add a left join to the query.

#


					
	public

leftJoinWhere(
	Expression|string $table,
	Closure|Expression|string $first,
	string $operator,
	Expression|string|null $second,
): $this

Add a "join where" clause to the query.

#


					
	public

leftJoinSub(
	Closure|Builder|Builder<*>|string $query,
	string $as,
	Closure|Expression|string $first,
	string|null $operator = null,
	Expression|string|null $second = null,
): $this

Add a subquery left join to the query.

#


					
	public

rightJoin(
	Expression|string $table,
	Closure|string $first,
	string|null $operator = null,
	Expression|string|null $second = null,
): $this

Add a right join to the query.

#


					
	public

rightJoinWhere(
	Expression|string $table,
	Closure|Expression|string $first,
	string $operator,
	Expression|string $second,
): $this

Add a "right join where" clause to the query.

#


					
	public

rightJoinSub(
	Closure|Builder|Builder<*>|string $query,
	string $as,
	Closure|Expression|string $first,
	string|null $operator = null,
	Expression|string|null $second = null,
): $this

Add a subquery right join to the query.

#


					
	public

crossJoin(
	Expression|string $table,
	Closure|Expression|string|null $first = null,
	string|null $operator = null,
	Expression|string|null $second = null,
): $this

Add a "cross join" clause to the query.

#


					
	public

crossJoinSub(Closure|Builder|Builder<*>|string $query, string $as): $this

Add a subquery cross join to the query.

#


					
	protected

newJoinClause(self $parentQuery, string $type, Expression|string $table): JoinClause

Get a new join clause.

#


					
	protected

newJoinLateralClause(self $parentQuery, string $type, Expression|string $table): JoinLateralClause

Get a new join lateral clause.

#


					
	public

mergeWheres(array $wheres, array $bindings): $this

Merge an array of where clauses and bindings.

#


					
	public

where(
	Closure|string|array|Expression $column,
	mixed $operator = null,
	mixed $value = null,
	string $boolean = 'and',
): $this

Add a basic where clause to the query.

#


					
	protected

addArrayOfWheres(array $column, string $boolean, string $method = 'where'): $this

Add an array of where clauses to the query.

#


					
	public

prepareValueAndOperator(string $value, string $operator, bool $useDefault = false): array

Prepare the value and operator for a where clause.

Throws

InvalidArgumentException

#


					
	protected

invalidOperatorAndValue(string $operator, mixed $value): bool

Determine if the given operator and value combination is legal.

Prevents using Null values with invalid operators.

#


					
	protected

invalidOperator(string $operator): bool

Determine if the given operator is supported.

#


					
	protected

isBitwiseOperator(string $operator): bool

Determine if the operator is a bitwise operator.

#


					
	public

orWhere(Closure|string|array|Expression $column, mixed $operator = null, mixed $value = null): $this

Add an "or where" clause to the query.

#


					
	public

whereNot(
	Closure|string|array|Expression $column,
	mixed $operator = null,
	mixed $value = null,
	string $boolean = 'and',
): $this

Add a basic "where not" clause to the query.

#


					
	public

orWhereNot(Closure|string|array|Expression $column, mixed $operator = null, mixed $value = null): $this

Add an "or where not" clause to the query.

#


					
	public

whereColumn(
	Expression|string|array $first,
	string|null $operator = null,
	string|null $second = null,
	string|null $boolean = 'and',
): $this

Add a "where" clause comparing two columns to the query.

#


					
	public

orWhereColumn(Expression|string|array $first, string|null $operator = null, string|null $second = null): $this

Add an "or where" clause comparing two columns to the query.

#


					
	public

whereRaw(string $sql, mixed $bindings = [], string $boolean = 'and'): $this

Add a raw where clause to the query.

#


					
	public

orWhereRaw(string $sql, mixed $bindings = []): $this

Add a raw or where clause to the query.

#


					
	public

whereLike(
	Expression|string $column,
	string $value,
	bool $caseSensitive = false,
	string $boolean = 'and',
	bool $not = false,
): $this

Add a "where like" clause to the query.

#


					
	public

orWhereLike(Expression|string $column, string $value, bool $caseSensitive = false): $this

Add an "or where like" clause to the query.

#


					
	public

whereNotLike(Expression|string $column, string $value, bool $caseSensitive = false, string $boolean = 'and'): $this

Add a "where not like" clause to the query.

#


					
	public

orWhereNotLike(Expression|string $column, string $value, bool $caseSensitive = false): $this

Add an "or where not like" clause to the query.

#


					
	public

whereIn(Expression|string $column, mixed $values, string $boolean = 'and', bool $not = false): $this

Add a "where in" clause to the query.

#


					
	public

orWhereIn(Expression|string $column, mixed $values): $this

Add an "or where in" clause to the query.

#


					
	public

whereNotIn(Expression|string $column, mixed $values, string $boolean = 'and'): $this

Add a "where not in" clause to the query.

#


					
	public

orWhereNotIn(Expression|string $column, mixed $values): $this

Add an "or where not in" clause to the query.

#


					
	public

whereIntegerInRaw(string $column, Arrayable|array $values, string $boolean = 'and', bool $not = false): $this

Add a "where in raw" clause for integer values to the query.

#


					
	public

orWhereIntegerInRaw(string $column, Arrayable|array $values): $this

Add an "or where in raw" clause for integer values to the query.

#


					
	public

whereIntegerNotInRaw(string $column, Arrayable|array $values, string $boolean = 'and'): $this

Add a "where not in raw" clause for integer values to the query.

#


					
	public

orWhereIntegerNotInRaw(string $column, Arrayable|array $values): $this

Add an "or where not in raw" clause for integer values to the query.

#


					
	public

whereNull(string|array|Expression $columns, string $boolean = 'and', bool $not = false): $this

Add a "where null" clause to the query.

#


					
	public

orWhereNull(string|array|Expression $column): $this

Add an "or where null" clause to the query.

#


					
	public

whereNotNull(string|array|Expression $columns, string $boolean = 'and'): $this

Add a "where not null" clause to the query.

#


					
	public

whereBetween(Expression|string $column, iterable $values, string $boolean = 'and', bool $not = false): $this

Add a where between statement to the query.

#


					
	public

whereBetweenColumns(Expression|string $column, array $values, string $boolean = 'and', bool $not = false): $this

Add a where between statement using columns to the query.

#


					
	public

orWhereBetween(Expression|string $column, iterable $values): $this

Add an or where between statement to the query.

#


					
	public

orWhereBetweenColumns(Expression|string $column, array $values): $this

Add an or where between statement using columns to the query.

#


					
	public

whereNotBetween(Expression|string $column, iterable $values, string $boolean = 'and'): $this

Add a where not between statement to the query.

#


					
	public

whereNotBetweenColumns(Expression|string $column, array $values, string $boolean = 'and'): $this

Add a where not between statement using columns to the query.

#


					
	public

orWhereNotBetween(Expression|string $column, iterable $values): $this

Add an or where not between statement to the query.

#


					
	public

orWhereNotBetweenColumns(Expression|string $column, array $values): $this

Add an or where not between statement using columns to the query.

#


					
	public

orWhereNotNull(Expression|string $column): $this

Add an "or where not null" clause to the query.

#


					
	public

whereDate(
	Expression|string $column,
	DateTimeInterface|string|null $operator,
	DateTimeInterface|string|null $value = null,
	string $boolean = 'and',
): $this

Add a "where date" statement to the query.

#


					
	public

orWhereDate(
	Expression|string $column,
	DateTimeInterface|string|null $operator,
	DateTimeInterface|string|null $value = null,
): $this

Add an "or where date" statement to the query.

#


					
	public

whereTime(
	Expression|string $column,
	DateTimeInterface|string|null $operator,
	DateTimeInterface|string|null $value = null,
	string $boolean = 'and',
): $this

Add a "where time" statement to the query.

#


					
	public

orWhereTime(
	Expression|string $column,
	DateTimeInterface|string|null $operator,
	DateTimeInterface|string|null $value = null,
): $this

Add an "or where time" statement to the query.

#


					
	public

whereDay(
	Expression|string $column,
	DateTimeInterface|string|int|null $operator,
	DateTimeInterface|string|int|null $value = null,
	string $boolean = 'and',
): $this

Add a "where day" statement to the query.

#


					
	public

orWhereDay(
	Expression|string $column,
	DateTimeInterface|string|int|null $operator,
	DateTimeInterface|string|int|null $value = null,
): $this

Add an "or where day" statement to the query.

#


					
	public

whereMonth(
	Expression|string $column,
	DateTimeInterface|string|int|null $operator,
	DateTimeInterface|string|int|null $value = null,
	string $boolean = 'and',
): $this

Add a "where month" statement to the query.

#


					
	public

orWhereMonth(
	Expression|string $column,
	DateTimeInterface|string|int|null $operator,
	DateTimeInterface|string|int|null $value = null,
): $this

Add an "or where month" statement to the query.

#


					
	public

whereYear(
	Expression|string $column,
	DateTimeInterface|string|int|null $operator,
	DateTimeInterface|string|int|null $value = null,
	string $boolean = 'and',
): $this

Add a "where year" statement to the query.

#


					
	public

orWhereYear(
	Expression|string $column,
	DateTimeInterface|string|int|null $operator,
	DateTimeInterface|string|int|null $value = null,
): $this

Add an "or where year" statement to the query.

#


					
	protected

addDateBasedWhere(
	string $type,
	Expression|string $column,
	string $operator,
	mixed $value,
	string $boolean = 'and',
): $this

Add a date based (year, month, day, time) statement to the query.

#


					
	public

whereNested(Closure $callback, string $boolean = 'and'): $this

Add a nested where statement to the query.

#


					
	public

forNestedWhere(): Builder

Create a new query instance for nested where condition.

#


					
	public

addNestedWhereQuery(Builder $query, string $boolean = 'and'): $this

Add another query builder as a nested where to the query builder.

#


					
	protected

whereSub(Expression|string $column, string $operator, Closure|Builder|Builder<*> $callback, string $boolean): $this

Add a full sub-select to the query.

#


					
	public

whereExists(Closure|Builder|Builder<*> $callback, string $boolean = 'and', bool $not = false): $this

Add an exists clause to the query.

#


					
	public

orWhereExists(Closure|Builder|Builder<*> $callback, bool $not = false): $this

Add an or exists clause to the query.

#


					
	public

whereNotExists(Closure|Builder|Builder<*> $callback, string $boolean = 'and'): $this

Add a where not exists clause to the query.

#


					
	public

orWhereNotExists(Closure|Builder|Builder<*> $callback): $this

Add a where not exists clause to the query.

#


					
	public

addWhereExistsQuery(self $query, string $boolean = 'and', bool $not = false): $this

Add an exists clause to the query.

#


					
	public

whereRowValues(array $columns, string $operator, array $values, string $boolean = 'and'): $this

Adds a where condition using row values.

Throws

InvalidArgumentException

#


					
	public

orWhereRowValues(array $columns, string $operator, array $values): $this

Adds an or where condition using row values.

#


					
	public

whereJsonContains(string $column, mixed $value, string $boolean = 'and', bool $not = false): $this

Add a "where JSON contains" clause to the query.

#


					
	public

orWhereJsonContains(string $column, mixed $value): $this

Add an "or where JSON contains" clause to the query.

#


					
	public

whereJsonDoesntContain(string $column, mixed $value, string $boolean = 'and'): $this

Add a "where JSON not contains" clause to the query.

#


					
	public

orWhereJsonDoesntContain(string $column, mixed $value): $this

Add an "or where JSON not contains" clause to the query.

#


					
	public

whereJsonOverlaps(string $column, mixed $value, string $boolean = 'and', bool $not = false): $this

Add a "where JSON overlaps" clause to the query.

#


					
	public

orWhereJsonOverlaps(string $column, mixed $value): $this

Add an "or where JSON overlaps" clause to the query.

#


					
	public

whereJsonDoesntOverlap(string $column, mixed $value, string $boolean = 'and'): $this

Add a "where JSON not overlap" clause to the query.

#


					
	public

orWhereJsonDoesntOverlap(string $column, mixed $value): $this

Add an "or where JSON not overlap" clause to the query.

#


					
	public

whereJsonContainsKey(string $column, string $boolean = 'and', bool $not = false): $this

Add a clause that determines if a JSON path exists to the query.

#


					
	public

orWhereJsonContainsKey(string $column): $this

Add an "or" clause that determines if a JSON path exists to the query.

#


					
	public

whereJsonDoesntContainKey(string $column, string $boolean = 'and'): $this

Add a clause that determines if a JSON path does not exist to the query.

#


					
	public

orWhereJsonDoesntContainKey(string $column): $this

Add an "or" clause that determines if a JSON path does not exist to the query.

#


					
	public

whereJsonLength(string $column, mixed $operator, mixed $value = null, string $boolean = 'and'): $this

Add a "where JSON length" clause to the query.

#


					
	public

orWhereJsonLength(string $column, mixed $operator, mixed $value = null): $this

Add an "or where JSON length" clause to the query.

#


					
	public

dynamicWhere(string $method, array $parameters): $this

Handles dynamic "where" clauses to the query.

#


					
	protected

addDynamic(string $segment, string $connector, array $parameters, int $index): void

Add a single dynamic where clause statement to the query.

#


					
	public

whereFullText(string|string[] $columns, string $value, array $options = [], string $boolean = 'and'): $this

Add a "where fulltext" clause to the query.

#


					
	public

orWhereFullText(string|string[] $columns, string $value, array $options = []): $this

Add a "or where fulltext" clause to the query.

#


					
	public

whereAll(
	Expression[]|Closure[]|string[] $columns,
	mixed $operator = null,
	mixed $value = null,
	string $boolean = 'and',
): $this

Add a "where" clause to the query for multiple columns with "and" conditions between them.

#


					
	public

orWhereAll(Expression[]|Closure[]|string[] $columns, mixed $operator = null, mixed $value = null): $this

Add an "or where" clause to the query for multiple columns with "and" conditions between them.

#


					
	public

whereAny(
	Expression[]|Closure[]|string[] $columns,
	mixed $operator = null,
	mixed $value = null,
	string $boolean = 'and',
): $this

Add a "where" clause to the query for multiple columns with "or" conditions between them.

#


					
	public

orWhereAny(Expression[]|Closure[]|string[] $columns, mixed $operator = null, mixed $value = null): $this

Add an "or where" clause to the query for multiple columns with "or" conditions between them.

#


					
	public

whereNone(
	Expression[]|Closure[]|string[] $columns,
	mixed $operator = null,
	mixed $value = null,
	string $boolean = 'and',
): $this

Add a "where not" clause to the query for multiple columns where none of the conditions should be true.

#


					
	public

orWhereNone(Expression[]|Closure[]|string[] $columns, mixed $operator = null, mixed $value = null): $this

Add an "or where not" clause to the query for multiple columns where none of the conditions should be true.

#


					
	public

groupBy(array|Expression|string ...$groups): $this

Add a "group by" clause to the query.

#


					
	public

groupByRaw(string $sql, array $bindings = []): $this

Add a raw groupBy clause to the query.

#


					
	public

having(
	Expression|Closure|string $column,
	DateTimeInterface|string|int|float|null $operator = null,
	DateTimeInterface|string|int|float|null $value = null,
	string $boolean = 'and',
): $this

Add a "having" clause to the query.

#


					
	public

orHaving(
	Expression|Closure|string $column,
	DateTimeInterface|string|int|float|null $operator = null,
	DateTimeInterface|string|int|float|null $value = null,
): $this

Add an "or having" clause to the query.

#


					
	public

havingNested(Closure $callback, string $boolean = 'and'): $this

Add a nested having statement to the query.

#


					
	public

addNestedHavingQuery(Builder $query, string $boolean = 'and'): $this

Add another query builder as a nested having to the query builder.

#


					
	public

havingNull(array|string $columns, string $boolean = 'and', bool $not = false): $this

Add a "having null" clause to the query.

#


					
	public

orHavingNull(string $column): $this

Add an "or having null" clause to the query.

#


					
	public

havingNotNull(array|string $columns, string $boolean = 'and'): $this

Add a "having not null" clause to the query.

#


					
	public

orHavingNotNull(string $column): $this

Add an "or having not null" clause to the query.

#


					
	public

havingBetween(string $column, iterable $values, string $boolean = 'and', bool $not = false): $this

Add a "having between " clause to the query.

#


					
	public

havingRaw(string $sql, array $bindings = [], string $boolean = 'and'): $this

Add a raw having clause to the query.

#


					
	public

orHavingRaw(string $sql, array $bindings = []): $this

Add a raw or having clause to the query.

#


					
	public

orderBy(Closure|Builder|Builder<*>|Expression|string $column, string $direction = 'asc'): $this

Add an "order by" clause to the query.

Throws

InvalidArgumentException

#


					
	public

orderByDesc(Closure|Builder|Builder<*>|Expression|string $column): $this

Add a descending "order by" clause to the query.

#


					
	public

latest(Closure|Builder|Expression|string $column = 'created_at'): $this

Add an "order by" clause for a timestamp to the query.

#


					
	public

oldest(Closure|Builder|Expression|string $column = 'created_at'): $this

Add an "order by" clause for a timestamp to the query.

#


					
	public

inRandomOrder(string|int $seed = ''): $this

Put the query's results in random order.

#


					
	public

orderByRaw(string $sql, array $bindings = []): $this

Add a raw "order by" clause to the query.

#


					
	public

skip(int $value): $this

Alias to set the "offset" value of the query.

#


					
	public

offset(int $value): $this

Set the "offset" value of the query.

#


					
	public

take(int $value): $this

Alias to set the "limit" value of the query.

#


					
	public

limit(int $value): $this

Set the "limit" value of the query.

#


					
	public

groupLimit(int $value, string $column): $this

Add a "group limit" clause to the query.

#


					
	public

forPage(int $page, int $perPage = 15): $this

Set the limit and offset for a given page.

#


					
	public

forPageBeforeId(int $perPage = 15, int|null $lastId = 0, string $column = 'id'): $this

Constrain the query to the previous "page" of results before a given ID.

#


					
	public

forPageAfterId(int $perPage = 15, int|null $lastId = 0, string $column = 'id'): $this

Constrain the query to the next "page" of results after a given ID.

#


					
	public

reorder(Closure|Builder|Expression|string|null $column = null, string $direction = 'asc'): $this

Remove all existing orders and optionally add a new order.

#


					
	protected

removeExistingOrdersFor(string $column): array

Get an array with all orders with a given column removed.

#


					
	public

union(Closure|Builder|Builder<*> $query, bool $all = false): $this

Add a union statement to the query.

#


					
	public

unionAll(Closure|Builder|Builder<*> $query): $this

Add a union all statement to the query.

#


					
	public

lock(string|bool $value = true): $this

Lock the selected rows in the table.

#


					
	public

lockForUpdate(): $this

Lock the selected rows in the table for updating.

#


					
	public

sharedLock(): $this

Share lock the selected rows in the table.

#


					
	public

beforeQuery(callable $callback): $this

Register a closure to be invoked before the query is executed.

#


					
	public

applyBeforeQueryCallbacks(): void

Invoke the "before query" modification callbacks.

#


					
	public

afterQuery(Closure $callback): $this

Register a closure to be invoked after the query is executed.

#


					
	public

applyAfterQueryCallbacks(mixed $result): mixed

Invoke the "after query" modification callbacks.

#


					
	public

toSql(): string

Get the SQL representation of the query.

#


					
	public

toRawSql(): string

Get the raw SQL representation of the query with embedded bindings.

#


					
	public

find(int|string $id, array|string $columns = ['*']): object|null

Execute a query for a single record by ID.

#


					
	public

findOr<TValue>(
	mixed $id,
	(Closure(): TValue)|list<string>|string $columns = ['*'],
	(Closure(): TValue)|null $callback = null,
): object|TValue

Execute a query for a single record by ID or call a callback.

#


					
	public

value(string $column): mixed

Get a single column's value from the first result of a query.

#


					
	public

rawValue(string $expression, array $bindings = []): mixed

Get a single expression value from the first result of a query.

#


					
	public

soleValue(string $column): mixed

Get a single column's value from the first result of a query if it's the sole matching record.

Throws

`Illuminate\Database\RecordsNotFoundException`
`Illuminate\Database\MultipleRecordsFoundException`

#


					
	public

get(array|string $columns = ['*']): Collection<int, stdClass>

Execute the query as a "select" statement.

#


					
	protected

runSelect(): array

Run the query as a "select" statement against the connection.

#


					
	protected

withoutGroupLimitKeys(Collection $items): Collection

Remove the group limit keys from the results in the collection.

#


					
	public

paginate(
	int|Closure $perPage = 15,
	array|string $columns = ['*'],
	string $pageName = 'page',
	int|null $page = null,
	Closure|int|null $total = null,
): LengthAwarePaginator

Paginate the given query into a simple paginator.

#


					
	public

simplePaginate(
	int $perPage = 15,
	array|string $columns = ['*'],
	string $pageName = 'page',
	int|null $page = null,
): Paginator

Get a paginator only supporting simple next and previous links.

This is more efficient on larger data-sets, etc.

#


					
	public

cursorPaginate(
	int|null $perPage = 15,
	array|string $columns = ['*'],
	string $cursorName = 'cursor',
	Cursor|string|null $cursor = null,
): CursorPaginator

Get a paginator only supporting simple next and previous links.

This is more efficient on larger data-sets, etc.

#


					
	protected

ensureOrderForCursorPagination(bool $shouldReverse = false): Collection

Ensure the proper order by required for cursor pagination.

#


					
	public

getCountForPagination(array $columns = ['*']): int

Get the count of the total records for the paginator.

#


					
	protected

runPaginationCountQuery(array $columns = ['*']): array

Run a pagination count query.

#


					
	protected

cloneForPaginationCount(): self

Clone the existing query instance for usage in a pagination subquery.

#


					
	protected

withoutSelectAliases(array $columns): array

Remove the column aliases since they will break count queries.

#


					
	public

cursor(): LazyCollection<int, stdClass>

Get a lazy collection for the given query.

#


					
	protected

enforceOrderBy(): void

Throw an exception if the query doesn't have an orderBy clause.

Throws

RuntimeException

#


					
	public

pluck(Expression|string $column, string|null $key = null): Collection<array-key, mixed>

Get a collection instance containing the values of a given column.

#


					
	protected

stripTableForPluck(string $column): string|null

Strip off the table name or alias from a column identifier.

#


					
	protected

pluckFromObjectColumn(array $queryResult, string $column, string $key): Collection

Retrieve column values from rows represented as objects.

#


					
	protected

pluckFromArrayColumn(array $queryResult, string $column, string $key): Collection

Retrieve column values from rows represented as arrays.

#


					
	public

implode(string $column, string $glue = ''): string

Concatenate values of a given column as a string.

#


					
	public

exists(): bool

Determine if any rows exist for the current query.

#


					
	public

doesntExist(): bool

Determine if no rows exist for the current query.

#


					
	public

existsOr(Closure $callback): mixed

Execute the given callback if no rows exist for the current query.

#


					
	public

doesntExistOr(Closure $callback): mixed

Execute the given callback if rows exist for the current query.

#


					
	public

count(Expression|string $columns = '*'): int

Retrieve the "count" result of the query.

#


					
	public

min(Expression|string $column): mixed

Retrieve the minimum value of a given column.

#


					
	public

max(Expression|string $column): mixed

Retrieve the maximum value of a given column.

#


					
	public

sum(Expression|string $column): mixed

Retrieve the sum of the values of a given column.

#


					
	public

avg(Expression|string $column): mixed

Retrieve the average of the values of a given column.

#


					
	public

average(Expression|string $column): mixed

Alias for the "avg" method.

#


					
	public

aggregate(string $function, array $columns = ['*']): mixed

Execute an aggregate function on the database.

#


					
	public

numericAggregate(string $function, array $columns = ['*']): float|int

Execute a numeric aggregate function on the database.

#


					
	protected

setAggregate(string $function, array $columns): $this

Set the aggregate property without running the query.

#


					
	protected

onceWithColumns(array $columns, callable $callback): mixed

Execute the given callback while selecting the given columns.

After running the callback, the columns are reset to the original value.

#


					
	public

insert(array $values): bool

Insert new records into the database.

#


					
	public

insertOrIgnore(array $values): int

Insert new records into the database while ignoring errors.

#


					
	public

insertGetId(array $values, string|null $sequence = null): int

Insert a new record and get the value of the primary key.

#


					
	public

insertUsing(array $columns, Closure|Builder|Builder<*>|string $query): int

Insert new records into the table using a subquery.

#


					
	public

insertOrIgnoreUsing(array $columns, Closure|Builder|Builder<*>|string $query): int

Insert new records into the table using a subquery while ignoring errors.

#


					
	public

update(array $values): int

Update records in the database.

#


					
	public

updateFrom(array $values): int

Update records in a PostgreSQL database using the update from syntax.

#


					
	public

updateOrInsert(array $attributes, array|callable $values = []): bool

Insert or update a record matching the attributes, and fill it with values.

#


					
	public

upsert(array $values, array|string $uniqueBy, array|null $update = null): int

Insert new records or update the existing ones.

#


					
	public

increment(string $column, float|int $amount = 1, array $extra = []): int

Increment a column's value by a given amount.

Throws

InvalidArgumentException

#


					
	public

incrementEach(array<string, float|int|numeric-string> $columns, array<string, mixed> $extra = []): int

Increment the given column's values by the given amounts.

Throws

InvalidArgumentException

#


					
	public

decrement(string $column, float|int $amount = 1, array $extra = []): int

Decrement a column's value by a given amount.

Throws

InvalidArgumentException

#


					
	public

decrementEach(array<string, float|int|numeric-string> $columns, array<string, mixed> $extra = []): int

Decrement the given column's values by the given amounts.

Throws

InvalidArgumentException

#


					
	public

delete(mixed $id = null): int

Delete records from the database.

#


					
	public

truncate(): void

Run a truncate statement on the table.

#


					
	public

newQuery(): Builder

Get a new instance of the query builder.

Overriden by

Illuminate\Database\Query\JoinClause::newQuery()

#


					
	protected

forSubQuery(): Builder

Create a new query instance for a sub-query.

Overriden by

Illuminate\Database\Query\JoinClause::forSubQuery()

#


					
	public

getColumns(): array

Get all of the query builder's columns in a text-only array with all expressions evaluated.

#


					
	public

raw(mixed $value): Expression

Create a raw database expression.

#


					
	protected

getUnionBuilders(): Collection

Get the query builder instances that are used in the union of the query.

#


					
	public

getLimit(): mixed

Get the "limit" value for the query or null if it's not set.

#


					
	public

getOffset(): mixed

Get the "offset" value for the query or null if it's not set.

#


					
	public

getBindings(): array

Get the current query value bindings in a flattened array.

#


					
	public

getRawBindings(): array

Get the raw array of bindings.

#


					
	public

setBindings(array $bindings, string $type = 'where'): $this

Set the bindings on the query builder.

Throws

InvalidArgumentException

#


					
	public

addBinding(mixed $value, string $type = 'where'): $this

Add a binding to the query.

Throws

InvalidArgumentException

#


					
	public

castBinding(mixed $value): mixed

Cast the given binding value.

#


					
	public

mergeBindings(self $query): $this

Merge an array of bindings into our bindings.

#


					
	public

cleanBindings(array $bindings): array

Remove all of the expressions from a list of bindings.

#


					
	protected

flattenValue(mixed $value): mixed

Get a scalar type value from an unknown type of input.

#


					
	protected

defaultKeyName(): string

Get the default key name of the table.

#


					
	public

getConnection(): ConnectionInterface

Get the database connection instance.

#


					
	public

getProcessor(): Processor

Get the database query processor instance.

#


					
	public

getGrammar(): Grammar

Get the query grammar instance.

#


					
	public

useWritePdo(): $this

Use the "write" PDO connection when executing the query.

#


					
	protected

isQueryable(mixed $value): bool

Determine if the value is a query builder instance or a Closure.

#


					
	public

clone(): static

Clone the query.

#


					
	public

cloneWithout(array $properties): static

Clone the query without the given properties.

#


					
	public

cloneWithoutBindings(array $except): static

Clone the query without the given bindings.

#


					
	public

dump(mixed ...$args): $this

Dump the current SQL and bindings.

#


					
	public

dumpRawSql(): $this

Dump the raw current SQL with embedded bindings.

#


					
	public

dd(): never

Die and dump the current SQL and bindings.

#


					
	public

ddRawSql(): never

Die and dump the current SQL with embedded bindings.

#


					
	public

__call(string $method, array $parameters): mixed

Handle dynamic method calls into the method.

Throws

BadMethodCallException

#

Properties
`public`	`ConnectionInterface`	`$connection`	#
`public`	`Grammar`	`$grammar`	#
`public`	`Processor`	`$processor`	#
`public`	`array`	`$bindings = [ 'select' => [], 'from' => [], 'join' => [], 'where' => [], 'groupBy' => [], 'having' => [], 'order' => [], 'union' => [], 'unionOrder' => [], ]`	#
`public`	`array\|null`	`$aggregate`	#
`public`	`array\|null`	`$columns`	#
`public`	`bool\|array`	`$distinct = false`	#
`public`	`Expression\|string`	`$from`	#
`public`	`IndexHint\|null`	`$indexHint`	#
`public`	`array\|null`	`$joins`	#
`public`	`array`	`$wheres = []`	#
`public`	`array\|null`	`$groups`	#
`public`	`array\|null`	`$havings`	#
`public`	`array\|null`	`$orders`	#
`public`	`int\|null`	`$limit`	#
`public`	`array\|null`	`$groupLimit`	#
`public`	`int\|null`	`$offset`	#
`public`	`array\|null`	`$unions`	#
`public`	`int\|null`	`$unionLimit`	#
`public`	`int\|null`	`$unionOffset`	#
`public`	`array\|null`	`$unionOrders`	#
`public`	`string\|bool\|null`	`$lock`	#
`public`	`array`	`$beforeQueryCallbacks = []`	#
`protected`	`array`	`$afterQueryCallbacks = []`	#
`public`	`string[]`	`$operators = [ '=', '<', '>', '<=', '>=', '<>', '!=', '<=>', 'like', 'like binary', 'not like', 'ilike', '&', '\|', '^', '<<', '>>', '&~', 'is', 'is not', 'rlike', 'not rlike', 'regexp', 'not regexp', '~', '~', '!~', '!~', 'similar to', 'not similar to', 'not ilike', '~~', '!~~', ]`	#
`public`	`string[]`	`$bitwiseOperators = ['&', '\|', '^', '<<', '>>', '&~']`	#
`public`	`bool`	`$useWritePdo = false`	#

Namespaces

Classes

Class Illuminate\Database\Query\Builder

Overriden by

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Overriden by

Overriden by

Throws

Throws

Throws