keel

package module

Go to main page

Versions in this module

v0

v0.10.0

Nov 6, 2026

Changes in this version

+ func AllPtrs(ctx context.Context, db *DB, q *QueryCore) ([]unsafe.Pointer, error)

+ func CopyPtrs(ctx context.Context, db *DB, t *TableBase, rows []unsafe.Pointer) (int64, error)

+ func CreateManyPtrs(ctx context.Context, db *DB, t *TableBase, rows []unsafe.Pointer) error

+ func CreateOrSkipPtrs(ctx context.Context, db *DB, t *TableBase, rows []unsafe.Pointer, ...) (int64, error)

+ func CreatePtr(ctx context.Context, db *DB, t *TableBase, row unsafe.Pointer) error

+ func DeleteRowPtr(ctx context.Context, db *DB, t *TableBase, row unsafe.Pointer) error

+ func EachPtrs(ctx context.Context, db *DB, q *QueryCore, size int, ...) error

+ func FirstPtr(ctx context.Context, db *DB, q *QueryCore) (unsafe.Pointer, error)

+ func ListPtrs(ctx context.Context, db *DB, q *QueryCore) ([]unsafe.Pointer, error)

+ func OnePtr(ctx context.Context, db *DB, q *QueryCore) (unsafe.Pointer, error)

+ func SaveExceptPtr(ctx context.Context, db *DB, t *TableBase, row unsafe.Pointer, cols ...Column) error

+ func SavePtr(ctx context.Context, db *DB, t *TableBase, row unsafe.Pointer, cols ...Column) error

+ func UpdateReturningPtrs(ctx context.Context, db *DB, q *QueryCore, sets ...Assignment) ([]unsafe.Pointer, error)

+ func UpsertPtrs(ctx context.Context, db *DB, t *TableBase, rows []unsafe.Pointer, c Conflict) ([]bool, error)

type Page

+ func PagePtrs(ctx context.Context, db *DB, q *QueryCore, p PageRequest) (Page[unsafe.Pointer], error)

+ type TypedStringCol struct

+ func (c TypedStringCol) Text() StringCol

v0.9.0

Nov 4, 2026

v0.8.0

Nov 4, 2026

v0.7.0

Nov 4, 2026

Changes in this version

+ func InlineSQL(e Expr, table *schema.Table, alias string) (string, []int32, error)

v0.6.3

Nov 2, 2026

Changes in this version

type QueryEvent

+ CustomPlan bool

type Shape

+ CustomPlan bool

v0.6.2

Nov 2, 2026

v0.6.1

Nov 2, 2026

Changes in this version

+ func Pool(db *DB) *pgxpool.Pool

type DB

+ func (db *DB) Stat() *pgxpool.Stat

v0.6.0

Nov 2, 2026

retracted

v0.5.0

Nov 2, 2026

Changes in this version

+ func All[T any](ctx context.Context, db *DB, q *QueryCore) ([]T, error)

+ func Copy[T any](ctx context.Context, db *DB, t *TableBase, rows []T) (int64, error)

+ func CreateMany[T any](ctx context.Context, db *DB, t *TableBase, rows []T) error

+ func CreateOrSkip[T any](ctx context.Context, db *DB, t *TableBase, rows []T, targets ...Expr) (int64, error)

+ func Create[T any](ctx context.Context, db *DB, t *TableBase, row T) error

+ func CursorAt[T any](p Page[T], i int) string

+ func DeleteRow[T any](ctx context.Context, db *DB, t *TableBase, row T) error

+ func Each[T any](ctx context.Context, db *DB, q *QueryCore, size int, ...) error

+ func First[T any](ctx context.Context, db *DB, q *QueryCore) (T, error)

+ func List[T any](ctx context.Context, db *DB, q *QueryCore) ([]T, error)

+ func One[T any](ctx context.Context, db *DB, q *QueryCore) (T, error)

+ func SaveExcept[T any](ctx context.Context, db *DB, t *TableBase, row T, cols ...Column) error

+ func Save[T any](ctx context.Context, db *DB, t *TableBase, row T, cols ...Column) error

+ func UpdateReturning[T any](ctx context.Context, db *DB, q *QueryCore, sets ...Assignment) ([]T, error)

+ func Upsert[T any](ctx context.Context, db *DB, t *TableBase, rows []T, c Conflict) ([]bool, error)

+ type LateralSource = interface

+ TableRef func() *Ref

type Page

+ func PageOf[T any](ctx context.Context, db *DB, q *QueryCore, p PageRequest) (Page[T], error)

type Query

+ func QueryOf[T any](ref *Ref) Query[T]

+ func RowsOf(ref *Ref) Query[*Row]

+ type QueryCore struct

+ func NewQueryCore(ref *Ref) QueryCore

+ func (q *QueryCore) AllTenants() *QueryCore

+ func (q *QueryCore) Any(ps ...Pred) Pred

+ func (q *QueryCore) Cache(opts ...CacheOption) *QueryCore

+ func (q *QueryCore) Clone() *QueryCore

+ func (q *QueryCore) Compute(col Column, e Expr) *QueryCore

+ func (q *QueryCore) Count(ctx context.Context, db *DB) (int64, error)

+ func (q *QueryCore) CountEstimate(ctx context.Context, db *DB, exactUpTo int64) (RowCount, error)

+ func (q *QueryCore) CountUpTo(ctx context.Context, db *DB, limit int64) (int64, error)

+ func (q *QueryCore) Cube(es ...Expr) *QueryCore

+ func (q *QueryCore) CustomPlan() *QueryCore

+ func (q *QueryCore) Delete(ctx context.Context, db *DB) (int64, error)

+ func (q *QueryCore) Distinct() *QueryCore

+ func (q *QueryCore) DistinctOn(es ...Expr) *QueryCore

+ func (q *QueryCore) Exists(ctx context.Context, db *DB) (bool, error)

+ func (q *QueryCore) Explain(ctx context.Context, db *DB, opts ExplainOptions) (*Plan, error)

+ func (q *QueryCore) Group(es ...Expr) *QueryCore

+ func (q *QueryCore) GroupingSets(sets ...[]Expr) *QueryCore

+ func (q *QueryCore) Having(ps ...Pred) *QueryCore

+ func (q *QueryCore) Join(t interface{ ... }, on ...Pred) *QueryCore

+ func (q *QueryCore) JoinLateral(sub LateralSource) *QueryCore

+ func (q *QueryCore) LeftJoin(t interface{ ... }, on ...Pred) *QueryCore

+ func (q *QueryCore) LeftJoinLateral(sub LateralSource) *QueryCore

+ func (q *QueryCore) Limit(n int) *QueryCore

+ func (q *QueryCore) Load(ls ...Loader) *QueryCore

+ func (q *QueryCore) LoadStrategy(s LoadStrategy) *QueryCore

+ func (q *QueryCore) Lock(strength LockStrength, wait ...LockWait) *QueryCore

+ func (q *QueryCore) None(ps ...Pred) Pred

+ func (q *QueryCore) Offset(n int) *QueryCore

+ func (q *QueryCore) Omit(cols ...Column) *QueryCore

+ func (q *QueryCore) Order(os ...Order) *QueryCore

+ func (q *QueryCore) Pick(es ...Expr) *QueryCore

+ func (q *QueryCore) Rollup(es ...Expr) *QueryCore

+ func (q *QueryCore) TableRef() *Ref

+ func (q *QueryCore) Timeout(d time.Duration) *QueryCore

+ func (q *QueryCore) ToSQL(ctx context.Context, db *DB) (string, []any, error)

+ func (q *QueryCore) Update(ctx context.Context, db *DB, sets ...Assignment) (int64, error)

+ func (q *QueryCore) Where(ps ...Pred) *QueryCore

+ func (q *QueryCore) Window(name string, w Window) *QueryCore

+ func (q *QueryCore) With(ctes ...*CTETable) *QueryCore

+ type TableBase struct

+ Ref *Ref

+ func (t TableBase) Any(ps ...Pred) Pred

+ func (t TableBase) InsertFrom(ctx context.Context, db *DB, src subquery, cols ...Column) (int64, error)

+ func (t TableBase) InsertFromSQL(ctx context.Context, db *DB, src subquery, cols ...Column) (string, []any, error)

+ func (t TableBase) None(ps ...Pred) Pred

+ func (t TableBase) TableRef() *Ref

+ func (t TableBase) UpsertFrom(ctx context.Context, db *DB, src subquery, c Conflict, cols ...Column) (int64, error)

+ func (t TableBase) UpsertFromSQL(ctx context.Context, db *DB, src subquery, c Conflict, cols ...Column) (string, []any, error)

v0.4.6

Nov 1, 2026

v0.4.5

Oct 29, 2026

v0.4.4

Oct 27, 2026

v0.4.3

Oct 27, 2026

Changes in this version

+ const DefaultCacheBytes

+ const ForKeyShare

+ const ForNoKeyUpdate

+ const ForShare

+ const ForUpdate

+ const NoWait

+ const SkipLocked

+ const Wait

+ var CurrentRow = FrameBound

+ var EmptyJSONArray = []byte("[]")

+ var EmptyJSONObject = []byte("{}")

+ var ErrAllTenantsRequired = errors.New("keel: system scope statement on a tenant table must declare AllTenants")

+ var ErrBudgetExceeded = errors.New("keel: budget exceeded")

+ var ErrConflict = errors.New("keel: version conflict")

+ var ErrNoScope = errors.New("keel: no tenant or system scope on the context")

+ var ErrNotFound = errors.New("keel: no rows")

+ var ErrNotSingular = errors.New("keel: more than one row")

+ var ErrReadOnly = errors.New("keel: write inside a read-only transaction")

+ var ErrScopeMismatch = errors.New(...)

+ var ErrSystemScopeRequired = errors.New("keel: AllTenants requires a system scope")

+ var ErrTenantMismatch = errors.New("keel: row belongs to a different tenant than the scope")

+ var ErrUnbounded = errors.New("keel: List needs a Limit; use Page, or All for a set known to be small")

+ var ErrWaitLimit = errors.New("keel: waited longer than Config.MaxWait")

+ var UnboundedFollowing = FrameBound

+ var UnboundedPreceding = FrameBound

+ func AfterCommit(ctx context.Context, fn func(ctx context.Context))

+ func Alias[H any](ref *Ref, alias string, build func(*Ref) H) H

+ func Batch(ctx context.Context, db *DB, items ...BatchItem) error

+ func Budget(ctx context.Context, opts ...BudgetOption) context.Context

+ func Code(err error) string

+ func ColumnOf(e Expr) (table *schema.Table, index int32, ok bool)

+ func ConstraintName(err error) string

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

+ func ExecAll(ctx context.Context, db *DB, sql string, args ...any) (int64, error)

+ func ExecBatch(ctx context.Context, db *DB, stmts ...Statement) ([]int64, error)

+ func InTx(ctx context.Context, db *DB) bool

+ func Int16s[S ~int16](vs []S) []int16

+ func Int32s[S ~int32](vs []S) []int32

+ func Int64s[S ~int64](vs []S) []int64

+ func IntoOne[R any](ctx context.Context, db *DB, p Projection) (R, error)

+ func Into[R any](ctx context.Context, db *DB, p Projection) ([]R, error)

+ func IsCheck(err error, constraints ...string) bool

+ func IsExclusion(err error, constraints ...string) bool

+ func IsForeignKey(err error, constraints ...string) bool

+ func IsNotNull(err error) bool

+ func IsRetryable(err error) bool

+ func IsUnique(err error, constraints ...string) bool

+ func JoinTx(ctx context.Context, db *DB, conn *pgx.Conn) (context.Context, func(committed bool))

+ func LockKey(ctx context.Context, db *DB, key string) error

+ func MarkChanged(ctx context.Context, db *DB, tables ...string)

+ func OnCreate[T any](db *DB, t tabler[T], phase Phase, ...)

+ func OnDelete[T any](db *DB, t tabler[T], phase Phase, ...)

+ func OnReplica(ctx context.Context) context.Context

+ func OnReplicaAfter(ctx context.Context, db *DB, pos Position) context.Context

+ func OnUpdate[T any](db *DB, t tabler[T], phase Phase, ...)

+ func OnWrite[T any](db *DB, t tabler[T], phase Phase, ...)

+ func Path[H any](parent *Ref, rel int32, build func(*Ref) H) H

+ func Pointers[T any](vs []T) []*T

+ func QueryAll[T any](ctx context.Context, db *DB, to pgx.RowToFunc[T], sql string, args ...any) ([]T, error)

+ func QueryRows(ctx context.Context, db *DB, fn func(row pgx.CollectableRow) error, sql string, ...) error

+ func QueryValue[T any](ctx context.Context, db *DB, sql string, args ...any) (T, error)

+ func Read(ctx context.Context, db *DB, fn func(ctx context.Context) error, ...) error

+ func ReadValue[T any](ctx context.Context, db *DB, fn func(ctx context.Context) (T, error), ...) (T, error)

+ func Savepoint(ctx context.Context, db *DB, fn func(ctx context.Context) error) error

