momo

package module

Go to main page

Versions in this module

v0

v0.11.0

Nov 13, 2026

v0.10.0

Nov 13, 2026

v0.9.0

Nov 13, 2026

v0.8.0

Nov 12, 2026

Changes in this version

+ func RelAlias(level int) string

+ func ScanDelete[R, T any](ctx context.Context, d DeleteQuery[T]) ([]R, error)

+ func ScanUpdate[R, T any](ctx context.Context, u UpdateQuery[T]) ([]R, error)

+ type ColumnRows interface

+ func RawRows(ctx context.Context, q Querier, sql string, args ...any) (ColumnRows, error)

type Config

+ func (c *Config) Generated(field any, expr string)

+ func (c *Config) GeneratedVirtual(field any, expr string)

type ExprSelect

+ func (s ExprSelect) CrossJoin(src TableSource) ExprSelect

+ func (s ExprSelect) GroupBy(es ...Expr) ExprSelect

+ func (s ExprSelect) Having(ps ...Predicate) ExprSelect

+ func (s ExprSelect) Join(src TableSource, on ...Predicate) ExprSelect

+ func (s ExprSelect) LeftJoin(src TableSource, on ...Predicate) ExprSelect

+ func (s ExprSelect) OrderBy(items ...Orderable) ExprSelect

type Expression

+ func ArrayOf[T any](elems ...Expression[T]) Expression[[]T]

+ func ArraySubquery[T any](sub Subquery) Expression[[]T]

+ type FieldNamer interface

+ ColumnName func(goField string) string

+ type LitExpr struct

+ func Lit[T Literal](v T) LitExpr[T]

+ func (l LitExpr[T]) AppendSQL(b *Builder)

+ func (l LitExpr[T]) As(alias string) Aliased[T]

+ type Literal interface

type NullColumn

+ func (c NullColumn[T]) EqPtr(v *T) Predicate

+ func (c NullColumn[T]) SetPtr(v *T) Assignment

type NullReadOnlyColumn

+ func (c NullReadOnlyColumn[T]) EqPtr(v *T) Predicate

type Option

+ func WithNaming(n FieldNamer) Option

+ type PredicateOrder struct

+ func OrderByPredicate(p Predicate) PredicateOrder

+ func (o PredicateOrder) Asc() Order

+ func (o PredicateOrder) Desc() Order

+ type RowExpr struct

+ func Row(elems ...Expr) RowExpr

+ func (r RowExpr) AppendSQL(b *Builder)

+ func (r RowExpr) Ge(other RowExpr) Predicate

+ func (r RowExpr) Gt(other RowExpr) Predicate

+ func (r RowExpr) Le(other RowExpr) Predicate

+ func (r RowExpr) Lt(other RowExpr) Predicate

+ type UnionQuery struct

+ func SelectUnion[T any](q Querier, all bool, members ...Subquery) UnionQuery[T]

+ func (u UnionQuery[T]) All(ctx context.Context) ([]T, error)

+ func (u UnionQuery[T]) Limit(n int64) UnionQuery[T]

+ func (u UnionQuery[T]) Offset(n int64) UnionQuery[T]

+ func (u UnionQuery[T]) OrderBy(items ...Orderable) UnionQuery[T]

+ func (u UnionQuery[T]) Rows(ctx context.Context) iter.Seq2[T, error]

+ func (u UnionQuery[T]) SQL() (Compiled, error)

+ type UnnestColumnSource struct

+ func UnnestColumn[T any](col Expression[[]T]) UnnestColumnSource[T]

+ func (u UnnestColumnSource[T]) As(alias, col string) UnnestColumnSource[T]

+ func (u UnnestColumnSource[T]) Column() Column[T]

+ func (u UnnestColumnSource[T]) Qualifier() string

v0.7.0

Nov 11, 2026

Changes in this version

type DeleteQuery

+ func (d DeleteQuery[T]) One(ctx context.Context) (T, error)

type InsertQuery

+ func (q InsertQuery[T]) One(ctx context.Context) (T, error)

type UpdateQuery

+ func (u UpdateQuery[T]) One(ctx context.Context) (T, error)

v0.6.0

Nov 10, 2026

Changes in this version

+ func RefreshMaterializedView(ctx context.Context, q Querier, name string, concurrently bool) error

v0.5.0

Nov 10, 2026

Changes in this version

+ const DefaultHybridCandidates

+ const DefaultHybridRRFK

+ const FlagDBDefault

+ func Explain(ctx context.Context, q Querier, c Compiled) ([]string, error)

+ func ExplainAnalyze(ctx context.Context, q Querier, c Compiled) ([]string, error)

+ func QueryRows[T any, PT Modeler[T]](ctx context.Context, q Querier, sql string, args ...any) iter.Seq2[T, error]

+ func Query[T any, PT Modeler[T]](ctx context.Context, q Querier, sql string, args ...any) ([]T, error)

+ func RegisterQuery(name string, build func(q Querier) Compilable)

+ type Compilable interface

+ SQL func() (Compiled, error)

+ func RawQuery(q Querier, sql string, args ...any) Compilable

type Config

+ func (c *Config) FKName(field any, name string)

+ func (c *Config) ForeignKey(name string, cols []any, refTable string, refColumns []string) *ForeignKeyOpts

+ func (c *Config) PrimaryKey(fields ...any)

type DB

+ func NewOffline(d dialect.Name) *DB

+ func (db *DB) IsPinned() bool

type DeleteQuery

+ func (d DeleteQuery[T]) AppendSQL(b *Builder)

+ func (d DeleteQuery[T]) Using(src TableSource) DeleteQuery[T]

+ func (d DeleteQuery[T]) With(name string, q Subquery, cols ...string) DeleteQuery[T]

+ func (d DeleteQuery[T]) WithRecursive(name string, q Subquery, cols ...string) DeleteQuery[T]

+ type ForeignKeyOpts struct

+ func (o *ForeignKeyOpts) OnDelete(action string) *ForeignKeyOpts

+ func (o *ForeignKeyOpts) OnUpdate(action string) *ForeignKeyOpts

+ type HybridQuery struct

+ func HybridSearch[T any, PT Modeler[T]](q Querier, spec HybridSpec) HybridQuery[T]

+ func (h HybridQuery[T]) All(ctx context.Context) ([]HybridResult[T], error)

+ func (h HybridQuery[T]) SQL() (Compiled, error)

+ type HybridResult struct

+ Row T

+ Score float64

+ type HybridSpec struct

+ Limit int

+ Query string

+ QueryVector vector.Vector

+ RRFK int

+ Text Column[string]

+ TextCandidates int

+ TextConfig string

+ Vector VectorColumn[vector.Vector]

+ VectorCandidates int

type IndexOpts

+ func (o *IndexOpts) Unique() *IndexOpts

type InsertQuery

+ func (q InsertQuery[T]) AppendSQL(b *Builder)

+ func (q InsertQuery[T]) With(name string, body Subquery, cols ...string) InsertQuery[T]

+ func (q InsertQuery[T]) WithRecursive(name string, body Subquery, cols ...string) InsertQuery[T]

type Meta

+ View bool

+ type QueryRegistry struct

+ func DefaultQueries() *QueryRegistry

+ func NewQueryRegistry() *QueryRegistry

+ func (r *QueryRegistry) Compile(d dialect.Name) ([]RegisteredQuery, error)

+ func (r *QueryRegistry) Names() []string

+ func (r *QueryRegistry) Register(name string, build func(q Querier) Compilable)

+ type RegisteredQuery struct

+ Name string

+ SQL string

type SelectQuery

+ func (sq SelectQuery[T]) ForKeyShare(opt ...string) SelectQuery[T]

+ func (sq SelectQuery[T]) ForNoKeyUpdate(opt ...string) SelectQuery[T]

type UpdateQuery

+ func (u UpdateQuery[T]) AppendSQL(b *Builder)

+ func (u UpdateQuery[T]) From(src TableSource) UpdateQuery[T]

+ func (u UpdateQuery[T]) With(name string, q Subquery, cols ...string) UpdateQuery[T]

+ func (u UpdateQuery[T]) WithRecursive(name string, q Subquery, cols ...string) UpdateQuery[T]

+ type View struct

v0.4.0

Nov 10, 2026

Changes in this version

+ const RedactedArg

+ var ErrCanceled = errors.New("momo: operation canceled")

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

+ func Batches[T any](ctx context.Context, sq SelectQuery[T], n int, fn func([]T) error) error

+ func FindAndCount[T any](ctx context.Context, sq SelectQuery[T]) ([]T, int64, error)

+ func FirstID[T any](ctx context.Context, sq SelectQuery[T]) (int64, error)

+ func FlagsOf(e Expr) uint16

+ func IDs[T any](ctx context.Context, sq SelectQuery[T]) ([]int64, error)

+ func IsBound(e Expr) bool

+ func LoadCounts[P, C any](ctx context.Context, q Querier, parents []P, rel Relation[P, C], ...) ([]int64, error)

+ func MapRows(ctx context.Context, q Querier, sql string, args ...any) ([]map[string]any, error)

+ func MySQLVectorType(flavor dialect.Flavor, serverVersion string, dim int) (string, error)

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

+ func Pluck[T, V any](ctx context.Context, sq SelectQuery[T], c Expression[V]) ([]V, error)

+ func SQLiteBitsType(column string, n int) (string, error)

+ func SQLiteVectorType(column string, dim int) (string, error)

+ func SetConfigLocal(ctx context.Context, tx *Tx, key, value string) error

+ func Truncate[T any, PT Modeler[T]](ctx context.Context, q Querier) error

+ func ValidName(s string) error

+ func ValidTypeName(s string) error

+ func WithDetail(err error, detail string) error

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

+ func WithTenant(ctx context.Context, tenant any) context.Context

type Agg

+ func (a Agg[T]) Filter(p Predicate) FilteredAgg[T]

+ func (a Agg[T]) Over(w WindowSpec) WindowExpr[T]

type Builder

+ func (b *Builder) AppendFilter(p Predicate)

+ func (b *Builder) ArgFor(flags uint16, v any)

+ func (b *Builder) ExprFor(flags uint16, e Expr)

+ func (b *Builder) MarkSensitive()

+ func (b *Builder) RenderSensitive(e Expr, flags uint16) uint16

+ func (b *Builder) Unsupported(feature string)

type Column

+ func (c Column) ParseCmp(op, raw string) (Predicate, error)

+ func (c Column) ParseEq(raw string) (Predicate, error)

