exp

type Aliaseable interface {
	// Returns an AliasedExpression
	//    I("col").As("other_col") //"col" AS "other_col"
	//    I("col").As(I("other_col")) //"col" AS "other_col"
	As(interface{}) AliasedExpression
}

type AliasedExpression interface {
	Expression
	// Returns the Epxression being aliased
	Aliased() Expression
	// Returns the alias value as an identiier expression
	GetAs() IdentifierExpression

	// Returns a new IdentifierExpression with the specified schema
	Schema(string) IdentifierExpression
	// Returns a new IdentifierExpression with the specified table
	Table(string) IdentifierExpression
	// Returns a new IdentifierExpression with the specified column
	Col(interface{}) IdentifierExpression
	// Returns a new IdentifierExpression with the column set to *
	//   I("my_table").All() //"my_table".*
	All() IdentifierExpression
}

type AppendableExpression interface {
	Expression
	AppendSQL(b sb.SQLBuilder)
	// Returns the alias value as an identiier expression
	GetAs() IdentifierExpression

	// Returns true if this expression returns columns.
	// Used to determine if a Select, Update, Insert, or Delete query returns columns
	ReturnsColumns() bool
}

type BitwiseExpression interface {
	Expression
	Aliaseable
	Comparable
	Isable
	Inable
	Likeable
	Rangeable
	Orderable
	Distinctable
	// Returns the operator for the expression
	Op() BitwiseOperation
	// The left hand side of the expression (e.g. I("a")
	LHS() Expression
	// The right hand side of the expression could be a primitive value, dataset, or expression
	RHS() interface{}
}

type BitwiseOperation int

type Bitwiseable interface {
	// Creates a Bit Operation Expresion for sql ~
	// I("col").BitiInversion() // (~ "col")
	BitwiseInversion() BitwiseExpression
	// Creates a Bit Operation Expresion for sql |
	// I("col").BitOr(1) // ("col" | 1)
	BitwiseOr(interface{}) BitwiseExpression
	// Creates a Bit Operation Expresion for sql &
	// I("col").BitAnd(1) // ("col" & 1)
	BitwiseAnd(interface{}) BitwiseExpression
	// Creates a Bit Operation Expresion for sql ^
	// I("col").BitXor(1) // ("col" ^ 1)
	BitwiseXor(interface{}) BitwiseExpression
	// Creates a Bit Operation Expresion for sql <<
	// I("col").BitLeftShift(1) // ("col" << 1)
	BitwiseLeftShift(interface{}) BitwiseExpression
	// Creates a Bit Operation Expresion for sql >>
	// I("col").BitRighttShift(1) // ("col" >> 1)
	BitwiseRightShift(interface{}) BitwiseExpression
}

type BooleanExpression interface {
	Expression
	Aliaseable
	// Returns the operator for the expression
	Op() BooleanOperation
	// The left hand side of the expression (e.g. I("a")
	LHS() Expression
	// The right hand side of the expression could be a primitive value, dataset, or expression
	RHS() interface{}
}

type BooleanOperation int

type CaseElse interface {
	Result() interface{}
}

type CaseExpression interface {
	Expression
	Aliaseable
	Orderable
	GetValue() interface{}
	GetWhens() []CaseWhen
	GetElse() CaseElse
	Value(val interface{}) CaseExpression
	When(condition, result interface{}) CaseExpression
	Else(result interface{}) CaseExpression
}

type CaseWhen interface {
	Condition() interface{}
	Result() interface{}
}

type CastExpression interface {
	Expression
	Aliaseable
	Comparable
	Inable
	Isable
	Likeable
	Orderable
	Distinctable
	Rangeable
	// The exression being casted
	Casted() Expression
	// The the SQL type to cast the expression to
	Type() LiteralExpression
}

type Castable interface {
	// Casts an expression to the specified type
	//   I("a").Cast("numeric")//CAST("a" AS numeric)
	Cast(val string) CastExpression
}

type ColumnListExpression interface {
	Expression
	// Returns the list of columns
	Columns() []Expression
	// Returns true if the column list is empty
	IsEmpty() bool
	// Returns a new ColumnListExpression with the columns appended.
	Append(...Expression) ColumnListExpression
}

type CommonTableExpression interface {
	Expression
	IsRecursive() bool
	// Returns the alias name for the extracted expression
	Name() LiteralExpression
	// Returns the Expression being extracted
	SubQuery() Expression
}

