With clause support extended, fixed test cases.

Author: ppoudyal-viant

expr/selector.go

@@ -1,8 +1,9 @@
 package expr
 
 import (
-	"github.com/viant/sqlparser/node"
 	"strings"
+
+	"github.com/viant/sqlparser/node"
 )
 
 // Selector represent identifier selector
@@ -24,9 +25,11 @@ func NewSelector(name string) node.Node {
 		name = strings.Replace(name, expr, "", 1)
 		expr = expr[1 : len(expr)-1]
 	}
-
 	part := strings.Index(name, ".")
 	if part == -1 {
+		if expr != "" {
+			return &Selector{Name: name, Expression: expr}
+		}
 		return &Ident{Name: name}
 	}
 	return &Selector{Name: name[:part], X: NewSelector(name[part+1:]), Expression: expr}

join.go

@@ -8,27 +8,27 @@ import (
 
 func parseJoin(cursor *parsly.Cursor, join *query.Join, dest *query.Select, expectOn bool) error {
 	match := cursor.MatchAfterOptional(whitespaceMatcher, parenthesesMatcher, exprMatcher, selectorMatcher)
+	var skipAlias bool
 	switch match.Code {
 	case parenthesesCode:
 		join.With = expr.NewRaw(match.Text(cursor))
 	case selectorTokenCode:
 		identityOrAlias := match.Text(cursor)
-
 		match = cursor.MatchAfterOptional(whitespaceMatcher, parenthesesMatcher)
 		if match.Code == parenthesesCode {
 			identityOrAlias += match.Text(cursor)
 		}
-
 		withSelect := dest.WithSelects.Select(identityOrAlias)
 		if withSelect != nil {
-			join.With = expr.NewParenthesis(withSelect.Raw)
-			join.Alias = identityOrAlias
+			join.With = expr.NewSelector(identityOrAlias)
+			join.Alias = ""
+			skipAlias = true
 		} else {
 			join.With = expr.NewSelector(identityOrAlias)
+			skipAlias = false
 		}
 	}
-
-	if join.Alias == "" {
+	if join.Alias == "" && !skipAlias {
 		join.Alias = discoverAlias(cursor)
 	}
 	match = cursor.MatchAfterOptional(whitespaceMatcher, commentBlockMatcher, onKeywordMatcher)

query.go

@@ -3,10 +3,11 @@ package sqlparser
 import (
 	"bytes"
 	"fmt"
+	"strings"
+
 	"github.com/viant/parsly"
 	"github.com/viant/sqlparser/expr"
 	"github.com/viant/sqlparser/query"
-	"strings"
 )
 
 // ParseQuery parses query
@@ -93,15 +94,18 @@ beginMatch:
 		case fromKeyword:
 			dest.From = query.From{}
 			match = cursor.MatchAfterOptional(whitespaceMatcher, tableMatcher, parenthesesMatcher)
+			var skipAlias bool
 			switch match.Code {
 			case tableTokenCode:
 				identityOrAlias := match.Text(cursor)
 				withSelect := dest.WithSelects.Select(identityOrAlias)
 				if withSelect != nil {
-					dest.From.X = expr.NewParenthesis(withSelect.Raw)
-					dest.From.Alias = identityOrAlias
+					dest.From.X = expr.NewSelector(identityOrAlias)
+					dest.From.Alias = ""
+					skipAlias = true
 				} else {
 					dest.From.X = expr.NewSelector(identityOrAlias)
+					skipAlias = false
 				}
 			case parenthesesCode:
 				dest.From.X = expr.NewRaw(match.Text(cursor))
@@ -116,7 +120,7 @@ beginMatch:
 				}
 				rawNode.X = subSelect
 			}
-			if dest.From.Alias == "" {
+			if dest.From.Alias == "" && !skipAlias {
 				dest.From.Alias = discoverAlias(cursor)
 			}
 			match = cursor.MatchAfterOptional(whitespaceMatcher, commentBlockMatcher)

query_test.go

@@ -3,13 +3,14 @@ package sqlparser
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
+	"testing"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/viant/parsly"
 	"github.com/viant/sqlparser/expr"
 	"github.com/viant/sqlparser/node"
 	"github.com/viant/sqlparser/query"
-	"strings"
-	"testing"
 )
 
 func TestBinaryWalk(t *testing.T) {
@@ -69,7 +70,7 @@ func TestParseSelect(t *testing.T) {
 				description: "with syntax",
 				SQL: `WITH p AS (SELECT * FROM product), v AS (SELECT * FROM vendor)
 				SELECT p.*, v.* FROM p JOIN v ON p.VENDOR_ID = v.ID`,
-				expect: `SELECT p.*, v.* FROM (SELECT * FROM product) p JOIN (SELECT * FROM vendor) v ON p.VENDOR_ID = v.ID`,
+				expect: `WITH p AS (SELECT * FROM product), v AS (SELECT * FROM vendor) SELECT p.*, v.* FROM p JOIN v ON p.VENDOR_ID = v.ID`,
 			},
 
 			{
@@ -359,6 +360,7 @@ func TestParseSelect(t *testing.T) {
 			actual := strings.TrimSpace(Stringify(query))
 			if !assert.EqualValues(t, testCase.expect, actual) {
 				data, _ := json.Marshal(query)
+				fmt.Printf("failed test case: %s\n", testCase.description)
 				fmt.Printf("%s\n", data)
 			}
 		}

stringify.go

@@ -39,17 +39,18 @@ func stringify(n node.Node, builder *bytes.Buffer) {
 				}
 				builder.WriteString(withSel.Alias)
 				builder.WriteString(" AS ")
-				if withSel.Raw != "" {
+				switch {
+				case withSel.Raw != "":
 					builder.WriteString(withSel.Raw)
-				} else if withSel.X != nil {
-					builder.WriteString("(")
+				case withSel.X != nil:
+					builder.WriteByte('(')
 					stringify(withSel.X, builder)
-					builder.WriteString(")")
-				} else {
+					builder.WriteByte(')')
+				default:
 					builder.WriteString("()")
 				}
 			}
-			builder.WriteString(" ")
+			builder.WriteByte(' ')
 		}
 		builder.WriteString("SELECT ")
 		stringify(actual.List, builder)
@@ -210,16 +211,24 @@ func stringify(n node.Node, builder *bytes.Buffer) {
 		builder.WriteString(" AND ")
 		stringify(actual.Max, builder)
 	case *expr.Selector:
-		builder.WriteString(actual.Name)
-		if actual.Expression != "" {
-			builder.WriteString("[")
+		name := actual.Name
+		if actual.Expression == "" {
+			builder.WriteString(name)
+		} else if strings.HasPrefix(name, "`") && strings.HasSuffix(name, "`") && len(name) > 1 {
+			builder.WriteString(name[:len(name)-1])
+			builder.WriteByte('[')
 			builder.WriteString(actual.Expression)
-			builder.WriteString("]")
+			builder.WriteString("]`")
+		} else {
+			builder.WriteString(name)
+			builder.WriteByte('[')
+			builder.WriteString(actual.Expression)
+			builder.WriteByte(']')
 		}
 		if actual.X != nil {
 			builder.WriteByte('.')
+			stringify(actual.X, builder)
 		}
-		stringify(actual.X, builder)
 	case *update.Item:
 		stringify(actual.Column, builder)
 		builder.WriteString(" = ")