db

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 17, 2026 License: MIT Imports: 21 Imported by: 0

Documentation

Overview

Package db is a fluent SQL query builder for Go. It builds SQL and bind arguments and, optionally, runs them through database/sql. It is not an ORM: there are no models, relations, hooks or migrations.

Build only (set the dialect first, then chain from Select, Insert, Update or Delete): 

sql, args, err := db.Use(db.Postgres).Select().From("users").
	Where("votes", ">", 100).
	OrderByDesc("created_at").
	Limit(10).
	ToSQL()

Build and execute: 

conn := db.New(sqlDB, db.Postgres)
var users []User
err := conn.Select().From("users").Where("active", true).Get(ctx, &users)

Typed reads take the table from the row type's TableName method (writes use the Insert, Update and Delete builders): 

users, err := db.From[User](conn).Where("active", true).Get(ctx)

Values are always sent as bind arguments. Identifiers are always quoted. The *Raw methods and Raw expressions take caller-trusted SQL: never build them from user input.

Index

Constants

This section is empty.

Variables

View Source 
var (
	// ErrNotFound is returned by First/Find/Sole/Value when no row matches.
	// It is sql.ErrNoRows, so errors.Is(err, sql.ErrNoRows) also works.
	ErrNotFound = sql.ErrNoRows
	// ErrMultipleRecords is returned by Sole when more than one row matches.
	ErrMultipleRecords = errors.New("quill: multiple records found")
	// ErrNoOrder is returned by Chunk when the query has no ORDER BY.
	ErrNoOrder = errors.New("quill: chunking requires an order by clause")
	// ErrNotBound is returned when running a query on a DB that has no connection,
	// such as one from Use. Create the DB with New(conn, dialect) to execute queries.
	ErrNotBound = errors.New("quill: no database connection; create the DB with db.New(conn, dialect) to run queries")
	// ErrNoTransaction is returned by Transaction when the connection cannot begin one.
	ErrNoTransaction = errors.New("quill: connection cannot begin transactions")
)
View Source 
var (
	// ErrUnknownDialect is returned when the Dialect is not one of the supported values.
	ErrUnknownDialect = errors.New("quill: unknown dialect")
	// ErrInvalidOperator is returned for a comparison operator outside the allow-list.
	ErrInvalidOperator = errors.New("quill: invalid operator")
	// ErrInvalidDirection is returned when an order direction is not "asc" or "desc".
	ErrInvalidDirection = errors.New("quill: order direction must be asc or desc")
	// ErrNoTable is returned when a query is built without a table or subquery source.
	ErrNoTable = errors.New("quill: no table specified")
	// ErrInvalidArgs is returned for arguments the library cannot use, such as a wrong
	// argument count, a non-struct passed to a struct write or a malformed cursor.
	ErrInvalidArgs = errs.ErrInvalidArgs
	// ErrUnsupported is returned when the dialect cannot express the feature, instead of
	// emitting SQL that behaves differently.
	ErrUnsupported = errors.New("quill: not supported by this dialect")
	// ErrJoinNeedsOn is returned for a join (other than a cross join) without an ON condition.
	ErrJoinNeedsOn = errors.New("quill: join requires an ON condition")
	// ErrNoValues is returned by a write that has no values to write.
	ErrNoValues = errors.New("quill: no values to write")
	// ErrNoWhere is returned by UpdateBuilder and DeleteBuilder without a WHERE or LIMIT
	// unless AllRows was called.
	ErrNoWhere = errors.New("quill: update/delete without a where clause; call AllRows() to confirm")
)

Sentinel errors returned by the builder. Match them with errors.Is: most are wrapped with a message that names the offending argument.

Functions

func PluckAs 

func PluckAs[V any](ctx context.Context, b *SelectBuilder, column string) ([]V, error)

PluckAs returns one column of every row as []V.

Example: 

ids, err := db.PluckAs[int64](ctx, conn.Select().From("users").OrderBy("id"), "id")
// SELECT "id" FROM "users" ORDER BY "id" ASC   args: []
// ids: [1 2]

func Row 

func Row(v any) (map[string]any, error)

Row converts a struct (or non-nil pointer to one) into a column map for the write methods, using the same `db` tags as scanning: 

`db:"name"`         column name (default: snake_case of the field name)
`db:"name,omitempty"` skipped while the field holds its zero value
`db:"-"`            never written

Embedded structs are flattened and unexported fields are ignored. Fields behind a nil embedded pointer are treated like omitted zero values. Values are passed through untouched, so pointers (nil -> NULL), sql.Null* types and Raw expressions all work. A field that is omitted for being zero cannot be set to its zero value through a struct: use a pointer field or a map for that.

Example: 

type Post struct {
	ID    int64  `db:"id,omitempty"`
	Title string `db:"title"`
	Notes string `db:"-"`
}
row, err := db.Row(Post{Title: "Hello", Notes: "internal"})
// row = map[title:Hello]   (zero ID omitted, Notes never written)

func Stream 

func Stream[T any](ctx context.Context, s *SelectBuilder) iter.Seq2[T, error]

Stream yields each row as T (struct, map[string]any or scalar) while holding one row in memory. Stop early by breaking out of the loop; the cursor is then closed. An error ends the sequence after being yielded once.

Example: 

q := conn.Select().From("users").OrderBy("id")
for u, err := range db.Stream[User](ctx, q) {
	if err != nil {
		break
	}
	fmt.Println(u.ID, u.Name)
}
// SELECT * FROM "users" ORDER BY "id" ASC
// scalar rows: db.Stream[string](ctx, conn.Select().From("users").Select("name"))

func TableName 

func TableName[T any]() (string, error)

TableName returns T's table from its TableName method. T may be a pointer type. It returns ErrInvalidArgs when T has no TableName method or it returns "".

Example: 

type Order struct{ ID int64 }
func (Order) TableName() string { return "orders" }

name, err := db.TableName[Order]()   // name = "orders"
_, err = db.TableName[struct{}]()    // err wraps ErrInvalidArgs (no TableName method)

func ValueAs 

func ValueAs[V any](ctx context.Context, b *SelectBuilder, column string) (V, error)

ValueAs returns one column of the first row as V (the zero value for NULL), or ErrNotFound.

Example: 

name, err := db.ValueAs[string](ctx, conn.Select().From("users").Where("id", 1), "name")
// SELECT "name" FROM "users" WHERE "id" = $1 LIMIT 1   args: [1]
// name: ann

Types

type CTEOption added in v0.2.0 

type CTEOption func(*cteClause)

CTEOption tunes a common table expression added with With, WithRaw or WithRecursive.

func CTEColumns added in v0.2.0 

func CTEColumns(cols ...string) CTEOption

CTEColumns names the columns of the CTE: "with name (a, b) as (...)".

Example: 

conn.Select().From("a").With("a", conn.Select("id", "name").From("users"), db.CTEColumns("uid", "uname"))
// WITH "a" ("uid", "uname") AS (SELECT "id", "name" FROM "users") SELECT * FROM "a"

func CTEMaterialized added in v0.2.0 

func CTEMaterialized() CTEOption

CTEMaterialized adds "as materialized": the CTE is computed once and reused. PostgreSQL 12+ and SQLite 3.35+; MySQL and MariaDB return ErrUnsupported. It cannot be combined with CTENotMaterialized.

Example: 

recent := conn.Select().From("orders").Where("total", ">", 100)
conn.Select().From("recent").With("recent", recent, db.CTEMaterialized())
// WITH "recent" AS MATERIALIZED (SELECT * FROM "orders" WHERE "total" > $1) SELECT * FROM
//     "recent"
// args: [100]

func CTENotMaterialized added in v0.2.0 

func CTENotMaterialized() CTEOption

CTENotMaterialized adds "as not materialized": the CTE may be inlined into the outer query. PostgreSQL 12+ and SQLite 3.35+; MySQL and MariaDB return ErrUnsupported. It cannot be combined with CTEMaterialized.

Example: 

recent := conn.Select().From("orders").Where("total", ">", 100)
conn.Select().From("recent").With("recent", recent, db.CTENotMaterialized())
// WITH "recent" AS NOT MATERIALIZED (SELECT * FROM "orders" WHERE "total" > $1) SELECT *
//     FROM "recent"
// args: [100]

func CTEUnionDistinct added in v0.2.0 

func CTEUnionDistinct() CTEOption

CTEUnionDistinct joins the anchor and the recursive member of WithRecursive with UNION (dropping duplicate rows) instead of UNION ALL.

Example: 

conn.Select().From("tree").WithRecursive("tree", anchor, step, db.CTEUnionDistinct())
// WITH RECURSIVE "tree" AS (<anchor> UNION <step>) SELECT * FROM "tree"

type Conn 

type Conn interface {
	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
}

Conn is the subset of *sql.DB, *sql.Tx and *sql.Conn the executor needs.

Example: 

sqlDB, err := sql.Open("pgx", dsn) // *sql.DB, *sql.Tx and *sql.Conn all satisfy Conn
conn := db.New(sqlDB, db.Postgres)

type CursorOptions 

type CursorOptions struct {
	Column string
	Desc   bool
}

CursorOptions selects the keyset column. Column must be unique and ordered (default "id"); ties would skip or repeat rows.

Example: 

opt := db.CursorOptions{Column: "id", Desc: true}
p, err := conn.Select().From("orders").CursorPaginate(ctx, 5, "", &orders, opt)
// SELECT * FROM "orders" ORDER BY "id" DESC LIMIT 6

type CursorPage 

type CursorPage struct {
	PerPage    int
	HasMore    bool
	NextCursor string // pass to the next CursorPaginate call; empty when !HasMore
}

CursorPage is a keyset pagination result.

Example: 

var users []User
p, err := conn.Select().From("users").CursorPaginate(ctx, 10, "", &users)
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 11
// p.HasMore = false and p.NextCursor = "" when 10 or fewer rows remain

type CursorPaged 

type CursorPaged[T any] struct {
	CursorPage
	Items []T
}

CursorPaged is a keyset page with its rows.

type DB 

type DB struct {
	// contains filtered or unexported fields
}

DB executes statements against a connection. It is safe for concurrent use when the underlying Conn is (as *sql.DB is); a DB made by Transaction is not.

Example: 

conn := db.New(sqlDB, db.Postgres)
n, err := conn.Select().From("users").Count(ctx)

func New 

func New(conn Conn, d Dialect, opts ...Option) *DB

New wraps conn (*sql.DB, *sql.Tx, *sql.Conn or any Conn) for the given dialect.

Example: 

conn := db.New(sqlDB, db.Postgres, db.WithPrefix("app_")) // sqlDB is a *sql.DB
n, err := conn.Select().From("users").Count(ctx)
// SELECT COUNT(*) AS "aggregate" FROM "app_users"

func Use 

func Use(d Dialect, opts ...Option) *DB

Use starts a connection-less DB for building SQL: set the dialect first, then chain from Select, Insert, Update or Delete: 

sql, args, err := db.Use(db.Postgres).Select().From("users").Where("id", 7).ToSQL()

The same options as New apply (WithPrefix). Running a query on it returns ErrNotBound; create the DB with New to execute.

func (*DB) Delete added in v0.2.0 

func (db *DB) Delete(table string) *DeleteBuilder

Delete starts a DELETE builder for table.

Example: 

sqlText, args, err := conn.Delete("users").Where("id", 7).ToSQL()
// DELETE FROM "users" WHERE "id" = $1   args: [7]

func (*DB) Dialect 

func (db *DB) Dialect() Dialect

Dialect returns the dialect this DB compiles for.

Example: 

conn := db.Use(db.MySQL)
conn.Dialect() == db.MySQL // true

func (*DB) Exec 

func (db *DB) Exec(ctx context.Context, sqlText string, args ...any) (int64, error)

Exec runs a raw statement and returns the rows affected.

Example: 

n, err := conn.Exec(ctx, "UPDATE users SET active = $1 WHERE id < $2", false, 4)
// n = 3 rows affected

func (*DB) Insert added in v0.2.0 

func (db *DB) Insert(table string) *InsertBuilder

Insert starts an INSERT builder for table.

Example: 

sqlText, args, err := conn.Insert("users").Values(map[string]any{"name": "Ann"}).ToSQL()
// INSERT INTO "users" ("name") VALUES ($1)   args: [Ann]

func (*DB) Query 

func (db *DB) Query(ctx context.Context, dest any, sqlText string, args ...any) error

Query runs raw SQL (use the dialect's placeholders) and scans every row into dest, a pointer to a slice of structs, maps or scalars.

Example: 

var users []User
err := conn.Query(ctx, &users, "SELECT id, name FROM users WHERE id = $1", 1)
// sends the text as given with args: [1]; users = [{1 ann}]

func (*DB) Select added in v0.2.0 

func (db *DB) Select(columns ...string) *SelectBuilder

Select starts a SELECT builder; columns are optional (default *).

Example: 

sqlText, args, err := conn.Select("id", "name").From("users").Where("id", 7).ToSQL()
// SELECT "id", "name" FROM "users" WHERE "id" = $1   args: [7]

func (*DB) Transaction 

func (db *DB) Transaction(ctx context.Context, fn func(tx *DB) error) error

Transaction runs fn in a transaction: commit on nil, rollback on error or panic (the panic is re-raised). Inside an existing transaction it uses a savepoint.

Example: 

err := conn.Transaction(ctx, func(tx *db.DB) error {
	_, err := tx.Exec(ctx, "UPDATE accounts SET balance = balance - $1 WHERE id = $2", 50, 1)
	return err // nil commits, an error rolls back
})
// BEGIN, UPDATE ..., COMMIT
// nested call on tx: SAVEPOINT sp_1 ... RELEASE SAVEPOINT sp_1

func (*DB) TransactionOpts 

func (db *DB) TransactionOpts(ctx context.Context, opts *sql.TxOptions, fn func(tx *DB) error) (err error)

TransactionOpts is Transaction with sql.TxOptions (isolation level, read-only). opts is ignored for nested savepoints.

Example: 

opts := &sql.TxOptions{Isolation: sql.LevelSerializable, ReadOnly: true}
err := conn.TransactionOpts(ctx, opts, func(tx *db.DB) error {
	_, err := tx.Select().From("users").Count(ctx)
	return err
})

func (*DB) Truncate added in v0.2.0 

func (db *DB) Truncate(ctx context.Context, table string) error

Truncate empties a table and resets its auto-increment counter. On SQLite this runs as DELETE plus a sqlite_sequence reset inside a transaction.

Example: 

err := conn.Truncate(ctx, "sessions")
// Postgres: TRUNCATE "sessions" RESTART IDENTITY   MySQL: TRUNCATE TABLE `sessions`

func (*DB) TruncateSQL added in v0.2.0 

func (db *DB) TruncateSQL(table string) ([]Stmt, error)

TruncateSQL builds the statements Truncate runs, in order.

Example: 

stmts, err := conn.TruncateSQL("sessions")
// Postgres: [TRUNCATE "sessions" RESTART IDENTITY]

func (*DB) Update added in v0.2.0 

func (db *DB) Update(table string) *UpdateBuilder

Update starts an UPDATE builder for table.

Example: 

sqlText, args, err := conn.Update("users").Set("name", "Ann").Where("id", 7).ToSQL()
// UPDATE "users" SET "name" = $1 WHERE "id" = $2   args: [Ann 7]

func (*DB) UpdateOrInsert added in v0.2.0 

func (db *DB) UpdateOrInsert(ctx context.Context, table string, attributes, values map[string]any) (bool, error)

UpdateOrInsert updates the first row matching attributes with values, or inserts attributes merged with values when none matches. It reports whether the write succeeded.

Example: 

ok, err := conn.UpdateOrInsert(ctx, "users",
	map[string]any{"email": "ann@example.com"}, map[string]any{"name": "Ann"})
// SELECT EXISTS(SELECT * FROM "users" WHERE "email" = $1)
// then UPDATE "users" SET "name" = $1 WHERE "email" = $2 (LIMIT 1), or INSERT when absent

type DeleteBuilder added in v0.2.0 

type DeleteBuilder struct {
	// contains filtered or unexported fields
}

DeleteBuilder is a mutable DELETE statement. Start one with DB.Delete, narrow it with Where, and finish with Exec, Get or ToSQL. Without a WHERE or LIMIT it refuses to build (ErrNoWhere) unless AllRows was called. Not safe for concurrent use.

func (*DeleteBuilder) AllRows added in v0.2.0 

func (d *DeleteBuilder) AllRows() *DeleteBuilder

AllRows confirms that an update/delete without a where clause is intended. Without it, an UpdateBuilder or DeleteBuilder refuses to build (ErrNoWhere).

Example: 

conn.Delete("sessions").AllRows().ToSQL()
// DELETE FROM "sessions"   args: []

func (*DeleteBuilder) Clone added in v0.2.0 

func (d *DeleteBuilder) Clone() *DeleteBuilder

Clone returns an independent copy. Cloning a nil *DeleteBuilder returns nil.

Example: 

base := conn.Delete("sessions").Where("expired", true)
old := base.Clone().Where("created_at", "<", cutoff)

func (*DeleteBuilder) CrossJoin added in v0.2.0 

func (d *DeleteBuilder) CrossJoin(table string) *DeleteBuilder

CrossJoin adds "CROSS JOIN table".

Example: 

conn.Select().From("users").CrossJoin("roles")
// SELECT * FROM "users" CROSS JOIN "roles"

func (*DeleteBuilder) CrossJoinSub added in v0.2.0 

func (d *DeleteBuilder) CrossJoinSub(sub *SelectBuilder, as string) *DeleteBuilder

CrossJoinSub cross joins a subquery.

Example: 

sub := conn.Select().From("roles").Select("name").Where("active", true)
conn.Select().From("users").CrossJoinSub(sub, "r")
// SELECT * FROM "users" CROSS JOIN (SELECT "name" FROM "roles" WHERE "active" = $1) AS "r"
// args: [true]

func (*DeleteBuilder) Err added in v0.2.0 

func (d *DeleteBuilder) Err() error

Err returns the first error recorded while building.

Example: 

q := conn.Select().From("users").Where("id", "!!", 1)
err := q.Err()
// err: quill: invalid operator: "!!"

func (*DeleteBuilder) Exec added in v0.2.0 

func (d *DeleteBuilder) Exec(ctx context.Context) (int64, error)

Exec runs the delete and returns the rows affected.

Example: 

n, err := conn.Delete("users").Where("id", 7).Exec(ctx)
// DELETE FROM "users" WHERE "id" = $1   args: [7]

func (*DeleteBuilder) Get added in v0.2.0 

func (d *DeleteBuilder) Get(ctx context.Context, dest any) error

Get runs the delete and scans the RETURNING rows into dest. Call Returning first.

Example: 

var gone []User
err := conn.Delete("users").Where("id", 7).Returning("*").Get(ctx, &gone)
// DELETE FROM "users" WHERE "id" = $1 RETURNING *   args: [7]

func (*DeleteBuilder) InRandomOrder added in v0.2.0 

func (d *DeleteBuilder) InRandomOrder(seed ...int) *DeleteBuilder

InRandomOrder orders randomly: RANDOM() on Postgres/SQLite, RAND([seed]) on MySQL.

Example: 

conn.Select().From("posts").InRandomOrder().Limit(5)
// Postgres: SELECT * FROM "posts" ORDER BY RANDOM() LIMIT 5
// MySQL: SELECT * FROM `posts` ORDER BY RAND() LIMIT 5

func (*DeleteBuilder) Join added in v0.2.0 

func (d *DeleteBuilder) Join(table string, first string, args ...any) *DeleteBuilder

Join adds "INNER JOIN table ON first = second" (or "first op second").

Example: 

conn.Select().From("users as u").Join("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*DeleteBuilder) JoinFunc added in v0.2.0 

func (d *DeleteBuilder) JoinFunc(table string, fn func(*JoinClause)) *DeleteBuilder

JoinFunc adds an inner join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.published", true)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."published" = $1
// args: [true]

func (*DeleteBuilder) JoinLateral added in v0.2.0 

func (d *DeleteBuilder) JoinLateral(sub *SelectBuilder, as string) *DeleteBuilder

JoinLateral adds "INNER JOIN LATERAL (subquery) AS alias ON TRUE" (Postgres, MySQL >= 8.0.14).

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").JoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" INNER JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE
// MariaDB returns ErrUnsupported

func (*DeleteBuilder) JoinSub added in v0.2.0 

func (d *DeleteBuilder) JoinSub(sub *SelectBuilder, as string, first string, args ...any) *DeleteBuilder

JoinSub joins a subquery: "INNER JOIN (SELECT ...) AS alias ON ...".

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").JoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*DeleteBuilder) JoinSubFunc added in v0.2.0 

func (d *DeleteBuilder) JoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *DeleteBuilder

JoinSubFunc joins a subquery with a complex ON clause built in fn.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").JoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" > $1
// args: [10]

func (*DeleteBuilder) JoinWhere added in v0.2.0 

func (d *DeleteBuilder) JoinWhere(table string, column string, args ...any) *DeleteBuilder

JoinWhere joins on a bound value: "INNER JOIN t ON col = ?".

Example: 

conn.Select().From("users as u").JoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*DeleteBuilder) Latest added in v0.2.0 

func (d *DeleteBuilder) Latest(column ...string) *DeleteBuilder

Latest orders by column descending (default "created_at").

Example: 

conn.Select().From("posts").Latest("published_at")
// SELECT * FROM "posts" ORDER BY "published_at" DESC

func (*DeleteBuilder) LeftJoin added in v0.2.0 

func (d *DeleteBuilder) LeftJoin(table string, first string, args ...any) *DeleteBuilder

LeftJoin adds a left join.

Example: 

conn.Select().From("users as u").LeftJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*DeleteBuilder) LeftJoinFunc added in v0.2.0 

func (d *DeleteBuilder) LeftJoinFunc(table string, fn func(*JoinClause)) *DeleteBuilder

LeftJoinFunc adds a left join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").LeftJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNull("p.deleted_at")
})
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."deleted_at" IS NULL

func (*DeleteBuilder) LeftJoinLateral added in v0.2.0 

func (d *DeleteBuilder) LeftJoinLateral(sub *SelectBuilder, as string) *DeleteBuilder

LeftJoinLateral is JoinLateral as a left join.

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").LeftJoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" LEFT JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE

func (*DeleteBuilder) LeftJoinSub added in v0.2.0 

func (d *DeleteBuilder) LeftJoinSub(sub *SelectBuilder, as string, first string, args ...any) *DeleteBuilder

LeftJoinSub joins a subquery with a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").LeftJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1) AS
//     "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*DeleteBuilder) LeftJoinSubFunc added in v0.2.0 

func (d *DeleteBuilder) LeftJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *DeleteBuilder

LeftJoinSubFunc is JoinSubFunc as a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").LeftJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNotNull("p.score")
})
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" IS NOT NULL

func (*DeleteBuilder) LeftJoinWhere added in v0.2.0 

func (d *DeleteBuilder) LeftJoinWhere(table string, column string, args ...any) *DeleteBuilder

LeftJoinWhere is JoinWhere as a left join.

Example: 

conn.Select().From("users as u").LeftJoinWhere("posts as p", "p.score", ">", 10)
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."score" > $1
// args: [10]

func (*DeleteBuilder) Limit added in v0.2.0 

func (d *DeleteBuilder) Limit(n int) *DeleteBuilder

Limit sets LIMIT; negative values are ignored.

Example: 

conn.Select().From("users").Limit(10)
// SELECT * FROM "users" LIMIT 10

func (*DeleteBuilder) Oldest added in v0.2.0 

func (d *DeleteBuilder) Oldest(column ...string) *DeleteBuilder

Oldest orders by column ascending (default "created_at").

Example: 

conn.Select().From("posts").Oldest()
// SELECT * FROM "posts" ORDER BY "created_at" ASC

func (*DeleteBuilder) OrWhere added in v0.2.0 

func (d *DeleteBuilder) OrWhere(column string, args ...any) *DeleteBuilder

OrWhere is Where joined with OR.

Example: 

conn.Select().From("users").Where("role", "admin").OrWhere("role", "owner")
// SELECT * FROM "users" WHERE "role" = $1 OR "role" = $2
// args: [admin owner]

func (*DeleteBuilder) OrWhereAll added in v0.2.0 

func (d *DeleteBuilder) OrWhereAll(columns []string, args ...any) *DeleteBuilder

OrWhereAll is WhereAll joined with OR.

Example: 

conn.Select().From("users").WhereAll([]string{"a", "b"}, 1).OrWhereAll([]string{"c", "d"}, ">", 5)
// SELECT * FROM "users" WHERE ("a" = $1 AND "b" = $2) OR ("c" > $3 AND "d" > $4)
//     args: [1 1 5 5]

func (*DeleteBuilder) OrWhereAny added in v0.2.0 

func (d *DeleteBuilder) OrWhereAny(columns []string, args ...any) *DeleteBuilder

OrWhereAny is WhereAny joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereAny([]string{"a", "b"}, ">", 5)
// SELECT * FROM "users" WHERE "active" = $1 OR ("a" > $2 OR "b" > $3)   args: [true 5 5]

func (*DeleteBuilder) OrWhereBetween added in v0.2.0 

func (d *DeleteBuilder) OrWhereBetween(column string, lo any, hi any) *DeleteBuilder

OrWhereBetween is WhereBetween joined with OR.

Example: 

conn.Select().From("orders").Where("status", "paid").OrWhereBetween("total", 500, 900)
// SELECT * FROM "orders" WHERE "status" = $1 OR "total" BETWEEN $2 AND $3
//     args: [paid 500 900]

func (*DeleteBuilder) OrWhereBetweenColumns added in v0.2.0 

func (d *DeleteBuilder) OrWhereBetweenColumns(column string, c1 string, c2 string) *DeleteBuilder

OrWhereBetweenColumns is WhereBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price").
	OrWhereBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price" OR "cost"
//     BETWEEN "low" AND "high"

func (*DeleteBuilder) OrWhereColumn added in v0.2.0 

func (d *DeleteBuilder) OrWhereColumn(first string, args ...any) *DeleteBuilder

OrWhereColumn is WhereColumn joined with OR.

Example: 

conn.Select().From("users").WhereColumn("first_name", "last_name").OrWhereColumn("a", "<>", "b")
// SELECT * FROM "users" WHERE "first_name" = "last_name" OR "a" <> "b"

func (*DeleteBuilder) OrWhereDate added in v0.2.0 

func (d *DeleteBuilder) OrWhereDate(column string, args ...any) *DeleteBuilder

OrWhereDate is WhereDate joined with OR.

Example: 

conn.Select().From("orders").WhereDate("created_at", "2024-01-15").
	OrWhereDate("created_at", "2024-02-01")
// SELECT * FROM "orders" WHERE "created_at"::DATE = $1 OR "created_at"::DATE = $2
//     args: [2024-01-15 2024-02-01]

func (*DeleteBuilder) OrWhereDay added in v0.2.0 

func (d *DeleteBuilder) OrWhereDay(column string, args ...any) *DeleteBuilder

OrWhereDay is WhereDay joined with OR.

Example: 

conn.Select().From("orders").WhereDay("created_at", 15).OrWhereDay("created_at", ">", 20)
// SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1 OR EXTRACT(DAY FROM
//     "created_at") > $2
//     args: [15 20]

func (*DeleteBuilder) OrWhereExists added in v0.2.0 

func (d *DeleteBuilder) OrWhereExists(sub *SelectBuilder) *DeleteBuilder

OrWhereExists is WhereExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*DeleteBuilder) OrWhereGroup added in v0.2.0 

func (d *DeleteBuilder) OrWhereGroup(fn func(*WhereClause)) *DeleteBuilder

OrWhereGroup is WhereGroup joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").Where("age", ">", 30)
})
// SELECT * FROM "users" WHERE "active" = $1 OR ("role" = $2 AND "age" > $3)
//     args: [true admin 30]

func (*DeleteBuilder) OrWhereIn added in v0.2.0 

func (d *DeleteBuilder) OrWhereIn(column string, values any) *DeleteBuilder

OrWhereIn is WhereIn joined with OR.

Example: 

conn.Select().From("users").WhereIn("role", []string{"ann", "bob"}).OrWhereIn("id", []int{9})
// SELECT * FROM "users" WHERE "role" IN ($1, $2) OR "id" IN ($3)   args: [ann bob 9]

func (*DeleteBuilder) OrWhereIntegerInRaw added in v0.2.0 

func (d *DeleteBuilder) OrWhereIntegerInRaw(column string, values any) *DeleteBuilder

OrWhereIntegerInRaw is WhereIntegerInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1}).
	OrWhereIntegerInRaw("id", []int64{7, 8})
// SELECT * FROM "users" WHERE "id" IN (1) OR "id" IN (7, 8)

func (*DeleteBuilder) OrWhereIntegerNotInRaw added in v0.2.0 

func (d *DeleteBuilder) OrWhereIntegerNotInRaw(column string, values any) *DeleteBuilder

OrWhereIntegerNotInRaw is WhereIntegerNotInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2}).
	OrWhereIntegerNotInRaw("id", []int{3})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2) OR "id" NOT IN (3)

func (*DeleteBuilder) OrWhereJsonContains added in v0.2.0 

func (d *DeleteBuilder) OrWhereJsonContains(column string, value any) *DeleteBuilder

OrWhereJsonContains is WhereJsonContains joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR ("options"->'tags')::JSONB @> $2
// args: [true "go"]

func (*DeleteBuilder) OrWhereJsonContainsKey added in v0.2.0 

func (d *DeleteBuilder) OrWhereJsonContainsKey(column string) *DeleteBuilder

OrWhereJsonContainsKey is WhereJsonContainsKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*DeleteBuilder) OrWhereJsonDoesntContain added in v0.2.0 

func (d *DeleteBuilder) OrWhereJsonDoesntContain(column string, value any) *DeleteBuilder

OrWhereJsonDoesntContain is WhereJsonDoesntContain joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("options"->'tags')::JSONB @> $2
// args: [true "php"]

func (*DeleteBuilder) OrWhereJsonDoesntContainKey added in v0.2.0 

func (d *DeleteBuilder) OrWhereJsonDoesntContainKey(column string) *DeleteBuilder

OrWhereJsonDoesntContainKey is WhereJsonDoesntContainKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).
	OrWhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1
//   OR NOT COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*DeleteBuilder) OrWhereJsonDoesntOverlap added in v0.2.0 

func (d *DeleteBuilder) OrWhereJsonDoesntOverlap(column string, value any) *DeleteBuilder

OrWhereJsonDoesntOverlap is WhereJsonDoesntOverlap joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["php"]]

func (*DeleteBuilder) OrWhereJsonLength added in v0.2.0 

func (d *DeleteBuilder) OrWhereJsonLength(column string, args ...any) *DeleteBuilder

OrWhereJsonLength is WhereJsonLength joined with OR.

Example: 

conn.Select().From("users").WhereJsonLength("options->tags", 0)
.OrWhereJsonLength("options->roles", ">=", 3).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   OR JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) >= $2   args: [0 3]

func (*DeleteBuilder) OrWhereJsonOverlaps added in v0.2.0 

func (d *DeleteBuilder) OrWhereJsonOverlaps(column string, value any) *DeleteBuilder

OrWhereJsonOverlaps is WhereJsonOverlaps joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonOverlaps("options->tags", []string{"go"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["go"]]

func (*DeleteBuilder) OrWhereLike added in v0.2.0 

func (d *DeleteBuilder) OrWhereLike(column string, value any, caseSensitive ...bool) *DeleteBuilder

OrWhereLike is WhereLike joined with OR.

Example: 

conn.Select().From("users").WhereLike("name", "an%").OrWhereLike("name", "bo%")
// SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1 OR "name"::TEXT ILIKE $2
//     args: [an% bo%]

func (*DeleteBuilder) OrWhereMap added in v0.2.0 

func (d *DeleteBuilder) OrWhereMap(m map[string]any) *DeleteBuilder

OrWhereMap is WhereMap joined with OR.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"a": 1}).OrWhereMap(map[string]any{"b": 2})
// SELECT * FROM "users" WHERE ("a" = $1) OR ("b" = $2)   args: [1 2]

func (*DeleteBuilder) OrWhereMonth added in v0.2.0 

func (d *DeleteBuilder) OrWhereMonth(column string, args ...any) *DeleteBuilder

OrWhereMonth is WhereMonth joined with OR.

Example: 

conn.Select().From("orders").WhereMonth("created_at", ">=", 6).OrWhereMonth("created_at", 1)
// SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") >= $1 OR EXTRACT(MONTH FROM
//     "created_at") = $2
//     args: [06 01]

func (*DeleteBuilder) OrWhereNone added in v0.2.0 

func (d *DeleteBuilder) OrWhereNone(columns []string, args ...any) *DeleteBuilder

OrWhereNone is WhereNone joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereNone([]string{"a", "b"}, 0)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("a" = $2 OR "b" = $3)
//     args: [true 0 0]

func (*DeleteBuilder) OrWhereNot added in v0.2.0 

func (d *DeleteBuilder) OrWhereNot(column string, args ...any) *DeleteBuilder

OrWhereNot adds "OR NOT <predicate>".

Example: 

conn.Select().From("users").Where("age", ">", 18).OrWhereNot("status", "<", 3)
// SELECT * FROM "users" WHERE "age" > $1 OR NOT "status" < $2   args: [18 3]

func (*DeleteBuilder) OrWhereNotBetween added in v0.2.0 

func (d *DeleteBuilder) OrWhereNotBetween(column string, lo any, hi any) *DeleteBuilder

OrWhereNotBetween is WhereNotBetween joined with OR.

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100).OrWhereNotBetween("qty", 1, 5)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2 OR "qty" NOT BETWEEN $3 AND $4
//     args: [10 100 1 5]

func (*DeleteBuilder) OrWhereNotBetweenColumns added in v0.2.0 

func (d *DeleteBuilder) OrWhereNotBetweenColumns(column string, c1 string, c2 string) *DeleteBuilder

OrWhereNotBetweenColumns is WhereNotBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price").
	OrWhereNotBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price" OR "cost"
//     NOT BETWEEN "low" AND "high"

func (*DeleteBuilder) OrWhereNotExists added in v0.2.0 

func (d *DeleteBuilder) OrWhereNotExists(sub *SelectBuilder) *DeleteBuilder

OrWhereNotExists is WhereNotExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereNotExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*DeleteBuilder) OrWhereNotIn added in v0.2.0 

func (d *DeleteBuilder) OrWhereNotIn(column string, values any) *DeleteBuilder

OrWhereNotIn is WhereNotIn joined with OR.

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2}).OrWhereNotIn("role", []string{"ann"})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2) OR "role" NOT IN ($3)   args: [1 2 ann]

func (*DeleteBuilder) OrWhereNotLike added in v0.2.0 

func (d *DeleteBuilder) OrWhereNotLike(column string, value any, caseSensitive ...bool) *DeleteBuilder

OrWhereNotLike is WhereNotLike joined with OR.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%").OrWhereNotLike("name", "%demo%", true)
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1 OR "name"::TEXT NOT LIKE $2
//     args: [%test% %demo%]

func (*DeleteBuilder) OrWhereNotNull added in v0.2.0 

func (d *DeleteBuilder) OrWhereNotNull(column string) *DeleteBuilder

OrWhereNotNull is WhereNotNull joined with OR.

Example: 