+ func SetLinks[K any](ctx context.Context, db *DB, rel interface{ ... }, parent K, targets []K) error

+ func Strings[S ~string](vs []S) []string

+ func TenantKeyOf(values ...any) string

+ func TryLockKey(ctx context.Context, db *DB, key string) (bool, error)

+ func WithReadFilter(ctx context.Context, f ReadFilter) context.Context

+ func Write(ctx context.Context, db *DB, fn func(ctx context.Context) error, ...) error

+ func WriteValue[T any](ctx context.Context, db *DB, fn func(ctx context.Context) (T, error), ...) (T, error)

+ type Agg struct

+ func ArrayAgg(e Expr) Agg

+ func Avg(e Expr) Agg

+ func BoolAnd(p Pred) Agg

+ func BoolOr(p Pred) Agg

+ func Count() Agg

+ func CountOf(e Expr) Agg

+ func CumeDist() Agg

+ func DenseRank() Agg

+ func FirstValue(e Expr) Agg

+ func Grouping(es ...Expr) Agg

+ func JSONBAgg(e Expr) Agg

+ func Lag(e Expr, offset int, def any) Agg

+ func LastValue(e Expr) Agg

+ func Lead(e Expr, offset int, def any) Agg

+ func Max(e Expr) Agg

+ func Min(e Expr) Agg

+ func Mode(order Order) Agg

+ func NthValue(e Expr, n int) Agg

+ func Ntile(n int) Agg

+ func PercentRank() Agg

+ func PercentileCont(fraction float64, order Order) Agg

+ func PercentileDisc(fraction float64, order Order) Agg

+ func Rank() Agg

+ func RowNumber() Agg

+ func StringAgg(e Expr, sep string) Agg

+ func Sum(e Expr) Agg

+ func (a Agg) Asc() Order

+ func (a Agg) Desc() Order

+ func (a Agg) Distinct() Agg

+ func (a Agg) Eq(v any) Pred

+ func (a Agg) Filter(p Pred) Agg

+ func (a Agg) Gt(v any) Pred

+ func (a Agg) Gte(v any) Pred

+ func (a Agg) Lt(v any) Pred

+ func (a Agg) Lte(v any) Pred

+ func (a Agg) Ne(v any) Pred

+ func (a Agg) OrderBy(os ...Order) Agg

+ func (a Agg) Over(partition []Expr, order ...Order) Agg

+ func (a Agg) OverWindow(w Window) Agg

+ type AnyCol struct

+ func (c AnyCol) Add(v NumericValue) NumericExpr

+ func (c AnyCol) Avg() Agg

+ func (c AnyCol) Between(lo, hi any) Pred

+ func (c AnyCol) Div(v NumericValue) NumericExpr

+ func (c AnyCol) Eq(v any) Pred

+ func (c AnyCol) Gt(v any) Pred

+ func (c AnyCol) Gte(v any) Pred

+ func (c AnyCol) In(slice any) Pred

+ func (c AnyCol) InArray(a NumericArrayValue) Pred

+ func (c AnyCol) Increment(v any) Assignment

+ func (c AnyCol) IsDistinctFrom(v any) Pred

+ func (c AnyCol) IsDistinctFromExpr(o NumericValue) Pred

+ func (c AnyCol) IsNotDistinctFrom(v any) Pred

+ func (c AnyCol) IsNotDistinctFromExpr(o NumericValue) Pred

+ func (c AnyCol) Lt(v any) Pred

+ func (c AnyCol) Lte(v any) Pred

+ func (c AnyCol) Mod(v NumericValue) NumericExpr

+ func (c AnyCol) Mul(v NumericValue) NumericExpr

+ func (c AnyCol) Ne(v any) Pred

+ func (c AnyCol) Neg() NumericExpr

+ func (c AnyCol) NotIn(slice any) Pred

+ func (c AnyCol) NotInArray(a NumericArrayValue) Pred

+ func (c AnyCol) Sub(v NumericValue) NumericExpr

+ func (c AnyCol) Sum() Agg

+ func (c AnyCol) To(v any) Assignment

+ type Assignment struct

+ type BatchItem struct

+ func AllInto[T any](q *Query[T], dst *[]T) BatchItem

+ func CountEstimateInto[T any](q *Query[T], exactUpTo int64, dst *RowCount) BatchItem

+ func CountInto[T any](q *Query[T], dst *int64) BatchItem

+ func CountUpToInto[T any](q *Query[T], limit int64, dst *int64) BatchItem

+ func DynCountEstimateInto(q *DynQuery, exactUpTo int64, dst *RowCount) BatchItem

+ func DynCountInto(q *DynQuery, dst *int64) BatchItem

+ func DynExistsInto(q *DynQuery, dst *bool) BatchItem

+ func DynInto(q *DynQuery, dst **DynResult) BatchItem

+ func DynPageInto(q *DynQuery, p PageRequest, dst **DynResult) BatchItem

+ func ExistsInto[T any](q *Query[T], dst *bool) BatchItem

+ func FirstInto[T any](q *Query[T], dst *T) BatchItem

+ func IntoSlice[R any](p Projection, dst *[]R) BatchItem

+ func IntoValue[R any](p Projection, dst *R) BatchItem

+ func ListInto[T any](q *Query[T], dst *[]T) BatchItem

+ func OneInto[T any](q *Query[T], dst *T) BatchItem

+ func PageInto[T any](q *Query[T], p PageRequest, dst *Page[T]) BatchItem

+ type BoolArrayCase struct

+ func CaseBoolArray() BoolArrayCase

+ func (b BoolArrayCase) Else(v BoolArrayValue) BoolArrayExpr

+ func (b BoolArrayCase) End() BoolArrayExpr

+ func (b BoolArrayCase) When(cond Pred, v BoolArrayValue) BoolArrayCase

+ type BoolArrayExpr struct

+ func ArrayOfBool(es ...BoolValue) BoolArrayExpr

+ func BoolArray(vs []bool) BoolArrayExpr

+ func BoolArrayOf(e Expr) BoolArrayExpr

+ func (e BoolArrayExpr) At(i int) BoolExpr

+ func (e BoolArrayExpr) Coalesce(o BoolArrayValue) BoolArrayExpr

+ func (e BoolArrayExpr) ContainedByExpr(o BoolArrayValue) Pred

+ func (e BoolArrayExpr) ContainsAllExpr(o BoolArrayValue) Pred

+ func (e BoolArrayExpr) IsNotNull() Pred

+ func (e BoolArrayExpr) IsNull() Pred

+ func (e BoolArrayExpr) Len() Int32Expr

+ func (e BoolArrayExpr) NullIf(o BoolArrayValue) BoolArrayExpr

+ func (e BoolArrayExpr) OverlapsExpr(o BoolArrayValue) Pred

+ func (e BoolArrayExpr) Unnest() BoolExpr

+ func (e BoolArrayExpr) Without(v BoolValue) BoolArrayExpr

+ type BoolArrayValue interface

+ type BoolCase struct

+ func CaseBool() BoolCase

+ func (b BoolCase) Else(v BoolValue) BoolExpr

+ func (b BoolCase) End() BoolExpr

+ func (b BoolCase) When(cond Pred, v BoolValue) BoolCase

+ type BoolCol struct

+ func (c BoolCol) Coalesce(vs ...any) BoolExpr

+ func (c BoolCol) Eq(v bool) Pred

+ func (c BoolCol) IsDistinctFrom(v bool) Pred

+ func (c BoolCol) IsDistinctFromExpr(o BoolValue) Pred

+ func (c BoolCol) IsFalse() Pred

+ func (c BoolCol) IsNotDistinctFrom(v bool) Pred

+ func (c BoolCol) IsNotDistinctFromExpr(o BoolValue) Pred

+ func (c BoolCol) IsTrue() Pred

+ func (c BoolCol) To(v bool) Assignment

+ type BoolExpr struct

+ func Bool(b bool) BoolExpr

+ func BoolOf(e Expr) BoolExpr

+ func BoolPtr(p *bool) BoolExpr

+ func CastBool(e Expr) BoolExpr

+ func ConstBool(b bool) BoolExpr

+ func NullBool() BoolExpr

+ func (e BoolExpr) Asc() Order

+ func (e BoolExpr) Coalesce(vs ...any) BoolExpr

+ func (e BoolExpr) Desc() Order

+ func (e BoolExpr) Eq(v bool) Pred

+ func (e BoolExpr) EqExpr(o BoolValue) Pred

+ func (e BoolExpr) IsDistinctFrom(v bool) Pred

+ func (e BoolExpr) IsDistinctFromExpr(o BoolValue) Pred

+ func (e BoolExpr) IsFalse() Pred

+ func (e BoolExpr) IsNotDistinctFrom(v bool) Pred

+ func (e BoolExpr) IsNotDistinctFromExpr(o BoolValue) Pred

+ func (e BoolExpr) IsNotNull() Pred

+ func (e BoolExpr) IsNull() Pred

+ func (e BoolExpr) IsTrue() Pred

+ type BoolValue interface

+ type BudgetError struct

+ Limit string

+ Max int

+ Report BudgetReport

+ func (e *BudgetError) Error() string

+ func (e *BudgetError) Is(target error) bool

+ type BudgetOption func(b *budget)

+ func MaxRepeats(n int) BudgetOption

+ func MaxRoundTrips(n int) BudgetOption

+ func MaxStatements(n int) BudgetOption

+ func OnExceeded(fn func(ctx context.Context, r BudgetReport)) BudgetOption

+ type BudgetReport struct

+ Repeats []Repeat

+ RoundTrips int

+ Statements int

+ func BudgetReportFrom(ctx context.Context) (BudgetReport, bool)

+ type BytesCol struct

+ func (c BytesCol) Eq(v []byte) Pred

+ func (c BytesCol) To(v []byte) Assignment

+ type CTETable struct

+ func CTE(name string, columns []string, body subquery) *CTETable

+ func RecursiveCTE(name string, columns []string, base subquery) *CTETable

+ func Unnest(name string, columns []string, arrays ...any) *CTETable

+ func (c *CTETable) Col(name string) AnyCol

+ func (c *CTETable) Distinct() *CTETable

+ func (c *CTETable) Query() *Query[*Row]

+ func (c *CTETable) Recurse(step subquery) *CTETable

+ func (c *CTETable) TableRef() *Ref

+ type CacheConfig struct

+ Key func(ctx context.Context) string

+ Listen *pgx.ConnConfig

+ Local LocalCache

+ MaxEntryBytes int

+ OnError func(err error)

+ Shared SharedCache

+ type CacheOption func(*cacheSpec)

+ func AlsoReads(tables ...string) CacheOption

+ func TTL(d time.Duration) CacheOption

+ type CacheStats struct

+ Bypasses int64

+ Bytes int64

+ Errors int64

+ Hits int64

+ Listening bool

+ Misses int64

+ Versions int

+ type Col struct

+ Index int32

+ Ref *Ref

+ func (c Col) Asc() Order

+ func (c Col) Coalesce(vs ...any) Expr

+ func (c Col) Count() Agg

+ func (c Col) CountDistinct() Agg

+ func (c Col) Desc() Order

+ func (c Col) EqCol(other Expr) Pred

+ func (c Col) Excluded() Expr

+ func (c Col) InQuery(q subquery) Pred

+ func (c Col) IsNotNull() Pred

+ func (c Col) IsNull() Pred

+ func (c Col) Max() Agg

+ func (c Col) Min() Agg

+ func (c Col) NeCol(other Expr) Pred

+ func (c Col) NotInQuery(q subquery) Pred

+ func (c Col) ToDefault() Assignment

+ func (c Col) ToExpr(e Expr) Assignment

+ func (c Col) ToNull() Assignment

+ type Column interface

+ type Compound struct

+ func Except(qs ...subquery) Compound

+ func Intersect(qs ...subquery) Compound

+ func Union(qs ...subquery) Compound

+ func UnionAll(qs ...subquery) Compound

+ type Config struct

+ AfterConnect func(ctx context.Context, conn *pgx.Conn) error

+ AwaitReadCommit bool

+ Cache *CacheConfig

+ DSN string

+ DataVersions DataVersionsConfig

+ DeadlineTimeouts bool

+ JSON *JSONCodec

+ LoadStrategy LoadStrategy

+ LoadTypes []string

+ MaxReplicaLag time.Duration

+ MaxWait time.Duration

+ NewID func(prefix string) string

+ Now func() time.Time

+ ObserveArgs bool

+ Observers []Observer

+ OnBegin func(ctx context.Context, tx TxInfo) ([]Statement, error)

+ PlanCache PlanCache

+ Pool *pgxpool.Config

+ ReadIsolation Isolation

+ Replicas []ReplicaConfig

+ SkipEnums bool

+ SlowWaits SlowWaitConfig

+ StatementCacheCapacity int

+ System func(ctx context.Context) (reason string, ok bool)

+ Tables []*schema.Table

+ Tenant func(ctx context.Context) ([]any, bool)

+ TenantColumns []string

+ TenantConcurrency int

