q

type Add struct {
	Left  interface{}
	Right interface{}
}

type And struct {
	Left  interface{}
	Right interface{}
}

type As struct {
	Expr  interface{}
	Alias Id
}

type Between struct {
	Operand interface{}
	Low     interface{}
	High    interface{}
}

type BetweenSymmetric struct {
	Operand interface{}
	Low     interface{}
	High    interface{}
}

type Divide struct {
	Left  interface{}
	Right interface{}
}

type Equals struct {
	Left  interface{}
	Right interface{}
}

type From struct {
	Expr FromExpr
}

type FromExpr = interface{}

type Fromer interface {
	From() FromExpr
}

type GreaterThan struct {
	Left  interface{}
	Right interface{}
}

type GreaterThanOrEqual struct {
	Left  interface{}
	Right interface{}
}

type Group struct {
	Contents interface{}
}

type Id = util.Verbatim

type Is struct {
	Left  interface{}
	Right interface{}
}

type IsDistinctFrom struct {
	Left  interface{}
	Right interface{}
}

type IsNot struct {
	Left  interface{}
	Right interface{}
}

type IsNotDistinctFrom struct {
	Left  interface{}
	Right interface{}
}

type IsNotNull struct {
	Left interface{}
}

type IsNull struct {
	Left interface{}
}

type LessThan struct {
	Left  interface{}
	Right interface{}
}

type LessThanOrEqual struct {
	Left  interface{}
	Right interface{}
}

type Marshaler interface {
	MarshalSql(wr io.Writer, args *params.Args) error
}

type Multiply struct {
	Left  interface{}
	Right interface{}
}

type Not struct {
	Right interface{}
}

type NotEquals struct {
	Left  interface{}
	Right interface{}
}

type Or struct {
	Left  interface{}
	Right interface{}
}

type QueryContexter interface {
	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
}

type QueryRowContexter interface {
	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

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

type Rows struct {
	*sql.Rows
}

type Scannable interface {
	Scan(Scanner) error
}

type Scanner interface {
	Scan(...interface{}) error
}

type Select []SelectExpr

type SelectExpr = interface{}

type Selector interface {
	Select() []SelectExpr
}

type Stmts []interface{}

type Subtract struct {
	Left  interface{}
	Right interface{}
}

type Where struct {
	Expr interface{}
}