conn.Select().From("users").WhereNotNull("verified_at").OrWhereNotNull("invited_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL OR "invited_at" IS NOT NULL

func (*DeleteBuilder) OrWhereNull added in v0.2.0 

func (d *DeleteBuilder) OrWhereNull(column string) *DeleteBuilder

OrWhereNull is WhereNull joined with OR.

Example: 

conn.Select().From("users").WhereNull("deleted_at").OrWhereNull("banned_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL OR "banned_at" IS NULL

func (*DeleteBuilder) OrWhereNullSafeEquals added in v0.2.0 

func (d *DeleteBuilder) OrWhereNullSafeEquals(column string, value any) *DeleteBuilder

OrWhereNullSafeEquals is WhereNullSafeEquals joined with OR.

Example: 

conn.Select().From("users").WhereNullSafeEquals("a", 1).OrWhereNullSafeEquals("b", 2)
// SELECT * FROM "users" WHERE "a" IS NOT DISTINCT FROM $1 OR "b" IS NOT DISTINCT FROM $2
//     args: [1 2]

func (*DeleteBuilder) OrWhereRaw added in v0.2.0 

func (d *DeleteBuilder) OrWhereRaw(sql string, args ...any) *DeleteBuilder

OrWhereRaw is WhereRaw joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereRaw("age between ? and ?", 18, 30)
// SELECT * FROM "users" WHERE "active" = $1 OR age between $2 and $3
// args: [true 18 30]

func (*DeleteBuilder) OrWhereRowValues added in v0.2.0 

func (d *DeleteBuilder) OrWhereRowValues(columns []string, op string, values []any) *DeleteBuilder

OrWhereRowValues is WhereRowValues joined with OR.

Example: 

conn.Select().From("events").Where("kind", "x").
	OrWhereRowValues([]string{"a", "b"}, "=", []any{1, 2})
// SELECT * FROM "events" WHERE "kind" = $1 OR ("a", "b") = ($2, $3)   args: [x 1 2]

func (*DeleteBuilder) OrWhereTime added in v0.2.0 

func (d *DeleteBuilder) OrWhereTime(column string, args ...any) *DeleteBuilder

OrWhereTime is WhereTime joined with OR.

Example: 

conn.Select().From("orders").WhereTime("created_at", "10:30:00").
	OrWhereTime("created_at", "<", "08:00:00")
// SELECT * FROM "orders" WHERE "created_at"::TIME = $1 OR "created_at"::TIME < $2
//     args: [10:30:00 08:00:00]

func (*DeleteBuilder) OrWhereValueBetween added in v0.2.0 

func (d *DeleteBuilder) OrWhereValueBetween(value any, c1 string, c2 string) *DeleteBuilder

OrWhereValueBetween is WhereValueBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total").
	OrWhereValueBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total" OR $2 BETWEEN "a" AND
//     "b"
//     args: [50 7]

func (*DeleteBuilder) OrWhereValueNotBetween added in v0.2.0 

func (d *DeleteBuilder) OrWhereValueNotBetween(value any, c1 string, c2 string) *DeleteBuilder

OrWhereValueNotBetween is WhereValueNotBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total").
	OrWhereValueNotBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total" OR $2 NOT BETWEEN
//     "a" AND "b"
//     args: [50 7]

func (*DeleteBuilder) OrWhereYear added in v0.2.0 

func (d *DeleteBuilder) OrWhereYear(column string, args ...any) *DeleteBuilder

OrWhereYear is WhereYear joined with OR.

Example: 

conn.Select().From("orders").WhereYear("created_at", ">", 2020).OrWhereYear("created_at", 1999)
// SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") > $1 OR EXTRACT(YEAR FROM
//     "created_at") = $2
//     args: [2020 1999]

func (*DeleteBuilder) OrderBy added in v0.2.0 

func (d *DeleteBuilder) OrderBy(column string, direction ...string) *DeleteBuilder

OrderBy adds ORDER BY column; direction is "asc" (default) or "desc".

Example: 

conn.Select().From("users").OrderBy("name").OrderBy("age", "desc")
// SELECT * FROM "users" ORDER BY "name" ASC, "age" DESC

func (*DeleteBuilder) OrderByDesc added in v0.2.0 

func (d *DeleteBuilder) OrderByDesc(column string) *DeleteBuilder

OrderByDesc is OrderBy(column, "desc").

Example: 

conn.Select().From("users").OrderByDesc("created_at")
// SELECT * FROM "users" ORDER BY "created_at" DESC

func (*DeleteBuilder) OrderByRaw added in v0.2.0 

func (d *DeleteBuilder) OrderByRaw(sql string, args ...any) *DeleteBuilder

OrderByRaw adds a raw ORDER BY expression (caller-trusted SQL).

Example: 

conn.Select().From("users").OrderByRaw("case when role = ? then 0 else 1 end", "admin")
// SELECT * FROM "users" ORDER BY case when role = $1 then 0 else 1 end
// args: [admin]

func (*DeleteBuilder) Prefix added in v0.2.0 

func (d *DeleteBuilder) Prefix(p string) *DeleteBuilder

Prefix sets a table prefix applied to table names, aliases and qualified columns.

Example: 

db.Use(db.Postgres).Select("u.id").From("users as u").Prefix("app_")
// SELECT "app_u"."id" FROM "app_users" AS "app_u"

func (*DeleteBuilder) Reorder added in v0.2.0 

func (d *DeleteBuilder) Reorder() *DeleteBuilder

Reorder removes all existing ORDER BY clauses (including a union's).

Example: 

conn.Select().From("posts").OrderBy("title").Reorder()
// SELECT * FROM "posts"

func (*DeleteBuilder) ReorderBy added in v0.2.0 

func (d *DeleteBuilder) ReorderBy(column string, direction ...string) *DeleteBuilder

ReorderBy is Reorder followed by OrderBy(column, direction).

Example: 

conn.Select().From("posts").OrderBy("title").ReorderBy("id", "desc")
// SELECT * FROM "posts" ORDER BY "id" DESC

func (*DeleteBuilder) Returning added in v0.2.0 

func (d *DeleteBuilder) Returning(columns ...string) *DeleteBuilder

Returning adds a RETURNING clause to insert/update/delete/upsert (Postgres, SQLite >= 3.35; MySQL returns ErrUnsupported). "*" is allowed.

Example: 

conn.Insert("users").Values(map[string]any{"name": "Ann"}).Returning("id", "created_at").ToSQL()
// INSERT INTO "users" ("name") VALUES ($1) RETURNING "id", "created_at"   args: [Ann]
// MySQL: ToSQL returns ErrUnsupported

func (*DeleteBuilder) RightJoin added in v0.2.0 

func (d *DeleteBuilder) RightJoin(table string, first string, args ...any) *DeleteBuilder

RightJoin adds a right join.

Example: 

conn.Select().From("users as u").RightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*DeleteBuilder) RightJoinFunc added in v0.2.0 

func (d *DeleteBuilder) RightJoinFunc(table string, fn func(*JoinClause)) *DeleteBuilder

RightJoinFunc adds a right join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").RightJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."score" > $1
// args: [10]

func (*DeleteBuilder) RightJoinSub added in v0.2.0 

func (d *DeleteBuilder) RightJoinSub(sub *SelectBuilder, as string, first string, args ...any) *DeleteBuilder

RightJoinSub joins a subquery with a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").RightJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*DeleteBuilder) RightJoinSubFunc added in v0.2.0 

func (d *DeleteBuilder) RightJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *DeleteBuilder

RightJoinSubFunc is JoinSubFunc as a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").RightJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id")
})
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id"

func (*DeleteBuilder) RightJoinWhere added in v0.2.0 

func (d *DeleteBuilder) RightJoinWhere(table string, column string, args ...any) *DeleteBuilder

RightJoinWhere is JoinWhere as a right join.

Example: 

conn.Select().From("users as u").RightJoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*DeleteBuilder) StraightJoin added in v0.2.0 

func (d *DeleteBuilder) StraightJoin(table string, first string, args ...any) *DeleteBuilder

StraightJoin adds a MySQL "straight_join"; other dialects error at compile time.

Example: 

connMy.Select().From("users as u").StraightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM `users` AS `u` STRAIGHT_JOIN `posts` AS `p` ON `p`.`user_id` = `u`.`id`
// connMy is db.Use(db.MySQL); other dialects return ErrUnsupported

func (*DeleteBuilder) Take added in v0.2.0 

func (d *DeleteBuilder) Take(n int) *DeleteBuilder

Take is an alias of Limit.

Example: 

conn.Select().From("users").Take(5)
// SELECT * FROM "users" LIMIT 5

func (*DeleteBuilder) ToSQL added in v0.2.0 

func (d *DeleteBuilder) ToSQL() (string, []any, error)

ToSQL compiles the DELETE into SQL text and its ordered bind arguments. Joins use "DELETE alias FROM ... JOIN" on MySQL and a ctid/rowid subquery on Postgres/SQLite.

Example: 

sqlText, args, err := conn.Delete("users").Where("id", 7).ToSQL()
// DELETE FROM "users" WHERE "id" = $1   args: [7]

func (*DeleteBuilder) Where added in v0.2.0 

func (d *DeleteBuilder) Where(column string, args ...any) *DeleteBuilder

Where adds an AND predicate. Forms: Where(col, value) means "="; Where(col, op, value). A nil value with "=" / "!=" / "<>" becomes IS [NOT] NULL.

Example: 

conn.Select().From("users").Where("active", true).Where("age", ">=", 18)
// SELECT * FROM "users" WHERE "active" = $1 AND "age" >= $2
// args: [true 18]

func (*DeleteBuilder) WhereAll added in v0.2.0 

func (d *DeleteBuilder) WhereAll(columns []string, args ...any) *DeleteBuilder

WhereAll requires the predicate to hold for every column: (a = ? and b = ?).

Example: 

conn.Select().From("users").WhereAll([]string{"first_name", "last_name"}, "like", "an%")
// SELECT * FROM "users" WHERE ("first_name"::TEXT LIKE $1 AND "last_name"::TEXT LIKE $2)
//     args: [an% an%]

func (*DeleteBuilder) WhereAny added in v0.2.0 

func (d *DeleteBuilder) WhereAny(columns []string, args ...any) *DeleteBuilder

WhereAny requires the predicate to hold for at least one column: (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereAny([]string{"first_name", "last_name"}, "ann")
// SELECT * FROM "users" WHERE ("first_name" = $1 OR "last_name" = $2)   args: [ann ann]

func (*DeleteBuilder) WhereBetween added in v0.2.0 

func (d *DeleteBuilder) WhereBetween(column string, lo any, hi any) *DeleteBuilder

WhereBetween adds "col BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" BETWEEN $1 AND $2   args: [10 100]

func (*DeleteBuilder) WhereBetweenColumns added in v0.2.0 

func (d *DeleteBuilder) WhereBetweenColumns(column string, c1 string, c2 string) *DeleteBuilder

WhereBetweenColumns adds "col BETWEEN c1 AND c2" comparing against columns.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price"

func (*DeleteBuilder) WhereColumn added in v0.2.0 

func (d *DeleteBuilder) WhereColumn(first string, args ...any) *DeleteBuilder

WhereColumn compares two columns: WhereColumn(a, b) means "=", or WhereColumn(a, op, b).

Example: 

conn.Select().From("users").WhereColumn("updated_at", ">", "created_at")
// SELECT * FROM "users" WHERE "updated_at" > "created_at"

func (*DeleteBuilder) WhereDate added in v0.2.0 

func (d *DeleteBuilder) WhereDate(column string, args ...any) *DeleteBuilder

WhereDate compares the date part of a column.

Example: 

conn.Select().From("orders").WhereDate("created_at", ">=", "2024-01-15")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::DATE >= $1   args: [2024-01-15]
// MySQL: SELECT * FROM `orders` WHERE DATE(`created_at`) >= ?   args: [2024-01-15]
// SQLite: SELECT * FROM "orders" WHERE STRFTIME('%Y-%m-%d', "created_at") >= CAST(? AS TEXT)
//     args: [2024-01-15]

func (*DeleteBuilder) WhereDay added in v0.2.0 

func (d *DeleteBuilder) WhereDay(column string, args ...any) *DeleteBuilder

WhereDay compares the day-of-month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereDay("created_at", 15)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1   args: [15]
// MySQL: SELECT * FROM `orders` WHERE DAY(`created_at`) = ?   args: [15]

func (*DeleteBuilder) WhereExists added in v0.2.0 

func (d *DeleteBuilder) WhereExists(sub *SelectBuilder) *DeleteBuilder

WhereExists adds "EXISTS (subquery)". Build sub with DB.Select.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereExists(posts)
// SELECT * FROM "users" WHERE EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*DeleteBuilder) WhereGroup added in v0.2.0 

func (d *DeleteBuilder) WhereGroup(fn func(*WhereClause)) *DeleteBuilder

WhereGroup wraps the predicates added inside fn in parentheses. fn receives a fresh WhereClause; only its Where* calls are used.

Example: 

conn.Select().From("users").Where("active", true).WhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").OrWhere("role", "editor")
})
// SELECT * FROM "users" WHERE "active" = $1 AND ("role" = $2 OR "role" = $3)
//     args: [true admin editor]

func (*DeleteBuilder) WhereIn added in v0.2.0 

func (d *DeleteBuilder) WhereIn(column string, values any) *DeleteBuilder

WhereIn adds "col IN (...)". values may be any slice, a scalar, or a *SelectBuilder subquery. An empty list compiles to the always-false "0 = 1".

Example: 

conn.Select().From("users").WhereIn("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN ($1, $2, $3)   args: [1 2 3]

func (*DeleteBuilder) WhereIntegerInRaw added in v0.2.0 

func (d *DeleteBuilder) WhereIntegerInRaw(column string, values any) *DeleteBuilder

WhereIntegerInRaw inlines integers (no bind args); non-integers record an error. Useful for very large ID lists that would exceed driver parameter limits.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN (1, 2, 3)

func (*DeleteBuilder) WhereIntegerNotInRaw added in v0.2.0 

func (d *DeleteBuilder) WhereIntegerNotInRaw(column string, values any) *DeleteBuilder

WhereIntegerNotInRaw is the negated WhereIntegerInRaw.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2)

func (*DeleteBuilder) WhereJsonContains added in v0.2.0 

func (d *DeleteBuilder) WhereJsonContains(column string, value any) *DeleteBuilder

WhereJsonContains adds a JSON containment test on a column or "col->path". MySQL json_contains, Postgres @> (jsonb), SQLite json_each membership.

Example: 

conn.Select().From("users").WhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE ("options"->'tags')::JSONB @> $1   args: ["go"]

func (*DeleteBuilder) WhereJsonContainsKey added in v0.2.0 

func (d *DeleteBuilder) WhereJsonContainsKey(column string) *DeleteBuilder

WhereJsonContainsKey tests that the JSON path "col->key" exists.

Example: 

conn.Select().From("users").WhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []
// MySQL: SELECT * FROM `users`
//   WHERE IFNULL(JSON_CONTAINS_PATH(`options`, 'one', '$."theme"'), 0)

func (*DeleteBuilder) WhereJsonDoesntContain added in v0.2.0 

func (d *DeleteBuilder) WhereJsonDoesntContain(column string, value any) *DeleteBuilder

WhereJsonDoesntContain negates WhereJsonContains.

Example: 

conn.Select().From("users").WhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE NOT ("options"->'tags')::JSONB @> $1   args: ["php"]

func (*DeleteBuilder) WhereJsonDoesntContainKey added in v0.2.0 

func (d *DeleteBuilder) WhereJsonDoesntContainKey(column string) *DeleteBuilder

WhereJsonDoesntContainKey negates WhereJsonContainsKey.

Example: 

conn.Select().From("users").WhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE NOT COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []

func (*DeleteBuilder) WhereJsonDoesntOverlap added in v0.2.0 

func (d *DeleteBuilder) WhereJsonDoesntOverlap(column string, value any) *DeleteBuilder

WhereJsonDoesntOverlap negates WhereJsonOverlaps.

Example: 

conn.Select().From("users")
.WhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["php"]]

func (*DeleteBuilder) WhereJsonLength added in v0.2.0 

func (d *DeleteBuilder) WhereJsonLength(column string, args ...any) *DeleteBuilder

WhereJsonLength compares the length of a JSON array: (value) or (operator, value).

Example: 

conn.Select().From("users")
.WhereJsonLength("options->tags", 2).WhereJsonLength("options->roles", ">", 1).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   AND JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) > $2   args: [2 1]

func (*DeleteBuilder) WhereJsonOverlaps added in v0.2.0 

func (d *DeleteBuilder) WhereJsonOverlaps(column string, value any) *DeleteBuilder

WhereJsonOverlaps adds json_overlaps (MySQL only; other dialects error at compile time).

Example: 

conn.Select().From("users")
.WhereJsonOverlaps("options->tags", []string{"go", "sql"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["go","sql"]]

func (*DeleteBuilder) WhereLike added in v0.2.0 

func (d *DeleteBuilder) WhereLike(column string, value any, caseSensitive ...bool) *DeleteBuilder

WhereLike adds a LIKE predicate, case-insensitive unless caseSensitive[0] is true. Postgres: ILIKE/LIKE. MySQL: LIKE/LIKE BINARY. SQLite: LIKE/GLOB (pattern converted).

Example: 

conn.Select().From("users").WhereLike("name", "An%")
// Postgres: SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1   args: [An%]
// MySQL: SELECT * FROM `users` WHERE `name` LIKE ?   args: [An%]
// SQLite: SELECT * FROM "users" WHERE "name" LIKE ?   args: [An%]

func (*DeleteBuilder) WhereMap added in v0.2.0 

func (d *DeleteBuilder) WhereMap(m map[string]any) *DeleteBuilder

WhereMap adds one grouped "a = ? and b = ?" predicate; keys are sorted for stable SQL.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"role": "ann", "active": true})
// SELECT * FROM "users" WHERE ("active" = $1 AND "role" = $2)   args: [true ann]

func (*DeleteBuilder) WhereMonth added in v0.2.0 

func (d *DeleteBuilder) WhereMonth(column string, args ...any) *DeleteBuilder

WhereMonth compares the month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereMonth("created_at", 3)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") = $1   args: [03]
// MySQL: SELECT * FROM `orders` WHERE MONTH(`created_at`) = ?   args: [03]

func (*DeleteBuilder) WhereNone added in v0.2.0 

func (d *DeleteBuilder) WhereNone(columns []string, args ...any) *DeleteBuilder

WhereNone requires the predicate to hold for no column: not (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereNone([]string{"first_name", "last_name"}, "like", "%test%")
// SELECT * FROM "users" WHERE NOT ("first_name"::TEXT LIKE $1 OR "last_name"::TEXT LIKE $2)
//     args: [%test% %test%]

func (*DeleteBuilder) WhereNot added in v0.2.0 

func (d *DeleteBuilder) WhereNot(column string, args ...any) *DeleteBuilder

WhereNot adds "AND NOT <predicate>".

Example: 

conn.Select().From("users").WhereNot("role", "admin")
// SELECT * FROM "users" WHERE NOT "role" = $1   args: [admin]

func (*DeleteBuilder) WhereNotBetween added in v0.2.0 

func (d *DeleteBuilder) WhereNotBetween(column string, lo any, hi any) *DeleteBuilder

WhereNotBetween adds "col NOT BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2   args: [10 100]

func (*DeleteBuilder) WhereNotBetweenColumns added in v0.2.0 

func (d *DeleteBuilder) WhereNotBetweenColumns(column string, c1 string, c2 string) *DeleteBuilder

WhereNotBetweenColumns is the negated WhereBetweenColumns.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price"

func (*DeleteBuilder) WhereNotExists added in v0.2.0 

func (d *DeleteBuilder) WhereNotExists(sub *SelectBuilder) *DeleteBuilder

WhereNotExists adds "NOT EXISTS (subquery)".

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereNotExists(posts)
// SELECT * FROM "users" WHERE NOT EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*DeleteBuilder) WhereNotIn added in v0.2.0 

func (d *DeleteBuilder) WhereNotIn(column string, values any) *DeleteBuilder

WhereNotIn adds "col NOT IN (...)". An empty list compiles to "1 = 1".

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2)   args: [1 2]

func (*DeleteBuilder) WhereNotLike added in v0.2.0 

func (d *DeleteBuilder) WhereNotLike(column string, value any, caseSensitive ...bool) *DeleteBuilder

WhereNotLike is the negated WhereLike.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%")
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1   args: [%test%]

func (*DeleteBuilder) WhereNotNull added in v0.2.0 

func (d *DeleteBuilder) WhereNotNull(column string) *DeleteBuilder

WhereNotNull adds "col IS NOT NULL".

Example: 