+ type ColumnNamer interface

+ Columns func() ([]string, error)

type ColumnRef

+ ParseCmp func(op, raw string) (Predicate, error)

+ ParseEq func(raw string) (Predicate, error)

type Config

+ func (c *Config) IDGen(field any, name string)

type CreateOnlyColumn

+ func (c CreateOnlyColumn) ParseCmp(op, raw string) (Predicate, error)

+ func (c CreateOnlyColumn) ParseEq(raw string) (Predicate, error)

type CreateOnlyVectorColumn

+ func (c CreateOnlyVectorColumn) ParseCmp(string, string) (Predicate, error)

+ func (c CreateOnlyVectorColumn) ParseEq(string) (Predicate, error)

type DB

+ func (db *DB) Replica(i int) (*DB, error)

type Expression

+ func JoinTypedSQL[T any](sep string, parts ...Expr) Expression[T]

+ func Typed[T any](e Expr) Expression[T]

+ type Filter struct

+ And []Filter

+ Field string

+ Not *Filter

+ Op string

+ Or []Filter

+ Value any

+ func (f Filter) Predicate(al Allowlist) (Predicate, error)

+ type FilteredAgg struct

+ func (f FilteredAgg[T]) AppendSQL(b *Builder)

+ func (f FilteredAgg[T]) As(alias string) Aliased[T]

+ func (f FilteredAgg[T]) Over(w WindowSpec) WindowExpr[T]

+ type Flagged interface

+ Flags func() uint16

+ type FrameBound struct

+ func CurrentRow() FrameBound

+ func Following(n int) FrameBound

+ func Preceding(n int) FrameBound

+ func UnboundedFollowing() FrameBound

+ func UnboundedPreceding() FrameBound

type Hook

+ func NewNPlusOneHook(threshold int, report func(NPlusOneFinding)) Hook

+ type HookSet struct

+ AfterLoad func(ctx context.Context, m *T) error

+ BeforeDelete func(ctx context.Context, m *T) error

+ BeforeInsert func(ctx context.Context, m *T) error

+ BeforeUpdate func(ctx context.Context, m *T) error

+ type IDGen struct

+ Column int

+ Name string

type ImmutableColumn

+ func (c ImmutableColumn) ParseCmp(op, raw string) (Predicate, error)

+ func (c ImmutableColumn) ParseEq(raw string) (Predicate, error)

type ImmutableVectorColumn

+ func (c ImmutableVectorColumn) ParseCmp(string, string) (Predicate, error)

+ func (c ImmutableVectorColumn) ParseEq(string) (Predicate, error)

+ type InsertIDExecer interface

+ ExecInsertID func(ctx context.Context, sql string, args []any) (rows, lastInsertID int64, err error)

type InsertQuery

+ func (q InsertQuery[T]) Copy(ctx context.Context, ms []T) (Result, error)

+ func (q InsertQuery[T]) Unnest() InsertQuery[T]

+ type Interceptor func(ctx context.Context, op *Operation) error

+ type MergeQuery struct

+ func Merge[T any, PT Modeler[T]](q Querier, source Subquery) MergeQuery[T]

+ func (m MergeQuery[T]) Exec(ctx context.Context) (Result, error)

+ func (m MergeQuery[T]) On(ps ...Predicate) MergeQuery[T]

+ func (m MergeQuery[T]) Returning(cols ...ColumnRef) MergeQuery[T]

+ func (m MergeQuery[T]) Rows(ctx context.Context) (*ModelRows[T], error)

+ func (m MergeQuery[T]) SQL() (Compiled, error)

+ func (m MergeQuery[T]) WhenMatchedUpdate(assigns ...Assignment) MergeQuery[T]

+ func (m MergeQuery[T]) WhenNotMatchedInsert(cols []ColumnRef, values ...Expr) MergeQuery[T]

type Meta

+ Hooks HookSet[T]

+ IDGens []IDGen

+ type NPlusOneFinding struct

+ Count int

+ Example string

+ Shape string

type NullColumn

+ func (c NullColumn) AppendSQL(b *Builder)

+ func (c NullColumn) AsExpr() Expression[T]

+ func (c NullColumn) Asc() Order

+ func (c NullColumn) ColumnName() string

+ func (c NullColumn) Desc() Order

+ func (c NullColumn) Excluded() ExcludedExpr[T]

+ func (c NullColumn) Flags() uint16

+ func (c NullColumn) ParseCmp(op, raw string) (Predicate, error)

+ func (c NullColumn) ParseEq(raw string) (Predicate, error)

+ func (c NullColumn) Table() string

type NullReadOnlyColumn

+ func (c NullReadOnlyColumn) ParseCmp(op, raw string) (Predicate, error)

+ func (c NullReadOnlyColumn) ParseEq(raw string) (Predicate, error)

type NullVectorColumn

+ func (c NullVectorColumn) ParseCmp(string, string) (Predicate, error)

+ func (c NullVectorColumn) ParseEq(string) (Predicate, error)

+ type Operation struct

+ Kind string

+ Table string

+ Where []Predicate

+ type Ops struct

+ func NewOps[T any](host Expr) Ops[T]

+ func (o Ops[T]) Asc() Order

+ func (o Ops[T]) Between(lo, hi T) Predicate

+ func (o Ops[T]) Desc() Order

+ func (o Ops[T]) Eq(v T) Predicate

+ func (o Ops[T]) EqExpr(x Expression[T]) Predicate

+ func (o Ops[T]) Ge(v T) Predicate

+ func (o Ops[T]) GeExpr(x Expression[T]) Predicate

+ func (o Ops[T]) Gt(v T) Predicate

+ func (o Ops[T]) GtExpr(x Expression[T]) Predicate

+ func (o Ops[T]) In(vs ...T) Predicate

+ func (o Ops[T]) InQuery(q Subquery) Predicate

+ func (o Ops[T]) IsDistinctFrom(v T) Predicate

+ func (o Ops[T]) IsNotDistinctFrom(v T) Predicate

+ func (o Ops[T]) IsNotNull() Predicate

+ func (o Ops[T]) IsNull() Predicate

+ func (o Ops[T]) Le(v T) Predicate

+ func (o Ops[T]) LeExpr(x Expression[T]) Predicate

+ func (o Ops[T]) Lt(v T) Predicate

+ func (o Ops[T]) LtExpr(x Expression[T]) Predicate

+ func (o Ops[T]) Ne(v T) Predicate

+ func (o Ops[T]) NeExpr(x Expression[T]) Predicate

+ func (o Ops[T]) NotIn(vs ...T) Predicate

+ func (o Ops[T]) NotInQuery(q Subquery) Predicate

type Option

+ func WithIDGenerator(name string, fn func() string) Option

+ func WithImplicitTx() Option

+ func WithInterceptor(i Interceptor) Option

+ func WithMaxInList(n int) Option

+ func WithReplicas(replicas ...Driver) Option

+ func WithTxSetup(fn func(ctx context.Context, tx *Tx) error) Option

type Order

+ func (o Order) AppendOrder(b *Builder)

type Predicate

+ func JoinSQL(sep string, parts ...Expr) Predicate

+ func TenantFilter[T any](ctx context.Context, col Column[T]) Predicate

+ type PredicateFunc func(b *Builder)

+ func (f PredicateFunc) AppendSQL(b *Builder)

type ReadOnlyColumn

+ func (c ReadOnlyColumn) ParseCmp(op, raw string) (Predicate, error)

+ func (c ReadOnlyColumn) ParseEq(raw string) (Predicate, error)

type ReadOnlyVectorColumn

+ func (c ReadOnlyVectorColumn) ParseCmp(string, string) (Predicate, error)

+ func (c ReadOnlyVectorColumn) ParseEq(string) (Predicate, error)

type Result

+ InsertID int64

+ type Scope func(SelectQuery[T]) SelectQuery[T]

type SelectQuery

+ func (sq SelectQuery[T]) DistinctOn(es ...Expr) SelectQuery[T]

+ func (sq SelectQuery[T]) LockOf(tables ...string) SelectQuery[T]

+ func (sq SelectQuery[T]) MaxRows(n int) SelectQuery[T]

+ func (sq SelectQuery[T]) Scope(s ...Scope[T]) SelectQuery[T]

+ type Series struct

+ func GenerateSeries[T SeriesInt](alias, col string, start, stop T, step ...T) Series[T]

+ func GenerateTimeSeries(alias, col string, start, stop time.Time, step time.Duration) Series[time.Time]

+ func (s Series[T]) Column() Column[T]

+ func (s Series[T]) Qualifier() string

+ type SeriesInt interface

type TableSource

+ func Lateral(q Subquery, alias string) TableSource

+ type UnnestArray interface

+ type UnnestCol struct

+ func UnnestValuesAs[T any](name, sqlType string, vals []T) UnnestCol[T]

+ func UnnestValues[T any](name string, vals []T) UnnestCol[T]

+ func (c UnnestCol[T]) Ref(source string) Column[T]

+ type UnnestSource struct

+ func Unnest(alias string, cols ...UnnestArray) UnnestSource

+ func (u UnnestSource) Qualifier() string

+ func (u UnnestSource) WithOrdinality(name string) UnnestSource

type UpdateQuery

+ func BulkUpdate[T any, PT Modeler[T]](q Querier, key ColumnRef, cols []ColumnRef, rows [][]any) UpdateQuery[T]

type VectorColumn

+ func VectorColumnOf[V VectorValue](s VectorSource[V]) VectorColumn[V]

+ func (c VectorColumn) ParseCmp(string, string) (Predicate, error)

+ func (c VectorColumn) ParseEq(string) (Predicate, error)

+ type WindowExpr struct

+ func WindowOf[T any](call Expr, w WindowSpec) WindowExpr[T]

+ func (e WindowExpr[T]) AppendSQL(b *Builder)

+ func (e WindowExpr[T]) As(alias string) Aliased[T]

+ type WindowFunc struct

+ func DenseRank() WindowFunc[int64]

+ func FirstValue[T any](e Expression[T]) WindowFunc[T]

+ func LagDefault[T any](e Expression[T], offset int, def T) WindowFunc[T]

+ func Lag[T any](e Expression[T], offset int) WindowFunc[T]

+ func LastValue[T any](e Expression[T]) WindowFunc[T]

+ func LeadDefault[T any](e Expression[T], offset int, def T) WindowFunc[T]

+ func Lead[T any](e Expression[T], offset int) WindowFunc[T]

+ func Rank() WindowFunc[int64]

