package clause

import "gorm.io/gorm/clause"

Index ¶

• Constants
• Variables
• type AndConditions
• func (and AndConditions) Build(builder Builder)
• type Assignment
• type Builder
• type Clause
• func (c Clause) Build(builder Builder)
• type ClauseBuilder
• type Column
• type CommaExpression
• func (comma CommaExpression) Build(builder Builder)
• type Delete
• func (d Delete) Build(builder Builder)
• func (d Delete) MergeClause(clause *Clause)
• func (d Delete) Name() string
• type Eq
• func (eq Eq) Build(builder Builder)
• func (eq Eq) NegationBuild(builder Builder)
• type Expr
• func (expr Expr) Build(builder Builder)
• type Expression
• func And(exprs ...Expression) Expression
• func Not(exprs ...Expression) Expression
• func Or(exprs ...Expression) Expression
• type From
• func (from From) Build(builder Builder)
• func (from From) MergeClause(clause *Clause)
• func (from From) Name() string
• type GroupBy
• func (groupBy GroupBy) Build(builder Builder)
• func (groupBy GroupBy) MergeClause(clause *Clause)
• func (groupBy GroupBy) Name() string
• type Gt
• func (gt Gt) Build(builder Builder)
• func (gt Gt) NegationBuild(builder Builder)
• type Gte
• func (gte Gte) Build(builder Builder)
• func (gte Gte) NegationBuild(builder Builder)
• type IN
• func (in IN) Build(builder Builder)
• func (in IN) NegationBuild(builder Builder)
• type Insert
• func (insert Insert) Build(builder Builder)
• func (insert Insert) MergeClause(clause *Clause)
• func (insert Insert) Name() string
• type Interface
• type Join
• func (join Join) Build(builder Builder)
• type JoinType
• type Like
• func (like Like) Build(builder Builder)
• func (like Like) NegationBuild(builder Builder)
• type Limit
• func (limit Limit) Build(builder Builder)
• func (limit Limit) MergeClause(clause *Clause)
• func (limit Limit) Name() string
• type Locking
• func (locking Locking) Build(builder Builder)
• func (locking Locking) MergeClause(clause *Clause)
• func (locking Locking) Name() string
• type Lt
• func (lt Lt) Build(builder Builder)
• func (lt Lt) NegationBuild(builder Builder)
• type Lte
• func (lte Lte) Build(builder Builder)
• func (lte Lte) NegationBuild(builder Builder)
• type NamedExpr
• func (expr NamedExpr) Build(builder Builder)
• type NegationExpressionBuilder
• type Neq
• func (neq Neq) Build(builder Builder)
• func (neq Neq) NegationBuild(builder Builder)
• type NotConditions
• func (not NotConditions) Build(builder Builder)
• type OnConflict
• func (onConflict OnConflict) Build(builder Builder)
• func (onConflict OnConflict) MergeClause(clause *Clause)
• func (OnConflict) Name() string
• type OrConditions
• func (or OrConditions) Build(builder Builder)
• type OrderBy
• func (orderBy OrderBy) Build(builder Builder)
• func (orderBy OrderBy) MergeClause(clause *Clause)
• func (orderBy OrderBy) Name() string
• type OrderByColumn
• type Returning
• func (returning Returning) Build(builder Builder)
• func (returning Returning) MergeClause(clause *Clause)
• func (returning Returning) Name() string
• type Select
• func (s Select) Build(builder Builder)
• func (s Select) MergeClause(clause *Clause)
• func (s Select) Name() string
• type Set
• func AssignmentColumns(values []string) Set
• func Assignments(values map[string]interface{}) Set
• func (set Set) Build(builder Builder)
• func (set Set) MergeClause(clause *Clause)
• func (set Set) Name() string
• type Table
• type Update
• func (update Update) Build(builder Builder)
• func (update Update) MergeClause(clause *Clause)
• func (update Update) Name() string
• type Values
• func (values Values) Build(builder Builder)
• func (values Values) MergeClause(clause *Clause)
• func (Values) Name() string
• type Where
• func (where Where) Build(builder Builder)
• func (where Where) MergeClause(clause *Clause)
• func (where Where) Name() string
• type With
• type Writer