conn.Select().From("users").WhereNotNull("verified_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL

func (*DeleteBuilder) WhereNull added in v0.2.0 

func (d *DeleteBuilder) WhereNull(column string) *DeleteBuilder

WhereNull adds "col IS NULL".

Example: 

conn.Select().From("users").WhereNull("deleted_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL

func (*DeleteBuilder) WhereNullSafeEquals added in v0.2.0 

func (d *DeleteBuilder) WhereNullSafeEquals(column string, value any) *DeleteBuilder

WhereNullSafeEquals compares with NULL-safe equality (<=>, IS NOT DISTINCT FROM, IS).

Example: 

conn.Select().From("users").WhereNullSafeEquals("manager_id", 7)
// Postgres: SELECT * FROM "users" WHERE "manager_id" IS NOT DISTINCT FROM $1   args: [7]
// MySQL: SELECT * FROM `users` WHERE `manager_id` <=> ?   args: [7]

func (*DeleteBuilder) WhereRaw added in v0.2.0 

func (d *DeleteBuilder) WhereRaw(sql string, args ...any) *DeleteBuilder

WhereRaw adds a raw predicate (caller-trusted SQL).

Example: 

conn.Select().From("users").WhereRaw("lower(name) = ?", "ann")
// SELECT * FROM "users" WHERE lower(name) = $1
// args: [ann]

func (*DeleteBuilder) WhereRowValues added in v0.2.0 

func (d *DeleteBuilder) WhereRowValues(columns []string, op string, values []any) *DeleteBuilder

WhereRowValues adds "(a, b) op (?, ?)".

Example: 

conn.Select().From("events").
	WhereRowValues([]string{"created_at", "id"}, ">", []any{"2024-01-15", 42})
// SELECT * FROM "events" WHERE ("created_at", "id") > ($1, $2)   args: [2024-01-15 42]

func (*DeleteBuilder) WhereTime added in v0.2.0 

func (d *DeleteBuilder) WhereTime(column string, args ...any) *DeleteBuilder

WhereTime compares the time part of a column.

Example: 

conn.Select().From("orders").WhereTime("created_at", ">", "10:30:00")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::TIME > $1   args: [10:30:00]
// MySQL: SELECT * FROM `orders` WHERE TIME(`created_at`) > ?   args: [10:30:00]

func (*DeleteBuilder) WhereValueBetween added in v0.2.0 

func (d *DeleteBuilder) WhereValueBetween(value any, c1 string, c2 string) *DeleteBuilder

WhereValueBetween adds "? BETWEEN c1 AND c2" (a value between two columns).

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total"   args: [50]

func (*DeleteBuilder) WhereValueNotBetween added in v0.2.0 

func (d *DeleteBuilder) WhereValueNotBetween(value any, c1 string, c2 string) *DeleteBuilder

WhereValueNotBetween is the negated WhereValueBetween.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total"   args: [50]

func (*DeleteBuilder) WhereYear added in v0.2.0 

func (d *DeleteBuilder) WhereYear(column string, args ...any) *DeleteBuilder

WhereYear compares the year of a column.

Example: 

conn.Select().From("orders").WhereYear("created_at", 2024)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") = $1
//     args: [2024]
// MySQL: SELECT * FROM `orders` WHERE YEAR(`created_at`) = ?   args: [2024]

func (*DeleteBuilder) With added in v0.2.0 

func (d *DeleteBuilder) With(name string, q *SelectBuilder, opts ...CTEOption) *DeleteBuilder

With adds a common table expression: "with name as (q)". The name is a table reference, so the table prefix applies to it as it does to From. The subquery is snapshotted: later changes to q do not affect this query. Options name the columns (CTEColumns) or hint materialization (CTEMaterialized, CTENotMaterialized).

On a select, a CTE can feed the query, a subquery, a union member, Count, Exists and Paginate. On an update or delete it is written before the verb (PostgreSQL, MySQL 8, SQLite; MariaDB returns ErrUnsupported). On an insert it is moved into the SELECT given to Using, so it needs Using.

Example: 

active := conn.Select().From("users").Where("active", true)
conn.Select().From("active_users").With("active_users", active)
// WITH "active_users" AS (SELECT * FROM "users" WHERE "active" = $1) SELECT * FROM
//     "active_users"
// args: [true]

func (*DeleteBuilder) WithRaw added in v0.2.0 

func (d *DeleteBuilder) WithRaw(name string, e Expression, opts ...CTEOption) *DeleteBuilder

WithRaw adds a common table expression whose body is a raw SQL fragment (caller-trusted SQL), e.g. db.Raw("values (?), (?)", 1, 2). It takes the same options as With.

Example: 

conn.Select().From("ids").WithRaw("ids", db.Raw("values (?), (?)", 1, 2), db.CTEColumns("id"))
// WITH "ids" ("id") AS (values ($1), ($2)) SELECT * FROM "ids"
// args: [1 2]

func (*DeleteBuilder) WithRecursive added in v0.2.0 

func (d *DeleteBuilder) WithRecursive(name string, anchor *SelectBuilder, step *SelectBuilder, opts ...CTEOption) *DeleteBuilder

WithRecursive adds a recursive common table expression and switches the clause to "with recursive". anchor is the starting query and step the recursive member that refers to name; they are joined with UNION ALL (CTEUnionDistinct for UNION) and written without parentheses, because SQLite rejects a recursive reference inside a subquery. Neither query is modified, and anchor must not have unions.

Example: 

anchor := conn.Select().From("categories").Where("parent_id", nil)
step := conn.Select().From("categories as c").Join("tree as t", "c.parent_id", "t.id")
conn.Select().From("tree").WithRecursive("tree", anchor, step)
// WITH RECURSIVE "tree" AS (SELECT * FROM "categories" WHERE "parent_id" IS NULL UNION ALL
//     SELECT * FROM "categories" AS "c" INNER JOIN "tree" AS "t" ON "c"."parent_id" =
//     "t"."id") SELECT * FROM "tree"

type Dialect 

type Dialect int

Dialect selects the SQL grammar used to compile queries. 

const (
	Postgres Dialect = iota + 1
	MySQL
	SQLite
	// MariaDB shares MySQL's grammar and differs in two places: it has no lateral
	// joins, and it has no CAST AS JSON (json_query is used for JSON container values).
	MariaDB
)

The supported dialects. The zero Dialect is invalid and returns ErrUnknownDialect.

func (Dialect) String 

func (d Dialect) String() string

String returns the lower-case dialect name ("postgres", "mysql", "sqlite", "mariadb"), or "unknown" for any other value.

Example: 

db.MariaDB.String() // "mariadb"; db.Dialect(0).String() is "unknown"

type Expression 

type Expression struct {
	SQL  string
	Args []any
}

Expression is a raw SQL fragment inlined verbatim into the query. Use "?" for bind markers (write "??" for a literal "?"). The SQL text is NOT escaped: only pass caller-trusted strings, never user input.

func Raw 

func Raw(sql string, args ...any) Expression

Raw builds an Expression.

Example: 

conn.Select().From("users").Where("created_at", ">", db.Raw("now() - interval '1 day'"))
// SELECT * FROM "users" WHERE "created_at" > now() - interval '1 day'

type HavingClause added in v0.2.0 

type HavingClause struct {
	// contains filtered or unexported fields
}

HavingClause collects the predicates of a parenthesized HAVING group; it only offers the having methods. It is passed to HavingGroup/OrHavingGroup callbacks.

func (*HavingClause) Having added in v0.2.0 

func (h *HavingClause) Having(column string, args ...any) *HavingClause

Having adds an AND HAVING predicate; same argument forms as Where.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	Having("user_id", ">", 10)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING "user_id" > $1
// args: [10]

func (*HavingClause) HavingBetween added in v0.2.0 

func (h *HavingClause) HavingBetween(column string, lo any, hi any) *HavingClause

HavingBetween adds "col BETWEEN lo AND hi" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingBetween("spent", 100, 500)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent"
//     BETWEEN $1 AND $2
//     args: [100 500]

func (*HavingClause) HavingGroup added in v0.2.0 

func (h *HavingClause) HavingGroup(fn func(*HavingClause)) *HavingClause

HavingGroup wraps the Having* predicates added inside fn in parentheses.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	SelectRaw("count(*) as n").HavingGroup(func(q *db.HavingClause) {
	q.Having("spent", ">", 100).OrHaving("n", ">", 5)
})
// SELECT "user_id", sum(total) as spent, count(*) as n FROM "orders" GROUP BY "user_id"
//     HAVING ("spent" > $1 OR "n" > $2)
//     args: [100 5]

func (*HavingClause) HavingNotBetween added in v0.2.0 

func (h *HavingClause) HavingNotBetween(column string, lo any, hi any) *HavingClause

HavingNotBetween adds "col NOT BETWEEN lo AND hi" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotBetween("spent", 100, 500)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" NOT
//     BETWEEN $1 AND $2
//     args: [100 500]

func (*HavingClause) HavingNotNull added in v0.2.0 

func (h *HavingClause) HavingNotNull(column string) *HavingClause

HavingNotNull adds "col IS NOT NULL" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotNull("spent")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NOT NULL

func (*HavingClause) HavingNull added in v0.2.0 

func (h *HavingClause) HavingNull(column string) *HavingClause

HavingNull adds "col IS NULL" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNull("spent")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NULL

func (*HavingClause) HavingRaw added in v0.2.0 

func (h *HavingClause) HavingRaw(sql string, args ...any) *HavingClause

HavingRaw adds a raw HAVING predicate (caller-trusted SQL).

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	HavingRaw("sum(amount) > ?", 100)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING sum(amount) > $1
// args: [100]

func (*HavingClause) OrHaving added in v0.2.0 

func (h *HavingClause) OrHaving(column string, args ...any) *HavingClause

OrHaving is Having joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	Having("user_id", ">", 10).OrHaving("user_id", 1)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING "user_id" > $1 OR "user_id" = $2
// args: [10 1]

func (*HavingClause) OrHavingBetween added in v0.2.0 

func (h *HavingClause) OrHavingBetween(column string, lo any, hi any) *HavingClause

OrHavingBetween is HavingBetween joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingBetween("spent", 100, 500).OrHavingBetween("user_id", 1, 3)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent"
//     BETWEEN $1 AND $2 OR "user_id" BETWEEN $3 AND $4
//     args: [100 500 1 3]

func (*HavingClause) OrHavingGroup added in v0.2.0 

func (h *HavingClause) OrHavingGroup(fn func(*HavingClause)) *HavingClause

OrHavingGroup is HavingGroup joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	SelectRaw("count(*) as n").Having("n", ">", 1).OrHavingGroup(func(q *db.HavingClause) {
	q.Having("spent", ">", 100).Having("n", "<", 3)
})
// SELECT "user_id", sum(total) as spent, count(*) as n FROM "orders" GROUP BY "user_id"
//     HAVING "n" > $1 OR ("spent" > $2 AND "n" < $3)
//     args: [1 100 3]

func (*HavingClause) OrHavingNotBetween added in v0.2.0 

func (h *HavingClause) OrHavingNotBetween(column string, lo any, hi any) *HavingClause

OrHavingNotBetween is HavingNotBetween joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotBetween("spent", 100, 500).OrHavingNotBetween("user_id", 1, 3)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" NOT
//     BETWEEN $1 AND $2 OR "user_id" NOT BETWEEN $3 AND $4
//     args: [100 500 1 3]

func (*HavingClause) OrHavingNotNull added in v0.2.0 

func (h *HavingClause) OrHavingNotNull(column string) *HavingClause

OrHavingNotNull is HavingNotNull joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotNull("spent").OrHavingNotNull("user_id")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NOT NULL OR "user_id" IS NOT NULL

func (*HavingClause) OrHavingNull added in v0.2.0 

func (h *HavingClause) OrHavingNull(column string) *HavingClause

OrHavingNull is HavingNull joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNull("spent").OrHavingNull("user_id")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NULL OR "user_id" IS NULL

func (*HavingClause) OrHavingRaw added in v0.2.0 

func (h *HavingClause) OrHavingRaw(sql string, args ...any) *HavingClause

OrHavingRaw is HavingRaw joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	HavingRaw("sum(amount) > ?", 100).OrHavingRaw("count(*) > ?", 5)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING sum(amount) > $1 OR count(*) > $2
// args: [100 5]

type InsertBuilder added in v0.2.0 

type InsertBuilder struct {
	// contains filtered or unexported fields
}

InsertBuilder is a mutable INSERT statement. Start one with DB.Insert; add rows with Values or Rows (or Using for INSERT ... SELECT) and finish with Exec, Get or ToSQL. Not safe for concurrent use.

func (*InsertBuilder) Clone added in v0.2.0 

func (i *InsertBuilder) Clone() *InsertBuilder

Clone returns an independent copy. Cloning a nil *InsertBuilder returns nil.

Example: 

base := conn.Insert("users").Values(map[string]any{"name": "Ann"})
withID := base.Clone().Returning("id")

func (*InsertBuilder) Err added in v0.2.0 

func (i *InsertBuilder) Err() error

Err returns the first error recorded while building.

Example: 

q := conn.Select().From("users").Where("id", "!!", 1)
err := q.Err()
// err: quill: invalid operator: "!!"

func (*InsertBuilder) Exec added in v0.2.0 

func (i *InsertBuilder) Exec(ctx context.Context) (int64, error)

Exec runs the insert and returns the rows affected. No rows is a no-op.

Example: 

n, err := conn.Insert("users").Values(map[string]any{"name": "Ann"}).Exec(ctx)
// INSERT INTO "users" ("name") VALUES ($1)   args: [Ann]   (n = 1)

func (*InsertBuilder) ExecGetID added in v0.2.0 

func (i *InsertBuilder) ExecGetID(ctx context.Context, sequence ...string) (int64, error)

ExecGetID runs a single-row insert and returns the generated key (see IDSQL).

Example: 

id, err := conn.Insert("users").Values(map[string]any{"name": "Ann"}).ExecGetID(ctx)
// Postgres: INSERT INTO "users" ("name") VALUES ($1) RETURNING "id"   (id = 12)

func (*InsertBuilder) Get added in v0.2.0 

func (i *InsertBuilder) Get(ctx context.Context, dest any) error

Get runs the insert and scans the RETURNING rows into dest (a pointer to a slice of structs, maps or scalars). Call Returning first. Postgres and SQLite >= 3.35.

Example: 

var created []User
err := conn.Insert("users").Values(map[string]any{"name": "Ann"}).Returning("*").Get(ctx, &created)
// INSERT INTO "users" ("name") VALUES ($1) RETURNING *   args: [Ann]

func (*InsertBuilder) IDSQL added in v0.2.0 

func (i *InsertBuilder) IDSQL(sequence ...string) (string, []any, error)

IDSQL compiles a single-row insert that returns the generated key: RETURNING on Postgres (sequence names the column, default "id"), a plain insert elsewhere.

Example: 

conn.Insert("users").Values(map[string]any{"name": "Ann"}).IDSQL()
// Postgres: INSERT INTO "users" ("name") VALUES ($1) RETURNING "id"   args: [Ann]

func (*InsertBuilder) Ignore added in v0.2.0 

func (i *InsertBuilder) Ignore() *InsertBuilder

Ignore skips rows that conflict instead of failing: INSERT IGNORE on MySQL, ON CONFLICT DO NOTHING on Postgres and SQLite.

Example: 

conn.Insert("users").Values(map[string]any{"email": "a@x.io"}).Ignore()
// INSERT INTO "users" ("email") VALUES ($1) ON CONFLICT DO NOTHING

func (*InsertBuilder) Prefix added in v0.2.0 

func (i *InsertBuilder) Prefix(p string) *InsertBuilder

Prefix sets a table prefix applied to table names, aliases and qualified columns.

Example: 

db.Use(db.Postgres).Select("u.id").From("users as u").Prefix("app_")
// SELECT "app_u"."id" FROM "app_users" AS "app_u"

func (*InsertBuilder) Returning added in v0.2.0 

func (i *InsertBuilder) Returning(columns ...string) *InsertBuilder

Returning adds a RETURNING clause to insert/update/delete/upsert (Postgres, SQLite >= 3.35; MySQL returns ErrUnsupported). "*" is allowed.

Example: 

conn.Insert("users").Values(map[string]any{"name": "Ann"}).Returning("id", "created_at").ToSQL()
// INSERT INTO "users" ("name") VALUES ($1) RETURNING "id", "created_at"   args: [Ann]
// MySQL: ToSQL returns ErrUnsupported

func (*InsertBuilder) Rows added in v0.2.0 

func (i *InsertBuilder) Rows(structs ...any) *InsertBuilder

Rows appends structs (or slices of structs) as rows, using the same `db` tags as Row. An `omitempty` column is left out only when it is zero in every row of one Rows call, since a batch insert cannot skip a column for just some rows.

Example: 

conn.Insert("posts").Rows(Post{Title: "One"}, Post{Title: "Two"})
// INSERT INTO "posts" ("title") VALUES ($1), ($2)   args: [One Two]

func (*InsertBuilder) ToSQL added in v0.2.0 

func (i *InsertBuilder) ToSQL() (string, []any, error)

ToSQL compiles the INSERT into SQL text and its ordered bind arguments. No rows returns ErrNoValues.

Example: 

sqlText, args, err := conn.Insert("users").Values(map[string]any{"name": "Ann"}).ToSQL()
// INSERT INTO "users" ("name") VALUES ($1)   args: [Ann]

func (*InsertBuilder) Upsert added in v0.2.0 

func (i *InsertBuilder) Upsert(uniqueBy, update []string) *InsertBuilder

Upsert updates on conflict. update lists the columns that take the inserted value (nil means every inserted column). uniqueBy is required on Postgres/SQLite (the conflict target) and ignored on MySQL.

Example: 

conn.Insert("users").Values(map[string]any{"email": "a@x.io", "name": "Ann"}).
	Upsert([]string{"email"}, []string{"name"})
// MySQL: INSERT INTO `users` (`email`, `name`) VALUES (?, ?)
//        ON DUPLICATE KEY UPDATE `name` = VALUES(`name`)   args: [a@x.io Ann]

func (*InsertBuilder) Using added in v0.2.0 

func (i *InsertBuilder) Using(columns []string, sub *SelectBuilder) *InsertBuilder

Using inserts the rows of a SELECT into columns (INSERT ... SELECT).

Example: 

conn.Insert("archived_users").Using([]string{"name"}, conn.Select("name").From("users"))
// INSERT INTO "archived_users" ("name") SELECT "name" FROM "users"   args: []

func (*InsertBuilder) Values added in v0.2.0 

func (i *InsertBuilder) Values(rows ...map[string]any) *InsertBuilder

Values appends rows, each a column map. Every row must use the same columns.

Example: 

conn.Insert("users").Values(map[string]any{"name": "Ann"}, map[string]any{"name": "Bob"})
// INSERT INTO "users" ("name") VALUES ($1), ($2)   args: [Ann Bob]

func (*InsertBuilder) With added in v0.2.0 

func (i *InsertBuilder) With(name string, q *SelectBuilder, opts ...CTEOption) *InsertBuilder

With adds a common table expression: "with name as (q)". The name is a table reference, so the table prefix applies to it as it does to From. The subquery is snapshotted: later changes to q do not affect this query. Options name the columns (CTEColumns) or hint materialization (CTEMaterialized, CTENotMaterialized).

On a select, a CTE can feed the query, a subquery, a union member, Count, Exists and Paginate. On an update or delete it is written before the verb (PostgreSQL, MySQL 8, SQLite; MariaDB returns ErrUnsupported). On an insert it is moved into the SELECT given to Using, so it needs Using.

Example: 

active := conn.Select().From("users").Where("active", true)
conn.Select().From("active_users").With("active_users", active)
// WITH "active_users" AS (SELECT * FROM "users" WHERE "active" = $1) SELECT * FROM
//     "active_users"
// args: [true]

func (*InsertBuilder) WithRaw added in v0.2.0 

func (i *InsertBuilder) WithRaw(name string, e Expression, opts ...CTEOption) *InsertBuilder

WithRaw adds a common table expression whose body is a raw SQL fragment (caller-trusted SQL), e.g. db.Raw("values (?), (?)", 1, 2). It takes the same options as With.

Example: 

conn.Select().From("ids").WithRaw("ids", db.Raw("values (?), (?)", 1, 2), db.CTEColumns("id"))
// WITH "ids" ("id") AS (values ($1), ($2)) SELECT * FROM "ids"
// args: [1 2]

func (*InsertBuilder) WithRecursive added in v0.2.0 

func (i *InsertBuilder) WithRecursive(name string, anchor *SelectBuilder, step *SelectBuilder, opts ...CTEOption) *InsertBuilder

WithRecursive adds a recursive common table expression and switches the clause to "with recursive". anchor is the starting query and step the recursive member that refers to name; they are joined with UNION ALL (CTEUnionDistinct for UNION) and written without parentheses, because SQLite rejects a recursive reference inside a subquery. Neither query is modified, and anchor must not have unions.

Example: 

anchor := conn.Select().From("categories").Where("parent_id", nil)
step := conn.Select().From("categories as c").Join("tree as t", "c.parent_id", "t.id")
conn.Select().From("tree").WithRecursive("tree", anchor, step)
// WITH RECURSIVE "tree" AS (SELECT * FROM "categories" WHERE "parent_id" IS NULL UNION ALL
//     SELECT * FROM "categories" AS "c" INNER JOIN "tree" AS "t" ON "c"."parent_id" =
//     "t"."id") SELECT * FROM "tree"

type JoinClause 

type JoinClause struct {
	// contains filtered or unexported fields
}

JoinClause builds the ON conditions of one join. Column-to-column comparisons use On/OrOn; value comparisons use Where/OrWhere.

func (*JoinClause) On 

func (j *JoinClause) On(first string, args ...any) *JoinClause

On adds "first = second" or "first op second" (column to column).

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").On("p.created_at", ">=", "u.created_at")
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."created_at" >= "u"."created_at"

func (*JoinClause) OnGroup 

func (j *JoinClause) OnGroup(fn func(*JoinClause)) *JoinClause

OnGroup wraps the conditions added inside fn in parentheses.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OnGroup(func(g *db.JoinClause) {
		g.Where("p.status", "published").OrWhere("p.status", "draft")
	})
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     ("p"."status" = $1 OR "p"."status" = $2)
// args: [published draft]

func (*JoinClause) OrOn 

func (j *JoinClause) OrOn(first string, args ...any) *JoinClause

OrOn is On joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OrOn("p.editor_id", "u.id")
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" OR
//     "p"."editor_id" = "u"."id"

func (*JoinClause) OrOnGroup 

func (j *JoinClause) OrOnGroup(fn func(*JoinClause)) *JoinClause

OrOnGroup is OnGroup joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OrOnGroup(func(g *db.JoinClause) {
		g.On("p.editor_id", "u.id").Where("p.score", ">", 10)
	})
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" OR
//     ("p"."editor_id" = "u"."id" AND "p"."score" > $1)
// args: [10]

func (*JoinClause) OrWhere 

func (j *JoinClause) OrWhere(column string, args ...any) *JoinClause

OrWhere is Where joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.status", "published").OrWhere("p.pinned", true)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."status" = $1 OR "p"."pinned" = $2
// args: [published true]

func (*JoinClause) OrWhereIn 

func (j *JoinClause) OrWhereIn(column string, values any) *JoinClause

OrWhereIn is WhereIn joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OrWhereIn("p.status", []string{"draft"})
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" OR
//     "p"."status" IN ($1)
// args: [draft]

func (*JoinClause) OrWhereNotIn 

func (j *JoinClause) OrWhereNotIn(column string, values any) *JoinClause

OrWhereNotIn is WhereNotIn joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OrWhereNotIn("p.status", []string{"spam"})
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" OR
//     "p"."status" NOT IN ($1)
// args: [spam]

func (*JoinClause) OrWhereNotNull 

func (j *JoinClause) OrWhereNotNull(column string) *JoinClause

OrWhereNotNull is WhereNotNull joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OrWhereNotNull("p.published_at")
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" OR
//     "p"."published_at" IS NOT NULL

func (*JoinClause) OrWhereNull 

func (j *JoinClause) OrWhereNull(column string) *JoinClause

OrWhereNull is WhereNull joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OrWhereNull("p.deleted_at")
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" OR
//     "p"."deleted_at" IS NULL

func (*JoinClause) OrWhereRaw 

func (j *JoinClause) OrWhereRaw(sql string, args ...any) *JoinClause

OrWhereRaw is WhereRaw joined with OR.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").OrWhereRaw("p.score > ?", 10)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" OR
//     p.score > $1
// args: [10]

func (*JoinClause) Where 

func (j *JoinClause) Where(column string, args ...any) *JoinClause

Where adds a bound-value condition: Where(col, value) or Where(col, op, value).

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.status", "published").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."status" = $1 AND "p"."score" > $2
// args: [published 10]

func (*JoinClause) WhereIn 

func (j *JoinClause) WhereIn(column string, values any) *JoinClause

WhereIn adds "col IN (...)".

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereIn("p.status", []string{"published", "draft"})
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."status" IN ($1, $2)
// args: [published draft]

func (*JoinClause) WhereNotIn 

func (j *JoinClause) WhereNotIn(column string, values any) *JoinClause

WhereNotIn adds "col NOT IN (...)".

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNotIn("p.status", []string{"spam"})
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."status" NOT IN ($1)
// args: [spam]

func (*JoinClause) WhereNotNull 

func (j *JoinClause) WhereNotNull(column string) *JoinClause

WhereNotNull adds "col IS NOT NULL".

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNotNull("p.published_at")
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."published_at" IS NOT NULL

func (*JoinClause) WhereNull 

func (j *JoinClause) WhereNull(column string) *JoinClause

WhereNull adds "col IS NULL".

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNull("p.deleted_at")
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."deleted_at" IS NULL

func (*JoinClause) WhereRaw 

func (j *JoinClause) WhereRaw(sql string, args ...any) *JoinClause

WhereRaw adds a raw condition (caller-trusted SQL).

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereRaw("p.score > ?", 10)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     p.score > $1
// args: [10]

type Option 

type Option func(*DB)

Option configures a DB.

Example: 

conn := db.New(sqlDB, db.Postgres, db.WithPrefix("app_"), db.WithLogArgs())

func WithHook 

func WithHook(fn func(context.Context, QueryEvent)) Option

WithHook registers fn to run after every statement (logging, metrics, tracing). Bind values are omitted from the event unless WithLogArgs is also set.

Example: 

hook := func(_ context.Context, ev db.QueryEvent) { log.Println(ev.SQL, ev.NumArgs) }
conn := db.New(sqlDB, db.Postgres, db.WithHook(hook))
conn.Select().From("users").Where("name", "ann").Count(ctx)
// hook sees: SELECT COUNT(*) AS "aggregate" FROM "users" WHERE "name" = $1, 1

func WithLogArgs 

func WithLogArgs() Option

WithLogArgs includes bind values in QueryEvent.Args. Off by default because arguments routinely carry personal data (UU PDP / ISO 27701).

Example: 

hook := func(_ context.Context, ev db.QueryEvent) { log.Println(ev.Args) }
conn := db.New(sqlDB, db.Postgres, db.WithHook(hook), db.WithLogArgs())
// ev.Args = ["ann"] for Where("name", "ann")

func WithPrefix 

func WithPrefix(prefix string) Option

WithPrefix sets a table prefix applied to every statement builder created from the DB.

Example: 

conn := db.New(sqlDB, db.Postgres, db.WithPrefix("app_"))
conn.Select().From("users")
// SELECT * FROM "app_users"

type Page 

type Page struct {
	Total       int64
	PerPage     int
	CurrentPage int
	LastPage    int
	From        int // 1-based index of the first row on the page; 0 when empty
	To          int
}

Page describes one page of a length-aware pagination.

Example: 

var users []User
p, err := conn.Select().From("users").OrderBy("id").Paginate(ctx, 2, 2, &users)
// with 5 matching rows: p.Total = 5, p.PerPage = 2, p.CurrentPage = 2
// p.LastPage = 3, p.From = 3, p.To = 4
// with no rows: p.LastPage = 1, p.From = 0, p.To = 0 and users is empty

type Paged 

type Paged[T any] struct {
	Page
	Items []T
}

Paged is a length-aware page with its rows.

type Query 

type Query[T any] struct {
	// contains filtered or unexported fields
}

Query reads rows of type T from a SelectBuilder. Go methods cannot take type parameters, so SelectBuilder cannot return []T itself; wrap the finished builder once instead: 

users, err := db.As[User](conn.Select().From("users").Where("active", true)).Get(ctx)

T may be a struct (`db:"col"` tags, else snake_case field names), a map[string]any, or a scalar when the query selects a single column.

func As 

func As[T any](b *SelectBuilder) *Query[T]

As wraps b for typed reads. The builder is not copied: keep chaining on it before calling As, or use Builder to get it back.

Example: 

q := db.As[string](conn.Select().From("users").Select("name"))
names, err := q.Get(ctx)
// SELECT "name" FROM "users"   args: []
// names: [ann bob]

func From 

func From[T any](db *DB) *Query[T]

From starts a typed query on T's table: db.From[User](conn).Where(...).Get(ctx). A problem with T (no TableName method) is reported by the first terminal call, like any other builder error, so the chain stays unbroken.

Example: 

q := db.From[Order](conn) // same as db.As[Order](conn.Select().From("orders"))

func (*Query[T]) AddSelect 

func (q *Query[T]) AddSelect(columns ...string) *Query[T]

AddSelect appends columns.

Example: 

conn.Select().From("users").Select("id").AddSelect("name", "age")
// SELECT "id", "name", "age" FROM "users"

func (*Query[T]) Apply 

func (q *Query[T]) Apply(fn func(*SelectBuilder)) *Query[T]

Apply runs fn on the underlying builder, for any SelectBuilder method this type does not mirror.

Example: 

db.From[User](conn).Apply(func(b *db.SelectBuilder) { b.WhereDate("created_at", day) })
// SELECT * FROM "users" WHERE "created_at"::DATE = $1   args: [2026-01-02]

func (*Query[T]) Avg 

func (q *Query[T]) Avg(ctx context.Context, column string) (float64, error)

Avg returns avg(column) as float64 (0 when there are no rows).

Example: 

avg, err := db.From[User](conn).Avg(ctx, "age")
// SELECT AVG("age") AS "aggregate" FROM "users"   args: []
// avg: 28.7

func (*Query[T]) Builder 

func (q *Query[T]) Builder() *SelectBuilder

Builder returns the underlying builder for further chaining.

Example: 

sql, args, err := db.From[User](conn).Where("age", ">", 18).Builder().OrderBy("name").ToSQL()
// SELECT * FROM "users" WHERE "age" > $1 ORDER BY "name" ASC   args: [18]

func (*Query[T]) Chunk 

func (q *Query[T]) Chunk(ctx context.Context, size int, fn func([]T) (bool, error)) error

Chunk reads size rows at a time and calls fn; return false to stop. The query needs an ORDER BY. See SelectBuilder.Chunk.

Example: 

err := db.From[User](conn).OrderBy("id").Chunk(ctx, 2, func(batch []User) (bool, error) {
	// batch of 2, then batch of 1; return false to stop
	return true, nil
})
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 2 OFFSET 0   args: []
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 2 OFFSET 2   args: []

func (*Query[T]) ChunkByID 

func (q *Query[T]) ChunkByID(ctx context.Context, size int, fn func([]T) (bool, error), column ...string) error

ChunkByID is Chunk with keyset paging on a unique column (default "id").

Example: 

err := db.From[User](conn).ChunkByID(ctx, 2, func(batch []User) (bool, error) {
	// batch of 2 (last id 2), then batch of 1 (last id 3)
	return true, nil
})
// SELECT * FROM "users" WHERE "id" IS NOT NULL ORDER BY "id" ASC LIMIT 2   args: []
// SELECT * FROM "users" WHERE "id" > $1 ORDER BY "id" ASC LIMIT 2   args: [2]

func (*Query[T]) Clone 

func (q *Query[T]) Clone() *Query[T]

Clone returns an independent copy of the query.

Example: 

base := db.From[User](conn).Where("age", ">=", 18)
refined := base.Clone().OrderBy("name")
// refined: SELECT * FROM "users" WHERE "age" >= $1 ORDER BY "name" ASC   args: [18]
// base is unchanged: SELECT * FROM "users" WHERE "age" >= $1   args: [18]

func (*Query[T]) Count 

func (q *Query[T]) Count(ctx context.Context) (int64, error)

Count returns the number of matching rows.

Example: 

n, err := db.From[User](conn).Where("age", ">", 18).Count(ctx)
// SELECT COUNT(*) AS "aggregate" FROM "users" WHERE "age" > $1   args: [18]
// n: 3

func (*Query[T]) CrossJoin added in v0.2.0 

func (q *Query[T]) CrossJoin(table string) *Query[T]

CrossJoin adds "CROSS JOIN table".

Example: 

conn.Select().From("users").CrossJoin("roles")
// SELECT * FROM "users" CROSS JOIN "roles"

func (*Query[T]) CrossJoinSub added in v0.2.0 

func (q *Query[T]) CrossJoinSub(sub *SelectBuilder, as string) *Query[T]

CrossJoinSub cross joins a subquery.

Example: 

sub := conn.Select().From("roles").Select("name").Where("active", true)
conn.Select().From("users").CrossJoinSub(sub, "r")
// SELECT * FROM "users" CROSS JOIN (SELECT "name" FROM "roles" WHERE "active" = $1) AS "r"
// args: [true]

func (*Query[T]) CursorPaginate 

func (q *Query[T]) CursorPaginate(
	ctx context.Context,
	perPage int,
	cursor string,
	opt ...CursorOptions,
) (CursorPaged[T], error)

CursorPaginate pages forward by keyset; see SelectBuilder.CursorPaginate.

Example: 

p, err := db.From[User](conn).CursorPaginate(ctx, 2, "")
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 3   args: []
// len(p.Items): 2, p.HasMore: true; pass p.NextCursor to fetch the next page

func (*Query[T]) Distinct 

func (q *Query[T]) Distinct() *Query[T]

Distinct marks the query SELECT DISTINCT.

Example: 

conn.Select().From("posts").Distinct().Select("user_id")
// SELECT DISTINCT "user_id" FROM "posts"

func (*Query[T]) DoesntExist 

func (q *Query[T]) DoesntExist(ctx context.Context) (bool, error)

DoesntExist reports whether no row matches.

Example: 

none, err := db.From[User](conn).Where("name", "ann").DoesntExist(ctx)
// SELECT EXISTS(SELECT * FROM "users" WHERE "name" = $1) AS "exists"   args: [ann]
// none: false when a matching row exists

func (*Query[T]) Each 

func (q *Query[T]) Each(ctx context.Context, fn func(T) error) error

Each streams rows to fn one at a time, holding a single row in memory.

Example: 

err := db.From[User](conn).Each(ctx, func(u User) error {
	fmt.Println(u.ID, u.Name) // 1 ann, then 2 bob
	return nil
})
// SELECT * FROM "users"   args: []

func (*Query[T]) Exists 

func (q *Query[T]) Exists(ctx context.Context) (bool, error)

Exists reports whether any row matches.

Example: 

ok, err := db.From[User](conn).Where("name", "ann").Exists(ctx)
// SELECT EXISTS(SELECT * FROM "users" WHERE "name" = $1) AS "exists"   args: [ann]
// ok: true

func (*Query[T]) Find 

func (q *Query[T]) Find(ctx context.Context, id any) (T, error)

Find returns the row whose "id" equals id, or ErrNotFound.

Example: 

u, err := db.From[User](conn).Find(ctx, 2)
// SELECT * FROM "users" WHERE "id" = $1 LIMIT 1   args: [2]
// u.Name: bob

func (*Query[T]) First 

func (q *Query[T]) First(ctx context.Context) (T, error)

First returns the first row, or ErrNotFound.

Example: 

u, err := db.From[User](conn).Where("name", "ann").First(ctx)
// SELECT * FROM "users" WHERE "name" = $1 LIMIT 1   args: [ann]
// u.Name: ann; no row: errors.Is(err, db.ErrNotFound)

func (*Query[T]) ForPage 

func (q *Query[T]) ForPage(page int, perPage int) *Query[T]

ForPage sets offset/limit for a 1-based page.

Example: 

conn.Select().From("users").OrderBy("id").ForPage(3, 25) // page 3, 25 rows per page
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 25 OFFSET 50

func (*Query[T]) ForPageAfterID added in v0.2.0 

func (q *Query[T]) ForPageAfterID(perPage int, lastID any, column ...string) *Query[T]

ForPageAfterID pages forwards by keyset: "id > lastID ORDER BY id ASC LIMIT n".

Example: 

conn.Select().From("posts").ForPageAfterID(10, 42)
// SELECT * FROM "posts" WHERE "id" > $1 ORDER BY "id" ASC LIMIT 10   args: [42]

func (*Query[T]) ForPageBeforeID added in v0.2.0 

func (q *Query[T]) ForPageBeforeID(perPage int, lastID any, column ...string) *Query[T]

ForPageBeforeID pages backwards by keyset: "id < lastID ORDER BY id DESC LIMIT n". A nil lastID selects "id IS NOT NULL". column defaults to "id".

Example: 

conn.Select().From("posts").ForPageBeforeID(10, 42)
// SELECT * FROM "posts" WHERE "id" < $1 ORDER BY "id" DESC LIMIT 10   args: [42]

func (*Query[T]) ForceIndex added in v0.2.0 

func (q *Query[T]) ForceIndex(index string) *Query[T]

ForceIndex adds "FORCE INDEX (a)" (MySQL) or "INDEXED BY a" (SQLite, one name).

Example: 

conn.Select().From("users").ForceIndex("idx_email").Where("active", true)
// MySQL: SELECT * FROM `users` FORCE INDEX (idx_email) WHERE `active` = ?   args: [true]
// SQLite: SELECT * FROM "users" INDEXED BY idx_email WHERE "active" = ?   args: [true]

func (*Query[T]) From added in v0.2.0 

func (q *Query[T]) From(table string) *Query[T]

From sets the table ("users", "users as u", "schema.users").

Example: 

db.Use(db.Postgres).Select().From("public.users as u")
// SELECT * FROM "public"."users" AS "u"

func (*Query[T]) FromRaw added in v0.2.0 

func (q *Query[T]) FromRaw(sql string, args ...any) *Query[T]

FromRaw uses a raw SQL fragment as the source (caller-trusted SQL).

Example: 

conn.Select().FromRaw("generate_series(?, ?) as g", 1, 3)
// SELECT * FROM generate_series($1, $2) as g   args: [1 3]

func (*Query[T]) FromSub added in v0.2.0 

func (q *Query[T]) FromSub(sub *SelectBuilder, as string) *Query[T]

FromSub uses "(subquery) as alias" as the source.

Example: 

top := conn.Select().From("orders").SelectRaw("user_id, sum(total) as spent").GroupBy("user_id")
conn.Select().FromSub(top, "t").Where("spent", ">", 100)
// SELECT * FROM (SELECT user_id, sum(total) as spent FROM "orders" GROUP BY "user_id") AS
//     "t" WHERE "spent" > $1
//     args: [100]

func (*Query[T]) Get 

func (q *Query[T]) Get(ctx context.Context) ([]T, error)

Get returns every matching row.

Example (User has TableName() returning "users"; conn is a *db.DB): 

users, err := db.From[User](conn).OrderBy("id").Get(ctx)
// SELECT * FROM "users" ORDER BY "id" ASC   args: []
// users: [{1 ann 30} {2 bob 25}]

func (*Query[T]) GroupBy 

func (q *Query[T]) GroupBy(columns ...string) *Query[T]

GroupBy adds GROUP BY columns.

Example: 

conn.Select().From("orders").Select("user_id", "status").GroupBy("user_id", "status")
// SELECT "user_id", "status" FROM "orders" GROUP BY "user_id", "status"

func (*Query[T]) GroupByRaw added in v0.2.0 

func (q *Query[T]) GroupByRaw(sql string, args ...any) *Query[T]

GroupByRaw adds a raw GROUP BY expression.

Example: 

conn.Select().From("orders").SelectRaw("date_trunc('day', created_at) as day").
	GroupByRaw("date_trunc('day', created_at)")
// SELECT date_trunc('day', created_at) as day FROM "orders" GROUP BY date_trunc('day',
//     created_at)

func (*Query[T]) Having 

func (q *Query[T]) Having(column string, args ...any) *Query[T]

Having adds an AND HAVING predicate; same argument forms as Where.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	Having("user_id", ">", 10)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING "user_id" > $1
// args: [10]

func (*Query[T]) HavingBetween added in v0.2.0 

func (q *Query[T]) HavingBetween(column string, lo any, hi any) *Query[T]

HavingBetween adds "col BETWEEN lo AND hi" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingBetween("spent", 100, 500)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent"
//     BETWEEN $1 AND $2
//     args: [100 500]

func (*Query[T]) HavingGroup added in v0.2.0 

func (q *Query[T]) HavingGroup(fn func(*HavingClause)) *Query[T]

HavingGroup wraps the Having* predicates added inside fn in parentheses.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	SelectRaw("count(*) as n").HavingGroup(func(q *db.HavingClause) {
	q.Having("spent", ">", 100).OrHaving("n", ">", 5)
})
// SELECT "user_id", sum(total) as spent, count(*) as n FROM "orders" GROUP BY "user_id"
//     HAVING ("spent" > $1 OR "n" > $2)
//     args: [100 5]

func (*Query[T]) HavingNotBetween added in v0.2.0 

func (q *Query[T]) HavingNotBetween(column string, lo any, hi any) *Query[T]

HavingNotBetween adds "col NOT BETWEEN lo AND hi" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotBetween("spent", 100, 500)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" NOT
//     BETWEEN $1 AND $2
//     args: [100 500]

func (*Query[T]) HavingNotNull added in v0.2.0 

func (q *Query[T]) HavingNotNull(column string) *Query[T]

HavingNotNull adds "col IS NOT NULL" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotNull("spent")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NOT NULL

func (*Query[T]) HavingNull added in v0.2.0 

func (q *Query[T]) HavingNull(column string) *Query[T]

HavingNull adds "col IS NULL" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNull("spent")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NULL

func (*Query[T]) HavingRaw 

func (q *Query[T]) HavingRaw(sql string, args ...any) *Query[T]

HavingRaw adds a raw HAVING predicate (caller-trusted SQL).

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	HavingRaw("sum(amount) > ?", 100)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING sum(amount) > $1
// args: [100]

func (*Query[T]) IgnoreIndex added in v0.2.0 

func (q *Query[T]) IgnoreIndex(index string) *Query[T]

IgnoreIndex adds "IGNORE INDEX (a)" (MySQL; ignored elsewhere).

Example: 

conn.Select().From("users").IgnoreIndex("idx_email").Where("active", true)
// SELECT * FROM `users` IGNORE INDEX (idx_email) WHERE `active` = ?   args: [true]

func (*Query[T]) InRandomOrder added in v0.2.0 

func (q *Query[T]) InRandomOrder(seed ...int) *Query[T]

InRandomOrder orders randomly: RANDOM() on Postgres/SQLite, RAND([seed]) on MySQL.

Example: 

conn.Select().From("posts").InRandomOrder().Limit(5)
// Postgres: SELECT * FROM "posts" ORDER BY RANDOM() LIMIT 5
// MySQL: SELECT * FROM `posts` ORDER BY RAND() LIMIT 5

func (*Query[T]) Join 

func (q *Query[T]) Join(table string, first string, args ...any) *Query[T]

Join adds "INNER JOIN table ON first = second" (or "first op second").

Example: 

conn.Select().From("users as u").Join("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*Query[T]) JoinFunc 

func (q *Query[T]) JoinFunc(table string, fn func(*JoinClause)) *Query[T]

JoinFunc adds an inner join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.published", true)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."published" = $1
// args: [true]

func (*Query[T]) JoinLateral added in v0.2.0 

func (q *Query[T]) JoinLateral(sub *SelectBuilder, as string) *Query[T]

JoinLateral adds "INNER JOIN LATERAL (subquery) AS alias ON TRUE" (Postgres, MySQL >= 8.0.14).

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").JoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" INNER JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE
// MariaDB returns ErrUnsupported

func (*Query[T]) JoinSub added in v0.2.0 

func (q *Query[T]) JoinSub(sub *SelectBuilder, as string, first string, args ...any) *Query[T]

JoinSub joins a subquery: "INNER JOIN (SELECT ...) AS alias ON ...".

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").JoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*Query[T]) JoinSubFunc added in v0.2.0 

func (q *Query[T]) JoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *Query[T]

JoinSubFunc joins a subquery with a complex ON clause built in fn.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").JoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" > $1
// args: [10]

func (*Query[T]) JoinWhere added in v0.2.0 

func (q *Query[T]) JoinWhere(table string, column string, args ...any) *Query[T]

JoinWhere joins on a bound value: "INNER JOIN t ON col = ?".

Example: 

conn.Select().From("users as u").JoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*Query[T]) Latest 

func (q *Query[T]) Latest(column ...string) *Query[T]

Latest orders by column descending (default "created_at").

Example: 

conn.Select().From("posts").Latest("published_at")
// SELECT * FROM "posts" ORDER BY "published_at" DESC

func (*Query[T]) LeftJoin 

func (q *Query[T]) LeftJoin(table string, first string, args ...any) *Query[T]

LeftJoin adds a left join.

Example: 

conn.Select().From("users as u").LeftJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*Query[T]) LeftJoinFunc 

func (q *Query[T]) LeftJoinFunc(table string, fn func(*JoinClause)) *Query[T]

LeftJoinFunc adds a left join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").LeftJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNull("p.deleted_at")
})
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."deleted_at" IS NULL

func (*Query[T]) LeftJoinLateral added in v0.2.0 

func (q *Query[T]) LeftJoinLateral(sub *SelectBuilder, as string) *Query[T]

LeftJoinLateral is JoinLateral as a left join.

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").LeftJoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" LEFT JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE

func (*Query[T]) LeftJoinSub added in v0.2.0 

func (q *Query[T]) LeftJoinSub(sub *SelectBuilder, as string, first string, args ...any) *Query[T]

LeftJoinSub joins a subquery with a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").LeftJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1) AS
//     "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*Query[T]) LeftJoinSubFunc added in v0.2.0 

func (q *Query[T]) LeftJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *Query[T]

LeftJoinSubFunc is JoinSubFunc as a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").LeftJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNotNull("p.score")
})
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" IS NOT NULL

func (*Query[T]) LeftJoinWhere added in v0.2.0 

func (q *Query[T]) LeftJoinWhere(table string, column string, args ...any) *Query[T]

LeftJoinWhere is JoinWhere as a left join.

Example: 

conn.Select().From("users as u").LeftJoinWhere("posts as p", "p.score", ">", 10)
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."score" > $1
// args: [10]

func (*Query[T]) Limit 

func (q *Query[T]) Limit(n int) *Query[T]

Limit sets LIMIT; negative values are ignored.

Example: 

conn.Select().From("users").Limit(10)
// SELECT * FROM "users" LIMIT 10

func (*Query[T]) Lock added in v0.2.0 

func (q *Query[T]) Lock(clause string) *Query[T]

Lock appends a raw locking clause such as "FOR NO KEY UPDATE" (caller-trusted SQL; ignored on SQLite).

Example: 

conn.Select().From("jobs").Where("state", "queued").Limit(1).Lock("FOR NO KEY UPDATE")
// SELECT * FROM "jobs" WHERE "state" = $1 LIMIT 1 FOR NO KEY UPDATE   args: [queued]

func (*Query[T]) LockForUpdate 

func (q *Query[T]) LockForUpdate() *Query[T]

LockForUpdate adds "FOR UPDATE" (Postgres, MySQL; ignored on SQLite).

Example: 

conn.Select().From("accounts").Where("id", 1).LockForUpdate()
// Postgres: SELECT * FROM "accounts" WHERE "id" = $1 FOR UPDATE   args: [1]
// MySQL: SELECT * FROM `accounts` WHERE `id` = ? FOR UPDATE   args: [1]

func (*Query[T]) Offset 

func (q *Query[T]) Offset(n int) *Query[T]

Offset sets OFFSET; negative values clamp to 0.

Example: 

conn.Select().From("users").Limit(10).Offset(20)
// SELECT * FROM "users" LIMIT 10 OFFSET 20

func (*Query[T]) Oldest 

func (q *Query[T]) Oldest(column ...string) *Query[T]

Oldest orders by column ascending (default "created_at").

Example: 

conn.Select().From("posts").Oldest()
// SELECT * FROM "posts" ORDER BY "created_at" ASC

func (*Query[T]) OrHaving added in v0.2.0 

func (q *Query[T]) OrHaving(column string, args ...any) *Query[T]

OrHaving is Having joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	Having("user_id", ">", 10).OrHaving("user_id", 1)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING "user_id" > $1 OR "user_id" = $2
// args: [10 1]

func (*Query[T]) OrHavingBetween added in v0.2.0 

func (q *Query[T]) OrHavingBetween(column string, lo any, hi any) *Query[T]

OrHavingBetween is HavingBetween joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingBetween("spent", 100, 500).OrHavingBetween("user_id", 1, 3)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent"
//     BETWEEN $1 AND $2 OR "user_id" BETWEEN $3 AND $4
//     args: [100 500 1 3]

func (*Query[T]) OrHavingGroup added in v0.2.0 

func (q *Query[T]) OrHavingGroup(fn func(*HavingClause)) *Query[T]

OrHavingGroup is HavingGroup joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	SelectRaw("count(*) as n").Having("n", ">", 1).OrHavingGroup(func(q *db.HavingClause) {
	q.Having("spent", ">", 100).Having("n", "<", 3)
})
// SELECT "user_id", sum(total) as spent, count(*) as n FROM "orders" GROUP BY "user_id"
//     HAVING "n" > $1 OR ("spent" > $2 AND "n" < $3)
//     args: [1 100 3]

func (*Query[T]) OrHavingNotBetween added in v0.2.0 

func (q *Query[T]) OrHavingNotBetween(column string, lo any, hi any) *Query[T]

OrHavingNotBetween is HavingNotBetween joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotBetween("spent", 100, 500).OrHavingNotBetween("user_id", 1, 3)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" NOT
//     BETWEEN $1 AND $2 OR "user_id" NOT BETWEEN $3 AND $4
//     args: [100 500 1 3]

func (*Query[T]) OrHavingNotNull added in v0.2.0 

func (q *Query[T]) OrHavingNotNull(column string) *Query[T]

OrHavingNotNull is HavingNotNull joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotNull("spent").OrHavingNotNull("user_id")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NOT NULL OR "user_id" IS NOT NULL

func (*Query[T]) OrHavingNull added in v0.2.0 

func (q *Query[T]) OrHavingNull(column string) *Query[T]

OrHavingNull is HavingNull joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNull("spent").OrHavingNull("user_id")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NULL OR "user_id" IS NULL

func (*Query[T]) OrHavingRaw added in v0.2.0 

func (q *Query[T]) OrHavingRaw(sql string, args ...any) *Query[T]

OrHavingRaw is HavingRaw joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	HavingRaw("sum(amount) > ?", 100).OrHavingRaw("count(*) > ?", 5)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING sum(amount) > $1 OR count(*) > $2
// args: [100 5]

func (*Query[T]) OrWhere 

func (q *Query[T]) OrWhere(column string, args ...any) *Query[T]

OrWhere is Where joined with OR.

Example: 

conn.Select().From("users").Where("role", "admin").OrWhere("role", "owner")
// SELECT * FROM "users" WHERE "role" = $1 OR "role" = $2
// args: [admin owner]

func (*Query[T]) OrWhereAll added in v0.2.0 

func (q *Query[T]) OrWhereAll(columns []string, args ...any) *Query[T]

OrWhereAll is WhereAll joined with OR.

Example: 

conn.Select().From("users").WhereAll([]string{"a", "b"}, 1).OrWhereAll([]string{"c", "d"}, ">", 5)
// SELECT * FROM "users" WHERE ("a" = $1 AND "b" = $2) OR ("c" > $3 AND "d" > $4)
//     args: [1 1 5 5]

func (*Query[T]) OrWhereAny added in v0.2.0 

func (q *Query[T]) OrWhereAny(columns []string, args ...any) *Query[T]

OrWhereAny is WhereAny joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereAny([]string{"a", "b"}, ">", 5)
// SELECT * FROM "users" WHERE "active" = $1 OR ("a" > $2 OR "b" > $3)   args: [true 5 5]

func (*Query[T]) OrWhereBetween added in v0.2.0 

func (q *Query[T]) OrWhereBetween(column string, lo any, hi any) *Query[T]

OrWhereBetween is WhereBetween joined with OR.

Example: 

conn.Select().From("orders").Where("status", "paid").OrWhereBetween("total", 500, 900)
// SELECT * FROM "orders" WHERE "status" = $1 OR "total" BETWEEN $2 AND $3
//     args: [paid 500 900]

func (*Query[T]) OrWhereBetweenColumns added in v0.2.0 

func (q *Query[T]) OrWhereBetweenColumns(column string, c1 string, c2 string) *Query[T]

OrWhereBetweenColumns is WhereBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price").
	OrWhereBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price" OR "cost"
//     BETWEEN "low" AND "high"

func (*Query[T]) OrWhereColumn added in v0.2.0 

func (q *Query[T]) OrWhereColumn(first string, args ...any) *Query[T]

OrWhereColumn is WhereColumn joined with OR.

Example: 

conn.Select().From("users").WhereColumn("first_name", "last_name").OrWhereColumn("a", "<>", "b")
// SELECT * FROM "users" WHERE "first_name" = "last_name" OR "a" <> "b"

func (*Query[T]) OrWhereDate added in v0.2.0 

func (q *Query[T]) OrWhereDate(column string, args ...any) *Query[T]

OrWhereDate is WhereDate joined with OR.

Example: 

conn.Select().From("orders").WhereDate("created_at", "2024-01-15").
	OrWhereDate("created_at", "2024-02-01")
// SELECT * FROM "orders" WHERE "created_at"::DATE = $1 OR "created_at"::DATE = $2
//     args: [2024-01-15 2024-02-01]

func (*Query[T]) OrWhereDay added in v0.2.0 

func (q *Query[T]) OrWhereDay(column string, args ...any) *Query[T]

OrWhereDay is WhereDay joined with OR.

Example: 

conn.Select().From("orders").WhereDay("created_at", 15).OrWhereDay("created_at", ">", 20)
// SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1 OR EXTRACT(DAY FROM
//     "created_at") > $2
//     args: [15 20]

func (*Query[T]) OrWhereExists added in v0.2.0 

func (q *Query[T]) OrWhereExists(sub *SelectBuilder) *Query[T]

OrWhereExists is WhereExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*Query[T]) OrWhereGroup 

func (q *Query[T]) OrWhereGroup(fn func(*WhereClause)) *Query[T]

OrWhereGroup is WhereGroup joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").Where("age", ">", 30)
})
// SELECT * FROM "users" WHERE "active" = $1 OR ("role" = $2 AND "age" > $3)
//     args: [true admin 30]

func (*Query[T]) OrWhereIn 

func (q *Query[T]) OrWhereIn(column string, values any) *Query[T]

OrWhereIn is WhereIn joined with OR.

Example: 

conn.Select().From("users").WhereIn("role", []string{"ann", "bob"}).OrWhereIn("id", []int{9})
// SELECT * FROM "users" WHERE "role" IN ($1, $2) OR "id" IN ($3)   args: [ann bob 9]

func (*Query[T]) OrWhereIntegerInRaw added in v0.2.0 

func (q *Query[T]) OrWhereIntegerInRaw(column string, values any) *Query[T]

OrWhereIntegerInRaw is WhereIntegerInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1}).
	OrWhereIntegerInRaw("id", []int64{7, 8})
// SELECT * FROM "users" WHERE "id" IN (1) OR "id" IN (7, 8)

func (*Query[T]) OrWhereIntegerNotInRaw added in v0.2.0 

func (q *Query[T]) OrWhereIntegerNotInRaw(column string, values any) *Query[T]

OrWhereIntegerNotInRaw is WhereIntegerNotInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2}).
	OrWhereIntegerNotInRaw("id", []int{3})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2) OR "id" NOT IN (3)

func (*Query[T]) OrWhereJsonContains added in v0.2.0 

func (q *Query[T]) OrWhereJsonContains(column string, value any) *Query[T]

OrWhereJsonContains is WhereJsonContains joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR ("options"->'tags')::JSONB @> $2
// args: [true "go"]

func (*Query[T]) OrWhereJsonContainsKey added in v0.2.0 

func (q *Query[T]) OrWhereJsonContainsKey(column string) *Query[T]

OrWhereJsonContainsKey is WhereJsonContainsKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*Query[T]) OrWhereJsonDoesntContain added in v0.2.0 

func (q *Query[T]) OrWhereJsonDoesntContain(column string, value any) *Query[T]

OrWhereJsonDoesntContain is WhereJsonDoesntContain joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("options"->'tags')::JSONB @> $2
// args: [true "php"]

func (*Query[T]) OrWhereJsonDoesntContainKey added in v0.2.0 

func (q *Query[T]) OrWhereJsonDoesntContainKey(column string) *Query[T]

OrWhereJsonDoesntContainKey is WhereJsonDoesntContainKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).
	OrWhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1
//   OR NOT COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*Query[T]) OrWhereJsonDoesntOverlap added in v0.2.0 

func (q *Query[T]) OrWhereJsonDoesntOverlap(column string, value any) *Query[T]

OrWhereJsonDoesntOverlap is WhereJsonDoesntOverlap joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["php"]]

func (*Query[T]) OrWhereJsonLength added in v0.2.0 

func (q *Query[T]) OrWhereJsonLength(column string, args ...any) *Query[T]

OrWhereJsonLength is WhereJsonLength joined with OR.

Example: 

conn.Select().From("users").WhereJsonLength("options->tags", 0)
.OrWhereJsonLength("options->roles", ">=", 3).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   OR JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) >= $2   args: [0 3]

func (*Query[T]) OrWhereJsonOverlaps added in v0.2.0 

func (q *Query[T]) OrWhereJsonOverlaps(column string, value any) *Query[T]

OrWhereJsonOverlaps is WhereJsonOverlaps joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonOverlaps("options->tags", []string{"go"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["go"]]

func (*Query[T]) OrWhereLike added in v0.2.0 

func (q *Query[T]) OrWhereLike(column string, value any, caseSensitive ...bool) *Query[T]

OrWhereLike is WhereLike joined with OR.

Example: 

conn.Select().From("users").WhereLike("name", "an%").OrWhereLike("name", "bo%")
// SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1 OR "name"::TEXT ILIKE $2
//     args: [an% bo%]

func (*Query[T]) OrWhereMap added in v0.2.0 

func (q *Query[T]) OrWhereMap(m map[string]any) *Query[T]

OrWhereMap is WhereMap joined with OR.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"a": 1}).OrWhereMap(map[string]any{"b": 2})
// SELECT * FROM "users" WHERE ("a" = $1) OR ("b" = $2)   args: [1 2]

func (*Query[T]) OrWhereMonth added in v0.2.0 

func (q *Query[T]) OrWhereMonth(column string, args ...any) *Query[T]

