jet

type BoolExpression interface {
	Expression

	// Check if this expression is equal to rhs
	EQ(rhs BoolExpression) BoolExpression
	// Check if this expression is not equal to rhs
	NOT_EQ(rhs BoolExpression) BoolExpression
	// Check if this expression is distinct to rhs
	IS_DISTINCT_FROM(rhs BoolExpression) BoolExpression
	// Check if this expression is not distinct to rhs
	IS_NOT_DISTINCT_FROM(rhs BoolExpression) BoolExpression

	// Check if this expression is true
	IS_TRUE() BoolExpression
	// Check if this expression is not true
	IS_NOT_TRUE() BoolExpression
	// Check if this expression is false
	IS_FALSE() BoolExpression
	// Check if this expression is not false
	IS_NOT_FALSE() BoolExpression
	// Check if this expression is unknown
	IS_UNKNOWN() BoolExpression
	// Check if this expression is not unknown
	IS_NOT_UNKNOWN() BoolExpression

	// expression AND operator rhs
	AND(rhs BoolExpression) BoolExpression
	// expression OR operator rhs
	OR(rhs BoolExpression) BoolExpression
}

type CaseOperator interface {
	Expression

	WHEN(condition Expression) CaseOperator
	THEN(then Expression) CaseOperator
	ELSE(els Expression) CaseOperator
}

type Cast interface {
	AS(castType string) Expression
}

type Clause interface {
	Serialize(statementType StatementType, out *SQLBuilder, options ...SerializeOption)
}

type ClauseDelete struct {
	Table SerializerTable
}

type ClauseFor struct {
	Lock RowLock
}

type ClauseFrom struct {
	Name   string
	Tables []Serializer
}

type ClauseGroupBy struct {
	List []GroupByClause
}

type ClauseHaving struct {
	Condition BoolExpression
}

type ClauseIn struct {
	LockMode string
}

type ClauseInsert struct {
	Table   SerializerTable
	Columns []Column
}

type ClauseLimit struct {
	Count int64
}

type ClauseOffset struct {
	Count int64
}

type ClauseOptional struct {
	Name      string
	Show      bool
	InNewLine bool
}

type ClauseOrderBy struct {
	List        []OrderByClause
	SkipNewLine bool
}

type ClauseQuery struct {
	Query          SerializerStatement
	SkipSelectWrap bool
}

type ClauseReturning struct {
	ProjectionList []Projection
}

type ClauseSelect struct {
	Distinct          bool
	DistinctOnColumns []ColumnExpression
	ProjectionList    []Projection
}

type ClauseSetStmtOperator struct {
	Operator       string
	All            bool
	Selects        []SerializerStatement
	OrderBy        ClauseOrderBy
	Limit          ClauseLimit
	Offset         ClauseOffset
	SkipSelectWrap bool
}

type ClauseStatementBegin struct {
	Name   string
	Tables []SerializerTable
}

type ClauseUpdate struct {
	Table SerializerTable
}

type ClauseValues struct {
	Rows [][]Serializer
}

type ClauseValuesQuery struct {
	ClauseValues
	ClauseQuery
}

type ClauseWhere struct {
	Condition BoolExpression
	Mandatory bool
}

type ClauseWindow struct {
	Definitions []WindowDefinition
}

type ClauseWithProjections interface {
	Clause

	Projections() ProjectionList
}

type Column interface {
	Name() string
	TableName() string
	// contains filtered or unexported methods
}

type ColumnAssigment interface {
	Serializer
	// contains filtered or unexported methods
}

type ColumnBool interface {
	BoolExpression
	Column

	From(subQuery SelectTable) ColumnBool
	SET(boolExp BoolExpression) ColumnAssigment
}

type ColumnDate interface {
	DateExpression
	Column

	From(subQuery SelectTable) ColumnDate
	SET(dateExp DateExpression) ColumnAssigment
}

type ColumnExpression interface {
	Column
	Expression
}

type ColumnExpressionImpl struct {
	ExpressionInterfaceImpl
	// contains filtered or unexported fields
}

type ColumnFloat interface {
	FloatExpression
	Column

	From(subQuery SelectTable) ColumnFloat
	SET(floatExp FloatExpression) ColumnAssigment
}

type ColumnInteger interface {
	IntegerExpression
	Column

	From(subQuery SelectTable) ColumnInteger
	SET(intExp IntegerExpression) ColumnAssigment
}

type ColumnList []ColumnExpression

type ColumnSerializer interface {
	Serializer
	Column
}

type ColumnString interface {
	StringExpression
	Column

	From(subQuery SelectTable) ColumnString
	SET(stringExp StringExpression) ColumnAssigment
}

type ColumnTime interface {
	TimeExpression
	Column

	From(subQuery SelectTable) ColumnTime
	SET(timeExp TimeExpression) ColumnAssigment
}