+ type Conflict struct

+ func OnConflict(targets ...Expr) Conflict

+ func (c Conflict) DoNothing() Conflict

+ func (c Conflict) Set(sets ...Assignment) Conflict

+ func (c Conflict) Update(cols ...Column) Conflict

+ func (c Conflict) UpdateWhere(ps ...Pred) Conflict

+ func (c Conflict) Where(ps ...Pred) Conflict

+ type ConflictError struct

+ Table string

+ Version int64

+ func (e *ConflictError) Error() string

+ func (e *ConflictError) Is(target error) bool

+ type Constraint = schema.Constraint

+ type ConstraintError struct

+ Columns []string

+ Constraint string

+ Err *pgconn.PgError

+ Fields []string

+ Kind ConstraintKind

+ Labels []string

+ Message string

+ Model *schema.Table

+ Table string

+ func (e *ConstraintError) Error() string

+ func (e *ConstraintError) Unwrap() error

+ type ConstraintKind uint8

+ const ConstraintCheck

+ const ConstraintExclusion

+ const ConstraintForeignKey

+ const ConstraintNotNull

+ const ConstraintUnique

+ func (k ConstraintKind) String() string

+ type DB struct

+ func Open(ctx context.Context, cfg Config) (*DB, error)

+ func (db *DB) CacheStats() CacheStats

+ func (db *DB) Close()

+ func (db *DB) DataVersions(ctx context.Context, tenantKey string, tables ...string) (map[string]int64, error)

+ func (db *DB) FlushDataVersions(ctx context.Context) error

+ func (db *DB) ForgetColumnTypes()

+ func (db *DB) Intercept(t interface{ ... }, fn Interceptor)

+ func (db *DB) InterceptAll(fn Interceptor)

+ func (db *DB) JSON() JSONCodec

+ func (db *DB) Ping(ctx context.Context) error

+ func (db *DB) Pool() *pgxpool.Pool

+ func (db *DB) ReadCommitFailures() int64

+ func (db *DB) ReplicaFallbacks() uint64

+ func (db *DB) Replicas() []ReplicaStats

+ func (db *DB) TenantColumns() []string

+ func (db *DB) TenantKey(ctx context.Context) string

+ func (db *DB) TenantWaits() int64

+ type DataVersionsConfig struct

+ Enabled bool

+ Interval time.Duration

+ OnError func(err error)

+ type Decimal string

+ func (d Decimal) Float64() (float64, error)

+ func (d Decimal) String() string

+ type DeclaredFunc interface

+ Decl func() *FuncDecl

+ type Drift struct

+ Column string

+ Detail string

+ Field string

+ Fix string

+ Kind DriftKind

+ Table string

+ func Verify(ctx context.Context, db *DB, tables []*schema.Table) ([]Drift, error)

+ func VerifyFuncs(ctx context.Context, db *DB, fns ...DeclaredFunc) ([]Drift, error)

+ func (d Drift) String() string

+ type DriftKind string

+ const DriftConstraint

+ const DriftFunctionArity

+ const DriftFunctionResult

+ const DriftGenerated

+ const DriftJSON

+ const DriftJoinTable

+ const DriftMissingColumn

+ const DriftMissingFunction

+ const DriftMissingTable

+ const DriftNullable

+ const DriftPrimaryKey

+ const DriftRelationKey

+ const DriftType

+ type DynCTE struct

+ func (c *DynCTE) Col(label string) DynExpr

+ func (c *DynCTE) Labels() []string

+ type DynCaseBuilder struct

+ func DynCase() DynCaseBuilder

+ func (b DynCaseBuilder) Else(v any) DynExpr

+ func (b DynCaseBuilder) End() DynExpr

+ func (b DynCaseBuilder) When(cond Pred, then any) DynCaseBuilder

+ type DynColumn struct

+ Bool []bool

+ Bytes [][]byte

+ Float64 []float64

+ Int64 []int64

+ JSON [][]byte

+ Name string

+ Nulls []uint64

+ Numeric []Decimal

+ OID uint32

+ String []string

+ Time []time.Time

+ Type ValueType

+ func (c *DynColumn) IsNull(i int) bool

+ func (c *DynColumn) Value(i int) any

+ type DynExpr struct

+ func DynArray(vs ...any) DynExpr

+ func DynConst(v any) DynExpr

+ func DynCount() DynExpr

+ func DynFunc(name string, args ...any) DynExpr

+ func DynLit(v any) DynExpr

+ func DynOf(e Expr) DynExpr

+ func DynRow(vs ...any) DynExpr

+ func ResolvePath(t interface{ ... }, segments ...string) DynExpr

+ func (d DynExpr) Add(v any) DynExpr

+ func (d DynExpr) And(ps ...Pred) DynExpr

+ func (d DynExpr) As(label string) DynExpr

+ func (d DynExpr) Asc() Order

+ func (d DynExpr) At(i int) DynExpr

+ func (d DynExpr) Avg() DynExpr

+ func (d DynExpr) Between(lo, hi any) DynExpr

+ func (d DynExpr) Cast(t ValueType) DynExpr

+ func (d DynExpr) Coalesce(vs ...any) DynExpr

+ func (d DynExpr) Collate(name string) DynExpr

+ func (d DynExpr) Concat(v any) DynExpr

+ func (d DynExpr) Contains(s string) DynExpr

+ func (d DynExpr) ContainsFold(s string) DynExpr

+ func (d DynExpr) Count() DynExpr

+ func (d DynExpr) CountDistinct() DynExpr

+ func (d DynExpr) CoveredBy(v any) DynExpr

+ func (d DynExpr) Covers(v any) DynExpr

+ func (d DynExpr) Desc() Order

+ func (d DynExpr) Distinct() DynExpr

+ func (d DynExpr) Div(v any) DynExpr

+ func (d DynExpr) Eq(v any) DynExpr

+ func (d DynExpr) Err() error

+ func (d DynExpr) Filter(p Pred) DynExpr

+ func (d DynExpr) Gt(v any) DynExpr

+ func (d DynExpr) Gte(v any) DynExpr

+ func (d DynExpr) HasPrefix(s string) DynExpr

+ func (d DynExpr) HasSuffix(s string) DynExpr

+ func (d DynExpr) ILike(pattern any) DynExpr

+ func (d DynExpr) In(list any) DynExpr

+ func (d DynExpr) InUnnest(arrays ...any) DynExpr

+ func (d DynExpr) IsDistinctFrom(v any) DynExpr

+ func (d DynExpr) IsFalse() DynExpr

+ func (d DynExpr) IsNotNull() DynExpr

+ func (d DynExpr) IsNull() DynExpr

+ func (d DynExpr) IsTrue() DynExpr

+ func (d DynExpr) Label() string

+ func (d DynExpr) Like(pattern any) DynExpr

+ func (d DynExpr) Lt(v any) DynExpr

+ func (d DynExpr) Lte(v any) DynExpr

+ func (d DynExpr) Match(query string, opts ...SearchOption) DynExpr

+ func (d DynExpr) Max() DynExpr

+ func (d DynExpr) Min() DynExpr

+ func (d DynExpr) Mod(v any) DynExpr

+ func (d DynExpr) Mul(v any) DynExpr

+ func (d DynExpr) Ne(v any) DynExpr

+ func (d DynExpr) Neg() DynExpr

+ func (d DynExpr) Not() DynExpr

+ func (d DynExpr) NotIn(list any) DynExpr

+ func (d DynExpr) NullIf(v any) DynExpr

+ func (d DynExpr) Or(ps ...Pred) DynExpr

+ func (d DynExpr) OrderBy(os ...Order) DynExpr

+ func (d DynExpr) Over(w Window) DynExpr

+ func (d DynExpr) Rank(query string, opts ...SearchOption) DynExpr

+ func (d DynExpr) RankCD(query string, opts ...SearchOption) DynExpr

+ func (d DynExpr) Sub(v any) DynExpr

+ func (d DynExpr) Sum() DynExpr

+ type DynPreAgg struct

+ func (p *DynPreAgg) AllParents() *DynPreAgg

+ func (p *DynPreAgg) Err() error

+ func (p *DynPreAgg) Measure(e DynExpr) DynExpr

+ func (p *DynPreAgg) Where(ps ...Pred) *DynPreAgg

+ type DynQuery struct

+ func DynExcept(parts ...*DynQuery) *DynQuery

+ func DynFrom(t *schema.Table) *DynQuery

+ func DynFromQuery(sub *DynQuery) *DynQuery

+ func DynIntersect(parts ...*DynQuery) *DynQuery

+ func DynUnion(parts ...*DynQuery) *DynQuery

+ func DynUnionAll(parts ...*DynQuery) *DynQuery

+ func (q *DynQuery) AllTenants() *DynQuery

+ func (q *DynQuery) Compute(name string, e DynExpr) *DynQuery

+ func (q *DynQuery) Count(ctx context.Context, db *DB) (int64, error)

+ func (q *DynQuery) CountEstimate(ctx context.Context, db *DB, exactUpTo int64) (RowCount, error)

+ func (q *DynQuery) Cube(es ...Expr) *DynQuery

+ func (q *DynQuery) CustomPlan() *DynQuery

+ func (q *DynQuery) Distinct() *DynQuery

+ func (q *DynQuery) Err() error

+ func (q *DynQuery) Exists(ctx context.Context, db *DB) (bool, error)

+ func (q *DynQuery) Explain(ctx context.Context, db *DB, opts ExplainOptions) (*Plan, error)

+ func (q *DynQuery) Group(es ...Expr) *DynQuery

+ func (q *DynQuery) GroupingSets(sets ...[]Expr) *DynQuery

+ func (q *DynQuery) Having(ps ...Pred) *DynQuery

+ func (q *DynQuery) Join(c *DynCTE, on ...Pred) *DynQuery

+ func (q *DynQuery) LeftJoin(c *DynCTE, on ...Pred) *DynQuery

+ func (q *DynQuery) Limit(n int) *DynQuery

+ func (q *DynQuery) Offset(n int) *DynQuery

+ func (q *DynQuery) Omit(names ...string) *DynQuery

+ func (q *DynQuery) Order(os ...Order) *DynQuery

+ func (q *DynQuery) Page(ctx context.Context, db *DB, p PageRequest) (*DynResult, error)

+ func (q *DynQuery) Path(segments ...string) DynExpr

+ func (q *DynQuery) Rel(path ...string) *DynRel

+ func (q *DynQuery) Rollup(es ...Expr) *DynQuery

+ func (q *DynQuery) Run(ctx context.Context, db *DB) (*DynResult, error)

+ func (q *DynQuery) Select(es ...DynExpr) *DynQuery

+ func (q *DynQuery) Stream(ctx context.Context, db *DB, size int) iter.Seq2[*DynResult, error]

+ func (q *DynQuery) Table() *schema.Table

+ func (q *DynQuery) Timeout(d time.Duration) *DynQuery

+ func (q *DynQuery) ToSQL(ctx context.Context, db *DB) (string, []any, error)

+ func (q *DynQuery) Where(ps ...Pred) *DynQuery

+ func (q *DynQuery) Window(name string, w Window) *DynQuery

+ func (q *DynQuery) With(sub *DynQuery) *DynCTE

+ type DynRel struct

+ func (d *DynRel) Any(ps ...Pred) DynExpr

+ func (d *DynRel) Col(path ...string) DynExpr

+ func (d *DynRel) Err() error

+ func (d *DynRel) None(ps ...Pred) DynExpr

+ func (d *DynRel) PreAggregate(s PreAggStrategy) *DynPreAgg

+ type DynResult struct

+ Columns []DynColumn

+ Next string

+ Rows int

+ Total int64

+ TotalExact bool

+ func (res *DynResult) Column(name string) *DynColumn

+ func (res *DynResult) CursorAt(i int) string

+ type ExplainOptions struct

+ Analyze bool

+ GenericPlan bool

+ type Expr interface

+ func ArrayOf(q subquery) Expr

+ func Scalar(q subquery) Expr

+ func Val(v any) Expr

+ type Float64ArrayCase struct

+ func CaseFloat64Array() Float64ArrayCase

+ func (b Float64ArrayCase) Else(v Float64ArrayValue) Float64ArrayExpr

+ func (b Float64ArrayCase) End() Float64ArrayExpr

+ func (b Float64ArrayCase) When(cond Pred, v Float64ArrayValue) Float64ArrayCase

+ type Float64ArrayExpr struct

+ func ArrayOfFloat64(es ...Float64Value) Float64ArrayExpr

+ func Float64Array(vs []float64) Float64ArrayExpr

+ func Float64ArrayOf(e Expr) Float64ArrayExpr

+ func (e Float64ArrayExpr) At(i int) Float64Expr

+ func (e Float64ArrayExpr) Coalesce(o Float64ArrayValue) Float64ArrayExpr

+ func (e Float64ArrayExpr) ContainedByExpr(o Float64ArrayValue) Pred

+ func (e Float64ArrayExpr) ContainsAllExpr(o Float64ArrayValue) Pred

+ func (e Float64ArrayExpr) IsNotNull() Pred