OrWhereMonth is WhereMonth joined with OR.

Example: 

conn.Select().From("orders").WhereMonth("created_at", ">=", 6).OrWhereMonth("created_at", 1)
// SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") >= $1 OR EXTRACT(MONTH FROM
//     "created_at") = $2
//     args: [06 01]

func (*Query[T]) OrWhereNone added in v0.2.0 

func (q *Query[T]) OrWhereNone(columns []string, args ...any) *Query[T]

OrWhereNone is WhereNone joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereNone([]string{"a", "b"}, 0)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("a" = $2 OR "b" = $3)
//     args: [true 0 0]

func (*Query[T]) OrWhereNot added in v0.2.0 

func (q *Query[T]) OrWhereNot(column string, args ...any) *Query[T]

OrWhereNot adds "OR NOT <predicate>".

Example: 

conn.Select().From("users").Where("age", ">", 18).OrWhereNot("status", "<", 3)
// SELECT * FROM "users" WHERE "age" > $1 OR NOT "status" < $2   args: [18 3]

func (*Query[T]) OrWhereNotBetween added in v0.2.0 

func (q *Query[T]) OrWhereNotBetween(column string, lo any, hi any) *Query[T]

OrWhereNotBetween is WhereNotBetween joined with OR.

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100).OrWhereNotBetween("qty", 1, 5)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2 OR "qty" NOT BETWEEN $3 AND $4
//     args: [10 100 1 5]

func (*Query[T]) OrWhereNotBetweenColumns added in v0.2.0 

func (q *Query[T]) OrWhereNotBetweenColumns(column string, c1 string, c2 string) *Query[T]

OrWhereNotBetweenColumns is WhereNotBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price").
	OrWhereNotBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price" OR "cost"
//     NOT BETWEEN "low" AND "high"

func (*Query[T]) OrWhereNotExists added in v0.2.0 

func (q *Query[T]) OrWhereNotExists(sub *SelectBuilder) *Query[T]

OrWhereNotExists is WhereNotExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereNotExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*Query[T]) OrWhereNotIn added in v0.2.0 

func (q *Query[T]) OrWhereNotIn(column string, values any) *Query[T]

OrWhereNotIn is WhereNotIn joined with OR.

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2}).OrWhereNotIn("role", []string{"ann"})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2) OR "role" NOT IN ($3)   args: [1 2 ann]

func (*Query[T]) OrWhereNotLike added in v0.2.0 

func (q *Query[T]) OrWhereNotLike(column string, value any, caseSensitive ...bool) *Query[T]

OrWhereNotLike is WhereNotLike joined with OR.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%").OrWhereNotLike("name", "%demo%", true)
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1 OR "name"::TEXT NOT LIKE $2
//     args: [%test% %demo%]

func (*Query[T]) OrWhereNotNull added in v0.2.0 

func (q *Query[T]) OrWhereNotNull(column string) *Query[T]

OrWhereNotNull is WhereNotNull joined with OR.

Example: 

conn.Select().From("users").WhereNotNull("verified_at").OrWhereNotNull("invited_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL OR "invited_at" IS NOT NULL

func (*Query[T]) OrWhereNull 

func (q *Query[T]) OrWhereNull(column string) *Query[T]

OrWhereNull is WhereNull joined with OR.

Example: 

conn.Select().From("users").WhereNull("deleted_at").OrWhereNull("banned_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL OR "banned_at" IS NULL

func (*Query[T]) OrWhereNullSafeEquals added in v0.2.0 

func (q *Query[T]) OrWhereNullSafeEquals(column string, value any) *Query[T]

OrWhereNullSafeEquals is WhereNullSafeEquals joined with OR.

Example: 

conn.Select().From("users").WhereNullSafeEquals("a", 1).OrWhereNullSafeEquals("b", 2)
// SELECT * FROM "users" WHERE "a" IS NOT DISTINCT FROM $1 OR "b" IS NOT DISTINCT FROM $2
//     args: [1 2]

func (*Query[T]) OrWhereRaw 

func (q *Query[T]) OrWhereRaw(sql string, args ...any) *Query[T]

OrWhereRaw is WhereRaw joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereRaw("age between ? and ?", 18, 30)
// SELECT * FROM "users" WHERE "active" = $1 OR age between $2 and $3
// args: [true 18 30]

func (*Query[T]) OrWhereRowValues added in v0.2.0 

func (q *Query[T]) OrWhereRowValues(columns []string, op string, values []any) *Query[T]

OrWhereRowValues is WhereRowValues joined with OR.

Example: 

conn.Select().From("events").Where("kind", "x").
	OrWhereRowValues([]string{"a", "b"}, "=", []any{1, 2})
// SELECT * FROM "events" WHERE "kind" = $1 OR ("a", "b") = ($2, $3)   args: [x 1 2]

func (*Query[T]) OrWhereTime added in v0.2.0 

func (q *Query[T]) OrWhereTime(column string, args ...any) *Query[T]

OrWhereTime is WhereTime joined with OR.

Example: 

conn.Select().From("orders").WhereTime("created_at", "10:30:00").
	OrWhereTime("created_at", "<", "08:00:00")
// SELECT * FROM "orders" WHERE "created_at"::TIME = $1 OR "created_at"::TIME < $2
//     args: [10:30:00 08:00:00]

func (*Query[T]) OrWhereValueBetween added in v0.2.0 

func (q *Query[T]) OrWhereValueBetween(value any, c1 string, c2 string) *Query[T]

OrWhereValueBetween is WhereValueBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total").
	OrWhereValueBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total" OR $2 BETWEEN "a" AND
//     "b"
//     args: [50 7]

func (*Query[T]) OrWhereValueNotBetween added in v0.2.0 

func (q *Query[T]) OrWhereValueNotBetween(value any, c1 string, c2 string) *Query[T]

OrWhereValueNotBetween is WhereValueNotBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total").
	OrWhereValueNotBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total" OR $2 NOT BETWEEN
//     "a" AND "b"
//     args: [50 7]

func (*Query[T]) OrWhereYear added in v0.2.0 

func (q *Query[T]) OrWhereYear(column string, args ...any) *Query[T]

OrWhereYear is WhereYear joined with OR.

Example: 

conn.Select().From("orders").WhereYear("created_at", ">", 2020).OrWhereYear("created_at", 1999)
// SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") > $1 OR EXTRACT(YEAR FROM
//     "created_at") = $2
//     args: [2020 1999]

func (*Query[T]) OrderBy 

func (q *Query[T]) OrderBy(column string, direction ...string) *Query[T]

OrderBy adds ORDER BY column; direction is "asc" (default) or "desc".

Example: 

conn.Select().From("users").OrderBy("name").OrderBy("age", "desc")
// SELECT * FROM "users" ORDER BY "name" ASC, "age" DESC

func (*Query[T]) OrderByDesc 

func (q *Query[T]) OrderByDesc(column string) *Query[T]

OrderByDesc is OrderBy(column, "desc").

Example: 

conn.Select().From("users").OrderByDesc("created_at")
// SELECT * FROM "users" ORDER BY "created_at" DESC

func (*Query[T]) OrderByRaw 

func (q *Query[T]) OrderByRaw(sql string, args ...any) *Query[T]

OrderByRaw adds a raw ORDER BY expression (caller-trusted SQL).

Example: 

conn.Select().From("users").OrderByRaw("case when role = ? then 0 else 1 end", "admin")
// SELECT * FROM "users" ORDER BY case when role = $1 then 0 else 1 end
// args: [admin]

func (*Query[T]) Paginate 

func (q *Query[T]) Paginate(ctx context.Context, page, perPage int) (Paged[T], error)

Paginate counts the rows, then returns the requested 1-based page.

Example: 

p, err := db.From[User](conn).OrderBy("id").Paginate(ctx, 2, 2)
// SELECT COUNT(*) AS "aggregate" FROM "users"   args: []
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 2 OFFSET 2   args: []
// p.Items: [{3 cy 41}], p.Total: 3, p.CurrentPage: 2, p.LastPage: 2

func (*Query[T]) Reorder added in v0.2.0 

func (q *Query[T]) Reorder() *Query[T]

Reorder removes all existing ORDER BY clauses (including a union's).

Example: 

conn.Select().From("posts").OrderBy("title").Reorder()
// SELECT * FROM "posts"

func (*Query[T]) ReorderBy added in v0.2.0 

func (q *Query[T]) ReorderBy(column string, direction ...string) *Query[T]

ReorderBy is Reorder followed by OrderBy(column, direction).

Example: 

conn.Select().From("posts").OrderBy("title").ReorderBy("id", "desc")
// SELECT * FROM "posts" ORDER BY "id" DESC

func (*Query[T]) RightJoin 

func (q *Query[T]) RightJoin(table string, first string, args ...any) *Query[T]

RightJoin adds a right join.

Example: 

conn.Select().From("users as u").RightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*Query[T]) RightJoinFunc added in v0.2.0 

func (q *Query[T]) RightJoinFunc(table string, fn func(*JoinClause)) *Query[T]

RightJoinFunc adds a right join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").RightJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."score" > $1
// args: [10]

func (*Query[T]) RightJoinSub added in v0.2.0 

func (q *Query[T]) RightJoinSub(sub *SelectBuilder, as string, first string, args ...any) *Query[T]

RightJoinSub joins a subquery with a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").RightJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*Query[T]) RightJoinSubFunc added in v0.2.0 

func (q *Query[T]) RightJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *Query[T]

RightJoinSubFunc is JoinSubFunc as a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").RightJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id")
})
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id"

func (*Query[T]) RightJoinWhere added in v0.2.0 

func (q *Query[T]) RightJoinWhere(table string, column string, args ...any) *Query[T]

RightJoinWhere is JoinWhere as a right join.

Example: 

conn.Select().From("users as u").RightJoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*Query[T]) Select 

func (q *Query[T]) Select(columns ...string) *Query[T]

Select replaces the selected columns.

Example: 

conn.Select().From("users as u").Select("u.id", "u.name as full_name")
// SELECT "u"."id", "u"."name" AS "full_name" FROM "users" AS "u"

func (*Query[T]) SelectRaw 

func (q *Query[T]) SelectRaw(sql string, args ...any) *Query[T]

SelectRaw appends a raw select expression.

Example: 

conn.Select().From("orders").Select("user_id").
	SelectRaw("sum(amount) * ? as total", 1.1).GroupBy("user_id")
// SELECT "user_id", sum(amount) * $1 as total FROM "orders" GROUP BY "user_id"
// args: [1.1]

func (*Query[T]) SelectSub added in v0.2.0 

func (q *Query[T]) SelectSub(sub *SelectBuilder, as string) *Query[T]

SelectSub appends "(subquery) as alias" to the select list. The subquery is snapshotted: later changes to sub do not affect this query.

Example: 

n := conn.Select().From("posts").SelectRaw("count(*)").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Select("name").SelectSub(n, "post_count")
// SELECT "name", (SELECT count(*) FROM "posts" WHERE "posts"."user_id" = "users"."id") AS
//     "post_count" FROM "users"

func (*Query[T]) SharedLock 

func (q *Query[T]) SharedLock() *Query[T]

SharedLock adds "FOR SHARE" (Postgres) or "LOCK IN SHARE MODE" (MySQL); ignored on SQLite.

Example: 

conn.Select().From("accounts").Where("id", 1).SharedLock()
// Postgres: SELECT * FROM "accounts" WHERE "id" = $1 FOR SHARE   args: [1]
// MySQL: SELECT * FROM `accounts` WHERE `id` = ? LOCK IN SHARE MODE   args: [1]

func (*Query[T]) SimplePaginate 

func (q *Query[T]) SimplePaginate(ctx context.Context, page, perPage int) (SimplePaged[T], error)

SimplePaginate returns a page and whether another follows, without a count query.

Example: 

p, err := db.From[User](conn).OrderBy("id").SimplePaginate(ctx, 1, 2)
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 3 OFFSET 0   args: []
// len(p.Items): 2, p.HasMore: true

func (*Query[T]) Skip added in v0.2.0 

func (q *Query[T]) Skip(n int) *Query[T]

Skip is an alias of Offset.

Example: 

conn.Select().From("users").Take(10).Skip(5)
// SELECT * FROM "users" LIMIT 10 OFFSET 5

func (*Query[T]) Sole 

func (q *Query[T]) Sole(ctx context.Context) (T, error)

Sole returns the only matching row: ErrNotFound for none, ErrMultipleRecords for several.

Example: 

u, err := db.From[User](conn).Where("name", "ann").Sole(ctx)
// SELECT * FROM "users" WHERE "name" = $1 LIMIT 2   args: [ann]
// u.Name: ann; two rows: err is ErrMultipleRecords

func (*Query[T]) StraightJoin added in v0.2.0 

func (q *Query[T]) StraightJoin(table string, first string, args ...any) *Query[T]

StraightJoin adds a MySQL "straight_join"; other dialects error at compile time.

Example: 

connMy.Select().From("users as u").StraightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM `users` AS `u` STRAIGHT_JOIN `posts` AS `p` ON `p`.`user_id` = `u`.`id`
// connMy is db.Use(db.MySQL); other dialects return ErrUnsupported

func (*Query[T]) Stream 

func (q *Query[T]) Stream(ctx context.Context) iter.Seq2[T, error]

Stream yields rows one at a time; break out of the loop to stop early.

Example: 

for u, err := range db.From[User](conn).Stream(ctx) {
	if err != nil {
		break
	}
	fmt.Println(u.Name) // ann, then bob
}
// SELECT * FROM "users"   args: []

func (*Query[T]) Sum 

func (q *Query[T]) Sum(ctx context.Context, column string) (float64, error)

Sum returns sum(column) as float64 (0 when there are no rows).

Example: 

total, err := db.From[User](conn).Sum(ctx, "age")
// SELECT SUM("age") AS "aggregate" FROM "users"   args: []
// total: 86

func (*Query[T]) Take added in v0.2.0 

func (q *Query[T]) Take(n int) *Query[T]

Take is an alias of Limit.

Example: 

conn.Select().From("users").Take(5)
// SELECT * FROM "users" LIMIT 5

func (*Query[T]) Union added in v0.2.0 

func (q *Query[T]) Union(sub *SelectBuilder) *Query[T]

Union appends "UNION (query)". After a union, OrderBy/Limit/Offset apply to the combined result. On SQLite members are wrapped as "SELECT * FROM (...)".

Example: 

a := conn.Select().From("users").Select("name").Where("active", true)
b := conn.Select().From("admins").Select("name")
a.Union(b).OrderBy("name").Limit(10)
// (SELECT "name" FROM "users" WHERE "active" = $1) UNION (SELECT "name" FROM "admins") ORDER
//     BY "name" ASC LIMIT 10
//     args: [true]

func (*Query[T]) UnionAll added in v0.2.0 

func (q *Query[T]) UnionAll(sub *SelectBuilder) *Query[T]

UnionAll appends "UNION ALL (query)".

Example: 

a := conn.Select().From("users").Select("name").Where("active", true)
b := conn.Select().From("admins").Select("name")
a.UnionAll(b).OrderBy("name").Limit(10)
// (SELECT "name" FROM "users" WHERE "active" = $1) UNION ALL (SELECT "name" FROM "admins")
//     ORDER BY "name" ASC LIMIT 10
//     args: [true]

func (*Query[T]) Unless 

func (q *Query[T]) Unless(cond bool, fn func(*Query[T])) *Query[T]

Unless runs fn when cond is false.

Example: 

db.From[User](conn).Unless(includeMinors, func(q *db.Query[User]) { q.Where("age", ">=", 18) })
// includeMinors == false: SELECT * FROM "users" WHERE "age" >= $1   args: [18]

func (*Query[T]) UseIndex added in v0.2.0 

func (q *Query[T]) UseIndex(index string) *Query[T]

UseIndex adds "USE INDEX (a, b)" (MySQL; ignored on Postgres and SQLite). Index names are emitted unquoted and validated against [a-zA-Z0-9_$].

Example: 

conn.Select().From("users").UseIndex("idx_email").Where("active", true)
// SELECT * FROM `users` USE INDEX (idx_email) WHERE `active` = ?   args: [true]

func (*Query[T]) When 

func (q *Query[T]) When(cond bool, fn func(*Query[T])) *Query[T]

When runs fn when cond is true.

Example: 

db.From[User](conn).When(onlyAdults, func(q *db.Query[User]) { q.Where("age", ">=", 18) })
// onlyAdults == true: SELECT * FROM "users" WHERE "age" >= $1   args: [18]

func (*Query[T]) Where 

func (q *Query[T]) Where(column string, args ...any) *Query[T]

Where adds an AND predicate. Forms: Where(col, value) means "="; Where(col, op, value). A nil value with "=" / "!=" / "<>" becomes IS [NOT] NULL.

Example: 

conn.Select().From("users").Where("active", true).Where("age", ">=", 18)
// SELECT * FROM "users" WHERE "active" = $1 AND "age" >= $2
// args: [true 18]

func (*Query[T]) WhereAll added in v0.2.0 

func (q *Query[T]) WhereAll(columns []string, args ...any) *Query[T]

WhereAll requires the predicate to hold for every column: (a = ? and b = ?).

Example: 

conn.Select().From("users").WhereAll([]string{"first_name", "last_name"}, "like", "an%")
// SELECT * FROM "users" WHERE ("first_name"::TEXT LIKE $1 AND "last_name"::TEXT LIKE $2)
//     args: [an% an%]

func (*Query[T]) WhereAny added in v0.2.0 

func (q *Query[T]) WhereAny(columns []string, args ...any) *Query[T]

WhereAny requires the predicate to hold for at least one column: (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereAny([]string{"first_name", "last_name"}, "ann")
// SELECT * FROM "users" WHERE ("first_name" = $1 OR "last_name" = $2)   args: [ann ann]

func (*Query[T]) WhereBetween 

func (q *Query[T]) WhereBetween(column string, lo any, hi any) *Query[T]

WhereBetween adds "col BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" BETWEEN $1 AND $2   args: [10 100]

func (*Query[T]) WhereBetweenColumns added in v0.2.0 

func (q *Query[T]) WhereBetweenColumns(column string, c1 string, c2 string) *Query[T]

WhereBetweenColumns adds "col BETWEEN c1 AND c2" comparing against columns.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price"

func (*Query[T]) WhereColumn 

func (q *Query[T]) WhereColumn(first string, args ...any) *Query[T]

WhereColumn compares two columns: WhereColumn(a, b) means "=", or WhereColumn(a, op, b).

Example: 

conn.Select().From("users").WhereColumn("updated_at", ">", "created_at")
// SELECT * FROM "users" WHERE "updated_at" > "created_at"

func (*Query[T]) WhereDate added in v0.2.0 

func (q *Query[T]) WhereDate(column string, args ...any) *Query[T]

WhereDate compares the date part of a column.

Example: 

conn.Select().From("orders").WhereDate("created_at", ">=", "2024-01-15")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::DATE >= $1   args: [2024-01-15]
// MySQL: SELECT * FROM `orders` WHERE DATE(`created_at`) >= ?   args: [2024-01-15]
// SQLite: SELECT * FROM "orders" WHERE STRFTIME('%Y-%m-%d', "created_at") >= CAST(? AS TEXT)
//     args: [2024-01-15]

func (*Query[T]) WhereDay added in v0.2.0 

func (q *Query[T]) WhereDay(column string, args ...any) *Query[T]

WhereDay compares the day-of-month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereDay("created_at", 15)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1   args: [15]
// MySQL: SELECT * FROM `orders` WHERE DAY(`created_at`) = ?   args: [15]

func (*Query[T]) WhereExists 

func (q *Query[T]) WhereExists(sub *SelectBuilder) *Query[T]

WhereExists adds "EXISTS (subquery)". Build sub with DB.Select.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereExists(posts)
// SELECT * FROM "users" WHERE EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*Query[T]) WhereGroup 

func (q *Query[T]) WhereGroup(fn func(*WhereClause)) *Query[T]

WhereGroup wraps the predicates added inside fn in parentheses. fn receives a fresh WhereClause; only its Where* calls are used.

Example: 

conn.Select().From("users").Where("active", true).WhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").OrWhere("role", "editor")
})
// SELECT * FROM "users" WHERE "active" = $1 AND ("role" = $2 OR "role" = $3)
//     args: [true admin editor]

func (*Query[T]) WhereIn 

func (q *Query[T]) WhereIn(column string, values any) *Query[T]

WhereIn adds "col IN (...)". values may be any slice, a scalar, or a *SelectBuilder subquery. An empty list compiles to the always-false "0 = 1".

Example: 

conn.Select().From("users").WhereIn("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN ($1, $2, $3)   args: [1 2 3]

func (*Query[T]) WhereIntegerInRaw added in v0.2.0 

func (q *Query[T]) WhereIntegerInRaw(column string, values any) *Query[T]

WhereIntegerInRaw inlines integers (no bind args); non-integers record an error. Useful for very large ID lists that would exceed driver parameter limits.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN (1, 2, 3)

func (*Query[T]) WhereIntegerNotInRaw added in v0.2.0 

func (q *Query[T]) WhereIntegerNotInRaw(column string, values any) *Query[T]

WhereIntegerNotInRaw is the negated WhereIntegerInRaw.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2)

func (*Query[T]) WhereJsonContains added in v0.2.0 

func (q *Query[T]) WhereJsonContains(column string, value any) *Query[T]

WhereJsonContains adds a JSON containment test on a column or "col->path". MySQL json_contains, Postgres @> (jsonb), SQLite json_each membership.

Example: 

conn.Select().From("users").WhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE ("options"->'tags')::JSONB @> $1   args: ["go"]

func (*Query[T]) WhereJsonContainsKey added in v0.2.0 

func (q *Query[T]) WhereJsonContainsKey(column string) *Query[T]

WhereJsonContainsKey tests that the JSON path "col->key" exists.

Example: 

conn.Select().From("users").WhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []
// MySQL: SELECT * FROM `users`
//   WHERE IFNULL(JSON_CONTAINS_PATH(`options`, 'one', '$."theme"'), 0)

func (*Query[T]) WhereJsonDoesntContain added in v0.2.0 

func (q *Query[T]) WhereJsonDoesntContain(column string, value any) *Query[T]

WhereJsonDoesntContain negates WhereJsonContains.

Example: 

conn.Select().From("users").WhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE NOT ("options"->'tags')::JSONB @> $1   args: ["php"]

func (*Query[T]) WhereJsonDoesntContainKey added in v0.2.0 

func (q *Query[T]) WhereJsonDoesntContainKey(column string) *Query[T]

WhereJsonDoesntContainKey negates WhereJsonContainsKey.

Example: 

conn.Select().From("users").WhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE NOT COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []

func (*Query[T]) WhereJsonDoesntOverlap added in v0.2.0 

func (q *Query[T]) WhereJsonDoesntOverlap(column string, value any) *Query[T]

WhereJsonDoesntOverlap negates WhereJsonOverlaps.

Example: 

conn.Select().From("users")
.WhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["php"]]

func (*Query[T]) WhereJsonLength added in v0.2.0 

func (q *Query[T]) WhereJsonLength(column string, args ...any) *Query[T]

WhereJsonLength compares the length of a JSON array: (value) or (operator, value).

Example: 

conn.Select().From("users")
.WhereJsonLength("options->tags", 2).WhereJsonLength("options->roles", ">", 1).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   AND JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) > $2   args: [2 1]

func (*Query[T]) WhereJsonOverlaps added in v0.2.0 

func (q *Query[T]) WhereJsonOverlaps(column string, value any) *Query[T]

WhereJsonOverlaps adds json_overlaps (MySQL only; other dialects error at compile time).

Example: 

conn.Select().From("users")
.WhereJsonOverlaps("options->tags", []string{"go", "sql"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["go","sql"]]

func (*Query[T]) WhereLike 

func (q *Query[T]) WhereLike(column string, value any, caseSensitive ...bool) *Query[T]

WhereLike adds a LIKE predicate, case-insensitive unless caseSensitive[0] is true. Postgres: ILIKE/LIKE. MySQL: LIKE/LIKE BINARY. SQLite: LIKE/GLOB (pattern converted).

Example: 

conn.Select().From("users").WhereLike("name", "An%")
// Postgres: SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1   args: [An%]
// MySQL: SELECT * FROM `users` WHERE `name` LIKE ?   args: [An%]
// SQLite: SELECT * FROM "users" WHERE "name" LIKE ?   args: [An%]

func (*Query[T]) WhereMap added in v0.2.0 

func (q *Query[T]) WhereMap(m map[string]any) *Query[T]

WhereMap adds one grouped "a = ? and b = ?" predicate; keys are sorted for stable SQL.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"role": "ann", "active": true})
// SELECT * FROM "users" WHERE ("active" = $1 AND "role" = $2)   args: [true ann]

func (*Query[T]) WhereMonth added in v0.2.0 

func (q *Query[T]) WhereMonth(column string, args ...any) *Query[T]

WhereMonth compares the month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereMonth("created_at", 3)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") = $1   args: [03]
// MySQL: SELECT * FROM `orders` WHERE MONTH(`created_at`) = ?   args: [03]

func (*Query[T]) WhereNone added in v0.2.0 

func (q *Query[T]) WhereNone(columns []string, args ...any) *Query[T]

WhereNone requires the predicate to hold for no column: not (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereNone([]string{"first_name", "last_name"}, "like", "%test%")
// SELECT * FROM "users" WHERE NOT ("first_name"::TEXT LIKE $1 OR "last_name"::TEXT LIKE $2)
//     args: [%test% %test%]

func (*Query[T]) WhereNot 

func (q *Query[T]) WhereNot(column string, args ...any) *Query[T]

WhereNot adds "AND NOT <predicate>".

Example: 

conn.Select().From("users").WhereNot("role", "admin")
// SELECT * FROM "users" WHERE NOT "role" = $1   args: [admin]

func (*Query[T]) WhereNotBetween 

func (q *Query[T]) WhereNotBetween(column string, lo any, hi any) *Query[T]

WhereNotBetween adds "col NOT BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2   args: [10 100]

func (*Query[T]) WhereNotBetweenColumns added in v0.2.0 

func (q *Query[T]) WhereNotBetweenColumns(column string, c1 string, c2 string) *Query[T]

WhereNotBetweenColumns is the negated WhereBetweenColumns.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price"

func (*Query[T]) WhereNotExists 

func (q *Query[T]) WhereNotExists(sub *SelectBuilder) *Query[T]

WhereNotExists adds "NOT EXISTS (subquery)".

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereNotExists(posts)
// SELECT * FROM "users" WHERE NOT EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*Query[T]) WhereNotIn 

func (q *Query[T]) WhereNotIn(column string, values any) *Query[T]

WhereNotIn adds "col NOT IN (...)". An empty list compiles to "1 = 1".

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2)   args: [1 2]

func (*Query[T]) WhereNotLike added in v0.2.0 

func (q *Query[T]) WhereNotLike(column string, value any, caseSensitive ...bool) *Query[T]

WhereNotLike is the negated WhereLike.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%")
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1   args: [%test%]

func (*Query[T]) WhereNotNull 

func (q *Query[T]) WhereNotNull(column string) *Query[T]

WhereNotNull adds "col IS NOT NULL".

Example: 

