moved from viant/sqlx/metadata/ast

Author: awitas

binary.go

@@ -0,0 +1,70 @@
+package sqlparser
+
+import (
+	"github.com/viant/parsly"
+	"github.com/viant/parsly/matcher"
+	"github.com/viant/sqlx/metadata/ast/expr"
+)
+
+func parseBinaryExpr(cursor *parsly.Cursor, binary *expr.Binary) error {
+	var err error
+	if binary.X == nil {
+		binary.X, err = expectOperand(cursor)
+		if err != nil || binary.X == nil {
+			return err
+		}
+	}
+	//fmt.Printf("After op %v,: %s\n", binary.Op, cursor.Input[cursor.Pos:])
+	pos := cursor.Pos
+	if binary.Op == "" {
+		match := cursor.MatchAfterOptional(whitespaceMatcher, betweenKeywordMatcher, binaryOperatorMatcher, logicalOperatorMatcher)
+		switch match.Code {
+		case logicalOperator:
+			if !matcher.IsWhiteSpace(cursor.Input[cursor.Pos]) {
+				cursor.Pos = pos
+				return nil
+			}
+			binary.Op = match.Text(cursor)
+		case binaryOperator:
+			binary.Op = match.Text(cursor)
+		case betweenToken:
+			binary.Op = match.Text(cursor)
+			rng := &expr.Range{}
+			if rng.Min, err = expectOperand(cursor); err != nil {
+				return err
+			}
+			match := cursor.MatchAfterOptional(whitespaceMatcher, rangeOperatorMatcher)
+			if match.Code != rangeOperator {
+				return cursor.NewError(rangeOperatorMatcher)
+			}
+			if rng.Max, err = expectOperand(cursor); err != nil {
+				return err
+			}
+			yExpr := &expr.Binary{X: rng}
+			if err := parseBinaryExpr(cursor, yExpr); err != nil {
+				return err
+			}
+			if yExpr.Y == nil {
+				binary.Y = rng
+			} else {
+				binary.Y = yExpr
+			}
+			return nil
+		default:
+			return nil
+		}
+	}
+	if binary.Y == nil {
+		yExpr := &expr.Binary{}
+		if err := parseBinaryExpr(cursor, yExpr); err != nil {
+			return err
+		}
+		if yExpr.X != nil {
+			binary.Y = yExpr
+		}
+		if yExpr.Op == "" {
+			binary.Y = yExpr.X
+		}
+	}
+	return nil
+}

delete.go

