stmt

type And ¶

type And struct {
	Left  Expr
	Right Expr
}

And represents an And boolean expression.

func (a *And) Write(b Builder) error

type BuildError ¶

type BuildError struct {
	Op  string
	Err error
}

BuildError is the error type usually returned by functions in the stmt package. It describes the current operation, occurred of an error.

func (b *BuildError) Error() string

func (b *BuildError) Unwrap() error

type Builder ¶

type Builder interface {
	WritePlaceholder()
	WriteString(string)
	AppendArgs(args ...interface{})
}

Builder an interface used to build SQL queries.

WriteString method uses the passed string is writing to the query builder. AppendArgs method uses for pass arguments corresponding to variables.

type Columns ¶ added in v0.0.2

type Columns []string

Columns represents columns field.

func (c Columns) Write(b Builder) error

type CompBetween ¶

type CompBetween struct {
	Negative bool
	Left     interface{}
	Right    interface{}
}

CompBetween represents condition for using "BETWEEN".

If enabled Negative field, it's meaning use "NOT BETWEEN". This struct will convert to be like "BETWEEN left_expr AND right_expr".

func (c *CompBetween) WriteComparison(b Builder) error

type CompIn ¶

type CompIn struct {
	Negative bool
	Values   []interface{}
}

CompIn represents condition for using "IN".

If enabled Negative field, it's meaning use "NOT IN". Values field should set list to use for comparison. This struct will convert to be like "IN (?, ?, ?)".

func (c *CompIn) WriteComparison(b Builder) error

type CompLike ¶

type CompLike struct {
	Negative bool
	Value    interface{}
}

CompLike represents condition for using "LIKE".

If enabled Negative field, it's meaning use "NOT LIKE". Value field should set the value to use for comparison.

func (c *CompLike) WriteComparison(b Builder) error

type CompOp ¶

type CompOp struct {
	Op    string
	Value interface{}
}

CompOp represents condition for using operators.

Op field should contain "=", ">=", ">", "<=", "<", "!=", "IS", "IS NOT" Value field should set the value to use for comparison.

func (c *CompOp) WriteComparison(b Builder) error

type Comparisoner ¶

type Comparisoner interface {
	WriteComparison(b Builder) error
}

Comparisoner implemented WriteComparison method.

This interface represents a conditional expression.

type Condition ¶

type Condition struct {
	Column  string
	Compare Comparisoner
}

Condition represents condition for using Comparisoner interface.

this struct creates "<column_name> <comparable_condition>" <comparable_condition> indicates Comparisoner interface.

func (c *Condition) Write(b Builder) error

type Expr ¶

type Expr interface {
	Write(Builder) error
}

Expr implemented Write method.

This interface represents an expression.

type Limit ¶ added in v0.0.2

type Limit int64

Limit represents "LIMIT <limit_num>".

func (l Limit) Write(b Builder) error

type Numeric ¶ added in v0.0.2

type Numeric int64

Numeric is able to replace bindvars with numeric.

i.e. "LIMIT ?" => "LIMIT numeric"

func (n Numeric) Write(b Builder) error

type Offset ¶ added in v0.0.2

type Offset int64

Offset represents "OFFSET <offset_num>".

func (o Offset) Write(b Builder) error

type Or ¶

type Or struct {
	Left  Expr
	Right Expr
}

Or represents an OR boolean expression.

func (o *Or) Write(b Builder) error

type OrderBy ¶ added in v0.0.2

type OrderBy struct {
	Column string
	Desc   bool
	Next   *OrderBy
}

OrderBy represents "<column_name>", "<column_name> DESC". If there is Next, it represents like "<column_name>, <column_name> DESC".

func (o *OrderBy) Write(b Builder) error

type Paren ¶

type Paren struct {
	Expr Expr
}

Paren represents a parenthesized expression.

func (p *Paren) Write(b Builder) error

type String ¶ added in v0.0.2

type String string

String is able to replace bindvars with string.

i.e. "SELECT * FROM ?" => "SELECT * FROM string"

func (s String) Write(b Builder) error