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

genorm

package module
v1.0.1 Latest Latest
Warning

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

 Go to latest Published: Mar 15, 2022 License: MIT Imports: 7 Imported by: 1

README

GenORM

MIT License

SQL Builder to prevent SQL mistakes using the Golang generics

document

Feature

By mapping SQL expressions to appropriate golang types using generics, you can discover many SQL mistakes at the time of compilation that are not prevented by traditional Golang ORMs or query builders.

For example:

  • Compilation error occurs when using values of different Go types in SQL for = etc. comparisons or updating values in UPDATE statements
  • Compile error occurs when using column names of unavailable tables

It also supports many CRUD syntaxes in SQL.

Example

Example 1

String column `users`. `name` can be compared to a string value, but comparing it to an int value will result in a compile error.

// correct
userValues, err := genorm.
	Select(orm.User()).
	Where(genorm.EqLit(user.NameExpr, genorm.Wrap("name"))).
	GetAll(db)

// compile error
userValues, err := genorm.
	Select(orm.User()).
	Where(genorm.EqLit(user.NameExpr, genorm.Wrap(1))).
	GetAll(db)
Example 2

You can use an id column from the users table in a SELECT statement that retrieves data from the users table, but using an id column from the messages table will result in a compile error.

// correct
userValues, err := genorm.
	Select(orm.User()).
	Where(genorm.EqLit(user.IDExpr, uuid.New())).
	GetAll(db)

// compile error
userValues, err := genorm.
	Select(orm.User()).
	Where(genorm.EqLit(message.IDExpr, uuid.New())).
	GetAll(db)

Install

GenORM uses the CLI to generate code. The genormpackage is used to invoke queries. For this reason, both the CLI and Package must be install.

CLI
go install github.com/mazrean/genorm/cmd/genorm@v1.0.0
Package
go get -u github.com/mazrean/genorm
Configuration
Example

The users table can join the messages table.

import "github.com/mazrean/genorm"

type User struct {
    // Column Information
    Message genorm.Ref[Message]
}

func (*User) TableName() string {
    return "users"
}

type Message struct {
    // Column Information
}

func (*Message) TableName() string {
    return "messages"
}

Usage

Connecting to a Database
import (
  "database/sql"
  _ "github.com/go-sql-driver/mysql"
)

db, err := sql.Open("mysql", "user:pass@tcp(host:port)/database?parseTime=true&loc=Asia%2FTokyo&charset=utf8mb4")
Insert
// INSERT INTO `users` (`id`, `name`, `created_at`) VALUES ({{uuid.New()}}, "name1", {{time.Now()}}), ({{uuid.New()}}, "name2", {{time.Now()}})
affectedRows, err := genorm.
    Insert(orm.User()).
    Values(&orm.UserTable{
        ID: uuid.New(),
        Name: genorm.Wrap("name1"),
        CreatedAt: genorm.Wrap(time.Now()),
    }, &orm.UserTable{
        ID: uuid.New(),
        Name: genorm.Wrap("name2"),
        CreatedAt: genorm.Wrap(time.Now()),
    }).
    Do(db)
Select
// SELECT `id`, `name`, `created_at` FROM `users`
// userValues: []orm.UserTable
userValues, err := genorm.
	Select(orm.User()).
	GetAll(db)

// SELECT `id`, `name`, `created_at` FROM `users` LIMIT 1
// userValue: orm.UserTable
userValue, err := genorm.
	Select(orm.User()).
	Get(db)

// SELECT `id` FROM `users`
// userIDs: []uuid.UUID
userIDs, err := genorm.
	Pluck(orm.User(), user.IDExpr).
	GetAll(db)

// SELECT COUNT(`id`) AS `result` FROM `users` LIMIT 1
// userNum: int64
userNum, err := genorm.
	Pluck(orm.User(), genorm.Count(user.IDExpr, false)).
	Get(db)
