Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  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
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.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)