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 {
	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 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 Or ¶

type Or struct {
	Left  Expr
	Right Expr
}

Or represents an OR boolean expression.

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

type Paren ¶

type Paren struct {
	Expr Expr
}

Paren represents a parenthesized expression.

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