dialect

package
v0.26.0 Latest Latest
Warning

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

Go to latest
Published: May 21, 2024 License: MIT Imports: 7 Imported by: 6

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	Dialect dialect
)

Functions

func CrossJoin

func CrossJoin[Q Joinable](e any) bob.Mod[Q]

Types

type CTEChain

type CTEChain[Q interface{ AppendWith(clause.CTE) }] func() clause.CTE

func With

func With[Q interface{ AppendWith(clause.CTE) }](name string, columns ...string) CTEChain[Q]

func (CTEChain[Q]) Apply

func (c CTEChain[Q]) Apply(q Q)

func (CTEChain[Q]) As

func (c CTEChain[Q]) As(q bob.Query) CTEChain[Q]

func (CTEChain[Q]) Cycle

func (c CTEChain[Q]) Cycle(set, using string, cols ...string) CTEChain[Q]

func (CTEChain[Q]) CycleValue

func (c CTEChain[Q]) CycleValue(value, defaultVal any) CTEChain[Q]

func (CTEChain[Q]) Materialized

func (c CTEChain[Q]) Materialized() CTEChain[Q]

func (CTEChain[Q]) NotMaterialized

func (c CTEChain[Q]) NotMaterialized() CTEChain[Q]

func (CTEChain[Q]) SearchBreadth

func (c CTEChain[Q]) SearchBreadth(setCol string, searchCols ...string) CTEChain[Q]

func (CTEChain[Q]) SearchDepth

func (c CTEChain[Q]) SearchDepth(setCol string, searchCols ...string) CTEChain[Q]

type DeleteQuery added in v0.13.0

type DeleteQuery struct {
	clause.With
	Only bool
	clause.Table
	clause.From
	clause.Where
	clause.Returning
}

Trying to represent the select query structure as documented in https://www.postgresql.org/docs/current/sql-delete.html

func (DeleteQuery) WriteSQL added in v0.13.0

func (d DeleteQuery) WriteSQL(w io.Writer, dl bob.Dialect, start int) ([]any, error)

type Distinct

type Distinct struct {
	On []any
}

func (Distinct) WriteSQL

func (di Distinct) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)

type Expression

type Expression struct {
	expr.Chain[Expression, Expression]
}

func (Expression) BetweenSymmetric

func (x Expression) BetweenSymmetric(a, b bob.Expression) Expression

BETWEEN SYMMETRIC a AND b

func (Expression) ILike added in v0.19.0

func (x Expression) ILike(val bob.Expression) Expression

ILIKE val

func (Expression) New

func (Expression) NotBetweenSymmetric

func (x Expression) NotBetweenSymmetric(a, b bob.Expression) Expression

NOT BETWEEN SYMMETRIC a AND b

func (Expression) String

func (x Expression) String() string

Implements fmt.Stringer()

type FromChain added in v0.7.0

type FromChain[Q fromable] func() clause.From

func From added in v0.7.0

func From[Q fromable](table any) FromChain[Q]

func (FromChain[Q]) Apply added in v0.7.0

func (f FromChain[Q]) Apply(q Q)

func (FromChain[Q]) As added in v0.7.0

func (f FromChain[Q]) As(alias string, columns ...string) FromChain[Q]

func (FromChain[Q]) Lateral added in v0.7.0

func (f FromChain[Q]) Lateral() FromChain[Q]

func (FromChain[Q]) Only added in v0.7.0

func (f FromChain[Q]) Only() FromChain[Q]

func (FromChain[Q]) WithOrdinality added in v0.7.0

func (f FromChain[Q]) WithOrdinality() FromChain[Q]

type Function

type Function struct {

	// For chain methods
	expr.Chain[Expression, Expression]
	// contains filtered or unexported fields
}

func NewFunction

func NewFunction(name string, args ...any) Function

func (*Function) As

func (f *Function) As(alias string) *Function

func (*Function) Col

func (f *Function) Col(name, datatype string) *Function

func (*Function) FilterWhere

func (f *Function) FilterWhere(e ...any) *functionOver

func (*Function) Over

func (f *Function) Over() *functionOver

func (*Function) WriteSQL

func (f *Function) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)

type Functions

type Functions []*Function

func (Functions) WriteSQL

func (f Functions) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)

type InsertQuery added in v0.13.0

type InsertQuery struct {
	clause.With
	Overriding string
	clause.Table
	clause.Values
	clause.Conflict
	clause.Returning
}

Trying to represent the select query structure as documented in https://www.postgresql.org/docs/current/sql-insert.html

func (InsertQuery) WriteSQL added in v0.13.0

func (i InsertQuery) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)

type JoinChain

type JoinChain[Q Joinable] func() clause.Join

func FullJoin

func FullJoin[Q Joinable](e any) JoinChain[Q]

func InnerJoin

func InnerJoin[Q Joinable](e any) JoinChain[Q]

func Join added in v0.17.0

func Join[Q Joinable](typ string, e any) JoinChain[Q]

func LeftJoin

func LeftJoin[Q Joinable](e any) JoinChain[Q]

func RightJoin

func RightJoin[Q Joinable](e any) JoinChain[Q]

func (JoinChain[Q]) Apply

func (j JoinChain[Q]) Apply(q Q)

func (JoinChain[Q]) As

func (j JoinChain[Q]) As(alias string, columns ...string) JoinChain[Q]