conn.Select().From("users").WhereNotNull("verified_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL

func (*Query[T]) WhereNull 

func (q *Query[T]) WhereNull(column string) *Query[T]

WhereNull adds "col IS NULL".

Example: 

conn.Select().From("users").WhereNull("deleted_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL

func (*Query[T]) WhereNullSafeEquals added in v0.2.0 

func (q *Query[T]) WhereNullSafeEquals(column string, value any) *Query[T]

WhereNullSafeEquals compares with NULL-safe equality (<=>, IS NOT DISTINCT FROM, IS).

Example: 

conn.Select().From("users").WhereNullSafeEquals("manager_id", 7)
// Postgres: SELECT * FROM "users" WHERE "manager_id" IS NOT DISTINCT FROM $1   args: [7]
// MySQL: SELECT * FROM `users` WHERE `manager_id` <=> ?   args: [7]

func (*Query[T]) WhereRaw 

func (q *Query[T]) WhereRaw(sql string, args ...any) *Query[T]

WhereRaw adds a raw predicate (caller-trusted SQL).

Example: 

conn.Select().From("users").WhereRaw("lower(name) = ?", "ann")
// SELECT * FROM "users" WHERE lower(name) = $1
// args: [ann]

func (*Query[T]) WhereRowValues added in v0.2.0 

func (q *Query[T]) WhereRowValues(columns []string, op string, values []any) *Query[T]

WhereRowValues adds "(a, b) op (?, ?)".

Example: 

conn.Select().From("events").
	WhereRowValues([]string{"created_at", "id"}, ">", []any{"2024-01-15", 42})
// SELECT * FROM "events" WHERE ("created_at", "id") > ($1, $2)   args: [2024-01-15 42]

func (*Query[T]) WhereTime added in v0.2.0 

func (q *Query[T]) WhereTime(column string, args ...any) *Query[T]

WhereTime compares the time part of a column.

Example: 

conn.Select().From("orders").WhereTime("created_at", ">", "10:30:00")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::TIME > $1   args: [10:30:00]
// MySQL: SELECT * FROM `orders` WHERE TIME(`created_at`) > ?   args: [10:30:00]

func (*Query[T]) WhereValueBetween added in v0.2.0 

func (q *Query[T]) WhereValueBetween(value any, c1 string, c2 string) *Query[T]

WhereValueBetween adds "? BETWEEN c1 AND c2" (a value between two columns).

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total"   args: [50]

func (*Query[T]) WhereValueNotBetween added in v0.2.0 

func (q *Query[T]) WhereValueNotBetween(value any, c1 string, c2 string) *Query[T]

WhereValueNotBetween is the negated WhereValueBetween.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total"   args: [50]

func (*Query[T]) WhereYear added in v0.2.0 

func (q *Query[T]) WhereYear(column string, args ...any) *Query[T]

WhereYear compares the year of a column.

Example: 

conn.Select().From("orders").WhereYear("created_at", 2024)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") = $1
//     args: [2024]
// MySQL: SELECT * FROM `orders` WHERE YEAR(`created_at`) = ?   args: [2024]

func (*Query[T]) With 

func (q *Query[T]) With(name string, sub *SelectBuilder, opts ...CTEOption) *Query[T]

With adds a common table expression: "with name as (q)". The name is a table reference, so the table prefix applies to it as it does to From. The subquery is snapshotted: later changes to q do not affect this query. Options name the columns (CTEColumns) or hint materialization (CTEMaterialized, CTENotMaterialized).

On a select, a CTE can feed the query, a subquery, a union member, Count, Exists and Paginate. On an update or delete it is written before the verb (PostgreSQL, MySQL 8, SQLite; MariaDB returns ErrUnsupported). On an insert it is moved into the SELECT given to Using, so it needs Using.

Example: 

active := conn.Select().From("users").Where("active", true)
conn.Select().From("active_users").With("active_users", active)
// WITH "active_users" AS (SELECT * FROM "users" WHERE "active" = $1) SELECT * FROM
//     "active_users"
// args: [true]

func (*Query[T]) WithRaw 

func (q *Query[T]) WithRaw(name string, e Expression, opts ...CTEOption) *Query[T]

WithRaw adds a common table expression whose body is a raw SQL fragment (caller-trusted SQL), e.g. db.Raw("values (?), (?)", 1, 2). It takes the same options as With.

Example: 

conn.Select().From("ids").WithRaw("ids", db.Raw("values (?), (?)", 1, 2), db.CTEColumns("id"))
// WITH "ids" ("id") AS (values ($1), ($2)) SELECT * FROM "ids"
// args: [1 2]

func (*Query[T]) WithRecursive 

func (q *Query[T]) WithRecursive(name string, anchor *SelectBuilder, step *SelectBuilder, opts ...CTEOption) *Query[T]

WithRecursive adds a recursive common table expression and switches the clause to "with recursive". anchor is the starting query and step the recursive member that refers to name; they are joined with UNION ALL (CTEUnionDistinct for UNION) and written without parentheses, because SQLite rejects a recursive reference inside a subquery. Neither query is modified, and anchor must not have unions.

Example: 

anchor := conn.Select().From("categories").Where("parent_id", nil)
step := conn.Select().From("categories as c").Join("tree as t", "c.parent_id", "t.id")
conn.Select().From("tree").WithRecursive("tree", anchor, step)
// WITH RECURSIVE "tree" AS (SELECT * FROM "categories" WHERE "parent_id" IS NULL UNION ALL
//     SELECT * FROM "categories" AS "c" INNER JOIN "tree" AS "t" ON "c"."parent_id" =
//     "t"."id") SELECT * FROM "tree"

type QueryEvent 

type QueryEvent struct {
	SQL      string
	NumArgs  int
	Args     []any // only set when WithLogArgs is enabled: bind values may be personal data
	Duration time.Duration
	Err      error
}

QueryEvent describes one executed statement, for hooks.

Example: 

hook := func(_ context.Context, ev db.QueryEvent) {
	log.Println(ev.SQL, ev.NumArgs, ev.Duration, ev.Err)
}
conn := db.New(sqlDB, db.Postgres, db.WithHook(hook))
// ev.Args stays nil unless db.WithLogArgs() is also passed

type SelectBuilder added in v0.2.0 

type SelectBuilder struct {
	// contains filtered or unexported fields
}

SelectBuilder is a mutable, fluent SELECT query. Not safe for concurrent use; call Clone to branch a query. Start one with DB.Select.

Most chain methods are generated into chain_gen.go from the query type; the ones below take or return a SelectBuilder themselves.

func (*SelectBuilder) AddSelect added in v0.2.0 

func (s *SelectBuilder) AddSelect(columns ...string) *SelectBuilder

AddSelect appends columns.

Example: 

conn.Select().From("users").Select("id").AddSelect("name", "age")
// SELECT "id", "name", "age" FROM "users"

func (*SelectBuilder) Aggregate added in v0.2.0 

func (s *SelectBuilder) Aggregate(ctx context.Context, fn string, column string, dest any) error

Aggregate runs fn(column) and scans the result into dest (a pointer to a scalar). Min/Max/Sum over no rows yield NULL, which leaves dest at its zero value.

Example: 

var total int64
err := conn.Select().From("orders").Aggregate(ctx, "sum", "total", &total)
// SELECT SUM("total") AS "aggregate" FROM "orders"
// total = 250

func (*SelectBuilder) AggregateSQL added in v0.2.0 

func (s *SelectBuilder) AggregateSQL(fn string, column string) (string, []any, error)

AggregateSQL builds "SELECT fn(column) AS aggregate FROM ...". Queries with group by, having, union, distinct, limit or offset are wrapped as "SELECT fn(column) AS aggregate FROM (<query>) AS aggregate_table" so the aggregate covers the final row set. Ordering is dropped when it cannot matter.

Example: 

sqlText, args, err := conn.Select().From("orders").Where("status", "paid").AggregateSQL("sum", "total")
// SELECT SUM("total") AS "aggregate" FROM "orders" WHERE "status" = $1   args: ["paid"]

func (*SelectBuilder) Avg added in v0.2.0 

func (s *SelectBuilder) Avg(ctx context.Context, column string) (float64, error)

Avg returns avg(column) as float64 (0 when there are no rows).

Example: 

avg, err := conn.Select().From("orders").Avg(ctx, "total")
// SELECT AVG("total") AS "aggregate" FROM "orders"
// avg = 50.1

func (*SelectBuilder) Chunk added in v0.2.0 

func (s *SelectBuilder) Chunk(ctx context.Context, size int, dest any, fn func() (bool, error)) error

Chunk reads size rows at a time into dest (a pointer to a slice, refilled each round) and calls fn; return false to stop early. The query must have an ORDER BY (ErrNoOrder otherwise). It pages by offset, so rows changed by fn can be skipped or repeated: prefer ChunkByID when fn updates the filtered column.

Example: 

var batch []User
err := conn.Select().From("users").OrderBy("id").Chunk(ctx, 2, &batch, func() (bool, error) {
	return true, nil // false stops early
})
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 2 OFFSET 0
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 2 OFFSET 2   (until a short batch)

func (*SelectBuilder) ChunkByID added in v0.2.0 

func (s *SelectBuilder) ChunkByID(ctx context.Context, size int, dest any, fn func() (bool, error), column ...string) error

ChunkByID is Chunk using keyset paging on a unique column (default "id"), so it is safe while fn updates or deletes the rows it was given. Any OrderBy on the query is replaced by the key order, and a query with a Union returns ErrInvalidArgs (wrap it with FromSub first).

Example: 

var batch []User
err := conn.Select().From("users").ChunkByID(ctx, 2, &batch, func() (bool, error) {
	return true, nil
})
// SELECT * FROM "users" WHERE "id" IS NOT NULL ORDER BY "id" ASC LIMIT 2
// SELECT * FROM "users" WHERE "id" > $1 ORDER BY "id" ASC LIMIT 2   args: [2]
// another key column: ChunkByID(ctx, 5, &batch, fn, "order_no")

func (*SelectBuilder) Clone added in v0.2.0 

func (s *SelectBuilder) Clone() *SelectBuilder

Clone returns an independent copy. Cloning a nil *SelectBuilder returns nil.

Example: 

base := conn.Select().From("users").Where("active", true)
admins := base.Clone().Where("role", "admin")
// base:   SELECT * FROM "users" WHERE "active" = $1
// admins: SELECT * FROM "users" WHERE "active" = $1 AND "role" = $2
// args: [true admin] (admins)

func (*SelectBuilder) Count added in v0.2.0 

func (s *SelectBuilder) Count(ctx context.Context, column ...string) (int64, error)

Count returns count(*), or count(column) when a column is given.

Example: 

n, err := conn.Select().From("users").Where("active", true).Count(ctx)
// SELECT COUNT(*) AS "aggregate" FROM "users" WHERE "active" = $1   args: [true]
// n = 3
n, err = conn.Select().From("users").Count(ctx, "email_verified_at")
// SELECT COUNT("email_verified_at") AS "aggregate" FROM "users"

func (*SelectBuilder) CrossJoin added in v0.2.0 

func (s *SelectBuilder) CrossJoin(table string) *SelectBuilder

CrossJoin adds "CROSS JOIN table".

Example: 

conn.Select().From("users").CrossJoin("roles")
// SELECT * FROM "users" CROSS JOIN "roles"

func (*SelectBuilder) CrossJoinSub added in v0.2.0 

func (s *SelectBuilder) CrossJoinSub(sub *SelectBuilder, as string) *SelectBuilder

CrossJoinSub cross joins a subquery.

Example: 

sub := conn.Select().From("roles").Select("name").Where("active", true)
conn.Select().From("users").CrossJoinSub(sub, "r")
// SELECT * FROM "users" CROSS JOIN (SELECT "name" FROM "roles" WHERE "active" = $1) AS "r"
// args: [true]

func (*SelectBuilder) CursorPaginate added in v0.2.0 

func (s *SelectBuilder) CursorPaginate(ctx context.Context, perPage int, cursor string, dest any, opt ...CursorOptions) (CursorPage, error)

CursorPaginate pages forward by keyset on opt.Column. Pass the previous page's NextCursor (empty for the first page). It replaces any existing ORDER BY. The cursor is an opaque token; its value is only ever bound as an argument.

Example: 

var users []User
p, err := conn.Select().From("users").CursorPaginate(ctx, 2, "", &users)
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 3
// next page: conn.Select().From("users").CursorPaginate(ctx, 2, p.NextCursor, &users)
// SELECT * FROM "users" WHERE "id" > $1 ORDER BY "id" ASC LIMIT 3   args: [2]

func (*SelectBuilder) Distinct added in v0.2.0 

func (s *SelectBuilder) Distinct() *SelectBuilder

Distinct marks the query SELECT DISTINCT.

Example: 

conn.Select().From("posts").Distinct().Select("user_id")
// SELECT DISTINCT "user_id" FROM "posts"

func (*SelectBuilder) DoesntExist added in v0.2.0 

func (s *SelectBuilder) DoesntExist(ctx context.Context) (bool, error)

DoesntExist is the negation of Exists.

Example: 

missing, err := conn.Select().From("users").Where("name", "zed").DoesntExist(ctx)
// SELECT EXISTS(SELECT * FROM "users" WHERE "name" = $1) AS "exists"   args: ["zed"]
// missing = true when no row matches

func (*SelectBuilder) Each added in v0.2.0 

func (s *SelectBuilder) Each(ctx context.Context, dest any, fn func() error) error

Each streams rows one at a time into dest (a pointer to a struct, map or scalar, reset before every row) and calls fn, holding a single row in memory.

Example: 

var u User
err := conn.Select().From("users").OrderBy("id").Each(ctx, &u, func() error {
	fmt.Println(u.ID, u.Name) // u is refilled for every row
	return nil
})
// SELECT * FROM "users" ORDER BY "id" ASC

func (*SelectBuilder) Err added in v0.2.0 

func (s *SelectBuilder) Err() error

Err returns the first error recorded while building.

Example: 

q := conn.Select().From("users").Where("id", "!!", 1)
err := q.Err()
// err: quill: invalid operator: "!!"

func (*SelectBuilder) Exists added in v0.2.0 

func (s *SelectBuilder) Exists(ctx context.Context) (bool, error)

Exists reports whether any row matches.

Example: 

ok, err := conn.Select().From("users").Where("name", "ann").Exists(ctx)
// SELECT EXISTS(SELECT * FROM "users" WHERE "name" = $1) AS "exists"   args: ["ann"]
// ok = true

func (*SelectBuilder) ExistsSQL added in v0.2.0 

func (s *SelectBuilder) ExistsSQL() (string, []any, error)

ExistsSQL builds "SELECT EXISTS(<query>) AS "exists"".

Example: 

sqlText, args, err := conn.Select().From("users").Where("name", "ann").ExistsSQL()
// SELECT EXISTS(SELECT * FROM "users" WHERE "name" = $1) AS "exists"   args: ["ann"]

func (*SelectBuilder) Find added in v0.2.0 

func (s *SelectBuilder) Find(ctx context.Context, id any, dest any) error

Find is Where("id", id).First.

Example: 

var u User
err := conn.Select().From("users").Find(ctx, 2, &u)
// SELECT * FROM "users" WHERE "id" = $1 LIMIT 1   args: [2]

func (*SelectBuilder) First added in v0.2.0 

func (s *SelectBuilder) First(ctx context.Context, dest any) error

First scans the first row into dest (*struct, *map[string]any or *scalar). It returns ErrNotFound when nothing matches.

Example: 

var u User
err := conn.Select().From("users").OrderBy("id").First(ctx, &u)
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 1
// no row: errors.Is(err, db.ErrNotFound) is true

func (*SelectBuilder) ForPage added in v0.2.0 

func (s *SelectBuilder) ForPage(page int, perPage int) *SelectBuilder

ForPage sets offset/limit for a 1-based page.

Example: 

conn.Select().From("users").OrderBy("id").ForPage(3, 25) // page 3, 25 rows per page
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 25 OFFSET 50

func (*SelectBuilder) ForPageAfterID added in v0.2.0 

func (s *SelectBuilder) ForPageAfterID(perPage int, lastID any, column ...string) *SelectBuilder

ForPageAfterID pages forwards by keyset: "id > lastID ORDER BY id ASC LIMIT n".

Example: 

conn.Select().From("posts").ForPageAfterID(10, 42)
// SELECT * FROM "posts" WHERE "id" > $1 ORDER BY "id" ASC LIMIT 10   args: [42]

func (*SelectBuilder) ForPageBeforeID added in v0.2.0 

func (s *SelectBuilder) ForPageBeforeID(perPage int, lastID any, column ...string) *SelectBuilder

ForPageBeforeID pages backwards by keyset: "id < lastID ORDER BY id DESC LIMIT n". A nil lastID selects "id IS NOT NULL". column defaults to "id".

Example: 

conn.Select().From("posts").ForPageBeforeID(10, 42)
// SELECT * FROM "posts" WHERE "id" < $1 ORDER BY "id" DESC LIMIT 10   args: [42]

func (*SelectBuilder) ForceIndex added in v0.2.0 

func (s *SelectBuilder) ForceIndex(index string) *SelectBuilder

ForceIndex adds "FORCE INDEX (a)" (MySQL) or "INDEXED BY a" (SQLite, one name).

Example: 

conn.Select().From("users").ForceIndex("idx_email").Where("active", true)
// MySQL: SELECT * FROM `users` FORCE INDEX (idx_email) WHERE `active` = ?   args: [true]
// SQLite: SELECT * FROM "users" INDEXED BY idx_email WHERE "active" = ?   args: [true]

func (*SelectBuilder) From added in v0.2.0 

func (s *SelectBuilder) From(table string) *SelectBuilder

From sets the table ("users", "users as u", "schema.users").

Example: 

db.Use(db.Postgres).Select().From("public.users as u")
// SELECT * FROM "public"."users" AS "u"

func (*SelectBuilder) FromRaw added in v0.2.0 

func (s *SelectBuilder) FromRaw(sql string, args ...any) *SelectBuilder

FromRaw uses a raw SQL fragment as the source (caller-trusted SQL).

Example: 

conn.Select().FromRaw("generate_series(?, ?) as g", 1, 3)
// SELECT * FROM generate_series($1, $2) as g   args: [1 3]

func (*SelectBuilder) FromSub added in v0.2.0 

func (s *SelectBuilder) FromSub(sub *SelectBuilder, as string) *SelectBuilder

FromSub uses "(subquery) as alias" as the source.

Example: 

top := conn.Select().From("orders").SelectRaw("user_id, sum(total) as spent").GroupBy("user_id")
conn.Select().FromSub(top, "t").Where("spent", ">", 100)
// SELECT * FROM (SELECT user_id, sum(total) as spent FROM "orders" GROUP BY "user_id") AS
//     "t" WHERE "spent" > $1
//     args: [100]

func (*SelectBuilder) Get added in v0.2.0 

func (s *SelectBuilder) Get(ctx context.Context, dest any) error

Get runs the query and scans every row into dest: a pointer to a slice of structs (`db:"col"` tags, else snake_case field names), pointers to structs, map[string]any, or scalars (single column). NULL leaves a plain field at its zero value; use pointer or sql.Null* fields to tell NULL apart.

Example: 

var users []User // or []map[string]any, or []string for one column
err := conn.Select().From("users").Where("active", true).OrderBy("id").Get(ctx, &users)
// SELECT * FROM "users" WHERE "active" = $1 ORDER BY "id" ASC   args: [true]

func (*SelectBuilder) GroupBy added in v0.2.0 

func (s *SelectBuilder) GroupBy(columns ...string) *SelectBuilder

GroupBy adds GROUP BY columns.

Example: 

conn.Select().From("orders").Select("user_id", "status").GroupBy("user_id", "status")
// SELECT "user_id", "status" FROM "orders" GROUP BY "user_id", "status"

func (*SelectBuilder) GroupByRaw added in v0.2.0 

func (s *SelectBuilder) GroupByRaw(sql string, args ...any) *SelectBuilder

GroupByRaw adds a raw GROUP BY expression.

Example: 

conn.Select().From("orders").SelectRaw("date_trunc('day', created_at) as day").
	GroupByRaw("date_trunc('day', created_at)")
// SELECT date_trunc('day', created_at) as day FROM "orders" GROUP BY date_trunc('day',
//     created_at)

func (*SelectBuilder) Having added in v0.2.0 

func (s *SelectBuilder) Having(column string, args ...any) *SelectBuilder

Having adds an AND HAVING predicate; same argument forms as Where.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	Having("user_id", ">", 10)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING "user_id" > $1
// args: [10]

func (*SelectBuilder) HavingBetween added in v0.2.0 

func (s *SelectBuilder) HavingBetween(column string, lo any, hi any) *SelectBuilder

HavingBetween adds "col BETWEEN lo AND hi" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingBetween("spent", 100, 500)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent"
//     BETWEEN $1 AND $2
//     args: [100 500]

func (*SelectBuilder) HavingGroup added in v0.2.0 

func (s *SelectBuilder) HavingGroup(fn func(*HavingClause)) *SelectBuilder

HavingGroup wraps the Having* predicates added inside fn in parentheses.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	SelectRaw("count(*) as n").HavingGroup(func(q *db.HavingClause) {
	q.Having("spent", ">", 100).OrHaving("n", ">", 5)
})
// SELECT "user_id", sum(total) as spent, count(*) as n FROM "orders" GROUP BY "user_id"
//     HAVING ("spent" > $1 OR "n" > $2)
//     args: [100 5]

func (*SelectBuilder) HavingNotBetween added in v0.2.0 

func (s *SelectBuilder) HavingNotBetween(column string, lo any, hi any) *SelectBuilder

HavingNotBetween adds "col NOT BETWEEN lo AND hi" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotBetween("spent", 100, 500)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" NOT
//     BETWEEN $1 AND $2
//     args: [100 500]

func (*SelectBuilder) HavingNotNull added in v0.2.0 

func (s *SelectBuilder) HavingNotNull(column string) *SelectBuilder

HavingNotNull adds "col IS NOT NULL" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotNull("spent")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NOT NULL

func (*SelectBuilder) HavingNull added in v0.2.0 

func (s *SelectBuilder) HavingNull(column string) *SelectBuilder

HavingNull adds "col IS NULL" to HAVING.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNull("spent")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NULL

func (*SelectBuilder) HavingRaw added in v0.2.0 

func (s *SelectBuilder) HavingRaw(sql string, args ...any) *SelectBuilder

HavingRaw adds a raw HAVING predicate (caller-trusted SQL).

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	HavingRaw("sum(amount) > ?", 100)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING sum(amount) > $1
// args: [100]

func (*SelectBuilder) IgnoreIndex added in v0.2.0 

func (s *SelectBuilder) IgnoreIndex(index string) *SelectBuilder

IgnoreIndex adds "IGNORE INDEX (a)" (MySQL; ignored elsewhere).

Example: 

conn.Select().From("users").IgnoreIndex("idx_email").Where("active", true)
// SELECT * FROM `users` IGNORE INDEX (idx_email) WHERE `active` = ?   args: [true]

func (*SelectBuilder) InRandomOrder added in v0.2.0 

func (s *SelectBuilder) InRandomOrder(seed ...int) *SelectBuilder

InRandomOrder orders randomly: RANDOM() on Postgres/SQLite, RAND([seed]) on MySQL.

Example: 

conn.Select().From("posts").InRandomOrder().Limit(5)
// Postgres: SELECT * FROM "posts" ORDER BY RANDOM() LIMIT 5
// MySQL: SELECT * FROM `posts` ORDER BY RAND() LIMIT 5

func (*SelectBuilder) Join added in v0.2.0 

func (s *SelectBuilder) Join(table string, first string, args ...any) *SelectBuilder

Join adds "INNER JOIN table ON first = second" (or "first op second").

Example: 

conn.Select().From("users as u").Join("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*SelectBuilder) JoinFunc added in v0.2.0 

func (s *SelectBuilder) JoinFunc(table string, fn func(*JoinClause)) *SelectBuilder

JoinFunc adds an inner join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.published", true)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."published" = $1
// args: [true]

func (*SelectBuilder) JoinLateral added in v0.2.0 

func (s *SelectBuilder) JoinLateral(sub *SelectBuilder, as string) *SelectBuilder

JoinLateral adds "INNER JOIN LATERAL (subquery) AS alias ON TRUE" (Postgres, MySQL >= 8.0.14).

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").JoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" INNER JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE
// MariaDB returns ErrUnsupported

func (*SelectBuilder) JoinSub added in v0.2.0 

func (s *SelectBuilder) JoinSub(sub *SelectBuilder, as string, first string, args ...any) *SelectBuilder

JoinSub joins a subquery: "INNER JOIN (SELECT ...) AS alias ON ...".

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").JoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*SelectBuilder) JoinSubFunc added in v0.2.0 

func (s *SelectBuilder) JoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *SelectBuilder

JoinSubFunc joins a subquery with a complex ON clause built in fn.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").JoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" > $1
// args: [10]

func (*SelectBuilder) JoinWhere added in v0.2.0 

func (s *SelectBuilder) JoinWhere(table string, column string, args ...any) *SelectBuilder

JoinWhere joins on a bound value: "INNER JOIN t ON col = ?".

Example: 

conn.Select().From("users as u").JoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*SelectBuilder) Latest added in v0.2.0 

func (s *SelectBuilder) Latest(column ...string) *SelectBuilder

Latest orders by column descending (default "created_at").

Example: 

conn.Select().From("posts").Latest("published_at")
// SELECT * FROM "posts" ORDER BY "published_at" DESC

func (*SelectBuilder) LeftJoin added in v0.2.0 

func (s *SelectBuilder) LeftJoin(table string, first string, args ...any) *SelectBuilder

LeftJoin adds a left join.

Example: 

conn.Select().From("users as u").LeftJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*SelectBuilder) LeftJoinFunc added in v0.2.0 

func (s *SelectBuilder) LeftJoinFunc(table string, fn func(*JoinClause)) *SelectBuilder

LeftJoinFunc adds a left join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").LeftJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNull("p.deleted_at")
})
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."deleted_at" IS NULL

func (*SelectBuilder) LeftJoinLateral added in v0.2.0 

func (s *SelectBuilder) LeftJoinLateral(sub *SelectBuilder, as string) *SelectBuilder

LeftJoinLateral is JoinLateral as a left join.

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").LeftJoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" LEFT JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE

func (*SelectBuilder) LeftJoinSub added in v0.2.0 

func (s *SelectBuilder) LeftJoinSub(sub *SelectBuilder, as string, first string, args ...any) *SelectBuilder

LeftJoinSub joins a subquery with a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").LeftJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1) AS
//     "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*SelectBuilder) LeftJoinSubFunc added in v0.2.0 

func (s *SelectBuilder) LeftJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *SelectBuilder

LeftJoinSubFunc is JoinSubFunc as a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").LeftJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNotNull("p.score")
})
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" IS NOT NULL

func (*SelectBuilder) LeftJoinWhere added in v0.2.0 

func (s *SelectBuilder) LeftJoinWhere(table string, column string, args ...any) *SelectBuilder

LeftJoinWhere is JoinWhere as a left join.

Example: 

conn.Select().From("users as u").LeftJoinWhere("posts as p", "p.score", ">", 10)
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."score" > $1
// args: [10]

func (*SelectBuilder) Limit added in v0.2.0 

func (s *SelectBuilder) Limit(n int) *SelectBuilder

Limit sets LIMIT; negative values are ignored.

Example: 

conn.Select().From("users").Limit(10)
// SELECT * FROM "users" LIMIT 10

func (*SelectBuilder) Lock added in v0.2.0 

func (s *SelectBuilder) Lock(clause string) *SelectBuilder

Lock appends a raw locking clause such as "FOR NO KEY UPDATE" (caller-trusted SQL; ignored on SQLite).

Example: 

conn.Select().From("jobs").Where("state", "queued").Limit(1).Lock("FOR NO KEY UPDATE")
// SELECT * FROM "jobs" WHERE "state" = $1 LIMIT 1 FOR NO KEY UPDATE   args: [queued]

func (*SelectBuilder) LockForUpdate added in v0.2.0 

func (s *SelectBuilder) LockForUpdate() *SelectBuilder

LockForUpdate adds "FOR UPDATE" (Postgres, MySQL; ignored on SQLite).

Example: 

conn.Select().From("accounts").Where("id", 1).LockForUpdate()
// Postgres: SELECT * FROM "accounts" WHERE "id" = $1 FOR UPDATE   args: [1]
// MySQL: SELECT * FROM `accounts` WHERE `id` = ? FOR UPDATE   args: [1]

func (*SelectBuilder) Max added in v0.2.0 

func (s *SelectBuilder) Max(ctx context.Context, column string, dest any) error

Max scans max(column) into dest.

Example: 

var highest int64
err := conn.Select().From("orders").Max(ctx, "total", &highest)
// SELECT MAX("total") AS "aggregate" FROM "orders"
// highest = 90

func (*SelectBuilder) Min added in v0.2.0 

func (s *SelectBuilder) Min(ctx context.Context, column string, dest any) error

Min scans min(column) into dest.

Example: 

var lowest int64
err := conn.Select().From("orders").Min(ctx, "total", &lowest)
// SELECT MIN("total") AS "aggregate" FROM "orders"
// lowest = 10

func (*SelectBuilder) MustRawSQL added in v0.2.0 

func (s *SelectBuilder) MustRawSQL() string

MustRawSQL is ToRawSQL that panics on error. DEBUG ONLY, like ToRawSQL: the result is not injection-safe. See MustSQL for when panicking is appropriate.

Example: 

sql := conn.Select().From("users").Where("id", 42).Where("name", "ann").MustRawSQL()
// sql: SELECT * FROM "users" WHERE "id" = 42 AND "name" = 'ann'
// DEBUG ONLY: not injection-safe

func (*SelectBuilder) MustSQL added in v0.2.0 

func (s *SelectBuilder) MustSQL() (string, []any)

MustSQL is ToSQL that panics on error instead of returning it. Use it for fixed queries (tests, examples, package-level vars) where an error means a programming mistake. Do not use it where an error can come from input, such as a user-chosen operator or column: handle ToSQL's error there. The panic value is the error, wrapped, so errors.Is still works on a recovered value.

Example: 

sql, args := conn.Select().From("users").Where("id", 42).MustSQL()
// SELECT * FROM "users" WHERE "id" = $1
// args: [42]

func (*SelectBuilder) Offset added in v0.2.0 

func (s *SelectBuilder) Offset(n int) *SelectBuilder

Offset sets OFFSET; negative values clamp to 0.

Example: 

conn.Select().From("users").Limit(10).Offset(20)
// SELECT * FROM "users" LIMIT 10 OFFSET 20

func (*SelectBuilder) Oldest added in v0.2.0 

func (s *SelectBuilder) Oldest(column ...string) *SelectBuilder

Oldest orders by column ascending (default "created_at").

Example: 

conn.Select().From("posts").Oldest()
// SELECT * FROM "posts" ORDER BY "created_at" ASC

func (*SelectBuilder) OrHaving added in v0.2.0 

func (s *SelectBuilder) OrHaving(column string, args ...any) *SelectBuilder

OrHaving is Having joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	Having("user_id", ">", 10).OrHaving("user_id", 1)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING "user_id" > $1 OR "user_id" = $2
// args: [10 1]

func (*SelectBuilder) OrHavingBetween added in v0.2.0 

func (s *SelectBuilder) OrHavingBetween(column string, lo any, hi any) *SelectBuilder

OrHavingBetween is HavingBetween joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingBetween("spent", 100, 500).OrHavingBetween("user_id", 1, 3)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent"
//     BETWEEN $1 AND $2 OR "user_id" BETWEEN $3 AND $4
//     args: [100 500 1 3]

func (*SelectBuilder) OrHavingGroup added in v0.2.0 

func (s *SelectBuilder) OrHavingGroup(fn func(*HavingClause)) *SelectBuilder

OrHavingGroup is HavingGroup joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	SelectRaw("count(*) as n").Having("n", ">", 1).OrHavingGroup(func(q *db.HavingClause) {
	q.Having("spent", ">", 100).Having("n", "<", 3)
})
// SELECT "user_id", sum(total) as spent, count(*) as n FROM "orders" GROUP BY "user_id"
//     HAVING "n" > $1 OR ("spent" > $2 AND "n" < $3)
//     args: [1 100 3]

func (*SelectBuilder) OrHavingNotBetween added in v0.2.0 

func (s *SelectBuilder) OrHavingNotBetween(column string, lo any, hi any) *SelectBuilder

OrHavingNotBetween is HavingNotBetween joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotBetween("spent", 100, 500).OrHavingNotBetween("user_id", 1, 3)
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" NOT
//     BETWEEN $1 AND $2 OR "user_id" NOT BETWEEN $3 AND $4
//     args: [100 500 1 3]

func (*SelectBuilder) OrHavingNotNull added in v0.2.0 

func (s *SelectBuilder) OrHavingNotNull(column string) *SelectBuilder

OrHavingNotNull is HavingNotNull joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNotNull("spent").OrHavingNotNull("user_id")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NOT NULL OR "user_id" IS NOT NULL

func (*SelectBuilder) OrHavingNull added in v0.2.0 

func (s *SelectBuilder) OrHavingNull(column string) *SelectBuilder

OrHavingNull is HavingNull joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").SelectRaw("sum(total) as spent").GroupBy("user_id").
	HavingNull("spent").OrHavingNull("user_id")
// SELECT "user_id", sum(total) as spent FROM "orders" GROUP BY "user_id" HAVING "spent" IS
//     NULL OR "user_id" IS NULL

func (*SelectBuilder) OrHavingRaw added in v0.2.0 

func (s *SelectBuilder) OrHavingRaw(sql string, args ...any) *SelectBuilder

OrHavingRaw is HavingRaw joined with OR.

Example: 

conn.Select().From("orders").Select("user_id").GroupBy("user_id").
	HavingRaw("sum(amount) > ?", 100).OrHavingRaw("count(*) > ?", 5)
// SELECT "user_id" FROM "orders" GROUP BY "user_id" HAVING sum(amount) > $1 OR count(*) > $2
// args: [100 5]

func (*SelectBuilder) OrWhere added in v0.2.0 

func (s *SelectBuilder) OrWhere(column string, args ...any) *SelectBuilder

OrWhere is Where joined with OR.

Example: 

conn.Select().From("users").Where("role", "admin").OrWhere("role", "owner")
// SELECT * FROM "users" WHERE "role" = $1 OR "role" = $2
// args: [admin owner]

func (*SelectBuilder) OrWhereAll added in v0.2.0 

func (s *SelectBuilder) OrWhereAll(columns []string, args ...any) *SelectBuilder

OrWhereAll is WhereAll joined with OR.

Example: 

conn.Select().From("users").WhereAll([]string{"a", "b"}, 1).OrWhereAll([]string{"c", "d"}, ">", 5)
// SELECT * FROM "users" WHERE ("a" = $1 AND "b" = $2) OR ("c" > $3 AND "d" > $4)
//     args: [1 1 5 5]

func (*SelectBuilder) OrWhereAny added in v0.2.0 

func (s *SelectBuilder) OrWhereAny(columns []string, args ...any) *SelectBuilder

OrWhereAny is WhereAny joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereAny([]string{"a", "b"}, ">", 5)
// SELECT * FROM "users" WHERE "active" = $1 OR ("a" > $2 OR "b" > $3)   args: [true 5 5]

func (*SelectBuilder) OrWhereBetween added in v0.2.0 

func (s *SelectBuilder) OrWhereBetween(column string, lo any, hi any) *SelectBuilder

OrWhereBetween is WhereBetween joined with OR.

Example: 

conn.Select().From("orders").Where("status", "paid").OrWhereBetween("total", 500, 900)
// SELECT * FROM "orders" WHERE "status" = $1 OR "total" BETWEEN $2 AND $3
//     args: [paid 500 900]

func (*SelectBuilder) OrWhereBetweenColumns added in v0.2.0 

func (s *SelectBuilder) OrWhereBetweenColumns(column string, c1 string, c2 string) *SelectBuilder

OrWhereBetweenColumns is WhereBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price").
	OrWhereBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price" OR "cost"
//     BETWEEN "low" AND "high"

func (*SelectBuilder) OrWhereColumn added in v0.2.0 

func (s *SelectBuilder) OrWhereColumn(first string, args ...any) *SelectBuilder

OrWhereColumn is WhereColumn joined with OR.

Example: 

conn.Select().From("users").WhereColumn("first_name", "last_name").OrWhereColumn("a", "<>", "b")
// SELECT * FROM "users" WHERE "first_name" = "last_name" OR "a" <> "b"

func (*SelectBuilder) OrWhereDate added in v0.2.0 

func (s *SelectBuilder) OrWhereDate(column string, args ...any) *SelectBuilder

OrWhereDate is WhereDate joined with OR.

Example: 

conn.Select().From("orders").WhereDate("created_at", "2024-01-15").
	OrWhereDate("created_at", "2024-02-01")
// SELECT * FROM "orders" WHERE "created_at"::DATE = $1 OR "created_at"::DATE = $2
//     args: [2024-01-15 2024-02-01]

func (*SelectBuilder) OrWhereDay added in v0.2.0 

func (s *SelectBuilder) OrWhereDay(column string, args ...any) *SelectBuilder

OrWhereDay is WhereDay joined with OR.

Example: 

conn.Select().From("orders").WhereDay("created_at", 15).OrWhereDay("created_at", ">", 20)
// SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1 OR EXTRACT(DAY FROM
//     "created_at") > $2
//     args: [15 20]

func (*SelectBuilder) OrWhereExists added in v0.2.0 

func (s *SelectBuilder) OrWhereExists(sub *SelectBuilder) *SelectBuilder

OrWhereExists is WhereExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*SelectBuilder) OrWhereGroup added in v0.2.0 

func (s *SelectBuilder) OrWhereGroup(fn func(*WhereClause)) *SelectBuilder

OrWhereGroup is WhereGroup joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").Where("age", ">", 30)
})
// SELECT * FROM "users" WHERE "active" = $1 OR ("role" = $2 AND "age" > $3)
//     args: [true admin 30]

func (*SelectBuilder) OrWhereIn added in v0.2.0 

func (s *SelectBuilder) OrWhereIn(column string, values any) *SelectBuilder

OrWhereIn is WhereIn joined with OR.

Example: 

conn.Select().From("users").WhereIn("role", []string{"ann", "bob"}).OrWhereIn("id", []int{9})
// SELECT * FROM "users" WHERE "role" IN ($1, $2) OR "id" IN ($3)   args: [ann bob 9]

func (*SelectBuilder) OrWhereIntegerInRaw added in v0.2.0 

func (s *SelectBuilder) OrWhereIntegerInRaw(column string, values any) *SelectBuilder

OrWhereIntegerInRaw is WhereIntegerInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1}).
	OrWhereIntegerInRaw("id", []int64{7, 8})
// SELECT * FROM "users" WHERE "id" IN (1) OR "id" IN (7, 8)

func (*SelectBuilder) OrWhereIntegerNotInRaw added in v0.2.0 

func (s *SelectBuilder) OrWhereIntegerNotInRaw(column string, values any) *SelectBuilder

OrWhereIntegerNotInRaw is WhereIntegerNotInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2}).
	OrWhereIntegerNotInRaw("id", []int{3})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2) OR "id" NOT IN (3)

func (*SelectBuilder) OrWhereJsonContains added in v0.2.0 

func (s *SelectBuilder) OrWhereJsonContains(column string, value any) *SelectBuilder

OrWhereJsonContains is WhereJsonContains joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR ("options"->'tags')::JSONB @> $2
// args: [true "go"]

func (*SelectBuilder) OrWhereJsonContainsKey added in v0.2.0 

func (s *SelectBuilder) OrWhereJsonContainsKey(column string) *SelectBuilder

OrWhereJsonContainsKey is WhereJsonContainsKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*SelectBuilder) OrWhereJsonDoesntContain added in v0.2.0 

func (s *SelectBuilder) OrWhereJsonDoesntContain(column string, value any) *SelectBuilder

OrWhereJsonDoesntContain is WhereJsonDoesntContain joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("options"->'tags')::JSONB @> $2
// args: [true "php"]

func (*SelectBuilder) OrWhereJsonDoesntContainKey added in v0.2.0 

func (s *SelectBuilder) OrWhereJsonDoesntContainKey(column string) *SelectBuilder

OrWhereJsonDoesntContainKey is WhereJsonDoesntContainKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).
	OrWhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1
//   OR NOT COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*SelectBuilder) OrWhereJsonDoesntOverlap added in v0.2.0 

func (s *SelectBuilder) OrWhereJsonDoesntOverlap(column string, value any) *SelectBuilder

OrWhereJsonDoesntOverlap is WhereJsonDoesntOverlap joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["php"]]

func (*SelectBuilder) OrWhereJsonLength added in v0.2.0 

func (s *SelectBuilder) OrWhereJsonLength(column string, args ...any) *SelectBuilder

OrWhereJsonLength is WhereJsonLength joined with OR.

Example: 

conn.Select().From("users").WhereJsonLength("options->tags", 0)
.OrWhereJsonLength("options->roles", ">=", 3).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   OR JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) >= $2   args: [0 3]

func (*SelectBuilder) OrWhereJsonOverlaps added in v0.2.0 

func (s *SelectBuilder) OrWhereJsonOverlaps(column string, value any) *SelectBuilder

OrWhereJsonOverlaps is WhereJsonOverlaps joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonOverlaps("options->tags", []string{"go"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["go"]]

func (*SelectBuilder) OrWhereLike added in v0.2.0 

func (s *SelectBuilder) OrWhereLike(column string, value any, caseSensitive ...bool) *SelectBuilder

OrWhereLike is WhereLike joined with OR.

Example: 

conn.Select().From("users").WhereLike("name", "an%").OrWhereLike("name", "bo%")
// SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1 OR "name"::TEXT ILIKE $2
//     args: [an% bo%]

func (*SelectBuilder) OrWhereMap added in v0.2.0 

func (s *SelectBuilder) OrWhereMap(m map[string]any) *SelectBuilder

OrWhereMap is WhereMap joined with OR.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"a": 1}).OrWhereMap(map[string]any{"b": 2})
// SELECT * FROM "users" WHERE ("a" = $1) OR ("b" = $2)   args: [1 2]

func (*SelectBuilder) OrWhereMonth added in v0.2.0 

func (s *SelectBuilder) OrWhereMonth(column string, args ...any) *SelectBuilder

OrWhereMonth is WhereMonth joined with OR.

Example: 

conn.Select().From("orders").WhereMonth("created_at", ">=", 6).OrWhereMonth("created_at", 1)
// SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") >= $1 OR EXTRACT(MONTH FROM
//     "created_at") = $2
//     args: [06 01]

func (*SelectBuilder) OrWhereNone added in v0.2.0 

func (s *SelectBuilder) OrWhereNone(columns []string, args ...any) *SelectBuilder

OrWhereNone is WhereNone joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereNone([]string{"a", "b"}, 0)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("a" = $2 OR "b" = $3)
//     args: [true 0 0]

func (*SelectBuilder) OrWhereNot added in v0.2.0 

func (s *SelectBuilder) OrWhereNot(column string, args ...any) *SelectBuilder

OrWhereNot adds "OR NOT <predicate>".

Example: 

conn.Select().From("users").Where("age", ">", 18).OrWhereNot("status", "<", 3)
// SELECT * FROM "users" WHERE "age" > $1 OR NOT "status" < $2   args: [18 3]

func (*SelectBuilder) OrWhereNotBetween added in v0.2.0 

func (s *SelectBuilder) OrWhereNotBetween(column string, lo any, hi any) *SelectBuilder

OrWhereNotBetween is WhereNotBetween joined with OR.

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100).OrWhereNotBetween("qty", 1, 5)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2 OR "qty" NOT BETWEEN $3 AND $4
//     args: [10 100 1 5]

func (*SelectBuilder) OrWhereNotBetweenColumns added in v0.2.0 

func (s *SelectBuilder) OrWhereNotBetweenColumns(column string, c1 string, c2 string) *SelectBuilder

OrWhereNotBetweenColumns is WhereNotBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price").
	OrWhereNotBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price" OR "cost"
//     NOT BETWEEN "low" AND "high"

func (*SelectBuilder) OrWhereNotExists added in v0.2.0 

func (s *SelectBuilder) OrWhereNotExists(sub *SelectBuilder) *SelectBuilder

OrWhereNotExists is WhereNotExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereNotExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*SelectBuilder) OrWhereNotIn added in v0.2.0 

func (s *SelectBuilder) OrWhereNotIn(column string, values any) *SelectBuilder

OrWhereNotIn is WhereNotIn joined with OR.

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2}).OrWhereNotIn("role", []string{"ann"})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2) OR "role" NOT IN ($3)   args: [1 2 ann]

func (*SelectBuilder) OrWhereNotLike added in v0.2.0 

func (s *SelectBuilder) OrWhereNotLike(column string, value any, caseSensitive ...bool) *SelectBuilder

OrWhereNotLike is WhereNotLike joined with OR.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%").OrWhereNotLike("name", "%demo%", true)
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1 OR "name"::TEXT NOT LIKE $2
//     args: [%test% %demo%]

func (*SelectBuilder) OrWhereNotNull added in v0.2.0 

func (s *SelectBuilder) OrWhereNotNull(column string) *SelectBuilder

OrWhereNotNull is WhereNotNull joined with OR.

Example: 

conn.Select().From("users").WhereNotNull("verified_at").OrWhereNotNull("invited_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL OR "invited_at" IS NOT NULL

func (*SelectBuilder) OrWhereNull added in v0.2.0 

func (s *SelectBuilder) OrWhereNull(column string) *SelectBuilder

OrWhereNull is WhereNull joined with OR.

Example: 

conn.Select().From("users").WhereNull("deleted_at").OrWhereNull("banned_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL OR "banned_at" IS NULL

func (*SelectBuilder) OrWhereNullSafeEquals added in v0.2.0 

func (s *SelectBuilder) OrWhereNullSafeEquals(column string, value any) *SelectBuilder

OrWhereNullSafeEquals is WhereNullSafeEquals joined with OR.

Example: 

conn.Select().From("users").WhereNullSafeEquals("a", 1).OrWhereNullSafeEquals("b", 2)
// SELECT * FROM "users" WHERE "a" IS NOT DISTINCT FROM $1 OR "b" IS NOT DISTINCT FROM $2
//     args: [1 2]

func (*SelectBuilder) OrWhereRaw added in v0.2.0 

func (s *SelectBuilder) OrWhereRaw(sql string, args ...any) *SelectBuilder

OrWhereRaw is WhereRaw joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereRaw("age between ? and ?", 18, 30)
// SELECT * FROM "users" WHERE "active" = $1 OR age between $2 and $3
// args: [true 18 30]

func (*SelectBuilder) OrWhereRowValues added in v0.2.0 

func (s *SelectBuilder) OrWhereRowValues(columns []string, op string, values []any) *SelectBuilder

OrWhereRowValues is WhereRowValues joined with OR.

Example: 

conn.Select().From("events").Where("kind", "x").
	OrWhereRowValues([]string{"a", "b"}, "=", []any{1, 2})
// SELECT * FROM "events" WHERE "kind" = $1 OR ("a", "b") = ($2, $3)   args: [x 1 2]

func (*SelectBuilder) OrWhereTime added in v0.2.0 

func (s *SelectBuilder) OrWhereTime(column string, args ...any) *SelectBuilder

OrWhereTime is WhereTime joined with OR.

Example: 

conn.Select().From("orders").WhereTime("created_at", "10:30:00").
	OrWhereTime("created_at", "<", "08:00:00")
// SELECT * FROM "orders" WHERE "created_at"::TIME = $1 OR "created_at"::TIME < $2
//     args: [10:30:00 08:00:00]

func (*SelectBuilder) OrWhereValueBetween added in v0.2.0 

func (s *SelectBuilder) OrWhereValueBetween(value any, c1 string, c2 string) *SelectBuilder

OrWhereValueBetween is WhereValueBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total").
	OrWhereValueBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total" OR $2 BETWEEN "a" AND
//     "b"
//     args: [50 7]

func (*SelectBuilder) OrWhereValueNotBetween added in v0.2.0 

func (s *SelectBuilder) OrWhereValueNotBetween(value any, c1 string, c2 string) *SelectBuilder

OrWhereValueNotBetween is WhereValueNotBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total").
	OrWhereValueNotBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total" OR $2 NOT BETWEEN
//     "a" AND "b"
//     args: [50 7]

func (*SelectBuilder) OrWhereYear added in v0.2.0 

func (s *SelectBuilder) OrWhereYear(column string, args ...any) *SelectBuilder

OrWhereYear is WhereYear joined with OR.

Example: 

conn.Select().From("orders").WhereYear("created_at", ">", 2020).OrWhereYear("created_at", 1999)
// SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") > $1 OR EXTRACT(YEAR FROM
//     "created_at") = $2
//     args: [2020 1999]

func (*SelectBuilder) OrderBy added in v0.2.0 

func (s *SelectBuilder) OrderBy(column string, direction ...string) *SelectBuilder

OrderBy adds ORDER BY column; direction is "asc" (default) or "desc".

Example: 

conn.Select().From("users").OrderBy("name").OrderBy("age", "desc")
// SELECT * FROM "users" ORDER BY "name" ASC, "age" DESC

func (*SelectBuilder) OrderByDesc added in v0.2.0 

func (s *SelectBuilder) OrderByDesc(column string) *SelectBuilder

OrderByDesc is OrderBy(column, "desc").

Example: 

conn.Select().From("users").OrderByDesc("created_at")
// SELECT * FROM "users" ORDER BY "created_at" DESC

func (*SelectBuilder) OrderByRaw added in v0.2.0 

func (s *SelectBuilder) OrderByRaw(sql string, args ...any) *SelectBuilder

OrderByRaw adds a raw ORDER BY expression (caller-trusted SQL).

Example: 

conn.Select().From("users").OrderByRaw("case when role = ? then 0 else 1 end", "admin")
// SELECT * FROM "users" ORDER BY case when role = $1 then 0 else 1 end
// args: [admin]

func (*SelectBuilder) Paginate added in v0.2.0 

func (s *SelectBuilder) Paginate(ctx context.Context, page int, perPage int, dest any) (Page, error)

Paginate counts the rows, then scans the requested 1-based page into dest (a pointer to a slice). The count ignores order, limit and offset.

Example: 

var users []User
p, err := conn.Select().From("users").OrderBy("id").Paginate(ctx, 2, 2, &users)
// SELECT COUNT(*) AS "aggregate" FROM "users"
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 2 OFFSET 2
// with 5 rows: p.Total = 5, p.LastPage = 3, p.From = 3, p.To = 4

func (*SelectBuilder) Pluck added in v0.2.0 

func (s *SelectBuilder) Pluck(ctx context.Context, column string, dest any) error

Pluck scans one column of every row into dest, a pointer to a slice of scalars.

Example: 

var names []string
err := conn.Select().From("users").OrderBy("id").Pluck(ctx, "name", &names)
// SELECT "name" FROM "users" ORDER BY "id" ASC
// names = ["ann", "bob"]

func (*SelectBuilder) PluckMap added in v0.2.0 

func (s *SelectBuilder) PluckMap(ctx context.Context, column string, key string, dest any) error

PluckMap scans two columns into dest, a non-nil pointer to a map[K]V (key column -> value column).

Example: 

var byID map[int64]string
err := conn.Select().From("users").PluckMap(ctx, "name", "id", &byID)
// SELECT "name", "id" FROM "users"
// byID = map[1:"ann" 2:"bob"]

func (*SelectBuilder) Prefix added in v0.2.0 

func (s *SelectBuilder) Prefix(p string) *SelectBuilder

Prefix sets a table prefix applied to table names, aliases and qualified columns.

Example: 

db.Use(db.Postgres).Select("u.id").From("users as u").Prefix("app_")
// SELECT "app_u"."id" FROM "app_users" AS "app_u"

func (*SelectBuilder) Reorder added in v0.2.0 

func (s *SelectBuilder) Reorder() *SelectBuilder

Reorder removes all existing ORDER BY clauses (including a union's).

Example: 

conn.Select().From("posts").OrderBy("title").Reorder()
// SELECT * FROM "posts"

func (*SelectBuilder) ReorderBy added in v0.2.0 

func (s *SelectBuilder) ReorderBy(column string, direction ...string) *SelectBuilder

ReorderBy is Reorder followed by OrderBy(column, direction).

Example: 

conn.Select().From("posts").OrderBy("title").ReorderBy("id", "desc")
// SELECT * FROM "posts" ORDER BY "id" DESC

func (*SelectBuilder) RightJoin added in v0.2.0 

func (s *SelectBuilder) RightJoin(table string, first string, args ...any) *SelectBuilder

RightJoin adds a right join.

Example: 

conn.Select().From("users as u").RightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*SelectBuilder) RightJoinFunc added in v0.2.0 

func (s *SelectBuilder) RightJoinFunc(table string, fn func(*JoinClause)) *SelectBuilder

RightJoinFunc adds a right join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").RightJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."score" > $1
// args: [10]

func (*SelectBuilder) RightJoinSub added in v0.2.0 

func (s *SelectBuilder) RightJoinSub(sub *SelectBuilder, as string, first string, args ...any) *SelectBuilder

RightJoinSub joins a subquery with a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").RightJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*SelectBuilder) RightJoinSubFunc added in v0.2.0 

func (s *SelectBuilder) RightJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *SelectBuilder

RightJoinSubFunc is JoinSubFunc as a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").RightJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id")
})
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id"