+ func (e Float64ArrayExpr) IsNull() Pred

+ func (e Float64ArrayExpr) Len() Int32Expr

+ func (e Float64ArrayExpr) NullIf(o Float64ArrayValue) Float64ArrayExpr

+ func (e Float64ArrayExpr) OverlapsExpr(o Float64ArrayValue) Pred

+ func (e Float64ArrayExpr) Unnest() Float64Expr

+ func (e Float64ArrayExpr) Without(v Float64Value) Float64ArrayExpr

+ type Float64ArrayValue interface

+ type Float64Case struct

+ func CaseFloat64() Float64Case

+ func (b Float64Case) Else(v Float64Value) Float64Expr

+ func (b Float64Case) End() Float64Expr

+ func (b Float64Case) When(cond Pred, v Float64Value) Float64Case

+ type Float64Col struct

+ func (c Float64Col) Abs() Float64Expr

+ func (c Float64Col) Add(v Float64Value) Float64Expr

+ func (c Float64Col) Avg() Agg

+ func (c Float64Col) Between(lo, hi float64) Pred

+ func (c Float64Col) Ceil() Float64Expr

+ func (c Float64Col) Coalesce(vs ...any) Float64Expr

+ func (c Float64Col) Div(v Float64Value) Float64Expr

+ func (c Float64Col) Eq(v float64) Pred

+ func (c Float64Col) Exp() Float64Expr

+ func (c Float64Col) Floor() Float64Expr

+ func (c Float64Col) Greatest(others ...Float64Value) Float64Expr

+ func (c Float64Col) Gt(v float64) Pred

+ func (c Float64Col) Gte(v float64) Pred

+ func (c Float64Col) InArray(a Float64ArrayValue) Pred

+ func (c Float64Col) Increment(v float64) Assignment

+ func (c Float64Col) IsDistinctFrom(v float64) Pred

+ func (c Float64Col) IsDistinctFromExpr(o Float64Value) Pred

+ func (c Float64Col) IsNotDistinctFrom(v float64) Pred

+ func (c Float64Col) IsNotDistinctFromExpr(o Float64Value) Pred

+ func (c Float64Col) Least(others ...Float64Value) Float64Expr

+ func (c Float64Col) Ln() Float64Expr

+ func (c Float64Col) Lt(v float64) Pred

+ func (c Float64Col) Lte(v float64) Pred

+ func (c Float64Col) Mul(v Float64Value) Float64Expr

+ func (c Float64Col) Ne(v float64) Pred

+ func (c Float64Col) Neg() Float64Expr

+ func (c Float64Col) NotInArray(a Float64ArrayValue) Pred

+ func (c Float64Col) NullIf(v float64) Float64Expr

+ func (c Float64Col) Round() Float64Expr

+ func (c Float64Col) Sub(v Float64Value) Float64Expr

+ func (c Float64Col) Sum() Agg

+ func (c Float64Col) To(v float64) Assignment

+ type Float64Expr struct

+ func CastFloat64(e Expr) Float64Expr

+ func ConstFloat64(f float64) Float64Expr

+ func DatePart(field string, t TimeValue) Float64Expr

+ func Float64(f float64) Float64Expr

+ func Float64Of(e Expr) Float64Expr

+ func Float64Ptr(p *float64) Float64Expr

+ func NullFloat64() Float64Expr

+ func (e Float64Expr) Abs() Float64Expr

+ func (e Float64Expr) Add(v Float64Value) Float64Expr

+ func (e Float64Expr) Asc() Order

+ func (e Float64Expr) Avg() Agg

+ func (e Float64Expr) Between(lo, hi float64) Pred

+ func (e Float64Expr) Ceil() Float64Expr

+ func (e Float64Expr) Coalesce(vs ...any) Float64Expr

+ func (e Float64Expr) Desc() Order

+ func (e Float64Expr) Div(v Float64Value) Float64Expr

+ func (e Float64Expr) Eq(v float64) Pred

+ func (e Float64Expr) EqExpr(o Float64Value) Pred

+ func (e Float64Expr) Exp() Float64Expr

+ func (e Float64Expr) Floor() Float64Expr

+ func (e Float64Expr) Greatest(others ...Float64Value) Float64Expr

+ func (e Float64Expr) Gt(v float64) Pred

+ func (e Float64Expr) GtExpr(o Float64Value) Pred

+ func (e Float64Expr) Gte(v float64) Pred

+ func (e Float64Expr) GteExpr(o Float64Value) Pred

+ func (e Float64Expr) InArray(a Float64ArrayValue) Pred

+ func (e Float64Expr) IsDistinctFrom(v float64) Pred

+ func (e Float64Expr) IsDistinctFromExpr(o Float64Value) Pred

+ func (e Float64Expr) IsNotDistinctFrom(v float64) Pred

+ func (e Float64Expr) IsNotDistinctFromExpr(o Float64Value) Pred

+ func (e Float64Expr) IsNotNull() Pred

+ func (e Float64Expr) IsNull() Pred

+ func (e Float64Expr) Least(others ...Float64Value) Float64Expr

+ func (e Float64Expr) Ln() Float64Expr

+ func (e Float64Expr) Lt(v float64) Pred

+ func (e Float64Expr) LtExpr(o Float64Value) Pred

+ func (e Float64Expr) Lte(v float64) Pred

+ func (e Float64Expr) LteExpr(o Float64Value) Pred

+ func (e Float64Expr) Max() Agg

+ func (e Float64Expr) Min() Agg

+ func (e Float64Expr) Mul(v Float64Value) Float64Expr

+ func (e Float64Expr) Ne(v float64) Pred

+ func (e Float64Expr) NeExpr(o Float64Value) Pred

+ func (e Float64Expr) Neg() Float64Expr

+ func (e Float64Expr) NotInArray(a Float64ArrayValue) Pred

+ func (e Float64Expr) NullIf(v float64) Float64Expr

+ func (e Float64Expr) Round() Float64Expr

+ func (e Float64Expr) Sub(v Float64Value) Float64Expr

+ func (e Float64Expr) Sum() Agg

+ type Float64Value interface

+ type FrameBound struct

+ func Following(offset any) FrameBound

+ func Preceding(offset any) FrameBound

+ type FrameExclusion string

+ const ExcludeCurrentRow

+ const ExcludeGroup

+ const ExcludeNoOthers

+ const ExcludeTies

+ type Func0 struct

+ func DeclareFunc0[R FuncResult](name string) Func0[R]

+ func (f Func0[R]) Call() R

+ func (f Func0[R]) Decl() *FuncDecl

+ type Func1 struct

+ func DeclareFunc1[R FuncResult, A Expr](name string) Func1[R, A]

+ func (f Func1[R, A]) Call(a A) R

+ func (f Func1[R, A]) Decl() *FuncDecl

+ type Func2 struct

+ func DeclareFunc2[R FuncResult, A, B Expr](name string) Func2[R, A, B]

+ func (f Func2[R, A, B]) Call(a A, b B) R

+ func (f Func2[R, A, B]) Decl() *FuncDecl

+ type Func3 struct

+ func DeclareFunc3[R FuncResult, A, B, C Expr](name string) Func3[R, A, B, C]

+ func (f Func3[R, A, B, C]) Call(a A, b B, c C) R

+ func (f Func3[R, A, B, C]) Decl() *FuncDecl

+ type FuncDecl struct

+ func (d *FuncDecl) Arity() int

+ func (d *FuncDecl) Name() string

+ type FuncResult interface

+ type Handle struct

+ Ref *Ref

+ func (h Handle[T]) AllTenants() *Query[T]

+ func (h Handle[T]) Any(ps ...Pred) Pred

+ func (h Handle[T]) Cache(opts ...CacheOption) *Query[T]

+ func (h Handle[T]) Compute(col Column, e Expr) *Query[T]

+ func (h Handle[T]) Copy(ctx context.Context, db *DB, rows []T) (int64, error)

+ func (h Handle[T]) Create(ctx context.Context, db *DB, row T) error

+ func (h Handle[T]) CreateMany(ctx context.Context, db *DB, rows []T) error

+ func (h Handle[T]) CreateOrSkip(ctx context.Context, db *DB, rows []T, targets ...Expr) (int64, error)

+ func (h Handle[T]) Cube(es ...Expr) *Query[T]

+ func (h Handle[T]) DeleteRow(ctx context.Context, db *DB, row T) error

+ func (h Handle[T]) DistinctOn(es ...Expr) *Query[T]

+ func (h Handle[T]) Group(es ...Expr) *Query[T]

+ func (h Handle[T]) GroupingSets(sets ...[]Expr) *Query[T]

+ func (h Handle[T]) InsertFrom(ctx context.Context, db *DB, src subquery, cols ...Column) (int64, error)

+ func (h Handle[T]) InsertFromSQL(ctx context.Context, db *DB, src subquery, cols ...Column) (string, []any, error)

+ func (h Handle[T]) Join(t interface{ ... }, on ...Pred) *Query[T]

+ func (h Handle[T]) JoinLateral(sub interface{ ... }) *Query[T]

+ func (h Handle[T]) LeftJoin(t interface{ ... }, on ...Pred) *Query[T]

+ func (h Handle[T]) LeftJoinLateral(sub interface{ ... }) *Query[T]

+ func (h Handle[T]) Limit(n int) *Query[T]

+ func (h Handle[T]) Load(ls ...Loader) *Query[T]

+ func (h Handle[T]) LoadStrategy(s LoadStrategy) *Query[T]

+ func (h Handle[T]) Lock(strength LockStrength, wait ...LockWait) *Query[T]

+ func (h Handle[T]) None(ps ...Pred) Pred

+ func (h Handle[T]) Omit(cols ...Column) *Query[T]

+ func (h Handle[T]) Order(os ...Order) *Query[T]

+ func (h Handle[T]) Pick(es ...Expr) *Query[T]

+ func (h Handle[T]) Query() *Query[T]

+ func (h Handle[T]) Rollup(es ...Expr) *Query[T]

+ func (h Handle[T]) Save(ctx context.Context, db *DB, row T, cols ...Column) error

+ func (h Handle[T]) SaveExcept(ctx context.Context, db *DB, row T, cols ...Column) error

+ func (h Handle[T]) TableRef() *Ref

+ func (h Handle[T]) Upsert(ctx context.Context, db *DB, rows []T, c Conflict) ([]bool, error)

+ func (h Handle[T]) UpsertFrom(ctx context.Context, db *DB, src subquery, c Conflict, cols ...Column) (int64, error)

+ func (h Handle[T]) UpsertFromSQL(ctx context.Context, db *DB, src subquery, c Conflict, cols ...Column) (string, []any, error)

+ func (h Handle[T]) Where(ps ...Pred) *Query[T]

+ func (h Handle[T]) With(ctes ...*CTETable) *Query[T]

+ type HookOption func(*hookEntry)

+ func Needs(cols ...Column) HookOption

+ type Int16Col struct

+ func (c Int16Col) Between(lo, hi int16) Pred

+ func (c Int16Col) Eq(v int16) Pred

+ func (c Int16Col) Gt(v int16) Pred

+ func (c Int16Col) Gte(v int16) Pred

+ func (c Int16Col) In(vs ...int16) Pred

+ func (c Int16Col) Increment(v int16) Assignment

+ func (c Int16Col) IsDistinctFrom(v int16) Pred

+ func (c Int16Col) IsNotDistinctFrom(v int16) Pred

+ func (c Int16Col) Lt(v int16) Pred

+ func (c Int16Col) Lte(v int16) Pred

+ func (c Int16Col) Ne(v int16) Pred

+ func (c Int16Col) NotIn(vs ...int16) Pred

+ func (c Int16Col) Sum() Agg

+ func (c Int16Col) To(v int16) Assignment

+ type Int32ArrayCase struct

+ func CaseInt32Array() Int32ArrayCase

+ func (b Int32ArrayCase) Else(v Int32ArrayValue) Int32ArrayExpr

+ func (b Int32ArrayCase) End() Int32ArrayExpr

+ func (b Int32ArrayCase) When(cond Pred, v Int32ArrayValue) Int32ArrayCase

+ type Int32ArrayExpr struct

+ func ArrayOfInt32(es ...Int32Value) Int32ArrayExpr

+ func Int32Array(vs []int32) Int32ArrayExpr

+ func Int32ArrayOf(e Expr) Int32ArrayExpr

+ func (e Int32ArrayExpr) At(i int) Int32Expr

+ func (e Int32ArrayExpr) Coalesce(o Int32ArrayValue) Int32ArrayExpr

+ func (e Int32ArrayExpr) ContainedByExpr(o Int32ArrayValue) Pred

+ func (e Int32ArrayExpr) ContainsAllExpr(o Int32ArrayValue) Pred

+ func (e Int32ArrayExpr) IsNotNull() Pred

+ func (e Int32ArrayExpr) IsNull() Pred

+ func (e Int32ArrayExpr) Len() Int32Expr

+ func (e Int32ArrayExpr) NullIf(o Int32ArrayValue) Int32ArrayExpr