Constants ¶

const (
	PrimaryKey   string = "~~~py~~~" // primary key
	CurrentTable string = "~~~ct~~~" // current table
	Associations string = "~~~as~~~" // associations
)

const (
	LockingStrengthUpdate    = "UPDATE"
	LockingStrengthShare     = "SHARE"
	LockingOptionsSkipLocked = "SKIP LOCKED"
	LockingOptionsNoWait     = "NOWAIT"
)

const (
	AndWithSpace = " AND "
	OrWithSpace  = " OR "
)

Variables ¶

var (
	PrimaryColumn = Column{Table: CurrentTable, Name: PrimaryKey}
)

Types ¶

type AndConditions ¶

type AndConditions struct {
	Exprs []Expression
}

func (AndConditions) Build ¶

func (and AndConditions) Build(builder Builder)

type Assignment ¶

type Assignment struct {
	Column Column
	Value  interface{}
}

type Builder ¶

type Builder interface {
	Writer
	WriteQuoted(field interface{})
	AddVar(Writer, ...interface{})
	AddError(error) error
}

Builder builder interface

type Clause ¶

type Clause struct {
	Name                string // WHERE
	BeforeExpression    Expression
	AfterNameExpression Expression
	AfterExpression     Expression
	Expression          Expression
	Builder             ClauseBuilder
}

Clause

func (Clause) Build ¶

func (c Clause) Build(builder Builder)

Build build clause

type ClauseBuilder ¶

type ClauseBuilder func(Clause, Builder)

ClauseBuilder clause builder, allows to customize how to build clause

type Column ¶

type Column struct {
	Table string
	Name  string
	Alias string
	Raw   bool
}

Column quote with name

type CommaExpression ¶

type CommaExpression struct {
	Exprs []Expression
}

CommaExpression represents a group of expressions separated by commas.

func (CommaExpression) Build ¶

func (comma CommaExpression) Build(builder Builder)

type Delete ¶

type Delete struct {
	Modifier string
}

func (Delete) Build ¶

func (d Delete) Build(builder Builder)

func (Delete) MergeClause ¶

func (d Delete) MergeClause(clause *Clause)

func (Delete) Name ¶

func (d Delete) Name() string

type Eq ¶

type Eq struct {
	Column interface{}
	Value  interface{}
}

Eq equal to for where

func (Eq) Build ¶

func (eq Eq) Build(builder Builder)

func (Eq) NegationBuild ¶

func (eq Eq) NegationBuild(builder Builder)

type Expr ¶

type Expr struct {
	SQL                string
	Vars               []interface{}
	WithoutParentheses bool
}

Expr raw expression

func (Expr) Build ¶

func (expr Expr) Build(builder Builder)

Build build raw expression

type Expression ¶

type Expression interface {
	Build(builder Builder)
}

Expression expression interface

func And ¶

func And(exprs ...Expression) Expression

func Not ¶

func Not(exprs ...Expression) Expression

func Or ¶

func Or(exprs ...Expression) Expression

type From ¶

type From struct {
	Tables []Table
	Joins  []Join
}

From from clause

func (From) Build ¶

func (from From) Build(builder Builder)

Build build from clause

func (From) MergeClause ¶

func (from From) MergeClause(clause *Clause)

MergeClause merge from clause

func (From) Name ¶

func (from From) Name() string

Name from clause name

type GroupBy ¶

type GroupBy struct {
	Columns []Column
	Having  []Expression
}

GroupBy group by clause

func (GroupBy) Build ¶

func (groupBy GroupBy) Build(builder Builder)

Build build group by clause

func (GroupBy) MergeClause ¶

func (groupBy GroupBy) MergeClause(clause *Clause)

MergeClause merge group by clause

func (GroupBy) Name ¶

func (groupBy GroupBy) Name() string

Name from clause name

type Gt ¶

type Gt Eq

Gt greater than for where

func (Gt) Build ¶

func (gt Gt) Build(builder Builder)

func (Gt) NegationBuild ¶

func (gt Gt) NegationBuild(builder Builder)

type Gte ¶

type Gte Eq

Gte greater than or equal to for where

func (Gte) Build ¶

func (gte Gte) Build(builder Builder)

func (Gte) NegationBuild ¶

func (gte Gte) NegationBuild(builder Builder)

type IN ¶

type IN struct {
	Column interface{}
	Values []interface{}
}

IN Whether a value is within a set of values

func (IN) Build ¶

func (in IN) Build(builder Builder)

func (IN) NegationBuild ¶

func (in IN) NegationBuild(builder Builder)

type Insert ¶

type Insert struct {
	Table    Table
	Modifier string
}

func (Insert) Build ¶

func (insert Insert) Build(builder Builder)

Build build insert clause

func (Insert) MergeClause ¶

func (insert Insert) MergeClause(clause *Clause)

MergeClause merge insert clause

func (Insert) Name ¶

func (insert Insert) Name() string

Name insert clause name

type Interface ¶

type Interface interface {
	Name() string
	Build(Builder)
	MergeClause(*Clause)
}

Interface clause interface

type Join ¶

type Join struct {
	Type       JoinType
	Table      Table
	ON         Where
	Using      []string
	Expression Expression
}

Join clause for from

func (Join) Build ¶

func (join Join) Build(builder Builder)

type JoinType ¶

type JoinType string

const (
	CrossJoin JoinType = "CROSS"
	InnerJoin JoinType = "INNER"
	LeftJoin  JoinType = "LEFT"
	RightJoin JoinType = "RIGHT"
)

type Like ¶

type Like Eq

Like whether string matches regular expression

func (Like) Build ¶

func (like Like) Build(builder Builder)

func (Like) NegationBuild ¶

func (like Like) NegationBuild(builder Builder)

type Limit ¶

type Limit struct {
	Limit  *int
	Offset int
}

Limit limit clause

func (Limit) Build ¶

func (limit Limit) Build(builder Builder)

Build build where clause

func (Limit) MergeClause ¶

func (limit Limit) MergeClause(clause *Clause)

MergeClause merge order by clauses

func (Limit) Name ¶

func (limit Limit) Name() string

Name where clause name

type Locking ¶

type Locking struct {
	Strength string
	Table    Table
	Options  string
}

func (Locking) Build ¶

func (locking Locking) Build(builder Builder)

Build build where clause

func (Locking) MergeClause ¶

func (locking Locking) MergeClause(clause *Clause)

MergeClause merge order by clauses

func (Locking) Name ¶

func (locking Locking) Name() string

Name where clause name

type Lt ¶

type Lt Eq

Lt less than for where

func (Lt) Build ¶

func (lt Lt) Build(builder Builder)

func (Lt) NegationBuild ¶

func (lt Lt) NegationBuild(builder Builder)

type Lte ¶

type Lte Eq

Lte less than or equal to for where

func (Lte) Build ¶

func (lte Lte) Build(builder Builder)

func (Lte) NegationBuild ¶

func (lte Lte) NegationBuild(builder Builder)

type NamedExpr ¶

type NamedExpr struct {
	SQL  string
	Vars []interface{}
}

NamedExpr raw expression for named expr

func (NamedExpr) Build ¶

func (expr NamedExpr) Build(builder Builder)

Build build raw expression

type NegationExpressionBuilder ¶

type NegationExpressionBuilder interface {
	NegationBuild(builder Builder)
}

NegationExpressionBuilder negation expression builder

type Neq ¶

type Neq Eq

Neq not equal to for where

func (Neq) Build ¶

func (neq Neq) Build(builder Builder)

func (Neq) NegationBuild ¶

func (neq Neq) NegationBuild(builder Builder)

type NotConditions ¶

type NotConditions struct {
	Exprs []Expression
}

func (NotConditions) Build ¶

