diff --git a/ast/ast.go b/ast/ast.go index 954504e9..809f4dcd 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -4349,6 +4349,13 @@ type GQLPrimitiveQueryStatement interface { } func (GQLReturn) isGQLPrimitiveQueryStatement() {} +func (GQLWith) isGQLPrimitiveQueryStatement() {} +func (GQLFilter) isGQLPrimitiveQueryStatement() {} +func (GQLFor) isGQLPrimitiveQueryStatement() {} +func (GQLLet) isGQLPrimitiveQueryStatement() {} +func (GQLOrderBy) isGQLPrimitiveQueryStatement() {} +func (GQLLimit) isGQLPrimitiveQueryStatement() {} +func (GQLOffset) isGQLPrimitiveQueryStatement() {} func (BadGQLPrimitiveQueryStatement) isGQLPrimitiveQueryStatement() {} // GQLGraphQuery is a top-level GQL query. @@ -4429,24 +4436,137 @@ type BadGQLPrimitiveQueryStatement struct { // GQLReturn is a RETURN statement in GQL. // -// RETURN {{.AllOrDistinct | sqlOpt}} {{.Items | sqlJoin ", "}} +// RETURN {{.AllOrDistinct | sqlOpt}} {{.Items | sqlJoin ", "}} {{.GroupBy | sqlOpt}} {{.OrderBy | sqlOpt}} {{.Offset | sqlOpt}} {{.Limit | sqlOpt}} type GQLReturn struct { // pos = Return - // end = Items[$].end + // end = (Limit ?? Offset ?? OrderBy ?? GroupBy ?? Items[$]).end Return token.Pos AllOrDistinct AllOrDistinct - Items []*GQLReturnItem + Items []*GQLReturnItem // len(Items) > 0 + GroupBy *GroupBy + OrderBy *GQLOrderBy + Offset *GQLOffset + Limit *GQLLimit } -// GQLReturnItem is an item in a RETURN statement. +// GQLReturnItem is an item in a RETURN or WITH statement. // -// {{.Expr | sql}}{{if .Alias}} {{.Alias | sqlOpt}}{{end}} +// {{if .Star}}*{{"\n"}}{{else}}{{.Expr | sql}}{{if .Alias}} AS {{.Alias | sql}}{{end}}{{end}} type GQLReturnItem struct { // pos = Star || Expr.pos // end = Star + 1 || (Alias ?? Expr).end - Star token.Pos + Star token.Pos // position of "*", optional + Expr Expr // optional + Alias *AsAlias // optional +} + +// GQLWith is a WITH statement in GQL. +// +// WITH {{.AllOrDistinct | sqlOpt}} {{.Items | sqlJoin ", "}} {{.GroupBy | sqlOpt}} +type GQLWith struct { + // pos = With + // end = (GroupBy ?? Items[$]).end + + With token.Pos // position of "WITH" keyword + AllOrDistinct AllOrDistinct + Items []*GQLReturnItem // len(Items) > 0 + GroupBy *GroupBy +} + +// GQLFilter is a FILTER statement in GQL. +// +// FILTER {{.Where | sqlOpt}} {{.Expr | sql}} +type GQLFilter struct { + // pos = Filter || Where + // end = Expr.end + + Filter token.Pos // position of "FILTER" keyword, optional + Where token.Pos // position of "WHERE" keyword, optional + Expr Expr +} + +// GQLFor is a FOR statement in GQL. +// +// FOR {{.Ident | sql}} IN {{.Expr | sql}} {{.WithOffset | sqlOpt}} +type GQLFor struct { + // pos = For + // end = (WithOffset ?? Expr).end + + For token.Pos + Ident *Ident Expr Expr - Alias *AsAlias // optional + + WithOffset *WithOffset // optional +} + +// GQLLet is a LET statement in GQL. +// +// LET {{.Items | sqlJoin ", "}} +type GQLLet struct { + // pos = Let + // end = Items[$].end + + Let token.Pos + Items []*GQLLetItem // len(Items) > 0 +} + +// GQLLetItem is an item in a LET statement. +// +// {{.Ident | sql}} = {{.Expr | sql}} +type GQLLetItem struct { + // pos = Ident.pos + // end = Expr.end + + Ident *Ident + Expr Expr +} + +// GQLOrderBy is an ORDER BY statement in GQL. +// +// ORDER BY {{.Items | sqlJoin ", "}} +type GQLOrderBy struct { + // pos = Order + // end = Items[$].end + + Order token.Pos + Items []*GQLOrderByItem // len(Items) > 0 +} + +// GQLLimit is a LIMIT statement in GQL. +// +// LIMIT {{.Limit | sql}} +type GQLLimit struct { + // pos = LimitPos + // end = Limit.end + + LimitPos token.Pos // position of "LIMIT" + Limit IntValue +} + +// GQLOffset is an OFFSET or SKIP statement in GQL. +// +// {{.Keyword}} {{.Offset | sql}} +type GQLOffset struct { + // pos = OffsetPos + // end = Offset.end + + OffsetPos token.Pos // position of "OFFSET" or "SKIP" + Keyword string // "OFFSET" or "SKIP" + Offset IntValue +} + +// GQLOrderByItem is expression node in GQL ORDER BY clause list. +// +// {{.Expr | sql}} {{.Collate | sqlOpt}} {{.Direction}} +type GQLOrderByItem struct { + // pos = Expr.pos + // end = DirEnd || Collate.end || Expr.end + + DirEnd token.Pos // end position of Dir + + Expr Expr + Collate *Collate // optional + Dir Direction // optional } diff --git a/ast/pos.go b/ast/pos.go index d6e58c2a..efe7f706 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -2235,7 +2235,7 @@ func (g *GQLReturn) Pos() token.Pos { } func (g *GQLReturn) End() token.Pos { - return nodeEnd(nodeSliceLast(g.Items)) + return nodeEnd(nodeChoice(wrapNode(g.Limit), wrapNode(g.Offset), wrapNode(g.OrderBy), wrapNode(g.GroupBy), nodeSliceLast(g.Items))) } func (g *GQLReturnItem) Pos() token.Pos { @@ -2245,3 +2245,75 @@ func (g *GQLReturnItem) Pos() token.Pos { func (g *GQLReturnItem) End() token.Pos { return posChoice(posAdd(g.Star, 1), nodeEnd(nodeChoice(wrapNode(g.Alias), wrapNode(g.Expr)))) } + +func (g *GQLWith) Pos() token.Pos { + return g.With +} + +func (g *GQLWith) End() token.Pos { + return nodeEnd(nodeChoice(wrapNode(g.GroupBy), nodeSliceLast(g.Items))) +} + +func (g *GQLFilter) Pos() token.Pos { + return posChoice(g.Filter, g.Where) +} + +func (g *GQLFilter) End() token.Pos { + return nodeEnd(wrapNode(g.Expr)) +} + +func (g *GQLFor) Pos() token.Pos { + return g.For +} + +func (g *GQLFor) End() token.Pos { + return nodeEnd(nodeChoice(wrapNode(g.WithOffset), wrapNode(g.Expr))) +} + +func (g *GQLLet) Pos() token.Pos { + return g.Let +} + +func (g *GQLLet) End() token.Pos { + return nodeEnd(nodeSliceLast(g.Items)) +} + +func (g *GQLLetItem) Pos() token.Pos { + return nodePos(wrapNode(g.Ident)) +} + +func (g *GQLLetItem) End() token.Pos { + return nodeEnd(wrapNode(g.Expr)) +} + +func (g *GQLOrderBy) Pos() token.Pos { + return g.Order +} + +func (g *GQLOrderBy) End() token.Pos { + return nodeEnd(nodeSliceLast(g.Items)) +} + +func (g *GQLLimit) Pos() token.Pos { + return g.LimitPos +} + +func (g *GQLLimit) End() token.Pos { + return nodeEnd(wrapNode(g.Limit)) +} + +func (g *GQLOffset) Pos() token.Pos { + return g.OffsetPos +} + +func (g *GQLOffset) End() token.Pos { + return nodeEnd(wrapNode(g.Offset)) +} + +func (g *GQLOrderByItem) Pos() token.Pos { + return nodePos(wrapNode(g.Expr)) +} + +func (g *GQLOrderByItem) End() token.Pos { + return posChoice(g.DirEnd, nodeEnd(wrapNode(g.Collate)), nodeEnd(wrapNode(g.Expr))) +} diff --git a/ast/sql.go b/ast/sql.go index e3564641..290ec674 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1473,7 +1473,8 @@ func (s *GQLCompoundLinearQueryStatement) SQL() string { } func (s *GQLReturn) SQL() string { - return "RETURN " + strOpt(s.AllOrDistinct != "", string(s.AllOrDistinct)+" ") + sqlJoin(s.Items, ", ") + return "RETURN " + strOpt(s.AllOrDistinct != "", string(s.AllOrDistinct)+" ") + sqlJoin(s.Items, ", ") + + sqlOpt(" ", s.GroupBy, "") + sqlOpt(" ", s.OrderBy, "") + sqlOpt(" ", s.Offset, "") + sqlOpt(" ", s.Limit, "") } func (i *GQLReturnItem) SQL() string { @@ -1482,3 +1483,40 @@ func (i *GQLReturnItem) SQL() string { } return i.Expr.SQL() + sqlOpt(" ", i.Alias, "") } + +func (s *GQLWith) SQL() string { + return "WITH " + strOpt(s.AllOrDistinct != "", string(s.AllOrDistinct)+" ") + sqlJoin(s.Items, ", ") + + sqlOpt(" ", s.GroupBy, "") +} + +func (s *GQLFilter) SQL() string { + return strOpt(!s.Filter.Invalid(), "FILTER ") + strOpt(!s.Where.Invalid(), "WHERE ") + s.Expr.SQL() +} + +func (s *GQLFor) SQL() string { + return "FOR " + s.Ident.SQL() + " IN " + s.Expr.SQL() + sqlOpt(" ", s.WithOffset, "") +} + +func (s *GQLLet) SQL() string { + return "LET " + sqlJoin(s.Items, ", ") +} + +func (i *GQLLetItem) SQL() string { + return i.Ident.SQL() + " = " + i.Expr.SQL() +} + +func (s *GQLOrderBy) SQL() string { + return "ORDER BY " + sqlJoin(s.Items, ", ") +} + +func (i *GQLOrderByItem) SQL() string { + return i.Expr.SQL() + sqlOpt(" ", i.Collate, "") + strOpt(i.Dir != "", " "+string(i.Dir)) +} + +func (s *GQLLimit) SQL() string { + return "LIMIT " + s.Limit.SQL() +} + +func (s *GQLOffset) SQL() string { + return s.Keyword + " " + s.Offset.SQL() +} diff --git a/ast/walk_internal.go b/ast/walk_internal.go index c567bed8..f3141806 100644 --- a/ast/walk_internal.go +++ b/ast/walk_internal.go @@ -1031,11 +1031,47 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")}) case *GQLReturn: + stack = append(stack, &stackItem{node: wrapNode(n.Limit), visitor: v.Field("Limit")}) + stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) + stack = append(stack, &stackItem{node: wrapNode(n.OrderBy), visitor: v.Field("OrderBy")}) + stack = append(stack, &stackItem{node: wrapNode(n.GroupBy), visitor: v.Field("GroupBy")}) stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")}) case *GQLReturnItem: stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + + case *GQLWith: + stack = append(stack, &stackItem{node: wrapNode(n.GroupBy), visitor: v.Field("GroupBy")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")}) + + case *GQLFilter: + stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + + case *GQLFor: + stack = append(stack, &stackItem{node: wrapNode(n.WithOffset), visitor: v.Field("WithOffset")}) + stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + stack = append(stack, &stackItem{node: wrapNode(n.Ident), visitor: v.Field("Ident")}) + + case *GQLLet: + stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")}) + + case *GQLLetItem: + stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + stack = append(stack, &stackItem{node: wrapNode(n.Ident), visitor: v.Field("Ident")}) + + case *GQLOrderBy: + stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")}) + + case *GQLLimit: + stack = append(stack, &stackItem{node: wrapNode(n.Limit), visitor: v.Field("Limit")}) + + case *GQLOffset: + stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) + + case *GQLOrderByItem: + stack = append(stack, &stackItem{node: wrapNode(n.Collate), visitor: v.Field("Collate")}) + stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) } return stack } diff --git a/parser.go b/parser.go index c11b1ce8..606f530f 100644 --- a/parser.go +++ b/parser.go @@ -1222,7 +1222,7 @@ func (p *Parser) parseIdentOrPath() []*ast.Ident { func (p *Parser) parseUnnestSuffix(expr ast.Expr, unnest, rparen token.Pos) ast.TableExpr { hint := p.tryParseHint() as := p.tryParseAsAlias(withOptionalAs) - withOffset := p.tryParseWithOffset() + withOffset := p.tryParseWithOffset(withOptionalAs) return p.parseTableExprSuffix(&ast.Unnest{ Unnest: unnest, @@ -1234,14 +1234,14 @@ func (p *Parser) parseUnnestSuffix(expr ast.Expr, unnest, rparen token.Pos) ast. }) } -func (p *Parser) tryParseWithOffset() *ast.WithOffset { +func (p *Parser) tryParseWithOffset(requiredAs withAs) *ast.WithOffset { if p.Token.Kind != "WITH" { return nil } with := p.expect("WITH").Pos offset := p.expectKeywordLike("OFFSET").Pos - as := p.tryParseAsAlias(withOptionalAs) + as := p.tryParseAsAlias(requiredAs) return &ast.WithOffset{ With: with, @@ -1263,7 +1263,7 @@ func (p *Parser) parseTableNameSuffix(id *ast.Ident) ast.TableExpr { func (p *Parser) parsePathTableExprSuffix(id *ast.Path) ast.TableExpr { hint := p.tryParseHint() as := p.tryParseAsAlias(withOptionalAs) - withOffset := p.tryParseWithOffset() + withOffset := p.tryParseWithOffset(withOptionalAs) return p.parseTableExprSuffix(&ast.PathTableExpr{ Path: id, Hint: hint, @@ -6353,21 +6353,186 @@ func (p *Parser) tryParseGQLPrimitiveQueryStatement() ast.GQLPrimitiveQueryState switch { case p.Token.IsKeywordLike("RETURN"): return p.parseGQLReturn() + case p.Token.Kind == "WITH": + return p.parseGQLWith() + case p.Token.IsKeywordLike("FILTER"): + return p.parseGQLFilter() + case p.Token.Kind == "FOR": + return p.parseGQLFor() + case p.Token.IsKeywordLike("LET"): + return p.parseGQLLet() + case p.Token.Kind == "ORDER": + return p.parseGQLOrderBy() + case p.Token.Kind == "LIMIT": + return p.parseGQLLimit() + case p.Token.IsKeywordLike("OFFSET") || p.Token.IsKeywordLike("SKIP"): + return p.parseGQLOffset() default: return nil } } +func (p *Parser) parseGQLFilter() *ast.GQLFilter { + filterPos := p.expectKeywordLike("FILTER").Pos + var wherePos token.Pos + if p.Token.Kind == "WHERE" { + wherePos = p.expect("WHERE").Pos + } + expr := p.parseExpr() + return &ast.GQLFilter{ + Filter: filterPos, + Where: wherePos, + Expr: expr, + } +} + +func (p *Parser) parseGQLFor() *ast.GQLFor { + pos := p.expect("FOR").Pos + ident := p.parseIdent() + p.expect("IN") + expr := p.parseExpr() + withOffset := p.tryParseWithOffset(withRequiredAs) + return &ast.GQLFor{ + For: pos, + Ident: ident, + Expr: expr, + WithOffset: withOffset, + } +} + +func (p *Parser) parseGQLLet() *ast.GQLLet { + pos := p.expectKeywordLike("LET").Pos + var items []*ast.GQLLetItem + for { + items = append(items, p.parseGQLLetItem()) + if p.Token.Kind != "," { + break + } + p.nextToken() + } + return &ast.GQLLet{ + Let: pos, + Items: items, + } +} + +func (p *Parser) parseGQLLetItem() *ast.GQLLetItem { + ident := p.parseIdent() + p.expect("=") + expr := p.parseExpr() + return &ast.GQLLetItem{ + Ident: ident, + Expr: expr, + } +} + +func (p *Parser) parseGQLOrderBy() *ast.GQLOrderBy { + pos := p.expect("ORDER").Pos + p.expect("BY") + items := parseCommaSeparatedList(p, p.parseGQLOrderByItem) + return &ast.GQLOrderBy{ + Order: pos, + Items: items, + } +} + +func (p *Parser) parseGQLOrderByItem() *ast.GQLOrderByItem { + expr := p.parseExpr() + var collate *ast.Collate + if p.Token.Kind == "COLLATE" { + collate = p.tryParseCollate() + } + + var dir ast.Direction + dirEnd := token.InvalidPos + switch { + case p.Token.Kind == "ASC" || p.Token.IsKeywordLike("ASCENDING"): + dir = ast.DirectionAsc + dirEnd = p.Token.End + p.nextToken() + case p.Token.Kind == "DESC" || p.Token.IsKeywordLike("DESCENDING"): + dir = ast.DirectionDesc + dirEnd = p.Token.End + p.nextToken() + } + + return &ast.GQLOrderByItem{ + DirEnd: dirEnd, + Expr: expr, + Collate: collate, + Dir: dir, + } +} + +func (p *Parser) parseGQLLimit() *ast.GQLLimit { + pos := p.expect("LIMIT").Pos + limit := p.parseIntValue() + return &ast.GQLLimit{ + LimitPos: pos, + Limit: limit, + } +} + +func (p *Parser) parseGQLOffset() *ast.GQLOffset { + pos := p.Token.Pos + var keyword string + if p.Token.IsKeywordLike("OFFSET") { + keyword = p.expectKeywordLike("OFFSET").Raw + } else { + keyword = p.expectKeywordLike("SKIP").Raw + } + offset := p.parseIntValue() + return &ast.GQLOffset{ + OffsetPos: pos, + Keyword: keyword, + Offset: offset, + } +} + +func (p *Parser) parseGQLWith() *ast.GQLWith { + pos := p.expect("WITH").Pos + allOrDistinct := p.tryParseAllOrDistinct() + items := p.parseGQLReturnItemList() + groupBy := p.tryParseGroupBy() + + return &ast.GQLWith{ + With: pos, + AllOrDistinct: allOrDistinct, + Items: items, + GroupBy: groupBy, + } +} + func (p *Parser) parseGQLReturn() *ast.GQLReturn { pos := p.expectKeywordLike("RETURN").Pos allOrDistinct := p.tryParseAllOrDistinct() items := p.parseGQLReturnItemList() + groupBy := p.tryParseGroupBy() + var orderBy *ast.GQLOrderBy + if p.Token.Kind == "ORDER" { + orderBy = p.parseGQLOrderBy() + } + + var offset *ast.GQLOffset + if p.Token.IsKeywordLike("OFFSET") || p.Token.IsKeywordLike("SKIP") { + offset = p.parseGQLOffset() + } + + var limit *ast.GQLLimit + if p.Token.Kind == "LIMIT" { + limit = p.parseGQLLimit() + } + return &ast.GQLReturn{ Return: pos, AllOrDistinct: allOrDistinct, Items: items, + GroupBy: groupBy, + OrderBy: orderBy, + Offset: offset, + Limit: limit, } } diff --git a/testdata/input/gql/complex_linear.sql b/testdata/input/gql/complex_linear.sql new file mode 100644 index 00000000..bc2b2d81 --- /dev/null +++ b/testdata/input/gql/complex_linear.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +LET x = 1 +FOR y IN [1, 2] +FILTER WHERE x < y +RETURN y diff --git a/testdata/input/gql/filter.sql b/testdata/input/gql/filter.sql new file mode 100644 index 00000000..3dfdfe02 --- /dev/null +++ b/testdata/input/gql/filter.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +FILTER a > 1 +RETURN a diff --git a/testdata/input/gql/for.sql b/testdata/input/gql/for.sql new file mode 100644 index 00000000..f19a650e --- /dev/null +++ b/testdata/input/gql/for.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +FOR x IN [1, 2, 3] +RETURN x diff --git a/testdata/input/gql/for_with_offset.sql b/testdata/input/gql/for_with_offset.sql new file mode 100644 index 00000000..bd8c5550 --- /dev/null +++ b/testdata/input/gql/for_with_offset.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +FOR x IN [1, 2] WITH OFFSET AS i +RETURN x, i diff --git a/testdata/input/gql/group_hint.sql b/testdata/input/gql/group_hint.sql new file mode 100644 index 00000000..73c459cb --- /dev/null +++ b/testdata/input/gql/group_hint.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +RETURN 1 AS x +GROUP @{GROUP_METHOD=STREAM_GROUP} BY x diff --git a/testdata/input/gql/let.sql b/testdata/input/gql/let.sql new file mode 100644 index 00000000..d0a64c7e --- /dev/null +++ b/testdata/input/gql/let.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +LET x = 1, y = 2 +RETURN x + y diff --git a/testdata/input/gql/limit_offset.sql b/testdata/input/gql/limit_offset.sql new file mode 100644 index 00000000..146f8788 --- /dev/null +++ b/testdata/input/gql/limit_offset.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +RETURN a +OFFSET 5 LIMIT 10 diff --git a/testdata/input/gql/limit_skip.sql b/testdata/input/gql/limit_skip.sql new file mode 100644 index 00000000..33295c15 --- /dev/null +++ b/testdata/input/gql/limit_skip.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +RETURN a +SKIP 5 LIMIT 10 diff --git a/testdata/input/gql/order_by.sql b/testdata/input/gql/order_by.sql new file mode 100644 index 00000000..ab1c2b33 --- /dev/null +++ b/testdata/input/gql/order_by.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +ORDER BY a DESC +RETURN a diff --git a/testdata/input/gql/order_by_directions.sql b/testdata/input/gql/order_by_directions.sql new file mode 100644 index 00000000..6462bdbe --- /dev/null +++ b/testdata/input/gql/order_by_directions.sql @@ -0,0 +1 @@ +GRAPH FinGraph FOR x IN [1] ORDER BY x, x ASC, x DESC, x ASCENDING, x DESCENDING RETURN x AS result diff --git a/testdata/input/gql/return_group_by.sql b/testdata/input/gql/return_group_by.sql new file mode 100644 index 00000000..4b30ab53 --- /dev/null +++ b/testdata/input/gql/return_group_by.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +RETURN a, b +GROUP BY a diff --git a/testdata/input/gql/return_limit_offset.sql b/testdata/input/gql/return_limit_offset.sql new file mode 100644 index 00000000..a2e323d4 --- /dev/null +++ b/testdata/input/gql/return_limit_offset.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +RETURN a +OFFSET 2 LIMIT 1 diff --git a/testdata/input/gql/return_order_by.sql b/testdata/input/gql/return_order_by.sql new file mode 100644 index 00000000..08b159c3 --- /dev/null +++ b/testdata/input/gql/return_order_by.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +RETURN a +ORDER BY a DESC diff --git a/testdata/input/gql/skip.sql b/testdata/input/gql/skip.sql new file mode 100644 index 00000000..647cabca --- /dev/null +++ b/testdata/input/gql/skip.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +RETURN a +SKIP 5 diff --git a/testdata/input/gql/where.sql b/testdata/input/gql/where.sql new file mode 100644 index 00000000..b54e1a65 --- /dev/null +++ b/testdata/input/gql/where.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +FILTER WHERE a > 1 +RETURN a diff --git a/testdata/input/gql/with.sql b/testdata/input/gql/with.sql new file mode 100644 index 00000000..e9480ee9 --- /dev/null +++ b/testdata/input/gql/with.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +WITH 1 AS a +RETURN a diff --git a/testdata/input/gql/with_all_distinct.sql b/testdata/input/gql/with_all_distinct.sql new file mode 100644 index 00000000..61b3ff26 --- /dev/null +++ b/testdata/input/gql/with_all_distinct.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +WITH ALL 1 AS a, 2 AS b +RETURN a, b diff --git a/testdata/input/gql/with_group_by.sql b/testdata/input/gql/with_group_by.sql new file mode 100644 index 00000000..cf4aa347 --- /dev/null +++ b/testdata/input/gql/with_group_by.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +WITH a, b +GROUP BY a +RETURN a diff --git a/testdata/input/gql/with_group_hint.sql b/testdata/input/gql/with_group_hint.sql new file mode 100644 index 00000000..00486cfa --- /dev/null +++ b/testdata/input/gql/with_group_hint.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +WITH 1 AS x +GROUP @{GROUP_METHOD=STREAM_GROUP} BY x +RETURN x diff --git a/testdata/input/gql/with_next.sql b/testdata/input/gql/with_next.sql new file mode 100644 index 00000000..b0c5223e --- /dev/null +++ b/testdata/input/gql/with_next.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +WITH 1 AS a +RETURN a +NEXT +RETURN a diff --git a/testdata/input/gql/with_star.sql b/testdata/input/gql/with_star.sql new file mode 100644 index 00000000..0a01e23c --- /dev/null +++ b/testdata/input/gql/with_star.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +LET x = 1 +WITH * +RETURN * diff --git a/testdata/result/gql/complex_linear.sql.txt b/testdata/result/gql/complex_linear.sql.txt new file mode 100644 index 00000000..f2e8be76 --- /dev/null +++ b/testdata/result/gql/complex_linear.sql.txt @@ -0,0 +1,107 @@ +--- complex_linear.sql +GRAPH FinGraph +LET x = 1 +FOR y IN [1, 2] +FILTER WHERE x < y +RETURN y + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLLet{ + Let: 15, + Items: []*ast.GQLLetItem{ + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.IntLiteral{ + ValuePos: 23, + ValueEnd: 24, + Base: 10, + Value: "1", + }, + }, + }, + }, + &ast.GQLFor{ + For: 25, + Ident: &ast.Ident{ + NamePos: 29, + NameEnd: 30, + Name: "y", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 34, + Rbrack: 39, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 35, + ValueEnd: 36, + Base: 10, + Value: "1", + }, + &ast.IntLiteral{ + ValuePos: 38, + ValueEnd: 39, + Base: 10, + Value: "2", + }, + }, + }, + }, + &ast.GQLFilter{ + Filter: 41, + Where: 48, + Expr: &ast.BinaryExpr{ + Op: "<", + Left: &ast.Ident{ + NamePos: 54, + NameEnd: 55, + Name: "x", + }, + Right: &ast.Ident{ + NamePos: 58, + NameEnd: 59, + Name: "y", + }, + }, + }, + &ast.GQLReturn{ + Return: 60, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 67, + NameEnd: 68, + Name: "y", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph LET x = 1 FOR y IN [1, 2] FILTER WHERE x < y RETURN y diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt new file mode 100644 index 00000000..a3a7ba86 --- /dev/null +++ b/testdata/result/gql/filter.sql.txt @@ -0,0 +1,60 @@ +--- filter.sql +GRAPH FinGraph +FILTER a > 1 +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFilter{ + Filter: 15, + Expr: &ast.BinaryExpr{ + Op: ">", + Left: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + Right: &ast.IntLiteral{ + ValuePos: 26, + ValueEnd: 27, + Base: 10, + Value: "1", + }, + }, + }, + &ast.GQLReturn{ + Return: 28, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 35, + NameEnd: 36, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FILTER WHERE a > 1 RETURN a diff --git a/testdata/result/gql/for.sql.txt b/testdata/result/gql/for.sql.txt new file mode 100644 index 00000000..675cea51 --- /dev/null +++ b/testdata/result/gql/for.sql.txt @@ -0,0 +1,76 @@ +--- for.sql +GRAPH FinGraph +FOR x IN [1, 2, 3] +RETURN x + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFor{ + For: 15, + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 24, + Rbrack: 32, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 25, + ValueEnd: 26, + Base: 10, + Value: "1", + }, + &ast.IntLiteral{ + ValuePos: 28, + ValueEnd: 29, + Base: 10, + Value: "2", + }, + &ast.IntLiteral{ + ValuePos: 31, + ValueEnd: 32, + Base: 10, + Value: "3", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 34, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 41, + NameEnd: 42, + Name: "x", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FOR x IN [1, 2, 3] RETURN x diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt new file mode 100644 index 00000000..8ae15f9b --- /dev/null +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -0,0 +1,90 @@ +--- for_with_offset.sql +GRAPH FinGraph +FOR x IN [1, 2] WITH OFFSET AS i +RETURN x, i + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFor{ + For: 15, + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 24, + Rbrack: 29, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 25, + ValueEnd: 26, + Base: 10, + Value: "1", + }, + &ast.IntLiteral{ + ValuePos: 28, + ValueEnd: 29, + Base: 10, + Value: "2", + }, + }, + }, + WithOffset: &ast.WithOffset{ + With: 31, + Offset: 36, + As: &ast.AsAlias{ + As: 43, + Alias: &ast.Ident{ + NamePos: 46, + NameEnd: 47, + Name: "i", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 48, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 55, + NameEnd: 56, + Name: "x", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 58, + NameEnd: 59, + Name: "i", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FOR x IN [1, 2] WITH OFFSET AS i RETURN x, i diff --git a/testdata/result/gql/group_hint.sql.txt b/testdata/result/gql/group_hint.sql.txt new file mode 100644 index 00000000..51073f1d --- /dev/null +++ b/testdata/result/gql/group_hint.sql.txt @@ -0,0 +1,84 @@ +--- group_hint.sql +GRAPH FinGraph +RETURN 1 AS x +GROUP @{GROUP_METHOD=STREAM_GROUP} BY x + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 22, + ValueEnd: 23, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 24, + Alias: &ast.Ident{ + NamePos: 27, + NameEnd: 28, + Name: "x", + }, + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 29, + Hint: &ast.Hint{ + Atmark: 35, + Rbrace: 62, + Records: []*ast.HintRecord{ + &ast.HintRecord{ + Key: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 37, + NameEnd: 49, + Name: "GROUP_METHOD", + }, + }, + }, + Value: &ast.Ident{ + NamePos: 50, + NameEnd: 62, + Name: "STREAM_GROUP", + }, + }, + }, + }, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 67, + NameEnd: 68, + Name: "x", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN 1 AS x GROUP @{GROUP_METHOD=STREAM_GROUP} BY x diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt new file mode 100644 index 00000000..bf36c610 --- /dev/null +++ b/testdata/result/gql/let.sql.txt @@ -0,0 +1,82 @@ +--- let.sql +GRAPH FinGraph +LET x = 1, y = 2 +RETURN x + y + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLLet{ + Let: 15, + Items: []*ast.GQLLetItem{ + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.IntLiteral{ + ValuePos: 23, + ValueEnd: 24, + Base: 10, + Value: "1", + }, + }, + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 26, + NameEnd: 27, + Name: "y", + }, + Expr: &ast.IntLiteral{ + ValuePos: 30, + ValueEnd: 31, + Base: 10, + Value: "2", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 32, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.BinaryExpr{ + Op: "+", + Left: &ast.Ident{ + NamePos: 39, + NameEnd: 40, + Name: "x", + }, + Right: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "y", + }, + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph LET x = 1, y = 2 RETURN x + y diff --git a/testdata/result/gql/limit_offset.sql.txt b/testdata/result/gql/limit_offset.sql.txt new file mode 100644 index 00000000..eb994167 --- /dev/null +++ b/testdata/result/gql/limit_offset.sql.txt @@ -0,0 +1,62 @@ +--- limit_offset.sql +GRAPH FinGraph +RETURN a +OFFSET 5 LIMIT 10 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "OFFSET", + Offset: &ast.IntLiteral{ + ValuePos: 31, + ValueEnd: 32, + Base: 10, + Value: "5", + }, + }, + Limit: &ast.GQLLimit{ + LimitPos: 33, + Limit: &ast.IntLiteral{ + ValuePos: 39, + ValueEnd: 41, + Base: 10, + Value: "10", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a OFFSET 5 LIMIT 10 diff --git a/testdata/result/gql/limit_skip.sql.txt b/testdata/result/gql/limit_skip.sql.txt new file mode 100644 index 00000000..5b9339ae --- /dev/null +++ b/testdata/result/gql/limit_skip.sql.txt @@ -0,0 +1,62 @@ +--- limit_skip.sql +GRAPH FinGraph +RETURN a +SKIP 5 LIMIT 10 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "SKIP", + Offset: &ast.IntLiteral{ + ValuePos: 29, + ValueEnd: 30, + Base: 10, + Value: "5", + }, + }, + Limit: &ast.GQLLimit{ + LimitPos: 31, + Limit: &ast.IntLiteral{ + ValuePos: 37, + ValueEnd: 39, + Base: 10, + Value: "10", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a SKIP 5 LIMIT 10 diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt new file mode 100644 index 00000000..e5d90781 --- /dev/null +++ b/testdata/result/gql/order_by.sql.txt @@ -0,0 +1,57 @@ +--- order_by.sql +GRAPH FinGraph +ORDER BY a DESC +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLOrderBy{ + Order: 15, + Items: []*ast.GQLOrderByItem{ + &ast.GQLOrderByItem{ + DirEnd: 30, + Expr: &ast.Ident{ + NamePos: 24, + NameEnd: 25, + Name: "a", + }, + Dir: "DESC", + }, + }, + }, + &ast.GQLReturn{ + Return: 31, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 38, + NameEnd: 39, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph ORDER BY a DESC RETURN a diff --git a/testdata/result/gql/order_by_directions.sql.txt b/testdata/result/gql/order_by_directions.sql.txt new file mode 100644 index 00000000..297ed826 --- /dev/null +++ b/testdata/result/gql/order_by_directions.sql.txt @@ -0,0 +1,119 @@ +--- order_by_directions.sql +GRAPH FinGraph FOR x IN [1] ORDER BY x, x ASC, x DESC, x ASCENDING, x DESCENDING RETURN x AS result + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFor{ + For: 15, + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 24, + Rbrack: 26, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 25, + ValueEnd: 26, + Base: 10, + Value: "1", + }, + }, + }, + }, + &ast.GQLOrderBy{ + Order: 28, + Items: []*ast.GQLOrderByItem{ + &ast.GQLOrderByItem{ + DirEnd: -1, + Expr: &ast.Ident{ + NamePos: 37, + NameEnd: 38, + Name: "x", + }, + }, + &ast.GQLOrderByItem{ + DirEnd: 45, + Expr: &ast.Ident{ + NamePos: 40, + NameEnd: 41, + Name: "x", + }, + Dir: "ASC", + }, + &ast.GQLOrderByItem{ + DirEnd: 53, + Expr: &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "x", + }, + Dir: "DESC", + }, + &ast.GQLOrderByItem{ + DirEnd: 66, + Expr: &ast.Ident{ + NamePos: 55, + NameEnd: 56, + Name: "x", + }, + Dir: "ASC", + }, + &ast.GQLOrderByItem{ + DirEnd: 80, + Expr: &ast.Ident{ + NamePos: 68, + NameEnd: 69, + Name: "x", + }, + Dir: "DESC", + }, + }, + }, + &ast.GQLReturn{ + Return: 81, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 88, + NameEnd: 89, + Name: "x", + }, + Alias: &ast.AsAlias{ + As: 90, + Alias: &ast.Ident{ + NamePos: 93, + NameEnd: 99, + Name: "result", + }, + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FOR x IN [1] ORDER BY x, x ASC, x DESC, x ASC, x DESC RETURN x AS result diff --git a/testdata/result/gql/return_group_by.sql.txt b/testdata/result/gql/return_group_by.sql.txt new file mode 100644 index 00000000..b67e0a66 --- /dev/null +++ b/testdata/result/gql/return_group_by.sql.txt @@ -0,0 +1,61 @@ +--- return_group_by.sql +GRAPH FinGraph +RETURN a, b +GROUP BY a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "b", + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 27, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 36, + NameEnd: 37, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a, b GROUP BY a diff --git a/testdata/result/gql/return_limit_offset.sql.txt b/testdata/result/gql/return_limit_offset.sql.txt new file mode 100644 index 00000000..0268a4de --- /dev/null +++ b/testdata/result/gql/return_limit_offset.sql.txt @@ -0,0 +1,62 @@ +--- return_limit_offset.sql +GRAPH FinGraph +RETURN a +OFFSET 2 LIMIT 1 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "OFFSET", + Offset: &ast.IntLiteral{ + ValuePos: 31, + ValueEnd: 32, + Base: 10, + Value: "2", + }, + }, + Limit: &ast.GQLLimit{ + LimitPos: 33, + Limit: &ast.IntLiteral{ + ValuePos: 39, + ValueEnd: 40, + Base: 10, + Value: "1", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a OFFSET 2 LIMIT 1 diff --git a/testdata/result/gql/return_order_by.sql.txt b/testdata/result/gql/return_order_by.sql.txt new file mode 100644 index 00000000..97f00d91 --- /dev/null +++ b/testdata/result/gql/return_order_by.sql.txt @@ -0,0 +1,57 @@ +--- return_order_by.sql +GRAPH FinGraph +RETURN a +ORDER BY a DESC + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + OrderBy: &ast.GQLOrderBy{ + Order: 24, + Items: []*ast.GQLOrderByItem{ + &ast.GQLOrderByItem{ + DirEnd: 39, + Expr: &ast.Ident{ + NamePos: 33, + NameEnd: 34, + Name: "a", + }, + Dir: "DESC", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a ORDER BY a DESC diff --git a/testdata/result/gql/skip.sql.txt b/testdata/result/gql/skip.sql.txt new file mode 100644 index 00000000..a7c9c17d --- /dev/null +++ b/testdata/result/gql/skip.sql.txt @@ -0,0 +1,53 @@ +--- skip.sql +GRAPH FinGraph +RETURN a +SKIP 5 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "SKIP", + Offset: &ast.IntLiteral{ + ValuePos: 29, + ValueEnd: 30, + Base: 10, + Value: "5", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a SKIP 5 diff --git a/testdata/result/gql/where.sql.txt b/testdata/result/gql/where.sql.txt new file mode 100644 index 00000000..a3e0306c --- /dev/null +++ b/testdata/result/gql/where.sql.txt @@ -0,0 +1,61 @@ +--- where.sql +GRAPH FinGraph +FILTER WHERE a > 1 +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFilter{ + Filter: 15, + Where: 22, + Expr: &ast.BinaryExpr{ + Op: ">", + Left: &ast.Ident{ + NamePos: 28, + NameEnd: 29, + Name: "a", + }, + Right: &ast.IntLiteral{ + ValuePos: 32, + ValueEnd: 33, + Base: 10, + Value: "1", + }, + }, + }, + &ast.GQLReturn{ + Return: 34, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 41, + NameEnd: 42, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FILTER WHERE a > 1 RETURN a diff --git a/testdata/result/gql/with.sql.txt b/testdata/result/gql/with.sql.txt new file mode 100644 index 00000000..fec1f9b9 --- /dev/null +++ b/testdata/result/gql/with.sql.txt @@ -0,0 +1,65 @@ +--- with.sql +GRAPH FinGraph +WITH 1 AS a +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 20, + ValueEnd: 21, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 22, + Alias: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "a", + }, + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 27, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 34, + NameEnd: 35, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH 1 AS a RETURN a diff --git a/testdata/result/gql/with_all_distinct.sql.txt b/testdata/result/gql/with_all_distinct.sql.txt new file mode 100644 index 00000000..39799ba6 --- /dev/null +++ b/testdata/result/gql/with_all_distinct.sql.txt @@ -0,0 +1,91 @@ +--- with_all_distinct.sql +GRAPH FinGraph +WITH ALL 1 AS a, 2 AS b +RETURN a, b + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + AllOrDistinct: "ALL", + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 24, + ValueEnd: 25, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 26, + Alias: &ast.Ident{ + NamePos: 29, + NameEnd: 30, + Name: "a", + }, + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 32, + ValueEnd: 33, + Base: 10, + Value: "2", + }, + Alias: &ast.AsAlias{ + As: 34, + Alias: &ast.Ident{ + NamePos: 37, + NameEnd: 38, + Name: "b", + }, + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 39, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 46, + NameEnd: 47, + Name: "a", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 49, + NameEnd: 50, + Name: "b", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH ALL 1 AS a, 2 AS b RETURN a, b diff --git a/testdata/result/gql/with_group_by.sql.txt b/testdata/result/gql/with_group_by.sql.txt new file mode 100644 index 00000000..32ccc5d2 --- /dev/null +++ b/testdata/result/gql/with_group_by.sql.txt @@ -0,0 +1,75 @@ +--- with_group_by.sql +GRAPH FinGraph +WITH a, b +GROUP BY a +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 20, + NameEnd: 21, + Name: "a", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 23, + NameEnd: 24, + Name: "b", + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 25, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 34, + NameEnd: 35, + Name: "a", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 36, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH a, b GROUP BY a RETURN a diff --git a/testdata/result/gql/with_group_hint.sql.txt b/testdata/result/gql/with_group_hint.sql.txt new file mode 100644 index 00000000..3c6d9a07 --- /dev/null +++ b/testdata/result/gql/with_group_hint.sql.txt @@ -0,0 +1,98 @@ +--- with_group_hint.sql +GRAPH FinGraph +WITH 1 AS x +GROUP @{GROUP_METHOD=STREAM_GROUP} BY x +RETURN x + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 20, + ValueEnd: 21, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 22, + Alias: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "x", + }, + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 27, + Hint: &ast.Hint{ + Atmark: 33, + Rbrace: 60, + Records: []*ast.HintRecord{ + &ast.HintRecord{ + Key: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 35, + NameEnd: 47, + Name: "GROUP_METHOD", + }, + }, + }, + Value: &ast.Ident{ + NamePos: 48, + NameEnd: 60, + Name: "STREAM_GROUP", + }, + }, + }, + }, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 65, + NameEnd: 66, + Name: "x", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 67, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 74, + NameEnd: 75, + Name: "x", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH 1 AS x GROUP @{GROUP_METHOD=STREAM_GROUP} BY x RETURN x diff --git a/testdata/result/gql/with_next.sql.txt b/testdata/result/gql/with_next.sql.txt new file mode 100644 index 00000000..d69b37e3 --- /dev/null +++ b/testdata/result/gql/with_next.sql.txt @@ -0,0 +1,84 @@ +--- with_next.sql +GRAPH FinGraph +WITH 1 AS a +RETURN a +NEXT +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 20, + ValueEnd: 21, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 22, + Alias: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "a", + }, + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 27, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 34, + NameEnd: 35, + Name: "a", + }, + }, + }, + }, + }, + }, + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 41, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 48, + NameEnd: 49, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH 1 AS a RETURN a NEXT RETURN a diff --git a/testdata/result/gql/with_star.sql.txt b/testdata/result/gql/with_star.sql.txt new file mode 100644 index 00000000..328ffc52 --- /dev/null +++ b/testdata/result/gql/with_star.sql.txt @@ -0,0 +1,65 @@ +--- with_star.sql +GRAPH FinGraph +LET x = 1 +WITH * +RETURN * + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLLet{ + Let: 15, + Items: []*ast.GQLLetItem{ + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.IntLiteral{ + ValuePos: 23, + ValueEnd: 24, + Base: 10, + Value: "1", + }, + }, + }, + }, + &ast.GQLWith{ + With: 25, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: 30, + }, + }, + }, + &ast.GQLReturn{ + Return: 32, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: 39, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph LET x = 1 WITH * RETURN * diff --git a/testdata/result/statement/complex_linear.sql.txt b/testdata/result/statement/complex_linear.sql.txt new file mode 100644 index 00000000..f2e8be76 --- /dev/null +++ b/testdata/result/statement/complex_linear.sql.txt @@ -0,0 +1,107 @@ +--- complex_linear.sql +GRAPH FinGraph +LET x = 1 +FOR y IN [1, 2] +FILTER WHERE x < y +RETURN y + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLLet{ + Let: 15, + Items: []*ast.GQLLetItem{ + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.IntLiteral{ + ValuePos: 23, + ValueEnd: 24, + Base: 10, + Value: "1", + }, + }, + }, + }, + &ast.GQLFor{ + For: 25, + Ident: &ast.Ident{ + NamePos: 29, + NameEnd: 30, + Name: "y", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 34, + Rbrack: 39, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 35, + ValueEnd: 36, + Base: 10, + Value: "1", + }, + &ast.IntLiteral{ + ValuePos: 38, + ValueEnd: 39, + Base: 10, + Value: "2", + }, + }, + }, + }, + &ast.GQLFilter{ + Filter: 41, + Where: 48, + Expr: &ast.BinaryExpr{ + Op: "<", + Left: &ast.Ident{ + NamePos: 54, + NameEnd: 55, + Name: "x", + }, + Right: &ast.Ident{ + NamePos: 58, + NameEnd: 59, + Name: "y", + }, + }, + }, + &ast.GQLReturn{ + Return: 60, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 67, + NameEnd: 68, + Name: "y", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph LET x = 1 FOR y IN [1, 2] FILTER WHERE x < y RETURN y diff --git a/testdata/result/statement/filter.sql.txt b/testdata/result/statement/filter.sql.txt new file mode 100644 index 00000000..a3a7ba86 --- /dev/null +++ b/testdata/result/statement/filter.sql.txt @@ -0,0 +1,60 @@ +--- filter.sql +GRAPH FinGraph +FILTER a > 1 +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFilter{ + Filter: 15, + Expr: &ast.BinaryExpr{ + Op: ">", + Left: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + Right: &ast.IntLiteral{ + ValuePos: 26, + ValueEnd: 27, + Base: 10, + Value: "1", + }, + }, + }, + &ast.GQLReturn{ + Return: 28, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 35, + NameEnd: 36, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FILTER WHERE a > 1 RETURN a diff --git a/testdata/result/statement/for.sql.txt b/testdata/result/statement/for.sql.txt new file mode 100644 index 00000000..675cea51 --- /dev/null +++ b/testdata/result/statement/for.sql.txt @@ -0,0 +1,76 @@ +--- for.sql +GRAPH FinGraph +FOR x IN [1, 2, 3] +RETURN x + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFor{ + For: 15, + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 24, + Rbrack: 32, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 25, + ValueEnd: 26, + Base: 10, + Value: "1", + }, + &ast.IntLiteral{ + ValuePos: 28, + ValueEnd: 29, + Base: 10, + Value: "2", + }, + &ast.IntLiteral{ + ValuePos: 31, + ValueEnd: 32, + Base: 10, + Value: "3", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 34, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 41, + NameEnd: 42, + Name: "x", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FOR x IN [1, 2, 3] RETURN x diff --git a/testdata/result/statement/for_with_offset.sql.txt b/testdata/result/statement/for_with_offset.sql.txt new file mode 100644 index 00000000..8ae15f9b --- /dev/null +++ b/testdata/result/statement/for_with_offset.sql.txt @@ -0,0 +1,90 @@ +--- for_with_offset.sql +GRAPH FinGraph +FOR x IN [1, 2] WITH OFFSET AS i +RETURN x, i + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFor{ + For: 15, + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 24, + Rbrack: 29, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 25, + ValueEnd: 26, + Base: 10, + Value: "1", + }, + &ast.IntLiteral{ + ValuePos: 28, + ValueEnd: 29, + Base: 10, + Value: "2", + }, + }, + }, + WithOffset: &ast.WithOffset{ + With: 31, + Offset: 36, + As: &ast.AsAlias{ + As: 43, + Alias: &ast.Ident{ + NamePos: 46, + NameEnd: 47, + Name: "i", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 48, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 55, + NameEnd: 56, + Name: "x", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 58, + NameEnd: 59, + Name: "i", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FOR x IN [1, 2] WITH OFFSET AS i RETURN x, i diff --git a/testdata/result/statement/group_hint.sql.txt b/testdata/result/statement/group_hint.sql.txt new file mode 100644 index 00000000..51073f1d --- /dev/null +++ b/testdata/result/statement/group_hint.sql.txt @@ -0,0 +1,84 @@ +--- group_hint.sql +GRAPH FinGraph +RETURN 1 AS x +GROUP @{GROUP_METHOD=STREAM_GROUP} BY x + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 22, + ValueEnd: 23, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 24, + Alias: &ast.Ident{ + NamePos: 27, + NameEnd: 28, + Name: "x", + }, + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 29, + Hint: &ast.Hint{ + Atmark: 35, + Rbrace: 62, + Records: []*ast.HintRecord{ + &ast.HintRecord{ + Key: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 37, + NameEnd: 49, + Name: "GROUP_METHOD", + }, + }, + }, + Value: &ast.Ident{ + NamePos: 50, + NameEnd: 62, + Name: "STREAM_GROUP", + }, + }, + }, + }, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 67, + NameEnd: 68, + Name: "x", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN 1 AS x GROUP @{GROUP_METHOD=STREAM_GROUP} BY x diff --git a/testdata/result/statement/let.sql.txt b/testdata/result/statement/let.sql.txt new file mode 100644 index 00000000..bf36c610 --- /dev/null +++ b/testdata/result/statement/let.sql.txt @@ -0,0 +1,82 @@ +--- let.sql +GRAPH FinGraph +LET x = 1, y = 2 +RETURN x + y + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLLet{ + Let: 15, + Items: []*ast.GQLLetItem{ + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.IntLiteral{ + ValuePos: 23, + ValueEnd: 24, + Base: 10, + Value: "1", + }, + }, + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 26, + NameEnd: 27, + Name: "y", + }, + Expr: &ast.IntLiteral{ + ValuePos: 30, + ValueEnd: 31, + Base: 10, + Value: "2", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 32, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.BinaryExpr{ + Op: "+", + Left: &ast.Ident{ + NamePos: 39, + NameEnd: 40, + Name: "x", + }, + Right: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "y", + }, + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph LET x = 1, y = 2 RETURN x + y diff --git a/testdata/result/statement/limit_offset.sql.txt b/testdata/result/statement/limit_offset.sql.txt new file mode 100644 index 00000000..eb994167 --- /dev/null +++ b/testdata/result/statement/limit_offset.sql.txt @@ -0,0 +1,62 @@ +--- limit_offset.sql +GRAPH FinGraph +RETURN a +OFFSET 5 LIMIT 10 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "OFFSET", + Offset: &ast.IntLiteral{ + ValuePos: 31, + ValueEnd: 32, + Base: 10, + Value: "5", + }, + }, + Limit: &ast.GQLLimit{ + LimitPos: 33, + Limit: &ast.IntLiteral{ + ValuePos: 39, + ValueEnd: 41, + Base: 10, + Value: "10", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a OFFSET 5 LIMIT 10 diff --git a/testdata/result/statement/limit_skip.sql.txt b/testdata/result/statement/limit_skip.sql.txt new file mode 100644 index 00000000..5b9339ae --- /dev/null +++ b/testdata/result/statement/limit_skip.sql.txt @@ -0,0 +1,62 @@ +--- limit_skip.sql +GRAPH FinGraph +RETURN a +SKIP 5 LIMIT 10 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "SKIP", + Offset: &ast.IntLiteral{ + ValuePos: 29, + ValueEnd: 30, + Base: 10, + Value: "5", + }, + }, + Limit: &ast.GQLLimit{ + LimitPos: 31, + Limit: &ast.IntLiteral{ + ValuePos: 37, + ValueEnd: 39, + Base: 10, + Value: "10", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a SKIP 5 LIMIT 10 diff --git a/testdata/result/statement/order_by.sql.txt b/testdata/result/statement/order_by.sql.txt new file mode 100644 index 00000000..e5d90781 --- /dev/null +++ b/testdata/result/statement/order_by.sql.txt @@ -0,0 +1,57 @@ +--- order_by.sql +GRAPH FinGraph +ORDER BY a DESC +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLOrderBy{ + Order: 15, + Items: []*ast.GQLOrderByItem{ + &ast.GQLOrderByItem{ + DirEnd: 30, + Expr: &ast.Ident{ + NamePos: 24, + NameEnd: 25, + Name: "a", + }, + Dir: "DESC", + }, + }, + }, + &ast.GQLReturn{ + Return: 31, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 38, + NameEnd: 39, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph ORDER BY a DESC RETURN a diff --git a/testdata/result/statement/order_by_directions.sql.txt b/testdata/result/statement/order_by_directions.sql.txt new file mode 100644 index 00000000..297ed826 --- /dev/null +++ b/testdata/result/statement/order_by_directions.sql.txt @@ -0,0 +1,119 @@ +--- order_by_directions.sql +GRAPH FinGraph FOR x IN [1] ORDER BY x, x ASC, x DESC, x ASCENDING, x DESCENDING RETURN x AS result + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFor{ + For: 15, + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.ArrayLiteral{ + Array: -1, + Lbrack: 24, + Rbrack: 26, + Values: []ast.Expr{ + &ast.IntLiteral{ + ValuePos: 25, + ValueEnd: 26, + Base: 10, + Value: "1", + }, + }, + }, + }, + &ast.GQLOrderBy{ + Order: 28, + Items: []*ast.GQLOrderByItem{ + &ast.GQLOrderByItem{ + DirEnd: -1, + Expr: &ast.Ident{ + NamePos: 37, + NameEnd: 38, + Name: "x", + }, + }, + &ast.GQLOrderByItem{ + DirEnd: 45, + Expr: &ast.Ident{ + NamePos: 40, + NameEnd: 41, + Name: "x", + }, + Dir: "ASC", + }, + &ast.GQLOrderByItem{ + DirEnd: 53, + Expr: &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "x", + }, + Dir: "DESC", + }, + &ast.GQLOrderByItem{ + DirEnd: 66, + Expr: &ast.Ident{ + NamePos: 55, + NameEnd: 56, + Name: "x", + }, + Dir: "ASC", + }, + &ast.GQLOrderByItem{ + DirEnd: 80, + Expr: &ast.Ident{ + NamePos: 68, + NameEnd: 69, + Name: "x", + }, + Dir: "DESC", + }, + }, + }, + &ast.GQLReturn{ + Return: 81, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 88, + NameEnd: 89, + Name: "x", + }, + Alias: &ast.AsAlias{ + As: 90, + Alias: &ast.Ident{ + NamePos: 93, + NameEnd: 99, + Name: "result", + }, + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FOR x IN [1] ORDER BY x, x ASC, x DESC, x ASC, x DESC RETURN x AS result diff --git a/testdata/result/statement/return_group_by.sql.txt b/testdata/result/statement/return_group_by.sql.txt new file mode 100644 index 00000000..b67e0a66 --- /dev/null +++ b/testdata/result/statement/return_group_by.sql.txt @@ -0,0 +1,61 @@ +--- return_group_by.sql +GRAPH FinGraph +RETURN a, b +GROUP BY a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "b", + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 27, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 36, + NameEnd: 37, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a, b GROUP BY a diff --git a/testdata/result/statement/return_limit_offset.sql.txt b/testdata/result/statement/return_limit_offset.sql.txt new file mode 100644 index 00000000..0268a4de --- /dev/null +++ b/testdata/result/statement/return_limit_offset.sql.txt @@ -0,0 +1,62 @@ +--- return_limit_offset.sql +GRAPH FinGraph +RETURN a +OFFSET 2 LIMIT 1 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "OFFSET", + Offset: &ast.IntLiteral{ + ValuePos: 31, + ValueEnd: 32, + Base: 10, + Value: "2", + }, + }, + Limit: &ast.GQLLimit{ + LimitPos: 33, + Limit: &ast.IntLiteral{ + ValuePos: 39, + ValueEnd: 40, + Base: 10, + Value: "1", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a OFFSET 2 LIMIT 1 diff --git a/testdata/result/statement/return_order_by.sql.txt b/testdata/result/statement/return_order_by.sql.txt new file mode 100644 index 00000000..97f00d91 --- /dev/null +++ b/testdata/result/statement/return_order_by.sql.txt @@ -0,0 +1,57 @@ +--- return_order_by.sql +GRAPH FinGraph +RETURN a +ORDER BY a DESC + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + OrderBy: &ast.GQLOrderBy{ + Order: 24, + Items: []*ast.GQLOrderByItem{ + &ast.GQLOrderByItem{ + DirEnd: 39, + Expr: &ast.Ident{ + NamePos: 33, + NameEnd: 34, + Name: "a", + }, + Dir: "DESC", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a ORDER BY a DESC diff --git a/testdata/result/statement/skip.sql.txt b/testdata/result/statement/skip.sql.txt new file mode 100644 index 00000000..a7c9c17d --- /dev/null +++ b/testdata/result/statement/skip.sql.txt @@ -0,0 +1,53 @@ +--- skip.sql +GRAPH FinGraph +RETURN a +SKIP 5 + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + }, + }, + Offset: &ast.GQLOffset{ + OffsetPos: 24, + Keyword: "SKIP", + Offset: &ast.IntLiteral{ + ValuePos: 29, + ValueEnd: 30, + Base: 10, + Value: "5", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph RETURN a SKIP 5 diff --git a/testdata/result/statement/where.sql.txt b/testdata/result/statement/where.sql.txt new file mode 100644 index 00000000..a3e0306c --- /dev/null +++ b/testdata/result/statement/where.sql.txt @@ -0,0 +1,61 @@ +--- where.sql +GRAPH FinGraph +FILTER WHERE a > 1 +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFilter{ + Filter: 15, + Where: 22, + Expr: &ast.BinaryExpr{ + Op: ">", + Left: &ast.Ident{ + NamePos: 28, + NameEnd: 29, + Name: "a", + }, + Right: &ast.IntLiteral{ + ValuePos: 32, + ValueEnd: 33, + Base: 10, + Value: "1", + }, + }, + }, + &ast.GQLReturn{ + Return: 34, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 41, + NameEnd: 42, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph FILTER WHERE a > 1 RETURN a diff --git a/testdata/result/statement/with.sql.txt b/testdata/result/statement/with.sql.txt new file mode 100644 index 00000000..fec1f9b9 --- /dev/null +++ b/testdata/result/statement/with.sql.txt @@ -0,0 +1,65 @@ +--- with.sql +GRAPH FinGraph +WITH 1 AS a +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 20, + ValueEnd: 21, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 22, + Alias: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "a", + }, + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 27, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 34, + NameEnd: 35, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH 1 AS a RETURN a diff --git a/testdata/result/statement/with_all_distinct.sql.txt b/testdata/result/statement/with_all_distinct.sql.txt new file mode 100644 index 00000000..39799ba6 --- /dev/null +++ b/testdata/result/statement/with_all_distinct.sql.txt @@ -0,0 +1,91 @@ +--- with_all_distinct.sql +GRAPH FinGraph +WITH ALL 1 AS a, 2 AS b +RETURN a, b + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + AllOrDistinct: "ALL", + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 24, + ValueEnd: 25, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 26, + Alias: &ast.Ident{ + NamePos: 29, + NameEnd: 30, + Name: "a", + }, + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 32, + ValueEnd: 33, + Base: 10, + Value: "2", + }, + Alias: &ast.AsAlias{ + As: 34, + Alias: &ast.Ident{ + NamePos: 37, + NameEnd: 38, + Name: "b", + }, + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 39, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 46, + NameEnd: 47, + Name: "a", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 49, + NameEnd: 50, + Name: "b", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH ALL 1 AS a, 2 AS b RETURN a, b diff --git a/testdata/result/statement/with_group_by.sql.txt b/testdata/result/statement/with_group_by.sql.txt new file mode 100644 index 00000000..32ccc5d2 --- /dev/null +++ b/testdata/result/statement/with_group_by.sql.txt @@ -0,0 +1,75 @@ +--- with_group_by.sql +GRAPH FinGraph +WITH a, b +GROUP BY a +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 20, + NameEnd: 21, + Name: "a", + }, + }, + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 23, + NameEnd: 24, + Name: "b", + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 25, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 34, + NameEnd: 35, + Name: "a", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 36, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH a, b GROUP BY a RETURN a diff --git a/testdata/result/statement/with_group_hint.sql.txt b/testdata/result/statement/with_group_hint.sql.txt new file mode 100644 index 00000000..3c6d9a07 --- /dev/null +++ b/testdata/result/statement/with_group_hint.sql.txt @@ -0,0 +1,98 @@ +--- with_group_hint.sql +GRAPH FinGraph +WITH 1 AS x +GROUP @{GROUP_METHOD=STREAM_GROUP} BY x +RETURN x + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 20, + ValueEnd: 21, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 22, + Alias: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "x", + }, + }, + }, + }, + GroupBy: &ast.GroupBy{ + Group: 27, + Hint: &ast.Hint{ + Atmark: 33, + Rbrace: 60, + Records: []*ast.HintRecord{ + &ast.HintRecord{ + Key: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 35, + NameEnd: 47, + Name: "GROUP_METHOD", + }, + }, + }, + Value: &ast.Ident{ + NamePos: 48, + NameEnd: 60, + Name: "STREAM_GROUP", + }, + }, + }, + }, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 65, + NameEnd: 66, + Name: "x", + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 67, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 74, + NameEnd: 75, + Name: "x", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH 1 AS x GROUP @{GROUP_METHOD=STREAM_GROUP} BY x RETURN x diff --git a/testdata/result/statement/with_next.sql.txt b/testdata/result/statement/with_next.sql.txt new file mode 100644 index 00000000..d69b37e3 --- /dev/null +++ b/testdata/result/statement/with_next.sql.txt @@ -0,0 +1,84 @@ +--- with_next.sql +GRAPH FinGraph +WITH 1 AS a +RETURN a +NEXT +RETURN a + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLWith{ + With: 15, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.IntLiteral{ + ValuePos: 20, + ValueEnd: 21, + Base: 10, + Value: "1", + }, + Alias: &ast.AsAlias{ + As: 22, + Alias: &ast.Ident{ + NamePos: 25, + NameEnd: 26, + Name: "a", + }, + }, + }, + }, + }, + &ast.GQLReturn{ + Return: 27, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 34, + NameEnd: 35, + Name: "a", + }, + }, + }, + }, + }, + }, + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturn{ + Return: 41, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: -1, + Expr: &ast.Ident{ + NamePos: 48, + NameEnd: 49, + Name: "a", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph WITH 1 AS a RETURN a NEXT RETURN a diff --git a/testdata/result/statement/with_star.sql.txt b/testdata/result/statement/with_star.sql.txt new file mode 100644 index 00000000..328ffc52 --- /dev/null +++ b/testdata/result/statement/with_star.sql.txt @@ -0,0 +1,65 @@ +--- with_star.sql +GRAPH FinGraph +LET x = 1 +WITH * +RETURN * + +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + }, + }, + Query: &ast.GQLMultiLinearQueryStatement{ + Statements: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + Statements: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLLet{ + Let: 15, + Items: []*ast.GQLLetItem{ + &ast.GQLLetItem{ + Ident: &ast.Ident{ + NamePos: 19, + NameEnd: 20, + Name: "x", + }, + Expr: &ast.IntLiteral{ + ValuePos: 23, + ValueEnd: 24, + Base: 10, + Value: "1", + }, + }, + }, + }, + &ast.GQLWith{ + With: 25, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: 30, + }, + }, + }, + &ast.GQLReturn{ + Return: 32, + Items: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Star: 39, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph LET x = 1 WITH * RETURN *