+ func (e Int32ArrayExpr) OverlapsExpr(o Int32ArrayValue) Pred

+ func (e Int32ArrayExpr) Unnest() Int32Expr

+ func (e Int32ArrayExpr) Without(v Int32Value) Int32ArrayExpr

+ type Int32ArrayValue interface

+ type Int32Case struct

+ func CaseInt32() Int32Case

+ func (b Int32Case) Else(v Int32Value) Int32Expr

+ func (b Int32Case) End() Int32Expr

+ func (b Int32Case) When(cond Pred, v Int32Value) Int32Case

+ type Int32Col struct

+ func (c Int32Col) Abs() Int32Expr

+ func (c Int32Col) Add(v Int32Value) Int32Expr

+ func (c Int32Col) Avg() Agg

+ func (c Int32Col) Between(lo, hi int32) Pred

+ func (c Int32Col) Coalesce(vs ...any) Int32Expr

+ func (c Int32Col) Div(v Int32Value) Int32Expr

+ func (c Int32Col) Eq(v int32) Pred

+ func (c Int32Col) Greatest(others ...Int32Value) Int32Expr

+ func (c Int32Col) Gt(v int32) Pred

+ func (c Int32Col) Gte(v int32) Pred

+ func (c Int32Col) In(vs ...int32) Pred

+ func (c Int32Col) InArray(a Int32ArrayValue) Pred

+ func (c Int32Col) Increment(v int32) Assignment

+ func (c Int32Col) IsDistinctFrom(v int32) Pred

+ func (c Int32Col) IsDistinctFromExpr(o Int32Value) Pred

+ func (c Int32Col) IsNotDistinctFrom(v int32) Pred

+ func (c Int32Col) IsNotDistinctFromExpr(o Int32Value) Pred

+ func (c Int32Col) Least(others ...Int32Value) Int32Expr

+ func (c Int32Col) Lt(v int32) Pred

+ func (c Int32Col) Lte(v int32) Pred

+ func (c Int32Col) Mod(v Int32Value) Int32Expr

+ func (c Int32Col) Mul(v Int32Value) Int32Expr

+ func (c Int32Col) Ne(v int32) Pred

+ func (c Int32Col) Neg() Int32Expr

+ func (c Int32Col) NotIn(vs ...int32) Pred

+ func (c Int32Col) NotInArray(a Int32ArrayValue) Pred

+ func (c Int32Col) NullIf(v int32) Int32Expr

+ func (c Int32Col) Sub(v Int32Value) Int32Expr

+ func (c Int32Col) Sum() Agg

+ func (c Int32Col) To(v int32) Assignment

+ type Int32Expr struct

+ func ArrayPosition(list []string, v StringValue) Int32Expr

+ func CastInt32(e Expr) Int32Expr

+ func ConstInt32(n int32) Int32Expr

+ func Int32(n int32) Int32Expr

+ func Int32Of(e Expr) Int32Expr

+ func Int32Ptr(p *int32) Int32Expr

+ func NullInt32() Int32Expr

+ func WidthBucket(v Int64Value, bounds []int64) Int32Expr

+ func WidthBucketRange(v Float64Value, lo, hi float64, buckets int) Int32Expr

+ func (e Int32Expr) Abs() Int32Expr

+ func (e Int32Expr) Add(v Int32Value) Int32Expr

+ func (e Int32Expr) Asc() Order

+ func (e Int32Expr) Avg() Agg

+ func (e Int32Expr) Between(lo, hi int32) Pred

+ func (e Int32Expr) Coalesce(vs ...any) Int32Expr

+ func (e Int32Expr) Desc() Order

+ func (e Int32Expr) Div(v Int32Value) Int32Expr

+ func (e Int32Expr) Eq(v int32) Pred

+ func (e Int32Expr) EqExpr(o Int32Value) Pred

+ func (e Int32Expr) Greatest(others ...Int32Value) Int32Expr

+ func (e Int32Expr) Gt(v int32) Pred

+ func (e Int32Expr) GtExpr(o Int32Value) Pred

+ func (e Int32Expr) Gte(v int32) Pred

+ func (e Int32Expr) GteExpr(o Int32Value) Pred

+ func (e Int32Expr) In(vs ...int32) Pred

+ func (e Int32Expr) InArray(a Int32ArrayValue) Pred

+ func (e Int32Expr) IsDistinctFrom(v int32) Pred

+ func (e Int32Expr) IsDistinctFromExpr(o Int32Value) Pred

+ func (e Int32Expr) IsNotDistinctFrom(v int32) Pred

+ func (e Int32Expr) IsNotDistinctFromExpr(o Int32Value) Pred

+ func (e Int32Expr) IsNotNull() Pred

+ func (e Int32Expr) IsNull() Pred

+ func (e Int32Expr) Least(others ...Int32Value) Int32Expr

+ func (e Int32Expr) Lt(v int32) Pred

+ func (e Int32Expr) LtExpr(o Int32Value) Pred

+ func (e Int32Expr) Lte(v int32) Pred

+ func (e Int32Expr) LteExpr(o Int32Value) Pred

+ func (e Int32Expr) Max() Agg

+ func (e Int32Expr) Min() Agg

+ func (e Int32Expr) Mod(v Int32Value) Int32Expr

+ func (e Int32Expr) Mul(v Int32Value) Int32Expr

+ func (e Int32Expr) Ne(v int32) Pred

+ func (e Int32Expr) NeExpr(o Int32Value) Pred

+ func (e Int32Expr) Neg() Int32Expr

+ func (e Int32Expr) NotIn(vs ...int32) Pred

+ func (e Int32Expr) NotInArray(a Int32ArrayValue) Pred

+ func (e Int32Expr) NullIf(v int32) Int32Expr

+ func (e Int32Expr) Sub(v Int32Value) Int32Expr

+ func (e Int32Expr) Sum() Agg

+ type Int32Value interface

+ type Int64ArrayCase struct

+ func CaseInt64Array() Int64ArrayCase

+ func (b Int64ArrayCase) Else(v Int64ArrayValue) Int64ArrayExpr

+ func (b Int64ArrayCase) End() Int64ArrayExpr

+ func (b Int64ArrayCase) When(cond Pred, v Int64ArrayValue) Int64ArrayCase

+ type Int64ArrayCol struct

+ func (c Int64ArrayCol) Append(v int64) Assignment

+ func (c Int64ArrayCol) At(i int) Int64Expr

+ func (c Int64ArrayCol) ContainedBy(vs ...int64) Pred

+ func (c Int64ArrayCol) ContainedByExpr(o Int64ArrayValue) Pred

+ func (c Int64ArrayCol) ContainsAll(vs ...int64) Pred

+ func (c Int64ArrayCol) ContainsAllExpr(o Int64ArrayValue) Pred

+ func (c Int64ArrayCol) Has(v int64) Pred

+ func (c Int64ArrayCol) Len() Int32Expr

+ func (c Int64ArrayCol) Overlaps(vs ...int64) Pred

+ func (c Int64ArrayCol) OverlapsExpr(o Int64ArrayValue) Pred

+ func (c Int64ArrayCol) Remove(v int64) Assignment

+ func (c Int64ArrayCol) To(vs []int64) Assignment

+ func (c Int64ArrayCol) Unnest() Int64Expr

+ func (c Int64ArrayCol) Without(v Int64Value) Int64ArrayExpr

+ type Int64ArrayExpr struct

+ func ArrayOfInt64(es ...Int64Value) Int64ArrayExpr

+ func Int64Array(vs []int64) Int64ArrayExpr

+ func Int64ArrayOf(e Expr) Int64ArrayExpr

+ func (e Int64ArrayExpr) At(i int) Int64Expr

+ func (e Int64ArrayExpr) Coalesce(o Int64ArrayValue) Int64ArrayExpr

+ func (e Int64ArrayExpr) ContainedByExpr(o Int64ArrayValue) Pred

+ func (e Int64ArrayExpr) ContainsAllExpr(o Int64ArrayValue) Pred

+ func (e Int64ArrayExpr) IsNotNull() Pred

+ func (e Int64ArrayExpr) IsNull() Pred

+ func (e Int64ArrayExpr) Len() Int32Expr

+ func (e Int64ArrayExpr) NullIf(o Int64ArrayValue) Int64ArrayExpr

+ func (e Int64ArrayExpr) OverlapsExpr(o Int64ArrayValue) Pred

+ func (e Int64ArrayExpr) Unnest() Int64Expr

+ func (e Int64ArrayExpr) Without(v Int64Value) Int64ArrayExpr

+ type Int64ArrayValue interface

+ type Int64Case struct

+ func CaseInt64() Int64Case

+ func (b Int64Case) Else(v Int64Value) Int64Expr

+ func (b Int64Case) End() Int64Expr

+ func (b Int64Case) When(cond Pred, v Int64Value) Int64Case

+ type Int64Col struct

+ func (c Int64Col) Abs() Int64Expr

+ func (c Int64Col) Add(v Int64Value) Int64Expr

+ func (c Int64Col) Avg() Agg

+ func (c Int64Col) Between(lo, hi int64) Pred

+ func (c Int64Col) Coalesce(vs ...any) Int64Expr

+ func (c Int64Col) Div(v Int64Value) Int64Expr

+ func (c Int64Col) Eq(v int64) Pred

+ func (c Int64Col) Greatest(others ...Int64Value) Int64Expr

+ func (c Int64Col) Gt(v int64) Pred

+ func (c Int64Col) Gte(v int64) Pred

+ func (c Int64Col) In(vs ...int64) Pred

+ func (c Int64Col) InArray(a Int64ArrayValue) Pred

+ func (c Int64Col) Increment(v int64) Assignment

+ func (c Int64Col) IsDistinctFrom(v int64) Pred

+ func (c Int64Col) IsDistinctFromExpr(o Int64Value) Pred

+ func (c Int64Col) IsNotDistinctFrom(v int64) Pred

+ func (c Int64Col) IsNotDistinctFromExpr(o Int64Value) Pred

+ func (c Int64Col) Least(others ...Int64Value) Int64Expr

+ func (c Int64Col) Lt(v int64) Pred

+ func (c Int64Col) Lte(v int64) Pred

+ func (c Int64Col) Mod(v Int64Value) Int64Expr

+ func (c Int64Col) Mul(v Int64Value) Int64Expr

+ func (c Int64Col) Ne(v int64) Pred

+ func (c Int64Col) Neg() Int64Expr

+ func (c Int64Col) NotIn(vs ...int64) Pred

+ func (c Int64Col) NotInArray(a Int64ArrayValue) Pred

+ func (c Int64Col) NullIf(v int64) Int64Expr

+ func (c Int64Col) Sub(v Int64Value) Int64Expr

+ func (c Int64Col) Sum() Agg

+ func (c Int64Col) To(v int64) Assignment

+ type Int64Expr struct

+ func CastInt64(e Expr) Int64Expr

+ func ConstInt64(n int64) Int64Expr

+ func Epoch(t TimeValue) Int64Expr

+ func GenerateSeries(start, stop Int64Value) Int64Expr

+ func GenerateSeriesBy(start, stop, step Int64Value) Int64Expr

+ func Int64(n int64) Int64Expr

+ func Int64Of(e Expr) Int64Expr

+ func Int64Ptr(p *int64) Int64Expr

+ func NowEpoch() Int64Expr

+ func NullInt64() Int64Expr

+ func (e Int64Expr) Abs() Int64Expr

+ func (e Int64Expr) Add(v Int64Value) Int64Expr

+ func (e Int64Expr) Asc() Order

+ func (e Int64Expr) Avg() Agg

+ func (e Int64Expr) Between(lo, hi int64) Pred

+ func (e Int64Expr) Coalesce(vs ...any) Int64Expr

+ func (e Int64Expr) Desc() Order

+ func (e Int64Expr) Div(v Int64Value) Int64Expr

+ func (e Int64Expr) Eq(v int64) Pred

+ func (e Int64Expr) EqExpr(o Int64Value) Pred

+ func (e Int64Expr) Greatest(others ...Int64Value) Int64Expr

+ func (e Int64Expr) Gt(v int64) Pred

+ func (e Int64Expr) GtExpr(o Int64Value) Pred

+ func (e Int64Expr) Gte(v int64) Pred

+ func (e Int64Expr) GteExpr(o Int64Value) Pred

+ func (e Int64Expr) In(vs ...int64) Pred

+ func (e Int64Expr) InArray(a Int64ArrayValue) Pred

+ func (e Int64Expr) IsDistinctFrom(v int64) Pred

+ func (e Int64Expr) IsDistinctFromExpr(o Int64Value) Pred

+ func (e Int64Expr) IsNotDistinctFrom(v int64) Pred

+ func (e Int64Expr) IsNotDistinctFromExpr(o Int64Value) Pred

+ func (e Int64Expr) IsNotNull() Pred

+ func (e Int64Expr) IsNull() Pred

+ func (e Int64Expr) Least(others ...Int64Value) Int64Expr

+ func (e Int64Expr) Lt(v int64) Pred

