drivers

type Column interface {
	Name() string
	Attribute() *dal.Attribute
	IsPrimaryKey() bool
	Encode(dal.ValueGetter) (any, error)
	Decode(any, dal.ValueSetter) error
	Type() Type
}

type Dialect interface {
	// Nuances returns dialect nuances
	// subtle differences between RDBMS implementations that
	// should be handled on common code
	Nuances() Nuances

	// GOQU returns goqu's dialect wrapper struct
	GOQU() goqu.DialectWrapper

	DialectOptions() *sqlgen.SQLDialectOptions

	JsonQuote(exp.Expression) exp.Expression

	// JsonExtract returns expression that returns a value from  inside JSON document
	//
	// Use this when you want use JSON encoded value
	JsonExtract(exp.Expression, ...any) (exp.Expression, error)

	// JsonExtractUnquote returns expression that returns a value from  inside JSON document:
	//
	// Use this when you want to use unencoded value!
	JsonExtractUnquote(exp.Expression, ...any) (exp.Expression, error)

	// JsonArrayContains generates expression JSON array containment check expression
	//
	// Literal values need to be JSON docs!
	//
	// @todo recheck if we really need JsonArrayContains on Dialect interface
	JsonArrayContains(needle, haystack exp.Expression) (exp.Expression, error)

	// AttributeCast prepares complex SQL expression that verifies
	// arbitrary string value in the db and casts it to b used in
	// comparison or soring expression
	AttributeCast(*dal.Attribute, exp.Expression) (exp.Expression, error)

	// TableCodec returns table codec (encodes & decodes data to/from db table)
	TableCodec(*dal.Model) TableCodec

	// TypeWrap returns driver's type implementation for a particular attribute type
	TypeWrap(dal.Type) Type

	QuoteIdent(string) string

	// AttributeToColumn converts attribute to column defunition
	AttributeToColumn(*dal.Attribute) (*ddl.Column, error)
	ColumnFits(base, assert *ddl.Column) bool

	// ExprHandler returns driver specific expression handling
	ExprHandler(*ql.ASTNode, ...exp.Expression) (exp.Expression, error)

	// ValHandler returns driver specific value expression handling
	ValHandler(*ql.ASTNode) (exp.Expression, error)

	// OrderedExpression returns compatible expression for ordering
	//
	// Database understand order modifiers differently. For example, MySQL does not know
	// about NULLS FIRST/LAST. Drivers should gracefully handle this.
	OrderedExpression(exp.Expression, exp.SortDirection, exp.NullSortType) exp.OrderedExpression
}

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

type ID struct {
	ID    uint64
	Valid bool // Valid is true if Uint64 is not NULL
}

type Nuances struct {
	// HavingClauseMustUseAlias
	// For example, Postgres and SQLite require
	// use of aliases inside HAVING clause and
	// MySQL does not.
	HavingClauseMustUseAlias bool

	// TwoStepUpsert allows support for databases which don't have an upsert
	// or we simply couldn't figure out how to make work.
	//
	// TwoStepUpsert uses the context from the update statement to figure out
	// if it needs to do an insert.
	TwoStepUpsert bool
}

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

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

type TableCodec interface {
	Columns() []Column
	Ident() exp.IdentifierExpression
	MakeScanBuffer() []any
	Encode(r dal.ValueGetter) (_ []any, err error)
	Decode(buf []any, r dal.ValueSetter) (err error)
	AttributeExpression(string) (exp.Expression, error)
}

type Type interface {
	MakeScanBuffer() any
	Decode(any) (any, bool, error)
	Encode(any) (driver.Value, error)
}

type TypeBlob struct{ *dal.TypeBlob }

type TypeBoolean struct{ *dal.TypeBoolean }

type TypeDate struct{ *dal.TypeDate }

type TypeEnum struct{ *dal.TypeEnum }

type TypeGeometry struct{ *dal.TypeGeometry }

type TypeID struct{ *dal.TypeID }

type TypeJSON struct{ *dal.TypeJSON }

type TypeNumber struct{ *dal.TypeNumber }

type TypeRef struct{ *dal.TypeRef }

type TypeText struct{ *dal.TypeText }

type TypeTime struct{ *dal.TypeTime }

type TypeTimestamp struct{ *dal.TypeTimestamp }

type TypeUUID struct{ *dal.TypeUUID }