func (*SelectBuilder) RightJoinWhere added in v0.2.0 

func (s *SelectBuilder) RightJoinWhere(table string, column string, args ...any) *SelectBuilder

RightJoinWhere is JoinWhere as a right join.

Example: 

conn.Select().From("users as u").RightJoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*SelectBuilder) Select added in v0.2.0 

func (s *SelectBuilder) Select(columns ...string) *SelectBuilder

Select replaces the selected columns.

Example: 

conn.Select().From("users as u").Select("u.id", "u.name as full_name")
// SELECT "u"."id", "u"."name" AS "full_name" FROM "users" AS "u"

func (*SelectBuilder) SelectRaw added in v0.2.0 

func (s *SelectBuilder) SelectRaw(sql string, args ...any) *SelectBuilder

SelectRaw appends a raw select expression.

Example: 

conn.Select().From("orders").Select("user_id").
	SelectRaw("sum(amount) * ? as total", 1.1).GroupBy("user_id")
// SELECT "user_id", sum(amount) * $1 as total FROM "orders" GROUP BY "user_id"
// args: [1.1]

func (*SelectBuilder) SelectSub added in v0.2.0 

func (s *SelectBuilder) SelectSub(sub *SelectBuilder, as string) *SelectBuilder

SelectSub appends "(subquery) as alias" to the select list. The subquery is snapshotted: later changes to sub do not affect this query.

Example: 

n := conn.Select().From("posts").SelectRaw("count(*)").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Select("name").SelectSub(n, "post_count")
// SELECT "name", (SELECT count(*) FROM "posts" WHERE "posts"."user_id" = "users"."id") AS
//     "post_count" FROM "users"

func (*SelectBuilder) SharedLock added in v0.2.0 

func (s *SelectBuilder) SharedLock() *SelectBuilder

SharedLock adds "FOR SHARE" (Postgres) or "LOCK IN SHARE MODE" (MySQL); ignored on SQLite.

Example: 

conn.Select().From("accounts").Where("id", 1).SharedLock()
// Postgres: SELECT * FROM "accounts" WHERE "id" = $1 FOR SHARE   args: [1]
// MySQL: SELECT * FROM `accounts` WHERE `id` = ? LOCK IN SHARE MODE   args: [1]

func (*SelectBuilder) SimplePaginate added in v0.2.0 

func (s *SelectBuilder) SimplePaginate(ctx context.Context, page int, perPage int, dest any) (SimplePage, error)

SimplePaginate fetches one extra row to learn whether another page exists, skipping the count query.

Example: 

var users []User
p, err := conn.Select().From("users").OrderBy("id").SimplePaginate(ctx, 1, 2, &users)
// SELECT * FROM "users" ORDER BY "id" ASC LIMIT 3 OFFSET 0
// users holds at most 2 rows; p.HasMore = true when a third came back

func (*SelectBuilder) Skip added in v0.2.0 

func (s *SelectBuilder) Skip(n int) *SelectBuilder

Skip is an alias of Offset.

Example: 

conn.Select().From("users").Take(10).Skip(5)
// SELECT * FROM "users" LIMIT 10 OFFSET 5

func (*SelectBuilder) Sole added in v0.2.0 

func (s *SelectBuilder) Sole(ctx context.Context, dest any) error

Sole returns the only matching row: ErrNotFound for none, ErrMultipleRecords for several.

Example: 

var u User
err := conn.Select().From("users").Where("name", "ann").Sole(ctx, &u)
// SELECT * FROM "users" WHERE "name" = $1 LIMIT 2   args: ["ann"]
// two or more rows: err is db.ErrMultipleRecords

func (*SelectBuilder) StraightJoin added in v0.2.0 

func (s *SelectBuilder) StraightJoin(table string, first string, args ...any) *SelectBuilder

StraightJoin adds a MySQL "straight_join"; other dialects error at compile time.

Example: 

connMy.Select().From("users as u").StraightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM `users` AS `u` STRAIGHT_JOIN `posts` AS `p` ON `p`.`user_id` = `u`.`id`
// connMy is db.Use(db.MySQL); other dialects return ErrUnsupported

func (*SelectBuilder) Sum added in v0.2.0 

func (s *SelectBuilder) Sum(ctx context.Context, column string) (float64, error)

Sum returns sum(column) as float64 (0 when there are no rows).

Example: 

sum, err := conn.Select().From("orders").Sum(ctx, "total")
// SELECT SUM("total") AS "aggregate" FROM "orders"
// sum = 250.5

func (*SelectBuilder) Take added in v0.2.0 

func (s *SelectBuilder) Take(n int) *SelectBuilder

Take is an alias of Limit.

Example: 

conn.Select().From("users").Take(5)
// SELECT * FROM "users" LIMIT 5

func (*SelectBuilder) Tap added in v0.2.0 

func (s *SelectBuilder) Tap(fn func(*SelectBuilder)) *SelectBuilder

Tap runs fn for side effects and returns the builder.

Example: 

conn.Select().From("users").Tap(func(q *db.SelectBuilder) { q.Where("id", 1) })
// SELECT * FROM "users" WHERE "id" = $1

func (*SelectBuilder) ToRawSQL added in v0.2.0 

func (s *SelectBuilder) ToRawSQL() (string, error)

ToRawSQL compiles and interpolates args into the SQL. DEBUG ONLY: the result is not injection-safe. Never execute or log it in production.

Example: 

sql, err := conn.Select().From("users").Where("id", 42).Where("name", "ann").ToRawSQL()
// sql: SELECT * FROM "users" WHERE "id" = 42 AND "name" = 'ann'
// DEBUG ONLY: not injection-safe

func (*SelectBuilder) ToSQL added in v0.2.0 

func (s *SelectBuilder) ToSQL() (string, []any, error)

ToSQL compiles a SELECT into SQL text and its ordered bind arguments.

Example: 

sql, args, err := conn.Select().From("users").Where("age", ">", 18).Limit(10).ToSQL()
// SELECT * FROM "users" WHERE "age" > $1 LIMIT 10
// args: [18]

func (*SelectBuilder) Union added in v0.2.0 

func (s *SelectBuilder) Union(q *SelectBuilder) *SelectBuilder

Union appends "UNION (query)". After a union, OrderBy/Limit/Offset apply to the combined result. On SQLite members are wrapped as "SELECT * FROM (...)".

Example: 

a := conn.Select().From("users").Select("name").Where("active", true)
b := conn.Select().From("admins").Select("name")
a.Union(b).OrderBy("name").Limit(10)
// (SELECT "name" FROM "users" WHERE "active" = $1) UNION (SELECT "name" FROM "admins") ORDER
//     BY "name" ASC LIMIT 10
//     args: [true]

func (*SelectBuilder) UnionAll added in v0.2.0 

func (s *SelectBuilder) UnionAll(q *SelectBuilder) *SelectBuilder

UnionAll appends "UNION ALL (query)".

Example: 

a := conn.Select().From("users").Select("name").Where("active", true)
b := conn.Select().From("admins").Select("name")
a.UnionAll(b).OrderBy("name").Limit(10)
// (SELECT "name" FROM "users" WHERE "active" = $1) UNION ALL (SELECT "name" FROM "admins")
//     ORDER BY "name" ASC LIMIT 10
//     args: [true]

func (*SelectBuilder) Unless added in v0.2.0 

func (s *SelectBuilder) Unless(cond bool, fn func(*SelectBuilder)) *SelectBuilder

Unless applies fn when cond is false.

Example: 

conn.Select().From("users").Unless(includeBanned, func(q *db.SelectBuilder) {
	q.Where("banned", false)
})
// includeBanned == false: SELECT * FROM "users" WHERE "banned" = $1

func (*SelectBuilder) UseIndex added in v0.2.0 

func (s *SelectBuilder) UseIndex(index string) *SelectBuilder

UseIndex adds "USE INDEX (a, b)" (MySQL; ignored on Postgres and SQLite). Index names are emitted unquoted and validated against [a-zA-Z0-9_$].

Example: 

conn.Select().From("users").UseIndex("idx_email").Where("active", true)
// SELECT * FROM `users` USE INDEX (idx_email) WHERE `active` = ?   args: [true]

func (*SelectBuilder) Value added in v0.2.0 

func (s *SelectBuilder) Value(ctx context.Context, column string, dest any) error

Value scans a single column of the first row into dest (a pointer to a scalar).

Example: 

var name string
err := conn.Select().From("users").Where("id", 1).Value(ctx, "name", &name)
// SELECT "name" FROM "users" WHERE "id" = $1 LIMIT 1   args: [1]
// name = "ann"

func (*SelectBuilder) When added in v0.2.0 

func (s *SelectBuilder) When(cond bool, fn func(*SelectBuilder)) *SelectBuilder

When applies fn when cond is true.

Example: 

conn.Select().From("users").When(onlyActive, func(q *db.SelectBuilder) {
	q.Where("active", true)
})
// onlyActive == true: SELECT * FROM "users" WHERE "active" = $1

func (*SelectBuilder) Where added in v0.2.0 

func (s *SelectBuilder) Where(column string, args ...any) *SelectBuilder

Where adds an AND predicate. Forms: Where(col, value) means "="; Where(col, op, value). A nil value with "=" / "!=" / "<>" becomes IS [NOT] NULL.

Example: 

conn.Select().From("users").Where("active", true).Where("age", ">=", 18)
// SELECT * FROM "users" WHERE "active" = $1 AND "age" >= $2
// args: [true 18]

func (*SelectBuilder) WhereAll added in v0.2.0 

func (s *SelectBuilder) WhereAll(columns []string, args ...any) *SelectBuilder

WhereAll requires the predicate to hold for every column: (a = ? and b = ?).

Example: 

conn.Select().From("users").WhereAll([]string{"first_name", "last_name"}, "like", "an%")
// SELECT * FROM "users" WHERE ("first_name"::TEXT LIKE $1 AND "last_name"::TEXT LIKE $2)
//     args: [an% an%]

func (*SelectBuilder) WhereAny added in v0.2.0 

func (s *SelectBuilder) WhereAny(columns []string, args ...any) *SelectBuilder

WhereAny requires the predicate to hold for at least one column: (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereAny([]string{"first_name", "last_name"}, "ann")
// SELECT * FROM "users" WHERE ("first_name" = $1 OR "last_name" = $2)   args: [ann ann]

func (*SelectBuilder) WhereBetween added in v0.2.0 

func (s *SelectBuilder) WhereBetween(column string, lo any, hi any) *SelectBuilder

WhereBetween adds "col BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" BETWEEN $1 AND $2   args: [10 100]

func (*SelectBuilder) WhereBetweenColumns added in v0.2.0 

func (s *SelectBuilder) WhereBetweenColumns(column string, c1 string, c2 string) *SelectBuilder

WhereBetweenColumns adds "col BETWEEN c1 AND c2" comparing against columns.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price"

func (*SelectBuilder) WhereColumn added in v0.2.0 

func (s *SelectBuilder) WhereColumn(first string, args ...any) *SelectBuilder

WhereColumn compares two columns: WhereColumn(a, b) means "=", or WhereColumn(a, op, b).

Example: 

conn.Select().From("users").WhereColumn("updated_at", ">", "created_at")
// SELECT * FROM "users" WHERE "updated_at" > "created_at"

func (*SelectBuilder) WhereDate added in v0.2.0 

func (s *SelectBuilder) WhereDate(column string, args ...any) *SelectBuilder

WhereDate compares the date part of a column.

Example: 

conn.Select().From("orders").WhereDate("created_at", ">=", "2024-01-15")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::DATE >= $1   args: [2024-01-15]
// MySQL: SELECT * FROM `orders` WHERE DATE(`created_at`) >= ?   args: [2024-01-15]
// SQLite: SELECT * FROM "orders" WHERE STRFTIME('%Y-%m-%d', "created_at") >= CAST(? AS TEXT)
//     args: [2024-01-15]

func (*SelectBuilder) WhereDay added in v0.2.0 

func (s *SelectBuilder) WhereDay(column string, args ...any) *SelectBuilder

WhereDay compares the day-of-month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereDay("created_at", 15)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1   args: [15]
// MySQL: SELECT * FROM `orders` WHERE DAY(`created_at`) = ?   args: [15]

func (*SelectBuilder) WhereExists added in v0.2.0 

func (s *SelectBuilder) WhereExists(sub *SelectBuilder) *SelectBuilder

WhereExists adds "EXISTS (subquery)". Build sub with DB.Select.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereExists(posts)
// SELECT * FROM "users" WHERE EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*SelectBuilder) WhereGroup added in v0.2.0 

func (s *SelectBuilder) WhereGroup(fn func(*WhereClause)) *SelectBuilder

WhereGroup wraps the predicates added inside fn in parentheses. fn receives a fresh WhereClause; only its Where* calls are used.

Example: 

conn.Select().From("users").Where("active", true).WhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").OrWhere("role", "editor")
})
// SELECT * FROM "users" WHERE "active" = $1 AND ("role" = $2 OR "role" = $3)
//     args: [true admin editor]

func (*SelectBuilder) WhereIn added in v0.2.0 

func (s *SelectBuilder) WhereIn(column string, values any) *SelectBuilder

WhereIn adds "col IN (...)". values may be any slice, a scalar, or a *SelectBuilder subquery. An empty list compiles to the always-false "0 = 1".

Example: 

conn.Select().From("users").WhereIn("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN ($1, $2, $3)   args: [1 2 3]

func (*SelectBuilder) WhereIntegerInRaw added in v0.2.0 

func (s *SelectBuilder) WhereIntegerInRaw(column string, values any) *SelectBuilder

WhereIntegerInRaw inlines integers (no bind args); non-integers record an error. Useful for very large ID lists that would exceed driver parameter limits.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN (1, 2, 3)

func (*SelectBuilder) WhereIntegerNotInRaw added in v0.2.0 

func (s *SelectBuilder) WhereIntegerNotInRaw(column string, values any) *SelectBuilder

WhereIntegerNotInRaw is the negated WhereIntegerInRaw.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2)

func (*SelectBuilder) WhereJsonContains added in v0.2.0 

func (s *SelectBuilder) WhereJsonContains(column string, value any) *SelectBuilder

WhereJsonContains adds a JSON containment test on a column or "col->path". MySQL json_contains, Postgres @> (jsonb), SQLite json_each membership.

Example: 

conn.Select().From("users").WhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE ("options"->'tags')::JSONB @> $1   args: ["go"]

func (*SelectBuilder) WhereJsonContainsKey added in v0.2.0 

func (s *SelectBuilder) WhereJsonContainsKey(column string) *SelectBuilder

WhereJsonContainsKey tests that the JSON path "col->key" exists.

Example: 

conn.Select().From("users").WhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []
// MySQL: SELECT * FROM `users`
//   WHERE IFNULL(JSON_CONTAINS_PATH(`options`, 'one', '$."theme"'), 0)

func (*SelectBuilder) WhereJsonDoesntContain added in v0.2.0 

func (s *SelectBuilder) WhereJsonDoesntContain(column string, value any) *SelectBuilder

WhereJsonDoesntContain negates WhereJsonContains.

Example: 

conn.Select().From("users").WhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE NOT ("options"->'tags')::JSONB @> $1   args: ["php"]

func (*SelectBuilder) WhereJsonDoesntContainKey added in v0.2.0 

func (s *SelectBuilder) WhereJsonDoesntContainKey(column string) *SelectBuilder

WhereJsonDoesntContainKey negates WhereJsonContainsKey.

Example: 

conn.Select().From("users").WhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE NOT COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []

func (*SelectBuilder) WhereJsonDoesntOverlap added in v0.2.0 

func (s *SelectBuilder) WhereJsonDoesntOverlap(column string, value any) *SelectBuilder

WhereJsonDoesntOverlap negates WhereJsonOverlaps.

Example: 

conn.Select().From("users")
.WhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["php"]]

func (*SelectBuilder) WhereJsonLength added in v0.2.0 

func (s *SelectBuilder) WhereJsonLength(column string, args ...any) *SelectBuilder

WhereJsonLength compares the length of a JSON array: (value) or (operator, value).

Example: 

conn.Select().From("users")
.WhereJsonLength("options->tags", 2).WhereJsonLength("options->roles", ">", 1).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   AND JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) > $2   args: [2 1]

func (*SelectBuilder) WhereJsonOverlaps added in v0.2.0 

func (s *SelectBuilder) WhereJsonOverlaps(column string, value any) *SelectBuilder

WhereJsonOverlaps adds json_overlaps (MySQL only; other dialects error at compile time).

Example: 

conn.Select().From("users")
.WhereJsonOverlaps("options->tags", []string{"go", "sql"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["go","sql"]]

func (*SelectBuilder) WhereLike added in v0.2.0 

func (s *SelectBuilder) WhereLike(column string, value any, caseSensitive ...bool) *SelectBuilder

WhereLike adds a LIKE predicate, case-insensitive unless caseSensitive[0] is true. Postgres: ILIKE/LIKE. MySQL: LIKE/LIKE BINARY. SQLite: LIKE/GLOB (pattern converted).

Example: 

conn.Select().From("users").WhereLike("name", "An%")
// Postgres: SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1   args: [An%]
// MySQL: SELECT * FROM `users` WHERE `name` LIKE ?   args: [An%]
// SQLite: SELECT * FROM "users" WHERE "name" LIKE ?   args: [An%]

func (*SelectBuilder) WhereMap added in v0.2.0 

func (s *SelectBuilder) WhereMap(m map[string]any) *SelectBuilder

WhereMap adds one grouped "a = ? and b = ?" predicate; keys are sorted for stable SQL.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"role": "ann", "active": true})
// SELECT * FROM "users" WHERE ("active" = $1 AND "role" = $2)   args: [true ann]

func (*SelectBuilder) WhereMonth added in v0.2.0 

func (s *SelectBuilder) WhereMonth(column string, args ...any) *SelectBuilder

WhereMonth compares the month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereMonth("created_at", 3)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") = $1   args: [03]
// MySQL: SELECT * FROM `orders` WHERE MONTH(`created_at`) = ?   args: [03]

func (*SelectBuilder) WhereNone added in v0.2.0 

func (s *SelectBuilder) WhereNone(columns []string, args ...any) *SelectBuilder

WhereNone requires the predicate to hold for no column: not (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereNone([]string{"first_name", "last_name"}, "like", "%test%")
// SELECT * FROM "users" WHERE NOT ("first_name"::TEXT LIKE $1 OR "last_name"::TEXT LIKE $2)
//     args: [%test% %test%]

func (*SelectBuilder) WhereNot added in v0.2.0 

func (s *SelectBuilder) WhereNot(column string, args ...any) *SelectBuilder

WhereNot adds "AND NOT <predicate>".

Example: 

conn.Select().From("users").WhereNot("role", "admin")
// SELECT * FROM "users" WHERE NOT "role" = $1   args: [admin]

func (*SelectBuilder) WhereNotBetween added in v0.2.0 

func (s *SelectBuilder) WhereNotBetween(column string, lo any, hi any) *SelectBuilder

WhereNotBetween adds "col NOT BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2   args: [10 100]

func (*SelectBuilder) WhereNotBetweenColumns added in v0.2.0 

func (s *SelectBuilder) WhereNotBetweenColumns(column string, c1 string, c2 string) *SelectBuilder

WhereNotBetweenColumns is the negated WhereBetweenColumns.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price"

func (*SelectBuilder) WhereNotExists added in v0.2.0 

func (s *SelectBuilder) WhereNotExists(sub *SelectBuilder) *SelectBuilder

WhereNotExists adds "NOT EXISTS (subquery)".

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereNotExists(posts)
// SELECT * FROM "users" WHERE NOT EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*SelectBuilder) WhereNotIn added in v0.2.0 

func (s *SelectBuilder) WhereNotIn(column string, values any) *SelectBuilder

WhereNotIn adds "col NOT IN (...)". An empty list compiles to "1 = 1".

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2)   args: [1 2]

func (*SelectBuilder) WhereNotLike added in v0.2.0 

func (s *SelectBuilder) WhereNotLike(column string, value any, caseSensitive ...bool) *SelectBuilder

WhereNotLike is the negated WhereLike.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%")
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1   args: [%test%]

func (*SelectBuilder) WhereNotNull added in v0.2.0 

func (s *SelectBuilder) WhereNotNull(column string) *SelectBuilder

WhereNotNull adds "col IS NOT NULL".

Example: 

conn.Select().From("users").WhereNotNull("verified_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL

func (*SelectBuilder) WhereNull added in v0.2.0 

func (s *SelectBuilder) WhereNull(column string) *SelectBuilder

WhereNull adds "col IS NULL".

Example: 

conn.Select().From("users").WhereNull("deleted_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL

func (*SelectBuilder) WhereNullSafeEquals added in v0.2.0 

func (s *SelectBuilder) WhereNullSafeEquals(column string, value any) *SelectBuilder

WhereNullSafeEquals compares with NULL-safe equality (<=>, IS NOT DISTINCT FROM, IS).

Example: 

conn.Select().From("users").WhereNullSafeEquals("manager_id", 7)
// Postgres: SELECT * FROM "users" WHERE "manager_id" IS NOT DISTINCT FROM $1   args: [7]
// MySQL: SELECT * FROM `users` WHERE `manager_id` <=> ?   args: [7]

func (*SelectBuilder) WhereRaw added in v0.2.0 

func (s *SelectBuilder) WhereRaw(sql string, args ...any) *SelectBuilder

WhereRaw adds a raw predicate (caller-trusted SQL).

Example: 

conn.Select().From("users").WhereRaw("lower(name) = ?", "ann")
// SELECT * FROM "users" WHERE lower(name) = $1
// args: [ann]

func (*SelectBuilder) WhereRowValues added in v0.2.0 

func (s *SelectBuilder) WhereRowValues(columns []string, op string, values []any) *SelectBuilder

WhereRowValues adds "(a, b) op (?, ?)".

Example: 

conn.Select().From("events").
	WhereRowValues([]string{"created_at", "id"}, ">", []any{"2024-01-15", 42})
// SELECT * FROM "events" WHERE ("created_at", "id") > ($1, $2)   args: [2024-01-15 42]

func (*SelectBuilder) WhereTime added in v0.2.0 

func (s *SelectBuilder) WhereTime(column string, args ...any) *SelectBuilder

WhereTime compares the time part of a column.

Example: 

conn.Select().From("orders").WhereTime("created_at", ">", "10:30:00")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::TIME > $1   args: [10:30:00]
// MySQL: SELECT * FROM `orders` WHERE TIME(`created_at`) > ?   args: [10:30:00]

func (*SelectBuilder) WhereValueBetween added in v0.2.0 

func (s *SelectBuilder) WhereValueBetween(value any, c1 string, c2 string) *SelectBuilder

WhereValueBetween adds "? BETWEEN c1 AND c2" (a value between two columns).

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total"   args: [50]

func (*SelectBuilder) WhereValueNotBetween added in v0.2.0 

func (s *SelectBuilder) WhereValueNotBetween(value any, c1 string, c2 string) *SelectBuilder

WhereValueNotBetween is the negated WhereValueBetween.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total"   args: [50]

func (*SelectBuilder) WhereYear added in v0.2.0 

func (s *SelectBuilder) WhereYear(column string, args ...any) *SelectBuilder

WhereYear compares the year of a column.

Example: 

conn.Select().From("orders").WhereYear("created_at", 2024)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") = $1
//     args: [2024]
// MySQL: SELECT * FROM `orders` WHERE YEAR(`created_at`) = ?   args: [2024]

func (*SelectBuilder) With added in v0.2.0 

func (s *SelectBuilder) With(name string, q *SelectBuilder, opts ...CTEOption) *SelectBuilder

With adds a common table expression: "with name as (q)". The name is a table reference, so the table prefix applies to it as it does to From. The subquery is snapshotted: later changes to q do not affect this query. Options name the columns (CTEColumns) or hint materialization (CTEMaterialized, CTENotMaterialized).

On a select, a CTE can feed the query, a subquery, a union member, Count, Exists and Paginate. On an update or delete it is written before the verb (PostgreSQL, MySQL 8, SQLite; MariaDB returns ErrUnsupported). On an insert it is moved into the SELECT given to Using, so it needs Using.

Example: 

active := conn.Select().From("users").Where("active", true)
conn.Select().From("active_users").With("active_users", active)
// WITH "active_users" AS (SELECT * FROM "users" WHERE "active" = $1) SELECT * FROM
//     "active_users"
// args: [true]

func (*SelectBuilder) WithRaw added in v0.2.0 

func (s *SelectBuilder) WithRaw(name string, e Expression, opts ...CTEOption) *SelectBuilder

WithRaw adds a common table expression whose body is a raw SQL fragment (caller-trusted SQL), e.g. db.Raw("values (?), (?)", 1, 2). It takes the same options as With.

Example: 

conn.Select().From("ids").WithRaw("ids", db.Raw("values (?), (?)", 1, 2), db.CTEColumns("id"))
// WITH "ids" ("id") AS (values ($1), ($2)) SELECT * FROM "ids"
// args: [1 2]

func (*SelectBuilder) WithRecursive added in v0.2.0 

func (s *SelectBuilder) WithRecursive(name string, anchor *SelectBuilder, step *SelectBuilder, opts ...CTEOption) *SelectBuilder

WithRecursive adds a recursive common table expression and switches the clause to "with recursive". anchor is the starting query and step the recursive member that refers to name; they are joined with UNION ALL (CTEUnionDistinct for UNION) and written without parentheses, because SQLite rejects a recursive reference inside a subquery. Neither query is modified, and anchor must not have unions.

Example: 

anchor := conn.Select().From("categories").Where("parent_id", nil)
step := conn.Select().From("categories as c").Join("tree as t", "c.parent_id", "t.id")
conn.Select().From("tree").WithRecursive("tree", anchor, step)
// WITH RECURSIVE "tree" AS (SELECT * FROM "categories" WHERE "parent_id" IS NULL UNION ALL
//     SELECT * FROM "categories" AS "c" INNER JOIN "tree" AS "t" ON "c"."parent_id" =
//     "t"."id") SELECT * FROM "tree"

type SimplePage 

type SimplePage struct {
	PerPage     int
	CurrentPage int
	HasMore     bool
}

SimplePage is a pagination without a total count.

Example: 

var users []User
p, err := conn.Select().From("users").OrderBy("id").SimplePaginate(ctx, 1, 2, &users)
// p.PerPage = 2, p.CurrentPage = 1, p.HasMore = true when a third row exists

type SimplePaged 

type SimplePaged[T any] struct {
	SimplePage
	Items []T
}

SimplePaged is a count-free page with its rows.

type Stmt 

type Stmt struct {
	SQL  string
	Args []any
}

Stmt is one compiled statement and its ordered bind arguments.

type Tabler 

type Tabler interface{ TableName() string }

Tabler is implemented by row types that know their table, which lets From[T] work without a table name: 

func (User) TableName() string { return "users" }

Either receiver kind works, and the method is promoted through embedding.

The method is called on a zero value, once per type: the result is cached, so a name that changes later is not picked up. A method that panics on a zero value (for example by dereferencing a nil embedded pointer) is reported as ErrInvalidArgs instead. For per-tenant or per-period tables, give the name explicitly with As[T](conn.Select().From(name)).

type UpdateBuilder added in v0.2.0 

type UpdateBuilder struct {
	// contains filtered or unexported fields
}

UpdateBuilder is a mutable UPDATE statement. Start one with DB.Update, add assignments with Set/SetMap/SetRow/Increment/Decrement, narrow it with Where, and finish with Exec, Get or ToSQL. Without a WHERE or LIMIT it refuses to build (ErrNoWhere) unless AllRows was called. Not safe for concurrent use.

func (*UpdateBuilder) AllRows added in v0.2.0 

func (u *UpdateBuilder) AllRows() *UpdateBuilder

AllRows confirms that an update/delete without a where clause is intended. Without it, an UpdateBuilder or DeleteBuilder refuses to build (ErrNoWhere).

Example: 

conn.Delete("sessions").AllRows().ToSQL()
// DELETE FROM "sessions"   args: []

func (*UpdateBuilder) Clone added in v0.2.0 

func (u *UpdateBuilder) Clone() *UpdateBuilder

Clone returns an independent copy. Cloning a nil *UpdateBuilder returns nil.

Example: 

base := conn.Update("users").Set("active", false)
one := base.Clone().Where("id", 1)

func (*UpdateBuilder) CrossJoin added in v0.2.0 

func (u *UpdateBuilder) CrossJoin(table string) *UpdateBuilder

CrossJoin adds "CROSS JOIN table".

Example: 

conn.Select().From("users").CrossJoin("roles")
// SELECT * FROM "users" CROSS JOIN "roles"

func (*UpdateBuilder) CrossJoinSub added in v0.2.0 

func (u *UpdateBuilder) CrossJoinSub(sub *SelectBuilder, as string) *UpdateBuilder

CrossJoinSub cross joins a subquery.

Example: 

sub := conn.Select().From("roles").Select("name").Where("active", true)
conn.Select().From("users").CrossJoinSub(sub, "r")
// SELECT * FROM "users" CROSS JOIN (SELECT "name" FROM "roles" WHERE "active" = $1) AS "r"
// args: [true]

func (*UpdateBuilder) Decrement added in v0.2.0 

func (u *UpdateBuilder) Decrement(column string, amount any) *UpdateBuilder

Decrement sets column = column - amount.

Example: 

conn.Update("products").Decrement("stock", 2).Where("id", 3)
// UPDATE "products" SET "stock" = "stock" - $1 WHERE "id" = $2   args: [2 3]

func (*UpdateBuilder) DecrementEach added in v0.2.0 

func (u *UpdateBuilder) DecrementEach(amounts map[string]any) *UpdateBuilder

DecrementEach decrements several columns at once.

Example: 

conn.Update("stats").DecrementEach(map[string]any{"views": 5, "clicks": 1}).Where("day", "2026-01-01")
// UPDATE "stats" SET "clicks" = "clicks" - $1, "views" = "views" - $2 WHERE "day" = $3
// args: [1 5 2026-01-01]

func (*UpdateBuilder) Err added in v0.2.0 

func (u *UpdateBuilder) Err() error

Err returns the first error recorded while building.

Example: 

q := conn.Select().From("users").Where("id", "!!", 1)
err := q.Err()
// err: quill: invalid operator: "!!"

func (*UpdateBuilder) Exec added in v0.2.0 

func (u *UpdateBuilder) Exec(ctx context.Context) (int64, error)

Exec runs the update and returns the rows affected.

Example: 

n, err := conn.Update("users").Set("name", "Ann").Where("id", 7).Exec(ctx)
// UPDATE "users" SET "name" = $1 WHERE "id" = $2   args: [Ann 7]

func (*UpdateBuilder) FromJoins added in v0.2.0 

func (u *UpdateBuilder) FromJoins() *UpdateBuilder

FromJoins switches to the Postgres "UPDATE t SET ... FROM j1, j2 WHERE ..." form, where each Join's ON conditions become part of the WHERE. Other dialects return ErrUnsupported (MySQL supports Join directly).

Example: 

conn.Update("posts").Join("users", "users.id", "=", "posts.user_id").FromJoins().
	Set("hidden", true).Where("users.banned", true)
// UPDATE "posts" SET "hidden" = $1 FROM "users"
//   WHERE "users"."banned" = $2 AND "users"."id" = "posts"."user_id"   args: [true true]

func (*UpdateBuilder) Get added in v0.2.0 

func (u *UpdateBuilder) Get(ctx context.Context, dest any) error

Get runs the update and scans the RETURNING rows into dest. Call Returning first.

Example: 

var rows []User
err := conn.Update("users").Set("name", "Ann").Where("id", 7).Returning("*").Get(ctx, &rows)
// UPDATE "users" SET "name" = $1 WHERE "id" = $2 RETURNING *   args: [Ann 7]

func (*UpdateBuilder) InRandomOrder added in v0.2.0 

func (u *UpdateBuilder) InRandomOrder(seed ...int) *UpdateBuilder

InRandomOrder orders randomly: RANDOM() on Postgres/SQLite, RAND([seed]) on MySQL.

Example: 

conn.Select().From("posts").InRandomOrder().Limit(5)
// Postgres: SELECT * FROM "posts" ORDER BY RANDOM() LIMIT 5
// MySQL: SELECT * FROM `posts` ORDER BY RAND() LIMIT 5

func (*UpdateBuilder) Increment added in v0.2.0 

func (u *UpdateBuilder) Increment(column string, amount any) *UpdateBuilder

Increment sets column = column + amount.

Example: 

conn.Update("posts").Increment("views", 1).Set("seen_by", "ann").Where("id", 7)
// UPDATE "posts" SET "views" = "views" + $1, "seen_by" = $2 WHERE "id" = $3   args: [1 ann 7]

func (*UpdateBuilder) IncrementEach added in v0.2.0 

func (u *UpdateBuilder) IncrementEach(amounts map[string]any) *UpdateBuilder

IncrementEach increments several columns at once; amounts maps column to amount.

Example: 

conn.Update("stats").IncrementEach(map[string]any{"views": 5, "clicks": 1}).Where("day", "2026-01-01")
// UPDATE "stats" SET "clicks" = "clicks" + $1, "views" = "views" + $2 WHERE "day" = $3
// args: [1 5 2026-01-01]

func (*UpdateBuilder) Join added in v0.2.0 

func (u *UpdateBuilder) Join(table string, first string, args ...any) *UpdateBuilder

Join adds "INNER JOIN table ON first = second" (or "first op second").

Example: 

conn.Select().From("users as u").Join("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*UpdateBuilder) JoinFunc added in v0.2.0 

func (u *UpdateBuilder) JoinFunc(table string, fn func(*JoinClause)) *UpdateBuilder

JoinFunc adds an inner join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").JoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.published", true)
})
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."published" = $1
// args: [true]

func (*UpdateBuilder) JoinLateral added in v0.2.0 

func (u *UpdateBuilder) JoinLateral(sub *SelectBuilder, as string) *UpdateBuilder

JoinLateral adds "INNER JOIN LATERAL (subquery) AS alias ON TRUE" (Postgres, MySQL >= 8.0.14).

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").JoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" INNER JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE
// MariaDB returns ErrUnsupported

func (*UpdateBuilder) JoinSub added in v0.2.0 

func (u *UpdateBuilder) JoinSub(sub *SelectBuilder, as string, first string, args ...any) *UpdateBuilder

JoinSub joins a subquery: "INNER JOIN (SELECT ...) AS alias ON ...".

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").JoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*UpdateBuilder) JoinSubFunc added in v0.2.0 