+ func RowNumber() WindowFunc[int64]

+ func (f WindowFunc[T]) Over(w WindowSpec) WindowExpr[T]

+ type WindowSpec struct

+ func Over() WindowSpec

+ func (w WindowSpec) Groups(start, end FrameBound) WindowSpec

+ func (w WindowSpec) OrderBy(items ...Orderable) WindowSpec

+ func (w WindowSpec) PartitionBy(es ...Expr) WindowSpec

+ func (w WindowSpec) Range(start, end FrameBound) WindowSpec

+ func (w WindowSpec) Rows(start, end FrameBound) WindowSpec

v0.3.0

Nov 7, 2026

Changes in this version

+ var ErrAdoptedTx = errors.New("momo: transaction is owned by the caller")

type Agg

+ func (a Agg[T]) As(name string) Aliased[T]

type Aliased

+ func (a Aliased[T]) Asc() Order

+ func (a Aliased[T]) Desc() Order

+ func (a Aliased[T]) Ref(source string) Column[T]

+ type ArithExpr struct

+ func AddExpr[T Numeric](e, other Expression[T]) ArithExpr[T]

+ func Add[T Numeric](e Expression[T], v T) ArithExpr[T]

+ func MulExpr[T Numeric](e, other Expression[T]) ArithExpr[T]

+ func Mul[T Numeric](e Expression[T], v T) ArithExpr[T]

+ func SubExpr[T Numeric](e, other Expression[T]) ArithExpr[T]

+ func Sub[T Numeric](e Expression[T], v T) ArithExpr[T]

+ func (a ArithExpr[T]) AppendSQL(b *Builder)

+ func (a ArithExpr[T]) As(alias string) Aliased[T]

+ func (o ArithExpr) Asc() Order

+ func (o ArithExpr) Between(lo, hi T) Predicate

+ func (o ArithExpr) Desc() Order

+ func (o ArithExpr) Eq(v T) Predicate

+ func (o ArithExpr) EqExpr(x Expression[T]) Predicate

+ func (o ArithExpr) Ge(v T) Predicate

+ func (o ArithExpr) GeExpr(x Expression[T]) Predicate

+ func (o ArithExpr) Gt(v T) Predicate

+ func (o ArithExpr) GtExpr(x Expression[T]) Predicate

+ func (o ArithExpr) In(vs ...T) Predicate

+ func (o ArithExpr) IsNotNull() Predicate

+ func (o ArithExpr) IsNull() Predicate

+ func (o ArithExpr) Le(v T) Predicate

+ func (o ArithExpr) LeExpr(x Expression[T]) Predicate

+ func (o ArithExpr) Lt(v T) Predicate

+ func (o ArithExpr) LtExpr(x Expression[T]) Predicate

+ func (o ArithExpr) Ne(v T) Predicate

+ func (o ArithExpr) NeExpr(x Expression[T]) Predicate

+ func (o ArithExpr) NotIn(vs ...T) Predicate

+ type CaseExpr struct

+ func Case[T any]() CaseExpr[T]

+ func (c CaseExpr[T]) AppendSQL(b *Builder)

+ func (c CaseExpr[T]) As(alias string) Aliased[T]

+ func (c CaseExpr[T]) Else(v T) CaseExpr[T]

+ func (c CaseExpr[T]) ElseExpr(e Expression[T]) CaseExpr[T]

+ func (c CaseExpr[T]) When(cond Predicate, v T) CaseExpr[T]

+ func (c CaseExpr[T]) WhenExpr(cond Predicate, e Expression[T]) CaseExpr[T]

+ func (o CaseExpr) Asc() Order

+ func (o CaseExpr) Between(lo, hi T) Predicate

+ func (o CaseExpr) Desc() Order

+ func (o CaseExpr) Eq(v T) Predicate

+ func (o CaseExpr) EqExpr(x Expression[T]) Predicate

+ func (o CaseExpr) Ge(v T) Predicate

+ func (o CaseExpr) GeExpr(x Expression[T]) Predicate

+ func (o CaseExpr) Gt(v T) Predicate

+ func (o CaseExpr) GtExpr(x Expression[T]) Predicate

+ func (o CaseExpr) In(vs ...T) Predicate

+ func (o CaseExpr) IsNotNull() Predicate

+ func (o CaseExpr) IsNull() Predicate

+ func (o CaseExpr) Le(v T) Predicate

+ func (o CaseExpr) LeExpr(x Expression[T]) Predicate

+ func (o CaseExpr) Lt(v T) Predicate

+ func (o CaseExpr) LtExpr(x Expression[T]) Predicate

+ func (o CaseExpr) Ne(v T) Predicate

+ func (o CaseExpr) NeExpr(x Expression[T]) Predicate

+ func (o CaseExpr) NotIn(vs ...T) Predicate

+ type CastExpr struct

+ func Cast[T any](e Expr, sqlType string) CastExpr[T]

+ func (c CastExpr[T]) AppendSQL(b *Builder)

+ func (c CastExpr[T]) As(alias string) Aliased[T]

+ func (o CastExpr) Asc() Order

+ func (o CastExpr) Between(lo, hi T) Predicate

+ func (o CastExpr) Desc() Order

+ func (o CastExpr) Eq(v T) Predicate

+ func (o CastExpr) EqExpr(x Expression[T]) Predicate

+ func (o CastExpr) Ge(v T) Predicate

+ func (o CastExpr) GeExpr(x Expression[T]) Predicate

+ func (o CastExpr) Gt(v T) Predicate

+ func (o CastExpr) GtExpr(x Expression[T]) Predicate

+ func (o CastExpr) In(vs ...T) Predicate

+ func (o CastExpr) IsNotNull() Predicate

+ func (o CastExpr) IsNull() Predicate

+ func (o CastExpr) Le(v T) Predicate

+ func (o CastExpr) LeExpr(x Expression[T]) Predicate

+ func (o CastExpr) Lt(v T) Predicate

+ func (o CastExpr) LtExpr(x Expression[T]) Predicate

+ func (o CastExpr) Ne(v T) Predicate

+ func (o CastExpr) NeExpr(x Expression[T]) Predicate

+ func (o CastExpr) NotIn(vs ...T) Predicate

+ type ConcatExpr struct

+ func Concat(a, b Expression[string], more ...Expression[string]) ConcatExpr

+ func (c ConcatExpr) AppendSQL(b *Builder)

+ func (c ConcatExpr) As(alias string) Aliased[string]

+ func (o ConcatExpr) Asc() Order

+ func (o ConcatExpr) Between(lo, hi T) Predicate

+ func (o ConcatExpr) Desc() Order

+ func (o ConcatExpr) Eq(v T) Predicate

+ func (o ConcatExpr) EqExpr(x Expression[T]) Predicate

+ func (o ConcatExpr) Ge(v T) Predicate

+ func (o ConcatExpr) GeExpr(x Expression[T]) Predicate

+ func (o ConcatExpr) Gt(v T) Predicate

+ func (o ConcatExpr) GtExpr(x Expression[T]) Predicate

+ func (o ConcatExpr) In(vs ...T) Predicate

+ func (o ConcatExpr) IsNotNull() Predicate

+ func (o ConcatExpr) IsNull() Predicate

+ func (o ConcatExpr) Le(v T) Predicate

+ func (o ConcatExpr) LeExpr(x Expression[T]) Predicate

+ func (o ConcatExpr) Lt(v T) Predicate

+ func (o ConcatExpr) LtExpr(x Expression[T]) Predicate

+ func (o ConcatExpr) Ne(v T) Predicate

+ func (o ConcatExpr) NeExpr(x Expression[T]) Predicate

+ func (o ConcatExpr) NotIn(vs ...T) Predicate

+ type CurrentSchemaExpr struct

+ func CurrentSchema() CurrentSchemaExpr

+ func (CurrentSchemaExpr) AppendSQL(b *Builder)

+ func (c CurrentSchemaExpr) As(alias string) Aliased[string]

type DB

+ func (db *DB) AdoptTx(dtx DriverTx) *Tx

+ type ExcludedExpr struct

+ func (e ExcludedExpr[T]) AppendSQL(b *Builder)

+ func (o ExcludedExpr) Asc() Order

+ func (o ExcludedExpr) Between(lo, hi T) Predicate

+ func (o ExcludedExpr) Desc() Order

+ func (o ExcludedExpr) Eq(v T) Predicate

+ func (o ExcludedExpr) EqExpr(x Expression[T]) Predicate

+ func (o ExcludedExpr) Ge(v T) Predicate

+ func (o ExcludedExpr) GeExpr(x Expression[T]) Predicate

+ func (o ExcludedExpr) Gt(v T) Predicate

+ func (o ExcludedExpr) GtExpr(x Expression[T]) Predicate

+ func (o ExcludedExpr) In(vs ...T) Predicate

+ func (o ExcludedExpr) IsNotNull() Predicate

+ func (o ExcludedExpr) IsNull() Predicate

+ func (o ExcludedExpr) Le(v T) Predicate

+ func (o ExcludedExpr) LeExpr(x Expression[T]) Predicate

+ func (o ExcludedExpr) Lt(v T) Predicate

+ func (o ExcludedExpr) LtExpr(x Expression[T]) Predicate

+ func (o ExcludedExpr) Ne(v T) Predicate

+ func (o ExcludedExpr) NeExpr(x Expression[T]) Predicate

+ func (o ExcludedExpr) NotIn(vs ...T) Predicate

+ type ExprSelect struct

+ func SelectExprs(cols ...Expr) ExprSelect

+ func (s ExprSelect) AppendSQL(b *Builder)

+ func (s ExprSelect) From(src TableSource) ExprSelect

+ func (s ExprSelect) Where(ps ...Predicate) ExprSelect

+ type FuncExpr struct

+ func CoalesceExpr[T any](a, b Expression[T], more ...Expression[T]) FuncExpr[T]

+ func Func[T any](name string, args ...any) FuncExpr[T]

+ func Lower(e Expression[string]) FuncExpr[string]

+ func Substr(e Expression[string], from, length int) FuncExpr[string]

+ func SubstrFrom(e Expression[string], from int) FuncExpr[string]

+ func Upper(e Expression[string]) FuncExpr[string]

+ func (f FuncExpr[T]) AppendSQL(b *Builder)

+ func (f FuncExpr[T]) As(alias string) Aliased[T]

+ func (o FuncExpr) Asc() Order

+ func (o FuncExpr) Between(lo, hi T) Predicate