Update
// UPDATE `users` SET `name`="name"
affectedRows, err = genorm.
    Update(orm.User()).
    Set(
        genorm.AssignLit(user.Name, genorm.Wrap("name")),
    ).
    Do(db)
Delete
// DELETE FROM `users`
affectedRows, err = genorm.
    Delete(orm.User()).
    Do(db)
Join
Select
// SELECT `users`.`name`, `messages`.`content` FROM `users` INNER JOIN `messages` ON `users`.`id` = `messages`.`user_id`
// messageUserValues: []orm.MessageUserTable
userID := orm.MessageUserParseExpr(user.ID)
userName := orm.MessageUserParse(user.Name)
messageUserID := orm.MessageUserParseExpr(message.UserID)
messageContent := orm.MessageUserParse(message.Content)
messageUserValues, err := genorm.
	Select(orm.User().
		Message().Join(genorm.Eq(userID, messageUserID))).
	Fields(userName, messageContent).
	GetAll(db)
Update
// UPDATE `users` INNER JOIN `messages` ON `users.id` = `messages`.`id` SET `content`="hello world"
userIDColumn := orm.MessageUserParseExpr(user.ID)
messageUserIDColumn := orm.MessageUserParseExpr(message.UserID)
messageContent := orm.MessageUserParse(message.Content)
affectedRows, err := genorm.
  Update(orm.User().
		Message().Join(genorm.Eq(userID, messageUserID))).
  Set(genorm.AssignLit(messageContent, genorm.Wrap("hello world"))).
  Do(db)
Transaction
tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

_, err = genorm.
    Insert(orm.User()).
    Values(&orm.UserTable{
        ID: uuid.New(),
        Name: genorm.Wrap("name1"),
        CreatedAt: genorm.Wrap(time.Now()),
    }, &orm.UserTable{
        ID: uuid.New(),
        Name: genorm.Wrap("name2"),
        CreatedAt: genorm.Wrap(time.Now()),
    }).
    Do(db)
if err != nil {
    _ = tx.Rollback()
    log.Fatal(err)
}

err = tx.Commit()
if err != nil {
    log.Fatal(err)
}
Context
// SELECT `id`, `name`, `created_at` FROM `users`
// userValues: []orm.UserTable
userValues, err := genorm.
	Select(orm.User()).
	GetAllCtx(context.Background(), db)

// INSERT INTO `users` (`id`, `name`, `created_at`) VALUES ({{uuid.New()}}, "name", {{time.Now()}})
affectedRows, err := genorm.
    Insert(orm.User()).
    Values(&orm.UserTable{
        ID: uuid.New(),
        Name: genorm.Wrap("name"),
        CreatedAt: genorm.Wrap(time.Now()),
    }).
    DoCtx(context.Background(), db)

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrRecordNotFound = errors.New("record not found")
	ErrNullValue      = errors.New("null value")
)

Functions

This section is empty.

Types

type BasicTable 

type BasicTable interface {
	Table
	// TableName table_name
	TableName() string
}

type Column 

type Column interface {
	Expr
	// SQLColumnName `table_name`.`column_name`
	SQLColumnName() string
	// TableName table_name
	TableName() string
	// ColumnName column_name
	ColumnName() string
}

type ColumnFieldExprType 

type ColumnFieldExprType interface {
	sql.Scanner
	driver.Valuer
}

type Context 

type Context[T Table] struct {
	// contains filtered or unexported fields
}

func (*Context[T]) Errors 

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

func (*Context[T]) Table 

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

type DB 

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

type DeleteContext 

type DeleteContext[T BasicTable] struct {
	*Context[T]
	// contains filtered or unexported fields
}

func Delete 

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

func (*DeleteContext[T]) Do 

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

func (*DeleteContext[T]) DoCtx 

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

func (*DeleteContext[T]) Limit 

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

func (*DeleteContext[T]) OrderBy 

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

func (*DeleteContext[T]) Where 

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

type Expr 

type Expr interface {
	Expr() (string, []ExprType, []error)
}