type ColumnTimestamp interface {
	TimestampExpression
	Column

	From(subQuery SelectTable) ColumnTimestamp
	SET(timestampExp TimestampExpression) ColumnAssigment
}

type ColumnTimestampz interface {
	TimestampzExpression
	Column

	From(subQuery SelectTable) ColumnTimestampz
	SET(timestampzExp TimestampzExpression) ColumnAssigment
}

type ColumnTimez interface {
	TimezExpression
	Column

	From(subQuery SelectTable) ColumnTimez
}

type CommonTableExpression struct {
	NotMaterialized bool
	Columns         []ColumnExpression
	// contains filtered or unexported fields
}

type DateExpression interface {
	Expression

	EQ(rhs DateExpression) BoolExpression
	NOT_EQ(rhs DateExpression) BoolExpression
	IS_DISTINCT_FROM(rhs DateExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs DateExpression) BoolExpression

	LT(rhs DateExpression) BoolExpression
	LT_EQ(rhs DateExpression) BoolExpression
	GT(rhs DateExpression) BoolExpression
	GT_EQ(rhs DateExpression) BoolExpression
	BETWEEN(min, max DateExpression) BoolExpression
	NOT_BETWEEN(min, max DateExpression) BoolExpression

	ADD(rhs Interval) TimestampExpression
	SUB(rhs Interval) TimestampExpression
}

type Dialect interface {
	Name() string
	PackageName() string
	OperatorSerializeOverride(operator string) SerializeOverride
	FunctionSerializeOverride(function string) SerializeOverride
	AliasQuoteChar() byte
	IdentifierQuoteChar() byte
	ArgumentPlaceholder() QueryPlaceholderFunc
	IsReservedWord(name string) bool
}

type DialectParams struct {
	Name                       string
	PackageName                string
	OperatorSerializeOverrides map[string]SerializeOverride
	FunctionSerializeOverrides map[string]SerializeOverride
	AliasQuoteChar             byte
	IdentifierQuoteChar        byte
	ArgumentPlaceholder        QueryPlaceholderFunc
	ReservedWords              []string
}

type Expression interface {
	Serializer
	Projection
	GroupByClause
	OrderByClause

	// IS_NULL tests expression whether it is a NULL value.
	IS_NULL() BoolExpression
	// IS_NOT_NULL tests expression whether it is a non-NULL value.
	IS_NOT_NULL() BoolExpression

	// IN checks if this expressions matches any in expressions list
	IN(expressions ...Expression) BoolExpression
	// NOT_IN checks if this expressions is different of all expressions in expressions list
	NOT_IN(expressions ...Expression) BoolExpression

	// AS the temporary alias name to assign to the expression
	AS(alias string) Projection

	// ASC expression will be used to sort query result in ascending order
	ASC() OrderByClause
	// DESC expression will be used to sort query result in descending order
	DESC() OrderByClause
}

type ExpressionInterfaceImpl struct {
	Parent Expression
}

type ExpressionStatement interface {
	Expression
	Statement
	HasProjections
}

type FloatExpression interface {
	Expression

	EQ(rhs FloatExpression) BoolExpression
	NOT_EQ(rhs FloatExpression) BoolExpression
	IS_DISTINCT_FROM(rhs FloatExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs FloatExpression) BoolExpression

	LT(rhs FloatExpression) BoolExpression
	LT_EQ(rhs FloatExpression) BoolExpression
	GT(rhs FloatExpression) BoolExpression
	GT_EQ(rhs FloatExpression) BoolExpression
	BETWEEN(min, max FloatExpression) BoolExpression
	NOT_BETWEEN(min, max FloatExpression) BoolExpression

	ADD(rhs NumericExpression) FloatExpression
	SUB(rhs NumericExpression) FloatExpression
	MUL(rhs NumericExpression) FloatExpression
	DIV(rhs NumericExpression) FloatExpression
	MOD(rhs NumericExpression) FloatExpression
	POW(rhs NumericExpression) FloatExpression
	// contains filtered or unexported methods
}

type FrameExtent interface {
	Serializer
	// contains filtered or unexported methods
}

type GroupByClause interface {
	// contains filtered or unexported methods
}

type HasProjections interface {
	// contains filtered or unexported methods
}