+ func (o FuncExpr) Desc() Order

+ func (o FuncExpr) Eq(v T) Predicate

+ func (o FuncExpr) EqExpr(x Expression[T]) Predicate

+ func (o FuncExpr) Ge(v T) Predicate

+ func (o FuncExpr) GeExpr(x Expression[T]) Predicate

+ func (o FuncExpr) Gt(v T) Predicate

+ func (o FuncExpr) GtExpr(x Expression[T]) Predicate

+ func (o FuncExpr) In(vs ...T) Predicate

+ func (o FuncExpr) IsNotNull() Predicate

+ func (o FuncExpr) IsNull() Predicate

+ func (o FuncExpr) Le(v T) Predicate

+ func (o FuncExpr) LeExpr(x Expression[T]) Predicate

+ func (o FuncExpr) Lt(v T) Predicate

+ func (o FuncExpr) LtExpr(x Expression[T]) Predicate

+ func (o FuncExpr) Ne(v T) Predicate

+ func (o FuncExpr) NeExpr(x Expression[T]) Predicate

+ func (o FuncExpr) NotIn(vs ...T) Predicate

type InsertQuery

+ func (q InsertQuery[T]) FromSelect(sel Subquery, cols ...ColumnRef) InsertQuery[T]

+ type LengthExpr struct

+ func Length(e Expression[string]) LengthExpr

+ func (l LengthExpr) AppendSQL(b *Builder)

+ func (l LengthExpr) As(alias string) Aliased[int64]

+ func (o LengthExpr) Asc() Order

+ func (o LengthExpr) Between(lo, hi T) Predicate

+ func (o LengthExpr) Desc() Order

+ func (o LengthExpr) Eq(v T) Predicate

+ func (o LengthExpr) EqExpr(x Expression[T]) Predicate

+ func (o LengthExpr) Ge(v T) Predicate

+ func (o LengthExpr) GeExpr(x Expression[T]) Predicate

+ func (o LengthExpr) Gt(v T) Predicate

+ func (o LengthExpr) GtExpr(x Expression[T]) Predicate

+ func (o LengthExpr) In(vs ...T) Predicate

+ func (o LengthExpr) IsNotNull() Predicate

+ func (o LengthExpr) IsNull() Predicate

+ func (o LengthExpr) Le(v T) Predicate

+ func (o LengthExpr) LeExpr(x Expression[T]) Predicate

+ func (o LengthExpr) Lt(v T) Predicate

+ func (o LengthExpr) LtExpr(x Expression[T]) Predicate

+ func (o LengthExpr) Ne(v T) Predicate

+ func (o LengthExpr) NeExpr(x Expression[T]) Predicate

+ func (o LengthExpr) NotIn(vs ...T) Predicate

+ type Numeric interface

+ type RelationLoader struct

+ func (l RelationLoader[P, C]) Scope(opts ...LoadOption[C]) RelationLoader[P, C]

+ func (l RelationLoader[P, C]) Then(nested ...Loader[C]) RelationLoader[P, C]

+ type Row1 struct

+ C1 A

+ func (*Row1[A]) MomoMeta() *Meta[Row1[A]]

+ type Row10 struct

+ C1 A

+ C10 J

+ C2 B

+ C3 C

+ C4 D

+ C5 E

+ C6 F

+ C7 G

+ C8 H

+ C9 I

+ func (*Row10[A, B, C, D, E, F, G, H, I, J]) MomoMeta() *Meta[Row10[A, B, C, D, E, F, G, H, I, J]]

+ type Row2 struct

+ C1 A

+ C2 B

+ func (*Row2[A, B]) MomoMeta() *Meta[Row2[A, B]]

+ type Row3 struct

+ C1 A

+ C2 B

+ C3 C

+ func (*Row3[A, B, C]) MomoMeta() *Meta[Row3[A, B, C]]

+ type Row4 struct

+ C1 A

+ C2 B

+ C3 C

+ C4 D

+ func (*Row4[A, B, C, D]) MomoMeta() *Meta[Row4[A, B, C, D]]

+ type Row5 struct

+ C1 A

+ C2 B

+ C3 C

+ C4 D

+ C5 E

+ func (*Row5[A, B, C, D, E]) MomoMeta() *Meta[Row5[A, B, C, D, E]]

+ type Row6 struct

+ C1 A

+ C2 B

+ C3 C

+ C4 D

+ C5 E

+ C6 F

+ func (*Row6[A, B, C, D, E, F]) MomoMeta() *Meta[Row6[A, B, C, D, E, F]]

+ type Row7 struct

+ C1 A

+ C2 B

+ C3 C

+ C4 D

+ C5 E

+ C6 F

+ C7 G

+ func (*Row7[A, B, C, D, E, F, G]) MomoMeta() *Meta[Row7[A, B, C, D, E, F, G]]

+ type Row8 struct

+ C1 A

+ C2 B

+ C3 C

+ C4 D

+ C5 E

+ C6 F

+ C7 G

+ C8 H

+ func (*Row8[A, B, C, D, E, F, G, H]) MomoMeta() *Meta[Row8[A, B, C, D, E, F, G, H]]

+ type Row9 struct

+ C1 A

+ C2 B

+ C3 C

+ C4 D

+ C5 E

+ C6 F

+ C7 G

+ C8 H

+ C9 I

+ func (*Row9[A, B, C, D, E, F, G, H, I]) MomoMeta() *Meta[Row9[A, B, C, D, E, F, G, H, I]]

type SearchSettings

+ HNSWScanMemMultiplier float64

type TableRef

+ SoftDelete string

+ SoftDeleteKind SoftDeleteKind

+ func (t TableRef) As(alias string) TableRef

type Tx

+ func (tx *Tx) DriverTx() DriverTx

v0.2.0

Nov 6, 2026

Changes in this version

type Column

+ func (c Column[T]) Excluded() Expression[T]

type ConflictQuery

+ func (c ConflictQuery[T]) Where(preds ...Predicate) ConflictQuery[T]

type CreateOnlyColumn

+ func (c CreateOnlyColumn[T]) Excluded() Expression[T]

type ImmutableColumn

+ func (c ImmutableColumn[T]) Excluded() Expression[T]

type InsertQuery

+ func (q InsertQuery[T]) Where(preds ...Predicate) InsertQuery[T]

type NullReadOnlyColumn

+ func (c NullReadOnlyColumn[T]) Excluded() Expression[T]

type ReadOnlyColumn

+ func (c ReadOnlyColumn[T]) Excluded() Expression[T]

type VectorColumn

+ func (c VectorColumn[V]) Excluded() Expression[V]

v0.1.0

Nov 6, 2026

Changes in this version

+ const FlagCreateOnly

+ const FlagCreatedAt

+ const FlagHasDefault

+ const FlagIdentity

+ const FlagImmutable

+ const FlagNullable

+ const FlagPK

+ const FlagReadOnly

+ const FlagSensitive

+ const FlagSoftDelete

+ const FlagUnique

+ const FlagUpdatedAt

+ const FlagVersion

+ var ErrBusy = errors.New("momo: database is busy")

+ var ErrCheckViolation = errors.New("momo: check constraint violation")

+ var ErrForeignKeyViolation = errors.New("momo: foreign key constraint violation")

+ var ErrInvalidVector = vector.ErrInvalidVector

+ var ErrLimitExceeded = errors.New("momo: limit exceeded")

+ var ErrNotFound = errors.New("momo: not found")

+ var ErrNotNullViolation = errors.New("momo: not-null constraint violation")

+ var ErrOptimisticLock = errors.New("momo: optimistic lock conflict")

+ var ErrPinnedBusy = errors.New("momo: pinned connection is busy")

+ var ErrSerialization = errors.New("momo: serialization failure")

+ var ErrTooManyRows = errors.New("momo: more than one row")

+ var ErrTxDone = errors.New("momo: transaction already finished")

+ var ErrUnfilteredMutation = errors.New("momo: refusing UPDATE/DELETE without WHERE; call AllRows to confirm")

+ var ErrUniqueViolation = errors.New("momo: unique constraint violation")

+ var ErrUnsupported = errors.New("momo: unsupported by dialect or driver")

+ var ErrValidation = errors.New("momo: validation failed")

+ func CreateGraph[P any, PP Modeler[P]](ctx context.Context, q Querier, p *P, includes ...Association[P]) error

+ func EscapeLike(s string) string

+ func Exec(ctx context.Context, q Querier, sql string, args ...any) (int64, error)

+ func FindOrCreate[T any, PT Modeler[T]](ctx context.Context, q Querier, key []ColumnRef, m *T) (created bool, err error)

+ func Ident(name string) any

+ func In(values any) any

+ func LoadAll[P any](ctx context.Context, q Querier, parents []P, loaders ...Loader[P]) error

+ func Load[P, C any](ctx context.Context, q Querier, parents []P, rel Relation[P, C], ...) error

+ func RecordPoolWait(ctx context.Context, d time.Duration)

+ func Scalars[V any](ctx context.Context, q Querier, sql string, args ...any) ([]V, error)

+ func UpsertByPK[T any, PT Modeler[T]](ctx context.Context, q Querier, m *T) error

+ type Agg struct

+ func Avg(e Expression[float64]) Agg[float64]

+ func CountAll() Agg[int64]

+ func CountDistinct(e Expr) Agg[int64]

+ func CountOf(e Expr) Agg[int64]

+ func Max[T any](e Expression[T]) Agg[T]

+ func Min[T any](e Expression[T]) Agg[T]

+ func Sum[T Number](e Expression[T]) Agg[T]

+ func (a Agg[T]) Asc() Order

+ func (a Agg[T]) Desc() Order

+ func (a Agg[T]) Eq(v T) Predicate

+ func (a Agg[T]) Ge(v T) Predicate

+ func (a Agg[T]) Gt(v T) Predicate

+ func (a Agg[T]) Le(v T) Predicate

+ func (a Agg[T]) Lt(v T) Predicate

+ func (a Agg[T]) Ne(v T) Predicate

+ func (f Agg) AppendSQL(b *Builder)

+ type Aliased struct

+ Alias string

+ Expr Expr

+ func As(e Expr, alias string) Aliased

+ func (a Aliased) AppendSQL(b *Builder)

+ type Allowlist struct

+ func NewAllowlist(cols ...ColumnRef) Allowlist

+ func (a Allowlist) Column(name string) (ColumnRef, error)

+ type Assignment struct

+ func (a Assignment) ColumnName() string

+ type Association interface