func (u *UpdateBuilder) JoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *UpdateBuilder

JoinSubFunc joins a subquery with a complex ON clause built in fn.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").JoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" INNER JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" > $1
// args: [10]

func (*UpdateBuilder) JoinWhere added in v0.2.0 

func (u *UpdateBuilder) JoinWhere(table string, column string, args ...any) *UpdateBuilder

JoinWhere joins on a bound value: "INNER JOIN t ON col = ?".

Example: 

conn.Select().From("users as u").JoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" INNER JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*UpdateBuilder) Latest added in v0.2.0 

func (u *UpdateBuilder) Latest(column ...string) *UpdateBuilder

Latest orders by column descending (default "created_at").

Example: 

conn.Select().From("posts").Latest("published_at")
// SELECT * FROM "posts" ORDER BY "published_at" DESC

func (*UpdateBuilder) LeftJoin added in v0.2.0 

func (u *UpdateBuilder) LeftJoin(table string, first string, args ...any) *UpdateBuilder

LeftJoin adds a left join.

Example: 

conn.Select().From("users as u").LeftJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*UpdateBuilder) LeftJoinFunc added in v0.2.0 

func (u *UpdateBuilder) LeftJoinFunc(table string, fn func(*JoinClause)) *UpdateBuilder

LeftJoinFunc adds a left join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").LeftJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNull("p.deleted_at")
})
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."deleted_at" IS NULL

func (*UpdateBuilder) LeftJoinLateral added in v0.2.0 

func (u *UpdateBuilder) LeftJoinLateral(sub *SelectBuilder, as string) *UpdateBuilder

LeftJoinLateral is JoinLateral as a left join.

Example: 

recent := conn.Select().From("posts").Select("id", "title").
	WhereColumn("posts.user_id", "u.id").Limit(1)
conn.Select().From("users as u").LeftJoinLateral(recent, "rp")
// SELECT * FROM "users" AS "u" LEFT JOIN LATERAL (SELECT "id", "title" FROM "posts" WHERE
//     "posts"."user_id" = "u"."id" LIMIT 1) AS "rp" ON TRUE

func (*UpdateBuilder) LeftJoinSub added in v0.2.0 

func (u *UpdateBuilder) LeftJoinSub(sub *SelectBuilder, as string, first string, args ...any) *UpdateBuilder

LeftJoinSub joins a subquery with a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").LeftJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1) AS
//     "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*UpdateBuilder) LeftJoinSubFunc added in v0.2.0 

func (u *UpdateBuilder) LeftJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *UpdateBuilder

LeftJoinSubFunc is JoinSubFunc as a left join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").LeftJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").WhereNotNull("p.score")
})
// SELECT * FROM "users" AS "u" LEFT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id" AND "p"."score" IS NOT NULL

func (*UpdateBuilder) LeftJoinWhere added in v0.2.0 

func (u *UpdateBuilder) LeftJoinWhere(table string, column string, args ...any) *UpdateBuilder

LeftJoinWhere is JoinWhere as a left join.

Example: 

conn.Select().From("users as u").LeftJoinWhere("posts as p", "p.score", ">", 10)
// SELECT * FROM "users" AS "u" LEFT JOIN "posts" AS "p" ON "p"."score" > $1
// args: [10]

func (*UpdateBuilder) Limit added in v0.2.0 

func (u *UpdateBuilder) Limit(n int) *UpdateBuilder

Limit sets LIMIT; negative values are ignored.

Example: 

conn.Select().From("users").Limit(10)
// SELECT * FROM "users" LIMIT 10

func (*UpdateBuilder) Oldest added in v0.2.0 

func (u *UpdateBuilder) Oldest(column ...string) *UpdateBuilder

Oldest orders by column ascending (default "created_at").

Example: 

conn.Select().From("posts").Oldest()
// SELECT * FROM "posts" ORDER BY "created_at" ASC

func (*UpdateBuilder) OrWhere added in v0.2.0 

func (u *UpdateBuilder) OrWhere(column string, args ...any) *UpdateBuilder

OrWhere is Where joined with OR.

Example: 

conn.Select().From("users").Where("role", "admin").OrWhere("role", "owner")
// SELECT * FROM "users" WHERE "role" = $1 OR "role" = $2
// args: [admin owner]

func (*UpdateBuilder) OrWhereAll added in v0.2.0 

func (u *UpdateBuilder) OrWhereAll(columns []string, args ...any) *UpdateBuilder

OrWhereAll is WhereAll joined with OR.

Example: 

conn.Select().From("users").WhereAll([]string{"a", "b"}, 1).OrWhereAll([]string{"c", "d"}, ">", 5)
// SELECT * FROM "users" WHERE ("a" = $1 AND "b" = $2) OR ("c" > $3 AND "d" > $4)
//     args: [1 1 5 5]

func (*UpdateBuilder) OrWhereAny added in v0.2.0 

func (u *UpdateBuilder) OrWhereAny(columns []string, args ...any) *UpdateBuilder

OrWhereAny is WhereAny joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereAny([]string{"a", "b"}, ">", 5)
// SELECT * FROM "users" WHERE "active" = $1 OR ("a" > $2 OR "b" > $3)   args: [true 5 5]

func (*UpdateBuilder) OrWhereBetween added in v0.2.0 

func (u *UpdateBuilder) OrWhereBetween(column string, lo any, hi any) *UpdateBuilder

OrWhereBetween is WhereBetween joined with OR.

Example: 

conn.Select().From("orders").Where("status", "paid").OrWhereBetween("total", 500, 900)
// SELECT * FROM "orders" WHERE "status" = $1 OR "total" BETWEEN $2 AND $3
//     args: [paid 500 900]

func (*UpdateBuilder) OrWhereBetweenColumns added in v0.2.0 

func (u *UpdateBuilder) OrWhereBetweenColumns(column string, c1 string, c2 string) *UpdateBuilder

OrWhereBetweenColumns is WhereBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price").
	OrWhereBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price" OR "cost"
//     BETWEEN "low" AND "high"

func (*UpdateBuilder) OrWhereColumn added in v0.2.0 

func (u *UpdateBuilder) OrWhereColumn(first string, args ...any) *UpdateBuilder

OrWhereColumn is WhereColumn joined with OR.

Example: 

conn.Select().From("users").WhereColumn("first_name", "last_name").OrWhereColumn("a", "<>", "b")
// SELECT * FROM "users" WHERE "first_name" = "last_name" OR "a" <> "b"

func (*UpdateBuilder) OrWhereDate added in v0.2.0 

func (u *UpdateBuilder) OrWhereDate(column string, args ...any) *UpdateBuilder

OrWhereDate is WhereDate joined with OR.

Example: 

conn.Select().From("orders").WhereDate("created_at", "2024-01-15").
	OrWhereDate("created_at", "2024-02-01")
// SELECT * FROM "orders" WHERE "created_at"::DATE = $1 OR "created_at"::DATE = $2
//     args: [2024-01-15 2024-02-01]

func (*UpdateBuilder) OrWhereDay added in v0.2.0 

func (u *UpdateBuilder) OrWhereDay(column string, args ...any) *UpdateBuilder

OrWhereDay is WhereDay joined with OR.

Example: 

conn.Select().From("orders").WhereDay("created_at", 15).OrWhereDay("created_at", ">", 20)
// SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1 OR EXTRACT(DAY FROM
//     "created_at") > $2
//     args: [15 20]

func (*UpdateBuilder) OrWhereExists added in v0.2.0 

func (u *UpdateBuilder) OrWhereExists(sub *SelectBuilder) *UpdateBuilder

OrWhereExists is WhereExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*UpdateBuilder) OrWhereGroup added in v0.2.0 

func (u *UpdateBuilder) OrWhereGroup(fn func(*WhereClause)) *UpdateBuilder

OrWhereGroup is WhereGroup joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").Where("age", ">", 30)
})
// SELECT * FROM "users" WHERE "active" = $1 OR ("role" = $2 AND "age" > $3)
//     args: [true admin 30]

func (*UpdateBuilder) OrWhereIn added in v0.2.0 

func (u *UpdateBuilder) OrWhereIn(column string, values any) *UpdateBuilder

OrWhereIn is WhereIn joined with OR.

Example: 

conn.Select().From("users").WhereIn("role", []string{"ann", "bob"}).OrWhereIn("id", []int{9})
// SELECT * FROM "users" WHERE "role" IN ($1, $2) OR "id" IN ($3)   args: [ann bob 9]

func (*UpdateBuilder) OrWhereIntegerInRaw added in v0.2.0 

func (u *UpdateBuilder) OrWhereIntegerInRaw(column string, values any) *UpdateBuilder

OrWhereIntegerInRaw is WhereIntegerInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1}).
	OrWhereIntegerInRaw("id", []int64{7, 8})
// SELECT * FROM "users" WHERE "id" IN (1) OR "id" IN (7, 8)

func (*UpdateBuilder) OrWhereIntegerNotInRaw added in v0.2.0 

func (u *UpdateBuilder) OrWhereIntegerNotInRaw(column string, values any) *UpdateBuilder

OrWhereIntegerNotInRaw is WhereIntegerNotInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2}).
	OrWhereIntegerNotInRaw("id", []int{3})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2) OR "id" NOT IN (3)

func (*UpdateBuilder) OrWhereJsonContains added in v0.2.0 

func (u *UpdateBuilder) OrWhereJsonContains(column string, value any) *UpdateBuilder

OrWhereJsonContains is WhereJsonContains joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR ("options"->'tags')::JSONB @> $2
// args: [true "go"]

func (*UpdateBuilder) OrWhereJsonContainsKey added in v0.2.0 

func (u *UpdateBuilder) OrWhereJsonContainsKey(column string) *UpdateBuilder

OrWhereJsonContainsKey is WhereJsonContainsKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*UpdateBuilder) OrWhereJsonDoesntContain added in v0.2.0 

func (u *UpdateBuilder) OrWhereJsonDoesntContain(column string, value any) *UpdateBuilder

OrWhereJsonDoesntContain is WhereJsonDoesntContain joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("options"->'tags')::JSONB @> $2
// args: [true "php"]

func (*UpdateBuilder) OrWhereJsonDoesntContainKey added in v0.2.0 

func (u *UpdateBuilder) OrWhereJsonDoesntContainKey(column string) *UpdateBuilder

OrWhereJsonDoesntContainKey is WhereJsonDoesntContainKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).
	OrWhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1
//   OR NOT COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*UpdateBuilder) OrWhereJsonDoesntOverlap added in v0.2.0 

func (u *UpdateBuilder) OrWhereJsonDoesntOverlap(column string, value any) *UpdateBuilder

OrWhereJsonDoesntOverlap is WhereJsonDoesntOverlap joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["php"]]

func (*UpdateBuilder) OrWhereJsonLength added in v0.2.0 

func (u *UpdateBuilder) OrWhereJsonLength(column string, args ...any) *UpdateBuilder

OrWhereJsonLength is WhereJsonLength joined with OR.

Example: 

conn.Select().From("users").WhereJsonLength("options->tags", 0)
.OrWhereJsonLength("options->roles", ">=", 3).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   OR JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) >= $2   args: [0 3]

func (*UpdateBuilder) OrWhereJsonOverlaps added in v0.2.0 

func (u *UpdateBuilder) OrWhereJsonOverlaps(column string, value any) *UpdateBuilder

OrWhereJsonOverlaps is WhereJsonOverlaps joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonOverlaps("options->tags", []string{"go"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["go"]]

func (*UpdateBuilder) OrWhereLike added in v0.2.0 

func (u *UpdateBuilder) OrWhereLike(column string, value any, caseSensitive ...bool) *UpdateBuilder

OrWhereLike is WhereLike joined with OR.

Example: 

conn.Select().From("users").WhereLike("name", "an%").OrWhereLike("name", "bo%")
// SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1 OR "name"::TEXT ILIKE $2
//     args: [an% bo%]

func (*UpdateBuilder) OrWhereMap added in v0.2.0 

func (u *UpdateBuilder) OrWhereMap(m map[string]any) *UpdateBuilder

OrWhereMap is WhereMap joined with OR.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"a": 1}).OrWhereMap(map[string]any{"b": 2})
// SELECT * FROM "users" WHERE ("a" = $1) OR ("b" = $2)   args: [1 2]

func (*UpdateBuilder) OrWhereMonth added in v0.2.0 

func (u *UpdateBuilder) OrWhereMonth(column string, args ...any) *UpdateBuilder

OrWhereMonth is WhereMonth joined with OR.

Example: 

conn.Select().From("orders").WhereMonth("created_at", ">=", 6).OrWhereMonth("created_at", 1)
// SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") >= $1 OR EXTRACT(MONTH FROM
//     "created_at") = $2
//     args: [06 01]

func (*UpdateBuilder) OrWhereNone added in v0.2.0 

func (u *UpdateBuilder) OrWhereNone(columns []string, args ...any) *UpdateBuilder

OrWhereNone is WhereNone joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereNone([]string{"a", "b"}, 0)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("a" = $2 OR "b" = $3)
//     args: [true 0 0]

func (*UpdateBuilder) OrWhereNot added in v0.2.0 

func (u *UpdateBuilder) OrWhereNot(column string, args ...any) *UpdateBuilder

OrWhereNot adds "OR NOT <predicate>".

Example: 

conn.Select().From("users").Where("age", ">", 18).OrWhereNot("status", "<", 3)
// SELECT * FROM "users" WHERE "age" > $1 OR NOT "status" < $2   args: [18 3]

func (*UpdateBuilder) OrWhereNotBetween added in v0.2.0 

func (u *UpdateBuilder) OrWhereNotBetween(column string, lo any, hi any) *UpdateBuilder

OrWhereNotBetween is WhereNotBetween joined with OR.

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100).OrWhereNotBetween("qty", 1, 5)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2 OR "qty" NOT BETWEEN $3 AND $4
//     args: [10 100 1 5]

func (*UpdateBuilder) OrWhereNotBetweenColumns added in v0.2.0 

func (u *UpdateBuilder) OrWhereNotBetweenColumns(column string, c1 string, c2 string) *UpdateBuilder

OrWhereNotBetweenColumns is WhereNotBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price").
	OrWhereNotBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price" OR "cost"
//     NOT BETWEEN "low" AND "high"

func (*UpdateBuilder) OrWhereNotExists added in v0.2.0 

func (u *UpdateBuilder) OrWhereNotExists(sub *SelectBuilder) *UpdateBuilder

OrWhereNotExists is WhereNotExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereNotExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*UpdateBuilder) OrWhereNotIn added in v0.2.0 

func (u *UpdateBuilder) OrWhereNotIn(column string, values any) *UpdateBuilder

OrWhereNotIn is WhereNotIn joined with OR.

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2}).OrWhereNotIn("role", []string{"ann"})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2) OR "role" NOT IN ($3)   args: [1 2 ann]

func (*UpdateBuilder) OrWhereNotLike added in v0.2.0 

func (u *UpdateBuilder) OrWhereNotLike(column string, value any, caseSensitive ...bool) *UpdateBuilder

OrWhereNotLike is WhereNotLike joined with OR.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%").OrWhereNotLike("name", "%demo%", true)
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1 OR "name"::TEXT NOT LIKE $2
//     args: [%test% %demo%]

func (*UpdateBuilder) OrWhereNotNull added in v0.2.0 

func (u *UpdateBuilder) OrWhereNotNull(column string) *UpdateBuilder

OrWhereNotNull is WhereNotNull joined with OR.

Example: 

conn.Select().From("users").WhereNotNull("verified_at").OrWhereNotNull("invited_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL OR "invited_at" IS NOT NULL

func (*UpdateBuilder) OrWhereNull added in v0.2.0 

func (u *UpdateBuilder) OrWhereNull(column string) *UpdateBuilder

OrWhereNull is WhereNull joined with OR.

Example: 

conn.Select().From("users").WhereNull("deleted_at").OrWhereNull("banned_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL OR "banned_at" IS NULL

func (*UpdateBuilder) OrWhereNullSafeEquals added in v0.2.0 

func (u *UpdateBuilder) OrWhereNullSafeEquals(column string, value any) *UpdateBuilder

OrWhereNullSafeEquals is WhereNullSafeEquals joined with OR.

Example: 

conn.Select().From("users").WhereNullSafeEquals("a", 1).OrWhereNullSafeEquals("b", 2)
// SELECT * FROM "users" WHERE "a" IS NOT DISTINCT FROM $1 OR "b" IS NOT DISTINCT FROM $2
//     args: [1 2]

func (*UpdateBuilder) OrWhereRaw added in v0.2.0 

func (u *UpdateBuilder) OrWhereRaw(sql string, args ...any) *UpdateBuilder

OrWhereRaw is WhereRaw joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereRaw("age between ? and ?", 18, 30)
// SELECT * FROM "users" WHERE "active" = $1 OR age between $2 and $3
// args: [true 18 30]

func (*UpdateBuilder) OrWhereRowValues added in v0.2.0 

func (u *UpdateBuilder) OrWhereRowValues(columns []string, op string, values []any) *UpdateBuilder

OrWhereRowValues is WhereRowValues joined with OR.

Example: 

conn.Select().From("events").Where("kind", "x").
	OrWhereRowValues([]string{"a", "b"}, "=", []any{1, 2})
// SELECT * FROM "events" WHERE "kind" = $1 OR ("a", "b") = ($2, $3)   args: [x 1 2]

func (*UpdateBuilder) OrWhereTime added in v0.2.0 

func (u *UpdateBuilder) OrWhereTime(column string, args ...any) *UpdateBuilder

OrWhereTime is WhereTime joined with OR.

Example: 

conn.Select().From("orders").WhereTime("created_at", "10:30:00").
	OrWhereTime("created_at", "<", "08:00:00")
// SELECT * FROM "orders" WHERE "created_at"::TIME = $1 OR "created_at"::TIME < $2
//     args: [10:30:00 08:00:00]

func (*UpdateBuilder) OrWhereValueBetween added in v0.2.0 

func (u *UpdateBuilder) OrWhereValueBetween(value any, c1 string, c2 string) *UpdateBuilder

OrWhereValueBetween is WhereValueBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total").
	OrWhereValueBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total" OR $2 BETWEEN "a" AND
//     "b"
//     args: [50 7]

func (*UpdateBuilder) OrWhereValueNotBetween added in v0.2.0 

func (u *UpdateBuilder) OrWhereValueNotBetween(value any, c1 string, c2 string) *UpdateBuilder

OrWhereValueNotBetween is WhereValueNotBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total").
	OrWhereValueNotBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total" OR $2 NOT BETWEEN
//     "a" AND "b"
//     args: [50 7]

func (*UpdateBuilder) OrWhereYear added in v0.2.0 

func (u *UpdateBuilder) OrWhereYear(column string, args ...any) *UpdateBuilder

OrWhereYear is WhereYear joined with OR.

Example: 

conn.Select().From("orders").WhereYear("created_at", ">", 2020).OrWhereYear("created_at", 1999)
// SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") > $1 OR EXTRACT(YEAR FROM
//     "created_at") = $2
//     args: [2020 1999]

func (*UpdateBuilder) OrderBy added in v0.2.0 

func (u *UpdateBuilder) OrderBy(column string, direction ...string) *UpdateBuilder

OrderBy adds ORDER BY column; direction is "asc" (default) or "desc".

Example: 

conn.Select().From("users").OrderBy("name").OrderBy("age", "desc")
// SELECT * FROM "users" ORDER BY "name" ASC, "age" DESC

func (*UpdateBuilder) OrderByDesc added in v0.2.0 

func (u *UpdateBuilder) OrderByDesc(column string) *UpdateBuilder

OrderByDesc is OrderBy(column, "desc").

Example: 

conn.Select().From("users").OrderByDesc("created_at")
// SELECT * FROM "users" ORDER BY "created_at" DESC

func (*UpdateBuilder) OrderByRaw added in v0.2.0 

func (u *UpdateBuilder) OrderByRaw(sql string, args ...any) *UpdateBuilder

OrderByRaw adds a raw ORDER BY expression (caller-trusted SQL).

Example: 

conn.Select().From("users").OrderByRaw("case when role = ? then 0 else 1 end", "admin")
// SELECT * FROM "users" ORDER BY case when role = $1 then 0 else 1 end
// args: [admin]

func (*UpdateBuilder) Prefix added in v0.2.0 

func (u *UpdateBuilder) Prefix(p string) *UpdateBuilder

Prefix sets a table prefix applied to table names, aliases and qualified columns.

Example: 

db.Use(db.Postgres).Select("u.id").From("users as u").Prefix("app_")
// SELECT "app_u"."id" FROM "app_users" AS "app_u"

func (*UpdateBuilder) Reorder added in v0.2.0 

func (u *UpdateBuilder) Reorder() *UpdateBuilder

Reorder removes all existing ORDER BY clauses (including a union's).

Example: 

conn.Select().From("posts").OrderBy("title").Reorder()
// SELECT * FROM "posts"

func (*UpdateBuilder) ReorderBy added in v0.2.0 

func (u *UpdateBuilder) ReorderBy(column string, direction ...string) *UpdateBuilder

ReorderBy is Reorder followed by OrderBy(column, direction).

Example: 

conn.Select().From("posts").OrderBy("title").ReorderBy("id", "desc")
// SELECT * FROM "posts" ORDER BY "id" DESC

func (*UpdateBuilder) Returning added in v0.2.0 

func (u *UpdateBuilder) Returning(columns ...string) *UpdateBuilder

Returning adds a RETURNING clause to insert/update/delete/upsert (Postgres, SQLite >= 3.35; MySQL returns ErrUnsupported). "*" is allowed.

Example: 

conn.Insert("users").Values(map[string]any{"name": "Ann"}).Returning("id", "created_at").ToSQL()
// INSERT INTO "users" ("name") VALUES ($1) RETURNING "id", "created_at"   args: [Ann]
// MySQL: ToSQL returns ErrUnsupported

func (*UpdateBuilder) RightJoin added in v0.2.0 

func (u *UpdateBuilder) RightJoin(table string, first string, args ...any) *UpdateBuilder

RightJoin adds a right join.

Example: 

conn.Select().From("users as u").RightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id"

func (*UpdateBuilder) RightJoinFunc added in v0.2.0 

func (u *UpdateBuilder) RightJoinFunc(table string, fn func(*JoinClause)) *UpdateBuilder

RightJoinFunc adds a right join with a complex ON clause built in fn.

Example: 

conn.Select().From("users as u").RightJoinFunc("posts as p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id").Where("p.score", ">", 10)
})
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."user_id" = "u"."id" AND
//     "p"."score" > $1
// args: [10]

func (*UpdateBuilder) RightJoinSub added in v0.2.0 

func (u *UpdateBuilder) RightJoinSub(sub *SelectBuilder, as string, first string, args ...any) *UpdateBuilder

RightJoinSub joins a subquery with a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id").Where("score", ">", 10)
conn.Select().From("users as u").RightJoinSub(sub, "t", "t.user_id", "u.id")
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id" FROM "posts" WHERE "score" > $1)
//     AS "t" ON "t"."user_id" = "u"."id"
// args: [10]

func (*UpdateBuilder) RightJoinSubFunc added in v0.2.0 

func (u *UpdateBuilder) RightJoinSubFunc(sub *SelectBuilder, as string, fn func(*JoinClause)) *UpdateBuilder

RightJoinSubFunc is JoinSubFunc as a right join.

Example: 

sub := conn.Select().From("posts").Select("user_id", "score")
conn.Select().From("users as u").RightJoinSubFunc(sub, "p", func(j *db.JoinClause) {
	j.On("p.user_id", "u.id")
})
// SELECT * FROM "users" AS "u" RIGHT JOIN (SELECT "user_id", "score" FROM "posts") AS "p" ON
//     "p"."user_id" = "u"."id"

func (*UpdateBuilder) RightJoinWhere added in v0.2.0 

func (u *UpdateBuilder) RightJoinWhere(table string, column string, args ...any) *UpdateBuilder

RightJoinWhere is JoinWhere as a right join.

Example: 

conn.Select().From("users as u").RightJoinWhere("posts as p", "p.status", "published")
// SELECT * FROM "users" AS "u" RIGHT JOIN "posts" AS "p" ON "p"."status" = $1
// args: [published]

func (*UpdateBuilder) Set added in v0.2.0 

func (u *UpdateBuilder) Set(column string, value any) *UpdateBuilder

Set assigns value to column. Values may be Raw expressions or *SelectBuilder subqueries; "col->path" keys update inside a JSON column. Setting the same column again replaces the earlier value.

Example: 

conn.Update("users").Set("name", "Ann").Set("age", 31).Where("id", 7)
// UPDATE "users" SET "name" = $1, "age" = $2 WHERE "id" = $3   args: [Ann 31 7]

func (*UpdateBuilder) SetMap added in v0.2.0 

func (u *UpdateBuilder) SetMap(values map[string]any) *UpdateBuilder

SetMap assigns every entry of values, in sorted column order.

Example: 

conn.Update("users").SetMap(map[string]any{"name": "Ann", "age": 31}).Where("id", 7)
// UPDATE "users" SET "age" = $1, "name" = $2 WHERE "id" = $3   args: [31 Ann 7]

func (*UpdateBuilder) SetRow added in v0.2.0 

func (u *UpdateBuilder) SetRow(row any) *UpdateBuilder

SetRow assigns the columns of a struct (see Row for the `db` tags).

Example: 

conn.Update("posts").SetRow(Post{Title: "Hello"}).Where("id", 1)
// UPDATE "posts" SET "title" = $1 WHERE "id" = $2   args: [Hello 1]

func (*UpdateBuilder) StraightJoin added in v0.2.0 

func (u *UpdateBuilder) StraightJoin(table string, first string, args ...any) *UpdateBuilder

StraightJoin adds a MySQL "straight_join"; other dialects error at compile time.

Example: 

connMy.Select().From("users as u").StraightJoin("posts as p", "p.user_id", "u.id")
// SELECT * FROM `users` AS `u` STRAIGHT_JOIN `posts` AS `p` ON `p`.`user_id` = `u`.`id`
// connMy is db.Use(db.MySQL); other dialects return ErrUnsupported

func (*UpdateBuilder) Take added in v0.2.0 

func (u *UpdateBuilder) Take(n int) *UpdateBuilder

Take is an alias of Limit.

Example: 

conn.Select().From("users").Take(5)
// SELECT * FROM "users" LIMIT 5

func (*UpdateBuilder) ToSQL added in v0.2.0 

func (u *UpdateBuilder) ToSQL() (string, []any, error)

ToSQL compiles the UPDATE into SQL text and its ordered bind arguments. No assignments returns ErrNoValues; no WHERE or LIMIT returns ErrNoWhere unless AllRows was called. Joins use native UPDATE ... JOIN on MySQL and a ctid/rowid subquery on Postgres/SQLite.

Example: 

sqlText, args, err := conn.Update("users").Set("name", "Ann").Where("id", 7).ToSQL()
// UPDATE "users" SET "name" = $1 WHERE "id" = $2   args: [Ann 7]

func (*UpdateBuilder) Where added in v0.2.0 

func (u *UpdateBuilder) Where(column string, args ...any) *UpdateBuilder

Where adds an AND predicate. Forms: Where(col, value) means "="; Where(col, op, value). A nil value with "=" / "!=" / "<>" becomes IS [NOT] NULL.

Example: 

conn.Select().From("users").Where("active", true).Where("age", ">=", 18)
// SELECT * FROM "users" WHERE "active" = $1 AND "age" >= $2
// args: [true 18]

func (*UpdateBuilder) WhereAll added in v0.2.0 

func (u *UpdateBuilder) WhereAll(columns []string, args ...any) *UpdateBuilder

WhereAll requires the predicate to hold for every column: (a = ? and b = ?).

Example: 

conn.Select().From("users").WhereAll([]string{"first_name", "last_name"}, "like", "an%")
// SELECT * FROM "users" WHERE ("first_name"::TEXT LIKE $1 AND "last_name"::TEXT LIKE $2)
//     args: [an% an%]

func (*UpdateBuilder) WhereAny added in v0.2.0 

func (u *UpdateBuilder) WhereAny(columns []string, args ...any) *UpdateBuilder

WhereAny requires the predicate to hold for at least one column: (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereAny([]string{"first_name", "last_name"}, "ann")
// SELECT * FROM "users" WHERE ("first_name" = $1 OR "last_name" = $2)   args: [ann ann]

func (*UpdateBuilder) WhereBetween added in v0.2.0 

func (u *UpdateBuilder) WhereBetween(column string, lo any, hi any) *UpdateBuilder

WhereBetween adds "col BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" BETWEEN $1 AND $2   args: [10 100]

func (*UpdateBuilder) WhereBetweenColumns added in v0.2.0 

func (u *UpdateBuilder) WhereBetweenColumns(column string, c1 string, c2 string) *UpdateBuilder

WhereBetweenColumns adds "col BETWEEN c1 AND c2" comparing against columns.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price"

func (*UpdateBuilder) WhereColumn added in v0.2.0 

func (u *UpdateBuilder) WhereColumn(first string, args ...any) *UpdateBuilder

WhereColumn compares two columns: WhereColumn(a, b) means "=", or WhereColumn(a, op, b).

Example: 

conn.Select().From("users").WhereColumn("updated_at", ">", "created_at")
// SELECT * FROM "users" WHERE "updated_at" > "created_at"

func (*UpdateBuilder) WhereDate added in v0.2.0 

func (u *UpdateBuilder) WhereDate(column string, args ...any) *UpdateBuilder

WhereDate compares the date part of a column.

Example: 

conn.Select().From("orders").WhereDate("created_at", ">=", "2024-01-15")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::DATE >= $1   args: [2024-01-15]
// MySQL: SELECT * FROM `orders` WHERE DATE(`created_at`) >= ?   args: [2024-01-15]
// SQLite: SELECT * FROM "orders" WHERE STRFTIME('%Y-%m-%d', "created_at") >= CAST(? AS TEXT)
//     args: [2024-01-15]

func (*UpdateBuilder) WhereDay added in v0.2.0 

func (u *UpdateBuilder) WhereDay(column string, args ...any) *UpdateBuilder

WhereDay compares the day-of-month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereDay("created_at", 15)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1   args: [15]
// MySQL: SELECT * FROM `orders` WHERE DAY(`created_at`) = ?   args: [15]

func (*UpdateBuilder) WhereExists added in v0.2.0 

func (u *UpdateBuilder) WhereExists(sub *SelectBuilder) *UpdateBuilder

WhereExists adds "EXISTS (subquery)". Build sub with DB.Select.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereExists(posts)
// SELECT * FROM "users" WHERE EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*UpdateBuilder) WhereGroup added in v0.2.0 

func (u *UpdateBuilder) WhereGroup(fn func(*WhereClause)) *UpdateBuilder

WhereGroup wraps the predicates added inside fn in parentheses. fn receives a fresh WhereClause; only its Where* calls are used.

Example: 

conn.Select().From("users").Where("active", true).WhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").OrWhere("role", "editor")
})
// SELECT * FROM "users" WHERE "active" = $1 AND ("role" = $2 OR "role" = $3)
//     args: [true admin editor]

func (*UpdateBuilder) WhereIn added in v0.2.0 

func (u *UpdateBuilder) WhereIn(column string, values any) *UpdateBuilder

WhereIn adds "col IN (...)". values may be any slice, a scalar, or a *SelectBuilder subquery. An empty list compiles to the always-false "0 = 1".

Example: 

conn.Select().From("users").WhereIn("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN ($1, $2, $3)   args: [1 2 3]

func (*UpdateBuilder) WhereIntegerInRaw added in v0.2.0 

func (u *UpdateBuilder) WhereIntegerInRaw(column string, values any) *UpdateBuilder

WhereIntegerInRaw inlines integers (no bind args); non-integers record an error. Useful for very large ID lists that would exceed driver parameter limits.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN (1, 2, 3)

func (*UpdateBuilder) WhereIntegerNotInRaw added in v0.2.0 

func (u *UpdateBuilder) WhereIntegerNotInRaw(column string, values any) *UpdateBuilder

WhereIntegerNotInRaw is the negated WhereIntegerInRaw.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2)

func (*UpdateBuilder) WhereJsonContains added in v0.2.0 

func (u *UpdateBuilder) WhereJsonContains(column string, value any) *UpdateBuilder

WhereJsonContains adds a JSON containment test on a column or "col->path". MySQL json_contains, Postgres @> (jsonb), SQLite json_each membership.

Example: 

conn.Select().From("users").WhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE ("options"->'tags')::JSONB @> $1   args: ["go"]

func (*UpdateBuilder) WhereJsonContainsKey added in v0.2.0 

func (u *UpdateBuilder) WhereJsonContainsKey(column string) *UpdateBuilder

WhereJsonContainsKey tests that the JSON path "col->key" exists.

Example: 

conn.Select().From("users").WhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []
// MySQL: SELECT * FROM `users`
//   WHERE IFNULL(JSON_CONTAINS_PATH(`options`, 'one', '$."theme"'), 0)

func (*UpdateBuilder) WhereJsonDoesntContain added in v0.2.0 

func (u *UpdateBuilder) WhereJsonDoesntContain(column string, value any) *UpdateBuilder

WhereJsonDoesntContain negates WhereJsonContains.

Example: 

conn.Select().From("users").WhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE NOT ("options"->'tags')::JSONB @> $1   args: ["php"]

func (*UpdateBuilder) WhereJsonDoesntContainKey added in v0.2.0 

func (u *UpdateBuilder) WhereJsonDoesntContainKey(column string) *UpdateBuilder

WhereJsonDoesntContainKey negates WhereJsonContainsKey.

Example: 

conn.Select().From("users").WhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE NOT COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []

func (*UpdateBuilder) WhereJsonDoesntOverlap added in v0.2.0 

func (u *UpdateBuilder) WhereJsonDoesntOverlap(column string, value any) *UpdateBuilder

WhereJsonDoesntOverlap negates WhereJsonOverlaps.

Example: 

conn.Select().From("users")
.WhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["php"]]

func (*UpdateBuilder) WhereJsonLength added in v0.2.0 

func (u *UpdateBuilder) WhereJsonLength(column string, args ...any) *UpdateBuilder

WhereJsonLength compares the length of a JSON array: (value) or (operator, value).

Example: 

conn.Select().From("users")
.WhereJsonLength("options->tags", 2).WhereJsonLength("options->roles", ">", 1).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   AND JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) > $2   args: [2 1]

func (*UpdateBuilder) WhereJsonOverlaps added in v0.2.0 

func (u *UpdateBuilder) WhereJsonOverlaps(column string, value any) *UpdateBuilder

WhereJsonOverlaps adds json_overlaps (MySQL only; other dialects error at compile time).

Example: 

conn.Select().From("users")
.WhereJsonOverlaps("options->tags", []string{"go", "sql"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["go","sql"]]

func (*UpdateBuilder) WhereLike added in v0.2.0 

func (u *UpdateBuilder) WhereLike(column string, value any, caseSensitive ...bool) *UpdateBuilder

WhereLike adds a LIKE predicate, case-insensitive unless caseSensitive[0] is true. Postgres: ILIKE/LIKE. MySQL: LIKE/LIKE BINARY. SQLite: LIKE/GLOB (pattern converted).

Example: 

conn.Select().From("users").WhereLike("name", "An%")
// Postgres: SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1   args: [An%]
// MySQL: SELECT * FROM `users` WHERE `name` LIKE ?   args: [An%]
// SQLite: SELECT * FROM "users" WHERE "name" LIKE ?   args: [An%]

func (*UpdateBuilder) WhereMap added in v0.2.0 

func (u *UpdateBuilder) WhereMap(m map[string]any) *UpdateBuilder

WhereMap adds one grouped "a = ? and b = ?" predicate; keys are sorted for stable SQL.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"role": "ann", "active": true})
// SELECT * FROM "users" WHERE ("active" = $1 AND "role" = $2)   args: [true ann]

func (*UpdateBuilder) WhereMonth added in v0.2.0 

func (u *UpdateBuilder) WhereMonth(column string, args ...any) *UpdateBuilder

WhereMonth compares the month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereMonth("created_at", 3)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") = $1   args: [03]
// MySQL: SELECT * FROM `orders` WHERE MONTH(`created_at`) = ?   args: [03]

func (*UpdateBuilder) WhereNone added in v0.2.0 

func (u *UpdateBuilder) WhereNone(columns []string, args ...any) *UpdateBuilder

WhereNone requires the predicate to hold for no column: not (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereNone([]string{"first_name", "last_name"}, "like", "%test%")
// SELECT * FROM "users" WHERE NOT ("first_name"::TEXT LIKE $1 OR "last_name"::TEXT LIKE $2)
//     args: [%test% %test%]

func (*UpdateBuilder) WhereNot added in v0.2.0 

func (u *UpdateBuilder) WhereNot(column string, args ...any) *UpdateBuilder

WhereNot adds "AND NOT <predicate>".

Example: 

conn.Select().From("users").WhereNot("role", "admin")
// SELECT * FROM "users" WHERE NOT "role" = $1   args: [admin]

func (*UpdateBuilder) WhereNotBetween added in v0.2.0 

func (u *UpdateBuilder) WhereNotBetween(column string, lo any, hi any) *UpdateBuilder

WhereNotBetween adds "col NOT BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2   args: [10 100]

func (*UpdateBuilder) WhereNotBetweenColumns added in v0.2.0 

func (u *UpdateBuilder) WhereNotBetweenColumns(column string, c1 string, c2 string) *UpdateBuilder

WhereNotBetweenColumns is the negated WhereBetweenColumns.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price"

func (*UpdateBuilder) WhereNotExists added in v0.2.0 

func (u *UpdateBuilder) WhereNotExists(sub *SelectBuilder) *UpdateBuilder

WhereNotExists adds "NOT EXISTS (subquery)".

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereNotExists(posts)
// SELECT * FROM "users" WHERE NOT EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*UpdateBuilder) WhereNotIn added in v0.2.0 

func (u *UpdateBuilder) WhereNotIn(column string, values any) *UpdateBuilder

WhereNotIn adds "col NOT IN (...)". An empty list compiles to "1 = 1".

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2)   args: [1 2]

func (*UpdateBuilder) WhereNotLike added in v0.2.0 

func (u *UpdateBuilder) WhereNotLike(column string, value any, caseSensitive ...bool) *UpdateBuilder

WhereNotLike is the negated WhereLike.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%")
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1   args: [%test%]

