sql

package
v0.0.11 Latest Latest
Warning

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

 Go to latest Published: May 13, 2024 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AssignmentClause 

type AssignmentClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewAssignmentClause 

func NewAssignmentClause[T sqb.Statement[T]](self T) *AssignmentClause[T]

func (*AssignmentClause[T]) Assign 

func (a *AssignmentClause[T]) Assign(column any, args ...any) T

Assign adds column and value to the SET clause.

  • Assign(column any)
  • Assign(column any, value any)

func (*AssignmentClause[T]) BuildAssignment 

func (a *AssignmentClause[T]) BuildAssignment() T

func (*AssignmentClause[T]) CleanAssignment 

func (a *AssignmentClause[T]) CleanAssignment() T

func (*AssignmentClause[T]) CopyAssignment 

func (a *AssignmentClause[T]) CopyAssignment(self T) *AssignmentClause[T]

type ColumnsClause 

type ColumnsClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewColumnsClause 

func NewColumnsClause[T sqb.Statement[T]](self T) *ColumnsClause[T]

func (*ColumnsClause[T]) BuildColumns 

func (c *ColumnsClause[T]) BuildColumns() T

func (*ColumnsClause[T]) CleanColumns 

func (c *ColumnsClause[T]) CleanColumns() T

func (*ColumnsClause[T]) Columns 

func (c *ColumnsClause[T]) Columns(columns any) T

func (*ColumnsClause[T]) CopyColumns 

func (c *ColumnsClause[T]) CopyColumns(self T) *ColumnsClause[T]

type DeleteClause 

type DeleteClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewDeleteClause 

func NewDeleteClause[T sqb.Statement[T]](self T) *DeleteClause[T]

func (*DeleteClause[T]) BuildDelete 

func (d *DeleteClause[T]) BuildDelete() (T, sql.DirectListExpression)

func (*DeleteClause[T]) CleanDelete 

func (d *DeleteClause[T]) CleanDelete() T

func (*DeleteClause[T]) CopyDelete 

func (d *DeleteClause[T]) CopyDelete(self T) *DeleteClause[T]

func (*DeleteClause[T]) From 

func (d *DeleteClause[T]) From(table any, args ...any) T

From adds table name and its alias to the delete clause:

  • From(table any)
  • From(table any, alias any)

type FromClause 

type FromClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewFromClause 

func NewFromClause[T sqb.Statement[T]](self T) *FromClause[T]

func (*FromClause[T]) BuildFrom 

func (f *FromClause[T]) BuildFrom() T

func (*FromClause[T]) CleanFrom 

func (f *FromClause[T]) CleanFrom() T

func (*FromClause[T]) CopyFrom 

func (f *FromClause[T]) CopyFrom(self T) *FromClause[T]

func (*FromClause[T]) From 

func (f *FromClause[T]) From(table any, args ...any) T

From adds table name and its alias to the "from" clause:

  • From(table any)
  • From(table any, alias any)

type GroupClause 

type GroupClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewGroupClause 

func NewGroupClause[T sqb.Statement[T]](self T) *GroupClause[T]

func (*GroupClause[T]) BuildGroup 

func (g *GroupClause[T]) BuildGroup() T

func (*GroupClause[T]) CleanGroup 

func (g *GroupClause[T]) CleanGroup() T

func (*GroupClause[T]) CopyGroup 

func (g *GroupClause[T]) CopyGroup(self T) *GroupClause[T]

func (*GroupClause[T]) GroupBy 

func (g *GroupClause[T]) GroupBy(column any, args ...any) T

GroupBy adds column name and its order to the group clause:

  • GroupBy(column any)
  • GroupBy(column any, order any)

type HavingClause 

type HavingClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewHavingClause 

func NewHavingClause[T sqb.Statement[T]](self T) *HavingClause[T]

func (*HavingClause[T]) AndHaving 

func (h *HavingClause[T]) AndHaving(args ...any) T

AndHaving adds "AND" exp condition to the statement:

  • AndHaving(condition string)
  • AndHaving(condition ConditionalExpression)
  • AndHaving(column string, operator string, value any)
  • AndHaving(operand any, operator string, value any)
  • AndHaving(operator string, operand any)

func (*HavingClause[T]) BuildHaving 

func (h *HavingClause[T]) BuildHaving() T

func (*HavingClause[T]) CleanHaving 

func (h *HavingClause[T]) CleanHaving() T

func (*HavingClause[T]) CopyHaving 

func (h *HavingClause[T]) CopyHaving(self T) *HavingClause[T]

func (*HavingClause[T]) Having 

func (h *HavingClause[T]) Having(args ...any) T

Having adds "OR" or "AND" condition to the statement:

  • Having(condition string)
  • Having(condition ConditionalExpression)
  • Having(column string, operator string, value any)
  • Having(operand any, operator string, value any)
  • Having(operator string, operand any)

func (*HavingClause[T]) OrHaving 

func (h *HavingClause[T]) OrHaving(args ...any) T

OrHaving adds "OR" exp condition to the statement:

  • OrHaving(condition string)
  • OrHaving(condition ConditionalExpression)
  • OrHaving(column string, operator string, value any)
  • OrHaving(operand any, operator string, value any)
  • OrHaving(operator string, operand any)

type InsertClause 

type InsertClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewInsertClause 

func NewInsertClause[T sqb.Statement[T]](self T) *InsertClause[T]

func (*InsertClause[T]) BuildInsert 

func (i *InsertClause[T]) BuildInsert() (T, sql.DirectListExpression)

func (*InsertClause[T]) CleanInsert 

func (i *InsertClause[T]) CleanInsert() T

func (*InsertClause[T]) CopyInsert 

func (i *InsertClause[T]) CopyInsert(self T) *InsertClause[T]

func (*InsertClause[T]) Into 

func (i *InsertClause[T]) Into(table any, args ...any) T

Into adds table name and its alias to the insert clause:

  • Into(table any)
  • Into(table any, alias any)

type JoinClause 

type JoinClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewJoinClause 

func NewJoinClause[T sqb.Statement[T]](self T) *JoinClause[T]

func (*JoinClause[T]) BuildJoin 

func (j *JoinClause[T]) BuildJoin() T

func (*JoinClause[T]) CleanJoin 

func (j *JoinClause[T]) CleanJoin() T

func (*JoinClause[T]) CopyJoin 

func (j *JoinClause[T]) CopyJoin(self T) *JoinClause[T]

func (*JoinClause[T]) CrossJoin 

func (j *JoinClause[T]) CrossJoin(table any, args ...any) T

CrossJoin adds cross join on new table with alias and condition:

  • CrossJoin(table any, condition any)
  • CrossJoin(table any, alias any, condition any)

func (*JoinClause[T]) InnerJoin 

func (j *JoinClause[T]) InnerJoin(table any, args ...any) T

InnerJoin adds inner join on new table with alias and condition:

  • InnerJoin(table any, condition any)
  • InnerJoin(table any, alias any, condition any)

func (*JoinClause[T]) Join 

func (j *JoinClause[T]) Join(joinType string, table any, args ...any) T

Join joins new table with alias and condition:

  • Join(joinType string, table any, condition any)
  • Join(joinType string, table any, alias any, condition any)

func (*JoinClause[T]) LeftJoin 

func (j *JoinClause[T]) LeftJoin(table any, args ...any) T

LeftJoin adds left join on new table with alias and condition:

  • LeftJoin(table any, condition any)
  • LeftJoin(table any, alias any, condition any)

func (*JoinClause[T]) LeftOuterJoin 

func (j *JoinClause[T]) LeftOuterJoin(table any, args ...any) T

LeftOuterJoin adds left outer join on new table with alias and condition:

  • LeftOuterJoin(table any, condition any)
  • LeftOuterJoin(table any, alias any, condition any)

func (*JoinClause[T]) NaturalInnerJoin 

func (j *JoinClause[T]) NaturalInnerJoin(table any, args ...any) T

NaturalInnerJoin adds natural inner join on new table with alias and condition:

  • NaturalInnerJoin(table any, condition any)
  • NaturalInnerJoin(table any, alias any, condition any)

func (*JoinClause[T]) NaturalLeftJoin 

func (j *JoinClause[T]) NaturalLeftJoin(table any, args ...any) T

NaturalLeftJoin adds natural left join on new table with alias and condition:

  • NaturalLeftJoin(table any, condition any)
  • NaturalLeftJoin(table any, alias any, condition any)