+ type Batcher interface

+ SendBatch func(ctx context.Context, stmts []Compiled) ([]Rows, error)

+ func BatcherOf(q Querier) (Batcher, bool)

+ type Builder struct

+ func NewBuilder(d *dialect.Dialect) *Builder

+ func (b *Builder) Arg(v any)

+ func (b *Builder) Args() []any

+ func (b *Builder) Dialect() *dialect.Dialect

+ func (b *Builder) Err() error

+ func (b *Builder) Ident(name string)

+ func (b *Builder) QualifiedIdent(qualifier, name string)

+ func (b *Builder) SetErr(err error)

+ func (b *Builder) String() string

+ func (b *Builder) WriteByte(c byte) error

+ func (b *Builder) WriteString(s string)

+ type Capabilities struct

+ Batch bool

+ Copy bool

+ Vectors bool

+ type CapabilityReporter interface

+ Capabilities func() Capabilities

+ type Column struct

+ func ColumnOf[T any](source string, name string) Column[T]

+ func NewColumn[T any](table, name string, flags uint16) Column[T]

+ func (c Column[T]) AppendSQL(b *Builder)

+ func (c Column[T]) As(alias string) Column[T]

+ func (c Column[T]) AsExpr() Expression[T]

+ func (c Column[T]) Asc() Order

+ func (c Column[T]) Between(lo, hi T) Predicate

+ func (c Column[T]) ColumnName() string

+ func (c Column[T]) Desc() Order

+ func (c Column[T]) Eq(v T) Predicate

+ func (c Column[T]) EqExpr(e Expression[T]) Predicate

+ func (c Column[T]) Flags() uint16

+ func (c Column[T]) Ge(v T) Predicate

+ func (c Column[T]) GeExpr(e Expression[T]) Predicate

+ func (c Column[T]) Gt(v T) Predicate

+ func (c Column[T]) GtExpr(e Expression[T]) Predicate

+ func (c Column[T]) In(vs ...T) Predicate

+ func (c Column[T]) InQuery(q Subquery) Predicate

+ func (c Column[T]) IsDistinctFrom(v T) Predicate

+ func (c Column[T]) IsNotDistinctFrom(v T) Predicate

+ func (c Column[T]) IsNotNull() Predicate

+ func (c Column[T]) IsNull() Predicate

+ func (c Column[T]) Le(v T) Predicate

+ func (c Column[T]) LeExpr(e Expression[T]) Predicate

+ func (c Column[T]) Lt(v T) Predicate

+ func (c Column[T]) LtExpr(e Expression[T]) Predicate

+ func (c Column[T]) Ne(v T) Predicate

+ func (c Column[T]) NeExpr(e Expression[T]) Predicate

+ func (c Column[T]) NotIn(vs ...T) Predicate

+ func (c Column[T]) NotInQuery(q Subquery) Predicate

+ func (c Column[T]) Set(v T) Assignment

+ func (c Column[T]) SetDefault() Assignment

+ func (c Column[T]) SetExcluded() Assignment

+ func (c Column[T]) SetExpr(e Expression[T]) Assignment

+ func (c Column[T]) Table() string

+ type ColumnMeta struct

+ Flags uint16

+ Name string

+ type ColumnRef interface

+ ColumnName func() string

+ type Compiled struct

+ Args []any

+ SQL string

+ func (c Compiled) String() string

+ type Config struct

+ func (c *Config) Check(name, expr string)

+ func (c *Config) Collate(field any, collation string)

+ func (c *Config) Comment(field any, text string)

+ func (c *Config) Default(field any, expr string)

+ func (c *Config) Enum(name string, values ...string)

+ func (c *Config) Function(f schema.Function)

+ func (c *Config) Index(name string, cols ...any) *IndexOpts

+ func (c *Config) IndexExpr(name string, exprs ...string) *IndexOpts

+ func (c *Config) Partition(p schema.Partition)

+ func (c *Config) PartitionOf(p schema.PartitionOf)

+ func (c *Config) Policy(p schema.Policy)

+ func (c *Config) RLS(r schema.RLS)

+ func (c *Config) Trigger(t schema.Trigger)

+ func (c *Config) Unique(name string, cols ...any) *IndexOpts

+ func (c *Config) View(v schema.View)

+ type ConflictQuery struct

+ func (c ConflictQuery[T]) DoNothing() InsertQuery[T]

+ func (c ConflictQuery[T]) DoUpdate(assigns ...Assignment) InsertQuery[T]

+ type Copier interface

+ CopyFrom func(ctx context.Context, table string, cols []string, rows [][]any) (int64, error)

+ func CopierOf(q Querier) (Copier, bool)

+ type CreateOnlyColumn struct

+ func NewCreateOnlyColumn[T any](table, name string, flags uint16) CreateOnlyColumn[T]

+ func (c CreateOnlyColumn[T]) AppendSQL(b *Builder)

+ func (c CreateOnlyColumn[T]) As(alias string) CreateOnlyColumn[T]

+ func (c CreateOnlyColumn[T]) AsExpr() Expression[T]

+ func (c CreateOnlyColumn[T]) Asc() Order

+ func (c CreateOnlyColumn[T]) Between(lo, hi T) Predicate

+ func (c CreateOnlyColumn[T]) ColumnName() string

+ func (c CreateOnlyColumn[T]) Desc() Order

+ func (c CreateOnlyColumn[T]) Eq(v T) Predicate

+ func (c CreateOnlyColumn[T]) EqExpr(e Expression[T]) Predicate

+ func (c CreateOnlyColumn[T]) Flags() uint16

+ func (c CreateOnlyColumn[T]) Ge(v T) Predicate

+ func (c CreateOnlyColumn[T]) GeExpr(e Expression[T]) Predicate

+ func (c CreateOnlyColumn[T]) Gt(v T) Predicate

+ func (c CreateOnlyColumn[T]) GtExpr(e Expression[T]) Predicate

+ func (c CreateOnlyColumn[T]) In(vs ...T) Predicate

+ func (c CreateOnlyColumn[T]) InQuery(q Subquery) Predicate

+ func (c CreateOnlyColumn[T]) IsDistinctFrom(v T) Predicate

+ func (c CreateOnlyColumn[T]) IsNotDistinctFrom(v T) Predicate

+ func (c CreateOnlyColumn[T]) IsNotNull() Predicate

+ func (c CreateOnlyColumn[T]) IsNull() Predicate

+ func (c CreateOnlyColumn[T]) Le(v T) Predicate

+ func (c CreateOnlyColumn[T]) LeExpr(e Expression[T]) Predicate

+ func (c CreateOnlyColumn[T]) Lt(v T) Predicate

+ func (c CreateOnlyColumn[T]) LtExpr(e Expression[T]) Predicate

+ func (c CreateOnlyColumn[T]) Ne(v T) Predicate

+ func (c CreateOnlyColumn[T]) NeExpr(e Expression[T]) Predicate

+ func (c CreateOnlyColumn[T]) NotIn(vs ...T) Predicate

+ func (c CreateOnlyColumn[T]) NotInQuery(q Subquery) Predicate

+ func (c CreateOnlyColumn[T]) Set(v T) InsertAssignment

+ func (c CreateOnlyColumn[T]) Table() string

+ type CreateOnlyVectorColumn struct

+ func NewCreateOnlyVectorColumn[V VectorValue](table, name string, dim int, flags uint16) CreateOnlyVectorColumn[V]

+ func (c CreateOnlyVectorColumn) AppendSQL(b *Builder)

+ func (c CreateOnlyVectorColumn) AsExpr() Expression[V]

+ func (c CreateOnlyVectorColumn) Asc() Order

+ func (c CreateOnlyVectorColumn) ColumnName() string

+ func (c CreateOnlyVectorColumn) Desc() Order

+ func (c CreateOnlyVectorColumn) Dim() int

+ func (c CreateOnlyVectorColumn) Eq(v V) Predicate

+ func (c CreateOnlyVectorColumn) EqExpr(e Expression[V]) Predicate

+ func (c CreateOnlyVectorColumn) Flags() uint16

+ func (c CreateOnlyVectorColumn) In(vs ...V) Predicate

+ func (c CreateOnlyVectorColumn) InQuery(q Subquery) Predicate

+ func (c CreateOnlyVectorColumn) IsDistinctFrom(v V) Predicate

+ func (c CreateOnlyVectorColumn) IsNotDistinctFrom(v V) Predicate

+ func (c CreateOnlyVectorColumn) IsNotNull() Predicate

+ func (c CreateOnlyVectorColumn) IsNull() Predicate

+ func (c CreateOnlyVectorColumn) Ne(v V) Predicate

+ func (c CreateOnlyVectorColumn) NeExpr(e Expression[V]) Predicate

+ func (c CreateOnlyVectorColumn) NotIn(vs ...V) Predicate

+ func (c CreateOnlyVectorColumn) NotInQuery(q Subquery) Predicate

+ func (c CreateOnlyVectorColumn) Table() string

+ func (c CreateOnlyVectorColumn[V]) As(alias string) CreateOnlyVectorColumn[V]

+ func (c CreateOnlyVectorColumn[V]) Set(v V) InsertAssignment

+ type DB struct

+ func New(drv Driver, opts ...Option) *DB

+ func (db *DB) Begin(ctx context.Context, opts TxOptions) (*Tx, error)

+ func (db *DB) Dialect() *dialect.Dialect

+ func (db *DB) Driver() Driver

+ func (db *DB) OnConn(pc PinnedConn) *DB

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

+ func (db *DB) WithSearch(ctx context.Context, s SearchSettings, fn func(*Tx) error) error

+ type DeleteQuery struct

+ func Delete[T any, PT Modeler[T]](q Querier) DeleteQuery[T]

+ func ForceDelete[T any, PT Modeler[T]](q Querier) DeleteQuery[T]

+ func (d DeleteQuery[T]) AllRows() DeleteQuery[T]

+ func (d DeleteQuery[T]) Exec(ctx context.Context) (Result, error)

+ func (d DeleteQuery[T]) Model(m *T) DeleteQuery[T]

+ func (d DeleteQuery[T]) Returning(cols ...ColumnRef) DeleteQuery[T]

+ func (d DeleteQuery[T]) ReturningAll() DeleteQuery[T]

+ func (d DeleteQuery[T]) Rows(ctx context.Context) (*ModelRows[T], error)

+ func (d DeleteQuery[T]) SQL() (Compiled, error)