func (*UpdateBuilder) WhereNotNull added in v0.2.0 

func (u *UpdateBuilder) WhereNotNull(column string) *UpdateBuilder

WhereNotNull adds "col IS NOT NULL".

Example: 

conn.Select().From("users").WhereNotNull("verified_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL

func (*UpdateBuilder) WhereNull added in v0.2.0 

func (u *UpdateBuilder) WhereNull(column string) *UpdateBuilder

WhereNull adds "col IS NULL".

Example: 

conn.Select().From("users").WhereNull("deleted_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL

func (*UpdateBuilder) WhereNullSafeEquals added in v0.2.0 

func (u *UpdateBuilder) WhereNullSafeEquals(column string, value any) *UpdateBuilder

WhereNullSafeEquals compares with NULL-safe equality (<=>, IS NOT DISTINCT FROM, IS).

Example: 

conn.Select().From("users").WhereNullSafeEquals("manager_id", 7)
// Postgres: SELECT * FROM "users" WHERE "manager_id" IS NOT DISTINCT FROM $1   args: [7]
// MySQL: SELECT * FROM `users` WHERE `manager_id` <=> ?   args: [7]

func (*UpdateBuilder) WhereRaw added in v0.2.0 

func (u *UpdateBuilder) WhereRaw(sql string, args ...any) *UpdateBuilder

WhereRaw adds a raw predicate (caller-trusted SQL).

Example: 

conn.Select().From("users").WhereRaw("lower(name) = ?", "ann")
// SELECT * FROM "users" WHERE lower(name) = $1
// args: [ann]

func (*UpdateBuilder) WhereRowValues added in v0.2.0 

func (u *UpdateBuilder) WhereRowValues(columns []string, op string, values []any) *UpdateBuilder

WhereRowValues adds "(a, b) op (?, ?)".

Example: 

conn.Select().From("events").
	WhereRowValues([]string{"created_at", "id"}, ">", []any{"2024-01-15", 42})
// SELECT * FROM "events" WHERE ("created_at", "id") > ($1, $2)   args: [2024-01-15 42]

func (*UpdateBuilder) WhereTime added in v0.2.0 

func (u *UpdateBuilder) WhereTime(column string, args ...any) *UpdateBuilder

WhereTime compares the time part of a column.

Example: 

conn.Select().From("orders").WhereTime("created_at", ">", "10:30:00")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::TIME > $1   args: [10:30:00]
// MySQL: SELECT * FROM `orders` WHERE TIME(`created_at`) > ?   args: [10:30:00]

func (*UpdateBuilder) WhereValueBetween added in v0.2.0 

func (u *UpdateBuilder) WhereValueBetween(value any, c1 string, c2 string) *UpdateBuilder

WhereValueBetween adds "? BETWEEN c1 AND c2" (a value between two columns).

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total"   args: [50]

func (*UpdateBuilder) WhereValueNotBetween added in v0.2.0 

func (u *UpdateBuilder) WhereValueNotBetween(value any, c1 string, c2 string) *UpdateBuilder

WhereValueNotBetween is the negated WhereValueBetween.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total"   args: [50]

func (*UpdateBuilder) WhereYear added in v0.2.0 

func (u *UpdateBuilder) WhereYear(column string, args ...any) *UpdateBuilder

WhereYear compares the year of a column.

Example: 

conn.Select().From("orders").WhereYear("created_at", 2024)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") = $1
//     args: [2024]
// MySQL: SELECT * FROM `orders` WHERE YEAR(`created_at`) = ?   args: [2024]

func (*UpdateBuilder) With added in v0.2.0 

func (u *UpdateBuilder) With(name string, q *SelectBuilder, opts ...CTEOption) *UpdateBuilder

With adds a common table expression: "with name as (q)". The name is a table reference, so the table prefix applies to it as it does to From. The subquery is snapshotted: later changes to q do not affect this query. Options name the columns (CTEColumns) or hint materialization (CTEMaterialized, CTENotMaterialized).

On a select, a CTE can feed the query, a subquery, a union member, Count, Exists and Paginate. On an update or delete it is written before the verb (PostgreSQL, MySQL 8, SQLite; MariaDB returns ErrUnsupported). On an insert it is moved into the SELECT given to Using, so it needs Using.

Example: 

active := conn.Select().From("users").Where("active", true)
conn.Select().From("active_users").With("active_users", active)
// WITH "active_users" AS (SELECT * FROM "users" WHERE "active" = $1) SELECT * FROM
//     "active_users"
// args: [true]

func (*UpdateBuilder) WithRaw added in v0.2.0 

func (u *UpdateBuilder) WithRaw(name string, e Expression, opts ...CTEOption) *UpdateBuilder

WithRaw adds a common table expression whose body is a raw SQL fragment (caller-trusted SQL), e.g. db.Raw("values (?), (?)", 1, 2). It takes the same options as With.

Example: 

conn.Select().From("ids").WithRaw("ids", db.Raw("values (?), (?)", 1, 2), db.CTEColumns("id"))
// WITH "ids" ("id") AS (values ($1), ($2)) SELECT * FROM "ids"
// args: [1 2]

func (*UpdateBuilder) WithRecursive added in v0.2.0 

func (u *UpdateBuilder) WithRecursive(name string, anchor *SelectBuilder, step *SelectBuilder, opts ...CTEOption) *UpdateBuilder

WithRecursive adds a recursive common table expression and switches the clause to "with recursive". anchor is the starting query and step the recursive member that refers to name; they are joined with UNION ALL (CTEUnionDistinct for UNION) and written without parentheses, because SQLite rejects a recursive reference inside a subquery. Neither query is modified, and anchor must not have unions.

Example: 

anchor := conn.Select().From("categories").Where("parent_id", nil)
step := conn.Select().From("categories as c").Join("tree as t", "c.parent_id", "t.id")
conn.Select().From("tree").WithRecursive("tree", anchor, step)
// WITH RECURSIVE "tree" AS (SELECT * FROM "categories" WHERE "parent_id" IS NULL UNION ALL
//     SELECT * FROM "categories" AS "c" INNER JOIN "tree" AS "t" ON "c"."parent_id" =
//     "t"."id") SELECT * FROM "tree"

type WhereClause added in v0.2.0 

type WhereClause struct {
	// contains filtered or unexported fields
}

WhereClause collects the predicates of a parenthesized WHERE group; it only offers the where methods. It is passed to WhereGroup/OrWhereGroup callbacks.

func (*WhereClause) OrWhere added in v0.2.0 

func (w *WhereClause) OrWhere(column string, args ...any) *WhereClause

OrWhere is Where joined with OR.

Example: 

conn.Select().From("users").Where("role", "admin").OrWhere("role", "owner")
// SELECT * FROM "users" WHERE "role" = $1 OR "role" = $2
// args: [admin owner]

func (*WhereClause) OrWhereAll added in v0.2.0 

func (w *WhereClause) OrWhereAll(columns []string, args ...any) *WhereClause

OrWhereAll is WhereAll joined with OR.

Example: 

conn.Select().From("users").WhereAll([]string{"a", "b"}, 1).OrWhereAll([]string{"c", "d"}, ">", 5)
// SELECT * FROM "users" WHERE ("a" = $1 AND "b" = $2) OR ("c" > $3 AND "d" > $4)
//     args: [1 1 5 5]

func (*WhereClause) OrWhereAny added in v0.2.0 

func (w *WhereClause) OrWhereAny(columns []string, args ...any) *WhereClause

OrWhereAny is WhereAny joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereAny([]string{"a", "b"}, ">", 5)
// SELECT * FROM "users" WHERE "active" = $1 OR ("a" > $2 OR "b" > $3)   args: [true 5 5]

func (*WhereClause) OrWhereBetween added in v0.2.0 

func (w *WhereClause) OrWhereBetween(column string, lo any, hi any) *WhereClause

OrWhereBetween is WhereBetween joined with OR.

Example: 

conn.Select().From("orders").Where("status", "paid").OrWhereBetween("total", 500, 900)
// SELECT * FROM "orders" WHERE "status" = $1 OR "total" BETWEEN $2 AND $3
//     args: [paid 500 900]

func (*WhereClause) OrWhereBetweenColumns added in v0.2.0 

func (w *WhereClause) OrWhereBetweenColumns(column string, c1 string, c2 string) *WhereClause

OrWhereBetweenColumns is WhereBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price").
	OrWhereBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price" OR "cost"
//     BETWEEN "low" AND "high"

func (*WhereClause) OrWhereColumn added in v0.2.0 

func (w *WhereClause) OrWhereColumn(first string, args ...any) *WhereClause

OrWhereColumn is WhereColumn joined with OR.

Example: 

conn.Select().From("users").WhereColumn("first_name", "last_name").OrWhereColumn("a", "<>", "b")
// SELECT * FROM "users" WHERE "first_name" = "last_name" OR "a" <> "b"

func (*WhereClause) OrWhereDate added in v0.2.0 

func (w *WhereClause) OrWhereDate(column string, args ...any) *WhereClause

OrWhereDate is WhereDate joined with OR.

Example: 

conn.Select().From("orders").WhereDate("created_at", "2024-01-15").
	OrWhereDate("created_at", "2024-02-01")
// SELECT * FROM "orders" WHERE "created_at"::DATE = $1 OR "created_at"::DATE = $2
//     args: [2024-01-15 2024-02-01]

func (*WhereClause) OrWhereDay added in v0.2.0 

func (w *WhereClause) OrWhereDay(column string, args ...any) *WhereClause

OrWhereDay is WhereDay joined with OR.

Example: 

conn.Select().From("orders").WhereDay("created_at", 15).OrWhereDay("created_at", ">", 20)
// SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1 OR EXTRACT(DAY FROM
//     "created_at") > $2
//     args: [15 20]

func (*WhereClause) OrWhereExists added in v0.2.0 

func (w *WhereClause) OrWhereExists(sub *SelectBuilder) *WhereClause

OrWhereExists is WhereExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*WhereClause) OrWhereGroup added in v0.2.0 

func (w *WhereClause) OrWhereGroup(fn func(*WhereClause)) *WhereClause

OrWhereGroup is WhereGroup joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").Where("age", ">", 30)
})
// SELECT * FROM "users" WHERE "active" = $1 OR ("role" = $2 AND "age" > $3)
//     args: [true admin 30]

func (*WhereClause) OrWhereIn added in v0.2.0 

func (w *WhereClause) OrWhereIn(column string, values any) *WhereClause

OrWhereIn is WhereIn joined with OR.

Example: 

conn.Select().From("users").WhereIn("role", []string{"ann", "bob"}).OrWhereIn("id", []int{9})
// SELECT * FROM "users" WHERE "role" IN ($1, $2) OR "id" IN ($3)   args: [ann bob 9]

func (*WhereClause) OrWhereIntegerInRaw added in v0.2.0 

func (w *WhereClause) OrWhereIntegerInRaw(column string, values any) *WhereClause

OrWhereIntegerInRaw is WhereIntegerInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1}).
	OrWhereIntegerInRaw("id", []int64{7, 8})
// SELECT * FROM "users" WHERE "id" IN (1) OR "id" IN (7, 8)

func (*WhereClause) OrWhereIntegerNotInRaw added in v0.2.0 

func (w *WhereClause) OrWhereIntegerNotInRaw(column string, values any) *WhereClause

OrWhereIntegerNotInRaw is WhereIntegerNotInRaw joined with OR.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2}).
	OrWhereIntegerNotInRaw("id", []int{3})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2) OR "id" NOT IN (3)

func (*WhereClause) OrWhereJsonContains added in v0.2.0 

func (w *WhereClause) OrWhereJsonContains(column string, value any) *WhereClause

OrWhereJsonContains is WhereJsonContains joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR ("options"->'tags')::JSONB @> $2
// args: [true "go"]

func (*WhereClause) OrWhereJsonContainsKey added in v0.2.0 

func (w *WhereClause) OrWhereJsonContainsKey(column string) *WhereClause

OrWhereJsonContainsKey is WhereJsonContainsKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*WhereClause) OrWhereJsonDoesntContain added in v0.2.0 

func (w *WhereClause) OrWhereJsonDoesntContain(column string, value any) *WhereClause

OrWhereJsonDoesntContain is WhereJsonDoesntContain joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("options"->'tags')::JSONB @> $2
// args: [true "php"]

func (*WhereClause) OrWhereJsonDoesntContainKey added in v0.2.0 

func (w *WhereClause) OrWhereJsonDoesntContainKey(column string) *WhereClause

OrWhereJsonDoesntContainKey is WhereJsonDoesntContainKey joined with OR.

Example: 

conn.Select().From("users").Where("active", true).
	OrWhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE "active" = $1
//   OR NOT COALESCE(("options")::JSONB ? 'theme', FALSE)
// args: [true]

func (*WhereClause) OrWhereJsonDoesntOverlap added in v0.2.0 

func (w *WhereClause) OrWhereJsonDoesntOverlap(column string, value any) *WhereClause

OrWhereJsonDoesntOverlap is WhereJsonDoesntOverlap joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["php"]]

func (*WhereClause) OrWhereJsonLength added in v0.2.0 

func (w *WhereClause) OrWhereJsonLength(column string, args ...any) *WhereClause

OrWhereJsonLength is WhereJsonLength joined with OR.

Example: 

conn.Select().From("users").WhereJsonLength("options->tags", 0)
.OrWhereJsonLength("options->roles", ">=", 3).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   OR JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) >= $2   args: [0 3]

func (*WhereClause) OrWhereJsonOverlaps added in v0.2.0 

func (w *WhereClause) OrWhereJsonOverlaps(column string, value any) *WhereClause

OrWhereJsonOverlaps is WhereJsonOverlaps joined with OR.

Example: 

conn.Select().From("users").Where("active", true)
.OrWhereJsonOverlaps("options->tags", []string{"go"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE `active` = ?
//   OR JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [true ["go"]]

func (*WhereClause) OrWhereLike added in v0.2.0 

func (w *WhereClause) OrWhereLike(column string, value any, caseSensitive ...bool) *WhereClause

OrWhereLike is WhereLike joined with OR.

Example: 

conn.Select().From("users").WhereLike("name", "an%").OrWhereLike("name", "bo%")
// SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1 OR "name"::TEXT ILIKE $2
//     args: [an% bo%]

func (*WhereClause) OrWhereMap added in v0.2.0 

func (w *WhereClause) OrWhereMap(m map[string]any) *WhereClause

OrWhereMap is WhereMap joined with OR.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"a": 1}).OrWhereMap(map[string]any{"b": 2})
// SELECT * FROM "users" WHERE ("a" = $1) OR ("b" = $2)   args: [1 2]

func (*WhereClause) OrWhereMonth added in v0.2.0 

func (w *WhereClause) OrWhereMonth(column string, args ...any) *WhereClause

OrWhereMonth is WhereMonth joined with OR.

Example: 

conn.Select().From("orders").WhereMonth("created_at", ">=", 6).OrWhereMonth("created_at", 1)
// SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") >= $1 OR EXTRACT(MONTH FROM
//     "created_at") = $2
//     args: [06 01]

func (*WhereClause) OrWhereNone added in v0.2.0 

func (w *WhereClause) OrWhereNone(columns []string, args ...any) *WhereClause

OrWhereNone is WhereNone joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereNone([]string{"a", "b"}, 0)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT ("a" = $2 OR "b" = $3)
//     args: [true 0 0]

func (*WhereClause) OrWhereNot added in v0.2.0 

func (w *WhereClause) OrWhereNot(column string, args ...any) *WhereClause

OrWhereNot adds "OR NOT <predicate>".

Example: 

conn.Select().From("users").Where("age", ">", 18).OrWhereNot("status", "<", 3)
// SELECT * FROM "users" WHERE "age" > $1 OR NOT "status" < $2   args: [18 3]

func (*WhereClause) OrWhereNotBetween added in v0.2.0 

func (w *WhereClause) OrWhereNotBetween(column string, lo any, hi any) *WhereClause

OrWhereNotBetween is WhereNotBetween joined with OR.

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100).OrWhereNotBetween("qty", 1, 5)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2 OR "qty" NOT BETWEEN $3 AND $4
//     args: [10 100 1 5]

func (*WhereClause) OrWhereNotBetweenColumns added in v0.2.0 

func (w *WhereClause) OrWhereNotBetweenColumns(column string, c1 string, c2 string) *WhereClause

OrWhereNotBetweenColumns is WhereNotBetweenColumns joined with OR.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price").
	OrWhereNotBetweenColumns("cost", "low", "high")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price" OR "cost"
//     NOT BETWEEN "low" AND "high"

func (*WhereClause) OrWhereNotExists added in v0.2.0 

func (w *WhereClause) OrWhereNotExists(sub *SelectBuilder) *WhereClause

OrWhereNotExists is WhereNotExists joined with OR.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").Where("active", true).OrWhereNotExists(posts)
// SELECT * FROM "users" WHERE "active" = $1 OR NOT EXISTS (SELECT "1" FROM "posts" WHERE
//     "posts"."user_id" = "users"."id")
//     args: [true]

func (*WhereClause) OrWhereNotIn added in v0.2.0 

func (w *WhereClause) OrWhereNotIn(column string, values any) *WhereClause

OrWhereNotIn is WhereNotIn joined with OR.

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2}).OrWhereNotIn("role", []string{"ann"})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2) OR "role" NOT IN ($3)   args: [1 2 ann]

func (*WhereClause) OrWhereNotLike added in v0.2.0 

func (w *WhereClause) OrWhereNotLike(column string, value any, caseSensitive ...bool) *WhereClause

OrWhereNotLike is WhereNotLike joined with OR.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%").OrWhereNotLike("name", "%demo%", true)
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1 OR "name"::TEXT NOT LIKE $2
//     args: [%test% %demo%]

func (*WhereClause) OrWhereNotNull added in v0.2.0 

func (w *WhereClause) OrWhereNotNull(column string) *WhereClause

OrWhereNotNull is WhereNotNull joined with OR.

Example: 

conn.Select().From("users").WhereNotNull("verified_at").OrWhereNotNull("invited_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL OR "invited_at" IS NOT NULL

func (*WhereClause) OrWhereNull added in v0.2.0 

func (w *WhereClause) OrWhereNull(column string) *WhereClause

OrWhereNull is WhereNull joined with OR.

Example: 

conn.Select().From("users").WhereNull("deleted_at").OrWhereNull("banned_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL OR "banned_at" IS NULL

func (*WhereClause) OrWhereNullSafeEquals added in v0.2.0 

func (w *WhereClause) OrWhereNullSafeEquals(column string, value any) *WhereClause

OrWhereNullSafeEquals is WhereNullSafeEquals joined with OR.

Example: 

conn.Select().From("users").WhereNullSafeEquals("a", 1).OrWhereNullSafeEquals("b", 2)
// SELECT * FROM "users" WHERE "a" IS NOT DISTINCT FROM $1 OR "b" IS NOT DISTINCT FROM $2
//     args: [1 2]

func (*WhereClause) OrWhereRaw added in v0.2.0 

func (w *WhereClause) OrWhereRaw(sql string, args ...any) *WhereClause

OrWhereRaw is WhereRaw joined with OR.

Example: 

conn.Select().From("users").Where("active", true).OrWhereRaw("age between ? and ?", 18, 30)
// SELECT * FROM "users" WHERE "active" = $1 OR age between $2 and $3
// args: [true 18 30]

func (*WhereClause) OrWhereRowValues added in v0.2.0 

func (w *WhereClause) OrWhereRowValues(columns []string, op string, values []any) *WhereClause

OrWhereRowValues is WhereRowValues joined with OR.

Example: 

conn.Select().From("events").Where("kind", "x").
	OrWhereRowValues([]string{"a", "b"}, "=", []any{1, 2})
// SELECT * FROM "events" WHERE "kind" = $1 OR ("a", "b") = ($2, $3)   args: [x 1 2]

func (*WhereClause) OrWhereTime added in v0.2.0 

func (w *WhereClause) OrWhereTime(column string, args ...any) *WhereClause

OrWhereTime is WhereTime joined with OR.

Example: 

conn.Select().From("orders").WhereTime("created_at", "10:30:00").
	OrWhereTime("created_at", "<", "08:00:00")
// SELECT * FROM "orders" WHERE "created_at"::TIME = $1 OR "created_at"::TIME < $2
//     args: [10:30:00 08:00:00]

func (*WhereClause) OrWhereValueBetween added in v0.2.0 

func (w *WhereClause) OrWhereValueBetween(value any, c1 string, c2 string) *WhereClause

OrWhereValueBetween is WhereValueBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total").
	OrWhereValueBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total" OR $2 BETWEEN "a" AND
//     "b"
//     args: [50 7]

func (*WhereClause) OrWhereValueNotBetween added in v0.2.0 

func (w *WhereClause) OrWhereValueNotBetween(value any, c1 string, c2 string) *WhereClause

OrWhereValueNotBetween is WhereValueNotBetween joined with OR.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total").
	OrWhereValueNotBetween(7, "a", "b")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total" OR $2 NOT BETWEEN
//     "a" AND "b"
//     args: [50 7]

func (*WhereClause) OrWhereYear added in v0.2.0 

func (w *WhereClause) OrWhereYear(column string, args ...any) *WhereClause

OrWhereYear is WhereYear joined with OR.

Example: 

conn.Select().From("orders").WhereYear("created_at", ">", 2020).OrWhereYear("created_at", 1999)
// SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") > $1 OR EXTRACT(YEAR FROM
//     "created_at") = $2
//     args: [2020 1999]

func (*WhereClause) Where added in v0.2.0 

func (w *WhereClause) Where(column string, args ...any) *WhereClause

Where adds an AND predicate. Forms: Where(col, value) means "="; Where(col, op, value). A nil value with "=" / "!=" / "<>" becomes IS [NOT] NULL.

Example: 

conn.Select().From("users").Where("active", true).Where("age", ">=", 18)
// SELECT * FROM "users" WHERE "active" = $1 AND "age" >= $2
// args: [true 18]

func (*WhereClause) WhereAll added in v0.2.0 

func (w *WhereClause) WhereAll(columns []string, args ...any) *WhereClause

WhereAll requires the predicate to hold for every column: (a = ? and b = ?).

Example: 

conn.Select().From("users").WhereAll([]string{"first_name", "last_name"}, "like", "an%")
// SELECT * FROM "users" WHERE ("first_name"::TEXT LIKE $1 AND "last_name"::TEXT LIKE $2)
//     args: [an% an%]

func (*WhereClause) WhereAny added in v0.2.0 

func (w *WhereClause) WhereAny(columns []string, args ...any) *WhereClause

WhereAny requires the predicate to hold for at least one column: (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereAny([]string{"first_name", "last_name"}, "ann")
// SELECT * FROM "users" WHERE ("first_name" = $1 OR "last_name" = $2)   args: [ann ann]

func (*WhereClause) WhereBetween added in v0.2.0 

func (w *WhereClause) WhereBetween(column string, lo any, hi any) *WhereClause

WhereBetween adds "col BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" BETWEEN $1 AND $2   args: [10 100]

func (*WhereClause) WhereBetweenColumns added in v0.2.0 

func (w *WhereClause) WhereBetweenColumns(column string, c1 string, c2 string) *WhereClause

WhereBetweenColumns adds "col BETWEEN c1 AND c2" comparing against columns.

Example: 

conn.Select().From("products").WhereBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" BETWEEN "min_price" AND "max_price"

func (*WhereClause) WhereColumn added in v0.2.0 

func (w *WhereClause) WhereColumn(first string, args ...any) *WhereClause

WhereColumn compares two columns: WhereColumn(a, b) means "=", or WhereColumn(a, op, b).

Example: 

conn.Select().From("users").WhereColumn("updated_at", ">", "created_at")
// SELECT * FROM "users" WHERE "updated_at" > "created_at"

func (*WhereClause) WhereDate added in v0.2.0 

func (w *WhereClause) WhereDate(column string, args ...any) *WhereClause

WhereDate compares the date part of a column.

Example: 

conn.Select().From("orders").WhereDate("created_at", ">=", "2024-01-15")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::DATE >= $1   args: [2024-01-15]
// MySQL: SELECT * FROM `orders` WHERE DATE(`created_at`) >= ?   args: [2024-01-15]
// SQLite: SELECT * FROM "orders" WHERE STRFTIME('%Y-%m-%d', "created_at") >= CAST(? AS TEXT)
//     args: [2024-01-15]

func (*WhereClause) WhereDay added in v0.2.0 

func (w *WhereClause) WhereDay(column string, args ...any) *WhereClause

WhereDay compares the day-of-month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereDay("created_at", 15)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(DAY FROM "created_at") = $1   args: [15]
// MySQL: SELECT * FROM `orders` WHERE DAY(`created_at`) = ?   args: [15]

func (*WhereClause) WhereExists added in v0.2.0 

func (w *WhereClause) WhereExists(sub *SelectBuilder) *WhereClause

WhereExists adds "EXISTS (subquery)". Build sub with DB.Select.

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereExists(posts)
// SELECT * FROM "users" WHERE EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*WhereClause) WhereGroup added in v0.2.0 

func (w *WhereClause) WhereGroup(fn func(*WhereClause)) *WhereClause

WhereGroup wraps the predicates added inside fn in parentheses. fn receives a fresh WhereClause; only its Where* calls are used.

Example: 

conn.Select().From("users").Where("active", true).WhereGroup(func(q *db.WhereClause) {
	q.Where("role", "admin").OrWhere("role", "editor")
})
// SELECT * FROM "users" WHERE "active" = $1 AND ("role" = $2 OR "role" = $3)
//     args: [true admin editor]

func (*WhereClause) WhereIn added in v0.2.0 

func (w *WhereClause) WhereIn(column string, values any) *WhereClause

WhereIn adds "col IN (...)". values may be any slice, a scalar, or a *SelectBuilder subquery. An empty list compiles to the always-false "0 = 1".

Example: 

conn.Select().From("users").WhereIn("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN ($1, $2, $3)   args: [1 2 3]

func (*WhereClause) WhereIntegerInRaw added in v0.2.0 

func (w *WhereClause) WhereIntegerInRaw(column string, values any) *WhereClause

WhereIntegerInRaw inlines integers (no bind args); non-integers record an error. Useful for very large ID lists that would exceed driver parameter limits.

Example: 

conn.Select().From("users").WhereIntegerInRaw("id", []int{1, 2, 3})
// SELECT * FROM "users" WHERE "id" IN (1, 2, 3)

func (*WhereClause) WhereIntegerNotInRaw added in v0.2.0 

func (w *WhereClause) WhereIntegerNotInRaw(column string, values any) *WhereClause

WhereIntegerNotInRaw is the negated WhereIntegerInRaw.

Example: 

conn.Select().From("users").WhereIntegerNotInRaw("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN (1, 2)

func (*WhereClause) WhereJsonContains added in v0.2.0 

func (w *WhereClause) WhereJsonContains(column string, value any) *WhereClause

WhereJsonContains adds a JSON containment test on a column or "col->path". MySQL json_contains, Postgres @> (jsonb), SQLite json_each membership.

Example: 

conn.Select().From("users").WhereJsonContains("options->tags", "go").ToSQL()
// SELECT * FROM "users" WHERE ("options"->'tags')::JSONB @> $1   args: ["go"]

func (*WhereClause) WhereJsonContainsKey added in v0.2.0 

func (w *WhereClause) WhereJsonContainsKey(column string) *WhereClause

WhereJsonContainsKey tests that the JSON path "col->key" exists.

Example: 

conn.Select().From("users").WhereJsonContainsKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []
// MySQL: SELECT * FROM `users`
//   WHERE IFNULL(JSON_CONTAINS_PATH(`options`, 'one', '$."theme"'), 0)

func (*WhereClause) WhereJsonDoesntContain added in v0.2.0 

func (w *WhereClause) WhereJsonDoesntContain(column string, value any) *WhereClause

WhereJsonDoesntContain negates WhereJsonContains.

Example: 

conn.Select().From("users").WhereJsonDoesntContain("options->tags", "php").ToSQL()
// SELECT * FROM "users" WHERE NOT ("options"->'tags')::JSONB @> $1   args: ["php"]

func (*WhereClause) WhereJsonDoesntContainKey added in v0.2.0 

func (w *WhereClause) WhereJsonDoesntContainKey(column string) *WhereClause

WhereJsonDoesntContainKey negates WhereJsonContainsKey.

Example: 

conn.Select().From("users").WhereJsonDoesntContainKey("options->theme").ToSQL()
// SELECT * FROM "users" WHERE NOT COALESCE(("options")::JSONB ? 'theme', FALSE)   args: []

func (*WhereClause) WhereJsonDoesntOverlap added in v0.2.0 

func (w *WhereClause) WhereJsonDoesntOverlap(column string, value any) *WhereClause

WhereJsonDoesntOverlap negates WhereJsonOverlaps.

Example: 

conn.Select().From("users")
.WhereJsonDoesntOverlap("options->tags", []string{"php"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE NOT JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["php"]]

func (*WhereClause) WhereJsonLength added in v0.2.0 

func (w *WhereClause) WhereJsonLength(column string, args ...any) *WhereClause

WhereJsonLength compares the length of a JSON array: (value) or (operator, value).

Example: 

conn.Select().From("users")
.WhereJsonLength("options->tags", 2).WhereJsonLength("options->roles", ">", 1).ToSQL()
// SELECT * FROM "users" WHERE JSONB_ARRAY_LENGTH(("options"->'tags')::JSONB) = $1
//   AND JSONB_ARRAY_LENGTH(("options"->'roles')::JSONB) > $2   args: [2 1]

func (*WhereClause) WhereJsonOverlaps added in v0.2.0 

func (w *WhereClause) WhereJsonOverlaps(column string, value any) *WhereClause

WhereJsonOverlaps adds json_overlaps (MySQL only; other dialects error at compile time).

Example: 

conn.Select().From("users")
.WhereJsonOverlaps("options->tags", []string{"go", "sql"}).ToSQL() // MySQL conn
// SELECT * FROM `users` WHERE JSON_OVERLAPS(JSON_EXTRACT(`options`, '$."tags"'), ?)
// args: [["go","sql"]]

func (*WhereClause) WhereLike added in v0.2.0 

func (w *WhereClause) WhereLike(column string, value any, caseSensitive ...bool) *WhereClause

WhereLike adds a LIKE predicate, case-insensitive unless caseSensitive[0] is true. Postgres: ILIKE/LIKE. MySQL: LIKE/LIKE BINARY. SQLite: LIKE/GLOB (pattern converted).

Example: 

conn.Select().From("users").WhereLike("name", "An%")
// Postgres: SELECT * FROM "users" WHERE "name"::TEXT ILIKE $1   args: [An%]
// MySQL: SELECT * FROM `users` WHERE `name` LIKE ?   args: [An%]
// SQLite: SELECT * FROM "users" WHERE "name" LIKE ?   args: [An%]

func (*WhereClause) WhereMap added in v0.2.0 

func (w *WhereClause) WhereMap(m map[string]any) *WhereClause

WhereMap adds one grouped "a = ? and b = ?" predicate; keys are sorted for stable SQL.

Example: 

conn.Select().From("users").WhereMap(map[string]any{"role": "ann", "active": true})
// SELECT * FROM "users" WHERE ("active" = $1 AND "role" = $2)   args: [true ann]

func (*WhereClause) WhereMonth added in v0.2.0 

func (w *WhereClause) WhereMonth(column string, args ...any) *WhereClause

WhereMonth compares the month of a column (numeric values are zero-padded).

Example: 

conn.Select().From("orders").WhereMonth("created_at", 3)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(MONTH FROM "created_at") = $1   args: [03]
// MySQL: SELECT * FROM `orders` WHERE MONTH(`created_at`) = ?   args: [03]

func (*WhereClause) WhereNone added in v0.2.0 

func (w *WhereClause) WhereNone(columns []string, args ...any) *WhereClause

WhereNone requires the predicate to hold for no column: not (a = ? or b = ?).

Example: 

conn.Select().From("users").WhereNone([]string{"first_name", "last_name"}, "like", "%test%")
// SELECT * FROM "users" WHERE NOT ("first_name"::TEXT LIKE $1 OR "last_name"::TEXT LIKE $2)
//     args: [%test% %test%]

func (*WhereClause) WhereNot added in v0.2.0 

func (w *WhereClause) WhereNot(column string, args ...any) *WhereClause

WhereNot adds "AND NOT <predicate>".

Example: 

conn.Select().From("users").WhereNot("role", "admin")
// SELECT * FROM "users" WHERE NOT "role" = $1   args: [admin]

func (*WhereClause) WhereNotBetween added in v0.2.0 

func (w *WhereClause) WhereNotBetween(column string, lo any, hi any) *WhereClause

WhereNotBetween adds "col NOT BETWEEN lo AND hi".

Example: 

conn.Select().From("orders").WhereNotBetween("total", 10, 100)
// SELECT * FROM "orders" WHERE "total" NOT BETWEEN $1 AND $2   args: [10 100]

func (*WhereClause) WhereNotBetweenColumns added in v0.2.0 

func (w *WhereClause) WhereNotBetweenColumns(column string, c1 string, c2 string) *WhereClause

WhereNotBetweenColumns is the negated WhereBetweenColumns.

Example: 

conn.Select().From("products").WhereNotBetweenColumns("price", "min_price", "max_price")
// SELECT * FROM "products" WHERE "price" NOT BETWEEN "min_price" AND "max_price"

func (*WhereClause) WhereNotExists added in v0.2.0 

func (w *WhereClause) WhereNotExists(sub *SelectBuilder) *WhereClause

WhereNotExists adds "NOT EXISTS (subquery)".

Example: 

posts := conn.Select().From("posts").Select("1").WhereColumn("posts.user_id", "users.id")
conn.Select().From("users").WhereNotExists(posts)
// SELECT * FROM "users" WHERE NOT EXISTS (SELECT "1" FROM "posts" WHERE "posts"."user_id" =
//     "users"."id")

func (*WhereClause) WhereNotIn added in v0.2.0 

func (w *WhereClause) WhereNotIn(column string, values any) *WhereClause

WhereNotIn adds "col NOT IN (...)". An empty list compiles to "1 = 1".

Example: 

conn.Select().From("users").WhereNotIn("id", []int{1, 2})
// SELECT * FROM "users" WHERE "id" NOT IN ($1, $2)   args: [1 2]

func (*WhereClause) WhereNotLike added in v0.2.0 

func (w *WhereClause) WhereNotLike(column string, value any, caseSensitive ...bool) *WhereClause

WhereNotLike is the negated WhereLike.

Example: 

conn.Select().From("users").WhereNotLike("name", "%test%")
// SELECT * FROM "users" WHERE "name"::TEXT NOT ILIKE $1   args: [%test%]

func (*WhereClause) WhereNotNull added in v0.2.0 

func (w *WhereClause) WhereNotNull(column string) *WhereClause

WhereNotNull adds "col IS NOT NULL".

Example: 

conn.Select().From("users").WhereNotNull("verified_at")
// SELECT * FROM "users" WHERE "verified_at" IS NOT NULL

func (*WhereClause) WhereNull added in v0.2.0 

func (w *WhereClause) WhereNull(column string) *WhereClause

WhereNull adds "col IS NULL".

Example: 

conn.Select().From("users").WhereNull("deleted_at")
// SELECT * FROM "users" WHERE "deleted_at" IS NULL

func (*WhereClause) WhereNullSafeEquals added in v0.2.0 

func (w *WhereClause) WhereNullSafeEquals(column string, value any) *WhereClause

WhereNullSafeEquals compares with NULL-safe equality (<=>, IS NOT DISTINCT FROM, IS).

Example: 

conn.Select().From("users").WhereNullSafeEquals("manager_id", 7)
// Postgres: SELECT * FROM "users" WHERE "manager_id" IS NOT DISTINCT FROM $1   args: [7]
// MySQL: SELECT * FROM `users` WHERE `manager_id` <=> ?   args: [7]

func (*WhereClause) WhereRaw added in v0.2.0 

func (w *WhereClause) WhereRaw(sql string, args ...any) *WhereClause

WhereRaw adds a raw predicate (caller-trusted SQL).

Example: 

conn.Select().From("users").WhereRaw("lower(name) = ?", "ann")
// SELECT * FROM "users" WHERE lower(name) = $1
// args: [ann]

func (*WhereClause) WhereRowValues added in v0.2.0 

func (w *WhereClause) WhereRowValues(columns []string, op string, values []any) *WhereClause

WhereRowValues adds "(a, b) op (?, ?)".

Example: 

conn.Select().From("events").
	WhereRowValues([]string{"created_at", "id"}, ">", []any{"2024-01-15", 42})
// SELECT * FROM "events" WHERE ("created_at", "id") > ($1, $2)   args: [2024-01-15 42]

func (*WhereClause) WhereTime added in v0.2.0 

func (w *WhereClause) WhereTime(column string, args ...any) *WhereClause

WhereTime compares the time part of a column.

Example: 

conn.Select().From("orders").WhereTime("created_at", ">", "10:30:00")
// Postgres: SELECT * FROM "orders" WHERE "created_at"::TIME > $1   args: [10:30:00]
// MySQL: SELECT * FROM `orders` WHERE TIME(`created_at`) > ?   args: [10:30:00]

func (*WhereClause) WhereValueBetween added in v0.2.0 

func (w *WhereClause) WhereValueBetween(value any, c1 string, c2 string) *WhereClause

WhereValueBetween adds "? BETWEEN c1 AND c2" (a value between two columns).

Example: 

conn.Select().From("coupons").WhereValueBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 BETWEEN "min_total" AND "max_total"   args: [50]

func (*WhereClause) WhereValueNotBetween added in v0.2.0 

func (w *WhereClause) WhereValueNotBetween(value any, c1 string, c2 string) *WhereClause

WhereValueNotBetween is the negated WhereValueBetween.

Example: 

conn.Select().From("coupons").WhereValueNotBetween(50, "min_total", "max_total")
// SELECT * FROM "coupons" WHERE $1 NOT BETWEEN "min_total" AND "max_total"   args: [50]

func (*WhereClause) WhereYear added in v0.2.0 

func (w *WhereClause) WhereYear(column string, args ...any) *WhereClause

WhereYear compares the year of a column.

Example: 

conn.Select().From("orders").WhereYear("created_at", 2024)
// Postgres: SELECT * FROM "orders" WHERE EXTRACT(YEAR FROM "created_at") = $1
//     args: [2024]
// MySQL: SELECT * FROM `orders` WHERE YEAR(`created_at`) = ?   args: [2024]

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.