type ExprPrimitive 

type ExprPrimitive interface {
	bool |
		int | int8 | int16 | int32 | int64 |
		uint | uint8 | uint16 | uint32 | uint64 |
		float32 | float64 |
		string | time.Time
}

type ExprStruct 

type ExprStruct[T Table, S ExprType] struct {
	// contains filtered or unexported fields
}

func RawExpr 

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

func (*ExprStruct[_, _]) Expr 

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

func (*ExprStruct[T, _]) TableExpr 

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

func (*ExprStruct[_, S]) TypedExpr 

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

type ExprType 

type ExprType interface {
	driver.Valuer
}

type InsertContext 

type InsertContext[T BasicTable] struct {
	*Context[T]
	// contains filtered or unexported fields
}

func Insert 

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

func (*InsertContext[T]) Do 

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

func (*InsertContext[T]) DoCtx 

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

func (*InsertContext[T]) Fields 

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

func (*InsertContext[T]) Values 

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

type JoinedTable 

type JoinedTable interface {
	Table
	BaseTables() []BasicTable
	AddError(error)
}

type LockType 

type LockType uint8
const (
	ForUpdate LockType
	ForShare
)

type OrderDirection 

type OrderDirection uint8
const (
	Asc OrderDirection = iota + 1
	Desc
)

type PluckContext 

type PluckContext[T Table, S ExprType] struct {
	*Context[T]
	// contains filtered or unexported fields
}

func Pluck 

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

func (*PluckContext[T, S]) Distinct 

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

func (*PluckContext[T, S]) Get 

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

func (*PluckContext[T, S]) GetAll 

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

func (*PluckContext[T, S]) GetAllCtx 

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

func (*PluckContext[T, S]) GetCtx 

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

func (*PluckContext[T, S]) GroupBy 

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

func (*PluckContext[T, S]) Having 

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

func (*PluckContext[T, S]) Limit 

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

func (*PluckContext[T, S]) Lock 

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

func (*PluckContext[T, S]) Offset 

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

func (*PluckContext[T, S]) OrderBy 

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

func (*PluckContext[T, S]) Where 

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

type Ref 

type Ref[T any] struct{}

type SelectContext 

type SelectContext[T Table] struct {
	*Context[T]
	// contains filtered or unexported fields
}

func Select 

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

func (*SelectContext[T]) Distinct 

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

func (*SelectContext[T]) Fields 

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

func (*SelectContext[T]) Get 

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

func (*SelectContext[T]) GetAll 

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

func (*SelectContext[T]) GetAllCtx 

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

func (*SelectContext[T]) GetCtx 

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

func (*SelectContext[T]) GroupBy 

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

func (*SelectContext[T]) Having 

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

func (*SelectContext[T]) Limit 

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

func (*SelectContext[T]) Lock 

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

func (*SelectContext[T]) Offset 

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

func (*SelectContext[T]) OrderBy 

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

func (*SelectContext[T]) Where 

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

type Table 

type Table interface {
	Expr
	New() Table
	Columns() []Column
	// ColumnMap key: `table_name`.`column_name`
	ColumnMap() map[string]ColumnFieldExprType
	GetErrors() []error
}

type TableAssignExpr 

type TableAssignExpr[T Table] struct {
	// contains filtered or unexported fields
}

func Assign 

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

Assign expr1 = expr2

func AssignLit 

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

AssignLit expr = literal

func (*TableAssignExpr[_]) AssignExpr 

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

type TableColumns 

type TableColumns[T Table] interface {
	Column
	TableExpr[T]
}

type TableExpr 

type TableExpr[T Table] interface {
	Expr
	TableExpr(T) (string, []ExprType, []error)
}

type TypedColumns 

type TypedColumns[S ExprType] interface {
	Column
	TypedExpr[S]
}

type TypedExpr 

type TypedExpr[T ExprType] interface {
	Expr
	TypedExpr(T) (string, []ExprType, []error)
}

type TypedTableColumns 

type TypedTableColumns[T Table, S ExprType] interface {
	TableColumns[T]
	TypedColumns[S]
}

type TypedTableExpr 

type TypedTableExpr[T Table, S ExprType] interface {
	Expr
	TableExpr[T]
	TypedExpr[S]
}

func And 

func And[T Table](
	expr1 TypedTableExpr[T, WrappedPrimitive[bool]],
	expr2 TypedTableExpr[T, WrappedPrimitive[bool]],
) TypedTableExpr[T, WrappedPrimitive[bool]]

And (expr1 AND expr2)

func Avg 

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

Avg if (distinct) {return AVG(DISTINCT expr)} else {return AVG(expr)}

func Count 

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

Count if (distinct) {return COUNT(DISTINCT expr)} else {return COUNT(expr)}

func Eq 

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

Eq (expr1 = expr2)

func EqLit 

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

EqLit (expr = literal)

func Geq 

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

Geq (expr1 >= expr2)

func GeqLit 

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

GeqLit (expr >= literal)

func Gt 

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

Gt (expr1 > expr2)

func GtLit 

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

GtLit (expr > literal)

func In 

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

In (expr1 IN (exprs[0], exprs[1], ...))

func InLit 

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

InLit (expr IN (literals[0], literal[1], ...))

func IsNotNull 

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

IsNotNull (expr IS NOT NULL)

func IsNull 

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

IsNull (expr IS NULL)

func Leq 

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

Leq (expr1 <= expr2)

func LeqLit 

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

LeqLit (expr <= literal)

func Lt 

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

Lt (expr1 < expr2)

func LtLit 

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

LtLit (expr < literal)

func Max 

func Max[T Table, S ExprType](expr TypedTableExpr[T, S]) TypedTableExpr[T, S]

Max MAX(expr)

func Min 

func Min[T Table, S ExprType](expr TypedTableExpr[T, S]) TypedTableExpr[T, S]

Min MIN(expr)

func Neq 

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

Neq (expr1 != expr2)

func NeqLit 

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

NeqLit (expr != literal)

func Not 

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

Not (NOT expr)

func NotIn 

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

NotIn (expr1 NOT IN (exprs[0], exprs[1], ...))

func NotInLit 

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

NotInLit (expr NOT IN (literals[0], literal[1], ...))

func Or 

func Or[T Table](
	expr1 TypedTableExpr[T, WrappedPrimitive[bool]],
	expr2 TypedTableExpr[T, WrappedPrimitive[bool]],
) TypedTableExpr[T, WrappedPrimitive[bool]]

Or (expr1 OR expr2)

func Xor 

func Xor[T Table](
	expr1 TypedTableExpr[T, WrappedPrimitive[bool]],
	expr2 TypedTableExpr[T, WrappedPrimitive[bool]],
) TypedTableExpr[T, WrappedPrimitive[bool]]

Xor (expr1 XOR expr2)

type UpdateContext 

type UpdateContext[T Table] struct {
	*Context[T]
	// contains filtered or unexported fields
}

func Update 

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

func (*UpdateContext[T]) Do 

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

func (*UpdateContext[T]) DoCtx 

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

func (*UpdateContext[T]) Limit 

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

func (*UpdateContext[T]) OrderBy 

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

func (*UpdateContext[T]) Set 

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

func (*UpdateContext[T]) Where 

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

type WrappedPrimitive 

type WrappedPrimitive[T ExprPrimitive] struct {
	// contains filtered or unexported fields
}

func Wrap 

func Wrap[T ExprPrimitive](val T) WrappedPrimitive[T]

func (*WrappedPrimitive[T]) Scan 

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

func (WrappedPrimitive[T]) Val 

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

func (WrappedPrimitive[_]) Value 

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

Source Files

View all Source files

Directories

Path Synopsis
cmd
genorm command
genorm/generator
genorm/generator/codegen
genorm/generator/convert
genorm/generator/parser
genorm/generator/types

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.