Help us shape the future of Go! Take the 2026 Go Developer Survey

Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

genorm

package module

Go to main page

Versions in this module

v1

v1.2.0

Nov 24, 2024

v1.1.3

Jun 22, 2024

v1.1.2

Jan 13, 2024

v1.1.1

Mar 6, 2023

Changes in this version

+ type ColumnFieldExprTypePointer interface

+ type FindContext struct

+ func Find(table T, tuple S) *FindContext[T, S, U]

+ func (c *FindContext[S, T, U]) Distinct() *FindContext[S, T, U]

+ func (c *FindContext[S, T, U]) Get(db DB) (T, error)

+ func (c *FindContext[S, T, U]) GetAll(db DB) ([]T, error)

+ func (c *FindContext[S, T, U]) GetAllCtx(ctx context.Context, db DB) ([]T, error)

+ func (c *FindContext[S, T, U]) GetCtx(ctx context.Context, db DB) (T, error)

+ func (c *FindContext[S, T, U]) GroupBy(exprs ...TableExpr[S]) *FindContext[S, T, U]

+ func (c *FindContext[S, T, U]) Having(condition TypedTableExpr[S, WrappedPrimitive[bool]]) *FindContext[S, T, U]

+ func (c *FindContext[S, T, U]) Limit(limit uint64) *FindContext[S, T, U]

+ func (c *FindContext[S, T, U]) Lock(lockType LockType) *FindContext[S, T, U]

+ func (c *FindContext[S, T, U]) Offset(offset uint64) *FindContext[S, T, U]

+ func (c *FindContext[S, T, U]) OrderBy(direction OrderDirection, expr TableExpr[S]) *FindContext[S, T, U]

+ func (c *FindContext[S, T, U]) Where(condition TypedTableExpr[S, WrappedPrimitive[bool]]) *FindContext[S, T, U]

+ type TablePointer interface

+ type Tuple interface

+ Columns func() []ColumnFieldExprType

+ Exprs func() []Expr

+ type Tuple2Struct struct

+ func Tuple2(expr1 TypedTableExpr[S, T1], expr2 TypedTableExpr[S, T2]) *Tuple2Struct[S, T1, U1, T2, U2]

+ func (t *Tuple2Struct[_, T1, _, T2, _]) Values() (T1, T2)

+ func (t *Tuple2Struct[_, _, U1, _, U2]) Columns() []ColumnFieldExprType

+ func (t *Tuple2Struct[_, _, _, _, _]) Exprs() []Expr

+ type Tuple3Struct struct

+ func Tuple3(expr1 TypedTableExpr[S, T1], expr2 TypedTableExpr[S, T2], ...) *Tuple3Struct[S, T1, U1, T2, U2, T3, U3]

+ func (t *Tuple3Struct[_, T1, _, T2, _, T3, _]) Values() (T1, T2, T3)

+ func (t *Tuple3Struct[_, _, U1, _, U2, _, U3]) Columns() []ColumnFieldExprType

+ func (t *Tuple3Struct[_, _, _, _, _, _, _]) Exprs() []Expr

+ type Tuple4Struct struct

+ func Tuple4(expr1 TypedTableExpr[S, T1], expr2 TypedTableExpr[S, T2], ...) *Tuple4Struct[S, T1, U1, T2, U2, T3, U3, T4, U4]

+ func (t *Tuple4Struct[_, T1, _, T2, _, T3, _, T4, _]) Values() (T1, T2, T3, T4)

+ func (t *Tuple4Struct[_, _, U1, _, U2, _, U3, _, U4]) Columns() []ColumnFieldExprType

+ func (t *Tuple4Struct[_, _, _, _, _, _, _, _, _]) Exprs() []Expr

+ type Tuple5Struct struct

+ func Tuple5(expr1 TypedTableExpr[S, T1], expr2 TypedTableExpr[S, T2], ...) *Tuple5Struct[S, T1, U1, T2, U2, T3, U3, T4, U4, T5, U5]

+ func (t *Tuple5Struct[_, T1, _, T2, _, T3, _, T4, _, T5, _]) Values() (T1, T2, T3, T4, T5)

+ func (t *Tuple5Struct[_, _, U1, _, U2, _, U3, _, U4, _, U5]) Columns() []ColumnFieldExprType

+ func (t *Tuple5Struct[_, _, _, _, _, _, _, _, _, _, _]) Exprs() []Expr

+ type TuplePointer interface

+ Columns func() []ColumnFieldExprType

+ Exprs func() []Expr

v1.0.1

Mar 15, 2022

v1.0.0

Mar 15, 2022

Changes in this version

+ var ErrNullValue = errors.New("null value")

+ var ErrRecordNotFound = errors.New("record not found")

