clause

package
v0.41.1 Latest Latest
Warning

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

 Go to latest Published: Sep 2, 2025 License: MIT Imports: 6 Imported by: 8

Documentation

Index

Constants

View Source 
const (
	Union     = "UNION"
	Intersect = "INTERSECT"
	Except    = "EXCEPT"
)
View Source 
const (
	SearchBreadth = "BREADTH"
	SearchDepth   = "DEPTH"
)
View Source 
const (
	InnerJoin    = "INNER JOIN"
	LeftJoin     = "LEFT JOIN"
	RightJoin    = "RIGHT JOIN"
	FullJoin     = "FULL JOIN"
	CrossJoin    = "CROSS JOIN"
	StraightJoin = "STRAIGHT_JOIN"
)
View Source 
const (
	LockStrengthUpdate      = "UPDATE"
	LockStrengthNoKeyUpdate = "NO KEY UPDATE"
	LockStrengthShare       = "SHARE"
	LockStrengthKeyShare    = "KEY SHARE"
)
View Source 
const (
	LockWaitNoWait     = "NOWAIT"
	LockWaitSkipLocked = "SKIP LOCKED"
)

Variables

View Source 
var ErrNoCombinationStrategy = errors.New("combination strategy must be set")
View Source 
var ErrNoLockStrength = errors.New("no lock strength specified")

Functions

This section is empty.

Types

type CTE 

type CTE struct {
	Query        bob.Query // SQL standard says only select, postgres allows insert/update/delete
	Name         string
	Columns      []string
	Materialized *bool
	Search       CTESearch
	Cycle        CTECycle
}

func (CTE) WriteSQL 

func (c CTE) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type CTECycle 

type CTECycle struct {
	Columns    []string
	Set        string
	Using      string
	SetVal     any
	DefaultVal any
}

func (CTECycle) WriteSQL 

func (c CTECycle) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type CTESearch 

type CTESearch struct {
	Order   string
	Columns []string
	Set     string
}

func (CTESearch) WriteSQL 

func (c CTESearch) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Combine 

type Combine struct {
	Strategy string
	Query    bob.Query
	All      bool
}

func (*Combine) SetCombine 

func (s *Combine) SetCombine(c Combine)

func (Combine) WriteSQL 

func (s Combine) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Combines added in v0.30.0 

type Combines struct {
	Queries []Combine
}

func (*Combines) AppendCombine added in v0.30.0 

func (c *Combines) AppendCombine(combine Combine)

type Conflict 

type Conflict struct {
	Expression bob.Expression
}

func (*Conflict) SetConflict 

func (c *Conflict) SetConflict(conflict bob.Expression)

type ConflictClause added in v0.33.0 

type ConflictClause struct {
	Do     string // DO NOTHING | DO UPDATE
	Target ConflictTarget
	Set
	Where
}

func (ConflictClause) WriteSQL added in v0.33.0 

func (c ConflictClause) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type ConflictTarget 

type ConflictTarget struct {
	Constraint string
	Columns    []any
	Where      []any
}

func (ConflictTarget) WriteSQL 

func (c ConflictTarget) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Fetch 

type Fetch struct {
	Count    any
	WithTies bool
}

func (*Fetch) SetFetch 

func (f *Fetch) SetFetch(fetch Fetch)

func (Fetch) WriteSQL 

func (f Fetch) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Frame 

type Frame struct {
	Defined   bool // whether any of the parts was defined
	Mode      string
	Start     any
	End       any    // can be nil
	Exclusion string // can be empty
}

func (*Frame) SetEnd 

func (f *Frame) SetEnd(end any)

func (*Frame) SetExclusion 

func (f *Frame) SetExclusion(excl string)

func (*Frame) SetMode 

func (f *Frame) SetMode(mode string)

func (*Frame) SetStart 

func (f *Frame) SetStart(start any)

func (Frame) WriteSQL 

func (f Frame) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type GroupBy 

type GroupBy struct {
	Groups   []any
	Distinct bool
	With     string // ROLLUP | CUBE
}

func (*GroupBy) AppendGroup 

func (g *GroupBy) AppendGroup(e any)

func (*GroupBy) SetGroupByDistinct 

func (g *GroupBy) SetGroupByDistinct(distinct bool)

func (*GroupBy) SetGroupWith 

func (g *GroupBy) SetGroupWith(with string)

func (*GroupBy) SetGroups added in v0.27.0 

func (g *GroupBy) SetGroups(groups ...any)

func (GroupBy) WriteSQL 

func (g GroupBy) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type GroupingSet 

type GroupingSet struct {
	Groups []bob.Expression
	Type   string // GROUPING SET | CUBE | ROLLUP
}

func (GroupingSet) WriteSQL 

func (g GroupingSet) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Having 

type Having struct {
	Conditions []any
}

func (*Having) AppendHaving 

func (h *Having) AppendHaving(e ...any)

func (Having) WriteSQL 

func (h Having) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type IndexHint 

type IndexHint struct {
	Type    string // USE, FORCE or IGNORE
	Indexes []string
	For     string // JOIN, ORDER BY or GROUP BY
}

func (IndexHint) WriteSQL 

func (f IndexHint) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Join 

type Join struct {
	Type string
	To   TableRef // the expression for the table

	// Join methods
	Natural bool
	On      []bob.Expression
	Using   []string
}

func (Join) WriteSQL 

func (j Join) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Limit 

type Limit struct {
	// Some DBs (e.g. SQite) can take an expression
	// It is up to the mods to enforce any extra conditions
	Count any
}

func (*Limit) SetLimit 

func (l *Limit) SetLimit(limit any)

func (Limit) WriteSQL 

func (l Limit) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Lock added in v0.32.0 

type Lock struct {
	Strength string
	Tables   []string
	Wait     string
}

func (Lock) WriteSQL added in v0.32.0 

func (f Lock) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Locks added in v0.32.0 

type Locks struct {
	Locks []bob.Expression
}

func (*Locks) AppendLock added in v0.32.0 

func (f *Locks) AppendLock(lock bob.Expression)

type NamedWindow 

type NamedWindow struct {
	Name       string
	Definition Window
}

func (NamedWindow) WriteSQL 

func (n NamedWindow) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Offset 

type Offset struct {
	// Some DBs (e.g. SQite) can take an expression
	// It is up to the mods to enforce any extra conditions
	Count any
}

func (*Offset) SetOffset 

func (o *Offset) SetOffset(offset any)

func (Offset) WriteSQL 

func (o Offset) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type OrderBy 

type OrderBy struct {
	Expressions []bob.Expression
}

func (*OrderBy) AppendOrder 

func (o *OrderBy) AppendOrder(order bob.Expression)

func (*OrderBy) ClearOrderBy added in v0.32.0 

func (o *OrderBy) ClearOrderBy()

func (OrderBy) WriteSQL 

func (o OrderBy) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type OrderDef 

type OrderDef struct {
	Expression any
	Direction  string // ASC | DESC | USING operator
	Nulls      string // FIRST | LAST
	Collation  string
}

func (OrderDef) WriteSQL 

func (o OrderDef) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Returning 

type Returning struct {
	Expressions []any
}

func (*Returning) AppendReturning 

func (r *Returning) AppendReturning(columns ...any)

func (*Returning) HasReturning added in v0.22.0 

func (r *Returning) HasReturning() bool

func (Returning) WriteSQL 

func (r Returning) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type SelectList added in v0.7.0 

type SelectList struct {
	Columns []any
	// necessary to be able to treat preloaders
	// like any other query Mod
	PreloadColumns []any
}

func (*SelectList) AppendPreloadSelect added in v0.20.0 

func (s *SelectList) AppendPreloadSelect(columns ...any)

func (*SelectList) AppendSelect added in v0.7.0 

func (s *SelectList) AppendSelect(columns ...any)

func (*SelectList) CountSelectCols added in v0.20.0 

func (s *SelectList) CountSelectCols() int