+ func (e Int64Expr) LtExpr(o Int64Value) Pred

+ func (e Int64Expr) Lte(v int64) Pred

+ func (e Int64Expr) LteExpr(o Int64Value) Pred

+ func (e Int64Expr) Max() Agg

+ func (e Int64Expr) Min() Agg

+ func (e Int64Expr) Mod(v Int64Value) Int64Expr

+ func (e Int64Expr) Mul(v Int64Value) Int64Expr

+ func (e Int64Expr) Ne(v int64) Pred

+ func (e Int64Expr) NeExpr(o Int64Value) Pred

+ func (e Int64Expr) Neg() Int64Expr

+ func (e Int64Expr) NotIn(vs ...int64) Pred

+ func (e Int64Expr) NotInArray(a Int64ArrayValue) Pred

+ func (e Int64Expr) NullIf(v int64) Int64Expr

+ func (e Int64Expr) Sub(v Int64Value) Int64Expr

+ func (e Int64Expr) Sum() Agg

+ type Int64Range struct

+ func Int8Range(lo, hi Int64Value) Int64Range

+ func (g Int64Range) Covers(v Int64Value) Pred

+ func (g Int64Range) Overlaps(o Int64Range) Pred

+ type Int64Value interface

+ type Intercepted struct

+ Op Op

+ Read bool

+ Table *schema.Table

+ func (i *Intercepted) Where(ps ...Pred)

+ type Interceptor func(ctx context.Context, q *Intercepted) error

+ type IntervalCase struct

+ func CaseInterval() IntervalCase

+ func (b IntervalCase) Else(v IntervalValue) IntervalExpr

+ func (b IntervalCase) End() IntervalExpr

+ func (b IntervalCase) When(cond Pred, v IntervalValue) IntervalCase

+ type IntervalExpr struct

+ func CastInterval(e Expr) IntervalExpr

+ func Duration(d time.Duration) IntervalExpr

+ func Interval(s string) IntervalExpr

+ func IntervalOf(e Expr) IntervalExpr

+ func NullInterval() IntervalExpr

+ func (e IntervalExpr) Add(o IntervalValue) IntervalExpr

+ func (e IntervalExpr) Asc() Order

+ func (e IntervalExpr) Avg() Agg

+ func (e IntervalExpr) Desc() Order

+ func (e IntervalExpr) Div(n NumberValue) IntervalExpr

+ func (e IntervalExpr) EqExpr(o IntervalValue) Pred

+ func (e IntervalExpr) GtExpr(o IntervalValue) Pred

+ func (e IntervalExpr) GteExpr(o IntervalValue) Pred

+ func (e IntervalExpr) IsDistinctFromExpr(o IntervalValue) Pred

+ func (e IntervalExpr) IsNotDistinctFromExpr(o IntervalValue) Pred

+ func (e IntervalExpr) IsNotNull() Pred

+ func (e IntervalExpr) IsNull() Pred

+ func (e IntervalExpr) LtExpr(o IntervalValue) Pred

+ func (e IntervalExpr) LteExpr(o IntervalValue) Pred

+ func (e IntervalExpr) Max() Agg

+ func (e IntervalExpr) Min() Agg

+ func (e IntervalExpr) Mul(n NumberValue) IntervalExpr

+ func (e IntervalExpr) NeExpr(o IntervalValue) Pred

+ func (e IntervalExpr) Neg() IntervalExpr

+ func (e IntervalExpr) Seconds() Float64Expr

+ func (e IntervalExpr) Sub(o IntervalValue) IntervalExpr

+ func (e IntervalExpr) Sum() Agg

+ type IntervalValue interface

+ type Isolation uint8

+ const ReadCommitted

+ const RepeatableRead

+ const Serializable

+ func (l Isolation) String() string

+ type JSONBCase struct

+ func CaseJSONB() JSONBCase

+ func (b JSONBCase) Else(v JSONBValue) JSONBExpr

+ func (b JSONBCase) End() JSONBExpr

+ func (b JSONBCase) When(cond Pred, v JSONBValue) JSONBCase

+ type JSONBCol struct

+ func (c JSONBCol) ArrayElementsText() StringExpr

+ func (c JSONBCol) Coalesce(v any) JSONBExpr

+ func (c JSONBCol) Concat(o JSONBValue) JSONBExpr

+ func (c JSONBCol) Contains(v any) Pred

+ func (c JSONBCol) HasAllKeys(keys ...string) Pred

+ func (c JSONBCol) HasAnyKey(keys ...string) Pred

+ func (c JSONBCol) HasKey(key string) Pred

+ func (c JSONBCol) IsDistinctFromExpr(o JSONBValue) Pred

+ func (c JSONBCol) IsNotDistinctFromExpr(o JSONBValue) Pred

+ func (c JSONBCol) Path(path ...string) DynExpr

+ func (c JSONBCol) Set(path []string, v JSONBValue) JSONBExpr

+ func (c JSONBCol) Text(path ...string) StringExpr

+ func (c JSONBCol) To(v any) Assignment

+ func (c JSONBCol) TypeOf() StringExpr

+ type JSONBExpr struct

+ func CastJSONB(e Expr) JSONBExpr

+ func JSONB(v any) JSONBExpr

+ func JSONBOf(e Expr) JSONBExpr

+ func JSONBuildArray(vs ...any) JSONBExpr

+ func JSONBuildObject(pairs ...JSONPair) JSONBExpr

+ func NullJSONB() JSONBExpr

+ func (e JSONBExpr) ArrayElementsText() StringExpr

+ func (e JSONBExpr) Coalesce(v any) JSONBExpr

+ func (e JSONBExpr) Concat(o JSONBValue) JSONBExpr

+ func (e JSONBExpr) Contains(v any) Pred

+ func (e JSONBExpr) ContainsExpr(o JSONBValue) Pred

+ func (e JSONBExpr) HasKey(key string) Pred

+ func (e JSONBExpr) IsDistinctFromExpr(o JSONBValue) Pred

+ func (e JSONBExpr) IsNotDistinctFromExpr(o JSONBValue) Pred

+ func (e JSONBExpr) IsNotNull() Pred

+ func (e JSONBExpr) IsNull() Pred

+ func (e JSONBExpr) Set(path []string, v JSONBValue) JSONBExpr

+ func (e JSONBExpr) Text(path ...string) StringExpr

+ func (e JSONBExpr) TypeOf() StringExpr

+ type JSONBValue interface

+ type JSONCodec struct

+ Marshal func(v any) ([]byte, error)

+ Unmarshal func(data []byte, v any) error

+ UnmarshalNumber func(data []byte, v any) error

+ type JSONPair struct

+ func Pair(key string, v any) JSONPair

+ type LoadStrategy uint8

+ const LoadPerLevel

+ const LoadPipelined

+ type Loader interface

+ type LocalCache interface

+ Bytes func() int64

+ Get func(key string) ([]byte, bool)

+ Set func(key string, value []byte, ttl time.Duration)

+ func MemoryCache(maxBytes int64) LocalCache

+ type LockStrength string

+ type LockWait string

+ type Mutation struct

+ Old T

+ Op Op

+ Row T

+ func (m *Mutation[T]) Changed(c Column) bool

+ type NumberValue interface

+ type NumericArrayCase struct

+ func CaseNumericArray() NumericArrayCase

+ func (b NumericArrayCase) Else(v NumericArrayValue) NumericArrayExpr

+ func (b NumericArrayCase) End() NumericArrayExpr

+ func (b NumericArrayCase) When(cond Pred, v NumericArrayValue) NumericArrayCase

+ type NumericArrayExpr struct

+ func ArrayOfNumeric(es ...NumericValue) NumericArrayExpr

+ func NumericArray(vs any) NumericArrayExpr

+ func NumericArrayOf(e Expr) NumericArrayExpr

+ func (e NumericArrayExpr) At(i int) NumericExpr

+ func (e NumericArrayExpr) Coalesce(o NumericArrayValue) NumericArrayExpr

+ func (e NumericArrayExpr) ContainedByExpr(o NumericArrayValue) Pred

+ func (e NumericArrayExpr) ContainsAllExpr(o NumericArrayValue) Pred

+ func (e NumericArrayExpr) IsNotNull() Pred

+ func (e NumericArrayExpr) IsNull() Pred

+ func (e NumericArrayExpr) Len() Int32Expr

+ func (e NumericArrayExpr) NullIf(o NumericArrayValue) NumericArrayExpr

+ func (e NumericArrayExpr) OverlapsExpr(o NumericArrayValue) Pred

+ func (e NumericArrayExpr) Unnest() NumericExpr

+ func (e NumericArrayExpr) Without(v NumericValue) NumericArrayExpr

+ type NumericArrayValue interface

+ type NumericCase struct

+ func CaseNumeric() NumericCase

+ func (b NumericCase) Else(v NumericValue) NumericExpr

+ func (b NumericCase) End() NumericExpr

+ func (b NumericCase) When(cond Pred, v NumericValue) NumericCase

+ type NumericExpr struct

+ func CastNumeric(e Expr) NumericExpr

+ func ConstNumeric(s string) NumericExpr

+ func NullNumeric() NumericExpr

+ func Numeric(v any) NumericExpr

+ func NumericOf(e Expr) NumericExpr

+ func (e NumericExpr) Abs() NumericExpr

+ func (e NumericExpr) Add(v NumericValue) NumericExpr

+ func (e NumericExpr) Asc() Order

+ func (e NumericExpr) Avg() Agg

+ func (e NumericExpr) Between(lo, hi any) Pred

+ func (e NumericExpr) Ceil() NumericExpr

+ func (e NumericExpr) Coalesce(vs ...any) NumericExpr

+ func (e NumericExpr) Desc() Order

+ func (e NumericExpr) Div(v NumericValue) NumericExpr

+ func (e NumericExpr) Eq(v any) Pred

+ func (e NumericExpr) EqExpr(o NumericValue) Pred

+ func (e NumericExpr) Exp() NumericExpr

+ func (e NumericExpr) Floor() NumericExpr

+ func (e NumericExpr) Greatest(others ...NumericValue) NumericExpr

+ func (e NumericExpr) Gt(v any) Pred

+ func (e NumericExpr) GtExpr(o NumericValue) Pred

+ func (e NumericExpr) Gte(v any) Pred

+ func (e NumericExpr) GteExpr(o NumericValue) Pred

+ func (e NumericExpr) InArray(a NumericArrayValue) Pred

+ func (e NumericExpr) IsDistinctFrom(v any) Pred

+ func (e NumericExpr) IsDistinctFromExpr(o NumericValue) Pred

+ func (e NumericExpr) IsNotDistinctFrom(v any) Pred

+ func (e NumericExpr) IsNotDistinctFromExpr(o NumericValue) Pred

+ func (e NumericExpr) IsNotNull() Pred

+ func (e NumericExpr) IsNull() Pred

+ func (e NumericExpr) Least(others ...NumericValue) NumericExpr

+ func (e NumericExpr) Ln() NumericExpr

+ func (e NumericExpr) Lt(v any) Pred

+ func (e NumericExpr) LtExpr(o NumericValue) Pred

+ func (e NumericExpr) Lte(v any) Pred

+ func (e NumericExpr) LteExpr(o NumericValue) Pred

+ func (e NumericExpr) Max() Agg

+ func (e NumericExpr) Min() Agg

+ func (e NumericExpr) Mod(v NumericValue) NumericExpr

+ func (e NumericExpr) Mul(v NumericValue) NumericExpr

+ func (e NumericExpr) Ne(v any) Pred

+ func (e NumericExpr) NeExpr(o NumericValue) Pred

+ func (e NumericExpr) Neg() NumericExpr

+ func (e NumericExpr) NotInArray(a NumericArrayValue) Pred

+ func (e NumericExpr) NullIf(v any) NumericExpr

+ func (e NumericExpr) Round() NumericExpr

+ func (e NumericExpr) RoundTo(places int) NumericExpr

+ func (e NumericExpr) Sub(v NumericValue) NumericExpr

+ func (e NumericExpr) Sum() Agg

+ type NumericValue interface

+ type Observer interface

+ AfterQuery func(ctx context.Context, e *QueryEvent)

+ BeforeQuery func(ctx context.Context, e *QueryEvent) context.Context

+ func RecordShapes(w io.Writer) Observer

+ func RecordShapesFile(path string) (Observer, func() error, error)

+ type Op uint8

+ const OpCreate

+ const OpDelete

+ const OpRead

+ const OpUpdate

+ func (o Op) String() string

+ type Order struct

+ func Asc(e Expr) Order

+ func Desc(e Expr) Order

+ func (o Order) NullsFirst() Order

+ func (o Order) NullsLast() Order

+ type Page struct

+ Items []T

+ Next string

+ Total int64

+ TotalExact bool

+ func (p Page[T]) CursorAt(i int) string

+ type PageRequest struct

+ func After(cursor string, size int) PageRequest

+ func (p PageRequest) Estimate() PageRequest

+ func (p PageRequest) Total(limit int64) PageRequest

+ type Phase uint8

+ const AfterWrite

+ const BeforeWrite

+ const Committed

+ type Plan struct

+ ActualRows float64

+ ActualTime float64

+ ExecutionTime float64

+ JSON []byte

+ PlanningTime float64

+ Rows float64

+ TotalCost float64

+ func (p *Plan) Indexes() []string

+ func (p *Plan) SeqScans() []string

+ type PlanCache uint8

+ const PlanCacheAuto

+ const PlanCacheCustom

+ const PlanCacheOff

+ type PoolState struct

+ Acquired int32

+ Idle int32

+ Max int32

+ Total int32

+ type Position uint64

+ func CommitPosition(ctx context.Context, db *DB) Position

+ func ParsePosition(s string) (Position, error)

+ func (p Position) String() string

+ type PreAggStrategy uint8

+ const PreAggCTE

+ const PreAggLateral

+ type Pred interface

+ func And(ps ...Pred) Pred

+ func Exists(q subquery) Pred

+ func Not(p Pred) Pred

+ func NotExists(q subquery) Pred

+ func Or(ps ...Pred) Pred

+ func True() Pred

+ func When(cond bool, p Pred) Pred

+ type Projection interface

+ type Query struct

+ func (q *Query[T]) All(ctx context.Context, db *DB) ([]T, error)

+ func (q *Query[T]) AllTenants() *Query[T]

+ func (q *Query[T]) Any(ps ...Pred) Pred

+ func (q *Query[T]) Cache(opts ...CacheOption) *Query[T]

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

+ func (q *Query[T]) Compute(col Column, e Expr) *Query[T]

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

+ func (q *Query[T]) CountEstimate(ctx context.Context, db *DB, exactUpTo int64) (RowCount, error)

+ func (q *Query[T]) CountUpTo(ctx context.Context, db *DB, limit int64) (int64, error)

+ func (q *Query[T]) Cube(es ...Expr) *Query[T]

+ func (q *Query[T]) CustomPlan() *Query[T]

+ func (q *Query[T]) Delete(ctx context.Context, db *DB) (int64, error)

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

+ func (q *Query[T]) DistinctOn(es ...Expr) *Query[T]

+ func (q *Query[T]) Each(ctx context.Context, db *DB, size int, ...) error

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

+ func (q *Query[T]) Explain(ctx context.Context, db *DB, opts ExplainOptions) (*Plan, error)

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

+ func (q *Query[T]) Group(es ...Expr) *Query[T]

+ func (q *Query[T]) GroupingSets(sets ...[]Expr) *Query[T]

+ func (q *Query[T]) Having(ps ...Pred) *Query[T]

+ func (q *Query[T]) Join(t interface{ ... }, on ...Pred) *Query[T]

+ func (q *Query[T]) JoinLateral(sub interface{ ... }) *Query[T]

+ func (q *Query[T]) LeftJoin(t interface{ ... }, on ...Pred) *Query[T]

+ func (q *Query[T]) LeftJoinLateral(sub interface{ ... }) *Query[T]

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

+ func (q *Query[T]) List(ctx context.Context, db *DB) ([]T, error)

+ func (q *Query[T]) Load(ls ...Loader) *Query[T]

+ func (q *Query[T]) LoadStrategy(s LoadStrategy) *Query[T]

+ func (q *Query[T]) Lock(strength LockStrength, wait ...LockWait) *Query[T]

+ func (q *Query[T]) None(ps ...Pred) Pred

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

+ func (q *Query[T]) Omit(cols ...Column) *Query[T]

+ func (q *Query[T]) One(ctx context.Context, db *DB) (T, error)

+ func (q *Query[T]) Order(os ...Order) *Query[T]

+ func (q *Query[T]) Page(ctx context.Context, db *DB, p PageRequest) (Page[T], error)

+ func (q *Query[T]) Pick(es ...Expr) *Query[T]

+ func (q *Query[T]) Rollup(es ...Expr) *Query[T]

+ func (q *Query[T]) TableRef() *Ref

+ func (q *Query[T]) Timeout(d time.Duration) *Query[T]

+ func (q *Query[T]) ToSQL(ctx context.Context, db *DB) (string, []any, error)

+ func (q *Query[T]) Update(ctx context.Context, db *DB, sets ...Assignment) (int64, error)

+ func (q *Query[T]) UpdateReturning(ctx context.Context, db *DB, sets ...Assignment) ([]T, error)

+ func (q *Query[T]) Where(ps ...Pred) *Query[T]

+ func (q *Query[T]) Window(name string, w Window) *Query[T]

+ func (q *Query[T]) With(ctes ...*CTETable) *Query[T]

+ type QueryEvent struct

+ Args int

+ Duration time.Duration

+ Err error

+ Op string

+ Replica string

+ Rows int64

+ SQL string

+ Start time.Time

+ Table string

+ Tx bool

+ Values []any

+ type RawExpr struct

+ func Raw(sql string, args ...any) RawExpr

+ type ReadFilter func(ctx context.Context, t *schema.Table) ([]Pred, error)

+ type Ref struct

+ Table *schema.Table

+ type Registry struct

+ func NewRegistry(tables ...*schema.Table) (*Registry, error)

+ func (g *Registry) Query(name string) *DynQuery

+ func (g *Registry) Table(name string) (*schema.Table, bool)

+ func (g *Registry) Tables() []*schema.Table

+ type Repeat struct

+ CallSites []string

+ Count int

+ SQL string

+ type ReplicaConfig struct

+ DSN string

+ Pool *pgxpool.Config

+ Weight int

+ type ReplicaStats struct

+ CheckedAt time.Time

+ Err error

+ Healthy bool

+ InFlight int64

+ Lag time.Duration

+ Name string

+ Position Position

+ Reads uint64

+ Weight int

+ type Row struct

+ type RowCount struct

+ Exact bool

+ N int64

+ type RowsTable struct

+ func Rows(name string, columns []string, exprs ...Expr) *RowsTable

+ func (s *RowsTable) Col(name string) AnyCol

+ func (s *RowsTable) TableRef() *Ref

+ type SearchMode uint8

+ const AnyPrefix

+ const AnyWebSearch

+ const AnyWord

+ const Phrase

+ const Plain

+ const Prefix

+ const TSQuery

+ const WebSearch

+ type SearchOption func(*search)

+ func RankNormalization(mask int) SearchOption

+ func SearchAlso(mode SearchMode, text string) SearchOption

+ func SearchConfig(configs ...string) SearchOption

+ func SearchModes(modes ...SearchMode) SearchOption

+ type Shape struct

+ Args int

+ Op string

+ SQL string

+ Table string

+ func ReadShapes(r io.Reader) ([]Shape, error)

+ type SharedCache interface

+ Get func(ctx context.Context, key string) ([]byte, bool, error)

+ Set func(ctx context.Context, key string, value []byte, ttl time.Duration) error

+ type SlotHolder struct

+ Held time.Duration

+ Stack []string

+ type SlowWait struct

+ Holders []SlotHolder

+ Kind WaitKind

+ Limit int

+ Pool PoolState

+ Stack []string

+ Tenant string

+ Waited time.Duration

+ Waiters int

+ type SlowWaitConfig struct

+ After time.Duration

+ Report func(ctx context.Context, w *SlowWait)

+ type Statement struct

+ Args []any

+ SQL string

+ type StringArrayCase struct

+ func CaseStringArray() StringArrayCase

+ func (b StringArrayCase) Else(v StringArrayValue) StringArrayExpr

+ func (b StringArrayCase) End() StringArrayExpr

+ func (b StringArrayCase) When(cond Pred, v StringArrayValue) StringArrayCase

+ type StringArrayCol struct

+ func (c StringArrayCol) Append(v string) Assignment

+ func (c StringArrayCol) At(i int) StringExpr

+ func (c StringArrayCol) ContainedBy(vs ...string) Pred

+ func (c StringArrayCol) ContainedByExpr(o StringArrayValue) Pred

+ func (c StringArrayCol) ContainsAll(vs ...string) Pred

+ func (c StringArrayCol) ContainsAllExpr(o StringArrayValue) Pred

+ func (c StringArrayCol) Has(v string) Pred

+ func (c StringArrayCol) Len() Int32Expr

+ func (c StringArrayCol) Overlaps(vs ...string) Pred

+ func (c StringArrayCol) OverlapsExpr(o StringArrayValue) Pred

+ func (c StringArrayCol) Remove(v string) Assignment

+ func (c StringArrayCol) To(vs []string) Assignment

+ func (c StringArrayCol) Unnest() StringExpr

+ func (c StringArrayCol) Without(v StringValue) StringArrayExpr

+ type StringArrayExpr struct

+ func ArrayOfString(es ...StringValue) StringArrayExpr

+ func StringArrayOf(e Expr) StringArrayExpr

+ func TextArray(vs []string) StringArrayExpr

+ func (e StringArrayExpr) At(i int) StringExpr

+ func (e StringArrayExpr) Coalesce(o StringArrayValue) StringArrayExpr

+ func (e StringArrayExpr) ContainedByExpr(o StringArrayValue) Pred

+ func (e StringArrayExpr) ContainsAllExpr(o StringArrayValue) Pred

+ func (e StringArrayExpr) IsNotNull() Pred

+ func (e StringArrayExpr) IsNull() Pred

+ func (e StringArrayExpr) Len() Int32Expr

+ func (e StringArrayExpr) NullIf(o StringArrayValue) StringArrayExpr

+ func (e StringArrayExpr) OverlapsExpr(o StringArrayValue) Pred

+ func (e StringArrayExpr) Unnest() StringExpr

+ func (e StringArrayExpr) Without(v StringValue) StringArrayExpr

+ type StringArrayValue interface

+ type StringCase struct

+ func CaseString() StringCase

+ func (b StringCase) Else(v StringValue) StringExpr

+ func (b StringCase) End() StringExpr

+ func (b StringCase) When(cond Pred, v StringValue) StringCase

+ type StringCol struct

+ func (c StringCol) Between(lo, hi string) Pred

+ func (c StringCol) Cat(vs ...StringValue) StringExpr

+ func (c StringCol) Coalesce(vs ...any) StringExpr

+ func (c StringCol) Collate(name string) StringExpr

+ func (c StringCol) Contains(s string) Pred

+ func (c StringCol) ContainsFold(s string) Pred

+ func (c StringCol) Eq(v string) Pred

+ func (c StringCol) Greatest(others ...StringValue) StringExpr

+ func (c StringCol) Gt(v string) Pred

+ func (c StringCol) Gte(v string) Pred

+ func (c StringCol) HasPrefix(s string) Pred

+ func (c StringCol) HasPrefixFold(s string) Pred

+ func (c StringCol) HasSuffix(s string) Pred

+ func (c StringCol) ILike(pattern string) Pred

+ func (c StringCol) ILikeExpr(pattern StringValue) Pred

+ func (c StringCol) In(vs ...string) Pred

+ func (c StringCol) InArray(a StringArrayValue) Pred

+ func (c StringCol) IsDistinctFrom(v string) Pred

+ func (c StringCol) IsDistinctFromExpr(o StringValue) Pred

+ func (c StringCol) IsNotDistinctFrom(v string) Pred

+ func (c StringCol) IsNotDistinctFromExpr(o StringValue) Pred

+ func (c StringCol) LTrim() StringExpr

+ func (c StringCol) LTrimChars(chars string) StringExpr

+ func (c StringCol) Least(others ...StringValue) StringExpr

+ func (c StringCol) Left(n int) StringExpr

+ func (c StringCol) Length() Int32Expr

+ func (c StringCol) Like(pattern string) Pred

+ func (c StringCol) LikeExpr(pattern StringValue) Pred

+ func (c StringCol) Lower() StringExpr

+ func (c StringCol) Lt(v string) Pred

+ func (c StringCol) Lte(v string) Pred

+ func (c StringCol) MD5() StringExpr

+ func (c StringCol) Match(re string) Pred

+ func (c StringCol) MatchFold(re string) Pred

+ func (c StringCol) Ne(v string) Pred

+ func (c StringCol) NotIn(vs ...string) Pred

+ func (c StringCol) NotInArray(a StringArrayValue) Pred

+ func (c StringCol) NullIf(v string) StringExpr

+ func (c StringCol) RTrim() StringExpr

+ func (c StringCol) RTrimChars(chars string) StringExpr

+ func (c StringCol) RegexpReplace(pattern, replacement, flags string) StringExpr

+ func (c StringCol) Replace(from, to string) StringExpr

+ func (c StringCol) Right(n int) StringExpr

+ func (c StringCol) SplitPart(delim string, n int) StringExpr

+ func (c StringCol) SplitPartExpr(delim StringValue, n Int32Value) StringExpr

+ func (c StringCol) Substr(start, count int) StringExpr

+ func (c StringCol) SubstrFrom(start int) StringExpr

+ func (c StringCol) To(v string) Assignment

+ func (c StringCol) Trim() StringExpr

+ func (c StringCol) TrimChars(chars string) StringExpr

+ func (c StringCol) Upper() StringExpr

+ type StringExpr struct