+ func (d DeleteQuery[T]) Where(ps ...Predicate) DeleteQuery[T]

+ type DialectValuer interface

+ DialectValue func(d dialect.Name) (any, error)

+ type Direction uint8

+ const DirAsc

+ const DirDesc

+ type Discarder interface

+ Discard func() error

+ type Discriminator struct

+ Column string

+ Value any

+ type DistanceExpr struct

+ func CosineDistance[V denseVector, C VectorSource[V]](c C, v V) DistanceExpr

+ func HammingDistance[V bitVector, C VectorSource[V]](c C, v V) DistanceExpr

+ func InnerProductDistance[V denseVector, C VectorSource[V]](c C, v V) DistanceExpr

+ func JaccardDistance[V bitVector, C VectorSource[V]](c C, v V) DistanceExpr

+ func L1Distance[V denseVector, C VectorSource[V]](c C, v V) DistanceExpr

+ func L2Distance[V denseVector, C VectorSource[V]](c C, v V) DistanceExpr

+ func (e DistanceExpr) AppendSQL(b *Builder)

+ func (e DistanceExpr) Asc() Order

+ func (e DistanceExpr) Desc() Order

+ type Driver interface

+ Begin func(ctx context.Context, opts TxOptions) (DriverTx, error)

+ Dialect func() *dialect.Dialect

+ Exec func(ctx context.Context, sql string, args []any) (int64, error)

+ Query func(ctx context.Context, sql string, args []any) (Rows, error)

+ type DriverTx interface

+ Commit func(ctx context.Context) error

+ Exec func(ctx context.Context, sql string, args []any) (int64, error)

+ Query func(ctx context.Context, sql string, args []any) (Rows, error)

+ Rollback func(ctx context.Context) error

+ type Error struct

+ Column string

+ Constraint string

+ Err error

+ Kind error

+ Op string

+ Table string

+ func (e *Error) Detail() string

+ func (e *Error) Error() string

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

+ func (e *Error) Unwrap() error

+ type ErrorClassifier interface

+ ClassifyError func(err error) error

+ type Expr interface

+ AppendSQL func(b *Builder)

+ type Expression interface

+ func Coalesce[T any](e Expression[T], fallback T) Expression[T]

+ func TypedSQL[T any](sql string, args ...any) Expression[T]

+ func Value[T any](v T) Expression[T]

+ type FieldHook struct

+ Column int

+ Default func(m *T) any

+ OnUpdate func(m *T) any

+ Validate func(v any) error

+ type Hook interface

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

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

+ type ImmutableColumn struct

+ func NewImmutableColumn[T any](table, name string, flags uint16) ImmutableColumn[T]

+ func (c ImmutableColumn[T]) AppendSQL(b *Builder)

+ func (c ImmutableColumn[T]) As(alias string) ImmutableColumn[T]

+ func (c ImmutableColumn[T]) AsExpr() Expression[T]

+ func (c ImmutableColumn[T]) Asc() Order

+ func (c ImmutableColumn[T]) Between(lo, hi T) Predicate

+ func (c ImmutableColumn[T]) ColumnName() string

+ func (c ImmutableColumn[T]) Desc() Order

+ func (c ImmutableColumn[T]) Eq(v T) Predicate

+ func (c ImmutableColumn[T]) EqExpr(e Expression[T]) Predicate

+ func (c ImmutableColumn[T]) Flags() uint16

+ func (c ImmutableColumn[T]) Ge(v T) Predicate

+ func (c ImmutableColumn[T]) GeExpr(e Expression[T]) Predicate

+ func (c ImmutableColumn[T]) Gt(v T) Predicate

+ func (c ImmutableColumn[T]) GtExpr(e Expression[T]) Predicate

+ func (c ImmutableColumn[T]) In(vs ...T) Predicate

+ func (c ImmutableColumn[T]) InQuery(q Subquery) Predicate

+ func (c ImmutableColumn[T]) IsDistinctFrom(v T) Predicate

+ func (c ImmutableColumn[T]) IsNotDistinctFrom(v T) Predicate

+ func (c ImmutableColumn[T]) IsNotNull() Predicate

+ func (c ImmutableColumn[T]) IsNull() Predicate

+ func (c ImmutableColumn[T]) Le(v T) Predicate

+ func (c ImmutableColumn[T]) LeExpr(e Expression[T]) Predicate

+ func (c ImmutableColumn[T]) Lt(v T) Predicate

+ func (c ImmutableColumn[T]) LtExpr(e Expression[T]) Predicate

+ func (c ImmutableColumn[T]) Ne(v T) Predicate

+ func (c ImmutableColumn[T]) NeExpr(e Expression[T]) Predicate

+ func (c ImmutableColumn[T]) NotIn(vs ...T) Predicate

+ func (c ImmutableColumn[T]) NotInQuery(q Subquery) Predicate

+ func (c ImmutableColumn[T]) Set(v T) InsertAssignment

+ func (c ImmutableColumn[T]) Table() string

+ type ImmutableVectorColumn struct

+ func NewImmutableVectorColumn[V VectorValue](table, name string, dim int, flags uint16) ImmutableVectorColumn[V]

+ func (c ImmutableVectorColumn) AppendSQL(b *Builder)

+ func (c ImmutableVectorColumn) AsExpr() Expression[V]

+ func (c ImmutableVectorColumn) Asc() Order

+ func (c ImmutableVectorColumn) ColumnName() string

+ func (c ImmutableVectorColumn) Desc() Order

+ func (c ImmutableVectorColumn) Dim() int

+ func (c ImmutableVectorColumn) Eq(v V) Predicate

+ func (c ImmutableVectorColumn) EqExpr(e Expression[V]) Predicate

+ func (c ImmutableVectorColumn) Flags() uint16

+ func (c ImmutableVectorColumn) In(vs ...V) Predicate

+ func (c ImmutableVectorColumn) InQuery(q Subquery) Predicate

+ func (c ImmutableVectorColumn) IsDistinctFrom(v V) Predicate

+ func (c ImmutableVectorColumn) IsNotDistinctFrom(v V) Predicate

+ func (c ImmutableVectorColumn) IsNotNull() Predicate

+ func (c ImmutableVectorColumn) IsNull() Predicate

+ func (c ImmutableVectorColumn) Ne(v V) Predicate

+ func (c ImmutableVectorColumn) NeExpr(e Expression[V]) Predicate

+ func (c ImmutableVectorColumn) NotIn(vs ...V) Predicate

+ func (c ImmutableVectorColumn) NotInQuery(q Subquery) Predicate

+ func (c ImmutableVectorColumn) Table() string

+ func (c ImmutableVectorColumn[V]) As(alias string) ImmutableVectorColumn[V]

+ func (c ImmutableVectorColumn[V]) Set(v V) InsertAssignment

+ type IndexOpts struct

+ func (o *IndexOpts) Concurrently() *IndexOpts

+ func (o *IndexOpts) Desc(field any) *IndexOpts

+ func (o *IndexOpts) Method(m string) *IndexOpts

+ func (o *IndexOpts) Nulls(field any, order string) *IndexOpts

+ func (o *IndexOpts) Opclass(field any, opclass string) *IndexOpts

+ func (o *IndexOpts) Where(pred string) *IndexOpts

+ func (o *IndexOpts) With(key, value string) *IndexOpts

+ type InsertAssignment struct

+ func (a InsertAssignment) ColumnName() string

+ type InsertQuery struct

+ func Insert[T any, PT Modeler[T]](q Querier) InsertQuery[T]

+ func Upsert[T any, PT Modeler[T]](q Querier) InsertQuery[T]

+ func (q InsertQuery[T]) Exec(ctx context.Context) (Result, error)

+ func (q InsertQuery[T]) Model(m *T) InsertQuery[T]

+ func (q InsertQuery[T]) Models(ms []T) InsertQuery[T]

+ func (q InsertQuery[T]) Omit(cols ...ColumnRef) InsertQuery[T]

+ func (q InsertQuery[T]) OnConflict(cols ...ColumnRef) ConflictQuery[T]

+ func (q InsertQuery[T]) Returning(cols ...ColumnRef) InsertQuery[T]

+ func (q InsertQuery[T]) ReturningAll() InsertQuery[T]

+ func (q InsertQuery[T]) Rows(ctx context.Context) (*ModelRows[T], error)

+ func (q InsertQuery[T]) SQL() (Compiled, error)

+ func (q InsertQuery[T]) Values(assigns ...InsertValue) InsertQuery[T]

+ func (q InsertQuery[T]) ValuesRows(rows ...[]Assignment) InsertQuery[T]

+ type InsertValue interface

+ type IterativeScan string

+ const IterativeOff

+ const IterativeRelaxedOrder

+ const IterativeStrictOrder

+ type LoadOption func(*loadConfig)

+ func LoadOnlyDeleted[C any]() LoadOption[C]

+ func LoadOrderBy[C any](items ...Orderable) LoadOption[C]

+ func LoadPerParentLimit[C any](n int) LoadOption[C]

+ func LoadWhere[C any](ps ...Predicate) LoadOption[C]

+ func LoadWithDeleted[C any]() LoadOption[C]

+ type Loader interface

+ type Meta struct

+ Columns []ColumnMeta

+ CreatedAt int

+ Fields []FieldHook[T]

+ Identity int

+ PK []int

+ Ptr func(m *T, i int) any

+ Schema string

+ SoftDelete int

+ SoftDeleteKind SoftDeleteKind

+ Table string

+ TableSchema *schema.Table

+ UpdatedAt int

+ Value func(m *T, i int) any

+ Version int

+ type Model struct

+ type ModelRows struct

+ func (r *ModelRows[T]) Close() error

+ func (r *ModelRows[T]) Err() error

+ func (r *ModelRows[T]) Next() bool

+ func (r *ModelRows[T]) ScanModel(m *T) error

+ type Modeler interface

+ MomoMeta func() *Meta[T]

+ type NamedArg struct

+ Name string

+ Value any

+ func Named(name string, value any) NamedArg

+ type NullColumn struct

+ func NewNullColumn[T any](table, name string, flags uint16) NullColumn[T]

+ func (c NullColumn[T]) As(alias string) NullColumn[T]

+ func (c NullColumn[T]) SetNull() Assignment

+ type NullReadOnlyColumn struct

+ func NewNullReadOnlyColumn[T any](table, name string, flags uint16) NullReadOnlyColumn[T]

+ func (c NullReadOnlyColumn[T]) AppendSQL(b *Builder)

