2020-08-06 20:58:47 +03:00
|
|
|
// Package ast holds types and functionality for the SLQ AST.
|
|
|
|
//
|
|
|
|
// Note: the SLQ language implementation is fairly rudimentary
|
|
|
|
// and has some incomplete functionality.
|
2016-10-17 07:14:01 +03:00
|
|
|
package ast
|
|
|
|
|
|
|
|
import (
|
2022-12-24 07:43:20 +03:00
|
|
|
"github.com/antlr/antlr4/runtime/Go/antlr/v4"
|
2016-10-17 07:14:01 +03:00
|
|
|
|
2020-08-06 20:58:47 +03:00
|
|
|
"github.com/neilotoole/lg"
|
2020-08-23 14:16:16 +03:00
|
|
|
|
|
|
|
"github.com/neilotoole/sq/libsq/ast/internal/slq"
|
2020-08-23 13:42:15 +03:00
|
|
|
"github.com/neilotoole/sq/libsq/core/errz"
|
2016-10-17 07:14:01 +03:00
|
|
|
)
|
|
|
|
|
2020-08-06 20:58:47 +03:00
|
|
|
// Parse parses the SLQ input string and builds the AST.
|
|
|
|
func Parse(log lg.Log, input string) (*AST, error) {
|
|
|
|
ptree, err := parseSLQ(log, input)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
atree, err := buildAST(log, ptree)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return atree, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// buildAST constructs sq's AST from a parse tree.
|
|
|
|
func buildAST(log lg.Log, query slq.IQueryContext) (*AST, error) {
|
|
|
|
if query == nil {
|
|
|
|
return nil, errorf("query is nil")
|
|
|
|
}
|
|
|
|
|
|
|
|
q, ok := query.(*slq.QueryContext)
|
|
|
|
if !ok {
|
|
|
|
return nil, errorf("unable to convert %T to *parser.QueryContext", query)
|
|
|
|
}
|
|
|
|
|
|
|
|
v := &parseTreeVisitor{log: lg.Discard()}
|
|
|
|
er := q.Accept(v)
|
|
|
|
if er != nil {
|
|
|
|
return nil, er.(error)
|
|
|
|
}
|
|
|
|
|
|
|
|
err := NewWalker(log, v.AST).AddVisitor(typeSelector, narrowTblSel).Walk()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = NewWalker(log, v.AST).AddVisitor(typeSelector, narrowColSel).Walk()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = NewWalker(log, v.AST).AddVisitor(typeJoin, determineJoinTables).Walk()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = NewWalker(log, v.AST).AddVisitor(typeRowRange, visitCheckRowRange).Walk()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = NewWalker(log, v.AST).AddVisitor(typeExpr, findWhereClause).Walk()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return v.AST, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ Node = (*AST)(nil)
|
|
|
|
|
|
|
|
// AST is the Abstract Syntax Tree. It is the root node of a SQL query/stmt.
|
2016-10-17 07:14:01 +03:00
|
|
|
type AST struct {
|
2020-08-06 20:58:47 +03:00
|
|
|
ctx *slq.QueryContext
|
|
|
|
segs []*Segment
|
2016-10-17 07:14:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) Parent() Node {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) SetParent(parent Node) error {
|
|
|
|
return errorf("root node (%T) cannot have parent: tried to add parent %T", a, parent)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) Children() []Node {
|
|
|
|
nodes := make([]Node, len(a.segs))
|
|
|
|
|
|
|
|
for i, seg := range a.segs {
|
|
|
|
nodes[i] = seg
|
|
|
|
}
|
|
|
|
|
|
|
|
return nodes
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) Segments() []*Segment {
|
|
|
|
return a.segs
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) AddChild(node Node) error {
|
|
|
|
seg, ok := node.(*Segment)
|
|
|
|
if !ok {
|
|
|
|
return errorf("expected *Segment but got: %T", node)
|
|
|
|
}
|
|
|
|
|
|
|
|
a.AddSegment(seg)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) SetChildren(children []Node) error {
|
|
|
|
segs := make([]*Segment, len(children))
|
|
|
|
|
|
|
|
for i, child := range children {
|
|
|
|
seg, ok := child.(*Segment)
|
|
|
|
if !ok {
|
2020-08-06 20:58:47 +03:00
|
|
|
return errorf("expected child of type %s, but got: %T", typeSegment, child)
|
2016-10-17 07:14:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
segs[i] = seg
|
|
|
|
}
|
|
|
|
|
|
|
|
a.segs = segs
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) Context() antlr.ParseTree {
|
|
|
|
return a.ctx
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) SetContext(ctx antlr.ParseTree) error {
|
|
|
|
qCtx, ok := ctx.(*slq.QueryContext)
|
|
|
|
if !ok {
|
|
|
|
return errorf("expected *parser.QueryContext, but got %T", ctx)
|
|
|
|
}
|
|
|
|
|
|
|
|
a.ctx = qCtx
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) String() string {
|
|
|
|
return nodeString(a)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (a *AST) Text() string {
|
|
|
|
return a.ctx.GetText()
|
|
|
|
}
|
|
|
|
|
2016-10-31 01:35:56 +03:00
|
|
|
// AddSegment appends seg to the AST.
|
2016-10-17 07:14:01 +03:00
|
|
|
func (a *AST) AddSegment(seg *Segment) {
|
2020-08-06 20:58:47 +03:00
|
|
|
_ = seg.SetParent(a)
|
2016-10-17 07:14:01 +03:00
|
|
|
a.segs = append(a.segs, seg)
|
|
|
|
}
|
|
|
|
|
2020-08-06 20:58:47 +03:00
|
|
|
// errorf builds an error. Error creation for this package
|
|
|
|
// was centralized here in the expectation that an AST-specific
|
|
|
|
// error type (annotated appropriately) would be returned.
|
2022-12-17 02:34:33 +03:00
|
|
|
func errorf(format string, v ...any) error {
|
2020-08-06 20:58:47 +03:00
|
|
|
return errz.Errorf(format, v...)
|
2016-10-17 07:14:01 +03:00
|
|
|
}
|