sqlbuilder

package module

Go to main page

Versions in this module

v1

v1.4.0

Nov 23, 2023

Changes in this version

type OrderingTerm

+ func OrderAscNullsFirst(expr AsExpr) *OrderingTerm

+ func OrderAscNullsLast(expr AsExpr) *OrderingTerm

+ func OrderDefaultNullsFirst(expr AsExpr) *OrderingTerm

+ func OrderDefaultNullsLast(expr AsExpr) *OrderingTerm

+ func OrderDescNullsFirst(expr AsExpr) *OrderingTerm

+ func OrderDescNullsLast(expr AsExpr) *OrderingTerm

v1.3.0

Aug 16, 2023

Changes in this version

+ type FuncTableWithoutNameExpr struct

+ func FuncTableWithoutName(expr *FuncExpr, names ...string) *FuncTableWithoutNameExpr

+ func (t *FuncTableWithoutNameExpr) AsTableOrSubquery(s *Serializer)

+ func (t *FuncTableWithoutNameExpr) C(name string) *BasicColumn

+ func (t *FuncTableWithoutNameExpr) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (t *FuncTableWithoutNameExpr) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (t *FuncTableWithoutNameExpr) LeftJoin(right AsTableOrSubquery) *JoinExpr

v1.2.0

Jul 25, 2023

Changes in this version

+ type UpdateField struct

+ Name AsNamedShort

+ Value AsExpr

type UpdateStatement

+ func (s *UpdateStatement) AndField(field UpdateField) *UpdateStatement

+ func (s *UpdateStatement) Fields(fields []UpdateField) *UpdateStatement

v1.1.0

Jul 25, 2023

Changes in this version

type InsertStatement

+ func (s *InsertStatement) Returning(returning ...AsExpr) *InsertStatement

+ type TypedLiteralExpr struct

+ func TypedLiteral(typ, text string) *TypedLiteralExpr

+ func (e *TypedLiteralExpr) As(alias string) *ColumnAlias

+ func (l *TypedLiteralExpr) AsExpr(s *Serializer)

type UpdateStatement

+ func (s *UpdateStatement) AndWith(with ...AsCommonTableExpression) *UpdateStatement

+ func (s *UpdateStatement) From(from AsTableOrSubquery) *UpdateStatement

+ func (s *UpdateStatement) GetTarget() AsTableOrSubquery

+ func (s *UpdateStatement) Returning(returning ...AsExpr) *UpdateStatement

+ func (s *UpdateStatement) Target(target AsTableOrSubquery) *UpdateStatement

+ func (s *UpdateStatement) With(with ...AsCommonTableExpression) *UpdateStatement

v1.0.1

Apr 15, 2023

Changes in this version

+ type AsCommonTableExpression interface

+ AsCommonTableExpression func(s *Serializer)

+ IsRecursive func() bool

+ type AsDistinct interface

+ AsDistinct func(s *Serializer)

+ type AsExpr interface

+ AsExpr func(s *Serializer)

+ func BindAllAsExpr(vals ...interface{}) []AsExpr

+ func BindAllIntsAsExpr(vals ...int) []AsExpr

+ func BindAllStringsAsExpr(vals ...string) []AsExpr

+ type AsNamed interface

+ AsNamed func(s *Serializer)

+ type AsNamedShort interface

+ AsNamedShort func(s *Serializer)

+ type AsOffsetLimit interface

+ AsOffsetLimit func(s *Serializer)

+ type AsOrderingTerm interface

+ AsOrderingTerm func(s *Serializer)

+ type AsResultColumn interface

+ AsResultColumn func(s *Serializer)

+ type AsTableOrSubquery interface

+ AsTableOrSubquery func(s *Serializer)

+ type AsTableOrSubqueryAndWithColumns interface

+ type AsUnion interface

+ AsUnion func(s *Serializer)

+ type BasicColumn struct

+ func BareColumn(name string) *BasicColumn

+ func (c *BasicColumn) As(alias string) *ColumnAlias

+ func (c *BasicColumn) AsExpr(s *Serializer)

+ func (c *BasicColumn) AsNamedShort(s *Serializer)

+ type BinaryOperatorExpr struct

+ func And(left, right AsExpr) *BinaryOperatorExpr

+ func BinaryOperator(operator string, left, right AsExpr) *BinaryOperatorExpr

+ func Eq(left, right AsExpr) *BinaryOperatorExpr

+ func Gt(left, right AsExpr) *BinaryOperatorExpr

+ func Gte(left, right AsExpr) *BinaryOperatorExpr

+ func Lt(left, right AsExpr) *BinaryOperatorExpr

+ func Lte(left, right AsExpr) *BinaryOperatorExpr

+ func Ne(left, right AsExpr) *BinaryOperatorExpr