+ func CastText(e Expr) StringExpr

+ func Concat(args ...any) StringExpr

+ func ConcatWS(sep string, args ...any) StringExpr

+ func ConstText(s string) StringExpr

+ func GenRandomUUID() StringExpr

+ func NullText() StringExpr

+ func StringOf(e Expr) StringExpr

+ func Text(s string) StringExpr

+ func TextPtr(p *string) StringExpr

+ func (e StringExpr) Asc() Order

+ func (e StringExpr) Between(lo, hi string) Pred

+ func (e StringExpr) Cat(vs ...StringValue) StringExpr

+ func (e StringExpr) Coalesce(vs ...any) StringExpr

+ func (e StringExpr) Collate(name string) StringExpr

+ func (e StringExpr) Contains(s string) Pred

+ func (e StringExpr) ContainsFold(s string) Pred

+ func (e StringExpr) Desc() Order

+ func (e StringExpr) Eq(v string) Pred

+ func (e StringExpr) EqExpr(o StringValue) Pred

+ func (e StringExpr) Greatest(others ...StringValue) StringExpr

+ func (e StringExpr) Gt(v string) Pred

+ func (e StringExpr) GtExpr(o StringValue) Pred

+ func (e StringExpr) Gte(v string) Pred

+ func (e StringExpr) GteExpr(o StringValue) Pred

+ func (e StringExpr) HasPrefix(s string) Pred

+ func (e StringExpr) HasPrefixFold(s string) Pred

+ func (e StringExpr) HasSuffix(s string) Pred

+ func (e StringExpr) ILike(p string) Pred

+ func (e StringExpr) ILikeExpr(p StringValue) Pred

+ func (e StringExpr) In(vs ...string) Pred

+ func (e StringExpr) InArray(a StringArrayValue) Pred

+ func (e StringExpr) IsDistinctFrom(v string) Pred

+ func (e StringExpr) IsDistinctFromExpr(o StringValue) Pred

+ func (e StringExpr) IsNotDistinctFrom(v string) Pred

+ func (e StringExpr) IsNotDistinctFromExpr(o StringValue) Pred

+ func (e StringExpr) IsNotNull() Pred

+ func (e StringExpr) IsNull() Pred

+ func (e StringExpr) LTrim() StringExpr

+ func (e StringExpr) LTrimChars(chars string) StringExpr

+ func (e StringExpr) Least(others ...StringValue) StringExpr

+ func (e StringExpr) Left(n int) StringExpr

+ func (e StringExpr) Length() Int32Expr

+ func (e StringExpr) Like(p string) Pred

+ func (e StringExpr) LikeExpr(p StringValue) Pred

+ func (e StringExpr) Lower() StringExpr

+ func (e StringExpr) Lt(v string) Pred

+ func (e StringExpr) LtExpr(o StringValue) Pred

+ func (e StringExpr) Lte(v string) Pred

+ func (e StringExpr) LteExpr(o StringValue) Pred

+ func (e StringExpr) MD5() StringExpr

+ func (e StringExpr) Match(re string) Pred

+ func (e StringExpr) MatchFold(re string) Pred

+ func (e StringExpr) Max() Agg

+ func (e StringExpr) Min() Agg

+ func (e StringExpr) Ne(v string) Pred

+ func (e StringExpr) NeExpr(o StringValue) Pred

+ func (e StringExpr) NotIn(vs ...string) Pred

+ func (e StringExpr) NotInArray(a StringArrayValue) Pred

+ func (e StringExpr) NullIf(v string) StringExpr

+ func (e StringExpr) RTrim() StringExpr

+ func (e StringExpr) RTrimChars(chars string) StringExpr

+ func (e StringExpr) RegexpReplace(pattern, replacement, flags string) StringExpr

+ func (e StringExpr) Replace(from, to string) StringExpr

+ func (e StringExpr) Right(n int) StringExpr

+ func (e StringExpr) SplitPart(delim string, n int) StringExpr

+ func (e StringExpr) SplitPartExpr(delim StringValue, n Int32Value) StringExpr

+ func (e StringExpr) Substr(start, count int) StringExpr

+ func (e StringExpr) SubstrFrom(start int) StringExpr

+ func (e StringExpr) Trim() StringExpr

+ func (e StringExpr) TrimChars(chars string) StringExpr

+ func (e StringExpr) Upper() StringExpr

+ type StringValue interface

+ type TSVectorCol struct

+ func (c TSVectorCol) Match(query string, opts ...SearchOption) Pred

+ func (c TSVectorCol) Rank(query string, opts ...SearchOption) Agg

+ func (c TSVectorCol) RankCD(query string, opts ...SearchOption) Agg

+ type Table struct

+ type TimeArrayCase struct

+ func CaseTimeArray() TimeArrayCase

+ func (b TimeArrayCase) Else(v TimeArrayValue) TimeArrayExpr

+ func (b TimeArrayCase) End() TimeArrayExpr

+ func (b TimeArrayCase) When(cond Pred, v TimeArrayValue) TimeArrayCase

+ type TimeArrayExpr struct

+ func ArrayOfTime(es ...TimeValue) TimeArrayExpr

+ func TimeArray(vs []time.Time) TimeArrayExpr

+ func TimeArrayOf(e Expr) TimeArrayExpr

+ func (e TimeArrayExpr) At(i int) TimeExpr

+ func (e TimeArrayExpr) Coalesce(o TimeArrayValue) TimeArrayExpr

+ func (e TimeArrayExpr) ContainedByExpr(o TimeArrayValue) Pred

+ func (e TimeArrayExpr) ContainsAllExpr(o TimeArrayValue) Pred

+ func (e TimeArrayExpr) IsNotNull() Pred

+ func (e TimeArrayExpr) IsNull() Pred

+ func (e TimeArrayExpr) Len() Int32Expr

+ func (e TimeArrayExpr) NullIf(o TimeArrayValue) TimeArrayExpr

+ func (e TimeArrayExpr) OverlapsExpr(o TimeArrayValue) Pred

+ func (e TimeArrayExpr) Unnest() TimeExpr

+ func (e TimeArrayExpr) Without(v TimeValue) TimeArrayExpr

+ type TimeArrayValue interface

+ type TimeCase struct

+ func CaseTime() TimeCase

+ func (b TimeCase) Else(v TimeValue) TimeExpr

+ func (b TimeCase) End() TimeExpr

+ func (b TimeCase) When(cond Pred, v TimeValue) TimeCase

+ type TimeCol struct

+ func (c TimeCol) Add(i IntervalValue) TimeExpr

+ func (c TimeCol) AtTimeZone(zone StringValue) TimeExpr

+ func (c TimeCol) Between(lo, hi time.Time) Pred

+ func (c TimeCol) Coalesce(vs ...any) TimeExpr

+ func (c TimeCol) Eq(v time.Time) Pred

+ func (c TimeCol) Greatest(others ...TimeValue) TimeExpr

+ func (c TimeCol) Gt(v time.Time) Pred

+ func (c TimeCol) Gte(v time.Time) Pred

+ func (c TimeCol) InArray(a TimeArrayValue) Pred

+ func (c TimeCol) IsDistinctFrom(v time.Time) Pred

+ func (c TimeCol) IsDistinctFromExpr(o TimeValue) Pred

+ func (c TimeCol) IsNotDistinctFrom(v time.Time) Pred

+ func (c TimeCol) IsNotDistinctFromExpr(o TimeValue) Pred

+ func (c TimeCol) Least(others ...TimeValue) TimeExpr

+ func (c TimeCol) Lt(v time.Time) Pred

+ func (c TimeCol) Lte(v time.Time) Pred

+ func (c TimeCol) Ne(v time.Time) Pred

+ func (c TimeCol) NotInArray(a TimeArrayValue) Pred

+ func (c TimeCol) Since(u TimeValue) IntervalExpr

+ func (c TimeCol) Sub(i IntervalValue) TimeExpr

+ func (c TimeCol) To(v time.Time) Assignment

+ func (c TimeCol) ToChar(format string) StringExpr

+ type TimeExpr struct

+ func CastTime(e Expr) TimeExpr

+ func DateTrunc(field string, t TimeValue) TimeExpr

+ func GenerateTimeSeries(start, stop TimeValue, step string) TimeExpr

+ func Now() TimeExpr

+ func NullTime() TimeExpr

+ func Time(t time.Time) TimeExpr

+ func TimeOf(e Expr) TimeExpr

+ func TimePtr(p *time.Time) TimeExpr

+ func ToTimestamp(seconds NumberValue) TimeExpr

+ func (e TimeExpr) Add(i IntervalValue) TimeExpr

+ func (e TimeExpr) Asc() Order

+ func (e TimeExpr) AtTimeZone(zone StringValue) TimeExpr

+ func (e TimeExpr) Between(lo, hi time.Time) Pred

+ func (e TimeExpr) Coalesce(vs ...any) TimeExpr

+ func (e TimeExpr) Desc() Order

+ func (e TimeExpr) Eq(v time.Time) Pred

+ func (e TimeExpr) EqExpr(o TimeValue) Pred

+ func (e TimeExpr) Greatest(others ...TimeValue) TimeExpr

+ func (e TimeExpr) Gt(v time.Time) Pred

+ func (e TimeExpr) GtExpr(o TimeValue) Pred

+ func (e TimeExpr) Gte(v time.Time) Pred

+ func (e TimeExpr) GteExpr(o TimeValue) Pred

+ func (e TimeExpr) InArray(a TimeArrayValue) Pred

+ func (e TimeExpr) IsDistinctFrom(v time.Time) Pred

+ func (e TimeExpr) IsDistinctFromExpr(o TimeValue) Pred

+ func (e TimeExpr) IsNotDistinctFrom(v time.Time) Pred

+ func (e TimeExpr) IsNotDistinctFromExpr(o TimeValue) Pred

+ func (e TimeExpr) IsNotNull() Pred

+ func (e TimeExpr) IsNull() Pred

+ func (e TimeExpr) Least(others ...TimeValue) TimeExpr

+ func (e TimeExpr) Lt(v time.Time) Pred

+ func (e TimeExpr) LtExpr(o TimeValue) Pred

+ func (e TimeExpr) Lte(v time.Time) Pred

+ func (e TimeExpr) LteExpr(o TimeValue) Pred

+ func (e TimeExpr) Max() Agg

+ func (e TimeExpr) Min() Agg

+ func (e TimeExpr) Ne(v time.Time) Pred

+ func (e TimeExpr) NeExpr(o TimeValue) Pred

+ func (e TimeExpr) NotInArray(a TimeArrayValue) Pred

+ func (e TimeExpr) Since(u TimeValue) IntervalExpr

+ func (e TimeExpr) Sub(i IntervalValue) TimeExpr

+ func (e TimeExpr) ToChar(format string) StringExpr

+ type TimeValue interface

+ type TupleExpr struct

+ func Tuple(vs ...any) TupleExpr

+ func (w TupleExpr) Eq(o TupleExpr) Pred

+ func (w TupleExpr) Gt(o TupleExpr) Pred

+ func (w TupleExpr) Gte(o TupleExpr) Pred

+ func (w TupleExpr) InUnnest(arrays ...Expr) Pred

+ func (w TupleExpr) IsDistinctFrom(o TupleExpr) Pred

+ func (w TupleExpr) IsNotDistinctFrom(o TupleExpr) Pred

+ func (w TupleExpr) Lt(o TupleExpr) Pred

+ func (w TupleExpr) Lte(o TupleExpr) Pred

+ func (w TupleExpr) Ne(o TupleExpr) Pred

+ type TxInfo struct

+ Implicit bool

+ ReadOnly bool

+ type TxOption interface

+ func Detached() TxOption

+ func LockTimeout(d time.Duration) TxOption

+ func ReplicaTx() TxOption

+ func Retry(n int) TxOption

+ func Setting(name, value string) TxOption

+ type ValueType uint8

+ const TypeBool

+ const TypeBytes

+ const TypeDate

+ const TypeFloat64

+ const TypeInt64

+ const TypeJSON

+ const TypeNumeric

+ const TypeString

+ const TypeTime

+ func (t ValueType) String() string

+ type WaitKind uint8

+ const WaitCacheFill

+ const WaitConnection

+ const WaitTenantSlot

+ func (k WaitKind) String() string

+ type Window struct

+ func NamedWindow(name string) Window

+ func OrderBy(os ...Order) Window

+ func PartitionBy(es ...Expr) Window

+ func (w Window) Exclude(x FrameExclusion) Window

+ func (w Window) Groups(start, end FrameBound) Window

+ func (w Window) OrderBy(os ...Order) Window

+ func (w Window) PartitionBy(es ...Expr) Window

+ func (w Window) Range(start, end FrameBound) Window

+ func (w Window) Rows(start, end FrameBound) Window

v0.4.2

Oct 26, 2026

retracted

v0.4.1

Oct 26, 2026

retracted

v0.4.0

Oct 26, 2026

v0.3.0

Oct 26, 2026

v0.2.0

Oct 26, 2026

v0.1.0

Oct 26, 2026

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL