mods

Documentation

Index

• type Combine
  • func (f Combine[Q]) Apply(q Q)
• type Conflict
  • func (s Conflict[Q]) Apply(q Q)
  • func (c Conflict[Q]) DoNothing() bob.Mod[Q]
  • func (c Conflict[Q]) DoUpdate(sets ...bob.Mod[*clause.Conflict]) bob.Mod[Q]
  • func (c Conflict[Q]) Where(where ...any) Conflict[Q]
• type Fetch
  • func (f Fetch[Q]) Apply(q Q)
• type For
  • func (f For[Q]) Apply(q Q)
• type GroupBy
  • func (f GroupBy[Q]) Apply(q Q)
• type GroupByDistinct
  • func (f GroupByDistinct[Q]) Apply(q Q)
• type GroupWith
  • func (f GroupWith[Q]) Apply(q Q)
• type Having
  • func (d Having[Q]) Apply(q Q)
• type Join
  • func (j Join[Q]) Apply(q Q)
• type Limit
  • func (f Limit[Q]) Apply(q Q)
• type Moddable
  • func (m Moddable[T]) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)
• type Offset
  • func (f Offset[Q]) Apply(q Q)
• type OrderBy
  • func (f OrderBy[Q]) Apply(q Q)
• type Preload
  • func (s Preload[Q]) Apply(q Q)
• type QueryModFunc
  • func (q QueryModFunc[T]) Apply(query T)
• type QueryMods
  • func (q QueryMods[T]) Apply(query T)
• type Recursive
  • func (r Recursive[Q]) Apply(q Q)
• type Returning
  • func (s Returning[Q]) Apply(q Q)
• type Rows
  • func (r Rows[Q]) Apply(q Q)
• type Select
  • func (s Select[Q]) Apply(q Q)
• type Set
  • func (s Set[Q]) To(to any) bob.Mod[Q]
  • func (s Set[Q]) ToArg(to any) bob.Mod[Q]
• type Values
  • func (s Values[Q]) Apply(q Q)
• type Where
  • func (w Where[Q]) Apply(q Q)
• type Window
  • func (f Window[Q]) Apply(q Q)
• type With
  • func (f With[Q]) Apply(q Q)

Types

type Combine

type Combine[Q interface{ SetCombine(clause.Combine) }] clause.Combine

func (Combine[Q]) Apply

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

type Conflict

type Conflict[Q interface{ SetConflict(clause.Conflict) }] func() clause.Conflict

func (Conflict[Q]) Apply

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

func (Conflict[Q]) DoNothing

func (c Conflict[Q]) DoNothing() bob.Mod[Q]

func (Conflict[Q]) DoUpdate

func (c Conflict[Q]) DoUpdate(sets ...bob.Mod[*clause.Conflict]) bob.Mod[Q]

func (Conflict[Q]) Where

func (c Conflict[Q]) Where(where ...any) Conflict[Q]

type Fetch

type Fetch[Q interface{ SetFetch(clause.Fetch) }] clause.Fetch

func (Fetch[Q]) Apply

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

type For

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

func (For[Q]) Apply

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

type GroupBy

type GroupBy[Q interface{ AppendGroup(any) }] struct {
	E any
}

func (GroupBy[Q]) Apply

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

type GroupByDistinct

type GroupByDistinct[Q interface{ SetGroupByDistinct(bool) }] bool

func (GroupByDistinct[Q]) Apply

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

type GroupWith

type GroupWith[Q interface{ SetGroupWith(string) }] string

func (GroupWith[Q]) Apply

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

type Having

type Having[Q interface{ AppendHaving(e ...any) }] []any

func (Having[Q]) Apply

func (d Having[Q]) Apply(q Q)

type Join

type Join[Q interface{ AppendJoin(clause.Join) }] clause.Join

func (Join[Q]) Apply

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

type Limit

type Limit[Q interface{ SetLimit(limit any) }] struct {
	Count any
}

func (Limit[Q]) Apply

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

type Moddable

type Moddable[T bob.Expression] func(...bob.Mod[T]) T

This is a generic type for expressions can take extra mods as a function allows for some fluent API, for example with functions

func (Moddable[T]) WriteSQL

func (m Moddable[T]) WriteSQL(w io.Writer, d bob.Dialect, start int) ([]any, error)

type Offset

type Offset[Q interface{ SetOffset(offset any) }] struct {
	Count any
}

func (Offset[Q]) Apply

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

type OrderBy

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

func (OrderBy[Q]) Apply

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

type Preload

type Preload[Q interface{ AppendPreloadSelect(columns ...any) }] []any

func (Preload[Q]) Apply

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

type QueryModFunc

type QueryModFunc[T any] func(T)

func (QueryModFunc[T]) Apply

func (q QueryModFunc[T]) Apply(query T)

type QueryMods

type QueryMods[T any] []bob.Mod[T]

func (QueryMods[T]) Apply

func (q QueryMods[T]) Apply(query T)

type Recursive

type Recursive[Q interface{ SetRecursive(bool) }] bool

func (Recursive[Q]) Apply

func (r Recursive[Q]) Apply(q Q)

type Returning

type Returning[Q interface{ AppendReturning(vals ...any) }] []any

func (Returning[Q]) Apply

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

type Rows

type Rows[Q interface{ AppendValues(vals ...bob.Expression) }] [][]bob.Expression

func (Rows[Q]) Apply

func (r Rows[Q]) Apply(q Q)

type Select

type Select[Q interface{ AppendSelect(columns ...any) }] []any

func (Select[Q]) Apply

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

type Set

type Set[Q interface{ AppendSet(clauses ...any) }] []string

func (Set[Q]) To

func (s Set[Q]) To(to any) bob.Mod[Q]

func (Set[Q]) ToArg

func (s Set[Q]) ToArg(to any) bob.Mod[Q]

type Values

type Values[Q interface{ AppendValues(vals ...bob.Expression) }] []bob.Expression

func (Values[Q]) Apply

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

type Where

type Where[Q interface{ AppendWhere(e ...any) }] struct {
	E bob.Expression
}

func (Where[Q]) Apply

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

type Window

type Window[Q interface{ AppendWindow(clause.NamedWindow) }] clause.NamedWindow

func (Window[Q]) Apply

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

type With

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

func (With[Q]) Apply

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