+ type BasicTable interface

+ TableName func() string

+ type Column interface

+ ColumnName func() string

+ SQLColumnName func() string

+ TableName func() string

+ type ColumnFieldExprType interface

+ type Context struct

+ func (c *Context[T]) Errors() []error

+ func (c *Context[T]) Table() T

+ type DB interface

+ ExecContext func(ctx context.Context, query string, args ...any) (sql.Result, error)

+ QueryContext func(ctx context.Context, query string, args ...any) (*sql.Rows, error)

+ QueryRowContext func(ctx context.Context, query string, args ...any) *sql.Row

+ type DeleteContext struct

+ func Delete(table T) *DeleteContext[T]

+ func (c *DeleteContext[T]) Do(db DB) (rowsAffected int64, err error)

+ func (c *DeleteContext[T]) DoCtx(ctx context.Context, db DB) (rowsAffected int64, err error)

+ func (c *DeleteContext[T]) Limit(limit uint64) *DeleteContext[T]

+ func (c *DeleteContext[T]) OrderBy(direction OrderDirection, expr TableExpr[T]) *DeleteContext[T]

+ func (c *DeleteContext[T]) Where(condition TypedTableExpr[T, WrappedPrimitive[bool]]) *DeleteContext[T]

+ type Expr interface

+ Expr func() (string, []ExprType, []error)

+ type ExprPrimitive interface

+ type ExprStruct struct

+ func RawExpr(query string, args ...ExprType) *ExprStruct[T, S]

+ func (es *ExprStruct[T, _]) TableExpr(T) (string, []ExprType, []error)

+ func (es *ExprStruct[_, S]) TypedExpr(S) (string, []ExprType, []error)

+ func (es *ExprStruct[_, _]) Expr() (string, []ExprType, []error)

+ type ExprType interface

+ type InsertContext struct

+ func Insert(table T) *InsertContext[T]

+ func (c *InsertContext[T]) Do(db DB) (rowsAffected int64, err error)

+ func (c *InsertContext[T]) DoCtx(ctx context.Context, db DB) (rowsAffected int64, err error)

+ func (c *InsertContext[T]) Fields(fields ...TableColumns[T]) *InsertContext[T]

+ func (c *InsertContext[T]) Values(tableBases ...T) *InsertContext[T]

+ type JoinedTable interface

+ AddError func(error)

+ BaseTables func() []BasicTable

+ type LockType uint8

+ const ForShare

+ const ForUpdate

+ type OrderDirection uint8

+ const Asc

+ const Desc

+ type PluckContext struct

+ func Pluck(table T, field TypedTableExpr[T, S]) *PluckContext[T, S]

+ func (c *PluckContext[T, S]) Distinct() *PluckContext[T, S]

+ func (c *PluckContext[T, S]) Get(db DB) (S, error)

+ func (c *PluckContext[T, S]) GetAll(db DB) ([]S, error)

+ func (c *PluckContext[T, S]) GetAllCtx(ctx context.Context, db DB) ([]S, error)

+ func (c *PluckContext[T, S]) GetCtx(ctx context.Context, db DB) (S, error)

+ func (c *PluckContext[T, S]) GroupBy(exprs ...TableExpr[T]) *PluckContext[T, S]

+ func (c *PluckContext[T, S]) Having(condition TypedTableExpr[T, WrappedPrimitive[bool]]) *PluckContext[T, S]

+ func (c *PluckContext[T, S]) Limit(limit uint64) *PluckContext[T, S]

+ func (c *PluckContext[T, S]) Lock(lockType LockType) *PluckContext[T, S]

+ func (c *PluckContext[T, S]) Offset(offset uint64) *PluckContext[T, S]

+ func (c *PluckContext[T, S]) OrderBy(direction OrderDirection, expr TableExpr[T]) *PluckContext[T, S]

+ func (c *PluckContext[T, S]) Where(condition TypedTableExpr[T, WrappedPrimitive[bool]]) *PluckContext[T, S]

+ type Ref struct

+ type SelectContext struct

+ func Select(table T) *SelectContext[T]

+ func (c *SelectContext[T]) Distinct() *SelectContext[T]

+ func (c *SelectContext[T]) Fields(fields ...TableColumns[T]) *SelectContext[T]

+ func (c *SelectContext[T]) Get(db DB) (T, error)

+ func (c *SelectContext[T]) GetAll(db DB) ([]T, error)

+ func (c *SelectContext[T]) GetAllCtx(ctx context.Context, db DB) ([]T, error)

+ func (c *SelectContext[T]) GetCtx(ctx context.Context, db DB) (T, error)

+ func (c *SelectContext[T]) GroupBy(exprs ...TableExpr[T]) *SelectContext[T]