@@ -0,0 +1,136 @@
+package sqlparser
+
+import (
+	"github.com/viant/parsly"
+	del "github.com/viant/sqlx/metadata/ast/delete"
+	"github.com/viant/sqlx/metadata/ast/expr"
+	"github.com/viant/sqlx/metadata/ast/query"
+)
+
+func ParseDelete(SQL string) (*del.Statement, error) {
+	aStmt := &del.Statement{}
+	cursor := parsly.NewCursor("", []byte(SQL), 0)
+	return aStmt, parseDelete(aStmt, cursor)
+}
+
+func parseDelete(stmt *del.Statement, cursor *parsly.Cursor) error {
+	matched := cursor.MatchAfterOptional(whitespaceMatcher, deleteMatcher)
+	if matched.Code != deleteCode {
+		return cursor.NewError(deleteMatcher)
+	}
+
+	var err error
+	stmt.Items, err = tryParseDeleteItems(cursor)
+	if err != nil {
+		return err
+	}
+
+	lastMatchedCode, err := buildDeleteTarget(stmt, cursor)
+	if err != nil {
+		return err
+	}
+
+	stmt.Qualify, err = tryParseQualify(cursor, lastMatchedCode)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func buildDeleteTarget(stmt *del.Statement, cursor *parsly.Cursor) (int, error) {
+	matchable := []*parsly.Token{whereKeywordMatcher, joinToken, selectorMatcher}
+
+	var targetData []string
+	lastMatched := parsly.Invalid
+	var matched *parsly.TokenMatch
+
+	for {
+		prevPos := cursor.Pos
+
+		switch lastMatched {
+		case whereKeyword:
+			stmt.Target = buildTarget(targetData, cursor)
+			return lastMatched, nil
+
+		case selectorTokenCode:
+			targetData = append(targetData, matched.Text(cursor))
+			if len(targetData) >= 2 {
+				matchable = matchable[:len(matchable)-1]
+			}
+
+		case joinTokenCode:
+			join := query.NewJoin(matched.Text(cursor))
+			if _, err := parseJoin(cursor, join); err != nil {
+				return lastMatched, err
+			}
+
+			stmt.Joins = append(stmt.Joins, join)
+			matchable = matchable[:len(matchable)-1]
+		case parsly.EOF:
+			stmt.Target = buildTarget(targetData, cursor)
+			return lastMatched, nil
+		default:
+			if matched != nil {
+				return lastMatched, cursor.NewError(matchable...)
+			}
+		}
+
+		if prevPos == cursor.Pos {
+			matched = cursor.MatchAfterOptional(whitespaceMatcher, matchable...)
+		}
+
+		lastMatched = matched.Code
+	}
+}
+
+func buildTarget(targetData []string, cursor *parsly.Cursor) del.Target {
+	alias := ""
+	if len(targetData) >= 2 {
+		alias = targetData[1]
+	}
+
+	target := del.Target{
+		X:        expr.NewSelector(targetData[0]),
+		Comments: matchComment(cursor),
+		Alias:    alias,
+	}
+	return target
+}
+
+func tryParseDeleteItems(cursor *parsly.Cursor) ([]*del.Item, error) {
+	var items []*del.Item
+	matchable := []*parsly.Token{fromKeywordMatcher, selectorMatcher}
+	for cursor.Pos < cursor.InputSize {
+		matched := cursor.MatchAfterOptional(whitespaceMatcher, matchable...)
+		switch matched.Code {
+		case fromKeyword:
+			return items, nil
+		case selectorTokenCode:
+			selName := matched.Text(cursor)
+			comment := matchComment(cursor)
+			items = append(items, &del.Item{
+				Comments: comment,
+				Raw:      selName,
+			})
+
+			matched = cursor.MatchAfterOptional(whitespaceMatcher, nextMatcher)
+			if matched.Code != nextCode {
+				matchable = matchable[:1]
+			}
+
+		default:
+			return nil, cursor.NewError(matchable...)
+		}
+	}
+	return items, nil
+}
+
+func tryParseQualify(cursor *parsly.Cursor, lastMatchedCode int) (*expr.Qualify, error) {
+	if lastMatchedCode != whereKeyword {
+		return nil, nil
+	}
+
+	qualify := expr.NewQualify()
+	return qualify, ParseQualify(cursor, qualify)
+}

delete/item.go

@@ -0,0 +1,6 @@
+package del
+
+type Item struct {
+	Comments string
+	Raw      string
+}

delete/statement.go

@@ -0,0 +1,13 @@
+package del
+
+import (
+	"github.com/viant/sqlx/metadata/ast/expr"
+	"github.com/viant/sqlx/metadata/ast/query"
+)
+
+type Statement struct {
+	Target  Target
+	Items   []*Item
+	Joins   []*query.Join
+	Qualify *expr.Qualify
+}

delete/target.go

@@ -0,0 +1,9 @@
+package del
+
+import "github.com/viant/sqlx/metadata/ast/node"
+
+type Target struct {
+	X        node.Node
+	Comments string
+	Alias    string
+}

delete_test.go

@@ -0,0 +1,45 @@
+package sqlparser
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestParseDelete(t *testing.T) {
+	testcases := []struct {
+		SQL         string
+		expect      string
+		description string
+	}{
+		{
+			description: "basic",
+			SQL:         "DELETE FROM PRODUCTS",
+			expect:      "DELETE FROM PRODUCTS",
+		},
+		{
+			description: "with qualify",
+			SQL:         "DELETE FROM PRODUCTS WHERE ID = 10",
+			expect:      "DELETE FROM PRODUCTS WHERE ID = 10",
+		},
+		{
+			description: "with aliases",
+			SQL:         "DELETE p FROM PRODUCTS p WHERE p.ID = 10",
+			expect:      "DELETE p FROM PRODUCTS p WHERE p.ID = 10",
+		},
+		{
+			description: "with joins",
+			SQL:         "DELETE p, o FROM PRODUCTS p JOIN OTHER o ON p.ID = o.PRODUCT_ID WHERE p.ID = 10",
+			expect:      "DELETE p,  o FROM PRODUCTS p JOIN OTHER o ON p.ID = o.PRODUCT_ID WHERE p.ID = 10",
+		},
+	}
+
+	//for _, testcase := range testcases[len(testcases)-1:] {
+	for _, testcase := range testcases {
+		statement, err := ParseDelete(testcase.SQL)
+		if !assert.Nil(t, err, testcase.description) {
+			continue
+		}
+
+		assert.Equal(t, testcase.expect, Stringify(statement), testcase.description)
+	}
+}

expr/binary.go

@@ -0,0 +1,12 @@
+package expr
+
+import "github.com/viant/sqlx/metadata/ast/node"
+
+type Binary struct {
+	X, Y node.Node
+	Op   string
+}
+
+func NewBinary(x node.Node) *Binary {
+	return &Binary{X: x}
+}

expr/call.go

@@ -0,0 +1,9 @@
+package expr
+
+import "github.com/viant/sqlx/metadata/ast/node"
+
+type Call struct {
+	X    node.Node
+	Args []node.Node
+	Raw  string
+}

expr/ident.go

@@ -0,0 +1,5 @@
+package expr
+
+type Ident struct {
+	Name string
+}

expr/literal.go

@@ -0,0 +1,26 @@
+package expr
+
+type Literal struct {
+	Value string
+	Kind  string
+}
+
+func NewIntLiteral(v string) *Literal {
+	return &Literal{Value: v, Kind: "int"}
+}
+
+func NewStringLiteral(v string) *Literal {
+	return &Literal{Value: v, Kind: "string"}
+}
+
+func NewBoolLiteral(v string) *Literal {
+	return &Literal{Value: v, Kind: "bool"}
+}
+
+func NewNullLiteral(v string) *Literal {
+	return &Literal{Value: v, Kind: "null"}
+}
+
+func NewNumericLiteral(v string) *Literal {
+	return &Literal{Value: v, Kind: "numeric"}
+}