updated parser

Author: awitas

expr/parent.go

@@ -1,7 +1,10 @@
 package expr
 
+import "github.com/viant/sqlparser/node"
+
 type Parenthesis struct {
 	Raw string
+	X   node.Node
 }
 
 func NewParenthesis(raw string) *Parenthesis {

expr/raw.go

@@ -1,7 +1,10 @@
 package expr
 
+import "github.com/viant/sqlparser/node"
+
 type Raw struct {
 	Raw string
+	X   node.Node
 }
 
 func NewRaw(raw string) *Raw {

lex.go

@@ -52,11 +52,13 @@ const (
 	rangeOperator
 	windowTokenCode
 	literalCode
+	exprToken
 	keyTokenCode
 	notNullToken
 	createTableToken
 	defaultToken
 	ifNotExistsToken
+	ifExistsToken
 	dropTableToken
 	deleteCode
 )
@@ -130,12 +132,17 @@ var identifierMatcher = parsly.NewToken(identifierCode, "IDENT", smatcher.NewIde
 var selectorMatcher = parsly.NewToken(selectorTokenCode, "SELECTOR", smatcher.NewSelector())
 var placeholderMatcher = parsly.NewToken(placeholderTokenCode, "SELECTOR", smatcher.NewPlaceholder())
 var literalMatcher = parsly.NewToken(literalCode, "LITERAL", matcher.NewNop())
+var exprMatcher = parsly.NewToken(exprToken, ",EXPR", matcher.NewNop())
+
 var deleteMatcher = parsly.NewToken(deleteCode, "DELETE", matcher.NewFragmentsFold([]byte("delete")))
 var notNullMatcher = parsly.NewToken(notNullToken, "NOT NULL", matcher.NewSpacedSet([]string{
 	"not null"}, &option.Case{}))
 var ifNotExistsMatcher = parsly.NewToken(ifNotExistsToken, "IF NOT EXISTS", matcher.NewSpacedSet([]string{
 	"if not exists"}, &option.Case{}))
 
+var ifExistsMatcher = parsly.NewToken(ifExistsToken, "IF EXISTS", matcher.NewSpacedSet([]string{
+	"if exists"}, &option.Case{}))
+
 var createTableMatcher = parsly.NewToken(createTableToken, "CREATE TABLE", matcher.NewSpacedSet([]string{
 	"create table"}, &option.Case{}))
 

list.go

@@ -43,7 +43,13 @@ func parseSelectListItem(cursor *parsly.Cursor, list *query.List) error {
 		}
 		fallthrough
 	case nextCode:
-		return parseSelectListItem(cursor, list)
+		count := len(*list)
+		if err = parseSelectListItem(cursor, list); err != nil {
+			return err
+		}
+		if count == len(*list) {
+			return cursor.NewError(exprMatcher)
+		}
 	}
 	return nil
 }

operand.go

@@ -44,6 +44,7 @@ func expectOperand(cursor *parsly.Cursor) (node.Node, error) {
 		commentBlockMatcher,
 	)
 	pos := cursor.Pos
+
 	switch match.Code {
 	case selectorTokenCode, placeholderTokenCode:
 
@@ -107,7 +108,7 @@ func expectOperand(cursor *parsly.Cursor) (node.Node, error) {
 		return unary, nil
 
 	case asKeyword, orderByKeyword, onKeyword, fromKeyword, whereKeyword, joinToken, groupByKeyword, havingKeyword, windowTokenCode, nextCode, commentBlock:
-		cursor.Pos -= pos
+		cursor.Pos = pos
 	}
 	return nil, nil
 }

query.go

@@ -15,7 +15,7 @@ func ParseQuery(SQL string) (*query.Select, error) {
 	cursor := parsly.NewCursor("", []byte(SQL), 0)
 	err := parseQuery(cursor, result)
 	if err != nil {
-		return result, fmt.Errorf("%s", SQL)
+		return result, fmt.Errorf("%w %s", err, SQL)
 	}
 	return result, err
 }
@@ -50,6 +50,7 @@ func parseQuery(cursor *parsly.Cursor, dest *query.Select) error {
 		}
 
 		match = cursor.MatchAfterOptional(whitespaceMatcher, fromKeywordMatcher)
+		pos := cursor.Pos
 		switch match.Code {
 		case fromKeyword:
 			dest.From = query.From{}
@@ -58,13 +59,21 @@ func parseQuery(cursor *parsly.Cursor, dest *query.Select) error {
 			case selectorTokenCode:
 				dest.From.X = expr.NewSelector(match.Text(cursor))
 			case parenthesesCode:
-				dest.From.X = expr.NewRaw(match.Text(cursor))
+				rawNode := expr.NewRaw(match.Text(cursor))
+				dest.From.X = rawNode
+				rawExpr := trimEnclosure(rawNode.Raw)
+				rawParser := parsly.NewCursor(cursor.Path, []byte(rawExpr), pos)
+				subSelect := &query.Select{}
+				if err := parseQuery(rawParser, subSelect); err != nil {
+					return fmt.Errorf("invalid subquery: %w, %s", err, rawExpr)
+				}
+				rawNode.X = subSelect
+
 			}
 			dest.From.Alias = discoverAlias(cursor)
 			dest.From.Comments = matchComment(cursor)
 
 			dest.Joins = make([]*query.Join, 0)
-
 			match = cursor.MatchAfterOptional(whitespaceMatcher, joinMatcher, whereKeywordMatcher, groupByMatcher, havingKeywordMatcher, orderByKeywordMatcher, windowMatcher)
 			if match.Code == parsly.EOF {
 				return nil

query/select.go

@@ -17,3 +17,23 @@ type Select struct {
 	Offset  *expr.Literal
 	Kind    string
 }
+
+func (s *Select) IsNested() bool {
+	if s.From.X == nil {
+		return false
+	}
+	_, ok := s.From.X.(*expr.Raw)
+	return ok
+}
+
+func (s *Select) NestedSelect() *Select {
+	if s.From.X == nil {
+		return nil
+	}
+	raw, ok := s.From.X.(*expr.Raw)
+	if !ok {
+		return nil
+	}
+	result, _ := raw.X.(*Select)
+	return result
+}

query_test.go

@@ -15,13 +15,20 @@ func TestParseSelect(t *testing.T) {
 			description string
 			SQL         string
 			expect      string
+			hasError    bool
 		}{
 
+			{
+				description: "error - extra coma",
+				SQL:         `SELECT TOUPPER(name) AS Name, FROM user u`,
+				hasError:    true,
+			},
 			{
 				description: "fun call",
 				SQL:         `SELECT TOUPPER(name) AS Name FROM user u`,
 				expect:      `SELECT TOUPPER(name) AS Name FROM user u`,
 			},
+
 			{
 				description: "cast call",
 				SQL:         `SELECT CAST(name AS TEXT) AS Name FROM user u`,
@@ -152,7 +159,12 @@ func TestParseSelect(t *testing.T) {
 
 		for _, testCase := range testCases {
 			query, err := ParseQuery(testCase.SQL)
+			if testCase.hasError {
+				assert.NotNilf(t, err, testCase.description)
+				continue
+			}
 			if !assert.Nil(t, err) {
+				fmt.Println(err)
 				fmt.Printf("%v\n", testCase.SQL)
 				continue
 			}

stringify.go

@@ -25,6 +25,8 @@ func stringify(n node.Node, builder *bytes.Buffer) {
 		panic("node was nill")
 	}
 	switch actual := n.(type) {
+	case string:
+		builder.WriteString(actual)
 	case *query.Select:
 		builder.WriteString("SELECT ")
 		stringify(actual.List, builder)

table.go

@@ -4,9 +4,105 @@ import (
 	"fmt"
 	"github.com/viant/parsly"
 	"github.com/viant/sqlparser/column"
+	del "github.com/viant/sqlparser/delete"
+	"github.com/viant/sqlparser/expr"
+	"github.com/viant/sqlparser/insert"
+	"github.com/viant/sqlparser/node"
+	"github.com/viant/sqlparser/query"
 	"github.com/viant/sqlparser/table"
+	"github.com/viant/sqlparser/update"
 )
 
+//TableName returns main table name
+func TableName(node node.Node) string {
+	switch actual := node.(type) {
+	case *query.Select:
+		return queryTableName(actual)
+	case *insert.Statement:
+		return trimEnclosure(actual.Target.X)
+	case *update.Statement:
+		return trimEnclosure(actual.Target.X)
+	case *del.Statement:
+		return trimEnclosure(actual.Target.X)
+	case *table.Create:
+		return trimEnclosure(actual.Spec.Name)
+	case *table.Drop:
+		return trimEnclosure(actual.Name)
+	}
+	return ""
+}
+
+func queryTableName(sel *query.Select) string {
+	if sel.From.X == nil {
+		return ""
+	}
+	switch actual := sel.From.X.(type) {
+	case *expr.Ident:
+		return actual.Name
+	case *expr.Selector:
+		return trimEnclosure(actual)
+	case *expr.Parenthesis:
+		raw := trimEnclosure(actual.Raw)
+		if sel, _ := ParseQuery(raw); sel != nil {
+			actual.X = sel
+			return TableName(sel)
+		}
+	case *expr.Raw:
+		if actual.X != nil {
+			return TableName(actual.X)
+		}
+	default:
+		panic(fmt.Sprintf("not supported:%T ", actual))
+	}
+	return ""
+}
+
+func trimEnclosure(node node.Node) string {
+	if node == nil {
+		return ""
+	}
+	var name string
+	var ok bool
+	if name, ok = node.(string); !ok {
+		name = Stringify(node)
+	}
+	switch name[0] {
+	case '`', '"', '[', '\'', '(':
+		name = name[1 : len(name)-1]
+	}
+	return name
+}
+
+func ParseDropTable(SQL string) (*table.Drop, error) {
+	result := &table.Drop{}
+	SQL = removeSQLComments(SQL)
+	cursor := parsly.NewCursor("", []byte(SQL), 0)
+	err := parseDropTable(cursor, result)
+	if err != nil {
+		return result, fmt.Errorf("%s", SQL)
+	}
+	return result, err
+}
+
+func parseDropTable(cursor *parsly.Cursor, dest *table.Drop) error {
+	match := cursor.MatchAfterOptional(whitespaceMatcher, dropTableMatcher)
+	if match.Code != dropTableToken {
+		return cursor.NewError(createTableMatcher)
+	}
+	if match = cursor.MatchOne(whitespaceMatcher); match.Code != whitespaceCode {
+		return cursor.NewError(whitespaceMatcher)
+	}
+	if match = cursor.MatchOne(ifExistsMatcher); match.Code == ifExistsToken {
+		dest.IfExists = true
+	}
+	match = cursor.MatchAfterOptional(whitespaceMatcher, identifierMatcher)
+	if match.Code != identifierCode {
+		return cursor.NewError(ifNotExistsMatcher)
+	}
+	dest.Name = match.Text(cursor)
+	return nil
+}
+
 func ParseCreateTable(SQL string) (*table.Create, error) {
 	result := &table.Create{}
 	SQL = removeSQLComments(SQL)