+ func Or(left, right AsExpr) *BinaryOperatorExpr

+ func (o *BinaryOperatorExpr) AsExpr(s *Serializer)

+ type BooleanOperatorExpr struct

+ func BooleanOperator(operator string, elements ...AsExpr) *BooleanOperatorExpr

+ func (b *BooleanOperatorExpr) AsExpr(s *Serializer)

+ type BoundVariable struct

+ func Bind(value interface{}) *BoundVariable

+ func (b *BoundVariable) As(alias string) *ColumnAlias

+ func (b *BoundVariable) AsExpr(s *Serializer)

+ type CaseExpr struct

+ func Case(inputExpr AsExpr) *CaseExpr

+ func (c *CaseExpr) AsExpr(s *Serializer)

+ func (c *CaseExpr) Else(elseExpr AsExpr) *CaseExpr

+ func (c *CaseExpr) When(whenClause ...*CaseWhenClause) *CaseExpr

+ type CaseWhenClause struct

+ func CaseWhen(whenExpr, resultExpr AsExpr) *CaseWhenClause

+ type CastExpr struct

+ func Cast(expr AsExpr, as string) *CastExpr

+ func (c *CastExpr) AsExpr(s *Serializer)

+ type ColumnAlias struct

+ func AliasColumn(expr AsExpr, alias string) *ColumnAlias

+ func (e *ColumnAlias) As(alias string) *ColumnAlias

+ func (e *ColumnAlias) AsExpr(s *Serializer)

+ func (e *ColumnAlias) AsResultColumn(s *Serializer)

+ type CommonTableExpressionExpr struct

+ func CommonTableExpression(name string) *CommonTableExpressionExpr

+ func (e *CommonTableExpressionExpr) As(as *SelectStatement) *CommonTableExpressionExpr

+ func (e *CommonTableExpressionExpr) AsCommonTableExpression(s *Serializer)

+ func (e *CommonTableExpressionExpr) AsNamed(s *Serializer)

+ func (e *CommonTableExpressionExpr) AsTableOrSubquery(s *Serializer)

+ func (e *CommonTableExpressionExpr) C(name string) *BasicColumn

+ func (e *CommonTableExpressionExpr) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (e *CommonTableExpressionExpr) IsRecursive() bool

+ func (e *CommonTableExpressionExpr) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (e *CommonTableExpressionExpr) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ func (e *CommonTableExpressionExpr) Recursive(recursive bool) *CommonTableExpressionExpr

+ type DeleteStatement struct

+ func Delete() *DeleteStatement

+ func (q *DeleteStatement) AsStatement(s *Serializer)

+ func (s *DeleteStatement) Table(table *Table) *DeleteStatement

+ func (s *DeleteStatement) Where(where AsExpr) *DeleteStatement

+ type Dialect interface

+ Bind func(i int) string

+ QuoteName func(name string) string

+ type DialectGeneric struct

+ func (DialectGeneric) Bind(i int) string

+ func (DialectGeneric) QuoteName(name string) string

+ type DialectMSSQL struct

+ QuoteEverything bool

+ func (DialectMSSQL) Bind(i int) string

+ func (d DialectMSSQL) QuoteName(name string) string

+ type DialectPostgres struct

+ func (DialectPostgres) Bind(i int) string

+ func (DialectPostgres) QuoteName(name string) string

+ type DialectSQLite struct

+ func (DialectSQLite) Bind(i int) string

+ func (DialectSQLite) QuoteName(name string) string

+ type DistinctExpr struct

+ func Distinct(on ...AsExpr) *DistinctExpr

+ func (e *DistinctExpr) AsDistinct(s *Serializer)

+ type ExpressionTableExpr struct

+ func ExpressionTable(expr AsExpr, name string, names ...string) *ExpressionTableExpr

+ func (t *ExpressionTableExpr) AsNamed(s *Serializer)

+ func (t *ExpressionTableExpr) AsTableOrSubquery(s *Serializer)

+ func (t *ExpressionTableExpr) C(name string) *BasicColumn

+ func (t *ExpressionTableExpr) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (t *ExpressionTableExpr) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (t *ExpressionTableExpr) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ type FilterExpr struct

+ func Filter(left, right AsExpr) *FilterExpr

+ func (c *FilterExpr) AsExpr(s *Serializer)

+ type FuncExpr struct

+ func Func(name string, args ...AsExpr) *FuncExpr

+ func (e *FuncExpr) As(alias string) *ColumnAlias

+ func (e *FuncExpr) AsExpr(s *Serializer)

+ type FuncTableExpr struct

+ func FuncTable(expr *FuncExpr, name string) *FuncTableExpr

+ func (t *FuncTableExpr) AsNamed(s *Serializer)