type Comparable interface {
	// Creates a Boolean expression comparing equality
	//    I("col").Eq(1) //("col" = 1)
	Eq(interface{}) BooleanExpression
	// Creates a Boolean expression comparing in-equality
	//    I("col").Neq(1) //("col" != 1)
	Neq(interface{}) BooleanExpression
	// Creates a Boolean expression for greater than comparisons
	//    I("col").Gt(1) //("col" > 1)
	Gt(interface{}) BooleanExpression
	// Creates a Boolean expression for greater than or equal to than comparisons
	//    I("col").Gte(1) //("col" >= 1)
	Gte(interface{}) BooleanExpression
	// Creates a Boolean expression for less than comparisons
	//    I("col").Lt(1) //("col" < 1)
	Lt(interface{}) BooleanExpression
	// Creates a Boolean expression for less than or equal to comparisons
	//    I("col").Lte(1) //("col" <= 1)
	Lte(interface{}) BooleanExpression
}

type CompoundExpression interface {
	Expression
	Type() CompoundType
	RHS() AppendableExpression
}

type CompoundType int

type ConditionedJoinExpression interface {
	JoinExpression
	Condition() JoinCondition
	IsConditionEmpty() bool
}

type ConflictAction int

type ConflictExpression interface {
	Expression
	Action() ConflictAction
}

type ConflictUpdateExpression interface {
	ConflictExpression
	TargetColumn() string
	Where(expressions ...Expression) ConflictUpdateExpression
	WhereClause() ExpressionList
	Update() interface{}
}

type DeleteClauses interface {
	HasFrom() bool

	CommonTables() []CommonTableExpression
	CommonTablesAppend(cte CommonTableExpression) DeleteClauses

	From() IdentifierExpression
	SetFrom(table IdentifierExpression) DeleteClauses

	Where() ExpressionList
	ClearWhere() DeleteClauses
	WhereAppend(expressions ...Expression) DeleteClauses

	Order() ColumnListExpression
	HasOrder() bool
	ClearOrder() DeleteClauses
	SetOrder(oes ...OrderedExpression) DeleteClauses
	OrderAppend(...OrderedExpression) DeleteClauses
	OrderPrepend(...OrderedExpression) DeleteClauses

	Limit() interface{}
	HasLimit() bool
	ClearLimit() DeleteClauses
	SetLimit(limit interface{}) DeleteClauses

	Returning() ColumnListExpression
	HasReturning() bool
	SetReturning(cl ColumnListExpression) DeleteClauses
	// contains filtered or unexported methods
}

type Distinctable interface {
	// Creates a DISTINCT clause
	//   I("a").Distinct() //DISTINCT("a")
	Distinct() SQLFunctionExpression
}

type Ex map[string]interface{}

type ExOr map[string]interface{}

type Expression interface {
	Clone() Expression
	Expression() Expression
}

type ExpressionList interface {
	Expression
	// Returns type (e.g. OR, AND)
	Type() ExpressionListType
	// Slice of expressions that should be joined together
	Expressions() []Expression
	// Returns a new expression list with the given expressions appended to the current Expressions list
	Append(...Expression) ExpressionList

	IsEmpty() bool
}

type ExpressionListType int

type IdentifierExpression interface {
	Expression
	Aliaseable
	Comparable
	Inable
	Isable
	Likeable
	Rangeable
	Orderable
	Updateable
	Distinctable
	Castable
	Bitwiseable
	// returns true if this identifier has more more than on part (Schema, Table or Col)
	//	"schema" -> true //cant qualify anymore
	//	"schema.table" -> true
	//	"table" -> false
	// "schema"."table"."col" -> true
	// "table"."col" -> true
	// "col" -> false
	IsQualified() bool
	// Returns a new IdentifierExpression with the specified schema
	Schema(string) IdentifierExpression
	// Returns the current schema
	GetSchema() string
	// Returns a new IdentifierExpression with the specified table
	Table(string) IdentifierExpression
	// Returns the current table
	GetTable() string
	// Returns a new IdentifierExpression with the specified column
	Col(interface{}) IdentifierExpression
	// Returns the current column
	GetCol() interface{}
	// Returns a new IdentifierExpression with the column set to *
	//   I("my_table").All() //"my_table".*
	All() IdentifierExpression

	// Returns true if schema table and identifier are all zero values.
	IsEmpty() bool
}

type Inable interface {
	// Creates a Boolean expression for IN clauses
	//    I("col").In([]string{"a", "b", "c"}) //("col" IN ('a', 'b', 'c'))
	In(...interface{}) BooleanExpression
	// Creates a Boolean expression for NOT IN clauses
	//    I("col").NotIn([]string{"a", "b", "c"}) //("col" NOT IN ('a', 'b', 'c'))
	NotIn(...interface{}) BooleanExpression
}

type InsertClauses interface {
	CommonTables() []CommonTableExpression
	CommonTablesAppend(cte CommonTableExpression) InsertClauses

	HasInto() bool

	Cols() ColumnListExpression
	HasCols() bool
	ColsAppend(cols ColumnListExpression) InsertClauses
	SetCols(cols ColumnListExpression) InsertClauses

	Into() Expression
	SetInto(cl Expression) InsertClauses

	Returning() ColumnListExpression
	HasReturning() bool
	SetReturning(cl ColumnListExpression) InsertClauses

	From() AppendableExpression
	HasFrom() bool
	SetFrom(ae AppendableExpression) InsertClauses

	Rows() []interface{}
	HasRows() bool
	SetRows(rows []interface{}) InsertClauses

	HasAlias() bool
	Alias() IdentifierExpression
	SetAlias(ie IdentifierExpression) InsertClauses

	Vals() [][]interface{}
	HasVals() bool
	SetVals(vals [][]interface{}) InsertClauses
	ValsAppend(vals [][]interface{}) InsertClauses

	OnConflict() ConflictExpression
	SetOnConflict(expression ConflictExpression) InsertClauses
	// contains filtered or unexported methods
}

type InsertExpression interface {
	Expression
	IsEmpty() bool
	IsInsertFrom() bool
	From() AppendableExpression
	Cols() ColumnListExpression
	SetCols(cols ColumnListExpression) InsertExpression
	Vals() [][]interface{}
	SetVals([][]interface{}) InsertExpression
}

type Isable interface {
	// Creates an Boolean expression IS clauses
	//   ds.Where(I("a").Is(nil)) //("a" IS NULL)
	//   ds.Where(I("a").Is(true)) //("a" IS TRUE)
	//   ds.Where(I("a").Is(false)) //("a" IS FALSE)
	Is(interface{}) BooleanExpression
	// Creates an Boolean expression IS NOT clauses
	//   ds.Where(I("a").IsNot(nil)) //("a" IS NOT NULL)
	//   ds.Where(I("a").IsNot(true)) //("a" IS NOT TRUE)
	//   ds.Where(I("a").IsNot(false)) //("a" IS NOT FALSE)
	IsNot(interface{}) BooleanExpression
	// Shortcut for Is(nil)
	IsNull() BooleanExpression
	// Shortcut for IsNot(nil)
	IsNotNull() BooleanExpression
	// Shortcut for Is(true)
	IsTrue() BooleanExpression
	// Shortcut for IsNot(true)
	IsNotTrue() BooleanExpression
	// Shortcut for Is(false)
	IsFalse() BooleanExpression
	// Shortcut for IsNot(false)
	IsNotFalse() BooleanExpression
}

type JoinCondition interface {
	Type() JoinConditionType
	IsEmpty() bool
}

type JoinConditionType int

type JoinExpression interface {
	Expression
	JoinType() JoinType
	IsConditioned() bool
	Table() Expression
}

type JoinExpressions []JoinExpression

type JoinOnCondition interface {
	JoinCondition
	On() ExpressionList
}

type JoinType int

type JoinUsingCondition interface {
	JoinCondition
	Using() ColumnListExpression
}

type LateralExpression interface {
	Expression
	Aliaseable
	Table() AppendableExpression
}

type Likeable interface {
	// Creates an Boolean expression for LIKE clauses
	//   ds.Where(I("a").Like("a%")) //("a" LIKE 'a%')
	Like(interface{}) BooleanExpression
	// Creates an Boolean expression for NOT LIKE clauses
	//   ds.Where(I("a").NotLike("a%")) //("a" NOT LIKE 'a%')
	NotLike(interface{}) BooleanExpression
	// Creates an Boolean expression for case insensitive LIKE clauses
	//   ds.Where(I("a").ILike("a%")) //("a" ILIKE 'a%')
	ILike(interface{}) BooleanExpression
	// Creates an Boolean expression for case insensitive NOT LIKE clauses
	//   ds.Where(I("a").NotILike("a%")) //("a" NOT ILIKE 'a%')
	NotILike(interface{}) BooleanExpression

	// Creates an Boolean expression for REGEXP LIKE clauses
	//   ds.Where(I("a").RegexpLike("a%")) //("a" ~ 'a%')
	RegexpLike(interface{}) BooleanExpression
	// Creates an Boolean expression for REGEXP NOT LIKE clauses
	//   ds.Where(I("a").RegexpNotLike("a%")) //("a" !~ 'a%')
	RegexpNotLike(interface{}) BooleanExpression
	// Creates an Boolean expression for case insensitive REGEXP ILIKE clauses
	//   ds.Where(I("a").RegexpILike("a%")) //("a" ~* 'a%')
	RegexpILike(interface{}) BooleanExpression
	// Creates an Boolean expression for case insensitive REGEXP NOT ILIKE clauses
	//   ds.Where(I("a").RegexpNotILike("a%")) //("a" !~* 'a%')
	RegexpNotILike(interface{}) BooleanExpression
}

type LiteralExpression interface {
	Expression
	Aliaseable
	Comparable
	Isable
	Inable
	Likeable
	Rangeable
	Orderable
	Bitwiseable
	// Returns the literal sql
	Literal() string
	// Arguments to be replaced within the sql
	Args() []interface{}
}

type Lock interface {
	Strength() LockStrength
	WaitOption() WaitOption
	Of() []IdentifierExpression
}

type LockStrength int

type NullSortType int

type Op map[string]interface{}

type Orderable interface {
	// Creates an Ordered Expression for sql ASC order
	//   ds.Order(I("a").Asc()) //ORDER BY "a" ASC
	Asc() OrderedExpression
	// Creates an Ordered Expression for sql DESC order
	//   ds.Order(I("a").Desc()) //ORDER BY "a" DESC
	Desc() OrderedExpression
}

type OrderedExpression interface {
	Expression
	// The expression being sorted
	SortExpression() Expression
	// Sort direction (e.g. ASC, DESC)
	IsAsc() bool
	// If the adapter supports it null sort type (e.g. NULLS FIRST, NULLS LAST)
	NullSortType() NullSortType
	// Returns a new OrderedExpression with NullSortType set to NULLS_FIRST
	NullsFirst() OrderedExpression
	// Returns a new OrderedExpression with NullSortType set to NULLS_LAST
	NullsLast() OrderedExpression
}

type RangeExpression interface {
	Expression
	// Returns the operator for the expression
	Op() RangeOperation
	// The left hand side of the expression (e.g. I("a")
	LHS() Expression
	// The right hand side of the expression could be a primitive value, dataset, or expression
	RHS() RangeVal
}

type RangeOperation int

type RangeVal interface {
	Start() interface{}
	End() interface{}
}

type Rangeable interface {
	// Creates a Range expression for between comparisons
	//    I("col").Between(RangeVal{Start:1, End:10}) //("col" BETWEEN 1 AND 10)
	Between(RangeVal) RangeExpression
	// Creates a Range expression for between comparisons
	//    I("col").NotBetween(RangeVal{Start:1, End:10}) //("col" NOT BETWEEN 1 AND 10)
	NotBetween(RangeVal) RangeExpression
}

type Record map[string]interface{}

type SQLExpression interface {
	Expression
	ToSQL() (string, []interface{}, error)
	IsPrepared() bool
}

type SQLFunctionExpression interface {
	Expression
	Aliaseable
	Rangeable
	Comparable
	Orderable
	Isable
	Inable
	Likeable
	Windowable
	// The function name
	Name() string
	// Arguments to be passed to the function
	Args() []interface{}
}

type SQLWindowFunctionExpression interface {
	Expression
	Aliaseable
	Rangeable
	Comparable
	Orderable
	Isable
	Inable
	Likeable
	Func() SQLFunctionExpression

	Window() WindowExpression
	WindowName() IdentifierExpression

	HasWindow() bool
	HasWindowName() bool
}

