Documentation ¶
Overview ¶
Package sqlz implements an SQL query builder based on github.com/jmoiron/sqlx.
Index ¶
- type AndOrCondition
- type ArrayCondition
- func EqAll(arr interface{}, value interface{}) ArrayCondition
- func EqAny(arr interface{}, value interface{}) ArrayCondition
- func GtAll(arr interface{}, value interface{}) ArrayCondition
- func GtAny(arr interface{}, value interface{}) ArrayCondition
- func GteAll(arr interface{}, value interface{}) ArrayCondition
- func GteAny(arr interface{}, value interface{}) ArrayCondition
- func LikeAny(arr interface{}, value interface{}) ArrayCondition
- func LtAll(arr interface{}, value interface{}) ArrayCondition
- func LtAny(arr interface{}, value interface{}) ArrayCondition
- func LteAll(arr interface{}, value interface{}) ArrayCondition
- func LteAny(arr interface{}, value interface{}) ArrayCondition
- func NeAll(arr interface{}, value interface{}) ArrayCondition
- func NeAny(arr interface{}, value interface{}) ArrayCondition
- type AuxStmt
- type ConflictAction
- type ConflictClause
- func (conflict *ConflictClause) DoNothing() *ConflictClause
- func (conflict *ConflictClause) DoUpdate() *ConflictClause
- func (conflict *ConflictClause) Set(col string, val interface{}) *ConflictClause
- func (conflict *ConflictClause) SetIf(col string, val interface{}, b bool) *ConflictClause
- func (conflict *ConflictClause) SetMap(vals map[string]interface{}) *ConflictClause
- func (conflict *ConflictClause) ToSQL() (asSQL string, bindings []interface{})
- type DB
- func (db *DB) DeleteFrom(table string) *DeleteStmt
- func (db *DB) InsertInto(table string) *InsertStmt
- func (db *DB) Select(cols ...string) *SelectStmt
- func (db *DB) Transactional(f func(tx *Tx) error) error
- func (db *DB) TransactionalContext(ctx context.Context, opts *sql.TxOptions, f func(tx *Tx) error) error
- func (db *DB) Update(table string) *UpdateStmt
- func (db *DB) With(stmt SQLStmt, as string) *WithStmt
- type DeleteStmt
- func (stmt *DeleteStmt) Exec() (res sql.Result, err error)
- func (stmt *DeleteStmt) ExecContext(ctx context.Context) (res sql.Result, err error)
- func (stmt *DeleteStmt) GetAll(into interface{}) error
- func (stmt *DeleteStmt) GetAllContext(ctx context.Context, into interface{}) error
- func (stmt *DeleteStmt) GetRow(into interface{}) error
- func (stmt *DeleteStmt) GetRowContext(ctx context.Context, into interface{}) error
- func (stmt *DeleteStmt) Returning(cols ...string) *DeleteStmt
- func (stmt *DeleteStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
- func (stmt *DeleteStmt) Using(tables ...string) *DeleteStmt
- func (stmt *DeleteStmt) Where(conds ...WhereCondition) *DeleteStmt
- type Ext
- type InCondition
- type IndirectValue
- type InsertStmt
- func (stmt *InsertStmt) Columns(cols ...string) *InsertStmt
- func (stmt *InsertStmt) Exec() (res sql.Result, err error)
- func (stmt *InsertStmt) ExecContext(ctx context.Context) (res sql.Result, err error)
- func (stmt *InsertStmt) FromSelect(selStmt *SelectStmt) *InsertStmt
- func (stmt *InsertStmt) GetAll(into interface{}) error
- func (stmt *InsertStmt) GetAllContext(ctx context.Context, into interface{}) error
- func (stmt *InsertStmt) GetRow(into interface{}) error
- func (stmt *InsertStmt) GetRowContext(ctx context.Context, into interface{}) error
- func (stmt *InsertStmt) OnConflict(clause *ConflictClause) *InsertStmt
- func (stmt *InsertStmt) OnConflictDoNothing() *InsertStmt
- func (stmt *InsertStmt) OrAbort() *InsertStmt
- func (stmt *InsertStmt) OrFail() *InsertStmt
- func (stmt *InsertStmt) OrIgnore() *InsertStmt
- func (stmt *InsertStmt) OrReplace() *InsertStmt
- func (stmt *InsertStmt) OrRollback() *InsertStmt
- func (stmt *InsertStmt) Returning(cols ...string) *InsertStmt
- func (stmt *InsertStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
- func (stmt *InsertStmt) ValueMap(vals map[string]interface{}) *InsertStmt
- func (stmt *InsertStmt) ValueMultiple(vals [][]interface{}) *InsertStmt
- func (stmt *InsertStmt) Values(vals ...interface{}) *InsertStmt
- type JSONBBuilder
- type JSONBObject
- type JoinClause
- type JoinType
- type LockClause
- type LockStrength
- type LockWait
- type OrderColumn
- type PreCondition
- type Queryer
- type SQLCondition
- type SQLStmt
- type SelectStmt
- func (stmt *SelectStmt) Distinct(cols ...string) *SelectStmt
- func (stmt *SelectStmt) From(table string) *SelectStmt
- func (stmt *SelectStmt) FullJoin(table string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) FullJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) GetAll(into interface{}) error
- func (stmt *SelectStmt) GetAllAsMaps() (maps []map[string]interface{}, err error)
- func (stmt *SelectStmt) GetAllAsRows() (rows *sqlx.Rows, err error)
- func (stmt *SelectStmt) GetAllAsRowsContext(ctx context.Context) (rows *sqlx.Rows, err error)
- func (stmt *SelectStmt) GetAllContext(ctx context.Context, into interface{}) error
- func (stmt *SelectStmt) GetCount() (count int64, err error)
- func (stmt *SelectStmt) GetCountContext(ctx context.Context) (count int64, err error)
- func (stmt *SelectStmt) GetRow(into interface{}) error
- func (stmt *SelectStmt) GetRowAsMap() (results map[string]interface{}, err error)
- func (stmt *SelectStmt) GetRowContext(ctx context.Context, into interface{}) error
- func (stmt *SelectStmt) GroupBy(cols ...string) *SelectStmt
- func (stmt *SelectStmt) Having(conditions ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) InnerJoin(table string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) InnerJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) InnerLateralJoin(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) Join(joinType JoinType, table string, resultSet *SelectStmt, ...) *SelectStmt
- func (stmt *SelectStmt) LeftJoin(table string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) LeftJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) LeftLateralJoin(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) Limit(limit int64) *SelectStmt
- func (stmt *SelectStmt) Lock(lock *LockClause) *SelectStmt
- func (stmt *SelectStmt) Offset(start int64, rows ...int64) *SelectStmt
- func (stmt *SelectStmt) OrderBy(cols ...SQLStmt) *SelectStmt
- func (stmt *SelectStmt) RightJoin(table string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) RightJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) RightLateralJoin(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
- func (stmt *SelectStmt) Union(statements ...*SelectStmt) *SelectStmt
- func (stmt *SelectStmt) UnionAll(statements ...*SelectStmt) *SelectStmt
- func (stmt *SelectStmt) Where(conditions ...WhereCondition) *SelectStmt
- func (stmt *SelectStmt) WithNullsFirst() *SelectStmt
- func (stmt *SelectStmt) WithNullsLast() *SelectStmt
- type SimpleCondition
- func Eq(col string, value interface{}) SimpleCondition
- func Gt(col string, value interface{}) SimpleCondition
- func Gte(col string, value interface{}) SimpleCondition
- func ILike(col string, value interface{}) SimpleCondition
- func IsNotNull(col string) SimpleCondition
- func IsNull(col string) SimpleCondition
- func JSONBOp(op string, left string, value interface{}) SimpleCondition
- func Like(col string, value interface{}) SimpleCondition
- func Lt(col string, value interface{}) SimpleCondition
- func Lte(col string, value interface{}) SimpleCondition
- func Ne(col string, value interface{}) SimpleCondition
- func NotLike(col string, value interface{}) SimpleCondition
- type Statment
- type SubqueryCondition
- type Tx
- type UpdateFunction
- type UpdateStmt
- func (stmt *UpdateStmt) Exec() (res sql.Result, err error)
- func (stmt *UpdateStmt) ExecContext(ctx context.Context) (res sql.Result, err error)
- func (stmt *UpdateStmt) FromSelect(selStmt *SelectStmt, alias string) *UpdateStmt
- func (stmt *UpdateStmt) GetAll(into interface{}) error
- func (stmt *UpdateStmt) GetAllContext(ctx context.Context, into interface{}) error
- func (stmt *UpdateStmt) GetRow(into interface{}) error
- func (stmt *UpdateStmt) GetRowContext(ctx context.Context, into interface{}) error
- func (stmt *UpdateStmt) Returning(cols ...string) *UpdateStmt
- func (stmt *UpdateStmt) Set(col string, value interface{}) *UpdateStmt
- func (stmt *UpdateStmt) SetIf(col string, value interface{}, b bool) *UpdateStmt
- func (stmt *UpdateStmt) SetMap(updates map[string]interface{}) *UpdateStmt
- func (stmt *UpdateStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
- func (stmt *UpdateStmt) Where(conditions ...WhereCondition) *UpdateStmt
- type WhereCondition
- type WithStmt
- func (stmt *WithStmt) And(auxStmt SQLStmt, as string) *WithStmt
- func (stmt *WithStmt) Exec() (res sql.Result, err error)
- func (stmt *WithStmt) ExecContext(ctx context.Context) (res sql.Result, err error)
- func (stmt *WithStmt) GetAll(into interface{}) error
- func (stmt *WithStmt) GetAllAsRows() (rows *sqlx.Rows, err error)
- func (stmt *WithStmt) GetAllContext(ctx context.Context, into interface{}) error
- func (stmt *WithStmt) GetRow(into interface{}) error
- func (stmt *WithStmt) GetRowContext(ctx context.Context, into interface{}) error
- func (stmt *WithStmt) Then(mainStmt SQLStmt) *WithStmt
- func (stmt *WithStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type AndOrCondition ¶
type AndOrCondition struct { Or bool Conditions []WhereCondition }
AndOrCondition represents a group of AND or OR conditions.
func And ¶
func And(conds ...WhereCondition) AndOrCondition
And joins multiple where conditions as an AndOrCondition (representing AND conditions). You will use this a lot less than Or as passing multiple conditions to functions like Where or Having are all AND conditions.
func Or ¶
func Or(conds ...WhereCondition) AndOrCondition
Or joins multiple where conditions as an AndOrCondition (representing OR conditions).
func (AndOrCondition) Parse ¶
func (andOr AndOrCondition) Parse() (asSQL string, bindings []interface{})
Parse implements the WhereCondition interface, generating SQL from the condition
type ArrayCondition ¶
ArrayCondition represents an array comparison condition
func EqAll ¶
func EqAll(arr interface{}, value interface{}) ArrayCondition
EqAll creates an "= ALL" condition on an array
func EqAny ¶
func EqAny(arr interface{}, value interface{}) ArrayCondition
EqAny creates an "= ANY" condition on an array column
func GtAll ¶
func GtAll(arr interface{}, value interface{}) ArrayCondition
GtAll creates an "> ALL" condition on an array
func GtAny ¶
func GtAny(arr interface{}, value interface{}) ArrayCondition
GtAny creates an "> ANY" condition on an array
func GteAll ¶
func GteAll(arr interface{}, value interface{}) ArrayCondition
GteAll creates an ">= ALL" condition on an array
func GteAny ¶
func GteAny(arr interface{}, value interface{}) ArrayCondition
GteAny creates an ">= ANY" condition on an array
func LikeAny ¶
func LikeAny(arr interface{}, value interface{}) ArrayCondition
LikeAny creates an "Like ANY" condition on an array
func LtAll ¶
func LtAll(arr interface{}, value interface{}) ArrayCondition
LtAll creates an "< ALL" condition on an array
func LtAny ¶
func LtAny(arr interface{}, value interface{}) ArrayCondition
LtAny creates an "< ANY" condition on an array
func LteAll ¶
func LteAll(arr interface{}, value interface{}) ArrayCondition
LteAll creates an "<= ALL" condition on an array
func LteAny ¶
func LteAny(arr interface{}, value interface{}) ArrayCondition
LteAny creates an "<= ANY" condition on an array
func NeAll ¶
func NeAll(arr interface{}, value interface{}) ArrayCondition
NeAll creates an "<> ALL" condition on an array
func NeAny ¶
func NeAny(arr interface{}, value interface{}) ArrayCondition
NeAny creates an "<> ANY" condition on an array
func (ArrayCondition) Parse ¶
func (array ArrayCondition) Parse() (asSQL string, bindings []interface{})
Parse implements the WhereCondition interface, generating SQL from the condition
type AuxStmt ¶
AuxStmt represents an auxiliary statement that is part of a WITH query. It includes the statement itself, and the name used for referencing it in other queries
type ConflictAction ¶
type ConflictAction string
ConflictAction represents an action to perform on an INSERT conflict
const ( DoNothing ConflictAction = "nothing" DoUpdate ConflictAction = "update" )
type ConflictClause ¶
type ConflictClause struct { Targets []string Action ConflictAction SetCols []string SetVals []interface{} Updates map[string]interface{} }
ConflictClause represents an ON CONFLICT clause in an INSERT statement
func OnConflict ¶
func OnConflict(targets ...string) *ConflictClause
OnConflict gets a list of targets and creates a new ConflictClause object
func (*ConflictClause) DoNothing ¶
func (conflict *ConflictClause) DoNothing() *ConflictClause
DoNothing sets the conflict clause's action as DO NOTHING
func (*ConflictClause) DoUpdate ¶
func (conflict *ConflictClause) DoUpdate() *ConflictClause
DoUpdate sets the conflict clause's action as DO UPDATE. Caller is expected to set columns to update using Set or SetMap after calling this method.
func (*ConflictClause) Set ¶
func (conflict *ConflictClause) Set(col string, val interface{}) *ConflictClause
Set adds a column to update as part of the conflict resolution
func (*ConflictClause) SetIf ¶
func (conflict *ConflictClause) SetIf(col string, val interface{}, b bool) *ConflictClause
SetIf is the same as Set, but also accepts a boolean value and only does anything if that value is true. This is a convenience method so that conditional updates can be made without having to save the ConflictClause into a variable and using if statements
func (*ConflictClause) SetMap ¶
func (conflict *ConflictClause) SetMap(vals map[string]interface{}) *ConflictClause
SetMap adds a mapping between columns to values to update as part of the conflict resolution
func (*ConflictClause) ToSQL ¶
func (conflict *ConflictClause) ToSQL() (asSQL string, bindings []interface{})
ToSQL generates the SQL code for the conflict clause
type DB ¶
DB is a wrapper around sqlx.DB (which is a wrapper around sql.DB)
func New ¶
New creates a new DB instance from an underlying sql.DB object. It requires the name of the SQL driver in order to use the correct placeholders when generating SQL
func (*DB) DeleteFrom ¶
func (db *DB) DeleteFrom(table string) *DeleteStmt
DeleteFrom creates a new DeleteStmt object for the provided table
func (*DB) InsertInto ¶
func (db *DB) InsertInto(table string) *InsertStmt
InsertInto creates a new InsertStmt object for the provided table
func (*DB) Select ¶
func (db *DB) Select(cols ...string) *SelectStmt
Select creates a new SelectStmt object, selecting the provided columns. You can use any SQL syntax supported by your database system, e.g. Select("*"), Select("one", "two t", "MAX(three) maxThree")
func (*DB) Transactional ¶
Transactional runs the provided function inside a transaction. The function must receive an sqlz Tx object, and return an error. If the function returns an error, the transaction is automatically rolled back. Otherwise, the transaction is committed.
func (*DB) TransactionalContext ¶
func (db *DB) TransactionalContext(ctx context.Context, opts *sql.TxOptions, f func(tx *Tx) error) error
TransactionalContext runs the provided function inside a transaction. The function must receive an sqlz Tx object, and return an error. If the function returns an error, the transaction is automatically rolled back. Otherwise, the transaction is committed.
func (*DB) Update ¶
func (db *DB) Update(table string) *UpdateStmt
Update creates a new UpdateStmt object for the specified table
type DeleteStmt ¶
type DeleteStmt struct { *Statment Table string Conditions []WhereCondition UsingTables []string Return []string // contains filtered or unexported fields }
DeleteStmt represents a DELETE statement
func (*DeleteStmt) Exec ¶
func (stmt *DeleteStmt) Exec() (res sql.Result, err error)
Exec executes the DELETE statement, returning the standard sql.Result struct and an error if the query failed.
func (*DeleteStmt) ExecContext ¶
ExecContext executes the DELETE statement, returning the standard sql.Result struct and an error if the query failed.
func (*DeleteStmt) GetAll ¶
func (stmt *DeleteStmt) GetAll(into interface{}) error
GetAll executes a DELETE statement with a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*DeleteStmt) GetAllContext ¶
func (stmt *DeleteStmt) GetAllContext(ctx context.Context, into interface{}) error
GetAllContext executes a DELETE statement with a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*DeleteStmt) GetRow ¶
func (stmt *DeleteStmt) GetRow(into interface{}) error
GetRow executes a DELETE statement with a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)
func (*DeleteStmt) GetRowContext ¶
func (stmt *DeleteStmt) GetRowContext(ctx context.Context, into interface{}) error
GetRowContext executes a DELETE statement with a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)
func (*DeleteStmt) Returning ¶
func (stmt *DeleteStmt) Returning(cols ...string) *DeleteStmt
Returning sets a RETURNING clause to receive values back from the database once executing the DELETE statement. Note that GetRow or GetAll must be used to execute the query rather than Exec to get back the values.
func (*DeleteStmt) ToSQL ¶
func (stmt *DeleteStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
ToSQL generates the DELETE statement's SQL and returns a list of bindings. It is used internally by Exec, but is exported if you wish to use it directly.
func (*DeleteStmt) Using ¶
func (stmt *DeleteStmt) Using(tables ...string) *DeleteStmt
Using adds a USING clause for joining in a delete statement
func (*DeleteStmt) Where ¶
func (stmt *DeleteStmt) Where(conds ...WhereCondition) *DeleteStmt
Where creates one or more WHERE conditions for the DELETE statement. If multiple conditions are passed, they are considered AND conditions.
type Ext ¶
type Ext interface { sqlx.Queryer sqlx.QueryerContext sqlx.Execer sqlx.ExecerContext }
Ext is a union interface which can bind, query, and exec, with or without contexts, used by NamedQuery and NamedExec
type InCondition ¶
InCondition is a struct representing IN and NOT IN conditions
func In ¶
func In(col string, values ...interface{}) InCondition
In creates an IN condition for matching the value of a column against an array of possible values
func NotIn ¶
func NotIn(col string, values ...interface{}) InCondition
NotIn creates a NOT IN condition for checking that the value of a column is not one of the defined values
func (InCondition) Parse ¶
func (in InCondition) Parse() (asSQL string, bindings []interface{})
Parse implements the WhereCondition interface, generating SQL from the condition
type IndirectValue ¶
type IndirectValue struct { Reference string Bindings []interface{} }
IndirectValue represents a reference to a database name (e.g. column, function) that should be used as-is in a query rather than replaced with a placeholder.
func Indirect ¶
func Indirect(value string, bindings ...interface{}) IndirectValue
Indirect receives a string and injects it into a query as-is rather than with a placeholder. Use this when comparing columns, modifying columns based on their (or others') existing values, using database functions, etc. Never use this with user-supplied input, as this may open the door for SQL injections!
func (IndirectValue) ToSQL ¶
func (i IndirectValue) ToSQL(_ bool) (string, []interface{})
type InsertStmt ¶
type InsertStmt struct { *Statment InsCols []string InsVals []interface{} InsMultipleVals [][]interface{} SelectStmt *SelectStmt Table string Return []string Conflicts []*ConflictClause // contains filtered or unexported fields }
InsertStmt represents an INSERT statement
func (*InsertStmt) Columns ¶
func (stmt *InsertStmt) Columns(cols ...string) *InsertStmt
Columns defines the columns to insert. It can be safely used alongside ValueMap in the same query, provided Values is used immediately after Columns
func (*InsertStmt) Exec ¶
func (stmt *InsertStmt) Exec() (res sql.Result, err error)
Exec executes the INSERT statement, returning the standard sql.Result struct and an error if the query failed.
func (*InsertStmt) ExecContext ¶
ExecContext executes the INSERT statement, returning the standard sql.Result struct and an error if the query failed.
func (*InsertStmt) FromSelect ¶
func (stmt *InsertStmt) FromSelect(selStmt *SelectStmt) *InsertStmt
Select sets a SELECT statements that will supply the rows to be inserted.
func (*InsertStmt) GetAll ¶
func (stmt *InsertStmt) GetAll(into interface{}) error
GetAll executes an INSERT statement with a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*InsertStmt) GetAllContext ¶
func (stmt *InsertStmt) GetAllContext(ctx context.Context, into interface{}) error
GetAllContext executes an INSERT statement with a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*InsertStmt) GetRow ¶
func (stmt *InsertStmt) GetRow(into interface{}) error
GetRow executes an INSERT statement with a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)
func (*InsertStmt) GetRowContext ¶
func (stmt *InsertStmt) GetRowContext(ctx context.Context, into interface{}) error
GetRowContext executes an INSERT statement with a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)
func (*InsertStmt) OnConflict ¶
func (stmt *InsertStmt) OnConflict(clause *ConflictClause) *InsertStmt
OnConflict adds an ON CONFLICT clause to the statement
func (*InsertStmt) OnConflictDoNothing ¶
func (stmt *InsertStmt) OnConflictDoNothing() *InsertStmt
OnConflictDoNothing sets an ON CONFLICT clause on the statement. This method is deprecated in favor of OnConflict.
func (*InsertStmt) OrAbort ¶
func (stmt *InsertStmt) OrAbort() *InsertStmt
OrAbort enables the "OR ABORT" conflict resolution for SQLIte inserts
func (*InsertStmt) OrFail ¶
func (stmt *InsertStmt) OrFail() *InsertStmt
OrFail enables the "OR FAIL" conflict resolution for SQLIte inserts
func (*InsertStmt) OrIgnore ¶
func (stmt *InsertStmt) OrIgnore() *InsertStmt
OrIgnore enables the "OR IGNORE" conflict resolution for SQLIte inserts
func (*InsertStmt) OrReplace ¶
func (stmt *InsertStmt) OrReplace() *InsertStmt
OrReplace enables the "OR REPLACE" conflict resolution for SQLIte inserts
func (*InsertStmt) OrRollback ¶
func (stmt *InsertStmt) OrRollback() *InsertStmt
OrRollback enables the "OR ROLLBACK" conflict resolution for SQLIte inserts
func (*InsertStmt) Returning ¶
func (stmt *InsertStmt) Returning(cols ...string) *InsertStmt
Returning sets a RETURNING clause to receive values back from the database once executing the INSERT statement. Note that GetRow or GetAll must be used to execute the query rather than Exec to get back the values.
func (*InsertStmt) ToSQL ¶
func (stmt *InsertStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
ToSQL generates the INSERT statement's SQL and returns a list of bindings. It is used internally by Exec, GetRow and GetAll, but is exported if you wish to use it directly.
func (*InsertStmt) ValueMap ¶
func (stmt *InsertStmt) ValueMap(vals map[string]interface{}) *InsertStmt
ValueMap receives a map of columns and values to insert
func (*InsertStmt) ValueMultiple ¶
func (stmt *InsertStmt) ValueMultiple(vals [][]interface{}) *InsertStmt
ValueMultiple receives an array of interfaces in order to insert multiple records using the same insert statement
func (*InsertStmt) Values ¶
func (stmt *InsertStmt) Values(vals ...interface{}) *InsertStmt
Values sets the values to insert to the table (based on the columns provided via Columns)
type JSONBBuilder ¶
type JSONBBuilder struct { Array bool Bindings []interface{} }
func BuildJSONBArray ¶
func BuildJSONBArray(in ...interface{}) (out JSONBBuilder)
func BuildJSONBObject ¶
func BuildJSONBObject(in map[string]interface{}) (out JSONBBuilder)
func (JSONBBuilder) Parse ¶
func (b JSONBBuilder) Parse() (asSQL string, bindings []interface{})
type JSONBObject ¶
type JSONBObject struct {
Bindings []interface{}
}
type JoinClause ¶
type JoinClause struct { Type JoinType Table string ResultSet *SelectStmt Conditions []WhereCondition }
JoinClause represents a JOIN clause in a SELECT statement
type JoinType ¶
type JoinType int
JoinType is an enumerated type representing the type of a JOIN clause (INNER, LEFT, RIGHT or FULL)
const ( InnerJoin JoinType = iota LeftJoin RightJoin FullJoin InnerLateralJoin LeftLateralJoin RightLateralJoin )
InnerJoin represents an inner join LeftJoin represents a left join RightJoin represents a right join FullJoin represents a full join InnerLateralJoin represents an inner lateral join LeftLateralJoin represents a left lateral join RightLateralJoin represents a right lateral join
type LockClause ¶
type LockClause struct { Strength LockStrength Tables []string Wait LockWait }
LockClause represents a row or table level locking for a SELECT statement
func ForKeyShare ¶
func ForKeyShare() *LockClause
ForKeyShare adds a "FOR KEY SHARE" lock clause on the statement
func ForNoKeyUpdate ¶
func ForNoKeyUpdate() *LockClause
ForNoKeyUpdate adds a "FOR NO KEY UPDATE" lock clause on the statement
func ForShare ¶
func ForShare() *LockClause
ForShare adds a "FOR SHARE" lock clause on the statement
func ForUpdate ¶
func ForUpdate() *LockClause
ForUpdate adds a "FOR UPDATE" lock clause on the statement
func (*LockClause) NoWait ¶
func (lock *LockClause) NoWait() *LockClause
func (*LockClause) OfTables ¶
func (lock *LockClause) OfTables(tables ...string) *LockClause
func (*LockClause) SkipLocked ¶
func (lock *LockClause) SkipLocked() *LockClause
type LockStrength ¶
type LockStrength int8
LockStrength represents the strength of a LockClause
const ( LockForUpdate LockStrength = iota LockForNoKeyUpdate )
type LockWait ¶
type LockWait int8
LockWait represents the behavior of the database when a lock cannot be acquired
type OrderColumn ¶
OrderColumn represents a column in an ORDER BY clause (with direction)
func Asc ¶
func Asc(col string) OrderColumn
Asc creates an OrderColumn for the provided column in ascending order
func Desc ¶
func Desc(col string) OrderColumn
Desc creates an OrderColumn for the provided column in descending order
func (OrderColumn) ToSQL ¶
func (o OrderColumn) ToSQL(_ bool) (string, []interface{})
ToSQL generates SQL for an OrderColumn
type PreCondition ¶
type PreCondition struct { Pre string Condition WhereCondition }
PreCondition represents pre-condition operator
func Not ¶
func Not(cond WhereCondition) PreCondition
Not represents a pre condition ("NOT" operator)
func (PreCondition) Parse ¶
func (pre PreCondition) Parse() (asSQL string, bindings []interface{})
Parse implements the WhereCondition interface, generating SQL from the condition
type Queryer ¶
type Queryer interface { sqlx.Queryer sqlx.QueryerContext }
Queryer is an interface used by Get and Select, with or without context
type SQLCondition ¶
type SQLCondition struct { Condition string Binds []interface{} }
SQLCondition represents a condition written directly in SQL, allows using complex SQL conditions not yet supported by sqlz
func SQLCond ¶
func SQLCond(condition string, binds ...interface{}) SQLCondition
SQLCond creates an SQL condition, allowing to use complex SQL conditions that are not yet supported by sqlz. Question marks must be used for placeholders in the condition regardless of the database driver.
func (SQLCondition) Parse ¶
func (cond SQLCondition) Parse() (asSQL string, bindings []interface{})
Parse implements the WhereCondition interface, generating SQL from the condition
type SQLStmt ¶
SQLStmt is an interface representing a general SQL statement. All specific statement types (e.g. SelectStmt, UpdateStmt, etc.) implement this interface
type SelectStmt ¶
type SelectStmt struct { *Statment IsDistinct bool IsUnionAll bool DistinctColumns []string Columns []string Table string Joins []JoinClause Conditions []WhereCondition Ordering []SQLStmt Grouping []string GroupConditions []WhereCondition Unions []*SelectStmt Locks []*LockClause LimitTo int64 OffsetFrom int64 OffsetRows int64 // contains filtered or unexported fields }
SelectStmt represents a SELECT statement
func (*SelectStmt) Distinct ¶
func (stmt *SelectStmt) Distinct(cols ...string) *SelectStmt
Distinct marks the statements as a SELECT DISTINCT statement
func (*SelectStmt) From ¶
func (stmt *SelectStmt) From(table string) *SelectStmt
From sets the table to select from
func (*SelectStmt) FullJoin ¶
func (stmt *SelectStmt) FullJoin(table string, conds ...WhereCondition) *SelectStmt
FullJoin is a wrapper of Join for creating a FULL JOIN on a table with the provided conditions
func (*SelectStmt) FullJoinRS ¶
func (stmt *SelectStmt) FullJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
FullJoinRS is a wrapper of Join for creating a FULL JOIN on the results of a sub-query
func (*SelectStmt) GetAll ¶
func (stmt *SelectStmt) GetAll(into interface{}) error
GetAll executes the SELECT statement and loads all the results into the provided slice variable.
func (*SelectStmt) GetAllAsMaps ¶
func (stmt *SelectStmt) GetAllAsMaps() (maps []map[string]interface{}, err error)
GetAllAsMaps executes the SELECT statement and returns all results as a slice of maps from string to empty interfaces. This is useful for intermediary query where creating a struct type would be redundant
func (*SelectStmt) GetAllAsRows ¶
func (stmt *SelectStmt) GetAllAsRows() (rows *sqlx.Rows, err error)
GetAllAsRows executes the SELECT statement and returns an sqlx.Rows object to use for iteration. It is the caller's responsibility to close the cursor with Close().
func (*SelectStmt) GetAllAsRowsContext ¶
GetAllAsRowsContext executes the SELECT statement and returns an sqlx.Rows object to use for iteration. It is the caller's responsibility to close the cursor with Close().
func (*SelectStmt) GetAllContext ¶
func (stmt *SelectStmt) GetAllContext(ctx context.Context, into interface{}) error
GetAllContext executes the SELECT statement and loads all the results into the provided slice variable.
func (*SelectStmt) GetCount ¶
func (stmt *SelectStmt) GetCount() (count int64, err error)
GetCount executes the SELECT statement disregarding limits, offsets, selected columns and ordering; and returns the total number of matching results. This is useful when paginating results.
func (*SelectStmt) GetCountContext ¶
func (stmt *SelectStmt) GetCountContext(ctx context.Context) (count int64, err error)
GetCountContext executes the SELECT statement disregarding limits, offsets, selected columns and ordering; and returns the total number of matching results. This is useful when paginating results.
func (*SelectStmt) GetRow ¶
func (stmt *SelectStmt) GetRow(into interface{}) error
GetRow executes the SELECT statement and loads the first result into the provided variable (which may be a simple variable if only one column was selected, or a struct if multiple columns were selected).
func (*SelectStmt) GetRowAsMap ¶
func (stmt *SelectStmt) GetRowAsMap() (results map[string]interface{}, err error)
GetRowAsMap executes the SELECT statement and returns the first result as a map from string to empty interfaces. This is useful for intermediary query where creating a struct type would be redundant
func (*SelectStmt) GetRowContext ¶
func (stmt *SelectStmt) GetRowContext(ctx context.Context, into interface{}) error
GetRowContext executes the SELECT statement and loads the first result into the provided variable (which may be a simple variable if only one column was selected, or a struct if multiple columns were selected).
func (*SelectStmt) GroupBy ¶
func (stmt *SelectStmt) GroupBy(cols ...string) *SelectStmt
GroupBy sets a GROUP BY clause with the provided columns.
func (*SelectStmt) Having ¶
func (stmt *SelectStmt) Having(conditions ...WhereCondition) *SelectStmt
Having sets HAVING conditions for aggregated values. Usage is the same as Where.
func (*SelectStmt) InnerJoin ¶
func (stmt *SelectStmt) InnerJoin(table string, conds ...WhereCondition) *SelectStmt
InnerJoin is a wrapper of Join for creating a INNER JOIN on a table with the provided conditions
func (*SelectStmt) InnerJoinRS ¶
func (stmt *SelectStmt) InnerJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
InnerJoinRS is a wrapper of Join for creating a INNER JOIN on the results of a sub-query
func (*SelectStmt) InnerLateralJoin ¶
func (stmt *SelectStmt) InnerLateralJoin(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
func (*SelectStmt) Join ¶
func (stmt *SelectStmt) Join(joinType JoinType, table string, resultSet *SelectStmt, conds ...WhereCondition) *SelectStmt
Join creates a new join with the supplied type, on the supplied table or result set (a sub-select statement), using the provided conditions. Since conditions in a JOIN clause usually compare two columns, use sqlz.Indirect in your conditions.
func (*SelectStmt) LeftJoin ¶
func (stmt *SelectStmt) LeftJoin(table string, conds ...WhereCondition) *SelectStmt
LeftJoin is a wrapper of Join for creating a LEFT JOIN on a table with the provided conditions
func (*SelectStmt) LeftJoinRS ¶
func (stmt *SelectStmt) LeftJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
LeftJoinRS is a wrapper of Join for creating a LEFT JOIN on the results of a sub-query
func (*SelectStmt) LeftLateralJoin ¶
func (stmt *SelectStmt) LeftLateralJoin(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
func (*SelectStmt) Limit ¶
func (stmt *SelectStmt) Limit(limit int64) *SelectStmt
Limit limits the amount of results returned to the provided value (this is a LIMIT clause). In some database systems, Offset with two values should be used instead.
func (*SelectStmt) Lock ¶
func (stmt *SelectStmt) Lock(lock *LockClause) *SelectStmt
func (*SelectStmt) Offset ¶
func (stmt *SelectStmt) Offset(start int64, rows ...int64) *SelectStmt
Offset skips the provided number of results. In supporting database systems, you can provide a limit on the number of the returned results as the second parameter
func (*SelectStmt) OrderBy ¶
func (stmt *SelectStmt) OrderBy(cols ...SQLStmt) *SelectStmt
OrderBy sets an ORDER BY clause for the query. Pass OrderColumn objects using the Asc and Desc functions.
func (*SelectStmt) RightJoin ¶
func (stmt *SelectStmt) RightJoin(table string, conds ...WhereCondition) *SelectStmt
RightJoin is a wrapper of Join for creating a RIGHT JOIN on a table with the provided conditions
func (*SelectStmt) RightJoinRS ¶
func (stmt *SelectStmt) RightJoinRS(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
RightJoinRS is a wrapper of Join for creating a RIGHT JOIN on the results of a sub-query
func (*SelectStmt) RightLateralJoin ¶
func (stmt *SelectStmt) RightLateralJoin(rs *SelectStmt, as string, conds ...WhereCondition) *SelectStmt
func (*SelectStmt) ToSQL ¶
func (stmt *SelectStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
ToSQL generates the SELECT statement's SQL and returns a list of bindings. It is used internally by GetRow and GetAll, but is exported if you wish to use it directly.
func (*SelectStmt) Union ¶
func (stmt *SelectStmt) Union(statements ...*SelectStmt) *SelectStmt
Union adds the 'UNION' command between two SELECT statements or more
func (*SelectStmt) UnionAll ¶
func (stmt *SelectStmt) UnionAll(statements ...*SelectStmt) *SelectStmt
Union adds the 'UNION ALL' command between two SELECT statements or more
func (*SelectStmt) Where ¶
func (stmt *SelectStmt) Where(conditions ...WhereCondition) *SelectStmt
Where creates one or more WHERE conditions for the SELECT statement. If multiple conditions are passed, they are considered AND conditions.
func (*SelectStmt) WithNullsFirst ¶
func (stmt *SelectStmt) WithNullsFirst() *SelectStmt
OrderBy with null values first
func (*SelectStmt) WithNullsLast ¶
func (stmt *SelectStmt) WithNullsLast() *SelectStmt
OrderBy with null values last
type SimpleCondition ¶
SimpleCondition represents the most basic WHERE condition, where one left-value (usually a column) is compared with a right-value using an operator (e.g. "=", "<>", ">=", ...)
func Eq ¶
func Eq(col string, value interface{}) SimpleCondition
Eq represents a simple equality condition ("=" operator)
func Gt ¶
func Gt(col string, value interface{}) SimpleCondition
Gt represents a simple greater-than condition (">" operator)
func Gte ¶
func Gte(col string, value interface{}) SimpleCondition
Gte represents a simple greater-than-or-equals condition (">=" operator)
func ILike ¶
func ILike(col string, value interface{}) SimpleCondition
ILike represents a wildcard equality condition ("ILIKE" operator)
func IsNotNull ¶
func IsNotNull(col string) SimpleCondition
IsNotNull represents a simple non-nullity condition ("IS NOT NULL" operator)
func IsNull ¶
func IsNull(col string) SimpleCondition
IsNull represents a simple nullity condition ("IS NULL" operator)
func JSONBOp ¶
func JSONBOp(op string, left string, value interface{}) SimpleCondition
JSONBOp creates simple conditions with JSONB operators for PostgreSQL databases (supported operators are "@>", "<@", "?", "?!", "?&", "||", "-" and "#-")
func Like ¶
func Like(col string, value interface{}) SimpleCondition
Like represents a wildcard equality condition ("LIKE" operator)
func Lt ¶
func Lt(col string, value interface{}) SimpleCondition
Lt represents a simple less-than condition ("<" operator)
func Lte ¶
func Lte(col string, value interface{}) SimpleCondition
Lte represents a simple less-than-or-equals condition ("<=" operator)
func Ne ¶
func Ne(col string, value interface{}) SimpleCondition
Ne represents a simple non-equality condition ("<>" operator)
func NotLike ¶
func NotLike(col string, value interface{}) SimpleCondition
NotLike represents a wildcard non-equality condition ("NOT LIKE" operator)
func (SimpleCondition) Parse ¶
func (simple SimpleCondition) Parse() (asSQL string, bindings []interface{})
Parse implements the WhereCondition interface, generating SQL from the condition
type Statment ¶
type Statment struct {
ErrHandlers []func(err error)
}
func (*Statment) HandlerError ¶
type SubqueryCondition ¶
type SubqueryCondition struct { Stmt *SelectStmt Operator string }
SubqueryCondition is a WHERE condition on the results of a sub-query.
func Exists ¶
func Exists(stmt *SelectStmt) SubqueryCondition
Exists creates a sub-query condition checking the sub-query returns results ("EXISTS" operator)
func NotExists ¶
func NotExists(stmt *SelectStmt) SubqueryCondition
NotExists creates a sub-query condition checking the sub-query does not return results ("NOT EXISTS" operator)
func (SubqueryCondition) Parse ¶
func (subCond SubqueryCondition) Parse() (asSQL string, bindings []interface{})
Parse implements the WhereCondition interface, generating SQL from the condition
type Tx ¶
Tx is a wrapper around sqlx.Tx (which is a wrapper around sql.Tx)
func (*Tx) DeleteFrom ¶
func (tx *Tx) DeleteFrom(table string) *DeleteStmt
DeleteFrom creates a new DeleteStmt object for the provided table
func (*Tx) InsertInto ¶
func (tx *Tx) InsertInto(table string) *InsertStmt
InsertInto creates a new InsertStmt object for the provided table
func (*Tx) Select ¶
func (tx *Tx) Select(cols ...string) *SelectStmt
Select creates a new SelectStmt object, selecting the provided columns. You can use any SQL syntax supported by your database system, e.g. Select("*"), Select("one", "two t", "MAX(three) maxThree")
func (*Tx) Update ¶
func (tx *Tx) Update(table string) *UpdateStmt
Update creates a new UpdateStmt object for the specified table
type UpdateFunction ¶
type UpdateFunction struct { Name string Arguments []interface{} }
UpdateFunction represents a function call in the context of updating a column's value. For example, PostgreSQL provides functions to append, prepend or remove items from array columns.
func ArrayAppend ¶
func ArrayAppend(name string, value interface{}) UpdateFunction
ArrayAppend is an UpdateFunction for calling PostgreSQL's array_append function during an update.
func ArrayPrepend ¶
func ArrayPrepend(name string, value interface{}) UpdateFunction
ArrayPrepend is an UpdateFunction for calling PostgreSQL's array_prepend function during an update.
func ArrayRemove ¶
func ArrayRemove(name string, value interface{}) UpdateFunction
ArrayRemove is an UpdateFunction for calling PostgreSQL's array_remove function during an update.
type UpdateStmt ¶
type UpdateStmt struct { *Statment Table string Updates map[string]interface{} Conditions []WhereCondition Return []string SelectStmt *SelectStmt SelectStmtAlias string // contains filtered or unexported fields }
UpdateStmt represents an UPDATE statement
func (*UpdateStmt) Exec ¶
func (stmt *UpdateStmt) Exec() (res sql.Result, err error)
Exec executes the UPDATE statement, returning the standard sql.Result struct and an error if the query failed.
func (*UpdateStmt) ExecContext ¶
ExecContext executes the UPDATE statement, returning the standard sql.Result struct and an error if the query failed.
func (*UpdateStmt) FromSelect ¶
func (stmt *UpdateStmt) FromSelect(selStmt *SelectStmt, alias string) *UpdateStmt
func (*UpdateStmt) GetAll ¶
func (stmt *UpdateStmt) GetAll(into interface{}) error
GetAll executes an UPDATE statement with a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*UpdateStmt) GetAllContext ¶
func (stmt *UpdateStmt) GetAllContext(ctx context.Context, into interface{}) error
GetAllContext executes an UPDATE statement with a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*UpdateStmt) GetRow ¶
func (stmt *UpdateStmt) GetRow(into interface{}) error
GetRow executes an UPDATE statement with a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)
func (*UpdateStmt) GetRowContext ¶
func (stmt *UpdateStmt) GetRowContext(ctx context.Context, into interface{}) error
GetRowContext executes an UPDATE statement with a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)
func (*UpdateStmt) Returning ¶
func (stmt *UpdateStmt) Returning(cols ...string) *UpdateStmt
Returning sets a RETURNING clause to receive values back from the database once executing the UPDATE statement. Note that GetRow or GetAll must be used to execute the query rather than Exec to get back the values.
func (*UpdateStmt) Set ¶
func (stmt *UpdateStmt) Set(col string, value interface{}) *UpdateStmt
Set receives the name of a column and a new value. Multiple calls to Set can be chained together to modify multiple columns. Set can also be chained with calls to SetMap
func (*UpdateStmt) SetIf ¶
func (stmt *UpdateStmt) SetIf(col string, value interface{}, b bool) *UpdateStmt
SetIf is the same as Set, but also accepts a boolean value and only does anything if that value is true. This is a convenience method so that conditional updates can be made without having to save the UpdateStmt into a variable and using if statements
func (*UpdateStmt) SetMap ¶
func (stmt *UpdateStmt) SetMap(updates map[string]interface{}) *UpdateStmt
SetMap receives a map of columns and values. Multiple calls to both Set and SetMap can be chained to modify multiple columns.
func (*UpdateStmt) ToSQL ¶
func (stmt *UpdateStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{})
ToSQL generates the UPDATE statement's SQL and returns a list of bindings. It is used internally by Exec, GetRow and GetAll, but is exported if you wish to use it directly.
func (*UpdateStmt) Where ¶
func (stmt *UpdateStmt) Where(conditions ...WhereCondition) *UpdateStmt
Where creates one or more WHERE conditions for the UPDATE statement. If multiple conditions are passed, they are considered AND conditions.
type WhereCondition ¶
type WhereCondition interface {
Parse() (asSQL string, bindings []interface{})
}
WhereCondition is an interface describing conditions that can be used inside an SQL WHERE clause. It defines the Parse function that generates SQL (with placeholders) from the condition(s) and returns a list of data bindings for the placeholders (if any)
type WithStmt ¶
type WithStmt struct { // AuxStmts is the list of auxiliary statements that are // part of the WITH query AuxStmts []AuxStmt // MainStmt is the query's main statement in which the // auxiliary statements can be referenced MainStmt SQLStmt // contains filtered or unexported fields }
WithStmt represents a WITH statement
func (*WithStmt) Exec ¶
Exec executes the WITH statement, returning the standard sql.Result struct and an error if the query failed.
func (*WithStmt) ExecContext ¶
ExecContext executes the WITH statement, returning the standard sql.Result struct and an error if the query failed.
func (*WithStmt) GetAll ¶
GetAll executes a WITH statement whose main statement has a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*WithStmt) GetAllAsRows ¶
GetAllAsRows executes the WITH statement and returns an sqlx.Rows object to use for iteration. It is the caller's responsibility to close the cursor with Close().
func (*WithStmt) GetAllContext ¶
GetAllContext executes a WITH statement whose main statement has a RETURNING clause expected to return multiple rows, and loads the result into the provided slice variable
func (*WithStmt) GetRow ¶
GetRow executes a WITH statement whose main statement has a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)
func (*WithStmt) GetRowContext ¶
GetRowContext executes a WITH statement whose main statement has a RETURNING clause expected to return one row, and loads the result into the provided variable (which may be a simple variable if only one column is returned, or a struct if multiple columns are returned)