+ func (c NullReadOnlyColumn[T]) As(alias string) NullReadOnlyColumn[T]

+ func (c NullReadOnlyColumn[T]) AsExpr() Expression[T]

+ func (c NullReadOnlyColumn[T]) Asc() Order

+ func (c NullReadOnlyColumn[T]) Between(lo, hi T) Predicate

+ func (c NullReadOnlyColumn[T]) ColumnName() string

+ func (c NullReadOnlyColumn[T]) Desc() Order

+ func (c NullReadOnlyColumn[T]) Eq(v T) Predicate

+ func (c NullReadOnlyColumn[T]) EqExpr(e Expression[T]) Predicate

+ func (c NullReadOnlyColumn[T]) Flags() uint16

+ func (c NullReadOnlyColumn[T]) Ge(v T) Predicate

+ func (c NullReadOnlyColumn[T]) GeExpr(e Expression[T]) Predicate

+ func (c NullReadOnlyColumn[T]) Gt(v T) Predicate

+ func (c NullReadOnlyColumn[T]) GtExpr(e Expression[T]) Predicate

+ func (c NullReadOnlyColumn[T]) In(vs ...T) Predicate

+ func (c NullReadOnlyColumn[T]) InQuery(q Subquery) Predicate

+ func (c NullReadOnlyColumn[T]) IsDistinctFrom(v T) Predicate

+ func (c NullReadOnlyColumn[T]) IsNotDistinctFrom(v T) Predicate

+ func (c NullReadOnlyColumn[T]) IsNotNull() Predicate

+ func (c NullReadOnlyColumn[T]) IsNull() Predicate

+ func (c NullReadOnlyColumn[T]) Le(v T) Predicate

+ func (c NullReadOnlyColumn[T]) LeExpr(e Expression[T]) Predicate

+ func (c NullReadOnlyColumn[T]) Lt(v T) Predicate

+ func (c NullReadOnlyColumn[T]) LtExpr(e Expression[T]) Predicate

+ func (c NullReadOnlyColumn[T]) Ne(v T) Predicate

+ func (c NullReadOnlyColumn[T]) NeExpr(e Expression[T]) Predicate

+ func (c NullReadOnlyColumn[T]) NotIn(vs ...T) Predicate

+ func (c NullReadOnlyColumn[T]) NotInQuery(q Subquery) Predicate

+ func (c NullReadOnlyColumn[T]) Table() string

+ type NullVectorColumn struct

+ func NewNullVectorColumn[V VectorValue](table, name string, dim int, flags uint16) NullVectorColumn[V]

+ func (c NullVectorColumn) AppendSQL(b *Builder)

+ func (c NullVectorColumn) AsExpr() Expression[V]

+ func (c NullVectorColumn) Asc() Order

+ func (c NullVectorColumn) ColumnName() string

+ func (c NullVectorColumn) Desc() Order

+ func (c NullVectorColumn) Dim() int

+ func (c NullVectorColumn) Eq(v V) Predicate

+ func (c NullVectorColumn) EqExpr(e Expression[V]) Predicate

+ func (c NullVectorColumn) Flags() uint16

+ func (c NullVectorColumn) In(vs ...V) Predicate

+ func (c NullVectorColumn) InQuery(q Subquery) Predicate

+ func (c NullVectorColumn) IsDistinctFrom(v V) Predicate

+ func (c NullVectorColumn) IsNotDistinctFrom(v V) Predicate

+ func (c NullVectorColumn) IsNotNull() Predicate

+ func (c NullVectorColumn) IsNull() Predicate

+ func (c NullVectorColumn) Ne(v V) Predicate

+ func (c NullVectorColumn) NeExpr(e Expression[V]) Predicate

+ func (c NullVectorColumn) NotIn(vs ...V) Predicate

+ func (c NullVectorColumn) NotInQuery(q Subquery) Predicate

+ func (c NullVectorColumn) Table() string

+ func (c NullVectorColumn[V]) As(alias string) NullVectorColumn[V]

+ func (c NullVectorColumn[V]) SetNull() Assignment

+ type Nulls uint8

+ const NullsDefault

+ const NullsFirst

+ const NullsLast

+ type Number interface

+ type Option func(*DB)

+ func WithArgLogging() Option

+ func WithClock(now func() time.Time) Option

+ func WithFieldHooks[T any, PT Modeler[T]](hooks []FieldHook[T]) Option

+ func WithHook(h Hook) Option

+ func WithMaxParams(n int) Option

+ type Order struct

+ Desc bool

+ Expr Expr

+ Nulls Nulls

+ func Asc(e Expr) Order

+ func Desc(e Expr) Order

+ func (o Order) NullsFirst() Order

+ func (o Order) NullsLast() Order

+ type Orderable interface

+ type PinnedConn interface

+ Begin func(ctx context.Context, opts TxOptions) (DriverTx, error)

+ Exec func(ctx context.Context, sql string, args []any) (int64, error)

+ Query func(ctx context.Context, sql string, args []any) (Rows, error)

+ Release func() error

+ type Pinner interface

+ Pin func(ctx context.Context) (PinnedConn, error)

+ type PoolStater interface

+ PoolStats func() PoolStats

+ type PoolStats struct

+ AcquireCount int64

+ AcquiredConns int

+ EmptyAcquireCount int64

+ EmptyAcquireWaitNS int64

+ IdleConns int

+ MaxConns int

+ TotalConns int

+ type Predicate = Expression[bool]

+ func And(ps ...Predicate) Predicate

+ func ContainsLiteral(e Expression[string], s string) Predicate

+ func Exists(q Subquery) Predicate

+ func ILike(e Expression[string], pattern string) Predicate

+ func Like(e Expression[string], pattern string) Predicate

+ func Not(p Predicate) Predicate

+ func NotExists(q Subquery) Predicate

+ func Or(ps ...Predicate) Predicate

+ func SQL(sql string, args ...any) Predicate

+ type Projection struct

+ type Querier interface

+ Dialect func() *dialect.Dialect

+ type QueryEvent struct

+ Args []any

+ Dialect *dialect.Dialect

+ Duration time.Duration

+ Err error

+ InTx bool

+ NumArgs int

+ Op string

+ PoolWait time.Duration

+ Querier Querier

+ Relation string

+ Rows int64

+ SQL string

+ Start time.Time

+ Table string

+ type ReadOnlyColumn struct

+ func NewReadOnlyColumn[T any](table, name string, flags uint16) ReadOnlyColumn[T]

+ func (c ReadOnlyColumn[T]) AppendSQL(b *Builder)

+ func (c ReadOnlyColumn[T]) As(alias string) ReadOnlyColumn[T]

+ func (c ReadOnlyColumn[T]) AsExpr() Expression[T]

+ func (c ReadOnlyColumn[T]) Asc() Order

+ func (c ReadOnlyColumn[T]) Between(lo, hi T) Predicate

+ func (c ReadOnlyColumn[T]) ColumnName() string

+ func (c ReadOnlyColumn[T]) Desc() Order

+ func (c ReadOnlyColumn[T]) Eq(v T) Predicate

+ func (c ReadOnlyColumn[T]) EqExpr(e Expression[T]) Predicate

+ func (c ReadOnlyColumn[T]) Flags() uint16

+ func (c ReadOnlyColumn[T]) Ge(v T) Predicate

+ func (c ReadOnlyColumn[T]) GeExpr(e Expression[T]) Predicate

+ func (c ReadOnlyColumn[T]) Gt(v T) Predicate

+ func (c ReadOnlyColumn[T]) GtExpr(e Expression[T]) Predicate

+ func (c ReadOnlyColumn[T]) In(vs ...T) Predicate

+ func (c ReadOnlyColumn[T]) InQuery(q Subquery) Predicate

+ func (c ReadOnlyColumn[T]) IsDistinctFrom(v T) Predicate

+ func (c ReadOnlyColumn[T]) IsNotDistinctFrom(v T) Predicate

+ func (c ReadOnlyColumn[T]) IsNotNull() Predicate

+ func (c ReadOnlyColumn[T]) IsNull() Predicate

+ func (c ReadOnlyColumn[T]) Le(v T) Predicate

+ func (c ReadOnlyColumn[T]) LeExpr(e Expression[T]) Predicate

+ func (c ReadOnlyColumn[T]) Lt(v T) Predicate

+ func (c ReadOnlyColumn[T]) LtExpr(e Expression[T]) Predicate

+ func (c ReadOnlyColumn[T]) Ne(v T) Predicate

+ func (c ReadOnlyColumn[T]) NeExpr(e Expression[T]) Predicate

+ func (c ReadOnlyColumn[T]) NotIn(vs ...T) Predicate

+ func (c ReadOnlyColumn[T]) NotInQuery(q Subquery) Predicate

+ func (c ReadOnlyColumn[T]) Table() string

+ type ReadOnlyVectorColumn struct

+ func NewReadOnlyVectorColumn[V VectorValue](table, name string, dim int, flags uint16) ReadOnlyVectorColumn[V]

+ func (c ReadOnlyVectorColumn) AppendSQL(b *Builder)

+ func (c ReadOnlyVectorColumn) AsExpr() Expression[V]

+ func (c ReadOnlyVectorColumn) Asc() Order

+ func (c ReadOnlyVectorColumn) ColumnName() string

+ func (c ReadOnlyVectorColumn) Desc() Order

+ func (c ReadOnlyVectorColumn) Dim() int

+ func (c ReadOnlyVectorColumn) Eq(v V) Predicate

+ func (c ReadOnlyVectorColumn) EqExpr(e Expression[V]) Predicate

+ func (c ReadOnlyVectorColumn) Flags() uint16

+ func (c ReadOnlyVectorColumn) In(vs ...V) Predicate

+ func (c ReadOnlyVectorColumn) InQuery(q Subquery) Predicate

+ func (c ReadOnlyVectorColumn) IsDistinctFrom(v V) Predicate

+ func (c ReadOnlyVectorColumn) IsNotDistinctFrom(v V) Predicate

+ func (c ReadOnlyVectorColumn) IsNotNull() Predicate

+ func (c ReadOnlyVectorColumn) IsNull() Predicate

+ func (c ReadOnlyVectorColumn) Ne(v V) Predicate

+ func (c ReadOnlyVectorColumn) NeExpr(e Expression[V]) Predicate

+ func (c ReadOnlyVectorColumn) NotIn(vs ...V) Predicate

+ func (c ReadOnlyVectorColumn) NotInQuery(q Subquery) Predicate

+ func (c ReadOnlyVectorColumn) Table() string

+ func (c ReadOnlyVectorColumn[V]) As(alias string) ReadOnlyVectorColumn[V]

+ type Relation struct

+ Child TableRef

+ ChildCols []string

+ ChildKey func(c *C) ([]any, bool)

+ ChildMeta *Meta[C]

+ ChildPK []string

+ Discriminator *Discriminator

+ GetMany func(p *P) []C

+ GetOne func(p *P) *C

+ Kind RelationKind

+ Name string

+ Parent TableRef

+ ParentCols []string

+ ParentKey func(p *P) ([]any, bool)

+ ParentMeta *Meta[P]

+ SetChildKey func(c *C, key []any)

+ SetMany func(p *P, cs []C)

+ SetOne func(p *P, c *C)

+ SetParentKey func(p *P, key []any)

+ Through *Through

+ func (r Relation[P, C]) Count(ctx context.Context, q Querier, p *P) (int64, error)

+ func (r Relation[P, C]) CountOrder(dir Direction) Orderable

+ func (r Relation[P, C]) From(parents SelectQuery[P]) SelectQuery[C]

+ func (r Relation[P, C]) Has(scope ...Predicate) Predicate

+ func (r Relation[P, C]) HasFrom(parentAlias string, scope ...Predicate) Predicate

+ func (r Relation[P, C]) HasNo(scope ...Predicate) Predicate

+ func (r Relation[P, C]) Include() Association[P]

+ func (r Relation[P, C]) Joined() Loader[P]

+ func (r Relation[P, C]) Link(ctx context.Context, q Querier, p *P, cs ...*C) error

+ func (r Relation[P, C]) Replace(ctx context.Context, q Querier, p *P, cs ...*C) error

+ func (r Relation[P, C]) Scope(opts ...LoadOption[C]) Loader[P]

+ func (r Relation[P, C]) Then(nested ...Loader[C]) Loader[P]

+ func (r Relation[P, C]) Unlink(ctx context.Context, q Querier, p *P, cs ...*C) error

+ type RelationEvent struct

+ Children int64

+ Duration time.Duration

+ Err error

+ Kind RelationKind

+ Name string

+ Parent string

+ Parents int

+ Queries int

+ type RelationHook interface

+ AfterRelation func(ctx context.Context, e *RelationEvent)

+ BeforeRelation func(ctx context.Context, e *RelationEvent) context.Context

+ type RelationKind uint8

+ const BelongsTo

+ const HasMany

+ const HasOne

+ const ManyToMany

+ func (k RelationKind) String() string

+ type Result struct

+ RowsAffected int64

+ type ReturningList struct

+ func Returning(cols ...ColumnRef) ReturningList

+ type Rows interface

+ Close func() error

+ Err func() error

+ Next func() bool

+ Scan func(dest ...any) error

+ type SearchSettings struct

+ ExactSearch bool

+ HNSWEfSearch int

+ HNSWIterativeScan IterativeScan

+ HNSWMaxScanTuples int

+ IVFFlatIterativeScan IterativeScan

+ IVFFlatMaxProbes int

+ IVFFlatProbes int

+ func (s SearchSettings) Validate() error

+ type SelectQuery struct

+ func Select[T any, PT Modeler[T]](q Querier) SelectQuery[T]

+ func (sq SelectQuery[T]) After(values ...any) SelectQuery[T]

+ func (sq SelectQuery[T]) All(ctx context.Context) ([]T, error)

+ func (sq SelectQuery[T]) AppendSQL(b *Builder)

+ func (sq SelectQuery[T]) Columns(es ...Expr) SelectQuery[T]

+ func (sq SelectQuery[T]) Count(ctx context.Context) (int64, error)

+ func (sq SelectQuery[T]) CrossJoin(src TableSource) SelectQuery[T]

+ func (sq SelectQuery[T]) Distinct() SelectQuery[T]

+ func (sq SelectQuery[T]) Each(ctx context.Context, fn func(*T) error) error

+ func (sq SelectQuery[T]) Exists(ctx context.Context) (bool, error)

+ func (sq SelectQuery[T]) Explain(ctx context.Context) (string, error)

+ func (sq SelectQuery[T]) First(ctx context.Context) (T, error)

+ func (sq SelectQuery[T]) ForShare(opt ...string) SelectQuery[T]

+ func (sq SelectQuery[T]) ForUpdate(opt ...string) SelectQuery[T]

+ func (sq SelectQuery[T]) From(src TableSource) SelectQuery[T]

+ func (sq SelectQuery[T]) GroupBy(es ...Expr) SelectQuery[T]

+ func (sq SelectQuery[T]) Having(ps ...Predicate) SelectQuery[T]

+ func (sq SelectQuery[T]) IndexedBy(index string) SelectQuery[T]

+ func (sq SelectQuery[T]) Iter(ctx context.Context) iter.Seq2[T, error]

+ func (sq SelectQuery[T]) Join(src TableSource, on ...Predicate) SelectQuery[T]

+ func (sq SelectQuery[T]) LeftJoin(src TableSource, on ...Predicate) SelectQuery[T]

+ func (sq SelectQuery[T]) Limit(n int64) SelectQuery[T]

+ func (sq SelectQuery[T]) Offset(n int64) SelectQuery[T]

+ func (sq SelectQuery[T]) One(ctx context.Context) (T, error)

+ func (sq SelectQuery[T]) OnlyDeleted() SelectQuery[T]

+ func (sq SelectQuery[T]) OrderBy(items ...Orderable) SelectQuery[T]

+ func (sq SelectQuery[T]) Preload(loaders ...Loader[T]) SelectQuery[T]

+ func (sq SelectQuery[T]) SQL() (Compiled, error)

+ func (sq SelectQuery[T]) Where(ps ...Predicate) SelectQuery[T]

+ func (sq SelectQuery[T]) With(name string, q Subquery, cols ...string) SelectQuery[T]

+ func (sq SelectQuery[T]) WithDeleted() SelectQuery[T]

+ func (sq SelectQuery[T]) WithRecursive(name string, q Subquery, cols ...string) SelectQuery[T]

+ func (sq SelectQuery[T]) WithTableName(name string) SelectQuery[T]

+ type ServerVersioner interface

+ ServerVersion func(ctx context.Context) (int, error)

+ type SoftDeleteKind uint8

+ const SoftDeleteBool

+ const SoftDeleteTimestamp

+ const SoftDeleteUnix

+ type Subquery interface

+ func RawSubquery(sql string, args ...any) Subquery

+ func Union(all bool, qs ...Subquery) Subquery

+ type TableRef struct

+ Alias string

+ Name string

+ Schema string

+ func CTE(name string) TableRef

+ func (t TableRef) Qualifier() string

+ func (t TableRef) Source() TableRef

+ type TableSource interface

+ func FromSubquery(q Subquery, alias string) TableSource

+ type Through struct

+ ChildCols []string

+ ParentCols []string

+ Table TableRef

+ type Tx struct

+ func (tx *Tx) Commit(ctx context.Context) error

+ func (tx *Tx) Dialect() *dialect.Dialect

+ func (tx *Tx) Release(ctx context.Context, name string) error

+ func (tx *Tx) Rollback(ctx context.Context) error

+ func (tx *Tx) RollbackTo(ctx context.Context, name string) error

+ func (tx *Tx) Savepoint(ctx context.Context, name string) error

+ func (tx *Tx) SetLocal(ctx context.Context, name, value string) error

+ func (tx *Tx) SetSearch(ctx context.Context, s SearchSettings) error

+ func (tx *Tx) Tx(ctx context.Context, fn func(tx *Tx) error) error

+ type TxOptions struct

+ Isolation sql.IsolationLevel

+ ReadOnly bool

+ type UpdateQuery struct

+ func SoftDelete[T any, PT Modeler[T]](q Querier) UpdateQuery[T]

+ func Update[T any, PT Modeler[T]](q Querier) UpdateQuery[T]

+ func (u UpdateQuery[T]) AllRows() UpdateQuery[T]

+ func (u UpdateQuery[T]) Exec(ctx context.Context) (Result, error)

+ func (u UpdateQuery[T]) Model(m *T) UpdateQuery[T]

+ func (u UpdateQuery[T]) Returning(cols ...ColumnRef) UpdateQuery[T]

+ func (u UpdateQuery[T]) ReturningAll() UpdateQuery[T]

+ func (u UpdateQuery[T]) Rows(ctx context.Context) (*ModelRows[T], error)

+ func (u UpdateQuery[T]) SQL() (Compiled, error)

+ func (u UpdateQuery[T]) Set(assigns ...Assignment) UpdateQuery[T]

+ func (u UpdateQuery[T]) Where(ps ...Predicate) UpdateQuery[T]

+ type VectorColumn struct

+ func NewVectorColumn[V VectorValue](table, name string, dim int, flags uint16) VectorColumn[V]

+ func (c VectorColumn) AppendSQL(b *Builder)

+ func (c VectorColumn) AsExpr() Expression[V]

+ func (c VectorColumn) Asc() Order

+ func (c VectorColumn) ColumnName() string

+ func (c VectorColumn) Desc() Order

+ func (c VectorColumn) Dim() int

+ func (c VectorColumn) Eq(v V) Predicate

+ func (c VectorColumn) EqExpr(e Expression[V]) Predicate

+ func (c VectorColumn) Flags() uint16

+ func (c VectorColumn) In(vs ...V) Predicate

+ func (c VectorColumn) InQuery(q Subquery) Predicate

+ func (c VectorColumn) IsDistinctFrom(v V) Predicate

+ func (c VectorColumn) IsNotDistinctFrom(v V) Predicate

+ func (c VectorColumn) IsNotNull() Predicate

+ func (c VectorColumn) IsNull() Predicate

+ func (c VectorColumn) Ne(v V) Predicate

+ func (c VectorColumn) NeExpr(e Expression[V]) Predicate

+ func (c VectorColumn) NotIn(vs ...V) Predicate

+ func (c VectorColumn) NotInQuery(q Subquery) Predicate

+ func (c VectorColumn) Table() string

+ func (c VectorColumn[V]) As(alias string) VectorColumn[V]

+ func (c VectorColumn[V]) Set(v V) Assignment

+ func (c VectorColumn[V]) SetDefault() Assignment

+ func (c VectorColumn[V]) SetExcluded() Assignment

+ func (c VectorColumn[V]) SetExpr(e Expression[V]) Assignment

+ type VectorSource interface

+ type VectorValue interface

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL