clause

Documentation

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 (
	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)
}