func (not NotConditions) Build(builder Builder)

type OnConflict ¶

type OnConflict struct {
	Columns      []Column
	Where        Where
	TargetWhere  Where
	OnConstraint string
	DoNothing    bool
	DoUpdates    Set
	UpdateAll    bool
}

func (OnConflict) Build ¶

func (onConflict OnConflict) Build(builder Builder)

Build build onConflict clause

func (OnConflict) MergeClause ¶

func (onConflict OnConflict) MergeClause(clause *Clause)

MergeClause merge onConflict clauses

func (OnConflict) Name ¶

func (OnConflict) Name() string

type OrConditions ¶

type OrConditions struct {
	Exprs []Expression
}

func (OrConditions) Build ¶

func (or OrConditions) Build(builder Builder)

type OrderBy ¶

type OrderBy struct {
	Columns    []OrderByColumn
	Expression Expression
}

func (OrderBy) Build ¶

func (orderBy OrderBy) Build(builder Builder)

Build build where clause

func (OrderBy) MergeClause ¶

func (orderBy OrderBy) MergeClause(clause *Clause)

MergeClause merge order by clauses

func (OrderBy) Name ¶

func (orderBy OrderBy) Name() string

Name where clause name

type OrderByColumn ¶

type OrderByColumn struct {
	Column  Column
	Desc    bool
	Reorder bool
}

type Returning ¶

type Returning struct {
	Columns []Column
}

func (Returning) Build ¶

func (returning Returning) Build(builder Builder)

Build build where clause

func (Returning) MergeClause ¶

func (returning Returning) MergeClause(clause *Clause)

MergeClause merge order by clauses

func (Returning) Name ¶

func (returning Returning) Name() string

Name where clause name

type Select ¶

type Select struct {
	Distinct   bool
	Columns    []Column
	Expression Expression
}

Select select attrs when querying, updating, creating

func (Select) Build ¶

func (s Select) Build(builder Builder)

func (Select) MergeClause ¶

func (s Select) MergeClause(clause *Clause)

func (Select) Name ¶

func (s Select) Name() string

type Set ¶

type Set []Assignment

func AssignmentColumns ¶

func AssignmentColumns(values []string) Set

func Assignments ¶

func Assignments(values map[string]interface{}) Set

func (Set) Build ¶

func (set Set) Build(builder Builder)

func (Set) MergeClause ¶

func (set Set) MergeClause(clause *Clause)

MergeClause merge assignments clauses

func (Set) Name ¶

func (set Set) Name() string

type Table ¶

type Table struct {
	Name  string
	Alias string
	Raw   bool
}

Table quote with name

type Update ¶

type Update struct {
	Modifier string
	Table    Table
}

func (Update) Build ¶

func (update Update) Build(builder Builder)

Build build update clause

func (Update) MergeClause ¶

func (update Update) MergeClause(clause *Clause)

MergeClause merge update clause

func (Update) Name ¶

func (update Update) Name() string

Name update clause name

type Values ¶

type Values struct {
	Columns []Column
	Values  [][]interface{}
}

func (Values) Build ¶

func (values Values) Build(builder Builder)

Build build from clause

func (Values) MergeClause ¶

func (values Values) MergeClause(clause *Clause)

MergeClause merge values clauses

func (Values) Name ¶

func (Values) Name() string

Name from clause name

type Where ¶

type Where struct {
	Exprs []Expression
}

Where where clause

func (Where) Build ¶

func (where Where) Build(builder Builder)

Build build where clause

func (Where) MergeClause ¶

func (where Where) MergeClause(clause *Clause)

MergeClause merge where clauses

func (Where) Name ¶

func (where Where) Name() string

Name where clause name

type With ¶

type With struct{}

type Writer ¶

type Writer interface {
	WriteByte(byte) error
	WriteString(string) (int, error)
}

Source Files ¶

clause.go delete.go expression.go from.go group_by.go insert.go joins.go limit.go locking.go on_conflict.go order_by.go returning.go select.go set.go update.go values.go where.go with.go