func (*JoinClause[T]) NaturalLeftOuterJoin 

func (j *JoinClause[T]) NaturalLeftOuterJoin(table any, args ...any) T

NaturalLeftOuterJoin adds natural left outer join on new table with alias and condition:

  • NaturalLeftOuterJoin(table any, condition any)
  • NaturalLeftOuterJoin(table any, alias any, condition any)

func (*JoinClause[T]) NaturalRightJoin 

func (j *JoinClause[T]) NaturalRightJoin(table any, args ...any) T

NaturalRightJoin adds natural right join on new table with alias and condition:

  • NaturalRightJoin(table any, condition any)
  • NaturalRightJoin(table any, alias any, condition any)

func (*JoinClause[T]) NaturalRightOuterJoin 

func (j *JoinClause[T]) NaturalRightOuterJoin(table any, args ...any) T

NaturalRightOuterJoin adds natural right outer join on new table with alias and condition:

  • NaturalRightOuterJoin(table any, condition any)
  • NaturalRightOuterJoin(table any, alias any, condition any)

func (*JoinClause[T]) RightJoin 

func (j *JoinClause[T]) RightJoin(table any, args ...any) T

RightJoin adds right join on new table with alias and condition:

  • RightJoin(table any, condition any)
  • rightJoin(table any, alias any, condition any)

func (*JoinClause[T]) RightOuterJoin 

func (j *JoinClause[T]) RightOuterJoin(table any, args ...any) T

RightOuterJoin adds right outer join on new table with alias and condition:

  • RightOuterJoin(table any, condition any)
  • RightOuterJoin(table any, alias any, condition any)

type LimitClause 

type LimitClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewLimitClause 

func NewLimitClause[T sqb.Statement[T]](self T) *LimitClause[T]

func (*LimitClause[T]) BuildLimit 

func (l *LimitClause[T]) BuildLimit() T

func (*LimitClause[T]) CleanLimit 

func (l *LimitClause[T]) CleanLimit() T

func (*LimitClause[T]) CopyLimit 

func (l *LimitClause[T]) CopyLimit(self T) *LimitClause[T]

func (*LimitClause[T]) Limit 

func (l *LimitClause[T]) Limit(limit int) T

type LockingClause 

type LockingClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewLockingClause 

func NewLockingClause[T sqb.Statement[T]](self T) *LockingClause[T]

func (*LockingClause[T]) BuildLock 

func (l *LockingClause[T]) BuildLock() T

func (*LockingClause[T]) CleanLock 

func (l *LockingClause[T]) CleanLock() T

func (*LockingClause[T]) CopyLock 

func (l *LockingClause[T]) CopyLock(self T) *LockingClause[T]

func (*LockingClause[T]) ForLock 

func (l *LockingClause[T]) ForLock(strength string, args ...any) T

ForLock sets the lock clause of the statement:

  • ForLock(strength string, table any)
  • ForLock(strength string, table any, option string)

func (*LockingClause[T]) ForShare 

func (l *LockingClause[T]) ForShare(args ...any) T

ForShare sets the lock for share clause of the statement:

  • ForShare(table any)
  • ForShare(table any, option string)

func (*LockingClause[T]) ForUpdate 

func (l *LockingClause[T]) ForUpdate(args ...any) T

ForUpdate sets the lock for update clause of the statement:

  • ForUpdate(table any)
  • ForUpdate(table any, option string)

type OffsetClause 

type OffsetClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewOffsetClause 

func NewOffsetClause[T sqb.Statement[T]](self T) *OffsetClause[T]

func (*OffsetClause[T]) BuildOffset 

func (o *OffsetClause[T]) BuildOffset() T

func (*OffsetClause[T]) CleanOffset 

func (o *OffsetClause[T]) CleanOffset() T

func (*OffsetClause[T]) CopyOffset 

func (o *OffsetClause[T]) CopyOffset(self T) *OffsetClause[T]

func (*OffsetClause[T]) Offset 

func (o *OffsetClause[T]) Offset(offset int) T

type OrderClause 

type OrderClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewOrderClause 

func NewOrderClause[T sqb.Statement[T]](self T) *OrderClause[T]

func (*OrderClause[T]) BuildOrder 

func (o *OrderClause[T]) BuildOrder() T

func (*OrderClause[T]) CleanOrder 

func (o *OrderClause[T]) CleanOrder() T

func (*OrderClause[T]) CopyOrder 

func (o *OrderClause[T]) CopyOrder(self T) *OrderClause[T]

func (*OrderClause[T]) OrderBy 

func (o *OrderClause[T]) OrderBy(column any, args ...any) T

OrderBy adds column name and its order to the order clause:

  • OrderBy(column any)
  • OrderBy(column any, order any)

type ReturningClause 

type ReturningClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewReturningClause 

func NewReturningClause[T sqb.Statement[T]](self T) *ReturningClause[T]

func (*ReturningClause[T]) BuildReturning 

func (r *ReturningClause[T]) BuildReturning() T

func (*ReturningClause[T]) CleanReturning 

func (r *ReturningClause[T]) CleanReturning() T

func (*ReturningClause[T]) CopyReturning 

func (r *ReturningClause[T]) CopyReturning(self T) *ReturningClause[T]

func (*ReturningClause[T]) Returning 

func (r *ReturningClause[T]) Returning(column any, args ...any) T

Returning adds column name and its alias to the returning clause:

  • Returning(column any)
  • Returning(column any, alias any)

func (*ReturningClause[T]) ReturningAll 

func (r *ReturningClause[T]) ReturningAll() T

type SelectClause 

type SelectClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewSelectClause 

func NewSelectClause[T sqb.Statement[T]](self T) *SelectClause[T]

func (*SelectClause[T]) BuildSelect 

func (s *SelectClause[T]) BuildSelect() T

func (*SelectClause[T]) CleanSelect 

func (s *SelectClause[T]) CleanSelect() T

func (*SelectClause[T]) CopySelect 

func (s *SelectClause[T]) CopySelect(self T) *SelectClause[T]

func (*SelectClause[T]) Select 

func (s *SelectClause[T]) Select(column any, args ...any) T

Select adds column name and its alias to the select clause:

  • Select(column any)
  • Select(column any, alias any)

type UnionClause 

type UnionClause[T sqb.QueryStmt[T]] struct {
	// contains filtered or unexported fields
}

func NewUnionClause 

func NewUnionClause[T sqb.QueryStmt[T]](self T) *UnionClause[T]

func (*UnionClause[T]) BuildUnion 

func (u *UnionClause[T]) BuildUnion() T

func (*UnionClause[T]) IsUnion 

func (u *UnionClause[T]) IsUnion() bool

func (*UnionClause[T]) Union 

func (u *UnionClause[T]) Union(query sqb.Query) T

func (*UnionClause[T]) UnionAll 

func (u *UnionClause[T]) UnionAll(query sqb.Query) T

func (*UnionClause[T]) UnionType 

func (u *UnionClause[T]) UnionType(unionType string, query sqb.Query) T

type UnionQuery 

type UnionQuery struct {
	UnionType string
	Query     sqb.Query
}

type UpdateClause 

type UpdateClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewUpdateClause 

func NewUpdateClause[T sqb.Statement[T]](self T) *UpdateClause[T]

func (*UpdateClause[T]) BuildUpdate 

func (u *UpdateClause[T]) BuildUpdate() (T, sql.DirectListExpression)

func (*UpdateClause[T]) CleanUpdate 

func (u *UpdateClause[T]) CleanUpdate() T

func (*UpdateClause[T]) CopyUpdate 

func (u *UpdateClause[T]) CopyUpdate(self T) *UpdateClause[T]

func (*UpdateClause[T]) Table 

func (u *UpdateClause[T]) Table(table any, args ...any) T

Table adds table name and its alias to the update clause:

  • Table(table any)
  • Table(table any, alias any)

type UsingClause 

type UsingClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewUsingClause 

func NewUsingClause[T sqb.Statement[T]](self T) *UsingClause[T]

func (*UsingClause[T]) BuildUsing 

func (u *UsingClause[T]) BuildUsing() T

func (*UsingClause[T]) CleanUsing 

func (u *UsingClause[T]) CleanUsing() T

func (*UsingClause[T]) CopyUsing 

func (u *UsingClause[T]) CopyUsing(self T) *UsingClause[T]

func (*UsingClause[T]) Using 

func (u *UsingClause[T]) Using(table any, args ...any) T

Using adds table name and its alias to the using clause:

  • Using(table any)
  • Using(table any, alias any)

type ValueListClause 

type ValueListClause[T sqb.ColumnsAwareStmt[T], Q sqb.QueryStmt[Q]] struct {
	// contains filtered or unexported fields
}

func NewValueListClause 

func NewValueListClause[T sqb.ColumnsAwareStmt[T], Q sqb.QueryStmt[Q]](self T) *ValueListClause[T, Q]

func (*ValueListClause[T, Q]) BuildValueList 

func (v *ValueListClause[T, Q]) BuildValueList() (T, *Q, sql.ValueListExpression)

func (*ValueListClause[T, Q]) CleanValueList 

func (v *ValueListClause[T, Q]) CleanValueList() T

func (*ValueListClause[T, Q]) CopyValueList 

func (v *ValueListClause[T, Q]) CopyValueList(self T) *ValueListClause[T, Q]

func (*ValueListClause[T, Q]) Select 

func (v *ValueListClause[T, Q]) Select(query Q) T

func (*ValueListClause[T, Q]) Values 

func (v *ValueListClause[T, Q]) Values(values any, args ...any) T

Values add values and columns to the value list clause: Values(values any) Values(values any, columns any)

type ValuesClause 

type ValuesClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewValuesClause 

func NewValuesClause[T sqb.Statement[T]](self T) *ValuesClause[T]

func (*ValuesClause[T]) BuildValues 

func (v *ValuesClause[T]) BuildValues() T

func (*ValuesClause[T]) CleanValues 

func (v *ValuesClause[T]) CleanValues() T

func (*ValuesClause[T]) CopyValues 

func (v *ValuesClause[T]) CopyValues(self T) *ValuesClause[T]

func (*ValuesClause[T]) Values 

func (v *ValuesClause[T]) Values(values any) T

type WhereClause 

type WhereClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewWhereClause 

func NewWhereClause[T sqb.Statement[T]](self T) *WhereClause[T]

func (*WhereClause[T]) AndWhere 

func (w *WhereClause[T]) AndWhere(args ...any) T

AndWhere adds "AND" condition to the statement:

  • AndWhere(condition string)
  • AndWhere(condition ConditionalExpression)
  • AndWhere(column string, operator string, value any)
  • AndWhere(operand any, operator string, value any)
  • AndWhere(operator string, operand any)

func (*WhereClause[T]) BuildWhere 

func (w *WhereClause[T]) BuildWhere() T

func (*WhereClause[T]) CleanWhere 

func (w *WhereClause[T]) CleanWhere() T

func (*WhereClause[T]) CopyWhere 

func (w *WhereClause[T]) CopyWhere(self T) *WhereClause[T]

func (*WhereClause[T]) OrWhere 

func (w *WhereClause[T]) OrWhere(args ...any) T

OrWhere adds "OR" condition to the statement:

  • OrWhere(condition string)
  • OrWhere(condition ConditionalExpression)
  • OrWhere(column string, operator string, value any)
  • OrWhere(operand any, operator string, value any)
  • OrWhere(operator string, operand any)

func (*WhereClause[T]) Where 

func (w *WhereClause[T]) Where(args ...any) T

Where adds "OR" or "AND" condition to the statement:

  • Where(condition string)
  • Where(condition ConditionalExpression)
  • Where(column string, operator string, value any)
  • Where(operand any, operator string, value any)
  • Where(operator string, operand any)

type WithClause 

type WithClause[T sqb.Statement[T]] struct {
	// contains filtered or unexported fields
}

func NewWithClause 

func NewWithClause[T sqb.Statement[T]](self T) *WithClause[T]

func (*WithClause[T]) BuildWith 

func (w *WithClause[T]) BuildWith() T

func (*WithClause[T]) CleanWith 

func (w *WithClause[T]) CleanWith() T

func (*WithClause[T]) CopyWith 

func (w *WithClause[T]) CopyWith(self T) *WithClause[T]

func (*WithClause[T]) With 

func (w *WithClause[T]) With(query any, args ...any) T

With adds query to the with clause: With(query any) With(query any, alias any)

func (*WithClause[T]) WithRecursive 

func (w *WithClause[T]) WithRecursive(query any, args ...any) T

WithRecursive adds recursive query to the with clause: WithRecursive(query any) WithRecursive(query any, alias any)

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.