internal

type Addable ¶

type Addable interface {
	String() string
	Args() []any
}

type Context ¶

type Context struct {
	FileSet *token.FileSet
	AstFile *ast.File

	PackageName string

	Data map[string]map[token.Position]QueryData // EntityName(type Arg) -> caller -> query

	TypeInfo *types.Info
}

func (c *Context) ParseFile(filePath string) error

func (c *Context) Visit(node ast.Node) (w ast.Visitor)

type Expression ¶

type Expression struct{ ast.Expr }

func (e Expression) Args() []any

func (e Expression) String() string

type GoQueryPackage ¶

type GoQueryPackage struct{}

type Neg ¶ added in v0.1.1

type Neg struct {
	Addable
}

func (n Neg) String() string

type Not ¶

type Not struct {
	Addable
}

func (n Not) String() string

type Parens ¶

type Parens struct {
	Addable
}

func (p Parens) String() string

type QueryData ¶

type QueryData struct {
	Query string
	Args  []string
}

type Simple ¶

type Simple struct {
	StringVal string
	Arg       []any
}

func NewColumn(name string) *Simple

func NewSimple(val string, args ...any) *Simple

func (s Simple) Args() []any

func (s Simple) String() string

type StringsPackage ¶

type StringsPackage struct{}

type TimePackage ¶

type TimePackage struct{}

type TimeType ¶

type TimeType struct{}

type Wrapper ¶

type Wrapper struct {
	Addable
	StringF func(a Addable) string
	ArgsF   func(a Addable) []any
}

Wrapper takes an addable and wraps it.

For example if string representation of Addable should be concatenated with something else like: `Addable.String()` to `'%' || Addable.String() || '%'".

Wrapper defined above would look like this:

Wrapper{
	Addable: addable,
	StringF: func(a Addable) string {
		return `'%' || ` + a.String() + ` || '%'`
	}
}

func (w Wrapper) Args() []any

func (w Wrapper) String() string