func (*SelectList) SetPreloadSelect added in v0.27.0 

func (s *SelectList) SetPreloadSelect(columns ...any)

func (*SelectList) SetSelect added in v0.20.0 

func (s *SelectList) SetSelect(columns ...any)

func (SelectList) WriteSQL added in v0.7.0 

func (s SelectList) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Set 

type Set struct {
	Set []any
}

func (*Set) AppendSet 

func (s *Set) AppendSet(exprs ...any)

func (Set) WriteSQL 

func (s Set) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type TableRef added in v0.35.0 

type TableRef struct {
	Expression any

	// Aliases
	Alias   string
	Columns []string

	// Dialect specific modifiers
	Only           bool        // Postgres
	Lateral        bool        // Postgres & MySQL
	WithOrdinality bool        // Postgres
	IndexedBy      *string     // SQLite
	Partitions     []string    // MySQL
	IndexHints     []IndexHint // MySQL

	// Joins
	Joins []Join
}

func (*TableRef) AppendIndexHint added in v0.35.0 

func (f *TableRef) AppendIndexHint(i IndexHint)

func (*TableRef) AppendJoin added in v0.35.0 

func (f *TableRef) AppendJoin(j Join)

func (*TableRef) AppendPartition added in v0.35.0 

func (f *TableRef) AppendPartition(partitions ...string)

func (TableRef) As added in v0.39.0 

func (f TableRef) As(alias string, columns ...string) TableRef

func (*TableRef) SetIndexedBy added in v0.35.0 

func (f *TableRef) SetIndexedBy(i *string)

func (*TableRef) SetLateral added in v0.35.0 

func (f *TableRef) SetLateral(lateral bool)

func (*TableRef) SetOnly added in v0.35.0 

func (f *TableRef) SetOnly(only bool)

func (*TableRef) SetTable added in v0.35.0 

func (f *TableRef) SetTable(table any)

func (*TableRef) SetTableAlias added in v0.35.0 

func (f *TableRef) SetTableAlias(alias string, columns ...string)

func (*TableRef) SetWithOrdinality added in v0.35.0 

func (f *TableRef) SetWithOrdinality(to bool)

func (TableRef) WriteSQL added in v0.35.0 

func (f TableRef) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Value added in v0.29.0 

type Value []bob.Expression

func (Value) WriteSQL added in v0.29.0 

func (v Value) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Values 

type Values struct {
	// Query takes the highest priority
	// If present, will attempt to insert from this query
	Query bob.Query

	// for multiple inserts
	// each sub-slice is one set of values
	Vals []Value
}

func (*Values) AppendValues 

func (v *Values) AppendValues(vals ...bob.Expression)

func (Values) WriteSQL 

func (v Values) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Where 

type Where struct {
	Conditions []any
}

func (*Where) AppendWhere 

func (wh *Where) AppendWhere(e ...any)

func (Where) WriteSQL 

func (wh Where) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Window added in v0.27.0 

type Window struct {
	BasedOn string // an existing window name
	OrderBy

	Frame
	// contains filtered or unexported fields
}

func (*Window) AddPartitionBy added in v0.27.0 

func (wi *Window) AddPartitionBy(condition ...any)

func (*Window) SetBasedOn added in v0.30.0 

func (wi *Window) SetBasedOn(from string)

func (Window) WriteSQL added in v0.27.0 

func (wi Window) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type Windows 

type Windows struct {
	Windows []bob.Expression
}

func (*Windows) AppendWindow 

func (wi *Windows) AppendWindow(w bob.Expression)

func (Windows) WriteSQL 

func (wi Windows) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error)

type With 

type With struct {
	Recursive bool
	CTEs      []bob.Expression
}

func (*With) AppendCTE added in v0.32.0 

func (w *With) AppendCTE(cte bob.Expression)

func (*With) SetRecursive 

func (w *With) SetRecursive(r bool)

func (With) WriteSQL 

func (w With) WriteSQL(ctx context.Context, wr io.Writer, d bob.Dialect, start int) ([]any, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.