+ func (c *SelectContext[T]) Having(condition TypedTableExpr[T, WrappedPrimitive[bool]]) *SelectContext[T]

+ func (c *SelectContext[T]) Limit(limit uint64) *SelectContext[T]

+ func (c *SelectContext[T]) Lock(lockType LockType) *SelectContext[T]

+ func (c *SelectContext[T]) Offset(offset uint64) *SelectContext[T]

+ func (c *SelectContext[T]) OrderBy(direction OrderDirection, expr TableExpr[T]) *SelectContext[T]

+ func (c *SelectContext[T]) Where(condition TypedTableExpr[T, WrappedPrimitive[bool]]) *SelectContext[T]

+ type Table interface

+ ColumnMap func() map[string]ColumnFieldExprType

+ Columns func() []Column

+ GetErrors func() []error

+ New func() Table

+ type TableAssignExpr struct

+ func Assign(expr1 TypedTableColumns[T, S], expr2 TypedTableExpr[T, S]) *TableAssignExpr[T]

+ func AssignLit(expr TypedTableColumns[T, S], literal S) *TableAssignExpr[T]

+ func (tae *TableAssignExpr[_]) AssignExpr() (string, []ExprType, []error)

+ type TableColumns interface

+ type TableExpr interface

+ TableExpr func(T) (string, []ExprType, []error)

+ type TypedColumns interface

+ type TypedExpr interface

+ TypedExpr func(T) (string, []ExprType, []error)

+ type TypedTableColumns interface

+ type TypedTableExpr interface

+ func And(expr1 TypedTableExpr[T, WrappedPrimitive[bool]], ...) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Avg(expr TypedTableExpr[T, S], distinct bool) TypedTableExpr[T, WrappedPrimitive[float64]]

+ func Count(expr TypedTableExpr[T, S], distinct bool) TypedTableExpr[T, WrappedPrimitive[int64]]

+ func Eq(expr1 TypedTableExpr[T, S], expr2 TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func EqLit(expr TypedTableExpr[T, S], literal S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Geq(expr1 TypedTableExpr[T, S], expr2 TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func GeqLit(expr TypedTableExpr[T, S], literal S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Gt(expr1 TypedTableExpr[T, S], expr2 TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func GtLit(expr TypedTableExpr[T, S], literal S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func In(expr1 TypedTableExpr[T, S], exprs ...TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func InLit(expr TypedTableExpr[T, S], literals ...S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func IsNotNull(expr TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func IsNull(expr TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Leq(expr1 TypedTableExpr[T, S], expr2 TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func LeqLit(expr TypedTableExpr[T, S], literal S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Lt(expr1 TypedTableExpr[T, S], expr2 TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func LtLit(expr TypedTableExpr[T, S], literal S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Max(expr TypedTableExpr[T, S]) TypedTableExpr[T, S]

+ func Min(expr TypedTableExpr[T, S]) TypedTableExpr[T, S]

+ func Neq(expr1 TypedTableExpr[T, S], expr2 TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func NeqLit(expr TypedTableExpr[T, S], literal S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Not(expr TypedTableExpr[T, WrappedPrimitive[bool]]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func NotIn(expr1 TypedTableExpr[T, S], exprs ...TypedTableExpr[T, S]) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func NotInLit(expr TypedTableExpr[T, S], literals ...S) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Or(expr1 TypedTableExpr[T, WrappedPrimitive[bool]], ...) TypedTableExpr[T, WrappedPrimitive[bool]]

+ func Xor(expr1 TypedTableExpr[T, WrappedPrimitive[bool]], ...) TypedTableExpr[T, WrappedPrimitive[bool]]

+ type UpdateContext struct

+ func Update(table T) *UpdateContext[T]

+ func (c *UpdateContext[T]) Do(db DB) (rowsAffected int64, err error)

+ func (c *UpdateContext[T]) DoCtx(ctx context.Context, db DB) (rowsAffected int64, err error)

+ func (c *UpdateContext[T]) Limit(limit uint64) *UpdateContext[T]

+ func (c *UpdateContext[T]) OrderBy(direction OrderDirection, expr TableExpr[T]) *UpdateContext[T]

+ func (c *UpdateContext[T]) Set(assignExprs ...*TableAssignExpr[T]) (res *UpdateContext[T])

+ func (c *UpdateContext[T]) Where(condition TypedTableExpr[T, WrappedPrimitive[bool]]) *UpdateContext[T]

+ type WrappedPrimitive struct

+ func Wrap(val T) WrappedPrimitive[T]

+ func (wp *WrappedPrimitive[T]) Scan(src any) error

+ func (wp WrappedPrimitive[T]) Val() (T, bool)

+ func (wp WrappedPrimitive[_]) Value() (driver.Value, error)