type SelectClauses interface {
	HasSources() bool
	IsDefaultSelect() bool

	Select() ColumnListExpression
	SelectAppend(cl ColumnListExpression) SelectClauses
	SetSelect(cl ColumnListExpression) SelectClauses

	Distinct() ColumnListExpression
	SetDistinct(cle ColumnListExpression) SelectClauses

	From() ColumnListExpression
	SetFrom(cl ColumnListExpression) SelectClauses

	HasAlias() bool
	Alias() IdentifierExpression
	SetAlias(ie IdentifierExpression) SelectClauses

	Joins() JoinExpressions
	JoinsAppend(jc JoinExpression) SelectClauses

	Where() ExpressionList
	ClearWhere() SelectClauses
	WhereAppend(expressions ...Expression) SelectClauses

	Having() ExpressionList
	ClearHaving() SelectClauses
	HavingAppend(expressions ...Expression) SelectClauses

	Order() ColumnListExpression
	HasOrder() bool
	ClearOrder() SelectClauses
	SetOrder(oes ...OrderedExpression) SelectClauses
	OrderAppend(...OrderedExpression) SelectClauses
	OrderPrepend(...OrderedExpression) SelectClauses

	GroupBy() ColumnListExpression
	SetGroupBy(cl ColumnListExpression) SelectClauses
	GroupByAppend(cl ColumnListExpression) SelectClauses

	Limit() interface{}
	HasLimit() bool
	ClearLimit() SelectClauses
	SetLimit(limit interface{}) SelectClauses

	Offset() uint
	ClearOffset() SelectClauses
	SetOffset(offset uint) SelectClauses

	Compounds() []CompoundExpression
	CompoundsAppend(ce CompoundExpression) SelectClauses

	Lock() Lock
	SetLock(l Lock) SelectClauses

	CommonTables() []CommonTableExpression
	CommonTablesAppend(cte CommonTableExpression) SelectClauses

	Windows() []WindowExpression
	SetWindows(ws []WindowExpression) SelectClauses
	WindowsAppend(ws ...WindowExpression) SelectClauses
	ClearWindows() SelectClauses
	// contains filtered or unexported methods
}

type SortDirection int

type TruncateClauses interface {
	HasTable() bool

	Table() ColumnListExpression
	SetTable(tables ColumnListExpression) TruncateClauses

	Options() TruncateOptions
	SetOptions(opts TruncateOptions) TruncateClauses
	// contains filtered or unexported methods
}

type TruncateOptions struct {
	// Set to true to add CASCADE to the TRUNCATE statement
	Cascade bool
	// Set to true to add RESTRICT to the TRUNCATE statement
	Restrict bool
	// Set to true to specify IDENTITY options, (e.g. RESTART, CONTINUE) to the TRUNCATE statement
	Identity string
}

type UpdateClauses interface {
	HasTable() bool

	CommonTables() []CommonTableExpression
	CommonTablesAppend(cte CommonTableExpression) UpdateClauses

	Table() Expression
	SetTable(table Expression) UpdateClauses

	SetValues() interface{}
	HasSetValues() bool
	SetSetValues(values interface{}) UpdateClauses

	From() ColumnListExpression
	HasFrom() bool
	SetFrom(tables ColumnListExpression) UpdateClauses

	Where() ExpressionList
	ClearWhere() UpdateClauses
	WhereAppend(expressions ...Expression) UpdateClauses

	Order() ColumnListExpression
	HasOrder() bool
	ClearOrder() UpdateClauses
	SetOrder(oes ...OrderedExpression) UpdateClauses
	OrderAppend(...OrderedExpression) UpdateClauses
	OrderPrepend(...OrderedExpression) UpdateClauses

	Limit() interface{}
	HasLimit() bool
	ClearLimit() UpdateClauses
	SetLimit(limit interface{}) UpdateClauses

	Returning() ColumnListExpression
	HasReturning() bool
	SetReturning(cl ColumnListExpression) UpdateClauses
	// contains filtered or unexported methods
}

type UpdateExpression interface {
	Col() IdentifierExpression
	Val() interface{}
}

type Updateable interface {
	// Used internally by update sql
	Set(interface{}) UpdateExpression
}

type Vals []interface{}

type WaitOption int

type WindowExpression interface {
	Expression

	Name() IdentifierExpression
	HasName() bool

	Parent() IdentifierExpression
	HasParent() bool
	PartitionCols() ColumnListExpression
	HasPartitionBy() bool
	OrderCols() ColumnListExpression
	HasOrder() bool

	Inherit(parent string) WindowExpression
	PartitionBy(cols ...interface{}) WindowExpression
	OrderBy(cols ...interface{}) WindowExpression
}

type Windowable interface {
	Over(WindowExpression) SQLWindowFunctionExpression
	OverName(IdentifierExpression) SQLWindowFunctionExpression
}