func (JoinChain[Q]) Lateral added in v0.20.0

func (f JoinChain[Q]) Lateral() JoinChain[Q]

func (JoinChain[Q]) Natural

func (j JoinChain[Q]) Natural() bob.Mod[Q]

func (JoinChain[Q]) On

func (j JoinChain[Q]) On(on ...bob.Expression) bob.Mod[Q]

func (JoinChain[Q]) OnEQ

func (j JoinChain[Q]) OnEQ(a, b bob.Expression) bob.Mod[Q]

func (JoinChain[Q]) Only added in v0.20.0

func (f JoinChain[Q]) Only() JoinChain[Q]

func (JoinChain[Q]) Using

func (j JoinChain[Q]) Using(using ...string) bob.Mod[Q]

func (JoinChain[Q]) WithOrdinality added in v0.20.0

func (f JoinChain[Q]) WithOrdinality() JoinChain[Q]

type Joinable added in v0.17.0

type Joinable interface{ AppendJoin(clause.Join) }

type LockChain

type LockChain[Q interface{ SetFor(clause.For) }] func() clause.For

func (LockChain[Q]) Apply

func (l LockChain[Q]) Apply(q Q)

func (LockChain[Q]) NoWait

func (l LockChain[Q]) NoWait() LockChain[Q]

func (LockChain[Q]) SkipLocked

func (l LockChain[Q]) SkipLocked() LockChain[Q]

type OrderBy

type OrderBy[Q interface{ AppendOrder(clause.OrderDef) }] func() clause.OrderDef

func (OrderBy[Q]) Apply

func (s OrderBy[Q]) Apply(q Q)

func (OrderBy[Q]) Asc

func (o OrderBy[Q]) Asc() OrderBy[Q]

func (OrderBy[Q]) Collate

func (o OrderBy[Q]) Collate(collation string) OrderBy[Q]

func (OrderBy[Q]) Desc

func (o OrderBy[Q]) Desc() OrderBy[Q]

func (OrderBy[Q]) NullsFirst

func (o OrderBy[Q]) NullsFirst() OrderBy[Q]

func (OrderBy[Q]) NullsLast

func (o OrderBy[Q]) NullsLast() OrderBy[Q]

func (OrderBy[Q]) Using

func (o OrderBy[Q]) Using(operator string) OrderBy[Q]

type SelectQuery added in v0.13.0

Trying to represent the select query structure as documented in https://www.postgresql.org/docs/current/sql-select.html

func (SelectQuery) WriteSQL added in v0.13.0

func (s SelectQuery) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)

type UpdateQuery added in v0.13.0

type UpdateQuery struct {
	clause.With
	Only bool
	clause.Table
	clause.Set
	clause.From
	clause.Where
	clause.Returning
}

Trying to represent the select query structure as documented in https://www.postgresql.org/docs/current/sql-update.html

func (UpdateQuery) WriteSQL added in v0.13.0

func (u UpdateQuery) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)

type WindowChain

type WindowChain[T any] struct {
	Wrap T
	// contains filtered or unexported fields
}

func (*WindowChain[T]) ExcludeCurrentRow

func (w *WindowChain[T]) ExcludeCurrentRow() T

func (*WindowChain[T]) ExcludeGroup

func (w *WindowChain[T]) ExcludeGroup() T

func (*WindowChain[T]) ExcludeNoOthers

func (w *WindowChain[T]) ExcludeNoOthers() T

func (*WindowChain[T]) ExcludeTies

func (w *WindowChain[T]) ExcludeTies() T

func (*WindowChain[T]) From

func (w *WindowChain[T]) From(name string) T

func (*WindowChain[T]) FromCurrentRow

func (w *WindowChain[T]) FromCurrentRow() T

func (*WindowChain[T]) FromFollowing

func (w *WindowChain[T]) FromFollowing(exp any) T

func (*WindowChain[T]) FromPreceding

func (w *WindowChain[T]) FromPreceding(exp any) T

func (*WindowChain[T]) FromUnboundedPreceding

func (w *WindowChain[T]) FromUnboundedPreceding() T

func (*WindowChain[T]) Groups

func (w *WindowChain[T]) Groups() T

func (*WindowChain[T]) OrderBy

func (w *WindowChain[T]) OrderBy(order ...any) T

func (*WindowChain[T]) PartitionBy

func (w *WindowChain[T]) PartitionBy(condition ...any) T

func (*WindowChain[T]) Range

func (w *WindowChain[T]) Range() T

func (*WindowChain[T]) Rows

func (w *WindowChain[T]) Rows() T

func (*WindowChain[T]) ToCurrentRow

func (w *WindowChain[T]) ToCurrentRow(count int) T

func (*WindowChain[T]) ToFollowing

func (w *WindowChain[T]) ToFollowing(exp any) T

func (*WindowChain[T]) ToPreceding

func (w *WindowChain[T]) ToPreceding(exp any) T

func (*WindowChain[T]) ToUnboundedFollowing

func (w *WindowChain[T]) ToUnboundedFollowing() T

type WindowMod

type WindowMod[Q interface{ AppendWindow(clause.NamedWindow) }] struct {
	Name string
	*WindowChain[*WindowMod[Q]]
}

func (WindowMod[Q]) Apply

func (w WindowMod[Q]) Apply(q Q)

Jump to

Keyboard shortcuts

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