type IntegerExpression interface {
	Expression

	EQ(rhs IntegerExpression) BoolExpression
	NOT_EQ(rhs IntegerExpression) BoolExpression
	IS_DISTINCT_FROM(rhs IntegerExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs IntegerExpression) BoolExpression

	LT(rhs IntegerExpression) BoolExpression
	LT_EQ(rhs IntegerExpression) BoolExpression
	GT(rhs IntegerExpression) BoolExpression
	GT_EQ(rhs IntegerExpression) BoolExpression
	BETWEEN(min, max IntegerExpression) BoolExpression
	NOT_BETWEEN(min, max IntegerExpression) BoolExpression

	ADD(rhs IntegerExpression) IntegerExpression
	SUB(rhs IntegerExpression) IntegerExpression
	MUL(rhs IntegerExpression) IntegerExpression
	DIV(rhs IntegerExpression) IntegerExpression
	MOD(rhs IntegerExpression) IntegerExpression
	POW(rhs IntegerExpression) IntegerExpression

	BIT_AND(rhs IntegerExpression) IntegerExpression
	BIT_OR(rhs IntegerExpression) IntegerExpression
	BIT_XOR(rhs IntegerExpression) IntegerExpression
	BIT_SHIFT_LEFT(shift IntegerExpression) IntegerExpression
	BIT_SHIFT_RIGHT(shift IntegerExpression) IntegerExpression
	// contains filtered or unexported methods
}

type Interval interface {
	Serializer
	IsInterval
}

type IntervalImpl struct {
	Value Serializer
	IsIntervalImpl
}

type IsInterval interface {
	// contains filtered or unexported methods
}

type IsIntervalImpl struct{}

type JoinTable SerializerTable

type JoinType int

type Keyword string

type KeywordClause struct {
	Keyword
}

type ListSerializer struct {
	Serializers []Serializer
	Separator   string
}

type LiteralExpression interface {
	Expression

	Value() interface{}
	SetConstant(constant bool)
}

type LoggerFunc func(ctx context.Context, statement PrintableStatement)

type NumericExpression interface {
	Expression
	// contains filtered or unexported methods
}

type OrderByClause interface {
	// contains filtered or unexported methods
}

type OrderSetAggregateFunc struct {
	// contains filtered or unexported fields
}

type PrintableStatement interface {
	Sql() (query string, args []interface{})
	DebugSql() (query string)
}

type Projection interface {
	// contains filtered or unexported methods
}

type ProjectionList []Projection

type QueryInfo struct {
	Statement PrintableStatement
	// Depending on how the statement is executed, RowsProcessed is:
	// 	- Number of rows returned for Query() and QueryContext() methods
	// 	- RowsAffected() for Exec() and ExecContext() methods
	// 	- Always 0 for Rows() method.
	RowsProcessed int64
	Duration      time.Duration
	Err           error
}

type QueryLoggerFunc func(ctx context.Context, info QueryInfo)

type QueryPlaceholderFunc func(ord int) string

type RowLock interface {
	Serializer

	NOWAIT() RowLock
	SKIP_LOCKED() RowLock
}

type Rows struct {
	*sql.Rows
	// contains filtered or unexported fields
}

type SQLBuilder struct {
	Dialect Dialect
	Buff    bytes.Buffer
	Args    []interface{}

	Debug bool
	// contains filtered or unexported fields
}

type SelectTable interface {
	SerializerHasProjections
	Alias() string
	AllColumns() ProjectionList
}

type SerializeOption int

type SerializeOverride func(expressions ...Serializer) SerializerFunc

type Serializer interface {
	// contains filtered or unexported methods
}

type SerializerFunc func(statement StatementType, out *SQLBuilder, options ...SerializeOption)

type SerializerHasProjections interface {
	Serializer
	HasProjections
}

type SerializerStatement interface {
	Serializer
	Statement
	HasProjections
}

type SerializerTable interface {
	Serializer
	Table
}

type SetClause struct {
	Columns []Column
	Values  []Serializer
}

type SetClauseNew []ColumnAssigment

type SetPair struct {
	Column ColumnSerializer
	Value  Serializer
}

type Statement interface {
	// Sql returns parametrized sql query with list of arguments.
	Sql() (query string, args []interface{})
	// DebugSql returns debug query where every parametrized placeholder is replaced with its argument.
	// Do not use it in production. Use it only for debug purposes.
	DebugSql() (query string)
	// Query executes statement over database connection/transaction db and stores row result in destination.
	// Destination can be either pointer to struct or pointer to a slice.
	// If destination is pointer to struct and query result set is empty, method returns qrm.ErrNoRows.
	Query(db qrm.DB, destination interface{}) error
	// QueryContext executes statement with a context over database connection/transaction db and stores row result in destination.
	// Destination can be either pointer to struct or pointer to a slice.
	// If destination is pointer to struct and query result set is empty, method returns qrm.ErrNoRows.
	QueryContext(ctx context.Context, db qrm.DB, destination interface{}) error
	// Exec executes statement over db connection/transaction without returning any rows.
	Exec(db qrm.DB) (sql.Result, error)
	// ExecContext executes statement with context over db connection/transaction without returning any rows.
	ExecContext(ctx context.Context, db qrm.DB) (sql.Result, error)
	// Rows executes statements over db connection/transaction and returns rows
	Rows(ctx context.Context, db qrm.DB) (*Rows, error)
}

type StatementType string

type StringExpression interface {
	Expression

	EQ(rhs StringExpression) BoolExpression
	NOT_EQ(rhs StringExpression) BoolExpression
	IS_DISTINCT_FROM(rhs StringExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs StringExpression) BoolExpression

	LT(rhs StringExpression) BoolExpression
	LT_EQ(rhs StringExpression) BoolExpression
	GT(rhs StringExpression) BoolExpression
	GT_EQ(rhs StringExpression) BoolExpression
	BETWEEN(min, max StringExpression) BoolExpression
	NOT_BETWEEN(min, max StringExpression) BoolExpression

	CONCAT(rhs Expression) StringExpression

	LIKE(pattern StringExpression) BoolExpression
	NOT_LIKE(pattern StringExpression) BoolExpression

	REGEXP_LIKE(pattern StringExpression, caseSensitive ...bool) BoolExpression
	NOT_REGEXP_LIKE(pattern StringExpression, caseSensitive ...bool) BoolExpression
}

type Table interface {
	SchemaName() string
	TableName() string
	Alias() string
	// contains filtered or unexported methods
}

type TimeExpression interface {
	Expression

	EQ(rhs TimeExpression) BoolExpression
	NOT_EQ(rhs TimeExpression) BoolExpression
	IS_DISTINCT_FROM(rhs TimeExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs TimeExpression) BoolExpression

	LT(rhs TimeExpression) BoolExpression
	LT_EQ(rhs TimeExpression) BoolExpression
	GT(rhs TimeExpression) BoolExpression
	GT_EQ(rhs TimeExpression) BoolExpression
	BETWEEN(min, max TimeExpression) BoolExpression
	NOT_BETWEEN(min, max TimeExpression) BoolExpression

	ADD(rhs Interval) TimeExpression
	SUB(rhs Interval) TimeExpression
}

type TimestampExpression interface {
	Expression

	EQ(rhs TimestampExpression) BoolExpression
	NOT_EQ(rhs TimestampExpression) BoolExpression
	IS_DISTINCT_FROM(rhs TimestampExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs TimestampExpression) BoolExpression

	LT(rhs TimestampExpression) BoolExpression
	LT_EQ(rhs TimestampExpression) BoolExpression
	GT(rhs TimestampExpression) BoolExpression
	GT_EQ(rhs TimestampExpression) BoolExpression
	BETWEEN(min, max TimestampExpression) BoolExpression
	NOT_BETWEEN(min, max TimestampExpression) BoolExpression

	ADD(rhs Interval) TimestampExpression
	SUB(rhs Interval) TimestampExpression
}

type TimestampzExpression interface {
	Expression

	EQ(rhs TimestampzExpression) BoolExpression
	NOT_EQ(rhs TimestampzExpression) BoolExpression
	IS_DISTINCT_FROM(rhs TimestampzExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs TimestampzExpression) BoolExpression

	LT(rhs TimestampzExpression) BoolExpression
	LT_EQ(rhs TimestampzExpression) BoolExpression
	GT(rhs TimestampzExpression) BoolExpression
	GT_EQ(rhs TimestampzExpression) BoolExpression
	BETWEEN(min, max TimestampzExpression) BoolExpression
	NOT_BETWEEN(min, max TimestampzExpression) BoolExpression

	ADD(rhs Interval) TimestampzExpression
	SUB(rhs Interval) TimestampzExpression
}

type TimezExpression interface {
	Expression

	EQ(rhs TimezExpression) BoolExpression
	NOT_EQ(rhs TimezExpression) BoolExpression
	IS_DISTINCT_FROM(rhs TimezExpression) BoolExpression
	IS_NOT_DISTINCT_FROM(rhs TimezExpression) BoolExpression

	LT(rhs TimezExpression) BoolExpression
	LT_EQ(rhs TimezExpression) BoolExpression
	GT(rhs TimezExpression) BoolExpression
	GT_EQ(rhs TimezExpression) BoolExpression
	BETWEEN(min, max TimezExpression) BoolExpression
	NOT_BETWEEN(min, max TimezExpression) BoolExpression

	ADD(rhs Interval) TimezExpression
	SUB(rhs Interval) TimezExpression
}

type Window interface {
	Serializer
	ORDER_BY(expr ...OrderByClause) Window
	ROWS(start FrameExtent, end ...FrameExtent) Window
	RANGE(start FrameExtent, end ...FrameExtent) Window
	GROUPS(start FrameExtent, end ...FrameExtent) Window
}

type WindowDefinition struct {
	Name   string
	Window Window
}