+ func (t *FuncTableExpr) AsTableOrSubquery(s *Serializer)

+ func (t *FuncTableExpr) C(name string) *BasicColumn

+ func (t *FuncTableExpr) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (t *FuncTableExpr) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (t *FuncTableExpr) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ type InOperatorExpr struct

+ func In(expr AsExpr, v ...AsExpr) *InOperatorExpr

+ func InOperator(operator string, expr AsExpr, v ...AsExpr) *InOperatorExpr

+ func NotIn(expr AsExpr, v ...AsExpr) *InOperatorExpr

+ func (o *InOperatorExpr) AsExpr(s *Serializer)

+ type InfixOperatorExpr struct

+ func InfixOperator(operator string, exprs ...AsExpr) *InfixOperatorExpr

+ func (o *InfixOperatorExpr) AsExpr(s *Serializer)

+ type InsertColumns map[*BasicColumn]AsExpr

+ type InsertStatement struct

+ func Insert() *InsertStatement

+ func (q *InsertStatement) AsStatement(s *Serializer)

+ func (s *InsertStatement) Columns(columns InsertColumns) *InsertStatement

+ func (s *InsertStatement) Table(table *Table) *InsertStatement

+ type JoinExpr struct

+ func CrossJoin(left, right AsTableOrSubquery) *JoinExpr

+ func Join(kind string, left, right AsTableOrSubquery) *JoinExpr

+ func LeftJoin(left, right AsTableOrSubquery) *JoinExpr

+ func (j *JoinExpr) AsTableOrSubquery(s *Serializer)

+ func (j *JoinExpr) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (j *JoinExpr) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (j *JoinExpr) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ func (j *JoinExpr) On(condition AsExpr) *JoinExpr

+ type LikeOperatorExpr struct

+ func Like(left, right AsExpr) *LikeOperatorExpr

+ func (o *LikeOperatorExpr) AsExpr(s *Serializer)

+ type LiteralExpr struct

+ func Literal(text string) *LiteralExpr

+ func (e *LiteralExpr) As(alias string) *ColumnAlias

+ func (l *LiteralExpr) AsExpr(s *Serializer)

+ type MSSQLDistinctExpr struct

+ func MSSQLDistinct() *MSSQLDistinctExpr

+ func (e *MSSQLDistinctExpr) AsDistinct(s *Serializer)

+ type MSSQLOffsetLimitClause struct

+ func MSSQLOffsetLimit(offset, limit AsExpr) *MSSQLOffsetLimitClause

+ func (c *MSSQLOffsetLimitClause) AsOffsetLimit(s *Serializer)

+ type OffsetLimitClause struct

+ func OffsetLimit(offset, limit AsExpr) *OffsetLimitClause

+ func (c *OffsetLimitClause) AsOffsetLimit(s *Serializer)

+ type OrderingTerm struct

+ func OrderAsc(expr AsExpr) *OrderingTerm

+ func OrderDefault(expr AsExpr) *OrderingTerm

+ func OrderDesc(expr AsExpr) *OrderingTerm

+ func (t *OrderingTerm) AsOrderingTerm(s *Serializer)

+ type PostfixOperatorExpr struct

+ func IsNotNull(expr AsExpr) *PostfixOperatorExpr

+ func IsNull(expr AsExpr) *PostfixOperatorExpr

+ func PostfixOperator(expr AsExpr, operator string) *PostfixOperatorExpr

+ func (o *PostfixOperatorExpr) AsExpr(s *Serializer)

+ type PrefixOperatorExpr struct

+ func Not(expr AsExpr) *PrefixOperatorExpr

+ func PrefixOperator(operator string, expr AsExpr) *PrefixOperatorExpr

+ func (o *PrefixOperatorExpr) AsExpr(s *Serializer)

+ type SelectStatement struct

+ func Select() *SelectStatement

+ func (q *SelectStatement) As(alias string) AsExpr

+ func (q *SelectStatement) AsExpr(s *Serializer)

+ func (q *SelectStatement) AsStatement(s *Serializer)

+ func (q *SelectStatement) AsTableOrSubquery(s *Serializer)

+ func (q *SelectStatement) C(name string) *BasicColumn

+ func (q *SelectStatement) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (q *SelectStatement) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (q *SelectStatement) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ func (s *SelectStatement) AndOrderBy(orderBy ...AsOrderingTerm) *SelectStatement

+ func (s *SelectStatement) AndUnion(union ...AsUnion) *SelectStatement

+ func (s *SelectStatement) AndWhere(where AsExpr) *SelectStatement

+ func (s *SelectStatement) AndWith(with ...AsCommonTableExpression) *SelectStatement

+ func (s *SelectStatement) Columns(columns ...AsExpr) *SelectStatement

+ func (s *SelectStatement) Distinct(distinct AsDistinct) *SelectStatement

+ func (s *SelectStatement) From(from AsTableOrSubquery) *SelectStatement

+ func (s *SelectStatement) GetFrom() AsTableOrSubquery

+ func (s *SelectStatement) GetWhere() AsExpr

+ func (s *SelectStatement) GroupBy(groupBy ...AsExpr) *SelectStatement

+ func (s *SelectStatement) Having(having AsExpr) *SelectStatement

+ func (s *SelectStatement) OffsetLimit(offsetLimit AsOffsetLimit) *SelectStatement

+ func (s *SelectStatement) OrderBy(orderBy ...AsOrderingTerm) *SelectStatement

+ func (s *SelectStatement) Union(union ...AsUnion) *SelectStatement

+ func (s *SelectStatement) Where(where AsExpr) *SelectStatement

+ func (s *SelectStatement) With(with ...AsCommonTableExpression) *SelectStatement

+ type Serializer struct

+ func NewSerializer(d Dialect) *Serializer

+ func (s *Serializer) Bind(val interface{}) *BoundVariable

+ func (s *Serializer) BindAllAsExpr(vals ...interface{}) []AsExpr

+ func (s *Serializer) BindAllIntsAsExpr(vals ...int) []AsExpr

+ func (s *Serializer) BindAllStringsAsExpr(vals ...string) []AsExpr

+ func (s *Serializer) D(data string) *Serializer

+ func (s *Serializer) DC(data string, w bool) *Serializer

+ func (s *Serializer) F(f func(s *Serializer)) *Serializer

+ func (s *Serializer) FC(f func(s *Serializer), w bool) *Serializer

+ func (s *Serializer) N(name string) *Serializer

+ func (s *Serializer) NC(name string, w bool) *Serializer

+ func (s *Serializer) SetDialect(d Dialect)

+ func (s *Serializer) ToSQL() (string, []interface{}, error)

+ func (s *Serializer) V(val interface{}) *Serializer

+ func (s *Serializer) VC(val interface{}, w bool) *Serializer

+ type Table struct

+ func NewTable(name string, columns ...string) *Table

+ func (t *Table) AsNamed(s *Serializer)

+ func (t *Table) AsTableOrSubquery(s *Serializer)

+ func (t *Table) C(name string) *BasicColumn

+ func (t *Table) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (t *Table) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (t *Table) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ type TableAlias struct

+ func AliasTable(t AsTableOrSubqueryAndWithColumns, name string) *TableAlias

+ func (a *TableAlias) AsNamed(s *Serializer)

+ func (a *TableAlias) AsTableOrSubquery(s *Serializer)

+ func (a *TableAlias) C(name string) *BasicColumn

+ func (a *TableAlias) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (a *TableAlias) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (a *TableAlias) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ type UnionExpr struct

+ func Union(all bool, stmt *SelectStatement) *UnionExpr

+ func (e *UnionExpr) AsUnion(s *Serializer)

+ type UpdateColumns map[*BasicColumn]AsExpr

+ type UpdateStatement struct

+ func Update() *UpdateStatement

+ func (q *UpdateStatement) AsStatement(s *Serializer)

+ func (s *UpdateStatement) AndSet(column *BasicColumn, expr AsExpr) *UpdateStatement

+ func (s *UpdateStatement) Set(set UpdateColumns) *UpdateStatement

+ func (s *UpdateStatement) Table(table *Table) *UpdateStatement

+ func (s *UpdateStatement) Where(where AsExpr) *UpdateStatement

+ type ValuesExpr struct

+ func Values(rows ...*ValuesRowExpr) *ValuesExpr

+ func (v *ValuesExpr) AsExpr(s *Serializer)

+ type ValuesRowExpr struct

+ func ValuesRow(values ...AsExpr) *ValuesRowExpr

+ func (r *ValuesRowExpr) AsExpr(s *Serializer)

+ type ValuesTableExpr struct

+ func ValuesTable(expr *ValuesExpr, name string, names ...string) *ValuesTableExpr

+ func (t *ValuesTableExpr) AsNamed(s *Serializer)

+ func (t *ValuesTableExpr) AsTableOrSubquery(s *Serializer)

+ func (t *ValuesTableExpr) C(name string) *BasicColumn

+ func (t *ValuesTableExpr) CrossJoin(right AsTableOrSubquery) *JoinExpr

+ func (t *ValuesTableExpr) Join(kind string, right AsTableOrSubquery) *JoinExpr

+ func (t *ValuesTableExpr) LeftJoin(right AsTableOrSubquery) *JoinExpr

+ type WithColumns interface

+ C func(name string) *BasicColumn

v1.0.0

Dec 15, 2019

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL