From 83b3f97f0581dc181dfdb46820b5169a8e771f29 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Fri, 13 Sep 2024 11:45:10 +0900 Subject: [PATCH 01/53] Support GQL LET and RETURN --- ast/gql.go | 180 ++++++++++++++++++++++++++++++++++++++++++++ parser.go | 27 +++++++ parser_gql.go | 88 ++++++++++++++++++++++ tools/parse/main.go | 5 +- 4 files changed, 298 insertions(+), 2 deletions(-) create mode 100644 ast/gql.go create mode 100644 parser_gql.go diff --git a/ast/gql.go b/ast/gql.go new file mode 100644 index 00000000..33b2f93f --- /dev/null +++ b/ast/gql.go @@ -0,0 +1,180 @@ +package ast + +import ( + "fmt" + "github.com/cloudspannerecosystem/memefish/token" +) + +type GqlGraphQuery struct { + GraphClause *GqlGraphClause + GqlMultiLinearQueryStatement *GqlMultiLinearQueryStatement +} + +func (g GqlGraphQuery) Pos() token.Pos { + return g.GraphClause.Pos() +} + +func (g GqlGraphQuery) End() token.Pos { + return g.GqlMultiLinearQueryStatement.End() +} + +func (g GqlGraphQuery) isStatement() {} +func (s *GqlGraphQuery) SQL() string { + return s.GraphClause.SQL() + "\n" + s.GqlMultiLinearQueryStatement.SQL() +} + +type GqlGraphClause struct { + GqlGraph token.Pos + GqlPropertyGraphName *Ident +} + +func (s *GqlGraphClause) Pos() token.Pos { + return s.GqlGraph +} + +func (s *GqlGraphClause) End() token.Pos { + return s.GqlPropertyGraphName.End() +} + +func (s *GqlGraphClause) SQL() string { + return fmt.Sprintf("GRAPH %v", s.GqlPropertyGraphName.SQL()) +} + +type GqlNextStatement struct { + GqlNext *token.Pos +} + +func (s *GqlNextStatement) SQL() string { + return "NEXT" +} + +type GqlMultiLinearQueryStatement struct { + GqlLinearQueryStatements []GqlLinearQueryStatement +} + +func (s *GqlMultiLinearQueryStatement) Pos() token.Pos { + return s.GqlLinearQueryStatements[0].Pos() +} + +func (s *GqlMultiLinearQueryStatement) End() token.Pos { + return s.GqlLinearQueryStatements[len(s.GqlLinearQueryStatements)-1].End() +} + +func (s *GqlMultiLinearQueryStatement) SQL() string { + sql := s.GqlLinearQueryStatements[0].SQL() + for _, r := range s.GqlLinearQueryStatements[1:] { + sql += "\n" + r.SQL() + } + return sql +} + +type GqlLinearQueryStatement interface { + Node + isGqlLinearQueryStatement() +} +type GqlSimpleLinearQueryStatement struct { + PrimitiveQueryStatementList []GqlPrimitiveQueryStatement +} + +func (s *GqlSimpleLinearQueryStatement) Pos() token.Pos { + return firstPos(s.PrimitiveQueryStatementList) +} + +func lastElem[T any](s []T) T { + return s[len(s)-1] +} + +func firstPos[T Node](s []T) token.Pos { + return s[0].Pos() +} + +func lastEnd[T Node](s []T) token.Pos { + return lastElem(s).End() +} + +func (s *GqlSimpleLinearQueryStatement) End() token.Pos { + return lastEnd(s.PrimitiveQueryStatementList) +} + +func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} +func (s *GqlSimpleLinearQueryStatement) SQL() string { + // TODO: list should not be empty + if len(s.PrimitiveQueryStatementList) == 0 { + return "" + } + sql := s.PrimitiveQueryStatementList[0].SQL() + for _, r := range s.PrimitiveQueryStatementList[1:] { + sql += "\n" + r.SQL() + } + return sql +} + +type GqlCompositeLinearQueryStatement struct{} + +func (*GqlCompositeLinearQueryStatement) isGqlLinearQueryStatement() {} + +type GqlPrimitiveQueryStatement interface { + Node + isGqlPrimitiveQueryStatement() +} +type GqlReturnStatement struct { + Return token.Pos + ReturnItemList []SelectItem +} + +func (s *GqlReturnStatement) Pos() token.Pos { + return s.Return +} + +func (s *GqlReturnStatement) End() token.Pos { + return s.ReturnItemList[len(s.ReturnItemList)-1].End() +} + +type GqlLinearGraphVariable struct { + VariableName *Ident + Value Expr +} + +func (s *GqlLinearGraphVariable) Pos() token.Pos { return s.VariableName.Pos() } + +func (s *GqlLinearGraphVariable) End() token.Pos { return s.Value.End() } + +func (s *GqlLinearGraphVariable) SQL() string { + return fmt.Sprintf("%v = %v", s.VariableName.SQL(), s.Value.SQL()) +} + +type GqlLetStatement struct { + Let token.Pos + LinearGraphVariableList []*GqlLinearGraphVariable +} + +func (s *GqlLetStatement) Pos() token.Pos { + return s.Let +} + +func (s *GqlLetStatement) End() token.Pos { + if len(s.LinearGraphVariableList) == 0 { + return s.Let + 3 + } + return s.LinearGraphVariableList[len(s.LinearGraphVariableList)].End() +} + +func (s *GqlLetStatement) SQL() string { + sql := fmt.Sprintf("LET %v", s.LinearGraphVariableList[0].SQL()) + for _, v := range s.LinearGraphVariableList[1:] { + sql += ", " + v.SQL() + } + return sql +} +func (*GqlLetStatement) isGqlPrimitiveQueryStatement() {} + +func (*GqlReturnStatement) isGqlPrimitiveQueryStatement() {} + +func (s *GqlReturnStatement) SQL() string { + sql := "RETURN " + sql += s.ReturnItemList[0].SQL() + for _, r := range s.ReturnItemList[1:] { + sql += ", " + r.SQL() + } + return sql +} diff --git a/parser.go b/parser.go index fb5473c3..e33ef4c6 100644 --- a/parser.go +++ b/parser.go @@ -34,6 +34,27 @@ func (p *Parser) ParseStatement() (stmt ast.Statement, err error) { return } +// ParseGqlStatement parses a GQL statement. +func (p *Parser) ParseGqlStatement() (stmt ast.Statement, err error) { + defer func() { + if r := recover(); r != nil { + stmt = nil + if e, ok := r.(*Error); ok { + err = e + } else { + panic(r) + } + } + }() + + p.nextToken() + stmt = p.parseGqlStatement() + if p.Token.Kind != token.TokenEOF { + p.panicfAtToken(&p.Token, "expected token: , but: %s", p.Token.Kind) + } + return +} + // ParseStatements parses SQL statements list separated by semi-colon. func (p *Parser) ParseStatements() (stmts []ast.Statement, err error) { defer func() { @@ -221,6 +242,12 @@ func (p *Parser) parseStatement() ast.Statement { panic(p.errorfAtToken(&p.Token, "unexpected token: %s", p.Token.Kind)) } +func (p *Parser) parseGqlStatement() ast.Statement { + return p.parseGqlQuery() + + panic(p.errorfAtToken(&p.Token, "unexpected token: %s", p.Token.Kind)) +} + func (p *Parser) parseStatements(doParse func()) { for p.Token.Kind != token.TokenEOF { if p.Token.Kind == ";" { diff --git a/parser_gql.go b/parser_gql.go new file mode 100644 index 00000000..92aab8d7 --- /dev/null +++ b/parser_gql.go @@ -0,0 +1,88 @@ +package memefish + +import ( + "github.com/cloudspannerecosystem/memefish/ast" +) + +// ================================================================================ +// +// GRAPH +// +// ================================================================================ + +func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { + graphClause := p.parseGqlGraphClause() + multiQueryStatement := p.parseGqlMultiLinearQueryStatement() + + return &ast.GqlGraphQuery{GraphClause: graphClause, GqlMultiLinearQueryStatement: multiQueryStatement} +} + +func (p *Parser) parseGqlGraphClause() *ast.GqlGraphClause { + graphPos := p.expectKeywordLike("GRAPH").Pos + graphName := p.parseIdent() + return &ast.GqlGraphClause{ + GqlGraph: graphPos, + GqlPropertyGraphName: graphName, + } +} + +func (p *Parser) parseGqlLinearQueryStatement() ast.GqlLinearQueryStatement { + // TODO process ast.GqlCompositeQueryStatement + return p.parseGqlSimpleLinearQueryStatement() +} + +func (p *Parser) parseGqlSimpleLinearQueryStatement() *ast.GqlSimpleLinearQueryStatement { + var stmts []ast.GqlPrimitiveQueryStatement + for stmt := p.tryParseGqlPrimitiveQueryStatement(); stmt != nil; stmt = p.tryParseGqlPrimitiveQueryStatement() { + stmts = append(stmts, stmt) + } + + return &ast.GqlSimpleLinearQueryStatement{PrimitiveQueryStatementList: stmts} +} + +func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryStatement { + + switch { + case p.Token.IsKeywordLike("RETURN"): + return p.parseGqlReturnStatement() + case p.Token.IsKeywordLike("LET"): + return p.parseGqlLetStatement() + default: + return nil + } +} + +func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { + ret := p.expectKeywordLike("RETURN").Pos + returnItems := p.parseSelectResults() + return &ast.GqlReturnStatement{Return: ret, ReturnItemList: returnItems} +} + +func (p *Parser) parseGqlLinearGraphVariable() *ast.GqlLinearGraphVariable { + name := p.parseIdent() + p.expect("=") + value := p.parseExpr() + + return &ast.GqlLinearGraphVariable{VariableName: name, Value: value} +} + +func (p *Parser) parseGqlLetStatement() *ast.GqlLetStatement { + let := p.expectKeywordLike("LET").Pos + vars := []*ast.GqlLinearGraphVariable{p.parseGqlLinearGraphVariable()} + + for p.Token.Kind == "," { + p.nextToken() + vars = append(vars, p.parseGqlLinearGraphVariable()) + } + + return &ast.GqlLetStatement{Let: let, LinearGraphVariableList: vars} +} + +func (p *Parser) parseGqlMultiLinearQueryStatement() *ast.GqlMultiLinearQueryStatement { + items := []ast.GqlLinearQueryStatement{p.parseGqlLinearQueryStatement()} + for false { + items = append(items, p.parseGqlLinearQueryStatement()) + } + + return &ast.GqlMultiLinearQueryStatement{GqlLinearQueryStatements: items} +} diff --git a/tools/parse/main.go b/tools/parse/main.go index f1aad9af..0e6d3171 100644 --- a/tools/parse/main.go +++ b/tools/parse/main.go @@ -17,7 +17,7 @@ var logging = flag.Bool("logging", false, "enable log") func main() { flag.Parse() if flag.NArg() < 1 { - log.Fatal("usage: ./parse [-mode statement|query|expr|ddl|dml] [-logging] ") + log.Fatal("usage: ./parse [-mode statement|query|expr|ddl|dml|gql] [-logging] ") } query := flag.Arg(0) @@ -43,7 +43,8 @@ func main() { case "ddl": node, err = p.ParseDDL() case "dml": - node, err = p.ParseDML() + case "gql": + node, err = p.ParseGqlStatement() } if err != nil { log.Fatal(err) From 7d5c816e825fdb2d9d0dd6ec491931549c65c164 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Fri, 13 Sep 2024 13:56:09 +0900 Subject: [PATCH 02/53] Experimental GQL MATCH statement support --- ast/gql.go | 32 +++++++ ast/graph_patterns.go | 211 ++++++++++++++++++++++++++++++++++++++++++ parser_gql.go | 73 +++++++++++++++ 3 files changed, 316 insertions(+) create mode 100644 ast/graph_patterns.go diff --git a/ast/gql.go b/ast/gql.go index 33b2f93f..0f2fdcb0 100644 --- a/ast/gql.go +++ b/ast/gql.go @@ -117,6 +117,38 @@ type GqlPrimitiveQueryStatement interface { Node isGqlPrimitiveQueryStatement() } + +type GqlMatchStatement struct { + Optional token.Pos + Match token.Pos + MatchHint *Hint + GraphPattern *GqlGraphPattern +} + +func (g GqlMatchStatement) Pos() token.Pos { + return g.Match +} + +func (g GqlMatchStatement) End() token.Pos { + return g.GraphPattern.Pos() +} + +func (g GqlMatchStatement) SQL() string { + var sql string + if g.Optional >= 0 { + sql = "OPTIONAL MATCH" + } else { + sql = "MATCH" + } + if g.MatchHint != nil { + sql += g.MatchHint.SQL() + } + sql += " " + g.GraphPattern.SQL() + return sql +} + +func (g GqlMatchStatement) isGqlPrimitiveQueryStatement() {} + type GqlReturnStatement struct { Return token.Pos ReturnItemList []SelectItem diff --git a/ast/graph_patterns.go b/ast/graph_patterns.go new file mode 100644 index 00000000..ea6be570 --- /dev/null +++ b/ast/graph_patterns.go @@ -0,0 +1,211 @@ +package ast + +import ( + "fmt" + "github.com/cloudspannerecosystem/memefish/token" +) + +type GqlGraphPattern struct { + PathPatternList []*GqlTopLevelPathPattern + OptionalWhereClause *GqlWhereClause // optional +} + +func (g GqlGraphPattern) Pos() token.Pos { + return firstPos(g.PathPatternList) +} + +func (g GqlGraphPattern) End() token.Pos { + if g.OptionalWhereClause != nil { + return g.OptionalWhereClause.End() + } + return lastEnd(g.PathPatternList) +} + +func (g GqlGraphPattern) SQL() string { + var sql string + if g.OptionalWhereClause != nil { + sql += g.OptionalWhereClause.SQL() + " " + } + sql += g.PathPatternList[0].SQL() + for _, pp := range g.PathPatternList[1:] { + sql += ", " + pp.SQL() + } + return sql +} + +type GqlTopLevelPathPattern struct { + PathSearchPrefixOrPathMode GqlPathSearchPrefixOrPathMode // optional + PathPattern *GqlPathPattern +} + +func (g GqlTopLevelPathPattern) Pos() token.Pos { + if g.PathSearchPrefixOrPathMode != nil { + return g.PathSearchPrefixOrPathMode.Pos() + } + return g.PathPattern.Pos() +} + +func (g GqlTopLevelPathPattern) End() token.Pos { + return g.PathPattern.End() +} + +func (g GqlTopLevelPathPattern) SQL() string { + var sql string + if g.PathSearchPrefixOrPathMode != nil { + sql += g.PathSearchPrefixOrPathMode.SQL() + " " + } + sql += g.PathPattern.SQL() + return sql +} + +// GqlPathSearchPrefixOrPathMode TODO +/* +{ path_search_prefix | path_mode } +*/ +type GqlPathSearchPrefixOrPathMode interface { + Node + isGqlPathSearchPrefixOrPathMode() +} + +type GqlPathPattern struct { + PathTermList []GqlPathTerm +} + +func (g GqlPathPattern) Pos() token.Pos { + return firstPos(g.PathTermList) +} + +func (g GqlPathPattern) End() token.Pos { + return lastEnd(g.PathTermList) +} + +func (g GqlPathPattern) SQL() string { + var sql string + sql += g.PathTermList[0].SQL() + for _, elem := range g.PathTermList[1:] { + sql += elem.SQL() + } + return sql +} + +type GqlPathTerm interface { + Node + isGqlPathTerm() +} + +type GqlWhereClause struct { + Where token.Pos + BoolExpression Expr +} + +func (g GqlWhereClause) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlWhereClause) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlWhereClause) SQL() string { + //TODO implement me + panic("implement me") +} + +func (g GqlWhereClause) isGqlPatternFilterFilter() {} + +type GqlElementPattern interface { + Node + GqlPathTerm + isGqlElementPattern() +} + +type GqlNodePattern struct { + LParen, RParen token.Pos + PatternFilter *GqlPatternFilter +} + +func (g GqlNodePattern) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlNodePattern) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlNodePattern) SQL() string { + var sql string + // TODO PatternFilter + sql += fmt.Sprintf("( )") + return sql +} + +func (g GqlNodePattern) isGqlPathTerm() {} + +// EdgePattern TODO +/* +edge_pattern: + { + full_edge_any | + full_edge_left | + full_edge_right | + abbreviated_edge_any | + abbreviated_edge_left | + abbreviated_edge_right + } +*/ +type EdgePattern interface { + Node + isEdgePattern() +} + +type GqlPatternFilter struct { + GraphPatternVariable *GqlGraphPatternVariable // optional + IsLabelCondition *GqlIsLabelCondition // optional + Filter *GqlPatternFilterFilter // optional +} + +type GqlGraphPatternVariable struct{} +type GqlIsLabelCondition struct { + IsOrColon token.Pos + LabelExpression GqlLabelExpression +} + +// GqlLabelExpression TODO +/* +label_expression: + { + label_name + | or_expression + | and_expression + | not_expression + } +*/ +type GqlLabelExpression interface { + Node + isGqlLabelExpression() +} + +type GqlPatternFilterFilter interface { + Node + isGqlPatternFilterFilter() +} + +type GqlPropertyFilters struct { + LBrace token.Pos + PropertyFilterElemList []*GqlPropertyFilterElem + RBrace token.Pos +} + +type GqlPropertyFilterElem struct { + Name *Ident + Value Expr +} + +type GqlElementProperty struct { + ElementPropertyName *Ident + ElementPropertyValue Expr +} diff --git a/parser_gql.go b/parser_gql.go index 92aab8d7..fc9f73c3 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -2,6 +2,7 @@ package memefish import ( "github.com/cloudspannerecosystem/memefish/ast" + "github.com/cloudspannerecosystem/memefish/token" ) // ================================================================================ @@ -47,11 +48,83 @@ func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryState return p.parseGqlReturnStatement() case p.Token.IsKeywordLike("LET"): return p.parseGqlLetStatement() + case p.Token.IsKeywordLike("OPTIONAL") || p.Token.IsKeywordLike("MATCH"): + return p.parseGqlMatchStatement() default: return nil } } +func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { + var optionalPos token.Pos + if p.Token.IsKeywordLike("OPTIONAL") { + optionalPos = p.Token.Pos + p.nextToken() + } else { + optionalPos = token.InvalidPos + } + + match := p.expectKeywordLike("MATCH").Pos + pattern := p.parseGqlGraphPattern() + return &ast.GqlMatchStatement{Optional: optionalPos, Match: match, GraphPattern: pattern} +} + +func (p *Parser) parseGqlPatternFilter() *ast.GqlPatternFilter { + return &ast.GqlPatternFilter{ + GraphPatternVariable: nil, // TODO + IsLabelCondition: nil, // TODO + Filter: nil, // TODO + } +} + +func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { + lparen := p.expect("(").Pos + filter := p.parseGqlPatternFilter() + rparen := p.expect(")").Pos + return &ast.GqlNodePattern{ + LParen: lparen, + RParen: rparen, + PatternFilter: filter, + } +} +func (p *Parser) parseGqlPathTerm() ast.GqlPathTerm { + // TODO + /* + path_term: + { + element_pattern + | subpath_pattern + } + */ + + return p.parseGqlNodePattern() +} + +func (p *Parser) parseGqlPathPattern() *ast.GqlPathPattern { + list := []ast.GqlPathTerm{p.parseGqlPathTerm()} + return &ast.GqlPathPattern{ + PathTermList: list, + } +} +func (p *Parser) parseGqlTopLevelPathPattern() *ast.GqlTopLevelPathPattern { + pattern := p.parseGqlPathPattern() + return &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, // TODO + PathPattern: pattern, + } +} +func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { + patterns := []*ast.GqlTopLevelPathPattern{p.parseGqlTopLevelPathPattern()} + for p.Token.Kind == "," { + p.nextToken() + patterns = append(patterns, p.parseGqlTopLevelPathPattern()) + } + return &ast.GqlGraphPattern{ + PathPatternList: patterns, + OptionalWhereClause: nil, // TODO + } +} + func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { ret := p.expectKeywordLike("RETURN").Pos returnItems := p.parseSelectResults() From 68ab6abe06fcef3b1a3634d71fb9e6190ea3299d Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Fri, 13 Sep 2024 16:39:13 +0900 Subject: [PATCH 03/53] Improve experiment support of graph patterns --- ast/ast.go | 2 + ast/graph_patterns.go | 388 ++++++++++++++++++++++++++++++++++++++++-- lexer.go | 4 + parser_gql.go | 208 +++++++++++++++++++++- 4 files changed, 577 insertions(+), 25 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index a58895cf..da0be455 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -565,6 +565,8 @@ type Where struct { Expr Expr } +func (w *Where) isGqlPatternFilterFilter() {} + // GroupBy is GROUP BY clause node. // // GROUP BY {{.Exprs | sqlJoin ","}} diff --git a/ast/graph_patterns.go b/ast/graph_patterns.go index ea6be570..1a5df611 100644 --- a/ast/graph_patterns.go +++ b/ast/graph_patterns.go @@ -3,11 +3,12 @@ package ast import ( "fmt" "github.com/cloudspannerecosystem/memefish/token" + "strings" ) type GqlGraphPattern struct { - PathPatternList []*GqlTopLevelPathPattern - OptionalWhereClause *GqlWhereClause // optional + PathPatternList []*GqlTopLevelPathPattern + WhereClause *Where // optional } func (g GqlGraphPattern) Pos() token.Pos { @@ -15,21 +16,21 @@ func (g GqlGraphPattern) Pos() token.Pos { } func (g GqlGraphPattern) End() token.Pos { - if g.OptionalWhereClause != nil { - return g.OptionalWhereClause.End() + if g.WhereClause != nil { + return g.WhereClause.End() } return lastEnd(g.PathPatternList) } func (g GqlGraphPattern) SQL() string { var sql string - if g.OptionalWhereClause != nil { - sql += g.OptionalWhereClause.SQL() + " " - } sql += g.PathPatternList[0].SQL() for _, pp := range g.PathPatternList[1:] { sql += ", " + pp.SQL() } + if g.WhereClause != nil { + sql += " " + g.WhereClause.SQL() + } return sql } @@ -67,6 +68,194 @@ type GqlPathSearchPrefixOrPathMode interface { isGqlPathSearchPrefixOrPathMode() } +type GqlEdgePattern interface { + GqlElementPattern + isGqlEdgePattern() +} + +type GqlFullEdgeAny struct { + PatternFilter *GqlPatternFilter +} + +func (g GqlFullEdgeAny) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeAny) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeAny) SQL() string { + return fmt.Sprintf("-[%v]-", g.PatternFilter.SQL()) +} + +func (g GqlFullEdgeAny) isGqlPathTerm() { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeAny) isGqlElementPattern() { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeAny) isGqlEdgePattern() { + //TODO implement me + panic("implement me") +} + +type GqlFullEdgeLeft struct { + PatternFilter *GqlPatternFilter +} + +func (g GqlFullEdgeLeft) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeLeft) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeLeft) SQL() string { + return fmt.Sprintf("<-[%v]-", g.PatternFilter.SQL()) +} + +func (g GqlFullEdgeLeft) isGqlPathTerm() { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeLeft) isGqlElementPattern() { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeLeft) isGqlEdgePattern() { + //TODO implement me + panic("implement me") +} + +type GqlFullEdgeRight struct { + PatternFilter *GqlPatternFilter +} + +func (g GqlFullEdgeRight) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeRight) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeRight) SQL() string { + return fmt.Sprintf("-[%v]->", g.PatternFilter.SQL()) +} + +func (g GqlFullEdgeRight) isGqlPathTerm() { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeRight) isGqlElementPattern() { + //TODO implement me + panic("implement me") +} + +func (g GqlFullEdgeRight) isGqlEdgePattern() { + //TODO implement me + panic("implement me") +} + +type GqlAbbreviatedEdgeAny struct{} + +func (g GqlAbbreviatedEdgeAny) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeAny) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeAny) SQL() string { + return "-" +} + +func (g GqlAbbreviatedEdgeAny) isGqlPathTerm() { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeAny) isGqlElementPattern() { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeAny) isGqlEdgePattern() { + //TODO implement me + panic("implement me") +} + +type GqlAbbreviatedEdgeLeft struct{} + +func (g GqlAbbreviatedEdgeLeft) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeLeft) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeLeft) SQL() string { + return "<-" +} + +func (g GqlAbbreviatedEdgeLeft) isGqlPathTerm() { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeLeft) isGqlElementPattern() { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeLeft) isGqlEdgePattern() { + //TODO implement me + panic("implement me") +} + +type GqlAbbreviatedEdgeRight struct{} + +func (g GqlAbbreviatedEdgeRight) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeRight) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlAbbreviatedEdgeRight) SQL() string { + return "->" +} + +func (g GqlAbbreviatedEdgeRight) isGqlPathTerm() {} + +func (g GqlAbbreviatedEdgeRight) isGqlElementPattern() {} + +func (g GqlAbbreviatedEdgeRight) isGqlEdgePattern() {} + type GqlPathPattern struct { PathTermList []GqlPathTerm } @@ -121,6 +310,72 @@ type GqlElementPattern interface { isGqlElementPattern() } +type GqlPathModeEnum int + +const ( + GqlPathModeWalk GqlPathModeEnum = iota + GqlPathModeTrail +) + +type GqlPathMode struct { + Mode GqlPathModeEnum +} + +func (g *GqlPathMode) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlPathMode) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlPathMode) SQL() string { + switch g.Mode { + case GqlPathModeTrail: + return "TRAIL" + case GqlPathModeWalk: + return "WALK" + default: + panic("UNKNOWN GqlPathMode") + } +} + +type GqlSubpathPattern struct { + LParen, RParen token.Pos + PathMode *GqlPathMode + PathPattern *GqlPathPattern + WhereClause *Where +} + +func (g GqlSubpathPattern) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlSubpathPattern) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlSubpathPattern) SQL() string { + sql := "(" + if g.PathMode != nil { + sql += g.PathMode.SQL() + " " + } + sql += g.PathPattern.SQL() + if g.WhereClause != nil { + sql += " " + g.WhereClause.SQL() + } + return sql + ")" +} + +func (g GqlSubpathPattern) isGqlPathTerm() { + //TODO implement me + panic("implement me") +} + type GqlNodePattern struct { LParen, RParen token.Pos PatternFilter *GqlPatternFilter @@ -138,8 +393,7 @@ func (g GqlNodePattern) End() token.Pos { func (g GqlNodePattern) SQL() string { var sql string - // TODO PatternFilter - sql += fmt.Sprintf("( )") + sql += fmt.Sprintf("(%v)", g.PatternFilter.SQL()) return sql } @@ -163,17 +417,58 @@ type EdgePattern interface { } type GqlPatternFilter struct { - GraphPatternVariable *GqlGraphPatternVariable // optional - IsLabelCondition *GqlIsLabelCondition // optional - Filter *GqlPatternFilterFilter // optional + GraphPatternVariable *Ident // optional + IsLabelCondition *GqlIsLabelCondition // optional + Filter GqlPatternFilterFilter // optional +} + +func (g GqlPatternFilter) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlPatternFilter) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlPatternFilter) SQL() string { + var sql string + if g.GraphPatternVariable != nil { + sql += g.GraphPatternVariable.SQL() + } + if g.IsLabelCondition != nil { + sql += g.IsLabelCondition.SQL() + } + if g.Filter != nil { + if sql == "" { + sql = g.Filter.SQL() + } else { + sql += " " + g.Filter.SQL() + } + } + return sql } -type GqlGraphPatternVariable struct{} type GqlIsLabelCondition struct { IsOrColon token.Pos LabelExpression GqlLabelExpression } +func (g GqlIsLabelCondition) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlIsLabelCondition) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlIsLabelCondition) SQL() string { + return ":" + g.LabelExpression.SQL() +} + // GqlLabelExpression TODO /* label_expression: @@ -189,6 +484,33 @@ type GqlLabelExpression interface { isGqlLabelExpression() } +type GqlLabelName struct { + IsPercent bool + LabelName *Ident +} + +func (g GqlLabelName) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelName) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelName) SQL() string { + if g.IsPercent { + return "%" + } + return g.LabelName.SQL() +} + +func (g GqlLabelName) isGqlLabelExpression() { + //TODO implement me + panic("implement me") +} + type GqlPatternFilterFilter interface { Node isGqlPatternFilterFilter() @@ -196,16 +518,48 @@ type GqlPatternFilterFilter interface { type GqlPropertyFilters struct { LBrace token.Pos - PropertyFilterElemList []*GqlPropertyFilterElem + PropertyFilterElemList []*GqlElementProperty RBrace token.Pos } -type GqlPropertyFilterElem struct { - Name *Ident - Value Expr +func (g GqlPropertyFilters) Pos() token.Pos { + //TODO implement me + panic("implement me") } +func (g GqlPropertyFilters) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlPropertyFilters) SQL() string { + var elemSqls []string + for _, elem := range g.PropertyFilterElemList { + elemSqls = append(elemSqls, elem.SQL()) + } + + return fmt.Sprintf("{%v}", strings.Join(elemSqls, ", ")) +} + +func (g GqlPropertyFilters) isGqlPatternFilterFilter() {} + type GqlElementProperty struct { ElementPropertyName *Ident ElementPropertyValue Expr } + +func (g GqlElementProperty) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlElementProperty) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlElementProperty) SQL() string { + var sql string + sql += g.ElementPropertyName.SQL() + ": " + g.ElementPropertyValue.SQL() + return sql +} diff --git a/lexer.go b/lexer.go index 7612ce16..5fdc380a 100644 --- a/lexer.go +++ b/lexer.go @@ -167,6 +167,10 @@ func (l *Lexer) consumeToken() { l.Token.Kind = "!=" return } + case ':': + l.skip() + l.Token.Kind = ":" + return case '@': if l.peekOk(1) && char.IsIdentStart(l.peek(1)) { i := 1 diff --git a/parser_gql.go b/parser_gql.go index fc9f73c3..a3f0f613 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -1,6 +1,7 @@ package memefish import ( + "fmt" "github.com/cloudspannerecosystem/memefish/ast" "github.com/cloudspannerecosystem/memefish/token" ) @@ -69,14 +70,74 @@ func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { return &ast.GqlMatchStatement{Optional: optionalPos, Match: match, GraphPattern: pattern} } +func (p *Parser) parseGqlLabelName() *ast.GqlLabelName { + if p.Token.Kind == "%" { + p.nextToken() + return &ast.GqlLabelName{IsPercent: true} + } + return &ast.GqlLabelName{ + IsPercent: false, + LabelName: p.parseIdent(), + } +} + +func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { + // TODO + /* + label_expression: + { + label_name + | or_expression + | and_expression + | not_expression + } + */ + return p.parseGqlLabelName() +} +func (p *Parser) parseGqlIsLabelCondition() *ast.GqlIsLabelCondition { + + pos := p.Token.Pos + p.nextToken() + labelExpr := p.parseGqlLabelExpression() + return &ast.GqlIsLabelCondition{ + IsOrColon: pos, + LabelExpression: labelExpr, + } +} func (p *Parser) parseGqlPatternFilter() *ast.GqlPatternFilter { + var patternVar *ast.Ident + if p.Token.Kind == token.TokenIdent { + patternVar = p.parseIdent() + } + var isLabelCondition *ast.GqlIsLabelCondition + if p.Token.Kind == ":" || p.Token.Kind == "IS" { + isLabelCondition = p.parseGqlIsLabelCondition() + } + + filter := p.tryParseGqlPatternFilterFilter() return &ast.GqlPatternFilter{ - GraphPatternVariable: nil, // TODO - IsLabelCondition: nil, // TODO - Filter: nil, // TODO + GraphPatternVariable: patternVar, // TODO + IsLabelCondition: isLabelCondition, // TODO + Filter: filter, // TODO } } +func (p *Parser) lookaheadGqlSubpathPattern() bool { + lexer := p.Lexer.Clone() + defer func() { + p.Lexer = lexer + }() + + if p.Token.Kind != "(" { + return false + } + p.nextToken() + if p.Token.Kind == "(" || p.Token.Kind == "-" || p.Token.Kind == "<" { + return true + } + return false +} + func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { lparen := p.expect("(").Pos filter := p.parseGqlPatternFilter() @@ -87,7 +148,7 @@ func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { PatternFilter: filter, } } -func (p *Parser) parseGqlPathTerm() ast.GqlPathTerm { +func (p *Parser) tryParseGqlPathTerm() ast.GqlPathTerm { // TODO /* path_term: @@ -97,11 +158,104 @@ func (p *Parser) parseGqlPathTerm() ast.GqlPathTerm { } */ - return p.parseGqlNodePattern() + if p.lookaheadGqlSubpathPattern() { + return p.parseGqlSubPathPattern() + } + if p.Token.Kind == "(" { + return p.parseGqlNodePattern() + } + if p.Token.Kind == "-" || p.Token.Kind == "<" { + return p.parseGqlEdgePattern() + } + return nil +} + +func (p *Parser) tryParseGqlPathMode() *ast.GqlPathMode { + if !p.Token.IsKeywordLike("TRAIL") && !p.Token.IsKeywordLike("WALK") { + return nil + } + var pathMode ast.GqlPathModeEnum + if p.Token.IsKeywordLike("TRAIL") { + p.nextToken() + pathMode = ast.GqlPathModeTrail + } else if p.Token.IsKeywordLike("WALK") { + p.nextToken() + pathMode = ast.GqlPathModeWalk + } + if p.Token.IsKeywordLike("PATH") || p.Token.IsKeywordLike("PATHS") { + p.nextToken() + } + return &ast.GqlPathMode{ + Mode: pathMode, + } + +} +func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { + lparen := p.expect("(").Pos + pathMode := p.tryParseGqlPathMode() + pattern := p.parseGqlPathPattern() + where := p.tryParseWhere() + rparen := p.expect(")").Pos + + return &ast.GqlSubpathPattern{ + LParen: lparen, + RParen: rparen, + PathMode: pathMode, + PathPattern: pattern, + WhereClause: where, + } +} + +func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { + //TODO implement + switch p.Token.Kind { + case "<": + p.nextToken() + p.expect("-") + if p.Token.Kind == "[" { + p.nextToken() + patternFilter := p.parseGqlPatternFilter() + p.expect("]") + p.expect("-") + p.expect("->") + return &ast.GqlFullEdgeLeft{PatternFilter: patternFilter} + } else { + return &ast.GqlAbbreviatedEdgeLeft{} + } + case "-": + p.nextToken() + switch p.Token.Kind { + case ">": + p.nextToken() + return &ast.GqlAbbreviatedEdgeRight{} + case "[": + p.nextToken() + patternFilter := p.parseGqlPatternFilter() + p.expect("]") + p.expect("-") + if p.Token.Kind == ">" { + p.nextToken() + return &ast.GqlFullEdgeRight{PatternFilter: patternFilter} + } + return &ast.GqlFullEdgeAny{PatternFilter: patternFilter} + default: + return &ast.GqlAbbreviatedEdgeAny{} + } + default: + panic(fmt.Sprintf("not implemented kind: %v %v", p.Token.Kind, p.Token.Raw)) + } } func (p *Parser) parseGqlPathPattern() *ast.GqlPathPattern { - list := []ast.GqlPathTerm{p.parseGqlPathTerm()} + // TODO list + list := []ast.GqlPathTerm{p.tryParseGqlPathTerm()} + for p.Token.Kind != ")" && !p.Token.IsKeywordLike("WHERE") { + term := p.tryParseGqlPathTerm() + if term == nil { + break + } + list = append(list, term) + } return &ast.GqlPathPattern{ PathTermList: list, } @@ -113,6 +267,44 @@ func (p *Parser) parseGqlTopLevelPathPattern() *ast.GqlTopLevelPathPattern { PathPattern: pattern, } } + +func (p *Parser) parseGqlElementProperty() *ast.GqlElementProperty { + ident := p.parseIdent() + _ = p.expect(":") + expr := p.parseExpr() + return &ast.GqlElementProperty{ + ElementPropertyName: ident, + ElementPropertyValue: expr, + } +} +func (p *Parser) parseGqlPropertyFilters() *ast.GqlPropertyFilters { + lbrace := p.expect("{").Pos + + elementPropertyList := []*ast.GqlElementProperty{p.parseGqlElementProperty()} + for p.Token.Kind == "," { + p.nextToken() + elementPropertyList = append(elementPropertyList, p.parseGqlElementProperty()) + } + + rbrace := p.expect("}").Pos + return &ast.GqlPropertyFilters{ + LBrace: lbrace, + PropertyFilterElemList: elementPropertyList, + RBrace: rbrace, + } +} + +func (p *Parser) tryParseGqlPatternFilterFilter() ast.GqlPatternFilterFilter { + switch { + case p.Token.Kind == "WHERE": + return p.parseWhere() + case p.Token.Kind == "{": + return p.parseGqlPropertyFilters() + default: + return nil + } +} + func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { patterns := []*ast.GqlTopLevelPathPattern{p.parseGqlTopLevelPathPattern()} for p.Token.Kind == "," { @@ -120,8 +312,8 @@ func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { patterns = append(patterns, p.parseGqlTopLevelPathPattern()) } return &ast.GqlGraphPattern{ - PathPatternList: patterns, - OptionalWhereClause: nil, // TODO + PathPatternList: patterns, + WhereClause: p.tryParseWhere(), // TODO } } From a6cc2886c73e0ea9e9d78fa7155f43a68ee7d94f Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Fri, 13 Sep 2024 17:15:04 +0900 Subject: [PATCH 04/53] Implement GRAPH_TABLE operator --- ast/ast.go | 36 ++++++++++++++++++++++++++++++++++++ parser.go | 17 +++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/ast/ast.go b/ast/ast.go index da0be455..d0999e21 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -734,6 +734,42 @@ type ParenTableExpr struct { Sample *TableSample // optional } +type GraphTableExpr struct { + // pos = GraphTable.Pos + // end = As.end || Rparen + 1 + GraphTable token.Pos + PropertyGraphName *Ident + + Lparen, Rparen token.Pos // position of "(" and ")" + + Query *GqlMultiLinearQueryStatement + As *AsAlias // optional +} + +func (g GraphTableExpr) Pos() token.Pos { + return g.GraphTable +} + +func (g GraphTableExpr) End() token.Pos { + if g.As != nil { + return g.As.End() + } + return g.Rparen + 1 +} + +func (g GraphTableExpr) SQL() string { + sql := "GRAPH_TABLE(\n" + + g.PropertyGraphName.SQL() + "\n" + + g.Query.SQL() + "\n" + + ")" + if g.As != nil { + sql += " " + g.As.SQL() + } + return sql +} + +func (g GraphTableExpr) isTableExpr() {} + // Join is JOIN expression. // // {{.Left | sql}} diff --git a/parser.go b/parser.go index e33ef4c6..fe4f2f48 100644 --- a/parser.go +++ b/parser.go @@ -824,6 +824,23 @@ func (p *Parser) parseSimpleTableExpr() ast.TableExpr { return p.parseUnnestSuffix(false, expr, unnest, rparen) } + if p.Token.IsKeywordLike("GRAPH_TABLE") { + graphTable := p.expectKeywordLike("GRAPH_TABLE").Pos + lparen := p.expect("(").Pos + graphName := p.parseIdent() + query := p.parseGqlMultiLinearQueryStatement() + rparen := p.expect(")").Pos + as := p.tryParseAsAlias() + return &ast.GraphTableExpr{ + GraphTable: graphTable, + PropertyGraphName: graphName, + Lparen: lparen, + Rparen: rparen, + Query: query, + As: as, + } + } + if p.Token.Kind == token.TokenIdent { ids := p.parseIdentOrPath() if len(ids) == 1 { From 9d05bd21670ed907e532174c7000f97331cc3213 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Sat, 14 Sep 2024 00:44:08 +0900 Subject: [PATCH 05/53] Refactor SQL() with list --- ast/gql.go | 209 ++++++++++++++++++++++++++++--- parser_gql.go | 98 +++++++++++++-- testdata/input/query/graph_1.sql | 0 3 files changed, 276 insertions(+), 31 deletions(-) create mode 100644 testdata/input/query/graph_1.sql diff --git a/ast/gql.go b/ast/gql.go index 0f2fdcb0..2d5277f4 100644 --- a/ast/gql.go +++ b/ast/gql.go @@ -61,9 +61,12 @@ func (s *GqlMultiLinearQueryStatement) End() token.Pos { } func (s *GqlMultiLinearQueryStatement) SQL() string { - sql := s.GqlLinearQueryStatements[0].SQL() - for _, r := range s.GqlLinearQueryStatements[1:] { - sql += "\n" + r.SQL() + var sql string + for i, r := range s.GqlLinearQueryStatements { + if i > 0 { + sql += "\nNEXT\n" + } + sql += r.SQL() } return sql } @@ -72,6 +75,7 @@ type GqlLinearQueryStatement interface { Node isGqlLinearQueryStatement() } + type GqlSimpleLinearQueryStatement struct { PrimitiveQueryStatementList []GqlPrimitiveQueryStatement } @@ -98,18 +102,78 @@ func (s *GqlSimpleLinearQueryStatement) End() token.Pos { func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} func (s *GqlSimpleLinearQueryStatement) SQL() string { - // TODO: list should not be empty - if len(s.PrimitiveQueryStatementList) == 0 { - return "" - } - sql := s.PrimitiveQueryStatementList[0].SQL() - for _, r := range s.PrimitiveQueryStatementList[1:] { - sql += "\n" + r.SQL() + var sql string + for i, r := range s.PrimitiveQueryStatementList { + if i > 0 { + sql += "\n" + } + sql += r.SQL() } return sql } -type GqlCompositeLinearQueryStatement struct{} +type GqlAllOrDistinctEnum int + +const ( + GqlAllOrDistinctImplicitAll = iota + GqlAllOrDistinctAll = iota + GqlAllOrDistinctDistinct +) + +type GqlSetOperatorEnum int + +const ( + GqlSetOperatorUnion = iota + GqlSetOperatorIntersect + GqlSetOperatorExcept +) + +type GqlSimpleLinearQueryStatementWithSetOperator struct { + StartPos token.Pos + SetOperator GqlSetOperatorEnum + DistinctOrAll GqlAllOrDistinctEnum + Statement *GqlSimpleLinearQueryStatement +} + +type GqlCompositeLinearQueryStatement struct { + HeadSimpleLinearQueryStatement *GqlSimpleLinearQueryStatement + TailSimpleLinearQueryStatementList []*GqlSimpleLinearQueryStatementWithSetOperator +} + +func (s *GqlCompositeLinearQueryStatement) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (s *GqlCompositeLinearQueryStatement) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (s *GqlCompositeLinearQueryStatement) SQL() string { + var sql string + sql += s.HeadSimpleLinearQueryStatement.SQL() + for _, s := range s.TailSimpleLinearQueryStatementList { + sql += "\n" + switch s.SetOperator { + case GqlSetOperatorUnion: + sql += "UNION" + case GqlSetOperatorIntersect: + sql += "INTERSECT" + case GqlSetOperatorExcept: + sql += "INTERSECT" + } + + switch s.DistinctOrAll { + case GqlAllOrDistinctAll: + sql += " " + "ALL" + case GqlAllOrDistinctDistinct: + sql += " " + "DISTINCT" + } + sql += "\n" + s.Statement.SQL() + } + return sql +} func (*GqlCompositeLinearQueryStatement) isGqlLinearQueryStatement() {} @@ -149,9 +213,94 @@ func (g GqlMatchStatement) SQL() string { func (g GqlMatchStatement) isGqlPrimitiveQueryStatement() {} +type GqlLimitAndOffsetClause interface { + Node + isGqlLimitAndOffsetClause() +} + +// GqlLimitClause is wrapper of Limit for GQL +type GqlLimitClause struct { + Limit *Limit +} + +// GqlOffsetClause is wrapper of Offset for GQL +type GqlOffsetClause struct { + Offset *Offset +} + +func (g GqlOffsetClause) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOffsetClause) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOffsetClause) SQL() string { + //TODO implement me + panic("implement me") +} + +func (g GqlOffsetClause) isGqlLimitAndOffsetClause() { + //TODO implement me + panic("implement me") +} + +// GqlLimitClauseWithOffset +type GqlLimitWithOffsetClause struct { + Limit *Limit + Offset *Offset +} + +func (g GqlLimitWithOffsetClause) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLimitWithOffsetClause) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLimitWithOffsetClause) SQL() string { + //TODO implement me + panic("implement me") +} + +func (g GqlLimitWithOffsetClause) isGqlLimitAndOffsetClause() { + //TODO implement me + panic("implement me") +} + +func (g GqlLimitClause) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLimitClause) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLimitClause) SQL() string { + //TODO implement me + panic("implement me") +} + +func (g GqlLimitClause) isGqlLimitAndOffsetClause() { + //TODO implement me + panic("implement me") +} + type GqlReturnStatement struct { - Return token.Pos - ReturnItemList []SelectItem + AllOrDistinct GqlAllOrDistinctEnum + Return token.Pos + ReturnItemList []SelectItem + GroupByClause *GroupBy + OrderByClause *OrderBy + LimitAndOffsetClause GqlLimitAndOffsetClause } func (s *GqlReturnStatement) Pos() token.Pos { @@ -192,9 +341,12 @@ func (s *GqlLetStatement) End() token.Pos { } func (s *GqlLetStatement) SQL() string { - sql := fmt.Sprintf("LET %v", s.LinearGraphVariableList[0].SQL()) - for _, v := range s.LinearGraphVariableList[1:] { - sql += ", " + v.SQL() + sql := "LET " + for i, v := range s.LinearGraphVariableList { + if i > 0 { + sql += ", " + } + sql += v.SQL() } return sql } @@ -204,9 +356,28 @@ func (*GqlReturnStatement) isGqlPrimitiveQueryStatement() {} func (s *GqlReturnStatement) SQL() string { sql := "RETURN " - sql += s.ReturnItemList[0].SQL() - for _, r := range s.ReturnItemList[1:] { - sql += ", " + r.SQL() + switch s.AllOrDistinct { + case GqlAllOrDistinctAll: + sql += "ALL " + case GqlAllOrDistinctDistinct: + sql += "DISTINCT " + case GqlAllOrDistinctImplicitAll: + // empty + } + for i, r := range s.ReturnItemList { + if i > 0 { + sql += ", " + } + sql += r.SQL() + } + if s.GroupByClause != nil { + sql += " " + s.GroupByClause.SQL() + } + if s.OrderByClause != nil { + sql += " " + s.OrderByClause.SQL() + } + if s.LimitAndOffsetClause != nil { + sql += " " + s.LimitAndOffsetClause.SQL() } return sql } diff --git a/parser_gql.go b/parser_gql.go index a3f0f613..f0f86fc6 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -29,10 +29,54 @@ func (p *Parser) parseGqlGraphClause() *ast.GqlGraphClause { } func (p *Parser) parseGqlLinearQueryStatement() ast.GqlLinearQueryStatement { - // TODO process ast.GqlCompositeQueryStatement - return p.parseGqlSimpleLinearQueryStatement() + stmt := p.parseGqlSimpleLinearQueryStatement() + if p.Token.Kind != ("UNION") && p.Token.Kind != ("EXCEPT") && p.Token.Kind != ("DISTINCT") { + return stmt + } + var tail []*ast.GqlSimpleLinearQueryStatementWithSetOperator + for p.Token.Kind == ("UNION") || p.Token.Kind == ("EXCEPT") || p.Token.Kind == ("DISTINCT") { + tail = append(tail, p.parseGqlSimpleLinearQueryStatementWithSetOperator()) + } + return &ast.GqlCompositeLinearQueryStatement{HeadSimpleLinearQueryStatement: stmt, TailSimpleLinearQueryStatementList: tail} } +func (p *Parser) parseGqlSimpleLinearQueryStatementWithSetOperator() *ast.GqlSimpleLinearQueryStatementWithSetOperator { + pos := p.Token.Pos + var op ast.GqlSetOperatorEnum + switch p.Token.Kind { + case "UNION": + p.nextToken() + op = ast.GqlSetOperatorUnion + case "INTERSECT": + p.nextToken() + op = ast.GqlSetOperatorIntersect + case "EXCEPT": + p.nextToken() + op = ast.GqlSetOperatorExcept + default: + panic("unknown SetOperatorEnum") + } + + var allOrDistinct ast.GqlAllOrDistinctEnum + switch p.Token.Kind { + case "ALL": + p.nextToken() + allOrDistinct = ast.GqlAllOrDistinctAll + case "DISTINCT": + p.nextToken() + allOrDistinct = ast.GqlAllOrDistinctDistinct + default: + panic("unknown SetAllOrDistinct") + } + + stmt := p.parseGqlSimpleLinearQueryStatement() + return &ast.GqlSimpleLinearQueryStatementWithSetOperator{ + StartPos: pos, + SetOperator: op, + DistinctOrAll: allOrDistinct, + Statement: stmt, + } +} func (p *Parser) parseGqlSimpleLinearQueryStatement() *ast.GqlSimpleLinearQueryStatement { var stmts []ast.GqlPrimitiveQueryStatement for stmt := p.tryParseGqlPrimitiveQueryStatement(); stmt != nil; stmt = p.tryParseGqlPrimitiveQueryStatement() { @@ -212,16 +256,14 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { case "<": p.nextToken() p.expect("-") - if p.Token.Kind == "[" { - p.nextToken() - patternFilter := p.parseGqlPatternFilter() - p.expect("]") - p.expect("-") - p.expect("->") - return &ast.GqlFullEdgeLeft{PatternFilter: patternFilter} - } else { + if p.Token.Kind != "[" { return &ast.GqlAbbreviatedEdgeLeft{} } + p.nextToken() + patternFilter := p.parseGqlPatternFilter() + p.expect("]") + p.expect("-") + return &ast.GqlFullEdgeLeft{PatternFilter: patternFilter} case "-": p.nextToken() switch p.Token.Kind { @@ -319,8 +361,39 @@ func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { ret := p.expectKeywordLike("RETURN").Pos + var allOrDistinct ast.GqlAllOrDistinctEnum + switch p.Token.Kind { + case "ALL": + p.nextToken() + allOrDistinct = ast.GqlAllOrDistinctAll + case "DISTINCT": + p.nextToken() + allOrDistinct = ast.GqlAllOrDistinctDistinct + } returnItems := p.parseSelectResults() - return &ast.GqlReturnStatement{Return: ret, ReturnItemList: returnItems} + groupBy := p.tryParseGroupBy() + orderBy := p.tryParseOrderBy() + limit := p.tryParseLimit() + offset := p.tryParseOffset() + var limitAndOffset ast.GqlLimitAndOffsetClause + switch { + case limit != nil && offset != nil: + limitAndOffset = &ast.GqlLimitWithOffsetClause{ + Limit: limit, + Offset: offset, + } + case limit != nil: + limitAndOffset = &ast.GqlLimitClause{Limit: limit} + case offset != nil: + limitAndOffset = &ast.GqlOffsetClause{Offset: offset} + default: + } + return &ast.GqlReturnStatement{Return: ret, + AllOrDistinct: allOrDistinct, + GroupByClause: groupBy, + OrderByClause: orderBy, + LimitAndOffsetClause: limitAndOffset, + ReturnItemList: returnItems} } func (p *Parser) parseGqlLinearGraphVariable() *ast.GqlLinearGraphVariable { @@ -345,7 +418,8 @@ func (p *Parser) parseGqlLetStatement() *ast.GqlLetStatement { func (p *Parser) parseGqlMultiLinearQueryStatement() *ast.GqlMultiLinearQueryStatement { items := []ast.GqlLinearQueryStatement{p.parseGqlLinearQueryStatement()} - for false { + for p.Token.IsKeywordLike("NEXT") { + p.expectKeywordLike("NEXT") items = append(items, p.parseGqlLinearQueryStatement()) } diff --git a/testdata/input/query/graph_1.sql b/testdata/input/query/graph_1.sql new file mode 100644 index 00000000..e69de29b From 602307eab97ec3aca890a3e8b8b474c4e41e2b64 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Sat, 14 Sep 2024 03:30:08 +0900 Subject: [PATCH 06/53] Implement graph patterns --- ast/gql.go | 51 ++-- ast/graph_patterns.go | 243 +++++++++++++++++- go.mod | 2 +- lexer.go | 11 +- parser.go | 21 ++ parser_gql.go | 186 ++++++++++++-- testdata/input/gql_path_pattern/pattern_1.sql | 1 + testdata/input/gql_path_pattern/pattern_2.sql | 1 + testdata/input/query/graph_1.sql | 11 + testdata/input/query/graph_2.sql | 3 + testdata/input/query/graph_3.sql | 3 + testdata/input/query/graph_4.sql | 3 + testdata/input/query/graph_5.sql | 5 + testdata/input/query/graph_6.sql | 3 + testdata/input/query/graph_7.sql | 5 + testdata/input/query/graph_8.sql | 3 + tools/parse/main.go | 2 + 17 files changed, 494 insertions(+), 60 deletions(-) create mode 100644 testdata/input/gql_path_pattern/pattern_1.sql create mode 100644 testdata/input/gql_path_pattern/pattern_2.sql create mode 100644 testdata/input/query/graph_2.sql create mode 100644 testdata/input/query/graph_3.sql create mode 100644 testdata/input/query/graph_4.sql create mode 100644 testdata/input/query/graph_5.sql create mode 100644 testdata/input/query/graph_6.sql create mode 100644 testdata/input/query/graph_7.sql create mode 100644 testdata/input/query/graph_8.sql diff --git a/ast/gql.go b/ast/gql.go index 2d5277f4..0c6f7802 100644 --- a/ast/gql.go +++ b/ast/gql.go @@ -3,6 +3,7 @@ package ast import ( "fmt" "github.com/cloudspannerecosystem/memefish/token" + "strings" ) type GqlGraphQuery struct { @@ -61,14 +62,7 @@ func (s *GqlMultiLinearQueryStatement) End() token.Pos { } func (s *GqlMultiLinearQueryStatement) SQL() string { - var sql string - for i, r := range s.GqlLinearQueryStatements { - if i > 0 { - sql += "\nNEXT\n" - } - sql += r.SQL() - } - return sql + return sqlJoin(s.GqlLinearQueryStatements, "\nNEXT\n") } type GqlLinearQueryStatement interface { @@ -100,16 +94,21 @@ func (s *GqlSimpleLinearQueryStatement) End() token.Pos { return lastEnd(s.PrimitiveQueryStatementList) } -func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} -func (s *GqlSimpleLinearQueryStatement) SQL() string { - var sql string - for i, r := range s.PrimitiveQueryStatementList { +func sqlJoin[T Node](elems []T, sep string) string { + var b strings.Builder + for i, r := range elems { if i > 0 { - sql += "\n" + b.WriteString(sep) } - sql += r.SQL() + b.WriteString(r.SQL()) } - return sql + return b.String() +} + +func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} + +func (s *GqlSimpleLinearQueryStatement) SQL() string { + return sqlJoin(s.PrimitiveQueryStatementList, "\n") } type GqlAllOrDistinctEnum int @@ -186,6 +185,7 @@ type GqlMatchStatement struct { Optional token.Pos Match token.Pos MatchHint *Hint + PrefixOrMode GqlPathSearchPrefixOrPathMode // optional GraphPattern *GqlGraphPattern } @@ -207,6 +207,9 @@ func (g GqlMatchStatement) SQL() string { if g.MatchHint != nil { sql += g.MatchHint.SQL() } + if g.PrefixOrMode != nil { + sql += " " + g.PrefixOrMode.SQL() + } sql += " " + g.GraphPattern.SQL() return sql } @@ -341,14 +344,7 @@ func (s *GqlLetStatement) End() token.Pos { } func (s *GqlLetStatement) SQL() string { - sql := "LET " - for i, v := range s.LinearGraphVariableList { - if i > 0 { - sql += ", " - } - sql += v.SQL() - } - return sql + return "LET " + sqlJoin(s.LinearGraphVariableList, ", ") } func (*GqlLetStatement) isGqlPrimitiveQueryStatement() {} @@ -364,12 +360,9 @@ func (s *GqlReturnStatement) SQL() string { case GqlAllOrDistinctImplicitAll: // empty } - for i, r := range s.ReturnItemList { - if i > 0 { - sql += ", " - } - sql += r.SQL() - } + + sql += sqlJoin(s.ReturnItemList, ", ") + if s.GroupByClause != nil { sql += " " + s.GroupByClause.SQL() } diff --git a/ast/graph_patterns.go b/ast/graph_patterns.go index 1a5df611..f181e310 100644 --- a/ast/graph_patterns.go +++ b/ast/graph_patterns.go @@ -256,8 +256,31 @@ func (g GqlAbbreviatedEdgeRight) isGqlElementPattern() {} func (g GqlAbbreviatedEdgeRight) isGqlEdgePattern() {} +type GqlQuantifiablePathTerm struct { + PathTerm GqlPathTerm + Quantifier GqlQuantifier // optional +} + +func (g GqlQuantifiablePathTerm) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlQuantifiablePathTerm) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlQuantifiablePathTerm) SQL() string { + sql := g.PathTerm.SQL() + if g.Quantifier != nil { + sql += g.Quantifier.SQL() + } + return sql +} + type GqlPathPattern struct { - PathTermList []GqlPathTerm + PathTermList []*GqlQuantifiablePathTerm } func (g GqlPathPattern) Pos() token.Pos { @@ -310,15 +333,22 @@ type GqlElementPattern interface { isGqlElementPattern() } -type GqlPathModeEnum int +type gqlPathModeEnum int const ( - GqlPathModeWalk GqlPathModeEnum = iota + GqlPathModeWalk gqlPathModeEnum = iota GqlPathModeTrail ) type GqlPathMode struct { - Mode GqlPathModeEnum + Mode gqlPathModeEnum + ModeToken *Ident + PathOrPathToken *Ident +} + +func (g *GqlPathMode) isGqlPathSearchPrefixOrPathMode() { + //TODO implement me + panic("implement me") } func (g *GqlPathMode) Pos() token.Pos { @@ -342,6 +372,76 @@ func (g *GqlPathMode) SQL() string { } } +/* + type GqlQuantifiedPathPrimary struct { + PathPrimary + } +*/ +type GqlQuantifier interface { + Node + isGqlQuantifier() +} +type GqlFixedQuantifier struct { + LBrace, RBrace token.Pos + Bound IntValue +} + +func (g GqlFixedQuantifier) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFixedQuantifier) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlFixedQuantifier) SQL() string { + return "{" + g.Bound.SQL() + "}" +} + +func (g GqlFixedQuantifier) isGqlQuantifier() { + //TODO implement me + panic("implement me") +} + +type GqlBoundedQuantifier struct { + LBrace, RBrace token.Pos + LowerBound IntValue // optional + UpperBound IntValue +} + +func (g *GqlBoundedQuantifier) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlBoundedQuantifier) End() token.Pos { + //TODO implement me + panic("implement me") +} + +// requires Go 1.20 +func sqlOpt[T interface { + Node + comparable +}](node T) string { + var zero T + if node == zero { + return "" + } + return node.SQL() +} + +func (g *GqlBoundedQuantifier) SQL() string { + return fmt.Sprintf("{%v,%v}", sqlOpt(g.LowerBound), g.UpperBound.SQL()) +} + +func (g *GqlBoundedQuantifier) isGqlQuantifier() { + //TODO implement me + panic("implement me") +} + type GqlSubpathPattern struct { LParen, RParen token.Pos PathMode *GqlPathMode @@ -484,6 +584,100 @@ type GqlLabelExpression interface { isGqlLabelExpression() } +type GqlLabelOrExpression struct { + Left, Right GqlLabelExpression +} + +type GqlLabelParenExpression struct { + LParen, RParen token.Pos + LabelExpr GqlLabelExpression +} + +func (g GqlLabelParenExpression) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelParenExpression) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelParenExpression) SQL() string { + return "(" + g.LabelExpr.SQL() + ")" +} + +func (g GqlLabelParenExpression) isGqlLabelExpression() { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelOrExpression) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelOrExpression) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelOrExpression) SQL() string { + return g.Left.SQL() + "|" + g.Right.SQL() +} + +func (g GqlLabelOrExpression) isGqlLabelExpression() { + //TODO implement me + panic("implement me") +} + +type GqlLabelAndExpression struct { + Left, Right GqlLabelExpression +} + +func (g GqlLabelAndExpression) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelAndExpression) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelAndExpression) SQL() string { + return g.Left.SQL() + "&" + g.Right.SQL() +} + +func (g GqlLabelAndExpression) isGqlLabelExpression() { + //TODO implement me + panic("implement me") +} + +type GqlLabelNotExpression struct { + NotPos token.Pos + LabelExpression GqlLabelExpression +} + +func (g GqlLabelNotExpression) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelNotExpression) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlLabelNotExpression) SQL() string { + return "!" + g.LabelExpression.SQL() +} + +func (g GqlLabelNotExpression) isGqlLabelExpression() { + //TODO implement me + panic("implement me") +} + type GqlLabelName struct { IsPercent bool LabelName *Ident @@ -563,3 +757,44 @@ func (g GqlElementProperty) SQL() string { sql += g.ElementPropertyName.SQL() + ": " + g.ElementPropertyValue.SQL() return sql } + +type gqlSearchPrefixEnum int + +const ( + GqlPathSearchPrefixAll = iota + GqlPathSearchPrefixAny + GqlPathSearchPrefixAnyShortest +) + +type GqlPathSearchPrefix struct { + StartPos token.Pos + SearchPrefix gqlSearchPrefixEnum +} + +func (p *GqlPathSearchPrefix) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (p *GqlPathSearchPrefix) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (p *GqlPathSearchPrefix) SQL() string { + switch p.SearchPrefix { + case GqlPathSearchPrefixAny: + return "ANY" + case GqlPathSearchPrefixAnyShortest: + return "ANY SHORTEST" + case GqlPathSearchPrefixAll: + return "ALL" + default: + panic("invalid GqlPathSearchPrefix") + } +} + +func (p *GqlPathSearchPrefix) isGqlPathSearchPrefixOrPathMode() { + //TODO implement me + panic("implement me") +} diff --git a/go.mod b/go.mod index cfc62164..3ae33182 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/cloudspannerecosystem/memefish -go 1.19 +go 1.20 require ( github.com/MakeNowJust/heredoc/v2 v2.0.1 diff --git a/lexer.go b/lexer.go index 5fdc380a..23c7e072 100644 --- a/lexer.go +++ b/lexer.go @@ -162,15 +162,24 @@ func (l *Lexer) consumeToken() { } return case '!': - if l.peekIs(1, '=') { + switch { + case l.peekIs(1, '='): l.skipN(2) l.Token.Kind = "!=" return + default: + l.skip() + l.Token.Kind = "!" + return } case ':': l.skip() l.Token.Kind = ":" return + case '%': + l.skip() + l.Token.Kind = "%" + return case '@': if l.peekOk(1) && char.IsIdentStart(l.peek(1)) { i := 1 diff --git a/parser.go b/parser.go index fe4f2f48..57d87860 100644 --- a/parser.go +++ b/parser.go @@ -55,6 +55,27 @@ func (p *Parser) ParseGqlStatement() (stmt ast.Statement, err error) { return } +// ParseGqlStatement parses a GQL statement. +func (p *Parser) ParseGqlPathPattern() (stmt *ast.GqlPathPattern, err error) { + defer func() { + if r := recover(); r != nil { + stmt = nil + if e, ok := r.(*Error); ok { + err = e + } else { + panic(r) + } + } + }() + + p.nextToken() + stmt = p.parseGqlPathPattern() + if p.Token.Kind != token.TokenEOF { + p.panicfAtToken(&p.Token, "expected token: , but: %s", p.Token.Kind) + } + return +} + // ParseStatements parses SQL statements list separated by semi-colon. func (p *Parser) ParseStatements() (stmts []ast.Statement, err error) { defer func() { diff --git a/parser_gql.go b/parser_gql.go index f0f86fc6..7bd809b0 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -100,6 +100,69 @@ func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryState } } +func (p *Parser) tryParseGqlPathModePathOrPaths() *ast.Ident { + switch { + case p.Token.IsKeywordLike("PATH"), p.Token.IsKeywordLike("PATHS"): + return p.parseIdent() + default: + return nil + } +} +func (p *Parser) tryParseGqlPathMode() *ast.GqlPathMode { + switch { + case p.Token.IsKeywordLike("WALK"): + pathModeToken := p.parseIdent() + pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() + return &ast.GqlPathMode{ + ModeToken: pathModeToken, + PathOrPathToken: pathOrPathsToken, + Mode: ast.GqlPathModeWalk, + } + + case p.Token.IsKeywordLike("TRAIL"): + pathModeToken := p.parseIdent() + pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() + return &ast.GqlPathMode{ + ModeToken: pathModeToken, + PathOrPathToken: pathOrPathsToken, + Mode: ast.GqlPathModeTrail, + } + default: + return nil + } +} +func (p *Parser) tryParseGqlPathSearchPrefixOrPathMode() ast.GqlPathSearchPrefixOrPathMode { + startPos := p.Token.Pos + switch { + case p.Token.Kind == "ALL": + p.nextToken() + return &ast.GqlPathSearchPrefix{ + StartPos: startPos, + SearchPrefix: ast.GqlPathSearchPrefixAll, + } + case p.Token.Kind == "ANY": + p.nextToken() + if p.Token.IsKeywordLike("SHORTEST") { + p.nextToken() + return &ast.GqlPathSearchPrefix{ + StartPos: startPos, + SearchPrefix: ast.GqlPathSearchPrefixAnyShortest, + } + } else { + return &ast.GqlPathSearchPrefix{ + StartPos: startPos, + SearchPrefix: ast.GqlPathSearchPrefixAny, + } + } + default: + if pathMode := p.tryParseGqlPathMode(); pathMode != nil { + return pathMode + } + return nil + } + +} + func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { var optionalPos token.Pos if p.Token.IsKeywordLike("OPTIONAL") { @@ -110,8 +173,10 @@ func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { } match := p.expectKeywordLike("MATCH").Pos + // var prefixOrMode ast.GqlPathSearchPrefixOrPathMode = nil // p.tryParseGqlPathSearchPrefixOrPathMode() + var prefixOrMode ast.GqlPathSearchPrefixOrPathMode = p.tryParseGqlPathSearchPrefixOrPathMode() pattern := p.parseGqlGraphPattern() - return &ast.GqlMatchStatement{Optional: optionalPos, Match: match, GraphPattern: pattern} + return &ast.GqlMatchStatement{Optional: optionalPos, Match: match, PrefixOrMode: prefixOrMode, GraphPattern: pattern} } func (p *Parser) parseGqlLabelName() *ast.GqlLabelName { @@ -136,7 +201,50 @@ func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { | not_expression } */ - return p.parseGqlLabelName() + var labelTerm ast.GqlLabelExpression + switch { + case p.Token.Kind == "!": + notPos := p.expect("!").Pos + expr := p.parseGqlLabelExpression() + labelTerm = &ast.GqlLabelNotExpression{NotPos: notPos, LabelExpression: expr} + case p.Token.Kind == "(": + lparen := p.expect("(").Pos + expr := p.parseGqlLabelExpression() + rparen := p.expect(")").Pos + labelTerm = &ast.GqlLabelParenExpression{ + LParen: lparen, + RParen: rparen, + LabelExpr: expr, + } + + /* + default: + p.panicfAtToken(&p.Token, "expected token: '|' or '&', but: %v", p.Token.Kind) + return nil // must not be reached + */ + case p.Token.Kind == token.TokenIdent || p.Token.Kind == "%": + labelTerm = p.parseGqlLabelName() + default: + p.panicfAtToken(&p.Token, `expected token: ",", "(", or "", but: %v`, p.Token.Kind) + return nil + } + switch { + case p.Token.Kind == "|": + p.nextToken() + right := p.parseGqlLabelExpression() + return &ast.GqlLabelOrExpression{ + Left: labelTerm, + Right: right, + } + case p.Token.Kind == "&": + p.nextToken() + right := p.parseGqlLabelExpression() + return &ast.GqlLabelAndExpression{ + Left: labelTerm, + Right: right, + } + } + return labelTerm } func (p *Parser) parseGqlIsLabelCondition() *ast.GqlIsLabelCondition { @@ -176,7 +284,7 @@ func (p *Parser) lookaheadGqlSubpathPattern() bool { return false } p.nextToken() - if p.Token.Kind == "(" || p.Token.Kind == "-" || p.Token.Kind == "<" { + if p.Token.Kind == "(" || p.Token.Kind == "-" || p.Token.Kind == "<" || p.Token.IsKeywordLike("WALK") || p.Token.IsKeywordLike("TRAIL") { return true } return false @@ -192,6 +300,54 @@ func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { PatternFilter: filter, } } + +func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { + if p.Token.Kind != "{" { + return nil + } + lbrace := p.expect("{").Pos + if p.Token.Kind == "," { + upperBound := p.parseIntValue() + rbrace := p.expect("}").Pos + return &ast.GqlBoundedQuantifier{ + LBrace: lbrace, + RBrace: rbrace, + UpperBound: upperBound, + } + } + bound := p.parseIntValue() + if p.Token.Kind != "," { + rbrace := p.expect("}").Pos + return &ast.GqlFixedQuantifier{ + LBrace: lbrace, + RBrace: rbrace, + Bound: bound, + } + } + p.expect(",") + upperBound := p.parseIntValue() + rbrace := p.expect("}").Pos + + return &ast.GqlBoundedQuantifier{ + LBrace: lbrace, + RBrace: rbrace, + LowerBound: bound, + UpperBound: upperBound, + } +} + +func (p *Parser) tryParseGqlQuantifiablePathTerm() *ast.GqlQuantifiablePathTerm { + pt := p.tryParseGqlPathTerm() + if pt == nil { + return nil + } + q := p.tryParseGqlQuantifier() + return &ast.GqlQuantifiablePathTerm{ + PathTerm: pt, + Quantifier: q, + } +} + func (p *Parser) tryParseGqlPathTerm() ast.GqlPathTerm { // TODO /* @@ -214,26 +370,6 @@ func (p *Parser) tryParseGqlPathTerm() ast.GqlPathTerm { return nil } -func (p *Parser) tryParseGqlPathMode() *ast.GqlPathMode { - if !p.Token.IsKeywordLike("TRAIL") && !p.Token.IsKeywordLike("WALK") { - return nil - } - var pathMode ast.GqlPathModeEnum - if p.Token.IsKeywordLike("TRAIL") { - p.nextToken() - pathMode = ast.GqlPathModeTrail - } else if p.Token.IsKeywordLike("WALK") { - p.nextToken() - pathMode = ast.GqlPathModeWalk - } - if p.Token.IsKeywordLike("PATH") || p.Token.IsKeywordLike("PATHS") { - p.nextToken() - } - return &ast.GqlPathMode{ - Mode: pathMode, - } - -} func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { lparen := p.expect("(").Pos pathMode := p.tryParseGqlPathMode() @@ -290,9 +426,9 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { func (p *Parser) parseGqlPathPattern() *ast.GqlPathPattern { // TODO list - list := []ast.GqlPathTerm{p.tryParseGqlPathTerm()} + list := []*ast.GqlQuantifiablePathTerm{p.tryParseGqlQuantifiablePathTerm()} for p.Token.Kind != ")" && !p.Token.IsKeywordLike("WHERE") { - term := p.tryParseGqlPathTerm() + term := p.tryParseGqlQuantifiablePathTerm() if term == nil { break } diff --git a/testdata/input/gql_path_pattern/pattern_1.sql b/testdata/input/gql_path_pattern/pattern_1.sql new file mode 100644 index 00000000..887d8101 --- /dev/null +++ b/testdata/input/gql_path_pattern/pattern_1.sql @@ -0,0 +1 @@ +(p:%) diff --git a/testdata/input/gql_path_pattern/pattern_2.sql b/testdata/input/gql_path_pattern/pattern_2.sql new file mode 100644 index 00000000..c61bf65b --- /dev/null +++ b/testdata/input/gql_path_pattern/pattern_2.sql @@ -0,0 +1 @@ +(p:(Singer|(!Writer&!Producer))) diff --git a/testdata/input/query/graph_1.sql b/testdata/input/query/graph_1.sql index e69de29b..06dc5160 100644 --- a/testdata/input/query/graph_1.sql +++ b/testdata/input/query/graph_1.sql @@ -0,0 +1,11 @@ +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers +GROUP BY account + +NEXT + +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN + account.id AS account_id, owner.name AS owner_name, + num_incoming_transfers \ No newline at end of file diff --git a/testdata/input/query/graph_2.sql b/testdata/input/query/graph_2.sql new file mode 100644 index 00000000..5a477ceb --- /dev/null +++ b/testdata/input/query/graph_2.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +MATCH (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account) +RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id \ No newline at end of file diff --git a/testdata/input/query/graph_3.sql b/testdata/input/query/graph_3.sql new file mode 100644 index 00000000..f5bfa49d --- /dev/null +++ b/testdata/input/query/graph_3.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +MATCH (n:Person|Account) +RETURN n.id, n.name, n.nick_name \ No newline at end of file diff --git a/testdata/input/query/graph_4.sql b/testdata/input/query/graph_4.sql new file mode 100644 index 00000000..0c8d5b6f --- /dev/null +++ b/testdata/input/query/graph_4.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +MATCH (n:Person|Account) +RETURN n.id \ No newline at end of file diff --git a/testdata/input/query/graph_5.sql b/testdata/input/query/graph_5.sql new file mode 100644 index 00000000..b21ee225 --- /dev/null +++ b/testdata/input/query/graph_5.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +MATCH ANY SHORTEST (a:Account)-[t:Transfers]->{1, 4} (b:Account) +WHERE a.is_blocked +LET total = SUM(t.amount) +RETURN a.id AS a_id, total, b.id AS b_id \ No newline at end of file diff --git a/testdata/input/query/graph_6.sql b/testdata/input/query/graph_6.sql new file mode 100644 index 00000000..92ee4af4 --- /dev/null +++ b/testdata/input/query/graph_6.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +MATCH TRAIL (WALK (a1:Account)-[t1:Transfers]->{4}(a5:Account)) +RETURN COUNT(1) as num_paths \ No newline at end of file diff --git a/testdata/input/query/graph_7.sql b/testdata/input/query/graph_7.sql new file mode 100644 index 00000000..fa4972dd --- /dev/null +++ b/testdata/input/query/graph_7.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +MATCH + (TRAIL (a1:Account)-[t1:Transfers]->{3}(a4:Account)) + -[t4:Transfers]->(a5:Account) +RETURN COUNT(1) as num_paths \ No newline at end of file diff --git a/testdata/input/query/graph_8.sql b/testdata/input/query/graph_8.sql new file mode 100644 index 00000000..ac557334 --- /dev/null +++ b/testdata/input/query/graph_8.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +MATCH ANY SHORTEST (TRAIL ->{1,4}) +RETURN COUNT(1) as num_paths \ No newline at end of file diff --git a/tools/parse/main.go b/tools/parse/main.go index 0e6d3171..c3f502fb 100644 --- a/tools/parse/main.go +++ b/tools/parse/main.go @@ -45,6 +45,8 @@ func main() { case "dml": case "gql": node, err = p.ParseGqlStatement() + case "gql_path_pattern": + node, err = p.ParseGqlPathPattern() } if err != nil { log.Fatal(err) From 54353ea0e4033cc715135ad2f84952a1191c9e70 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Sat, 14 Sep 2024 12:36:48 +0900 Subject: [PATCH 07/53] Support FILTER, ORDER BY, LIMIT, SKIP/OFFSET, FOR, WITH statements --- ast/gql.go | 255 ++++++++++++++++- parser_gql.go | 261 ++++++++++++++++-- testdata/input/gql/filter.sql | 4 + testdata/input/gql/filter_where.sql | 4 + testdata/input/gql/for.sql | 5 + testdata/input/gql/for_as_offset_name.sql | 4 + testdata/input/gql/graph_hints_between.sql | 6 + testdata/input/gql/graph_hints_match.sql | 4 + .../input/gql/graph_hints_traversal_hint.sql | 6 + testdata/input/gql/let.sql | 4 + testdata/input/gql/limit.sql | 5 + testdata/input/gql/match.sql | 3 + testdata/input/gql/match_optional.sql | 4 + testdata/input/gql/next.sql | 18 ++ testdata/input/gql/offset_1.sql | 4 + testdata/input/gql/order_by.sql | 5 + testdata/input/gql/return.sql | 10 + testdata/input/gql/skip_1.sql | 4 + testdata/input/gql/with_1.sql | 4 + testdata/input/gql_path_pattern/pattern_1.sql | 2 +- testdata/input/gql_path_pattern/pattern_2.sql | 2 +- 21 files changed, 581 insertions(+), 33 deletions(-) create mode 100644 testdata/input/gql/filter.sql create mode 100644 testdata/input/gql/filter_where.sql create mode 100644 testdata/input/gql/for.sql create mode 100644 testdata/input/gql/for_as_offset_name.sql create mode 100644 testdata/input/gql/graph_hints_between.sql create mode 100644 testdata/input/gql/graph_hints_match.sql create mode 100644 testdata/input/gql/graph_hints_traversal_hint.sql create mode 100644 testdata/input/gql/let.sql create mode 100644 testdata/input/gql/limit.sql create mode 100644 testdata/input/gql/match.sql create mode 100644 testdata/input/gql/match_optional.sql create mode 100644 testdata/input/gql/next.sql create mode 100644 testdata/input/gql/offset_1.sql create mode 100644 testdata/input/gql/order_by.sql create mode 100644 testdata/input/gql/return.sql create mode 100644 testdata/input/gql/skip_1.sql create mode 100644 testdata/input/gql/with_1.sql diff --git a/ast/gql.go b/ast/gql.go index 0c6f7802..7296e2b5 100644 --- a/ast/gql.go +++ b/ast/gql.go @@ -199,7 +199,7 @@ func (g GqlMatchStatement) End() token.Pos { func (g GqlMatchStatement) SQL() string { var sql string - if g.Optional >= 0 { + if g.Optional != token.InvalidPos { sql = "OPTIONAL MATCH" } else { sql = "MATCH" @@ -297,12 +297,252 @@ func (g GqlLimitClause) isGqlLimitAndOffsetClause() { panic("implement me") } +type GqlFilterStatement struct { + Filter token.Pos + Where token.Pos + Expr Expr +} + +func (g *GqlFilterStatement) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlFilterStatement) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlFilterStatement) SQL() string { + if g.Where != token.InvalidPos { + return "FILTER WHERE " + g.Expr.SQL() + } + return "FILTER " + g.Expr.SQL() +} + +func (g *GqlFilterStatement) isGqlPrimitiveQueryStatement() { + //TODO implement me + panic("implement me") +} + +type GqlForStatement struct { + For token.Pos + ElementName *Ident + ArrayExpression Expr + WithOffsetClause *GqlWithOffsetClause +} + +func (g GqlForStatement) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlForStatement) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlForStatement) SQL() string { + return "FOR " + g.ElementName.SQL() + " IN " + g.ArrayExpression.SQL() + sqlOpt(" ", g.WithOffsetClause, "") +} + +func (g GqlForStatement) isGqlPrimitiveQueryStatement() { + //TODO implement me + panic("implement me") +} + +type GqlLimitStatement struct { + Limit token.Pos + Count IntValue +} + +func (g *GqlLimitStatement) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlLimitStatement) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlLimitStatement) SQL() string { + return "LIMIT " + g.Count.SQL() +} + +func (g *GqlLimitStatement) isGqlPrimitiveQueryStatement() { + //TODO implement me + panic("implement me") +} + +/* OFFSET/SKIP statement */ + +// GqlOffsetStatement represents OFFSET statement. +// It also represents SKIP statement as the synonym. +type GqlOffsetStatement struct { + // pos = Offset.pos + // end = Count.end + Offset token.Pos + IsSkip bool + Count IntValue +} + +func (g GqlOffsetStatement) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOffsetStatement) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOffsetStatement) SQL() string { + if g.IsSkip { + return "SKIP " + g.Count.SQL() + } + return "OFFSET " + g.Count.SQL() +} + +func (g GqlOffsetStatement) isGqlPrimitiveQueryStatement() { + //TODO implement me + panic("implement me") +} + +type GqlOrderByStatement struct { + Order token.Pos + OrderBySpecificationList []*GqlOrderBySpecification +} + +func (g GqlOrderByStatement) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOrderByStatement) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOrderByStatement) SQL() string { + return "ORDER BY " + sqlJoin(g.OrderBySpecificationList, ", ") +} + +func (g GqlOrderByStatement) isGqlPrimitiveQueryStatement() { + //TODO implement me + panic("implement me") +} + +type GqlDirection string + +const ( + GqlSortOrderUnspecified = "" + GqlSortOrderAsc = "ASC" + GqlSortOrderAscending = "ASCENDING" + GqlSortOrderDesc = "DESC" + GqlSortOrderDescending = "DESCENDING" +) + +// TODO +type GqlOrderBySpecification struct { + Expr Expr + // TODO + // CollationSpecification *GqlCollationSpecification + DirectionPos token.Pos + Direction GqlDirection +} + +func (g GqlOrderBySpecification) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOrderBySpecification) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlOrderBySpecification) SQL() string { + sql := g.Expr.SQL() + if g.Direction != GqlSortOrderUnspecified { + sql += " " + string(g.Direction) + } + return sql +} + +type GqlWithStatement struct { + With token.Pos + AllOrDistinct GqlAllOrDistinctEnum + ReturnItemList []GqlReturnItem + GroupByClause *GroupBy // optional +} + +func (g GqlWithStatement) Pos() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlWithStatement) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g GqlWithStatement) SQL() string { + var allOrDistinctStr string + switch g.AllOrDistinct { + case GqlAllOrDistinctDistinct: + allOrDistinctStr = "DISTINCT " + case GqlAllOrDistinctAll: + allOrDistinctStr = "ALL " + case GqlAllOrDistinctImplicitAll: + allOrDistinctStr = "" + } + return "WITH " + allOrDistinctStr + sqlJoin(g.ReturnItemList, ", ") + sqlOpt(" ", g.GroupByClause, "") +} + +func (g GqlWithStatement) isGqlPrimitiveQueryStatement() { + //TODO implement me + panic("implement me") +} + +type GqlWithOffsetClause struct { + // pos = With.pos + // end = OffsetName.end ?? Offset + 6 + With token.Pos + Offset token.Pos + OffsetName *Ident +} + +func (g *GqlWithOffsetClause) Pos() token.Pos { + return g.With +} + +func (g *GqlWithOffsetClause) End() token.Pos { + if g.OffsetName != nil { + return g.OffsetName.End() + } + return g.Offset + 6 +} + +func (g *GqlWithOffsetClause) SQL() string { + return "WITH OFFSET" + sqlOpt(" AS ", g.OffsetName, "") +} + +// GqlReturnItem is similar to SelectItem, +// but it don't permit DotStar and AsAlias without AS. +type GqlReturnItem SelectItem + type GqlReturnStatement struct { - AllOrDistinct GqlAllOrDistinctEnum - Return token.Pos - ReturnItemList []SelectItem - GroupByClause *GroupBy - OrderByClause *OrderBy + AllOrDistinct GqlAllOrDistinctEnum + Return token.Pos + ReturnItemList []GqlReturnItem + + // Use GoogleSQL GroupBy because it is referenced in docs + GroupByClause *GroupBy //optional + + // Use GoogleSQL OrderBy because it is referenced in docs + OrderByClause *OrderBy //optional + LimitAndOffsetClause GqlLimitAndOffsetClause } @@ -328,6 +568,9 @@ func (s *GqlLinearGraphVariable) SQL() string { } type GqlLetStatement struct { + // pos = Let.pos + // end = LinearGraphVariableList[$].end + Let token.Pos LinearGraphVariableList []*GqlLinearGraphVariable } diff --git a/parser_gql.go b/parser_gql.go index 7bd809b0..98a504c1 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -57,16 +57,9 @@ func (p *Parser) parseGqlSimpleLinearQueryStatementWithSetOperator() *ast.GqlSim panic("unknown SetOperatorEnum") } - var allOrDistinct ast.GqlAllOrDistinctEnum - switch p.Token.Kind { - case "ALL": - p.nextToken() - allOrDistinct = ast.GqlAllOrDistinctAll - case "DISTINCT": - p.nextToken() - allOrDistinct = ast.GqlAllOrDistinctDistinct - default: - panic("unknown SetAllOrDistinct") + allOrDistinct := p.tryParseGqlAllOrDistinctEnum() + if allOrDistinct == ast.GqlAllOrDistinctImplicitAll { + p.panicfAtToken(&p.Token, `expect "ALL" or "DISTINCT, but: %v`, p.Token.Kind) } stmt := p.parseGqlSimpleLinearQueryStatement() @@ -86,15 +79,182 @@ func (p *Parser) parseGqlSimpleLinearQueryStatement() *ast.GqlSimpleLinearQueryS return &ast.GqlSimpleLinearQueryStatement{PrimitiveQueryStatementList: stmts} } -func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryStatement { +func (p *Parser) tryParseGqlWithOffsetClause() *ast.GqlWithOffsetClause { + if p.Token.Kind != "WITH" { + return nil + } + with := p.expect("WITH").Pos + offset := p.expectKeywordLike("OFFSET").Pos + var offsetName *ast.Ident + if p.Token.Kind == "AS" { + p.nextToken() + offsetName = p.parseIdent() + } + + return &ast.GqlWithOffsetClause{ + With: with, + Offset: offset, + OffsetName: offsetName, + } +} + +func (p *Parser) parseGqlForStatement() *ast.GqlForStatement { + forPos := p.expect("FOR").Pos + name := p.parseIdent() + p.expect("IN") + expr := p.parseExpr() + + withOffset := p.tryParseGqlWithOffsetClause() + + return &ast.GqlForStatement{ + For: forPos, + ElementName: name, + ArrayExpression: expr, + WithOffsetClause: withOffset, + } +} + +func (p *Parser) tryParseGqlOrderBySpecificationList() []*ast.GqlOrderBySpecification { + var list []*ast.GqlOrderBySpecification + for { + expr := p.parseExpr() + var direction ast.GqlDirection + directionPos := p.Token.Pos + switch { + case p.Token.Kind == "ASC": + p.nextToken() + direction = ast.GqlSortOrderAsc + case p.Token.Kind == "DESC": + p.nextToken() + direction = ast.GqlSortOrderDesc + case p.Token.Kind == "ASCENDING": + p.nextToken() + direction = ast.GqlSortOrderAscending + case p.Token.Kind == "DESCENDING": + p.nextToken() + direction = ast.GqlSortOrderDescending + default: + directionPos = token.InvalidPos + } + list = append(list, &ast.GqlOrderBySpecification{Expr: expr, DirectionPos: directionPos, Direction: direction}) + if p.Token.Kind != "," { + break + } + } + return list +} + +func (p *Parser) parseGqlOrderByStatement() *ast.GqlOrderByStatement { + order := p.expect("ORDER").Pos + p.expect("BY") + spec := p.tryParseGqlOrderBySpecificationList() + if spec == nil { + p.panicfAtToken(&p.Token, "expect at least one order_by_specification") + } + + return &ast.GqlOrderByStatement{ + Order: order, + OrderBySpecificationList: spec, + } +} + +func (p *Parser) parseGqlLimitStatement() *ast.GqlLimitStatement { + limit := p.expect("LIMIT").Pos + expr := p.parseIntValue() + + return &ast.GqlLimitStatement{ + Limit: limit, + Count: expr, + } +} + +func (p *Parser) parseGqlFilterStatement() *ast.GqlFilterStatement { + filter := p.expectKeywordLike("FILTER").Pos + where := token.InvalidPos + if p.Token.Kind == "WHERE" { + where = p.expect("WHERE").Pos + } + expr := p.parseExpr() + + return &ast.GqlFilterStatement{ + Filter: filter, + Where: where, + Expr: expr, + } +} + +func (p *Parser) parseGqlOffsetStatement() *ast.GqlOffsetStatement { + var pos token.Pos + var isSkip bool + switch { + case p.Token.IsKeywordLike("OFFSET"): + pos = p.expectKeywordLike("OFFSET").Pos + case p.Token.IsKeywordLike("SKIP"): + pos = p.expectKeywordLike("SKIP").Pos + isSkip = true + default: + p.panicfAtToken(&p.Token, `expected "OFFSET" or "SKIP", but: %v`, p.Token.Kind) + } + count := p.parseIntValue() + + return &ast.GqlOffsetStatement{ + Offset: pos, + IsSkip: isSkip, + Count: count, + } +} + +func (p *Parser) parseGqlReturnItem() ast.GqlReturnItem { + if p.Token.Kind == "*" { + pos := p.expect("*").Pos + return &ast.Star{ + Star: pos, + } + } + + expr := p.parseExpr() + if p.Token.Kind == "AS" { + if as := p.tryParseAsAlias(); as != nil { + return &ast.Alias{ + Expr: expr, + As: as, + } + } + } + + return &ast.ExprSelectItem{ + Expr: expr, + } +} + +func (p *Parser) tryParseAsAliasAsMandatory() *ast.AsAlias { + if p.Token.Kind != "AS" { + return nil + } + return p.tryParseAsAlias() +} + +func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryStatement { switch { case p.Token.IsKeywordLike("RETURN"): return p.parseGqlReturnStatement() case p.Token.IsKeywordLike("LET"): return p.parseGqlLetStatement() + case p.Token.IsKeywordLike("FILTER"): + return p.parseGqlFilterStatement() + case p.Token.Kind == "ORDER": + return p.parseGqlOrderByStatement() + case p.Token.Kind == "LIMIT": + return p.parseGqlLimitStatement() + case p.Token.IsKeywordLike("SKIP"), p.Token.IsKeywordLike("OFFSET"): + return p.parseGqlOffsetStatement() + case p.Token.Kind == "FOR": + return p.parseGqlForStatement() case p.Token.IsKeywordLike("OPTIONAL") || p.Token.IsKeywordLike("MATCH"): return p.parseGqlMatchStatement() + case p.Token.Kind == "WITH": + return p.parseGqlWithStatement() default: return nil } @@ -173,10 +333,16 @@ func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { } match := p.expectKeywordLike("MATCH").Pos - // var prefixOrMode ast.GqlPathSearchPrefixOrPathMode = nil // p.tryParseGqlPathSearchPrefixOrPathMode() - var prefixOrMode ast.GqlPathSearchPrefixOrPathMode = p.tryParseGqlPathSearchPrefixOrPathMode() + hint := p.tryParseHint() + var prefixOrMode = p.tryParseGqlPathSearchPrefixOrPathMode() pattern := p.parseGqlGraphPattern() - return &ast.GqlMatchStatement{Optional: optionalPos, Match: match, PrefixOrMode: prefixOrMode, GraphPattern: pattern} + return &ast.GqlMatchStatement{ + Optional: optionalPos, + Match: match, + MatchHint: hint, + PrefixOrMode: prefixOrMode, + GraphPattern: pattern, + } } func (p *Parser) parseGqlLabelName() *ast.GqlLabelName { @@ -257,6 +423,7 @@ func (p *Parser) parseGqlIsLabelCondition() *ast.GqlIsLabelCondition { } } func (p *Parser) parseGqlPatternFilter() *ast.GqlPatternFilter { + hint := p.tryParseHint() var patternVar *ast.Ident if p.Token.Kind == token.TokenIdent { patternVar = p.parseIdent() @@ -268,6 +435,7 @@ func (p *Parser) parseGqlPatternFilter() *ast.GqlPatternFilter { filter := p.tryParseGqlPatternFilterFilter() return &ast.GqlPatternFilter{ + Hint: hint, GraphPatternVariable: patternVar, // TODO IsLabelCondition: isLabelCondition, // TODO Filter: filter, // TODO @@ -337,12 +505,14 @@ func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { } func (p *Parser) tryParseGqlQuantifiablePathTerm() *ast.GqlQuantifiablePathTerm { + hint := p.tryParseHint() pt := p.tryParseGqlPathTerm() if pt == nil { return nil } q := p.tryParseGqlQuantifier() return &ast.GqlQuantifiablePathTerm{ + Hint: hint, PathTerm: pt, Quantifier: q, } @@ -425,7 +595,6 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { } func (p *Parser) parseGqlPathPattern() *ast.GqlPathPattern { - // TODO list list := []*ast.GqlQuantifiablePathTerm{p.tryParseGqlQuantifiablePathTerm()} for p.Token.Kind != ")" && !p.Token.IsKeywordLike("WHERE") { term := p.tryParseGqlQuantifiablePathTerm() @@ -495,18 +664,22 @@ func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { } } +/* +*** +GQL statements +*** +*/ + +/* +*** +GQL RETURN statement +*** +*/ func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { ret := p.expectKeywordLike("RETURN").Pos - var allOrDistinct ast.GqlAllOrDistinctEnum - switch p.Token.Kind { - case "ALL": - p.nextToken() - allOrDistinct = ast.GqlAllOrDistinctAll - case "DISTINCT": - p.nextToken() - allOrDistinct = ast.GqlAllOrDistinctDistinct - } - returnItems := p.parseSelectResults() + + allOrDistinct := p.tryParseGqlAllOrDistinctEnum() + returnItems := p.parseGqlReturnItemList() groupBy := p.tryParseGroupBy() orderBy := p.tryParseOrderBy() limit := p.tryParseLimit() @@ -532,6 +705,44 @@ func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { ReturnItemList: returnItems} } +func (p *Parser) parseGqlReturnItemList() []ast.GqlReturnItem { + var results []ast.GqlReturnItem + for { + results = append(results, p.parseGqlReturnItem()) + if p.Token.Kind != "," { + break + } + p.nextToken() + } + return results +} + +func (p *Parser) tryParseGqlAllOrDistinctEnum() ast.GqlAllOrDistinctEnum { + switch p.Token.Kind { + case "ALL": + p.nextToken() + return ast.GqlAllOrDistinctAll + case "DISTINCT": + p.nextToken() + return ast.GqlAllOrDistinctDistinct + default: + return ast.GqlAllOrDistinctImplicitAll + } +} + +func (p *Parser) parseGqlWithStatement() *ast.GqlWithStatement { + with := p.expect("WITH").Pos + allOrDistinct := p.tryParseGqlAllOrDistinctEnum() + returnItems := p.parseGqlReturnItemList() + groupBy := p.tryParseGroupBy() + + return &ast.GqlWithStatement{ + With: with, + AllOrDistinct: allOrDistinct, + GroupByClause: groupBy, + ReturnItemList: returnItems} +} + func (p *Parser) parseGqlLinearGraphVariable() *ast.GqlLinearGraphVariable { name := p.parseIdent() p.expect("=") diff --git a/testdata/input/gql/filter.sql b/testdata/input/gql/filter.sql new file mode 100644 index 00000000..25401d31 --- /dev/null +++ b/testdata/input/gql/filter.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FILTER p.birthday < '1990-01-10' +RETURN p.name \ No newline at end of file diff --git a/testdata/input/gql/filter_where.sql b/testdata/input/gql/filter_where.sql new file mode 100644 index 00000000..fba49536 --- /dev/null +++ b/testdata/input/gql/filter_where.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FILTER WHERE p.birthday < '1990-01-10' +RETURN p.name \ No newline at end of file diff --git a/testdata/input/gql/for.sql b/testdata/input/gql/for.sql new file mode 100644 index 00000000..985c2d8a --- /dev/null +++ b/testdata/input/gql/for.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FOR element in ["all","some"] WITH OFFSET +RETURN p.name, element as alert_type, offset +ORDER BY p.name, element, offset diff --git a/testdata/input/gql/for_as_offset_name.sql b/testdata/input/gql/for_as_offset_name.sql new file mode 100644 index 00000000..2af7067d --- /dev/null +++ b/testdata/input/gql/for_as_offset_name.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (p:Person) +FOR element in [] WITH OFFSET AS off +RETURN p.name, element, off \ No newline at end of file diff --git a/testdata/input/gql/graph_hints_between.sql b/testdata/input/gql/graph_hints_between.sql new file mode 100644 index 00000000..3ba24047 --- /dev/null +++ b/testdata/input/gql/graph_hints_between.sql @@ -0,0 +1,6 @@ +GRAPH FinGraph +MATCH + (p:Person {id: 1})-[e:Owns]-> + @{JOIN_METHOD=APPLY_JOIN} + ((a:Account)-[s:Transfers]->(oa:Account)) +RETURN oa.id \ No newline at end of file diff --git a/testdata/input/gql/graph_hints_match.sql b/testdata/input/gql/graph_hints_match.sql new file mode 100644 index 00000000..376c3d92 --- /dev/null +++ b/testdata/input/gql/graph_hints_match.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (p:Person {id: 1})-[:Owns]->(a:Account) +MATCH @{JOIN_METHOD=APPLY_JOIN}(a:Account)-[e:Transfers]->(oa:Account) +RETURN oa.id \ No newline at end of file diff --git a/testdata/input/gql/graph_hints_traversal_hint.sql b/testdata/input/gql/graph_hints_traversal_hint.sql new file mode 100644 index 00000000..fd7a62eb --- /dev/null +++ b/testdata/input/gql/graph_hints_traversal_hint.sql @@ -0,0 +1,6 @@ +GRAPH FinGraph +MATCH + (p:Person {id: 1})-[:Owns]->(a:Account), -- path pattern 1 + @{JOIN_METHOD=HASH_JOIN, HASH_JOIN_BUILD_SIDE=BUILD_RIGHT} -- traversal hint + (a:Account)-[e:Transfers]->(c:Account) -- path pattern 2 +RETURN c.id \ No newline at end of file diff --git a/testdata/input/gql/let.sql b/testdata/input/gql/let.sql new file mode 100644 index 00000000..ab4931d9 --- /dev/null +++ b/testdata/input/gql/let.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (source:Account)-[e:Transfers]->(destination:Account) +LET a = source +RETURN a.id AS a_id \ No newline at end of file diff --git a/testdata/input/gql/limit.sql b/testdata/input/gql/limit.sql new file mode 100644 index 00000000..69697528 --- /dev/null +++ b/testdata/input/gql/limit.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +MATCH (source:Account)-[e:Transfers]->(destination:Account) +ORDER BY source.nick_name +LIMIT 3 +RETURN source.nick_name \ No newline at end of file diff --git a/testdata/input/gql/match.sql b/testdata/input/gql/match.sql new file mode 100644 index 00000000..f790065c --- /dev/null +++ b/testdata/input/gql/match.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +MATCH (p:Person) +RETURN p.name, p.id \ No newline at end of file diff --git a/testdata/input/gql/match_optional.sql b/testdata/input/gql/match_optional.sql new file mode 100644 index 00000000..4a5007e0 --- /dev/null +++ b/testdata/input/gql/match_optional.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (n:Person) +OPTIONAL MATCH (n:Person)-[:Owns]->(a:Account {is_blocked: TRUE}) +RETURN n.name, a.id AS blocked_account_id \ No newline at end of file diff --git a/testdata/input/gql/next.sql b/testdata/input/gql/next.sql new file mode 100644 index 00000000..94ce2ef0 --- /dev/null +++ b/testdata/input/gql/next.sql @@ -0,0 +1,18 @@ +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers +GROUP BY account + +NEXT + +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN + account.id AS account_id, owner.name AS owner_name, + num_incoming_transfers + +NEXT + +FILTER num_incoming_transfers < 2 +RETURN account_id, owner_name +UNION ALL +RETURN "Bob" AS owner_name, 100 AS account_id \ No newline at end of file diff --git a/testdata/input/gql/offset_1.sql b/testdata/input/gql/offset_1.sql new file mode 100644 index 00000000..030a421a --- /dev/null +++ b/testdata/input/gql/offset_1.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (p:Person) +OFFSET 2 +RETURN p.name, p.id \ No newline at end of file diff --git a/testdata/input/gql/order_by.sql b/testdata/input/gql/order_by.sql new file mode 100644 index 00000000..beb2098b --- /dev/null +++ b/testdata/input/gql/order_by.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account) +ORDER BY transfer.amount DESC +LIMIT 3 +RETURN src_account.id AS account_id, transfer.amount AS transfer_amount \ No newline at end of file diff --git a/testdata/input/gql/return.sql b/testdata/input/gql/return.sql new file mode 100644 index 00000000..2b4d6f4a --- /dev/null +++ b/testdata/input/gql/return.sql @@ -0,0 +1,10 @@ +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers +GROUP BY account + +NEXT + +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN owner.name AS owner_name, num_incoming_transfers +ORDER BY num_incoming_transfers DESC \ No newline at end of file diff --git a/testdata/input/gql/skip_1.sql b/testdata/input/gql/skip_1.sql new file mode 100644 index 00000000..a5fb230d --- /dev/null +++ b/testdata/input/gql/skip_1.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (p:Person) +SKIP 2 +RETURN p.name, p.id \ No newline at end of file diff --git a/testdata/input/gql/with_1.sql b/testdata/input/gql/with_1.sql new file mode 100644 index 00000000..cee54218 --- /dev/null +++ b/testdata/input/gql/with_1.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +WITH account, COUNT(*) AS num_incoming_transfers GROUP BY account +RETURN account.id AS account_id, num_incoming_transfers \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/pattern_1.sql b/testdata/input/gql_path_pattern/pattern_1.sql index 887d8101..5eec94ff 100644 --- a/testdata/input/gql_path_pattern/pattern_1.sql +++ b/testdata/input/gql_path_pattern/pattern_1.sql @@ -1 +1 @@ -(p:%) +(p:%) \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/pattern_2.sql b/testdata/input/gql_path_pattern/pattern_2.sql index c61bf65b..8f2deb47 100644 --- a/testdata/input/gql_path_pattern/pattern_2.sql +++ b/testdata/input/gql_path_pattern/pattern_2.sql @@ -1 +1 @@ -(p:(Singer|(!Writer&!Producer))) +(p:(Singer|(!Writer&!Producer))) \ No newline at end of file From 7d4d49ab94e0c251bad07ceed2dc5d67928e5ca7 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Sun, 15 Sep 2024 05:05:27 +0900 Subject: [PATCH 08/53] Clean up lexer.go --- lexer.go | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/lexer.go b/lexer.go index 23c7e072..73dd36b9 100644 --- a/lexer.go +++ b/lexer.go @@ -109,7 +109,7 @@ func (l *Lexer) consumeToken() { } switch l.peek(0) { - case '(', ')', '{', '}', ';', ',', '[', ']', '~', '*', '/', '&', '^', '=', '+', '-': + case '(', ')', '{', '}', ';', ',', '[', ']', '~', '*', '/', '&', '^', '=', '+', '-', '%', ':': l.Token.Kind = token.TokenKind([]byte{l.skip()}) return case '.': @@ -172,14 +172,6 @@ func (l *Lexer) consumeToken() { l.Token.Kind = "!" return } - case ':': - l.skip() - l.Token.Kind = ":" - return - case '%': - l.skip() - l.Token.Kind = "%" - return case '@': if l.peekOk(1) && char.IsIdentStart(l.peek(1)) { i := 1 From 17dfe7eb7beb7c6eff50c689640d0a2900787afc Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 07:12:50 +0900 Subject: [PATCH 09/53] Add GRAPH as a top level statement --- parser.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/parser.go b/parser.go index 57d87860..2e62b647 100644 --- a/parser.go +++ b/parser.go @@ -258,6 +258,10 @@ func (p *Parser) parseStatement() ast.Statement { return p.parseDDL() case p.Token.IsKeywordLike("INSERT") || p.Token.IsKeywordLike("DELETE") || p.Token.IsKeywordLike("UPDATE"): return p.parseDML() + // GQL queries are first level statements + // because it is supported by Cloud Spanner's ExecuteSql API. + case p.Token.IsKeywordLike("GRAPH"): + return p.parseGqlStatement() } panic(p.errorfAtToken(&p.Token, "unexpected token: %s", p.Token.Kind)) From e925a5a38443f28bc8d16d443cc4501022ced603 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 07:14:23 +0900 Subject: [PATCH 10/53] Implement some Pos(), End(), Sql() --- ast/ast_test.go | 2 + ast/graph_patterns.go | 172 ++++++++++++++++-------------------------- ast/util.go | 18 +++++ parser_gql.go | 23 ++++-- parser_test.go | 18 +++++ 5 files changed, 119 insertions(+), 114 deletions(-) create mode 100644 ast/util.go diff --git a/ast/ast_test.go b/ast/ast_test.go index e3ab0b70..4265cd08 100644 --- a/ast/ast_test.go +++ b/ast/ast_test.go @@ -23,6 +23,8 @@ func TestStatement(t *testing.T) { Statement(&Update{}).isStatement() Statement(&Grant{}).isStatement() Statement(&Revoke{}).isStatement() + + Statement(&GqlGraphQuery{}).isStatement() } func TestQueryExpr(t *testing.T) { diff --git a/ast/graph_patterns.go b/ast/graph_patterns.go index f181e310..3b54bdab 100644 --- a/ast/graph_patterns.go +++ b/ast/graph_patterns.go @@ -7,6 +7,8 @@ import ( ) type GqlGraphPattern struct { + // pos = GqlTopLevelPathPattern[0].pos + // end = (WhereClause ?? PathPatternList[$]).end PathPatternList []*GqlTopLevelPathPattern WhereClause *Where // optional } @@ -23,18 +25,12 @@ func (g GqlGraphPattern) End() token.Pos { } func (g GqlGraphPattern) SQL() string { - var sql string - sql += g.PathPatternList[0].SQL() - for _, pp := range g.PathPatternList[1:] { - sql += ", " + pp.SQL() - } - if g.WhereClause != nil { - sql += " " + g.WhereClause.SQL() - } - return sql + return sqlJoin(g.PathPatternList, ", ") + sqlOpt(" ", g.WhereClause, "") } type GqlTopLevelPathPattern struct { + // pos = (PathSearchPrefixOrPathMode ?? PathPattern).pos + // end = PathPattern.end PathSearchPrefixOrPathMode GqlPathSearchPrefixOrPathMode // optional PathPattern *GqlPathPattern } @@ -51,18 +47,9 @@ func (g GqlTopLevelPathPattern) End() token.Pos { } func (g GqlTopLevelPathPattern) SQL() string { - var sql string - if g.PathSearchPrefixOrPathMode != nil { - sql += g.PathSearchPrefixOrPathMode.SQL() + " " - } - sql += g.PathPattern.SQL() - return sql + return sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() } -// GqlPathSearchPrefixOrPathMode TODO -/* -{ path_search_prefix | path_mode } -*/ type GqlPathSearchPrefixOrPathMode interface { Node isGqlPathSearchPrefixOrPathMode() @@ -74,103 +61,79 @@ type GqlEdgePattern interface { } type GqlFullEdgeAny struct { + // pos = First.pos + // end = Last.pos + 1 + First, Last token.Pos PatternFilter *GqlPatternFilter } func (g GqlFullEdgeAny) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.First } func (g GqlFullEdgeAny) End() token.Pos { - //TODO implement me - panic("implement me") + return g.Last + 1 } func (g GqlFullEdgeAny) SQL() string { return fmt.Sprintf("-[%v]-", g.PatternFilter.SQL()) } -func (g GqlFullEdgeAny) isGqlPathTerm() { - //TODO implement me - panic("implement me") -} - -func (g GqlFullEdgeAny) isGqlElementPattern() { - //TODO implement me - panic("implement me") -} - -func (g GqlFullEdgeAny) isGqlEdgePattern() { - //TODO implement me - panic("implement me") -} +func (g GqlFullEdgeAny) isGqlPathTerm() {} +func (g GqlFullEdgeAny) isGqlElementPattern() {} +func (g GqlFullEdgeAny) isGqlEdgePattern() {} type GqlFullEdgeLeft struct { + // pos = First + // end = Last + 1 + First token.Pos // position of "<" + Last token.Pos // position of the last "-" PatternFilter *GqlPatternFilter } func (g GqlFullEdgeLeft) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.First } func (g GqlFullEdgeLeft) End() token.Pos { - //TODO implement me - panic("implement me") + return g.Last + 1 } func (g GqlFullEdgeLeft) SQL() string { return fmt.Sprintf("<-[%v]-", g.PatternFilter.SQL()) } -func (g GqlFullEdgeLeft) isGqlPathTerm() { - //TODO implement me - panic("implement me") -} +func (g GqlFullEdgeLeft) isGqlPathTerm() {} -func (g GqlFullEdgeLeft) isGqlElementPattern() { - //TODO implement me - panic("implement me") -} +func (g GqlFullEdgeLeft) isGqlElementPattern() {} -func (g GqlFullEdgeLeft) isGqlEdgePattern() { - //TODO implement me - panic("implement me") -} +func (g GqlFullEdgeLeft) isGqlEdgePattern() {} type GqlFullEdgeRight struct { + // pos = First + // end = Last + 1 + First token.Pos // position of the first "-" + Last token.Pos // position of ">" PatternFilter *GqlPatternFilter } func (g GqlFullEdgeRight) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.First } func (g GqlFullEdgeRight) End() token.Pos { - //TODO implement me - panic("implement me") + return g.Last + 1 } func (g GqlFullEdgeRight) SQL() string { return fmt.Sprintf("-[%v]->", g.PatternFilter.SQL()) } -func (g GqlFullEdgeRight) isGqlPathTerm() { - //TODO implement me - panic("implement me") -} +func (g GqlFullEdgeRight) isGqlPathTerm() {} -func (g GqlFullEdgeRight) isGqlElementPattern() { - //TODO implement me - panic("implement me") -} +func (g GqlFullEdgeRight) isGqlElementPattern() {} -func (g GqlFullEdgeRight) isGqlEdgePattern() { - //TODO implement me - panic("implement me") -} +func (g GqlFullEdgeRight) isGqlEdgePattern() {} type GqlAbbreviatedEdgeAny struct{} @@ -234,7 +197,12 @@ func (g GqlAbbreviatedEdgeLeft) isGqlEdgePattern() { panic("implement me") } -type GqlAbbreviatedEdgeRight struct{} +type GqlAbbreviatedEdgeRight struct { + // pos = First + // end = Last + 1 + First token.Pos // position of "-" + Last token.Pos // position of ">" +} func (g GqlAbbreviatedEdgeRight) Pos() token.Pos { //TODO implement me @@ -257,6 +225,7 @@ func (g GqlAbbreviatedEdgeRight) isGqlElementPattern() {} func (g GqlAbbreviatedEdgeRight) isGqlEdgePattern() {} type GqlQuantifiablePathTerm struct { + Hint *Hint // optional PathTerm GqlPathTerm Quantifier GqlQuantifier // optional } @@ -272,7 +241,9 @@ func (g GqlQuantifiablePathTerm) End() token.Pos { } func (g GqlQuantifiablePathTerm) SQL() string { - sql := g.PathTerm.SQL() + var sql string + sql += sqlOpt("", g.Hint, "") + sql += g.PathTerm.SQL() if g.Quantifier != nil { sql += g.Quantifier.SQL() } @@ -406,43 +377,31 @@ func (g GqlFixedQuantifier) isGqlQuantifier() { } type GqlBoundedQuantifier struct { + // pos = LBrace + // end = RBrace + 1 LBrace, RBrace token.Pos LowerBound IntValue // optional UpperBound IntValue } func (g *GqlBoundedQuantifier) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.LBrace } func (g *GqlBoundedQuantifier) End() token.Pos { - //TODO implement me - panic("implement me") -} - -// requires Go 1.20 -func sqlOpt[T interface { - Node - comparable -}](node T) string { - var zero T - if node == zero { - return "" - } - return node.SQL() + return g.RBrace + 1 } func (g *GqlBoundedQuantifier) SQL() string { - return fmt.Sprintf("{%v,%v}", sqlOpt(g.LowerBound), g.UpperBound.SQL()) + return fmt.Sprintf("{%v,%v}", sqlOpt("", g.LowerBound, ""), g.UpperBound.SQL()) } func (g *GqlBoundedQuantifier) isGqlQuantifier() { - //TODO implement me - panic("implement me") } type GqlSubpathPattern struct { + // pos = LParen + // end = RParen + 1 LParen, RParen token.Pos PathMode *GqlPathMode PathPattern *GqlPathPattern @@ -450,30 +409,22 @@ type GqlSubpathPattern struct { } func (g GqlSubpathPattern) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.LParen } func (g GqlSubpathPattern) End() token.Pos { - //TODO implement me - panic("implement me") + return g.RParen + 1 } func (g GqlSubpathPattern) SQL() string { - sql := "(" - if g.PathMode != nil { - sql += g.PathMode.SQL() + " " - } - sql += g.PathPattern.SQL() - if g.WhereClause != nil { - sql += " " + g.WhereClause.SQL() - } - return sql + ")" + return "(" + + sqlOpt("", g.PathMode, " ") + + g.PathPattern.SQL() + + sqlOpt(" ", g.WhereClause, "") + + ")" } func (g GqlSubpathPattern) isGqlPathTerm() { - //TODO implement me - panic("implement me") } type GqlNodePattern struct { @@ -511,12 +462,17 @@ edge_pattern: abbreviated_edge_right } */ +/* type EdgePattern interface { Node isEdgePattern() } +*/ + type GqlPatternFilter struct { + // Hint is graph element hint which is a table hint. + Hint *Hint GraphPatternVariable *Ident // optional IsLabelCondition *GqlIsLabelCondition // optional Filter GqlPatternFilterFilter // optional @@ -534,6 +490,7 @@ func (g GqlPatternFilter) End() token.Pos { func (g GqlPatternFilter) SQL() string { var sql string + sql += sqlOpt("", g.Hint, "") if g.GraphPatternVariable != nil { sql += g.GraphPatternVariable.SQL() } @@ -794,7 +751,4 @@ func (p *GqlPathSearchPrefix) SQL() string { } } -func (p *GqlPathSearchPrefix) isGqlPathSearchPrefixOrPathMode() { - //TODO implement me - panic("implement me") -} +func (p *GqlPathSearchPrefix) isGqlPathSearchPrefixOrPathMode() {} diff --git a/ast/util.go b/ast/util.go new file mode 100644 index 00000000..374161b9 --- /dev/null +++ b/ast/util.go @@ -0,0 +1,18 @@ +package ast + +// sqlOpt output: +// +// when node != nil: left + node.SQL() + right +// when node == nil: empty string +// +// requires Go 1.20 +func sqlOpt[T interface { + Node + comparable +}](left string, node T, right string) string { + var zero T + if node == zero { + return "" + } + return left + node.SQL() + right +} diff --git a/parser_gql.go b/parser_gql.go index 98a504c1..e183dc69 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -558,6 +558,7 @@ func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { //TODO implement + firstPos := p.Token.Pos switch p.Token.Kind { case "<": p.nextToken() @@ -574,18 +575,30 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { p.nextToken() switch p.Token.Kind { case ">": - p.nextToken() - return &ast.GqlAbbreviatedEdgeRight{} + lastPos := p.expect(">").Pos + return &ast.GqlAbbreviatedEdgeRight{ + First: firstPos, + Last: lastPos, + } case "[": p.nextToken() patternFilter := p.parseGqlPatternFilter() p.expect("]") - p.expect("-") + lastHyphenPos := p.expect("-").Pos if p.Token.Kind == ">" { + lastPos := p.Token.Pos p.nextToken() - return &ast.GqlFullEdgeRight{PatternFilter: patternFilter} + return &ast.GqlFullEdgeRight{ + First: firstPos, + Last: lastPos, + PatternFilter: patternFilter, + } + } + return &ast.GqlFullEdgeAny{ + First: firstPos, + Last: lastHyphenPos, + PatternFilter: patternFilter, } - return &ast.GqlFullEdgeAny{PatternFilter: patternFilter} default: return &ast.GqlAbbreviatedEdgeAny{} } diff --git a/parser_test.go b/parser_test.go index ca732dfd..aaf38830 100644 --- a/parser_test.go +++ b/parser_test.go @@ -135,6 +135,24 @@ func TestParseQuery(t *testing.T) { }) } +func TestParseGqlStatement(t *testing.T) { + inputPath := "./testdata/input/gql" + resultPath := "./testdata/result/gql" + + testParser(t, inputPath, resultPath, func(p *memefish.Parser) (ast.Node, error) { + return p.ParseGqlStatement() + }) +} + +func TestParseGqlPathPattern(t *testing.T) { + inputPath := "./testdata/input/gql_path_pattern" + resultPath := "./testdata/result/gql_path_pattern" + + testParser(t, inputPath, resultPath, func(p *memefish.Parser) (ast.Node, error) { + return p.ParseGqlPathPattern() + }) +} + func TestParseDDL(t *testing.T) { inputPath := "./testdata/input/ddl" resultPath := "./testdata/result/ddl" From 51b27dfb63ae45f767deb7d05f4eeb739f39c8e5 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 07:16:24 +0900 Subject: [PATCH 11/53] Add some testdata --- .../gql/{for.sql => for_with_offset.sql} | 0 ...offset_name.sql => for_with_offset_as.sql} | 0 .../match_any_shortest.sql} | 0 .../match_any_shortest_subpath_trail.sql} | 0 .../match_or_expression.sql} | 0 .../match_subpath_trail.sql} | 0 .../match_trail_subpath_walk.sql} | 0 .../{query/graph_1.sql => gql/next_1.sql} | 0 .../graph_2.sql => gql/return_distinct.sql} | 0 testdata/input/query/graph_4.sql | 3 - testdata/result/gql/filter.sql.txt | 183 +++++++ testdata/result/gql/filter_where.sql.txt | 183 +++++++ testdata/result/gql/for_with_offset.sql.txt | 255 ++++++++++ .../result/gql/for_with_offset_as.sql.txt | 139 ++++++ .../result/gql/graph_hints_between.sql.txt | 263 ++++++++++ testdata/result/gql/graph_hints_match.sql.txt | 290 ++++++++++++ .../gql/graph_hints_traversal_hint.sql.txt | 292 ++++++++++++ testdata/result/gql/let.sql.txt | 182 +++++++ testdata/result/gql/limit.sql.txt | 191 ++++++++ testdata/result/gql/match.sql.txt | 115 +++++ .../result/gql/match_any_shortest.sql.txt | 270 +++++++++++ .../match_any_shortest_subpath_trail.sql.txt | 132 ++++++ testdata/result/gql/match_optional.sql.txt | 239 ++++++++++ .../result/gql/match_or_expression.sql.txt | 141 ++++++ .../result/gql/match_subpath_trail.sql.txt | 257 ++++++++++ .../gql/match_trail_subpath_walk.sql.txt | 207 ++++++++ testdata/result/gql/next.sql.txt | 448 ++++++++++++++++++ testdata/result/gql/next_1.sql.txt | 338 +++++++++++++ testdata/result/gql/offset_1.sql.txt | 127 +++++ testdata/result/gql/order_by.sql.txt | 223 +++++++++ testdata/result/gql/return.sql.txt | 327 +++++++++++++ testdata/result/gql/return_distinct.sql.txt | 224 +++++++++ testdata/result/gql/skip_1.sql.txt | 127 +++++ testdata/result/gql/with_1.sql.txt | 201 ++++++++ .../result/gql_path_pattern/pattern_1.sql.txt | 34 ++ .../result/gql_path_pattern/pattern_2.sql.txt | 72 +++ 36 files changed, 5460 insertions(+), 3 deletions(-) rename testdata/input/gql/{for.sql => for_with_offset.sql} (100%) rename testdata/input/gql/{for_as_offset_name.sql => for_with_offset_as.sql} (100%) rename testdata/input/{query/graph_5.sql => gql/match_any_shortest.sql} (100%) rename testdata/input/{query/graph_8.sql => gql/match_any_shortest_subpath_trail.sql} (100%) rename testdata/input/{query/graph_3.sql => gql/match_or_expression.sql} (100%) rename testdata/input/{query/graph_7.sql => gql/match_subpath_trail.sql} (100%) rename testdata/input/{query/graph_6.sql => gql/match_trail_subpath_walk.sql} (100%) rename testdata/input/{query/graph_1.sql => gql/next_1.sql} (100%) rename testdata/input/{query/graph_2.sql => gql/return_distinct.sql} (100%) delete mode 100644 testdata/input/query/graph_4.sql create mode 100644 testdata/result/gql/filter.sql.txt create mode 100644 testdata/result/gql/filter_where.sql.txt create mode 100644 testdata/result/gql/for_with_offset.sql.txt create mode 100644 testdata/result/gql/for_with_offset_as.sql.txt create mode 100644 testdata/result/gql/graph_hints_between.sql.txt create mode 100644 testdata/result/gql/graph_hints_match.sql.txt create mode 100644 testdata/result/gql/graph_hints_traversal_hint.sql.txt create mode 100644 testdata/result/gql/let.sql.txt create mode 100644 testdata/result/gql/limit.sql.txt create mode 100644 testdata/result/gql/match.sql.txt create mode 100644 testdata/result/gql/match_any_shortest.sql.txt create mode 100644 testdata/result/gql/match_any_shortest_subpath_trail.sql.txt create mode 100644 testdata/result/gql/match_optional.sql.txt create mode 100644 testdata/result/gql/match_or_expression.sql.txt create mode 100644 testdata/result/gql/match_subpath_trail.sql.txt create mode 100644 testdata/result/gql/match_trail_subpath_walk.sql.txt create mode 100644 testdata/result/gql/next.sql.txt create mode 100644 testdata/result/gql/next_1.sql.txt create mode 100644 testdata/result/gql/offset_1.sql.txt create mode 100644 testdata/result/gql/order_by.sql.txt create mode 100644 testdata/result/gql/return.sql.txt create mode 100644 testdata/result/gql/return_distinct.sql.txt create mode 100644 testdata/result/gql/skip_1.sql.txt create mode 100644 testdata/result/gql/with_1.sql.txt create mode 100644 testdata/result/gql_path_pattern/pattern_1.sql.txt create mode 100644 testdata/result/gql_path_pattern/pattern_2.sql.txt diff --git a/testdata/input/gql/for.sql b/testdata/input/gql/for_with_offset.sql similarity index 100% rename from testdata/input/gql/for.sql rename to testdata/input/gql/for_with_offset.sql diff --git a/testdata/input/gql/for_as_offset_name.sql b/testdata/input/gql/for_with_offset_as.sql similarity index 100% rename from testdata/input/gql/for_as_offset_name.sql rename to testdata/input/gql/for_with_offset_as.sql diff --git a/testdata/input/query/graph_5.sql b/testdata/input/gql/match_any_shortest.sql similarity index 100% rename from testdata/input/query/graph_5.sql rename to testdata/input/gql/match_any_shortest.sql diff --git a/testdata/input/query/graph_8.sql b/testdata/input/gql/match_any_shortest_subpath_trail.sql similarity index 100% rename from testdata/input/query/graph_8.sql rename to testdata/input/gql/match_any_shortest_subpath_trail.sql diff --git a/testdata/input/query/graph_3.sql b/testdata/input/gql/match_or_expression.sql similarity index 100% rename from testdata/input/query/graph_3.sql rename to testdata/input/gql/match_or_expression.sql diff --git a/testdata/input/query/graph_7.sql b/testdata/input/gql/match_subpath_trail.sql similarity index 100% rename from testdata/input/query/graph_7.sql rename to testdata/input/gql/match_subpath_trail.sql diff --git a/testdata/input/query/graph_6.sql b/testdata/input/gql/match_trail_subpath_walk.sql similarity index 100% rename from testdata/input/query/graph_6.sql rename to testdata/input/gql/match_trail_subpath_walk.sql diff --git a/testdata/input/query/graph_1.sql b/testdata/input/gql/next_1.sql similarity index 100% rename from testdata/input/query/graph_1.sql rename to testdata/input/gql/next_1.sql diff --git a/testdata/input/query/graph_2.sql b/testdata/input/gql/return_distinct.sql similarity index 100% rename from testdata/input/query/graph_2.sql rename to testdata/input/gql/return_distinct.sql diff --git a/testdata/input/query/graph_4.sql b/testdata/input/query/graph_4.sql deleted file mode 100644 index 0c8d5b6f..00000000 --- a/testdata/input/query/graph_4.sql +++ /dev/null @@ -1,3 +0,0 @@ -GRAPH FinGraph -MATCH (n:Person|Account) -RETURN n.id \ No newline at end of file diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt new file mode 100644 index 00000000..1cd7e568 --- /dev/null +++ b/testdata/result/gql/filter.sql.txt @@ -0,0 +1,183 @@ +--- filter.sql +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FILTER p.birthday < '1990-01-10' +RETURN p.name +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 41, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 33, + NameEnd: 34, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 34, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 35, + NameEnd: 39, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 42, + RParen: 52, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 44, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 45, + NameEnd: 52, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlFilterStatement{ + Filter: 54, + Where: -1, + Expr: &ast.BinaryExpr{ + Op: "<", + Left: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 61, + NameEnd: 62, + Name: "p", + }, + &ast.Ident{ + NamePos: 63, + NameEnd: 71, + Name: "birthday", + }, + }, + }, + Right: &ast.StringLiteral{ + ValuePos: 74, + ValueEnd: 86, + Value: "1990-01-10", + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 87, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 94, + NameEnd: 95, + Name: "p", + }, + &ast.Ident{ + NamePos: 96, + NameEnd: 100, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FILTER p.birthday < "1990-01-10" +RETURN p.name diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt new file mode 100644 index 00000000..4de7c099 --- /dev/null +++ b/testdata/result/gql/filter_where.sql.txt @@ -0,0 +1,183 @@ +--- filter_where.sql +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FILTER WHERE p.birthday < '1990-01-10' +RETURN p.name +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 41, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 33, + NameEnd: 34, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 34, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 35, + NameEnd: 39, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 42, + RParen: 52, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 44, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 45, + NameEnd: 52, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlFilterStatement{ + Filter: 54, + Where: 61, + Expr: &ast.BinaryExpr{ + Op: "<", + Left: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 67, + NameEnd: 68, + Name: "p", + }, + &ast.Ident{ + NamePos: 69, + NameEnd: 77, + Name: "birthday", + }, + }, + }, + Right: &ast.StringLiteral{ + ValuePos: 80, + ValueEnd: 92, + Value: "1990-01-10", + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 93, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 100, + NameEnd: 101, + Name: "p", + }, + &ast.Ident{ + NamePos: 102, + NameEnd: 106, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FILTER WHERE p.birthday < "1990-01-10" +RETURN p.name 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..2a56882a --- /dev/null +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -0,0 +1,255 @@ +--- for_with_offset.sql +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FOR element in ["all","some"] WITH OFFSET +RETURN p.name, element as alert_type, offset +ORDER BY p.name, element, offset + +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 41, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 33, + NameEnd: 34, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 34, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 35, + NameEnd: 39, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 42, + RParen: 52, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 44, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 45, + NameEnd: 52, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlForStatement{ + For: 54, + ElementName: &ast.Ident{ + NamePos: 58, + NameEnd: 65, + Name: "element", + }, + ArrayExpression: &ast.ArrayLiteral{ + Array: 0, + Lbrack: 69, + Rbrack: 82, + Type: nil, + Values: []ast.Expr{ + &ast.StringLiteral{ + ValuePos: 70, + ValueEnd: 75, + Value: "all", + }, + &ast.StringLiteral{ + ValuePos: 76, + ValueEnd: 82, + Value: "some", + }, + }, + }, + WithOffsetClause: &ast.GqlWithOffsetClause{ + With: 84, + Offset: 89, + OffsetName: (*ast.Ident)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 96, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 103, + NameEnd: 104, + Name: "p", + }, + &ast.Ident{ + NamePos: 105, + NameEnd: 109, + Name: "name", + }, + }, + }, + }, + &ast.Alias{ + Expr: &ast.Ident{ + NamePos: 111, + NameEnd: 118, + Name: "element", + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 122, + NameEnd: 132, + Name: "alert_type", + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 134, + NameEnd: 140, + Name: "offset", + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: &ast.OrderBy{ + Order: 141, + Items: []*ast.OrderByItem{ + &ast.OrderByItem{ + DirPos: -1, + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 150, + NameEnd: 151, + Name: "p", + }, + &ast.Ident{ + NamePos: 152, + NameEnd: 156, + Name: "name", + }, + }, + }, + Collate: (*ast.Collate)(nil), + Dir: "", + }, + &ast.OrderByItem{ + DirPos: -1, + Expr: &ast.Ident{ + NamePos: 158, + NameEnd: 165, + Name: "element", + }, + Collate: (*ast.Collate)(nil), + Dir: "", + }, + &ast.OrderByItem{ + DirPos: -1, + Expr: &ast.Ident{ + NamePos: 167, + NameEnd: 173, + Name: "offset", + }, + Collate: (*ast.Collate)(nil), + Dir: "", + }, + }, + }, + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +FOR element IN ARRAY["all", "some"] WITH OFFSET +RETURN p.name, element AS alert_type, offset ORDER BY p.name, element, offset diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt new file mode 100644 index 00000000..7c6592d7 --- /dev/null +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -0,0 +1,139 @@ +--- for_with_offset_as.sql +GRAPH FinGraph +MATCH (p:Person) +FOR element in [] WITH OFFSET AS off +RETURN p.name, element, off +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlForStatement{ + For: 32, + ElementName: &ast.Ident{ + NamePos: 36, + NameEnd: 43, + Name: "element", + }, + ArrayExpression: &ast.ArrayLiteral{ + Array: 0, + Lbrack: 47, + Rbrack: 48, + Type: nil, + Values: []ast.Expr(nil), + }, + WithOffsetClause: &ast.GqlWithOffsetClause{ + With: 50, + Offset: 55, + OffsetName: &ast.Ident{ + NamePos: 65, + NameEnd: 68, + Name: "off", + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 69, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 76, + NameEnd: 77, + Name: "p", + }, + &ast.Ident{ + NamePos: 78, + NameEnd: 82, + Name: "name", + }, + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 84, + NameEnd: 91, + Name: "element", + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 93, + NameEnd: 96, + Name: "off", + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person) +FOR element IN ARRAY[] WITH OFFSET AS off +RETURN p.name, element, off diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt new file mode 100644 index 00000000..bfddf40e --- /dev/null +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -0,0 +1,263 @@ +--- graph_hints_between.sql +GRAPH FinGraph +MATCH + (p:Person {id: 1})-[e:Owns]-> + @{JOIN_METHOD=APPLY_JOIN} + ((a:Account)-[s:Transfers]->(oa:Account)) +RETURN oa.id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 23, + RParen: 40, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 24, + NameEnd: 25, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 25, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 26, + NameEnd: 32, + Name: "Person", + }, + }, + }, + Filter: &ast.GqlPropertyFilters{ + LBrace: 33, + PropertyFilterElemList: []*ast.GqlElementProperty{ + &ast.GqlElementProperty{ + ElementPropertyName: &ast.Ident{ + NamePos: 34, + NameEnd: 36, + Name: "id", + }, + ElementPropertyValue: &ast.IntLiteral{ + ValuePos: 38, + ValueEnd: 39, + Base: 10, + Value: "1", + }, + }, + }, + RBrace: 39, + }, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 41, + Last: 51, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "e", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 44, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 45, + NameEnd: 49, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: &ast.Hint{ + Atmark: 55, + Rbrace: 79, + Records: []*ast.HintRecord{ + &ast.HintRecord{ + Key: &ast.Ident{ + NamePos: 57, + NameEnd: 68, + Name: "JOIN_METHOD", + }, + Value: &ast.Ident{ + NamePos: 69, + NameEnd: 79, + Name: "APPLY_JOIN", + }, + }, + }, + }, + PathTerm: &ast.GqlSubpathPattern{ + LParen: 83, + RParen: 123, + PathMode: (*ast.GqlPathMode)(nil), + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 84, + RParen: 94, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 85, + NameEnd: 86, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 86, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 87, + NameEnd: 94, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 95, + Last: 110, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 97, + NameEnd: 98, + Name: "s", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 98, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 99, + NameEnd: 108, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 111, + RParen: 122, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 112, + NameEnd: 114, + Name: "oa", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 114, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 115, + NameEnd: 122, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 125, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 132, + NameEnd: 134, + Name: "oa", + }, + &ast.Ident{ + NamePos: 135, + NameEnd: 137, + Name: "id", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person {id: 1})-[e:Owns]->@{JOIN_METHOD=APPLY_JOIN}((a:Account)-[s:Transfers]->(oa:Account)) +RETURN oa.id diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt new file mode 100644 index 00000000..43c21738 --- /dev/null +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -0,0 +1,290 @@ +--- graph_hints_match.sql +GRAPH FinGraph +MATCH (p:Person {id: 1})-[:Owns]->(a:Account) +MATCH @{JOIN_METHOD=APPLY_JOIN}(a:Account)-[e:Transfers]->(oa:Account) +RETURN oa.id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 38, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: &ast.GqlPropertyFilters{ + LBrace: 31, + PropertyFilterElemList: []*ast.GqlElementProperty{ + &ast.GqlElementProperty{ + ElementPropertyName: &ast.Ident{ + NamePos: 32, + NameEnd: 34, + Name: "id", + }, + ElementPropertyValue: &ast.IntLiteral{ + ValuePos: 36, + ValueEnd: 37, + Base: 10, + Value: "1", + }, + }, + }, + RBrace: 37, + }, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 39, + Last: 48, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 41, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 42, + NameEnd: 46, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 49, + RParen: 59, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 50, + NameEnd: 51, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 51, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 52, + NameEnd: 59, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlMatchStatement{ + Optional: -1, + Match: 61, + MatchHint: &ast.Hint{ + Atmark: 67, + Rbrace: 91, + Records: []*ast.HintRecord{ + &ast.HintRecord{ + Key: &ast.Ident{ + NamePos: 69, + NameEnd: 80, + Name: "JOIN_METHOD", + }, + Value: &ast.Ident{ + NamePos: 81, + NameEnd: 91, + Name: "APPLY_JOIN", + }, + }, + }, + }, + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 92, + RParen: 102, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 93, + NameEnd: 94, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 94, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 95, + NameEnd: 102, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 103, + Last: 118, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 105, + NameEnd: 106, + Name: "e", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 106, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 107, + NameEnd: 116, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 119, + RParen: 130, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 120, + NameEnd: 122, + Name: "oa", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 122, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 123, + NameEnd: 130, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 132, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 139, + NameEnd: 141, + Name: "oa", + }, + &ast.Ident{ + NamePos: 142, + NameEnd: 144, + Name: "id", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person {id: 1})-[:Owns]->(a:Account) +MATCH@{JOIN_METHOD=APPLY_JOIN} (a:Account)-[e:Transfers]->(oa:Account) +RETURN oa.id diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt new file mode 100644 index 00000000..f6f95393 --- /dev/null +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -0,0 +1,292 @@ +--- graph_hints_traversal_hint.sql +GRAPH FinGraph +MATCH + (p:Person {id: 1})-[:Owns]->(a:Account), -- path pattern 1 + @{JOIN_METHOD=HASH_JOIN, HASH_JOIN_BUILD_SIDE=BUILD_RIGHT} -- traversal hint + (a:Account)-[e:Transfers]->(c:Account) -- path pattern 2 +RETURN c.id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 23, + RParen: 40, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 24, + NameEnd: 25, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 25, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 26, + NameEnd: 32, + Name: "Person", + }, + }, + }, + Filter: &ast.GqlPropertyFilters{ + LBrace: 33, + PropertyFilterElemList: []*ast.GqlElementProperty{ + &ast.GqlElementProperty{ + ElementPropertyName: &ast.Ident{ + NamePos: 34, + NameEnd: 36, + Name: "id", + }, + ElementPropertyValue: &ast.IntLiteral{ + ValuePos: 38, + ValueEnd: 39, + Base: 10, + Value: "1", + }, + }, + }, + RBrace: 39, + }, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 41, + Last: 50, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 43, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 44, + NameEnd: 48, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 51, + RParen: 61, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 52, + NameEnd: 53, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 53, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 54, + NameEnd: 61, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: &ast.Hint{ + Atmark: 102, + Rbrace: 159, + Records: []*ast.HintRecord{ + &ast.HintRecord{ + Key: &ast.Ident{ + NamePos: 104, + NameEnd: 115, + Name: "JOIN_METHOD", + }, + Value: &ast.Ident{ + NamePos: 116, + NameEnd: 125, + Name: "HASH_JOIN", + }, + }, + &ast.HintRecord{ + Key: &ast.Ident{ + NamePos: 127, + NameEnd: 147, + Name: "HASH_JOIN_BUILD_SIDE", + }, + Value: &ast.Ident{ + NamePos: 148, + NameEnd: 159, + Name: "BUILD_RIGHT", + }, + }, + }, + }, + PathTerm: &ast.GqlNodePattern{ + LParen: 181, + RParen: 191, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 182, + NameEnd: 183, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 183, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 184, + NameEnd: 191, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 192, + Last: 207, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 194, + NameEnd: 195, + Name: "e", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 195, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 196, + NameEnd: 205, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 208, + RParen: 218, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 209, + NameEnd: 210, + Name: "c", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 210, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 211, + NameEnd: 218, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 258, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 265, + NameEnd: 266, + Name: "c", + }, + &ast.Ident{ + NamePos: 267, + NameEnd: 269, + Name: "id", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person {id: 1})-[:Owns]->(a:Account), @{JOIN_METHOD=HASH_JOIN, HASH_JOIN_BUILD_SIDE=BUILD_RIGHT}(a:Account)-[e:Transfers]->(c:Account) +RETURN c.id diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt new file mode 100644 index 00000000..48d2ea08 --- /dev/null +++ b/testdata/result/gql/let.sql.txt @@ -0,0 +1,182 @@ +--- let.sql +GRAPH FinGraph +MATCH (source:Account)-[e:Transfers]->(destination:Account) +LET a = source +RETURN a.id AS a_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 36, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 28, + Name: "source", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 28, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 29, + NameEnd: 36, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 37, + Last: 52, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 39, + NameEnd: 40, + Name: "e", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 40, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 41, + NameEnd: 50, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 53, + RParen: 73, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 54, + NameEnd: 65, + Name: "destination", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 65, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 66, + NameEnd: 73, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlLetStatement{ + Let: 75, + LinearGraphVariableList: []*ast.GqlLinearGraphVariable{ + &ast.GqlLinearGraphVariable{ + VariableName: &ast.Ident{ + NamePos: 79, + NameEnd: 80, + Name: "a", + }, + Value: &ast.Ident{ + NamePos: 83, + NameEnd: 89, + Name: "source", + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 90, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 97, + NameEnd: 98, + Name: "a", + }, + &ast.Ident{ + NamePos: 99, + NameEnd: 101, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 105, + NameEnd: 109, + Name: "a_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (source:Account)-[e:Transfers]->(destination:Account) +LET a = source +RETURN a.id AS a_id diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt new file mode 100644 index 00000000..bb686683 --- /dev/null +++ b/testdata/result/gql/limit.sql.txt @@ -0,0 +1,191 @@ +--- limit.sql +GRAPH FinGraph +MATCH (source:Account)-[e:Transfers]->(destination:Account) +ORDER BY source.nick_name +LIMIT 3 +RETURN source.nick_name +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 36, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 28, + Name: "source", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 28, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 29, + NameEnd: 36, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 37, + Last: 52, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 39, + NameEnd: 40, + Name: "e", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 40, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 41, + NameEnd: 50, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 53, + RParen: 73, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 54, + NameEnd: 65, + Name: "destination", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 65, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 66, + NameEnd: 73, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlOrderByStatement{ + Order: 75, + OrderBySpecificationList: []*ast.GqlOrderBySpecification{ + &ast.GqlOrderBySpecification{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 84, + NameEnd: 90, + Name: "source", + }, + &ast.Ident{ + NamePos: 91, + NameEnd: 100, + Name: "nick_name", + }, + }, + }, + DirectionPos: -1, + Direction: "", + }, + }, + }, + &ast.GqlLimitStatement{ + Limit: 101, + Count: &ast.IntLiteral{ + ValuePos: 107, + ValueEnd: 108, + Base: 10, + Value: "3", + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 109, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 116, + NameEnd: 122, + Name: "source", + }, + &ast.Ident{ + NamePos: 123, + NameEnd: 132, + Name: "nick_name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (source:Account)-[e:Transfers]->(destination:Account) +ORDER BY source.nick_name +LIMIT 3 +RETURN source.nick_name diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt new file mode 100644 index 00000000..e19bd96c --- /dev/null +++ b/testdata/result/gql/match.sql.txt @@ -0,0 +1,115 @@ +--- match.sql +GRAPH FinGraph +MATCH (p:Person) +RETURN p.name, p.id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 32, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 39, + NameEnd: 40, + Name: "p", + }, + &ast.Ident{ + NamePos: 41, + NameEnd: 45, + Name: "name", + }, + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "p", + }, + &ast.Ident{ + NamePos: 49, + NameEnd: 51, + Name: "id", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person) +RETURN p.name, p.id diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt new file mode 100644 index 00000000..87da585e --- /dev/null +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -0,0 +1,270 @@ +--- match_any_shortest.sql +GRAPH FinGraph +MATCH ANY SHORTEST (a:Account)-[t:Transfers]->{1, 4} (b:Account) +WHERE a.is_blocked +LET total = SUM(t.amount) +RETURN a.id AS a_id, total, b.id AS b_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: &ast.GqlPathSearchPrefix{ + StartPos: 21, + SearchPrefix: 2, + }, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 34, + RParen: 44, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 35, + NameEnd: 36, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 36, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 37, + NameEnd: 44, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 45, + Last: 60, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "t", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 48, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 49, + NameEnd: 58, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: &ast.GqlBoundedQuantifier{ + LBrace: 61, + RBrace: 66, + LowerBound: &ast.IntLiteral{ + ValuePos: 62, + ValueEnd: 63, + Base: 10, + Value: "1", + }, + UpperBound: &ast.IntLiteral{ + ValuePos: 65, + ValueEnd: 66, + Base: 10, + Value: "4", + }, + }, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 68, + RParen: 78, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 69, + NameEnd: 70, + Name: "b", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 70, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 71, + NameEnd: 78, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 80, + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 86, + NameEnd: 87, + Name: "a", + }, + &ast.Ident{ + NamePos: 88, + NameEnd: 98, + Name: "is_blocked", + }, + }, + }, + }, + }, + }, + &ast.GqlLetStatement{ + Let: 99, + LinearGraphVariableList: []*ast.GqlLinearGraphVariable{ + &ast.GqlLinearGraphVariable{ + VariableName: &ast.Ident{ + NamePos: 103, + NameEnd: 108, + Name: "total", + }, + Value: &ast.CallExpr{ + Rparen: 123, + Func: &ast.Ident{ + NamePos: 111, + NameEnd: 114, + Name: "SUM", + }, + Distinct: false, + Args: []ast.Arg{ + &ast.ExprArg{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 115, + NameEnd: 116, + Name: "t", + }, + &ast.Ident{ + NamePos: 117, + NameEnd: 123, + Name: "amount", + }, + }, + }, + }, + }, + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 125, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 132, + NameEnd: 133, + Name: "a", + }, + &ast.Ident{ + NamePos: 134, + NameEnd: 136, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 140, + NameEnd: 144, + Name: "a_id", + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 146, + NameEnd: 151, + Name: "total", + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 153, + NameEnd: 154, + Name: "b", + }, + &ast.Ident{ + NamePos: 155, + NameEnd: 157, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 161, + NameEnd: 165, + Name: "b_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH ANY SHORTEST (a:Account)-[t:Transfers]->{1,4}(b:Account) WHERE a.is_blocked +LET total = SUM(t.amount) +RETURN a.id AS a_id, total, b.id AS b_id diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt new file mode 100644 index 00000000..c3ee6d6d --- /dev/null +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -0,0 +1,132 @@ +--- match_any_shortest_subpath_trail.sql +GRAPH FinGraph +MATCH ANY SHORTEST (TRAIL ->{1,4}) +RETURN COUNT(1) as num_paths +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: &ast.GqlPathSearchPrefix{ + StartPos: 21, + SearchPrefix: 2, + }, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlSubpathPattern{ + LParen: 34, + RParen: 48, + PathMode: &ast.GqlPathMode{ + Mode: 1, + ModeToken: &ast.Ident{ + NamePos: 35, + NameEnd: 40, + Name: "TRAIL", + }, + PathOrPathToken: (*ast.Ident)(nil), + }, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlAbbreviatedEdgeRight{ + First: 41, + Last: 42, + }, + Quantifier: &ast.GqlBoundedQuantifier{ + LBrace: 43, + RBrace: 47, + LowerBound: &ast.IntLiteral{ + ValuePos: 44, + ValueEnd: 45, + Base: 10, + Value: "1", + }, + UpperBound: &ast.IntLiteral{ + ValuePos: 46, + ValueEnd: 47, + Base: 10, + Value: "4", + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 50, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.CallExpr{ + Rparen: 64, + Func: &ast.Ident{ + NamePos: 57, + NameEnd: 62, + Name: "COUNT", + }, + Distinct: false, + Args: []ast.Arg{ + &ast.ExprArg{ + Expr: &ast.IntLiteral{ + ValuePos: 63, + ValueEnd: 64, + Base: 10, + Value: "1", + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 69, + NameEnd: 78, + Name: "num_paths", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH ANY SHORTEST (TRAIL ->{1,4}) +RETURN COUNT(1) AS num_paths diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt new file mode 100644 index 00000000..657e2b76 --- /dev/null +++ b/testdata/result/gql/match_optional.sql.txt @@ -0,0 +1,239 @@ +--- match_optional.sql +GRAPH FinGraph +MATCH (n:Person) +OPTIONAL MATCH (n:Person)-[:Owns]->(a:Account {is_blocked: TRUE}) +RETURN n.name, a.id AS blocked_account_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "n", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlMatchStatement{ + Optional: 32, + Match: 41, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 47, + RParen: 56, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 48, + NameEnd: 49, + Name: "n", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 49, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 50, + NameEnd: 56, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 57, + Last: 66, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 59, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 60, + NameEnd: 64, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 67, + RParen: 96, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 68, + NameEnd: 69, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 69, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 70, + NameEnd: 77, + Name: "Account", + }, + }, + }, + Filter: &ast.GqlPropertyFilters{ + LBrace: 78, + PropertyFilterElemList: []*ast.GqlElementProperty{ + &ast.GqlElementProperty{ + ElementPropertyName: &ast.Ident{ + NamePos: 79, + NameEnd: 89, + Name: "is_blocked", + }, + ElementPropertyValue: &ast.BoolLiteral{ + ValuePos: 91, + Value: true, + }, + }, + }, + RBrace: 95, + }, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 98, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 105, + NameEnd: 106, + Name: "n", + }, + &ast.Ident{ + NamePos: 107, + NameEnd: 111, + Name: "name", + }, + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 113, + NameEnd: 114, + Name: "a", + }, + &ast.Ident{ + NamePos: 115, + NameEnd: 117, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 121, + NameEnd: 139, + Name: "blocked_account_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (n:Person) +OPTIONAL MATCH (n:Person)-[:Owns]->(a:Account {is_blocked: TRUE}) +RETURN n.name, a.id AS blocked_account_id diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt new file mode 100644 index 00000000..4f2e4485 --- /dev/null +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -0,0 +1,141 @@ +--- match_or_expression.sql +GRAPH FinGraph +MATCH (n:Person|Account) +RETURN n.id, n.name, n.nick_name +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 38, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "n", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelOrExpression{ + Left: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + Right: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 31, + NameEnd: 38, + Name: "Account", + }, + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 40, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "n", + }, + &ast.Ident{ + NamePos: 49, + NameEnd: 51, + Name: "id", + }, + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 53, + NameEnd: 54, + Name: "n", + }, + &ast.Ident{ + NamePos: 55, + NameEnd: 59, + Name: "name", + }, + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 61, + NameEnd: 62, + Name: "n", + }, + &ast.Ident{ + NamePos: 63, + NameEnd: 72, + Name: "nick_name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (n:Person|Account) +RETURN n.id, n.name, n.nick_name diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt new file mode 100644 index 00000000..a94995b5 --- /dev/null +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -0,0 +1,257 @@ +--- match_subpath_trail.sql +GRAPH FinGraph +MATCH + (TRAIL (a1:Account)-[t1:Transfers]->{3}(a4:Account)) + -[t4:Transfers]->(a5:Account) +RETURN COUNT(1) as num_paths +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlSubpathPattern{ + LParen: 23, + RParen: 74, + PathMode: &ast.GqlPathMode{ + Mode: 1, + ModeToken: &ast.Ident{ + NamePos: 24, + NameEnd: 29, + Name: "TRAIL", + }, + PathOrPathToken: (*ast.Ident)(nil), + }, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 30, + RParen: 41, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 31, + NameEnd: 33, + Name: "a1", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 33, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 34, + NameEnd: 41, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 42, + Last: 58, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 44, + NameEnd: 46, + Name: "t1", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 46, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 47, + NameEnd: 56, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: &ast.GqlFixedQuantifier{ + LBrace: 59, + RBrace: 61, + Bound: &ast.IntLiteral{ + ValuePos: 60, + ValueEnd: 61, + Base: 10, + Value: "3", + }, + }, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 62, + RParen: 73, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 63, + NameEnd: 65, + Name: "a4", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 65, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 66, + NameEnd: 73, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 78, + Last: 94, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 80, + NameEnd: 82, + Name: "t4", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 82, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 83, + NameEnd: 92, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 95, + RParen: 106, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 96, + NameEnd: 98, + Name: "a5", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 98, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 99, + NameEnd: 106, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 108, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.CallExpr{ + Rparen: 122, + Func: &ast.Ident{ + NamePos: 115, + NameEnd: 120, + Name: "COUNT", + }, + Distinct: false, + Args: []ast.Arg{ + &ast.ExprArg{ + Expr: &ast.IntLiteral{ + ValuePos: 121, + ValueEnd: 122, + Base: 10, + Value: "1", + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 127, + NameEnd: 136, + Name: "num_paths", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (TRAIL (a1:Account)-[t1:Transfers]->{3}(a4:Account))-[t4:Transfers]->(a5:Account) +RETURN COUNT(1) AS num_paths diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt new file mode 100644 index 00000000..0cda9ac0 --- /dev/null +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -0,0 +1,207 @@ +--- match_trail_subpath_walk.sql +GRAPH FinGraph +MATCH TRAIL (WALK (a1:Account)-[t1:Transfers]->{4}(a5:Account)) +RETURN COUNT(1) as num_paths +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: &ast.GqlPathMode{ + Mode: 1, + ModeToken: &ast.Ident{ + NamePos: 21, + NameEnd: 26, + Name: "TRAIL", + }, + PathOrPathToken: (*ast.Ident)(nil), + }, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlSubpathPattern{ + LParen: 27, + RParen: 77, + PathMode: &ast.GqlPathMode{ + Mode: 0, + ModeToken: &ast.Ident{ + NamePos: 28, + NameEnd: 32, + Name: "WALK", + }, + PathOrPathToken: (*ast.Ident)(nil), + }, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 33, + RParen: 44, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 34, + NameEnd: 36, + Name: "a1", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 36, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 37, + NameEnd: 44, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 45, + Last: 61, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 47, + NameEnd: 49, + Name: "t1", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 49, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 50, + NameEnd: 59, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: &ast.GqlFixedQuantifier{ + LBrace: 62, + RBrace: 64, + Bound: &ast.IntLiteral{ + ValuePos: 63, + ValueEnd: 64, + Base: 10, + Value: "4", + }, + }, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 65, + RParen: 76, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 66, + NameEnd: 68, + Name: "a5", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 68, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 69, + NameEnd: 76, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 79, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.CallExpr{ + Rparen: 93, + Func: &ast.Ident{ + NamePos: 86, + NameEnd: 91, + Name: "COUNT", + }, + Distinct: false, + Args: []ast.Arg{ + &ast.ExprArg{ + Expr: &ast.IntLiteral{ + ValuePos: 92, + ValueEnd: 93, + Base: 10, + Value: "1", + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 98, + NameEnd: 107, + Name: "num_paths", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH TRAIL (WALK (a1:Account)-[t1:Transfers]->{4}(a5:Account)) +RETURN COUNT(1) AS num_paths diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt new file mode 100644 index 00000000..210ca76d --- /dev/null +++ b/testdata/result/gql/next.sql.txt @@ -0,0 +1,448 @@ +--- next.sql +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers +GROUP BY account + +NEXT + +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN + account.id AS account_id, owner.name AS owner_name, + num_incoming_transfers + +NEXT + +FILTER num_incoming_transfers < 2 +RETURN account_id, owner_name +UNION ALL +RETURN "Bob" AS owner_name, 100 AS account_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 22, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 23, + NameEnd: 30, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 45, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 33, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 34, + NameEnd: 43, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 46, + RParen: 62, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 47, + NameEnd: 54, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 54, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 55, + NameEnd: 62, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 64, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 71, + NameEnd: 78, + Name: "account", + }, + }, + &ast.Alias{ + Expr: &ast.CountStarExpr{ + Count: 80, + Rparen: 87, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 92, + NameEnd: 114, + Name: "num_incoming_transfers", + }, + }, + }, + }, + GroupByClause: &ast.GroupBy{ + Group: 115, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 124, + NameEnd: 131, + Name: "account", + }, + }, + }, + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 139, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 145, + RParen: 161, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 146, + NameEnd: 153, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 153, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 154, + NameEnd: 161, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeLeft{ + First: 0, + Last: 0, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 165, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 166, + NameEnd: 170, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 172, + RParen: 185, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 173, + NameEnd: 178, + Name: "owner", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 178, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 179, + NameEnd: 185, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 187, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 196, + NameEnd: 203, + Name: "account", + }, + &ast.Ident{ + NamePos: 204, + NameEnd: 206, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 210, + NameEnd: 220, + Name: "account_id", + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 222, + NameEnd: 227, + Name: "owner", + }, + &ast.Ident{ + NamePos: 228, + NameEnd: 232, + Name: "name", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 236, + NameEnd: 246, + Name: "owner_name", + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 250, + NameEnd: 272, + Name: "num_incoming_transfers", + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + &ast.GqlCompositeLinearQueryStatement{ + HeadSimpleLinearQueryStatement: &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlFilterStatement{ + Filter: 280, + Where: -1, + Expr: &ast.BinaryExpr{ + Op: "<", + Left: &ast.Ident{ + NamePos: 287, + NameEnd: 309, + Name: "num_incoming_transfers", + }, + Right: &ast.IntLiteral{ + ValuePos: 312, + ValueEnd: 313, + Base: 10, + Value: "2", + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 314, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 321, + NameEnd: 331, + Name: "account_id", + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 333, + NameEnd: 343, + Name: "owner_name", + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + TailSimpleLinearQueryStatementList: []*ast.GqlSimpleLinearQueryStatementWithSetOperator{ + &ast.GqlSimpleLinearQueryStatementWithSetOperator{ + StartPos: 344, + SetOperator: 0, + DistinctOrAll: 1, + Statement: &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 354, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.StringLiteral{ + ValuePos: 361, + ValueEnd: 366, + Value: "Bob", + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 370, + NameEnd: 380, + Name: "owner_name", + }, + }, + }, + &ast.Alias{ + Expr: &ast.IntLiteral{ + ValuePos: 382, + ValueEnd: 385, + Base: 10, + Value: "100", + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 389, + NameEnd: 399, + Name: "account_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account +NEXT +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers +NEXT +FILTER num_incoming_transfers < 2 +RETURN account_id, owner_name +UNION ALL +RETURN "Bob" AS owner_name, 100 AS account_id diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt new file mode 100644 index 00000000..39bb0747 --- /dev/null +++ b/testdata/result/gql/next_1.sql.txt @@ -0,0 +1,338 @@ +--- next_1.sql +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers +GROUP BY account + +NEXT + +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN + account.id AS account_id, owner.name AS owner_name, + num_incoming_transfers +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 22, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 23, + NameEnd: 30, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 45, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 33, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 34, + NameEnd: 43, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 46, + RParen: 62, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 47, + NameEnd: 54, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 54, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 55, + NameEnd: 62, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 64, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 71, + NameEnd: 78, + Name: "account", + }, + }, + &ast.Alias{ + Expr: &ast.CountStarExpr{ + Count: 80, + Rparen: 87, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 92, + NameEnd: 114, + Name: "num_incoming_transfers", + }, + }, + }, + }, + GroupByClause: &ast.GroupBy{ + Group: 115, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 124, + NameEnd: 131, + Name: "account", + }, + }, + }, + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 139, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 145, + RParen: 161, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 146, + NameEnd: 153, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 153, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 154, + NameEnd: 161, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeLeft{ + First: 0, + Last: 0, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 165, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 166, + NameEnd: 170, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 172, + RParen: 185, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 173, + NameEnd: 178, + Name: "owner", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 178, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 179, + NameEnd: 185, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 187, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 196, + NameEnd: 203, + Name: "account", + }, + &ast.Ident{ + NamePos: 204, + NameEnd: 206, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 210, + NameEnd: 220, + Name: "account_id", + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 222, + NameEnd: 227, + Name: "owner", + }, + &ast.Ident{ + NamePos: 228, + NameEnd: 232, + Name: "name", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 236, + NameEnd: 246, + Name: "owner_name", + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 250, + NameEnd: 272, + Name: "num_incoming_transfers", + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account +NEXT +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt new file mode 100644 index 00000000..7f66852f --- /dev/null +++ b/testdata/result/gql/offset_1.sql.txt @@ -0,0 +1,127 @@ +--- offset_1.sql +GRAPH FinGraph +MATCH (p:Person) +OFFSET 2 +RETURN p.name, p.id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlOffsetStatement{ + Offset: 32, + IsSkip: false, + Count: &ast.IntLiteral{ + ValuePos: 39, + ValueEnd: 40, + Base: 10, + Value: "2", + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 41, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 48, + NameEnd: 49, + Name: "p", + }, + &ast.Ident{ + NamePos: 50, + NameEnd: 54, + Name: "name", + }, + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 56, + NameEnd: 57, + Name: "p", + }, + &ast.Ident{ + NamePos: 58, + NameEnd: 60, + Name: "id", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person) +OFFSET 2 +RETURN p.name, p.id diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt new file mode 100644 index 00000000..7f8bf0fc --- /dev/null +++ b/testdata/result/gql/order_by.sql.txt @@ -0,0 +1,223 @@ +--- order_by.sql +GRAPH FinGraph +MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account) +ORDER BY transfer.amount DESC +LIMIT 3 +RETURN src_account.id AS account_id, transfer.amount AS transfer_amount +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 41, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 33, + Name: "src_account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 33, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 34, + NameEnd: 41, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 42, + Last: 64, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 44, + NameEnd: 52, + Name: "transfer", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 52, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 53, + NameEnd: 62, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 65, + RParen: 85, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 66, + NameEnd: 77, + Name: "dst_account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 77, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 78, + NameEnd: 85, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlOrderByStatement{ + Order: 87, + OrderBySpecificationList: []*ast.GqlOrderBySpecification{ + &ast.GqlOrderBySpecification{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 96, + NameEnd: 104, + Name: "transfer", + }, + &ast.Ident{ + NamePos: 105, + NameEnd: 111, + Name: "amount", + }, + }, + }, + DirectionPos: 112, + Direction: "DESC", + }, + }, + }, + &ast.GqlLimitStatement{ + Limit: 117, + Count: &ast.IntLiteral{ + ValuePos: 123, + ValueEnd: 124, + Base: 10, + Value: "3", + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 125, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 132, + NameEnd: 143, + Name: "src_account", + }, + &ast.Ident{ + NamePos: 144, + NameEnd: 146, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 150, + NameEnd: 160, + Name: "account_id", + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 162, + NameEnd: 170, + Name: "transfer", + }, + &ast.Ident{ + NamePos: 171, + NameEnd: 177, + Name: "amount", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 181, + NameEnd: 196, + Name: "transfer_amount", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account) +ORDER BY transfer.amount DESC +LIMIT 3 +RETURN src_account.id AS account_id, transfer.amount AS transfer_amount diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt new file mode 100644 index 00000000..e537da05 --- /dev/null +++ b/testdata/result/gql/return.sql.txt @@ -0,0 +1,327 @@ +--- return.sql +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers +GROUP BY account + +NEXT + +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN owner.name AS owner_name, num_incoming_transfers +ORDER BY num_incoming_transfers DESC +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 22, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 23, + NameEnd: 30, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 45, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 33, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 34, + NameEnd: 43, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 46, + RParen: 62, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 47, + NameEnd: 54, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 54, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 55, + NameEnd: 62, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 64, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 71, + NameEnd: 78, + Name: "account", + }, + }, + &ast.Alias{ + Expr: &ast.CountStarExpr{ + Count: 80, + Rparen: 87, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 92, + NameEnd: 114, + Name: "num_incoming_transfers", + }, + }, + }, + }, + GroupByClause: &ast.GroupBy{ + Group: 115, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 124, + NameEnd: 131, + Name: "account", + }, + }, + }, + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 139, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 145, + RParen: 161, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 146, + NameEnd: 153, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 153, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 154, + NameEnd: 161, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeLeft{ + First: 0, + Last: 0, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 165, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 166, + NameEnd: 170, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 172, + RParen: 185, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 173, + NameEnd: 178, + Name: "owner", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 178, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 179, + NameEnd: 185, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 187, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 194, + NameEnd: 199, + Name: "owner", + }, + &ast.Ident{ + NamePos: 200, + NameEnd: 204, + Name: "name", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 208, + NameEnd: 218, + Name: "owner_name", + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 220, + NameEnd: 242, + Name: "num_incoming_transfers", + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: &ast.OrderBy{ + Order: 243, + Items: []*ast.OrderByItem{ + &ast.OrderByItem{ + DirPos: 275, + Expr: &ast.Ident{ + NamePos: 252, + NameEnd: 274, + Name: "num_incoming_transfers", + }, + Collate: (*ast.Collate)(nil), + Dir: "DESC", + }, + }, + }, + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account +NEXT +MATCH (account:Account)<-[:Owns]-(owner:Person) +RETURN owner.name AS owner_name, num_incoming_transfers ORDER BY num_incoming_transfers DESC diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt new file mode 100644 index 00000000..5b0b0004 --- /dev/null +++ b/testdata/result/gql/return_distinct.sql.txt @@ -0,0 +1,224 @@ +--- return_distinct.sql +GRAPH FinGraph +MATCH (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account) +RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 41, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 25, + Name: "src", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 25, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 26, + NameEnd: 33, + Name: "Account", + }, + }, + }, + Filter: &ast.GqlPropertyFilters{ + LBrace: 34, + PropertyFilterElemList: []*ast.GqlElementProperty{ + &ast.GqlElementProperty{ + ElementPropertyName: &ast.Ident{ + NamePos: 35, + NameEnd: 37, + Name: "id", + }, + ElementPropertyValue: &ast.IntLiteral{ + ValuePos: 39, + ValueEnd: 40, + Base: 10, + Value: "7", + }, + }, + }, + RBrace: 40, + }, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 42, + Last: 57, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 44, + NameEnd: 45, + Name: "e", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 45, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 46, + NameEnd: 55, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: &ast.GqlBoundedQuantifier{ + LBrace: 58, + RBrace: 63, + LowerBound: &ast.IntLiteral{ + ValuePos: 59, + ValueEnd: 60, + Base: 10, + Value: "1", + }, + UpperBound: &ast.IntLiteral{ + ValuePos: 62, + ValueEnd: 63, + Base: 10, + Value: "3", + }, + }, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 64, + RParen: 76, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 65, + NameEnd: 68, + Name: "dst", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 68, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 69, + NameEnd: 76, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 2, + Return: 78, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.CallExpr{ + Rparen: 108, + Func: &ast.Ident{ + NamePos: 94, + NameEnd: 106, + Name: "ARRAY_LENGTH", + }, + Distinct: false, + Args: []ast.Arg{ + &ast.ExprArg{ + Expr: &ast.Ident{ + NamePos: 107, + NameEnd: 108, + Name: "e", + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 113, + NameEnd: 117, + Name: "hops", + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 119, + NameEnd: 122, + Name: "dst", + }, + &ast.Ident{ + NamePos: 123, + NameEnd: 125, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 129, + NameEnd: 151, + Name: "destination_account_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (src:Account {id: 7})-[e:Transfers]->{1,3}(dst:Account) +RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt new file mode 100644 index 00000000..6c11cc35 --- /dev/null +++ b/testdata/result/gql/skip_1.sql.txt @@ -0,0 +1,127 @@ +--- skip_1.sql +GRAPH FinGraph +MATCH (p:Person) +SKIP 2 +RETURN p.name, p.id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlOffsetStatement{ + Offset: 32, + IsSkip: true, + Count: &ast.IntLiteral{ + ValuePos: 37, + ValueEnd: 38, + Base: 10, + Value: "2", + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 39, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 46, + NameEnd: 47, + Name: "p", + }, + &ast.Ident{ + NamePos: 48, + NameEnd: 52, + Name: "name", + }, + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 54, + NameEnd: 55, + Name: "p", + }, + &ast.Ident{ + NamePos: 56, + NameEnd: 58, + Name: "id", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person) +SKIP 2 +RETURN p.name, p.id diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt new file mode 100644 index 00000000..405448cc --- /dev/null +++ b/testdata/result/gql/with_1.sql.txt @@ -0,0 +1,201 @@ +--- with_1.sql +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +WITH account, COUNT(*) AS num_incoming_transfers GROUP BY account +RETURN account.id AS account_id, num_incoming_transfers +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 22, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 23, + NameEnd: 30, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 45, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 33, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 34, + NameEnd: 43, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 46, + RParen: 62, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 47, + NameEnd: 54, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 54, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 55, + NameEnd: 62, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlWithStatement{ + With: 64, + AllOrDistinct: 0, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 69, + NameEnd: 76, + Name: "account", + }, + }, + &ast.Alias{ + Expr: &ast.CountStarExpr{ + Count: 78, + Rparen: 85, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 90, + NameEnd: 112, + Name: "num_incoming_transfers", + }, + }, + }, + }, + GroupByClause: &ast.GroupBy{ + Group: 113, + Exprs: []ast.Expr{ + &ast.Ident{ + NamePos: 122, + NameEnd: 129, + Name: "account", + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 130, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 137, + NameEnd: 144, + Name: "account", + }, + &ast.Ident{ + NamePos: 145, + NameEnd: 147, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 151, + NameEnd: 161, + Name: "account_id", + }, + }, + }, + &ast.ExprSelectItem{ + Expr: &ast.Ident{ + NamePos: 163, + NameEnd: 185, + Name: "num_incoming_transfers", + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (:Account)-[:Transfers]->(account:Account) +WITH account, COUNT(*) AS num_incoming_transfers GROUP BY account +RETURN account.id AS account_id, num_incoming_transfers diff --git a/testdata/result/gql_path_pattern/pattern_1.sql.txt b/testdata/result/gql_path_pattern/pattern_1.sql.txt new file mode 100644 index 00000000..956e4276 --- /dev/null +++ b/testdata/result/gql_path_pattern/pattern_1.sql.txt @@ -0,0 +1,34 @@ +--- pattern_1.sql +(p:%) +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 0, + RParen: 4, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 1, + NameEnd: 2, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 2, + LabelExpression: &ast.GqlLabelName{ + IsPercent: true, + LabelName: (*ast.Ident)(nil), + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +(p:%) diff --git a/testdata/result/gql_path_pattern/pattern_2.sql.txt b/testdata/result/gql_path_pattern/pattern_2.sql.txt new file mode 100644 index 00000000..162077a7 --- /dev/null +++ b/testdata/result/gql_path_pattern/pattern_2.sql.txt @@ -0,0 +1,72 @@ +--- pattern_2.sql +(p:(Singer|(!Writer&!Producer))) +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 0, + RParen: 31, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 1, + NameEnd: 2, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 2, + LabelExpression: &ast.GqlLabelParenExpression{ + LParen: 3, + RParen: 30, + LabelExpr: &ast.GqlLabelOrExpression{ + Left: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 4, + NameEnd: 10, + Name: "Singer", + }, + }, + Right: &ast.GqlLabelParenExpression{ + LParen: 11, + RParen: 29, + LabelExpr: &ast.GqlLabelNotExpression{ + NotPos: 12, + LabelExpression: &ast.GqlLabelAndExpression{ + Left: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 13, + NameEnd: 19, + Name: "Writer", + }, + }, + Right: &ast.GqlLabelNotExpression{ + NotPos: 20, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 21, + NameEnd: 29, + Name: "Producer", + }, + }, + }, + }, + }, + }, + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +(p:(Singer|(!Writer&!Producer))) From c817e66720e4e943c579463b01054eab17a22018 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 07:39:37 +0900 Subject: [PATCH 12/53] Complete Pos(), End() of edge_patterns --- ast/graph_patterns.go | 55 +++++++------------ parser_gql.go | 27 +++++---- .../input/gql_path_pattern/abbr_edge_any.sql | 1 + .../abbreviated_edge_left.sql | 1 + .../abbreviated_edge_right.sql | 1 + .../input/gql_path_pattern/full_edge_any.sql | 1 + .../input/gql_path_pattern/full_edge_left.sql | 1 + .../gql_path_pattern/full_edge_right.sql | 1 + .../gql_path_pattern/node_pattern_unnamed.sql | 1 + testdata/result/gql/next.sql.txt | 4 +- testdata/result/gql/next_1.sql.txt | 4 +- testdata/result/gql/return.sql.txt | 4 +- .../gql_path_pattern/abbr_edge_any.sql.txt | 17 ++++++ .../abbreviated_edge_left.sql.txt | 18 ++++++ .../abbreviated_edge_right.sql.txt | 18 ++++++ .../gql_path_pattern/full_edge_any.sql.txt | 28 ++++++++++ .../gql_path_pattern/full_edge_left.sql.txt | 28 ++++++++++ .../gql_path_pattern/full_edge_right.sql.txt | 24 ++++++++ .../node_pattern_unnamed.sql.txt | 24 ++++++++ 19 files changed, 206 insertions(+), 52 deletions(-) create mode 100644 testdata/input/gql_path_pattern/abbr_edge_any.sql create mode 100644 testdata/input/gql_path_pattern/abbreviated_edge_left.sql create mode 100644 testdata/input/gql_path_pattern/abbreviated_edge_right.sql create mode 100644 testdata/input/gql_path_pattern/full_edge_any.sql create mode 100644 testdata/input/gql_path_pattern/full_edge_left.sql create mode 100644 testdata/input/gql_path_pattern/full_edge_right.sql create mode 100644 testdata/input/gql_path_pattern/node_pattern_unnamed.sql create mode 100644 testdata/result/gql_path_pattern/abbr_edge_any.sql.txt create mode 100644 testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt create mode 100644 testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt create mode 100644 testdata/result/gql_path_pattern/full_edge_any.sql.txt create mode 100644 testdata/result/gql_path_pattern/full_edge_left.sql.txt create mode 100644 testdata/result/gql_path_pattern/full_edge_right.sql.txt create mode 100644 testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt diff --git a/ast/graph_patterns.go b/ast/graph_patterns.go index 3b54bdab..3ea658ba 100644 --- a/ast/graph_patterns.go +++ b/ast/graph_patterns.go @@ -135,67 +135,54 @@ func (g GqlFullEdgeRight) isGqlElementPattern() {} func (g GqlFullEdgeRight) isGqlEdgePattern() {} -type GqlAbbreviatedEdgeAny struct{} +type GqlAbbreviatedEdgeAny struct { + // pos = Hyphen + // end = Hyphen +1 + Hyphen token.Pos // position of "-" +} func (g GqlAbbreviatedEdgeAny) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.Hyphen } func (g GqlAbbreviatedEdgeAny) End() token.Pos { - //TODO implement me - panic("implement me") + return g.Hyphen + 1 } func (g GqlAbbreviatedEdgeAny) SQL() string { return "-" } -func (g GqlAbbreviatedEdgeAny) isGqlPathTerm() { - //TODO implement me - panic("implement me") -} +func (g GqlAbbreviatedEdgeAny) isGqlPathTerm() {} -func (g GqlAbbreviatedEdgeAny) isGqlElementPattern() { - //TODO implement me - panic("implement me") -} +func (g GqlAbbreviatedEdgeAny) isGqlElementPattern() {} -func (g GqlAbbreviatedEdgeAny) isGqlEdgePattern() { - //TODO implement me - panic("implement me") -} +func (g GqlAbbreviatedEdgeAny) isGqlEdgePattern() {} -type GqlAbbreviatedEdgeLeft struct{} +type GqlAbbreviatedEdgeLeft struct { + // pos = First + // end = Last + 1 + First token.Pos // position of "<" + Last token.Pos // position of "-" +} func (g GqlAbbreviatedEdgeLeft) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.First } func (g GqlAbbreviatedEdgeLeft) End() token.Pos { - //TODO implement me - panic("implement me") + return g.Last + 1 } func (g GqlAbbreviatedEdgeLeft) SQL() string { return "<-" } -func (g GqlAbbreviatedEdgeLeft) isGqlPathTerm() { - //TODO implement me - panic("implement me") -} +func (g GqlAbbreviatedEdgeLeft) isGqlPathTerm() {} -func (g GqlAbbreviatedEdgeLeft) isGqlElementPattern() { - //TODO implement me - panic("implement me") -} +func (g GqlAbbreviatedEdgeLeft) isGqlElementPattern() {} -func (g GqlAbbreviatedEdgeLeft) isGqlEdgePattern() { - //TODO implement me - panic("implement me") -} +func (g GqlAbbreviatedEdgeLeft) isGqlEdgePattern() {} type GqlAbbreviatedEdgeRight struct { // pos = First diff --git a/parser_gql.go b/parser_gql.go index e183dc69..a1322452 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -382,12 +382,6 @@ func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { RParen: rparen, LabelExpr: expr, } - - /* - default: - p.panicfAtToken(&p.Token, "expected token: '|' or '&', but: %v", p.Token.Kind) - return nil // must not be reached - */ case p.Token.Kind == token.TokenIdent || p.Token.Kind == "%": labelTerm = p.parseGqlLabelName() default: @@ -557,20 +551,29 @@ func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { } func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { - //TODO implement + // NOTE: Currently, this implementation allows whitespace in any place of "<-[" and "]->". + // It is more relaxed syntax than spec. + // It will be fixed when we are sure that the modification of lexer is safe. firstPos := p.Token.Pos switch p.Token.Kind { case "<": p.nextToken() - p.expect("-") + firstHyphenPos := p.expect("-").Pos if p.Token.Kind != "[" { - return &ast.GqlAbbreviatedEdgeLeft{} + return &ast.GqlAbbreviatedEdgeLeft{ + First: firstPos, + Last: firstHyphenPos, + } } p.nextToken() patternFilter := p.parseGqlPatternFilter() p.expect("]") - p.expect("-") - return &ast.GqlFullEdgeLeft{PatternFilter: patternFilter} + lastPos := p.expect("-").Pos + return &ast.GqlFullEdgeLeft{ + First: firstPos, + Last: lastPos, + PatternFilter: patternFilter, + } case "-": p.nextToken() switch p.Token.Kind { @@ -600,7 +603,7 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { PatternFilter: patternFilter, } default: - return &ast.GqlAbbreviatedEdgeAny{} + return &ast.GqlAbbreviatedEdgeAny{Hyphen: firstPos} } default: panic(fmt.Sprintf("not implemented kind: %v %v", p.Token.Kind, p.Token.Raw)) diff --git a/testdata/input/gql_path_pattern/abbr_edge_any.sql b/testdata/input/gql_path_pattern/abbr_edge_any.sql new file mode 100644 index 00000000..69db6bb6 --- /dev/null +++ b/testdata/input/gql_path_pattern/abbr_edge_any.sql @@ -0,0 +1 @@ + - \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/abbreviated_edge_left.sql b/testdata/input/gql_path_pattern/abbreviated_edge_left.sql new file mode 100644 index 00000000..1c150fa8 --- /dev/null +++ b/testdata/input/gql_path_pattern/abbreviated_edge_left.sql @@ -0,0 +1 @@ + <- \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/abbreviated_edge_right.sql b/testdata/input/gql_path_pattern/abbreviated_edge_right.sql new file mode 100644 index 00000000..d882b4a5 --- /dev/null +++ b/testdata/input/gql_path_pattern/abbreviated_edge_right.sql @@ -0,0 +1 @@ + -> \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/full_edge_any.sql b/testdata/input/gql_path_pattern/full_edge_any.sql new file mode 100644 index 00000000..7b7fcf96 --- /dev/null +++ b/testdata/input/gql_path_pattern/full_edge_any.sql @@ -0,0 +1 @@ + -[a]- \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/full_edge_left.sql b/testdata/input/gql_path_pattern/full_edge_left.sql new file mode 100644 index 00000000..0c9f97ed --- /dev/null +++ b/testdata/input/gql_path_pattern/full_edge_left.sql @@ -0,0 +1 @@ + <-[a]- \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/full_edge_right.sql b/testdata/input/gql_path_pattern/full_edge_right.sql new file mode 100644 index 00000000..aae652dc --- /dev/null +++ b/testdata/input/gql_path_pattern/full_edge_right.sql @@ -0,0 +1 @@ + -[]-> \ No newline at end of file diff --git a/testdata/input/gql_path_pattern/node_pattern_unnamed.sql b/testdata/input/gql_path_pattern/node_pattern_unnamed.sql new file mode 100644 index 00000000..2ef69aa2 --- /dev/null +++ b/testdata/input/gql_path_pattern/node_pattern_unnamed.sql @@ -0,0 +1 @@ + () \ No newline at end of file diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 210ca76d..b7de4010 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -210,8 +210,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id &ast.GqlQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GqlFullEdgeLeft{ - First: 0, - Last: 0, + First: 162, + Last: 171, PatternFilter: &ast.GqlPatternFilter{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 39bb0747..8ee2be47 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -203,8 +203,8 @@ RETURN &ast.GqlQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GqlFullEdgeLeft{ - First: 0, - Last: 0, + First: 162, + Last: 171, PatternFilter: &ast.GqlPatternFilter{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index e537da05..2af506f6 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -202,8 +202,8 @@ ORDER BY num_incoming_transfers DESC &ast.GqlQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GqlFullEdgeLeft{ - First: 0, - Last: 0, + First: 162, + Last: 171, PatternFilter: &ast.GqlPatternFilter{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql_path_pattern/abbr_edge_any.sql.txt b/testdata/result/gql_path_pattern/abbr_edge_any.sql.txt new file mode 100644 index 00000000..76b1ebd4 --- /dev/null +++ b/testdata/result/gql_path_pattern/abbr_edge_any.sql.txt @@ -0,0 +1,17 @@ +--- abbr_edge_any.sql + - +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlAbbreviatedEdgeAny{ + Hyphen: 1, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +- diff --git a/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt b/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt new file mode 100644 index 00000000..aae389f5 --- /dev/null +++ b/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt @@ -0,0 +1,18 @@ +--- abbreviated_edge_left.sql + <- +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlAbbreviatedEdgeLeft{ + First: 1, + Last: 2, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +<- diff --git a/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt new file mode 100644 index 00000000..73ae0445 --- /dev/null +++ b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt @@ -0,0 +1,18 @@ +--- abbreviated_edge_right.sql + -> +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlAbbreviatedEdgeRight{ + First: 1, + Last: 2, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +-> diff --git a/testdata/result/gql_path_pattern/full_edge_any.sql.txt b/testdata/result/gql_path_pattern/full_edge_any.sql.txt new file mode 100644 index 00000000..bb5713f0 --- /dev/null +++ b/testdata/result/gql_path_pattern/full_edge_any.sql.txt @@ -0,0 +1,28 @@ +--- full_edge_any.sql + -[a]- +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeAny{ + First: 1, + Last: 5, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 3, + NameEnd: 4, + Name: "a", + }, + IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +-[a]- diff --git a/testdata/result/gql_path_pattern/full_edge_left.sql.txt b/testdata/result/gql_path_pattern/full_edge_left.sql.txt new file mode 100644 index 00000000..b5765a73 --- /dev/null +++ b/testdata/result/gql_path_pattern/full_edge_left.sql.txt @@ -0,0 +1,28 @@ +--- full_edge_left.sql + <-[a]- +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeLeft{ + First: 2, + Last: 7, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 5, + NameEnd: 6, + Name: "a", + }, + IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +<-[a]- diff --git a/testdata/result/gql_path_pattern/full_edge_right.sql.txt b/testdata/result/gql_path_pattern/full_edge_right.sql.txt new file mode 100644 index 00000000..3385b0a5 --- /dev/null +++ b/testdata/result/gql_path_pattern/full_edge_right.sql.txt @@ -0,0 +1,24 @@ +--- full_edge_right.sql + -[]-> +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 1, + Last: 5, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +-[]-> diff --git a/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt new file mode 100644 index 00000000..4c4fe918 --- /dev/null +++ b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt @@ -0,0 +1,24 @@ +--- node_pattern_unnamed.sql + () +--- AST +&ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 1, + RParen: 2, + PatternFilter: &ast.GqlPatternFilter{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, +} + +--- SQL +() From c4fdacb9d2e25303d023a38e46ed4ef9eacfb15f Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 08:21:37 +0900 Subject: [PATCH 13/53] Fix typo of pattern filler and some wording changes --- ast/ast.go | 2 +- ast/gql.go | 24 -------- ast/graph_patterns.go | 61 +++++++++++-------- ast/util.go | 36 +++++++++++ parser_gql.go | 22 +++---- testdata/result/gql/filter.sql.txt | 6 +- testdata/result/gql/filter_where.sql.txt | 6 +- testdata/result/gql/for_with_offset.sql.txt | 6 +- .../result/gql/for_with_offset_as.sql.txt | 2 +- .../result/gql/graph_hints_between.sql.txt | 10 +-- testdata/result/gql/graph_hints_match.sql.txt | 12 ++-- .../gql/graph_hints_traversal_hint.sql.txt | 12 ++-- testdata/result/gql/let.sql.txt | 6 +- testdata/result/gql/limit.sql.txt | 6 +- testdata/result/gql/match.sql.txt | 2 +- .../result/gql/match_any_shortest.sql.txt | 6 +- testdata/result/gql/match_optional.sql.txt | 8 +-- .../result/gql/match_or_expression.sql.txt | 2 +- .../result/gql/match_subpath_trail.sql.txt | 10 +-- .../gql/match_trail_subpath_walk.sql.txt | 6 +- testdata/result/gql/next.sql.txt | 12 ++-- testdata/result/gql/next_1.sql.txt | 12 ++-- testdata/result/gql/offset_1.sql.txt | 2 +- testdata/result/gql/order_by.sql.txt | 6 +- testdata/result/gql/return.sql.txt | 12 ++-- testdata/result/gql/return_distinct.sql.txt | 6 +- testdata/result/gql/skip_1.sql.txt | 2 +- testdata/result/gql/with_1.sql.txt | 6 +- .../gql_path_pattern/full_edge_any.sql.txt | 2 +- .../gql_path_pattern/full_edge_left.sql.txt | 2 +- .../gql_path_pattern/full_edge_right.sql.txt | 2 +- .../node_pattern_unnamed.sql.txt | 2 +- .../result/gql_path_pattern/pattern_1.sql.txt | 2 +- .../result/gql_path_pattern/pattern_2.sql.txt | 2 +- 34 files changed, 169 insertions(+), 146 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index d0999e21..a186d4de 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -565,7 +565,7 @@ type Where struct { Expr Expr } -func (w *Where) isGqlPatternFilterFilter() {} +func (w *Where) isGqlPatternFillerFilter() {} // GroupBy is GROUP BY clause node. // diff --git a/ast/gql.go b/ast/gql.go index 7296e2b5..3f1cbaad 100644 --- a/ast/gql.go +++ b/ast/gql.go @@ -3,7 +3,6 @@ package ast import ( "fmt" "github.com/cloudspannerecosystem/memefish/token" - "strings" ) type GqlGraphQuery struct { @@ -78,33 +77,10 @@ func (s *GqlSimpleLinearQueryStatement) Pos() token.Pos { return firstPos(s.PrimitiveQueryStatementList) } -func lastElem[T any](s []T) T { - return s[len(s)-1] -} - -func firstPos[T Node](s []T) token.Pos { - return s[0].Pos() -} - -func lastEnd[T Node](s []T) token.Pos { - return lastElem(s).End() -} - func (s *GqlSimpleLinearQueryStatement) End() token.Pos { return lastEnd(s.PrimitiveQueryStatementList) } -func sqlJoin[T Node](elems []T, sep string) string { - var b strings.Builder - for i, r := range elems { - if i > 0 { - b.WriteString(sep) - } - b.WriteString(r.SQL()) - } - return b.String() -} - func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} func (s *GqlSimpleLinearQueryStatement) SQL() string { diff --git a/ast/graph_patterns.go b/ast/graph_patterns.go index 3ea658ba..e85bda7e 100644 --- a/ast/graph_patterns.go +++ b/ast/graph_patterns.go @@ -6,6 +6,9 @@ import ( "strings" ) +// https://cloud.google.com/spanner/docs/reference/standard-sql/graph-patterns + +// GqlGraphPattern represents is the toplevel node of GQL graph patterns. type GqlGraphPattern struct { // pos = GqlTopLevelPathPattern[0].pos // end = (WhereClause ?? PathPatternList[$]).end @@ -28,6 +31,7 @@ func (g GqlGraphPattern) SQL() string { return sqlJoin(g.PathPatternList, ", ") + sqlOpt(" ", g.WhereClause, "") } +// GqlTopLevelPathPattern is a PathPattern optionally prefixed by PathSearchPrefixOrPathMode. type GqlTopLevelPathPattern struct { // pos = (PathSearchPrefixOrPathMode ?? PathPattern).pos // end = PathPattern.end @@ -36,10 +40,7 @@ type GqlTopLevelPathPattern struct { } func (g GqlTopLevelPathPattern) Pos() token.Pos { - if g.PathSearchPrefixOrPathMode != nil { - return g.PathSearchPrefixOrPathMode.Pos() - } - return g.PathPattern.Pos() + return firstValidPos(g.PathSearchPrefixOrPathMode, g.PathPattern) } func (g GqlTopLevelPathPattern) End() token.Pos { @@ -50,21 +51,34 @@ func (g GqlTopLevelPathPattern) SQL() string { return sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() } +// GqlPathSearchPrefixOrPathMode represents `{ path_search_prefix | path_mode }` type GqlPathSearchPrefixOrPathMode interface { Node isGqlPathSearchPrefixOrPathMode() } +// GqlEdgePattern represents edge pattern nodes. +// +// edge_pattern: +// { +// full_edge_any | +// full_edge_left | +// full_edge_right | +// abbreviated_edge_any | +// abbreviated_edge_left | +// abbreviated_edge_right +// } type GqlEdgePattern interface { GqlElementPattern isGqlEdgePattern() } +// GqlFullEdgeAny is node representing`-[pattern_filler]-` . type GqlFullEdgeAny struct { // pos = First.pos // end = Last.pos + 1 First, Last token.Pos - PatternFilter *GqlPatternFilter + PatternFiller *GqlPatternFiller } func (g GqlFullEdgeAny) Pos() token.Pos { @@ -76,7 +90,7 @@ func (g GqlFullEdgeAny) End() token.Pos { } func (g GqlFullEdgeAny) SQL() string { - return fmt.Sprintf("-[%v]-", g.PatternFilter.SQL()) + return fmt.Sprintf("-[%v]-", g.PatternFiller.SQL()) } func (g GqlFullEdgeAny) isGqlPathTerm() {} @@ -88,7 +102,7 @@ type GqlFullEdgeLeft struct { // end = Last + 1 First token.Pos // position of "<" Last token.Pos // position of the last "-" - PatternFilter *GqlPatternFilter + PatternFiller *GqlPatternFiller } func (g GqlFullEdgeLeft) Pos() token.Pos { @@ -100,7 +114,7 @@ func (g GqlFullEdgeLeft) End() token.Pos { } func (g GqlFullEdgeLeft) SQL() string { - return fmt.Sprintf("<-[%v]-", g.PatternFilter.SQL()) + return fmt.Sprintf("<-[%v]-", g.PatternFiller.SQL()) } func (g GqlFullEdgeLeft) isGqlPathTerm() {} @@ -114,7 +128,7 @@ type GqlFullEdgeRight struct { // end = Last + 1 First token.Pos // position of the first "-" Last token.Pos // position of ">" - PatternFilter *GqlPatternFilter + PatternFiller *GqlPatternFiller } func (g GqlFullEdgeRight) Pos() token.Pos { @@ -126,7 +140,7 @@ func (g GqlFullEdgeRight) End() token.Pos { } func (g GqlFullEdgeRight) SQL() string { - return fmt.Sprintf("-[%v]->", g.PatternFilter.SQL()) + return fmt.Sprintf("-[%v]->", g.PatternFiller.SQL()) } func (g GqlFullEdgeRight) isGqlPathTerm() {} @@ -283,7 +297,7 @@ func (g GqlWhereClause) SQL() string { panic("implement me") } -func (g GqlWhereClause) isGqlPatternFilterFilter() {} +func (g GqlWhereClause) isGqlPatternFillerFilter() {} type GqlElementPattern interface { Node @@ -416,7 +430,7 @@ func (g GqlSubpathPattern) isGqlPathTerm() { type GqlNodePattern struct { LParen, RParen token.Pos - PatternFilter *GqlPatternFilter + PatternFiller *GqlPatternFiller } func (g GqlNodePattern) Pos() token.Pos { @@ -431,7 +445,7 @@ func (g GqlNodePattern) End() token.Pos { func (g GqlNodePattern) SQL() string { var sql string - sql += fmt.Sprintf("(%v)", g.PatternFilter.SQL()) + sql += fmt.Sprintf("(%v)", g.PatternFiller.SQL()) return sql } @@ -457,25 +471,25 @@ type EdgePattern interface { */ -type GqlPatternFilter struct { +type GqlPatternFiller struct { // Hint is graph element hint which is a table hint. Hint *Hint GraphPatternVariable *Ident // optional IsLabelCondition *GqlIsLabelCondition // optional - Filter GqlPatternFilterFilter // optional + Filter GqlPatternFillerFilter // optional } -func (g GqlPatternFilter) Pos() token.Pos { +func (g GqlPatternFiller) Pos() token.Pos { //TODO implement me panic("implement me") } -func (g GqlPatternFilter) End() token.Pos { +func (g GqlPatternFiller) End() token.Pos { //TODO implement me panic("implement me") } -func (g GqlPatternFilter) SQL() string { +func (g GqlPatternFiller) SQL() string { var sql string sql += sqlOpt("", g.Hint, "") if g.GraphPatternVariable != nil { @@ -644,14 +658,11 @@ func (g GqlLabelName) SQL() string { return g.LabelName.SQL() } -func (g GqlLabelName) isGqlLabelExpression() { - //TODO implement me - panic("implement me") -} +func (g GqlLabelName) isGqlLabelExpression() {} -type GqlPatternFilterFilter interface { +type GqlPatternFillerFilter interface { Node - isGqlPatternFilterFilter() + isGqlPatternFillerFilter() } type GqlPropertyFilters struct { @@ -679,7 +690,7 @@ func (g GqlPropertyFilters) SQL() string { return fmt.Sprintf("{%v}", strings.Join(elemSqls, ", ")) } -func (g GqlPropertyFilters) isGqlPatternFilterFilter() {} +func (g GqlPropertyFilters) isGqlPatternFillerFilter() {} type GqlElementProperty struct { ElementPropertyName *Ident diff --git a/ast/util.go b/ast/util.go index 374161b9..27c62ab8 100644 --- a/ast/util.go +++ b/ast/util.go @@ -1,5 +1,10 @@ package ast +import ( + "github.com/cloudspannerecosystem/memefish/token" + "strings" +) + // sqlOpt output: // // when node != nil: left + node.SQL() + right @@ -16,3 +21,34 @@ func sqlOpt[T interface { } return left + node.SQL() + right } + +func lastElem[T any](s []T) T { + return s[len(s)-1] +} + +func firstValidPos(ns ...Node) token.Pos { + for _, n := range ns { + if n != nil { + return n.Pos() + } + } + return token.InvalidPos +} + +func firstPos[T Node](s []T) token.Pos { + return s[0].Pos() +} + +func lastEnd[T Node](s []T) token.Pos { + return lastElem(s).End() +} +func sqlJoin[T Node](elems []T, sep string) string { + var b strings.Builder + for i, r := range elems { + if i > 0 { + b.WriteString(sep) + } + b.WriteString(r.SQL()) + } + return b.String() +} diff --git a/parser_gql.go b/parser_gql.go index a1322452..e54d2ae2 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -416,7 +416,7 @@ func (p *Parser) parseGqlIsLabelCondition() *ast.GqlIsLabelCondition { LabelExpression: labelExpr, } } -func (p *Parser) parseGqlPatternFilter() *ast.GqlPatternFilter { +func (p *Parser) parseGqlPatternFiller() *ast.GqlPatternFiller { hint := p.tryParseHint() var patternVar *ast.Ident if p.Token.Kind == token.TokenIdent { @@ -427,8 +427,8 @@ func (p *Parser) parseGqlPatternFilter() *ast.GqlPatternFilter { isLabelCondition = p.parseGqlIsLabelCondition() } - filter := p.tryParseGqlPatternFilterFilter() - return &ast.GqlPatternFilter{ + filter := p.tryParseGqlPatternFillerFilter() + return &ast.GqlPatternFiller{ Hint: hint, GraphPatternVariable: patternVar, // TODO IsLabelCondition: isLabelCondition, // TODO @@ -454,12 +454,12 @@ func (p *Parser) lookaheadGqlSubpathPattern() bool { func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { lparen := p.expect("(").Pos - filter := p.parseGqlPatternFilter() + filter := p.parseGqlPatternFiller() rparen := p.expect(")").Pos return &ast.GqlNodePattern{ LParen: lparen, RParen: rparen, - PatternFilter: filter, + PatternFiller: filter, } } @@ -566,13 +566,13 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { } } p.nextToken() - patternFilter := p.parseGqlPatternFilter() + patternFilter := p.parseGqlPatternFiller() p.expect("]") lastPos := p.expect("-").Pos return &ast.GqlFullEdgeLeft{ First: firstPos, Last: lastPos, - PatternFilter: patternFilter, + PatternFiller: patternFilter, } case "-": p.nextToken() @@ -585,7 +585,7 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { } case "[": p.nextToken() - patternFilter := p.parseGqlPatternFilter() + patternFiller := p.parseGqlPatternFiller() p.expect("]") lastHyphenPos := p.expect("-").Pos if p.Token.Kind == ">" { @@ -594,13 +594,13 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { return &ast.GqlFullEdgeRight{ First: firstPos, Last: lastPos, - PatternFilter: patternFilter, + PatternFiller: patternFiller, } } return &ast.GqlFullEdgeAny{ First: firstPos, Last: lastHyphenPos, - PatternFilter: patternFilter, + PatternFiller: patternFiller, } default: return &ast.GqlAbbreviatedEdgeAny{Hyphen: firstPos} @@ -657,7 +657,7 @@ func (p *Parser) parseGqlPropertyFilters() *ast.GqlPropertyFilters { } } -func (p *Parser) tryParseGqlPatternFilterFilter() ast.GqlPatternFilterFilter { +func (p *Parser) tryParseGqlPatternFillerFilter() ast.GqlPatternFillerFilter { switch { case p.Token.Kind == "WHERE": return p.parseWhere() diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index 1cd7e568..649bda2a 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -33,7 +33,7 @@ RETURN p.name PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -61,7 +61,7 @@ RETURN p.name PathTerm: &ast.GqlFullEdgeRight{ First: 31, Last: 41, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 33, @@ -89,7 +89,7 @@ RETURN p.name PathTerm: &ast.GqlNodePattern{ LParen: 42, RParen: 52, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index 4de7c099..3b20533d 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -33,7 +33,7 @@ RETURN p.name PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -61,7 +61,7 @@ RETURN p.name PathTerm: &ast.GqlFullEdgeRight{ First: 31, Last: 41, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 33, @@ -89,7 +89,7 @@ RETURN p.name PathTerm: &ast.GqlNodePattern{ LParen: 42, RParen: 52, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index 2a56882a..f87fb408 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -35,7 +35,7 @@ ORDER BY p.name, element, offset PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -63,7 +63,7 @@ ORDER BY p.name, element, offset PathTerm: &ast.GqlFullEdgeRight{ First: 31, Last: 41, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 33, @@ -91,7 +91,7 @@ ORDER BY p.name, element, offset PathTerm: &ast.GqlNodePattern{ LParen: 42, RParen: 52, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index 7c6592d7..8d39c825 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -33,7 +33,7 @@ RETURN p.name, element, off PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index bfddf40e..d321ea2f 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -35,7 +35,7 @@ RETURN oa.id PathTerm: &ast.GqlNodePattern{ LParen: 23, RParen: 40, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 24, @@ -81,7 +81,7 @@ RETURN oa.id PathTerm: &ast.GqlFullEdgeRight{ First: 41, Last: 51, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, @@ -134,7 +134,7 @@ RETURN oa.id PathTerm: &ast.GqlNodePattern{ LParen: 84, RParen: 94, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 85, @@ -162,7 +162,7 @@ RETURN oa.id PathTerm: &ast.GqlFullEdgeRight{ First: 95, Last: 110, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 97, @@ -190,7 +190,7 @@ RETURN oa.id PathTerm: &ast.GqlNodePattern{ LParen: 111, RParen: 122, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 112, diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index 43c21738..c684487e 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -33,7 +33,7 @@ RETURN oa.id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 38, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -79,7 +79,7 @@ RETURN oa.id PathTerm: &ast.GqlFullEdgeRight{ First: 39, Last: 48, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -103,7 +103,7 @@ RETURN oa.id PathTerm: &ast.GqlNodePattern{ LParen: 49, RParen: 59, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 50, @@ -166,7 +166,7 @@ RETURN oa.id PathTerm: &ast.GqlNodePattern{ LParen: 92, RParen: 102, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 93, @@ -194,7 +194,7 @@ RETURN oa.id PathTerm: &ast.GqlFullEdgeRight{ First: 103, Last: 118, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 105, @@ -222,7 +222,7 @@ RETURN oa.id PathTerm: &ast.GqlNodePattern{ LParen: 119, RParen: 130, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 120, diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index f6f95393..4cac92c0 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -35,7 +35,7 @@ RETURN c.id PathTerm: &ast.GqlNodePattern{ LParen: 23, RParen: 40, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 24, @@ -81,7 +81,7 @@ RETURN c.id PathTerm: &ast.GqlFullEdgeRight{ First: 41, Last: 50, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -105,7 +105,7 @@ RETURN c.id PathTerm: &ast.GqlNodePattern{ LParen: 51, RParen: 61, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 52, @@ -169,7 +169,7 @@ RETURN c.id PathTerm: &ast.GqlNodePattern{ LParen: 181, RParen: 191, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 182, @@ -197,7 +197,7 @@ RETURN c.id PathTerm: &ast.GqlFullEdgeRight{ First: 192, Last: 207, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 194, @@ -225,7 +225,7 @@ RETURN c.id PathTerm: &ast.GqlNodePattern{ LParen: 208, RParen: 218, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 209, diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 48d2ea08..27e5d183 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -33,7 +33,7 @@ RETURN a.id AS a_id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 36, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -61,7 +61,7 @@ RETURN a.id AS a_id PathTerm: &ast.GqlFullEdgeRight{ First: 37, Last: 52, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 39, @@ -89,7 +89,7 @@ RETURN a.id AS a_id PathTerm: &ast.GqlNodePattern{ LParen: 53, RParen: 73, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 54, diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index bb686683..53d87f57 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -34,7 +34,7 @@ RETURN source.nick_name PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 36, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -62,7 +62,7 @@ RETURN source.nick_name PathTerm: &ast.GqlFullEdgeRight{ First: 37, Last: 52, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 39, @@ -90,7 +90,7 @@ RETURN source.nick_name PathTerm: &ast.GqlNodePattern{ LParen: 53, RParen: 73, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 54, diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt index e19bd96c..49b909b5 100644 --- a/testdata/result/gql/match.sql.txt +++ b/testdata/result/gql/match.sql.txt @@ -32,7 +32,7 @@ RETURN p.name, p.id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index 87da585e..f4ac32de 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -37,7 +37,7 @@ RETURN a.id AS a_id, total, b.id AS b_id PathTerm: &ast.GqlNodePattern{ LParen: 34, RParen: 44, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 35, @@ -65,7 +65,7 @@ RETURN a.id AS a_id, total, b.id AS b_id PathTerm: &ast.GqlFullEdgeRight{ First: 45, Last: 60, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -108,7 +108,7 @@ RETURN a.id AS a_id, total, b.id AS b_id PathTerm: &ast.GqlNodePattern{ LParen: 68, RParen: 78, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 69, diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index 657e2b76..4a185fe1 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -33,7 +33,7 @@ RETURN n.name, a.id AS blocked_account_id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -79,7 +79,7 @@ RETURN n.name, a.id AS blocked_account_id PathTerm: &ast.GqlNodePattern{ LParen: 47, RParen: 56, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 48, @@ -107,7 +107,7 @@ RETURN n.name, a.id AS blocked_account_id PathTerm: &ast.GqlFullEdgeRight{ First: 57, Last: 66, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -131,7 +131,7 @@ RETURN n.name, a.id AS blocked_account_id PathTerm: &ast.GqlNodePattern{ LParen: 67, RParen: 96, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 68, diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt index 4f2e4485..d0afc2cd 100644 --- a/testdata/result/gql/match_or_expression.sql.txt +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -32,7 +32,7 @@ RETURN n.id, n.name, n.nick_name PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 38, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index a94995b5..bb06991d 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -50,7 +50,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlNodePattern{ LParen: 30, RParen: 41, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 31, @@ -78,7 +78,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlFullEdgeRight{ First: 42, Last: 58, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 44, @@ -115,7 +115,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlNodePattern{ LParen: 62, RParen: 73, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 63, @@ -149,7 +149,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlFullEdgeRight{ First: 78, Last: 94, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 80, @@ -177,7 +177,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlNodePattern{ LParen: 95, RParen: 106, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 96, diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 0cda9ac0..993b2a2e 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -56,7 +56,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlNodePattern{ LParen: 33, RParen: 44, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 34, @@ -84,7 +84,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlFullEdgeRight{ First: 45, Last: 61, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -121,7 +121,7 @@ RETURN COUNT(1) as num_paths PathTerm: &ast.GqlNodePattern{ LParen: 65, RParen: 76, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 66, diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index b7de4010..ab1ab263 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -47,7 +47,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -71,7 +71,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTerm: &ast.GqlFullEdgeRight{ First: 31, Last: 45, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -95,7 +95,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTerm: &ast.GqlNodePattern{ LParen: 46, RParen: 62, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -184,7 +184,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTerm: &ast.GqlNodePattern{ LParen: 145, RParen: 161, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 146, @@ -212,7 +212,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTerm: &ast.GqlFullEdgeLeft{ First: 162, Last: 171, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -236,7 +236,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTerm: &ast.GqlNodePattern{ LParen: 172, RParen: 185, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 173, diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 8ee2be47..39864132 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -40,7 +40,7 @@ RETURN PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -64,7 +64,7 @@ RETURN PathTerm: &ast.GqlFullEdgeRight{ First: 31, Last: 45, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -88,7 +88,7 @@ RETURN PathTerm: &ast.GqlNodePattern{ LParen: 46, RParen: 62, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -177,7 +177,7 @@ RETURN PathTerm: &ast.GqlNodePattern{ LParen: 145, RParen: 161, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 146, @@ -205,7 +205,7 @@ RETURN PathTerm: &ast.GqlFullEdgeLeft{ First: 162, Last: 171, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -229,7 +229,7 @@ RETURN PathTerm: &ast.GqlNodePattern{ LParen: 172, RParen: 185, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 173, diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt index 7f66852f..231053db 100644 --- a/testdata/result/gql/offset_1.sql.txt +++ b/testdata/result/gql/offset_1.sql.txt @@ -33,7 +33,7 @@ RETURN p.name, p.id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index 7f8bf0fc..9f7f5eec 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -34,7 +34,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 41, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -62,7 +62,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount PathTerm: &ast.GqlFullEdgeRight{ First: 42, Last: 64, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 44, @@ -90,7 +90,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount PathTerm: &ast.GqlNodePattern{ LParen: 65, RParen: 85, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 66, diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index 2af506f6..3f6ee5ba 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -39,7 +39,7 @@ ORDER BY num_incoming_transfers DESC PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -63,7 +63,7 @@ ORDER BY num_incoming_transfers DESC PathTerm: &ast.GqlFullEdgeRight{ First: 31, Last: 45, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -87,7 +87,7 @@ ORDER BY num_incoming_transfers DESC PathTerm: &ast.GqlNodePattern{ LParen: 46, RParen: 62, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -176,7 +176,7 @@ ORDER BY num_incoming_transfers DESC PathTerm: &ast.GqlNodePattern{ LParen: 145, RParen: 161, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 146, @@ -204,7 +204,7 @@ ORDER BY num_incoming_transfers DESC PathTerm: &ast.GqlFullEdgeLeft{ First: 162, Last: 171, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -228,7 +228,7 @@ ORDER BY num_incoming_transfers DESC PathTerm: &ast.GqlNodePattern{ LParen: 172, RParen: 185, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 173, diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index 5b0b0004..90106db3 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -32,7 +32,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 41, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -78,7 +78,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id PathTerm: &ast.GqlFullEdgeRight{ First: 42, Last: 57, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 44, @@ -121,7 +121,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id PathTerm: &ast.GqlNodePattern{ LParen: 64, RParen: 76, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 65, diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt index 6c11cc35..c35411ff 100644 --- a/testdata/result/gql/skip_1.sql.txt +++ b/testdata/result/gql/skip_1.sql.txt @@ -33,7 +33,7 @@ RETURN p.name, p.id PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index 405448cc..d67fb070 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -33,7 +33,7 @@ RETURN account.id AS account_id, num_incoming_transfers PathTerm: &ast.GqlNodePattern{ LParen: 21, RParen: 30, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -57,7 +57,7 @@ RETURN account.id AS account_id, num_incoming_transfers PathTerm: &ast.GqlFullEdgeRight{ First: 31, Last: 45, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: &ast.GqlIsLabelCondition{ @@ -81,7 +81,7 @@ RETURN account.id AS account_id, num_incoming_transfers PathTerm: &ast.GqlNodePattern{ LParen: 46, RParen: 62, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, diff --git a/testdata/result/gql_path_pattern/full_edge_any.sql.txt b/testdata/result/gql_path_pattern/full_edge_any.sql.txt index bb5713f0..936a34da 100644 --- a/testdata/result/gql_path_pattern/full_edge_any.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_any.sql.txt @@ -8,7 +8,7 @@ PathTerm: &ast.GqlFullEdgeAny{ First: 1, Last: 5, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 3, diff --git a/testdata/result/gql_path_pattern/full_edge_left.sql.txt b/testdata/result/gql_path_pattern/full_edge_left.sql.txt index b5765a73..f2449421 100644 --- a/testdata/result/gql_path_pattern/full_edge_left.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_left.sql.txt @@ -8,7 +8,7 @@ PathTerm: &ast.GqlFullEdgeLeft{ First: 2, Last: 7, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 5, diff --git a/testdata/result/gql_path_pattern/full_edge_right.sql.txt b/testdata/result/gql_path_pattern/full_edge_right.sql.txt index 3385b0a5..0eabfb87 100644 --- a/testdata/result/gql_path_pattern/full_edge_right.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_right.sql.txt @@ -8,7 +8,7 @@ PathTerm: &ast.GqlFullEdgeRight{ First: 1, Last: 5, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), diff --git a/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt index 4c4fe918..5eec245a 100644 --- a/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt +++ b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt @@ -8,7 +8,7 @@ PathTerm: &ast.GqlNodePattern{ LParen: 1, RParen: 2, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), diff --git a/testdata/result/gql_path_pattern/pattern_1.sql.txt b/testdata/result/gql_path_pattern/pattern_1.sql.txt index 956e4276..bde1718d 100644 --- a/testdata/result/gql_path_pattern/pattern_1.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_1.sql.txt @@ -8,7 +8,7 @@ PathTerm: &ast.GqlNodePattern{ LParen: 0, RParen: 4, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 1, diff --git a/testdata/result/gql_path_pattern/pattern_2.sql.txt b/testdata/result/gql_path_pattern/pattern_2.sql.txt index 162077a7..eb689478 100644 --- a/testdata/result/gql_path_pattern/pattern_2.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_2.sql.txt @@ -8,7 +8,7 @@ PathTerm: &ast.GqlNodePattern{ LParen: 0, RParen: 31, - PatternFilter: &ast.GqlPatternFilter{ + PatternFiller: &ast.GqlPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 1, From 717a60a37251b72931dcb29a112969cb9f68f8c1 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 08:43:51 +0900 Subject: [PATCH 14/53] Add GRAPH_TABLE tests --- ast/ast.go | 11 ++- .../input/query/select_from_graph_table.sql | 1 + .../query/select_from_graph_table.sql.txt | 75 +++++++++++++++++++ .../statement/select_from_graph_table.sql.txt | 75 +++++++++++++++++++ 4 files changed, 156 insertions(+), 6 deletions(-) create mode 100644 testdata/input/query/select_from_graph_table.sql create mode 100644 testdata/result/query/select_from_graph_table.sql.txt create mode 100644 testdata/result/statement/select_from_graph_table.sql.txt diff --git a/ast/ast.go b/ast/ast.go index a186d4de..ce3d0028 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -734,6 +734,9 @@ type ParenTableExpr struct { Sample *TableSample // optional } +// GraphTableExpr is GRAPH_TABLE operator +// +// GRAPH_TABLE({{.PropertyGraphName | sql}} {{.Query | sql}}) {{.As | sqlOpt}} type GraphTableExpr struct { // pos = GraphTable.Pos // end = As.end || Rparen + 1 @@ -758,14 +761,10 @@ func (g GraphTableExpr) End() token.Pos { } func (g GraphTableExpr) SQL() string { - sql := "GRAPH_TABLE(\n" + + return "GRAPH_TABLE(\n" + g.PropertyGraphName.SQL() + "\n" + g.Query.SQL() + "\n" + - ")" - if g.As != nil { - sql += " " + g.As.SQL() - } - return sql + ")" + sqlOpt(" ", g.As, "") } func (g GraphTableExpr) isTableExpr() {} diff --git a/testdata/input/query/select_from_graph_table.sql b/testdata/input/query/select_from_graph_table.sql new file mode 100644 index 00000000..04f0a5a4 --- /dev/null +++ b/testdata/input/query/select_from_graph_table.sql @@ -0,0 +1 @@ +SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) \ No newline at end of file diff --git a/testdata/result/query/select_from_graph_table.sql.txt b/testdata/result/query/select_from_graph_table.sql.txt new file mode 100644 index 00000000..f51ad952 --- /dev/null +++ b/testdata/result/query/select_from_graph_table.sql.txt @@ -0,0 +1,75 @@ +--- select_from_graph_table.sql +SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) +--- AST +&ast.QueryStatement{ + Hint: (*ast.Hint)(nil), + With: (*ast.With)(nil), + Query: &ast.Select{ + Select: 0, + Distinct: false, + AsStruct: false, + Results: []ast.SelectItem{ + &ast.Star{ + Star: 7, + }, + }, + From: &ast.From{ + From: 9, + Source: &ast.GraphTableExpr{ + GraphTable: 14, + PropertyGraphName: &ast.Ident{ + NamePos: 26, + NameEnd: 34, + Name: "FinGraph", + }, + Lparen: 25, + Rparen: 48, + Query: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 35, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.IntLiteral{ + ValuePos: 42, + ValueEnd: 43, + Base: 10, + Value: "1", + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "a", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, + As: (*ast.AsAlias)(nil), + }, + }, + Where: (*ast.Where)(nil), + GroupBy: (*ast.GroupBy)(nil), + Having: (*ast.Having)(nil), + OrderBy: (*ast.OrderBy)(nil), + Limit: (*ast.Limit)(nil), + }, +} + +--- SQL +SELECT * FROM GRAPH_TABLE( +FinGraph +RETURN 1 AS a +) diff --git a/testdata/result/statement/select_from_graph_table.sql.txt b/testdata/result/statement/select_from_graph_table.sql.txt new file mode 100644 index 00000000..f51ad952 --- /dev/null +++ b/testdata/result/statement/select_from_graph_table.sql.txt @@ -0,0 +1,75 @@ +--- select_from_graph_table.sql +SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) +--- AST +&ast.QueryStatement{ + Hint: (*ast.Hint)(nil), + With: (*ast.With)(nil), + Query: &ast.Select{ + Select: 0, + Distinct: false, + AsStruct: false, + Results: []ast.SelectItem{ + &ast.Star{ + Star: 7, + }, + }, + From: &ast.From{ + From: 9, + Source: &ast.GraphTableExpr{ + GraphTable: 14, + PropertyGraphName: &ast.Ident{ + NamePos: 26, + NameEnd: 34, + Name: "FinGraph", + }, + Lparen: 25, + Rparen: 48, + Query: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 35, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.IntLiteral{ + ValuePos: 42, + ValueEnd: 43, + Base: 10, + Value: "1", + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "a", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, + As: (*ast.AsAlias)(nil), + }, + }, + Where: (*ast.Where)(nil), + GroupBy: (*ast.GroupBy)(nil), + Having: (*ast.Having)(nil), + OrderBy: (*ast.OrderBy)(nil), + Limit: (*ast.Limit)(nil), + }, +} + +--- SQL +SELECT * FROM GRAPH_TABLE( +FinGraph +RETURN 1 AS a +) From d7639211379beb63b62f8e05e919ec0d0ef1cd42 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 08:52:41 +0900 Subject: [PATCH 15/53] Clean GraphTableExpr --- ast/ast.go | 21 +-------------------- ast/pos.go | 8 ++++++++ ast/sql.go | 7 +++++++ 3 files changed, 16 insertions(+), 20 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index ce3d0028..a0d4b1cd 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -107,6 +107,7 @@ func (TableName) isTableExpr() {} func (SubQueryTableExpr) isTableExpr() {} func (ParenTableExpr) isTableExpr() {} func (Join) isTableExpr() {} +func (*GraphTableExpr) isTableExpr() {} // JoinCondition represents condition part of JOIN expression. type JoinCondition interface { @@ -749,26 +750,6 @@ type GraphTableExpr struct { As *AsAlias // optional } -func (g GraphTableExpr) Pos() token.Pos { - return g.GraphTable -} - -func (g GraphTableExpr) End() token.Pos { - if g.As != nil { - return g.As.End() - } - return g.Rparen + 1 -} - -func (g GraphTableExpr) SQL() string { - return "GRAPH_TABLE(\n" + - g.PropertyGraphName.SQL() + "\n" + - g.Query.SQL() + "\n" + - ")" + sqlOpt(" ", g.As, "") -} - -func (g GraphTableExpr) isTableExpr() {} - // Join is JOIN expression. // // {{.Left | sql}} diff --git a/ast/pos.go b/ast/pos.go index ad28dcae..7fdc5381 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -263,6 +263,14 @@ func (t *TableSample) End() token.Pos { return t.Size.End() } func (t *TableSampleSize) Pos() token.Pos { return t.Lparen } func (t *TableSampleSize) End() token.Pos { return t.Rparen + 1 } +func (g *GraphTableExpr) Pos() token.Pos { return g.GraphTable } +func (g *GraphTableExpr) End() token.Pos { + if g.As != nil { + return g.As.End() + } + return g.Rparen + 1 +} + // ================================================================================ // // Expr diff --git a/ast/sql.go b/ast/sql.go index 8c3fdad5..ac5dd1cf 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -361,6 +361,13 @@ func (t *TableSampleSize) SQL() string { return "(" + t.Value.SQL() + " " + string(t.Unit) + ")" } +func (g *GraphTableExpr) SQL() string { + return "GRAPH_TABLE(\n" + + g.PropertyGraphName.SQL() + "\n" + + g.Query.SQL() + "\n" + + ")" + sqlOpt(" ", g.As, "") +} + // ================================================================================ // // Expr From 175e9294aab290651b4444f6edaddc295380eea1 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 09:26:03 +0900 Subject: [PATCH 16/53] Implement IN GQL subquery --- ast/ast.go | 13 ++ ast/gql.go | 30 ++- ast/pos.go | 3 + ast/sql.go | 4 + parser.go | 3 + parser_gql.go | 17 ++ testdata/input/gql/return_in_gql_subquery.sql | 5 + .../input/query/select_in_gql_subquery.sql | 5 + .../result/gql/return_in_gql_subquery.sql.txt | 199 ++++++++++++++++++ .../query/select_in_gql_subquery.sql.txt | 196 +++++++++++++++++ .../statement/select_in_gql_subquery.sql.txt | 196 +++++++++++++++++ 11 files changed, 668 insertions(+), 3 deletions(-) create mode 100644 testdata/input/gql/return_in_gql_subquery.sql create mode 100644 testdata/input/query/select_in_gql_subquery.sql create mode 100644 testdata/result/gql/return_in_gql_subquery.sql.txt create mode 100644 testdata/result/query/select_in_gql_subquery.sql.txt create mode 100644 testdata/result/statement/select_in_gql_subquery.sql.txt diff --git a/ast/ast.go b/ast/ast.go index a0d4b1cd..adb153d6 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -175,6 +175,7 @@ type InCondition interface { func (UnnestInCondition) isInCondition() {} func (SubQueryInCondition) isInCondition() {} func (ValuesInCondition) isInCondition() {} +func (*GqlSubQuery) isInCondition() {} // Type represents type node. type Type interface { @@ -898,6 +899,18 @@ type ValuesInCondition struct { Exprs []Expr // len(Exprs) > 0 } +// GqlSubQuery is GQL subquery at IN condition. +// +// {{"{"}}{{.Query | sql}}}{{"}"}} +type GqlSubQuery struct { + // pos = LBrace + // end = RBrace + 1 + + LBrace, RBrace token.Pos // position of "{" and "}" + + Query *GqlQueryExpr +} + // IsNullExpr is IS NULL expression node. // // {{.Left | sql}} IS {{if .Not}}NOT{{end}} NULL diff --git a/ast/gql.go b/ast/gql.go index 3f1cbaad..5040e28b 100644 --- a/ast/gql.go +++ b/ast/gql.go @@ -5,24 +5,48 @@ import ( "github.com/cloudspannerecosystem/memefish/token" ) +// GqlGraphQuery is toplevel node of GRAPH query. type GqlGraphQuery struct { + // pos = (GraphClause ?? GqlMultiLinearQueryStatement).pos + // end = GqlMultiLinearQueryStatement.pos GraphClause *GqlGraphClause GqlMultiLinearQueryStatement *GqlMultiLinearQueryStatement } -func (g GqlGraphQuery) Pos() token.Pos { +func (g *GqlGraphQuery) Pos() token.Pos { return g.GraphClause.Pos() } -func (g GqlGraphQuery) End() token.Pos { +func (g *GqlGraphQuery) End() token.Pos { return g.GqlMultiLinearQueryStatement.End() } -func (g GqlGraphQuery) isStatement() {} +func (g *GqlGraphQuery) isStatement() {} func (s *GqlGraphQuery) SQL() string { return s.GraphClause.SQL() + "\n" + s.GqlMultiLinearQueryStatement.SQL() } +// GqlQueryExpr is similar to GqlGraphQuery, +// but it is appeared in GQL subqueries and it can optionally have GRAPH clause +type GqlQueryExpr struct { + // pos = (GraphClause ?? GqlMultiLinearQueryStatement).pos + // end = GqlMultiLinearQueryStatement.pos + GraphClause *GqlGraphClause // optional + GqlMultiLinearQueryStatement *GqlMultiLinearQueryStatement +} + +func (g *GqlQueryExpr) Pos() token.Pos { + return firstValidPos(g.GraphClause, g.GqlMultiLinearQueryStatement) +} + +func (g *GqlQueryExpr) End() token.Pos { + return g.GqlMultiLinearQueryStatement.End() +} + +func (g *GqlQueryExpr) SQL() string { + return sqlOpt("", g.GraphClause, "\n") + g.GqlMultiLinearQueryStatement.SQL() +} + type GqlGraphClause struct { GqlGraph token.Pos GqlPropertyGraphName *Ident diff --git a/ast/pos.go b/ast/pos.go index 7fdc5381..af6f5c1e 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -295,6 +295,9 @@ func (s *SubQueryInCondition) End() token.Pos { return s.Rparen + 1 } func (v *ValuesInCondition) Pos() token.Pos { return v.Lparen } func (v *ValuesInCondition) End() token.Pos { return v.Rparen + 1 } +func (g *GqlSubQuery) Pos() token.Pos { return g.LBrace } +func (g *GqlSubQuery) End() token.Pos { return g.RBrace + 1 } + func (i *IsNullExpr) Pos() token.Pos { return i.Left.Pos() } func (i *IsNullExpr) End() token.Pos { return i.Null + 4 } diff --git a/ast/sql.go b/ast/sql.go index ac5dd1cf..84993528 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -418,6 +418,10 @@ func (v *ValuesInCondition) SQL() string { return sql } +func (g *GqlSubQuery) SQL() string { + return "{" + g.Query.SQL() + "}" +} + func (i *IsNullExpr) SQL() string { p := exprPrec(i) sql := paren(p, i.Left) diff --git a/parser.go b/parser.go index 2e62b647..ae397644 100644 --- a/parser.go +++ b/parser.go @@ -1213,6 +1213,9 @@ func (p *Parser) parseInCondition() ast.InCondition { } } + if p.Token.Kind == "{" { + return p.parseGqlSubquery() + } if p.Token.Kind == "(" { lparen := p.Token.Pos p.nextToken() diff --git a/parser_gql.go b/parser_gql.go index e54d2ae2..b16c5efa 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -19,6 +19,23 @@ func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { return &ast.GqlGraphQuery{GraphClause: graphClause, GqlMultiLinearQueryStatement: multiQueryStatement} } +func (p *Parser) parseGqlSubquery() *ast.GqlSubQuery { + lbrace := p.expect("{").Pos + query := p.parseGqlQueryExpr() + rbrace := p.expect("}").Pos + + return &ast.GqlSubQuery{LBrace: lbrace, RBrace: rbrace, Query: query} +} +func (p *Parser) parseGqlQueryExpr() *ast.GqlQueryExpr { + var graphClause *ast.GqlGraphClause + if p.Token.IsKeywordLike("GRAPH") { + graphClause = p.parseGqlGraphClause() + } + multiQueryStatement := p.parseGqlMultiLinearQueryStatement() + + return &ast.GqlQueryExpr{GraphClause: graphClause, GqlMultiLinearQueryStatement: multiQueryStatement} +} + func (p *Parser) parseGqlGraphClause() *ast.GqlGraphClause { graphPos := p.expectKeywordLike("GRAPH").Pos graphName := p.parseIdent() diff --git a/testdata/input/gql/return_in_gql_subquery.sql b/testdata/input/gql/return_in_gql_subquery.sql new file mode 100644 index 00000000..8dc11778 --- /dev/null +++ b/testdata/input/gql/return_in_gql_subquery.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +RETURN 'Dana' IN { + MATCH (p:Person)-[o:Owns]->(a:Account) + RETURN p.name +} AS results \ No newline at end of file diff --git a/testdata/input/query/select_in_gql_subquery.sql b/testdata/input/query/select_in_gql_subquery.sql new file mode 100644 index 00000000..d7f84916 --- /dev/null +++ b/testdata/input/query/select_in_gql_subquery.sql @@ -0,0 +1,5 @@ +SELECT 'Dana' IN { + GRAPH FinGraph + MATCH (p:Person)-[o:Owns]->(a:Account) + RETURN p.name +} AS results \ No newline at end of file diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt new file mode 100644 index 00000000..d48f9d20 --- /dev/null +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -0,0 +1,199 @@ +--- return_in_gql_subquery.sql +GRAPH FinGraph +RETURN 'Dana' IN { + MATCH (p:Person)-[o:Owns]->(a:Account) + RETURN p.name +} AS results +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 15, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.InExpr{ + Not: false, + Left: &ast.StringLiteral{ + ValuePos: 22, + ValueEnd: 28, + Value: "Dana", + }, + Right: &ast.GqlSubQuery{ + LBrace: 32, + RBrace: 91, + Query: &ast.GqlQueryExpr{ + GraphClause: (*ast.GqlGraphClause)(nil), + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 36, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 42, + RParen: 51, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 43, + NameEnd: 44, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 44, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 45, + NameEnd: 51, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 52, + Last: 62, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 54, + NameEnd: 55, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 55, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 56, + NameEnd: 60, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 63, + RParen: 73, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 64, + NameEnd: 65, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 65, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 66, + NameEnd: 73, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 77, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 84, + NameEnd: 85, + Name: "p", + }, + &ast.Ident{ + NamePos: 86, + NameEnd: 90, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 96, + NameEnd: 103, + Name: "results", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +RETURN "Dana" IN {MATCH (p:Person)-[o:Owns]->(a:Account) +RETURN p.name} AS results diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt new file mode 100644 index 00000000..17ded36d --- /dev/null +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -0,0 +1,196 @@ +--- select_in_gql_subquery.sql +SELECT 'Dana' IN { + GRAPH FinGraph + MATCH (p:Person)-[o:Owns]->(a:Account) + RETURN p.name +} AS results +--- AST +&ast.QueryStatement{ + Hint: (*ast.Hint)(nil), + With: (*ast.With)(nil), + Query: &ast.Select{ + Select: 0, + Distinct: false, + AsStruct: false, + Results: []ast.SelectItem{ + &ast.Alias{ + Expr: &ast.InExpr{ + Not: false, + Left: &ast.StringLiteral{ + ValuePos: 7, + ValueEnd: 13, + Value: "Dana", + }, + Right: &ast.GqlSubQuery{ + LBrace: 17, + RBrace: 93, + Query: &ast.GqlQueryExpr{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 21, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 27, + NameEnd: 35, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 38, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 44, + RParen: 53, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 45, + NameEnd: 46, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 46, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 47, + NameEnd: 53, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 54, + Last: 64, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 56, + NameEnd: 57, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 57, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 58, + NameEnd: 62, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 65, + RParen: 75, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 66, + NameEnd: 67, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 67, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 68, + NameEnd: 75, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 79, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 86, + NameEnd: 87, + Name: "p", + }, + &ast.Ident{ + NamePos: 88, + NameEnd: 92, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 98, + NameEnd: 105, + Name: "results", + }, + }, + }, + }, + From: (*ast.From)(nil), + Where: (*ast.Where)(nil), + GroupBy: (*ast.GroupBy)(nil), + Having: (*ast.Having)(nil), + OrderBy: (*ast.OrderBy)(nil), + Limit: (*ast.Limit)(nil), + }, +} + +--- SQL +SELECT "Dana" IN {GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +RETURN p.name} AS results diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt new file mode 100644 index 00000000..17ded36d --- /dev/null +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -0,0 +1,196 @@ +--- select_in_gql_subquery.sql +SELECT 'Dana' IN { + GRAPH FinGraph + MATCH (p:Person)-[o:Owns]->(a:Account) + RETURN p.name +} AS results +--- AST +&ast.QueryStatement{ + Hint: (*ast.Hint)(nil), + With: (*ast.With)(nil), + Query: &ast.Select{ + Select: 0, + Distinct: false, + AsStruct: false, + Results: []ast.SelectItem{ + &ast.Alias{ + Expr: &ast.InExpr{ + Not: false, + Left: &ast.StringLiteral{ + ValuePos: 7, + ValueEnd: 13, + Value: "Dana", + }, + Right: &ast.GqlSubQuery{ + LBrace: 17, + RBrace: 93, + Query: &ast.GqlQueryExpr{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 21, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 27, + NameEnd: 35, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 38, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 44, + RParen: 53, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 45, + NameEnd: 46, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 46, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 47, + NameEnd: 53, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 54, + Last: 64, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 56, + NameEnd: 57, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 57, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 58, + NameEnd: 62, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 65, + RParen: 75, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 66, + NameEnd: 67, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 67, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 68, + NameEnd: 75, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 79, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 86, + NameEnd: 87, + Name: "p", + }, + &ast.Ident{ + NamePos: 88, + NameEnd: 92, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 98, + NameEnd: 105, + Name: "results", + }, + }, + }, + }, + From: (*ast.From)(nil), + Where: (*ast.Where)(nil), + GroupBy: (*ast.GroupBy)(nil), + Having: (*ast.Having)(nil), + OrderBy: (*ast.OrderBy)(nil), + Limit: (*ast.Limit)(nil), + }, +} + +--- SQL +SELECT "Dana" IN {GRAPH FinGraph +MATCH (p:Person)-[o:Owns]->(a:Account) +RETURN p.name} AS results From e322d36fc8f524faa8d00d8fb7d4e2af3b44146a Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 10:09:43 +0900 Subject: [PATCH 17/53] Implement ARRAY and VALUE GQL subqueries --- ast/ast.go | 100 +++-- ast/gql.go | 62 ++- ast/pos.go | 16 +- ast/sql.go | 16 +- parser.go | 21 ++ parser_gql.go | 4 +- testdata/input/gql/return_array_subquery.sql | 9 + testdata/input/gql/return_value_subquery.sql | 7 + .../result/gql/return_array_subquery.sql.txt | 355 ++++++++++++++++++ .../result/gql/return_in_gql_subquery.sql.txt | 2 +- .../result/gql/return_value_subquery.sql.txt | 174 +++++++++ .../query/select_in_gql_subquery.sql.txt | 2 +- .../statement/select_in_gql_subquery.sql.txt | 2 +- 13 files changed, 688 insertions(+), 82 deletions(-) create mode 100644 testdata/input/gql/return_array_subquery.sql create mode 100644 testdata/input/gql/return_value_subquery.sql create mode 100644 testdata/result/gql/return_array_subquery.sql.txt create mode 100644 testdata/result/gql/return_value_subquery.sql.txt diff --git a/ast/ast.go b/ast/ast.go index adb153d6..1f51754d 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -124,37 +124,39 @@ type Expr interface { isExpr() } -func (BinaryExpr) isExpr() {} -func (UnaryExpr) isExpr() {} -func (InExpr) isExpr() {} -func (IsNullExpr) isExpr() {} -func (IsBoolExpr) isExpr() {} -func (BetweenExpr) isExpr() {} -func (SelectorExpr) isExpr() {} -func (IndexExpr) isExpr() {} -func (CallExpr) isExpr() {} -func (CountStarExpr) isExpr() {} -func (CastExpr) isExpr() {} -func (ExtractExpr) isExpr() {} -func (CaseExpr) isExpr() {} -func (ParenExpr) isExpr() {} -func (ScalarSubQuery) isExpr() {} -func (ArraySubQuery) isExpr() {} -func (ExistsSubQuery) isExpr() {} -func (Param) isExpr() {} -func (Ident) isExpr() {} -func (Path) isExpr() {} -func (ArrayLiteral) isExpr() {} -func (StructLiteral) isExpr() {} -func (NullLiteral) isExpr() {} -func (BoolLiteral) isExpr() {} -func (IntLiteral) isExpr() {} -func (FloatLiteral) isExpr() {} -func (StringLiteral) isExpr() {} -func (BytesLiteral) isExpr() {} -func (DateLiteral) isExpr() {} -func (TimestampLiteral) isExpr() {} -func (NumericLiteral) isExpr() {} +func (BinaryExpr) isExpr() {} +func (UnaryExpr) isExpr() {} +func (InExpr) isExpr() {} +func (IsNullExpr) isExpr() {} +func (IsBoolExpr) isExpr() {} +func (BetweenExpr) isExpr() {} +func (SelectorExpr) isExpr() {} +func (IndexExpr) isExpr() {} +func (CallExpr) isExpr() {} +func (CountStarExpr) isExpr() {} +func (CastExpr) isExpr() {} +func (ExtractExpr) isExpr() {} +func (CaseExpr) isExpr() {} +func (ParenExpr) isExpr() {} +func (ScalarSubQuery) isExpr() {} +func (ArraySubQuery) isExpr() {} +func (ExistsSubQuery) isExpr() {} +func (Param) isExpr() {} +func (Ident) isExpr() {} +func (Path) isExpr() {} +func (ArrayLiteral) isExpr() {} +func (StructLiteral) isExpr() {} +func (NullLiteral) isExpr() {} +func (BoolLiteral) isExpr() {} +func (IntLiteral) isExpr() {} +func (FloatLiteral) isExpr() {} +func (StringLiteral) isExpr() {} +func (BytesLiteral) isExpr() {} +func (DateLiteral) isExpr() {} +func (TimestampLiteral) isExpr() {} +func (NumericLiteral) isExpr() {} +func (*ArrayGqlSubQuery) isExpr() {} +func (*ValueGqlSubQuery) isExpr() {} // Arg represents argument of function call. type Arg interface { @@ -172,10 +174,10 @@ type InCondition interface { isInCondition() } -func (UnnestInCondition) isInCondition() {} -func (SubQueryInCondition) isInCondition() {} -func (ValuesInCondition) isInCondition() {} -func (*GqlSubQuery) isInCondition() {} +func (UnnestInCondition) isInCondition() {} +func (SubQueryInCondition) isInCondition() {} +func (ValuesInCondition) isInCondition() {} +func (*GqlSubQueryInCondition) isInCondition() {} // Type represents type node. type Type interface { @@ -899,10 +901,10 @@ type ValuesInCondition struct { Exprs []Expr // len(Exprs) > 0 } -// GqlSubQuery is GQL subquery at IN condition. +// GqlSubQueryInCondition is GQL subquery at IN condition. // // {{"{"}}{{.Query | sql}}}{{"}"}} -type GqlSubQuery struct { +type GqlSubQueryInCondition struct { // pos = LBrace // end = RBrace + 1 @@ -1152,6 +1154,30 @@ type ArraySubQuery struct { Query QueryExpr } +// ArrayGqlSubQuery is GQL subquery as ARRAY. +// +// ARRAY{{"{"}}{{.Query | sql}}{{"}"}} +type ArrayGqlSubQuery struct { + // pos = Array + // end = RBrace + 1 + + Array token.Pos // position of "ARRAY" keyword + RBrace token.Pos // position of "{" and "}" + Query *GqlQueryExpr +} + +// ValueGqlSubQuery is GQL subquery as VALUE. +// +// VALUE{{"{"}}{{.Query | sql}}{{"}"}} +type ValueGqlSubQuery struct { + // pos = Array + // end = RBrace + 1 + + Array token.Pos // position of "ARRAY" keyword + RBrace token.Pos // position of "{" and "}" + Query *GqlQueryExpr +} + // ExistsSubQuery is subquery in EXISTS call. // // EXISTS {{.Hint | sqlOpt}} ({{.Query | sql}}) diff --git a/ast/gql.go b/ast/gql.go index 5040e28b..d54e02f8 100644 --- a/ast/gql.go +++ b/ast/gql.go @@ -223,79 +223,67 @@ type GqlLimitAndOffsetClause interface { // GqlLimitClause is wrapper of Limit for GQL type GqlLimitClause struct { + // pos = Limit.pos + // end = Limit.end Limit *Limit } // GqlOffsetClause is wrapper of Offset for GQL type GqlOffsetClause struct { + // pos = Offset.pos + // end = Offset.end Offset *Offset } -func (g GqlOffsetClause) Pos() token.Pos { - //TODO implement me - panic("implement me") +func (g *GqlOffsetClause) Pos() token.Pos { + return g.Pos() } -func (g GqlOffsetClause) End() token.Pos { - //TODO implement me - panic("implement me") +func (g *GqlOffsetClause) End() token.Pos { + return g.End() } -func (g GqlOffsetClause) SQL() string { - //TODO implement me - panic("implement me") +func (g *GqlOffsetClause) SQL() string { + return g.SQL() } -func (g GqlOffsetClause) isGqlLimitAndOffsetClause() { - //TODO implement me - panic("implement me") -} +func (g *GqlOffsetClause) isGqlLimitAndOffsetClause() {} // GqlLimitClauseWithOffset type GqlLimitWithOffsetClause struct { + // pos = Limit.pos + // end = Offset.end Limit *Limit Offset *Offset } func (g GqlLimitWithOffsetClause) Pos() token.Pos { - //TODO implement me - panic("implement me") + return g.Limit.Pos() } func (g GqlLimitWithOffsetClause) End() token.Pos { - //TODO implement me - panic("implement me") + return g.Offset.End() } -func (g GqlLimitWithOffsetClause) SQL() string { - //TODO implement me - panic("implement me") +func (g *GqlLimitWithOffsetClause) SQL() string { + return g.Limit.SQL() + " " + g.Offset.SQL() } -func (g GqlLimitWithOffsetClause) isGqlLimitAndOffsetClause() { - //TODO implement me - panic("implement me") -} +func (g *GqlLimitWithOffsetClause) isGqlLimitAndOffsetClause() {} -func (g GqlLimitClause) Pos() token.Pos { - //TODO implement me - panic("implement me") +func (g *GqlLimitClause) Pos() token.Pos { + return g.Limit.Pos() } -func (g GqlLimitClause) End() token.Pos { - //TODO implement me - panic("implement me") +func (g *GqlLimitClause) End() token.Pos { + return g.Limit.End() } -func (g GqlLimitClause) SQL() string { - //TODO implement me - panic("implement me") +func (g *GqlLimitClause) SQL() string { + return g.Limit.SQL() } -func (g GqlLimitClause) isGqlLimitAndOffsetClause() { - //TODO implement me - panic("implement me") -} +func (g *GqlLimitClause) isGqlLimitAndOffsetClause() {} type GqlFilterStatement struct { Filter token.Pos diff --git a/ast/pos.go b/ast/pos.go index af6f5c1e..3df0d780 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -295,8 +295,8 @@ func (s *SubQueryInCondition) End() token.Pos { return s.Rparen + 1 } func (v *ValuesInCondition) Pos() token.Pos { return v.Lparen } func (v *ValuesInCondition) End() token.Pos { return v.Rparen + 1 } -func (g *GqlSubQuery) Pos() token.Pos { return g.LBrace } -func (g *GqlSubQuery) End() token.Pos { return g.RBrace + 1 } +func (g *GqlSubQueryInCondition) Pos() token.Pos { return g.LBrace } +func (g *GqlSubQueryInCondition) End() token.Pos { return g.RBrace + 1 } func (i *IsNullExpr) Pos() token.Pos { return i.Left.Pos() } func (i *IsNullExpr) End() token.Pos { return i.Null + 4 } @@ -483,6 +483,18 @@ func (c *CastIntValue) End() token.Pos { return c.Rparen + 1 } func (c *CastNumValue) Pos() token.Pos { return c.Cast } func (c *CastNumValue) End() token.Pos { return c.Rparen + 1 } +// ================================================================================ +// +// GQL subquery expressions +// +// ================================================================================ + +func (v *ValueGqlSubQuery) Pos() token.Pos { return v.Array } +func (v *ValueGqlSubQuery) End() token.Pos { return v.Query.End() } + +func (a *ArrayGqlSubQuery) Pos() token.Pos { return a.Array } +func (a *ArrayGqlSubQuery) End() token.Pos { return a.RBrace + 1 } + // ================================================================================ // // DDL diff --git a/ast/sql.go b/ast/sql.go index 84993528..e7c9f332 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -418,7 +418,7 @@ func (v *ValuesInCondition) SQL() string { return sql } -func (g *GqlSubQuery) SQL() string { +func (g *GqlSubQueryInCondition) SQL() string { return "{" + g.Query.SQL() + "}" } @@ -730,6 +730,20 @@ func (c *CastNumValue) SQL() string { return "CAST(" + c.Expr.SQL() + " AS " + string(c.Type) + ")" } +// ================================================================================ +// +// GQL subquery expressions +// +// ================================================================================ + +func (a *ArrayGqlSubQuery) SQL() string { + return "ARRAY {\n" + a.Query.SQL() + "\n}" +} + +func (v *ValueGqlSubQuery) SQL() string { + return "VALUE {\n" + v.Query.SQL() + "\n}" +} + // ================================================================================ // // DDL diff --git a/parser.go b/parser.go index ae397644..bdb98e45 100644 --- a/parser.go +++ b/parser.go @@ -1483,6 +1483,16 @@ func (p *Parser) parseLit() ast.Expr { case token.TokenIdent: id := p.Token p.nextToken() + if id.IsKeywordLike("VALUE") && p.Token.Kind == "{" { + p.nextToken() + query := p.parseGqlQueryExpr() + rbrace := p.expect("}").Pos + return &ast.ValueGqlSubQuery{ + Array: id.Pos, + RBrace: rbrace, + Query: query, + } + } switch p.Token.Kind { case "(": return p.parseCall(id) @@ -1761,6 +1771,17 @@ func (p *Parser) parseArrayLiteralOrSubQuery() ast.Expr { } } + if p.Token.Kind == "{" { + p.nextToken() + query := p.parseGqlQueryExpr() + rbrace := p.expect("}").Pos + return &ast.ArrayGqlSubQuery{ + Array: pos, + RBrace: rbrace, + Query: query, + } + } + var t ast.Type if p.Token.Kind == "<" { p.nextToken() diff --git a/parser_gql.go b/parser_gql.go index b16c5efa..60afc21c 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -19,12 +19,12 @@ func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { return &ast.GqlGraphQuery{GraphClause: graphClause, GqlMultiLinearQueryStatement: multiQueryStatement} } -func (p *Parser) parseGqlSubquery() *ast.GqlSubQuery { +func (p *Parser) parseGqlSubquery() *ast.GqlSubQueryInCondition { lbrace := p.expect("{").Pos query := p.parseGqlQueryExpr() rbrace := p.expect("}").Pos - return &ast.GqlSubQuery{LBrace: lbrace, RBrace: rbrace, Query: query} + return &ast.GqlSubQueryInCondition{LBrace: lbrace, RBrace: rbrace, Query: query} } func (p *Parser) parseGqlQueryExpr() *ast.GqlQueryExpr { var graphClause *ast.GqlGraphClause diff --git a/testdata/input/gql/return_array_subquery.sql b/testdata/input/gql/return_array_subquery.sql new file mode 100644 index 00000000..3b1ca3e1 --- /dev/null +++ b/testdata/input/gql/return_array_subquery.sql @@ -0,0 +1,9 @@ +GRAPH FinGraph +MATCH (p:Person)-[:Owns]->(account:Account) +RETURN + p.name, account.id AS account_id, + ARRAY { + MATCH (a:Account)-[transfer:Transfers]->(:Account) + WHERE a = account + RETURN transfer.amount AS transfers + } AS transfers \ No newline at end of file diff --git a/testdata/input/gql/return_value_subquery.sql b/testdata/input/gql/return_value_subquery.sql new file mode 100644 index 00000000..9992d440 --- /dev/null +++ b/testdata/input/gql/return_value_subquery.sql @@ -0,0 +1,7 @@ +GRAPH FinGraph +RETURN VALUE { + MATCH (p:Person) + WHERE p.name LIKE '%e%' + RETURN p.name + LIMIT 1 +} AS results \ No newline at end of file diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt new file mode 100644 index 00000000..eded80a0 --- /dev/null +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -0,0 +1,355 @@ +--- return_array_subquery.sql +GRAPH FinGraph +MATCH (p:Person)-[:Owns]->(account:Account) +RETURN + p.name, account.id AS account_id, + ARRAY { + MATCH (a:Account)-[transfer:Transfers]->(:Account) + WHERE a = account + RETURN transfer.amount AS transfers + } AS transfers +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 31, + Last: 40, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 33, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 34, + NameEnd: 38, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 41, + RParen: 57, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 42, + NameEnd: 49, + Name: "account", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 49, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 50, + NameEnd: 57, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 59, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 67, + NameEnd: 68, + Name: "p", + }, + &ast.Ident{ + NamePos: 69, + NameEnd: 73, + Name: "name", + }, + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 75, + NameEnd: 82, + Name: "account", + }, + &ast.Ident{ + NamePos: 83, + NameEnd: 85, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 89, + NameEnd: 99, + Name: "account_id", + }, + }, + }, + &ast.Alias{ + Expr: &ast.ArrayGqlSubQuery{ + Array: 102, + RBrace: 225, + Query: &ast.GqlQueryExpr{ + GraphClause: (*ast.GqlGraphClause)(nil), + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 113, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 119, + RParen: 129, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 120, + NameEnd: 121, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 121, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 122, + NameEnd: 129, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 130, + Last: 152, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 132, + NameEnd: 140, + Name: "transfer", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 140, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 141, + NameEnd: 150, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 153, + RParen: 162, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: (*ast.Ident)(nil), + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 154, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 155, + NameEnd: 162, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 167, + Expr: &ast.BinaryExpr{ + Op: "=", + Left: &ast.Ident{ + NamePos: 173, + NameEnd: 174, + Name: "a", + }, + Right: &ast.Ident{ + NamePos: 177, + NameEnd: 184, + Name: "account", + }, + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 188, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 195, + NameEnd: 203, + Name: "transfer", + }, + &ast.Ident{ + NamePos: 204, + NameEnd: 210, + Name: "amount", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 214, + NameEnd: 223, + Name: "transfers", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 230, + NameEnd: 239, + Name: "transfers", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person)-[:Owns]->(account:Account) +RETURN p.name, account.id AS account_id, ARRAY { +MATCH (a:Account)-[transfer:Transfers]->(:Account) WHERE a = account +RETURN transfer.amount AS transfers +} AS transfers diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index d48f9d20..48c3ebb5 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -30,7 +30,7 @@ RETURN 'Dana' IN { ValueEnd: 28, Value: "Dana", }, - Right: &ast.GqlSubQuery{ + Right: &ast.GqlSubQueryInCondition{ LBrace: 32, RBrace: 91, Query: &ast.GqlQueryExpr{ diff --git a/testdata/result/gql/return_value_subquery.sql.txt b/testdata/result/gql/return_value_subquery.sql.txt new file mode 100644 index 00000000..67150631 --- /dev/null +++ b/testdata/result/gql/return_value_subquery.sql.txt @@ -0,0 +1,174 @@ +--- return_value_subquery.sql +GRAPH FinGraph +RETURN VALUE { + MATCH (p:Person) + WHERE p.name LIKE '%e%' + RETURN p.name + LIMIT 1 +} AS results +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 15, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.ValueGqlSubQuery{ + Array: 22, + RBrace: 101, + Query: &ast.GqlQueryExpr{ + GraphClause: (*ast.GqlGraphClause)(nil), + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 32, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 38, + RParen: 47, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 39, + NameEnd: 40, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 40, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 41, + NameEnd: 47, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 51, + Expr: &ast.BinaryExpr{ + Op: "LIKE", + Left: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 57, + NameEnd: 58, + Name: "p", + }, + &ast.Ident{ + NamePos: 59, + NameEnd: 63, + Name: "name", + }, + }, + }, + Right: &ast.StringLiteral{ + ValuePos: 69, + ValueEnd: 74, + Value: "%e%", + }, + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 77, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 84, + NameEnd: 85, + Name: "p", + }, + &ast.Ident{ + NamePos: 86, + NameEnd: 90, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: &ast.GqlLimitClause{ + Limit: &ast.Limit{ + Limit: 93, + Count: &ast.IntLiteral{ + ValuePos: 99, + ValueEnd: 100, + Base: 10, + Value: "1", + }, + Offset: (*ast.Offset)(nil), + }, + }, + }, + }, + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 106, + NameEnd: 113, + Name: "results", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +RETURN VALUE { +MATCH (p:Person) WHERE p.name LIKE "%e%" +RETURN p.name LIMIT 1 +} AS results diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index 17ded36d..29cba542 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -21,7 +21,7 @@ SELECT 'Dana' IN { ValueEnd: 13, Value: "Dana", }, - Right: &ast.GqlSubQuery{ + Right: &ast.GqlSubQueryInCondition{ LBrace: 17, RBrace: 93, Query: &ast.GqlQueryExpr{ diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index 17ded36d..29cba542 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -21,7 +21,7 @@ SELECT 'Dana' IN { ValueEnd: 13, Value: "Dana", }, - Right: &ast.GqlSubQuery{ + Right: &ast.GqlSubQueryInCondition{ LBrace: 17, RBrace: 93, Query: &ast.GqlQueryExpr{ From a84cde3b4ee0f77027377fcd9e73732f8345e749 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 11:16:22 +0900 Subject: [PATCH 18/53] Implement EXISTS GQL subquery --- ast/ast.go | 88 ++++--- ast/pos.go | 3 + ast/sql.go | 4 + parser.go | 35 ++- .../input/gql/return_exists_graph_pattern.sql | 4 + testdata/input/gql/return_exists_match.sql | 5 + .../input/gql/return_exists_query_expr.sql | 7 + .../gql/return_exists_graph_pattern.sql.txt | 173 +++++++++++++ .../result/gql/return_exists_match.sql.txt | 191 +++++++++++++++ .../gql/return_exists_query_expr.sql.txt | 230 ++++++++++++++++++ 10 files changed, 706 insertions(+), 34 deletions(-) create mode 100644 testdata/input/gql/return_exists_graph_pattern.sql create mode 100644 testdata/input/gql/return_exists_match.sql create mode 100644 testdata/input/gql/return_exists_query_expr.sql create mode 100644 testdata/result/gql/return_exists_graph_pattern.sql.txt create mode 100644 testdata/result/gql/return_exists_match.sql.txt create mode 100644 testdata/result/gql/return_exists_query_expr.sql.txt diff --git a/ast/ast.go b/ast/ast.go index 1f51754d..dc090235 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -124,39 +124,40 @@ type Expr interface { isExpr() } -func (BinaryExpr) isExpr() {} -func (UnaryExpr) isExpr() {} -func (InExpr) isExpr() {} -func (IsNullExpr) isExpr() {} -func (IsBoolExpr) isExpr() {} -func (BetweenExpr) isExpr() {} -func (SelectorExpr) isExpr() {} -func (IndexExpr) isExpr() {} -func (CallExpr) isExpr() {} -func (CountStarExpr) isExpr() {} -func (CastExpr) isExpr() {} -func (ExtractExpr) isExpr() {} -func (CaseExpr) isExpr() {} -func (ParenExpr) isExpr() {} -func (ScalarSubQuery) isExpr() {} -func (ArraySubQuery) isExpr() {} -func (ExistsSubQuery) isExpr() {} -func (Param) isExpr() {} -func (Ident) isExpr() {} -func (Path) isExpr() {} -func (ArrayLiteral) isExpr() {} -func (StructLiteral) isExpr() {} -func (NullLiteral) isExpr() {} -func (BoolLiteral) isExpr() {} -func (IntLiteral) isExpr() {} -func (FloatLiteral) isExpr() {} -func (StringLiteral) isExpr() {} -func (BytesLiteral) isExpr() {} -func (DateLiteral) isExpr() {} -func (TimestampLiteral) isExpr() {} -func (NumericLiteral) isExpr() {} -func (*ArrayGqlSubQuery) isExpr() {} -func (*ValueGqlSubQuery) isExpr() {} +func (BinaryExpr) isExpr() {} +func (UnaryExpr) isExpr() {} +func (InExpr) isExpr() {} +func (IsNullExpr) isExpr() {} +func (IsBoolExpr) isExpr() {} +func (BetweenExpr) isExpr() {} +func (SelectorExpr) isExpr() {} +func (IndexExpr) isExpr() {} +func (CallExpr) isExpr() {} +func (CountStarExpr) isExpr() {} +func (CastExpr) isExpr() {} +func (ExtractExpr) isExpr() {} +func (CaseExpr) isExpr() {} +func (ParenExpr) isExpr() {} +func (ScalarSubQuery) isExpr() {} +func (ArraySubQuery) isExpr() {} +func (ExistsSubQuery) isExpr() {} +func (Param) isExpr() {} +func (Ident) isExpr() {} +func (Path) isExpr() {} +func (ArrayLiteral) isExpr() {} +func (StructLiteral) isExpr() {} +func (NullLiteral) isExpr() {} +func (BoolLiteral) isExpr() {} +func (IntLiteral) isExpr() {} +func (FloatLiteral) isExpr() {} +func (StringLiteral) isExpr() {} +func (BytesLiteral) isExpr() {} +func (DateLiteral) isExpr() {} +func (TimestampLiteral) isExpr() {} +func (NumericLiteral) isExpr() {} +func (*ArrayGqlSubQuery) isExpr() {} +func (*ValueGqlSubQuery) isExpr() {} +func (*ExistsGqlSubQuery) isExpr() {} // Arg represents argument of function call. type Arg interface { @@ -1178,6 +1179,27 @@ type ValueGqlSubQuery struct { Query *GqlQueryExpr } +// ExistsGqlSubQuery is GQL subquery as EXISTS. +// +// EXISTS{{"{"}}{{.Expr | sql}}{{"}"}} +type ExistsGqlSubQuery struct { + // pos = Array + // end = RBrace + 1 + + Exists token.Pos // position of "ARRAY" keyword + RBrace token.Pos // position of "{" and "}" + Query GqlExistsExpr +} + +type GqlExistsExpr interface { + Node + isGqlExistsExpr() +} + +func (*GqlQueryExpr) isGqlExistsExpr() {} +func (*GqlMatchStatement) isGqlExistsExpr() {} +func (*GqlGraphPattern) isGqlExistsExpr() {} + // ExistsSubQuery is subquery in EXISTS call. // // EXISTS {{.Hint | sqlOpt}} ({{.Query | sql}}) diff --git a/ast/pos.go b/ast/pos.go index 3df0d780..c8f44c4f 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -495,6 +495,9 @@ func (v *ValueGqlSubQuery) End() token.Pos { return v.Query.End() } func (a *ArrayGqlSubQuery) Pos() token.Pos { return a.Array } func (a *ArrayGqlSubQuery) End() token.Pos { return a.RBrace + 1 } +func (e *ExistsGqlSubQuery) Pos() token.Pos { return e.Exists } +func (e *ExistsGqlSubQuery) End() token.Pos { return e.RBrace + 1 } + // ================================================================================ // // DDL diff --git a/ast/sql.go b/ast/sql.go index e7c9f332..9f948ba8 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -744,6 +744,10 @@ func (v *ValueGqlSubQuery) SQL() string { return "VALUE {\n" + v.Query.SQL() + "\n}" } +func (v *ExistsGqlSubQuery) SQL() string { + return "EXISTS {\n" + v.Query.SQL() + "\n}" +} + // ================================================================================ // // DDL diff --git a/parser.go b/parser.go index bdb98e45..e84c35cf 100644 --- a/parser.go +++ b/parser.go @@ -1669,8 +1669,41 @@ func (p *Parser) parseCastExpr() *ast.CastExpr { } } -func (p *Parser) parseExistsSubQuery() *ast.ExistsSubQuery { +func (p *Parser) lookaheadGqlGraphPattern() bool { + // path_search_prefix + return p.Token.IsKeywordLike("ANY") || p.Token.IsKeywordLike("ALL") || // path_search_prefix + p.Token.IsKeywordLike("WALK") || p.Token.IsKeywordLike("TRAIL") || // path_mode + // subpath_pattern or node_pattern + p.Token.Kind == "(" || + // edge_pattern + p.Token.Kind == "<" || p.Token.Kind == "-" + +} + +func (p *Parser) parseGqlExistsExpr() ast.GqlExistsExpr { + // NOTE: Single MATCH statement pattern is covered by GqlQueryExpr + // because there is no check that SimpleLinearQueryStatement is terminated by RETURN statement. + if p.lookaheadGqlGraphPattern() { + return p.parseGqlGraphPattern() + } else { + return p.parseGqlQueryExpr() + } +} + +// parseExistsSubQuery parses EXISTS subquery or EXISTS GQL subquery +func (p *Parser) parseExistsSubQuery() ast.Expr { exists := p.expect("EXISTS").Pos + if p.Token.Kind == "{" { + p.expect("{") + expr := p.parseGqlExistsExpr() + rbrace := p.expect("}").Pos + return &ast.ExistsGqlSubQuery{ + Exists: exists, + RBrace: rbrace, + Query: expr, + } + } + p.expect("(") query := p.parseQueryExpr() rparen := p.expect(")").Pos diff --git a/testdata/input/gql/return_exists_graph_pattern.sql b/testdata/input/gql/return_exists_graph_pattern.sql new file mode 100644 index 00000000..cfbb543d --- /dev/null +++ b/testdata/input/gql/return_exists_graph_pattern.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +RETURN EXISTS { + (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE 'D%' +} AS results \ No newline at end of file diff --git a/testdata/input/gql/return_exists_match.sql b/testdata/input/gql/return_exists_match.sql new file mode 100644 index 00000000..915c52a9 --- /dev/null +++ b/testdata/input/gql/return_exists_match.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +RETURN EXISTS { + MATCH (p:Person)-[o:Owns]->(a:Account) + WHERE p.Name LIKE 'D%' +} AS results \ No newline at end of file diff --git a/testdata/input/gql/return_exists_query_expr.sql b/testdata/input/gql/return_exists_query_expr.sql new file mode 100644 index 00000000..2af7f450 --- /dev/null +++ b/testdata/input/gql/return_exists_query_expr.sql @@ -0,0 +1,7 @@ +GRAPH FinGraph +RETURN EXISTS { + MATCH (p:Person)-[o:Owns]->(a:Account) + WHERE p.Name LIKE 'D%' + RETURN p.Name + LIMIT 1 +} AS results \ No newline at end of file diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt new file mode 100644 index 00000000..a2e79982 --- /dev/null +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -0,0 +1,173 @@ +--- return_exists_graph_pattern.sql +GRAPH FinGraph +RETURN EXISTS { + (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE 'D%' +} AS results +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 15, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.ExistsGqlSubQuery{ + Exists: 22, + RBrace: 89, + Query: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 33, + RParen: 42, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 34, + NameEnd: 35, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 35, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 36, + NameEnd: 42, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 43, + Last: 53, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 45, + NameEnd: 46, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 46, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 47, + NameEnd: 51, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 54, + RParen: 64, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 55, + NameEnd: 56, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 56, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 57, + NameEnd: 64, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 66, + Expr: &ast.BinaryExpr{ + Op: "LIKE", + Left: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 72, + NameEnd: 73, + Name: "p", + }, + &ast.Ident{ + NamePos: 74, + NameEnd: 78, + Name: "Name", + }, + }, + }, + Right: &ast.StringLiteral{ + ValuePos: 84, + ValueEnd: 88, + Value: "D%", + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 94, + NameEnd: 101, + Name: "results", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +RETURN EXISTS { +(p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%" +} AS results diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt new file mode 100644 index 00000000..ac446899 --- /dev/null +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -0,0 +1,191 @@ +--- return_exists_match.sql +GRAPH FinGraph +RETURN EXISTS { + MATCH (p:Person)-[o:Owns]->(a:Account) + WHERE p.Name LIKE 'D%' +} AS results +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 15, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.ExistsGqlSubQuery{ + Exists: 22, + RBrace: 97, + Query: &ast.GqlQueryExpr{ + GraphClause: (*ast.GqlGraphClause)(nil), + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 33, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 39, + RParen: 48, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 40, + NameEnd: 41, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 41, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 42, + NameEnd: 48, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 49, + Last: 59, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 51, + NameEnd: 52, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 52, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 53, + NameEnd: 57, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 60, + RParen: 70, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 61, + NameEnd: 62, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 62, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 63, + NameEnd: 70, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 74, + Expr: &ast.BinaryExpr{ + Op: "LIKE", + Left: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 80, + NameEnd: 81, + Name: "p", + }, + &ast.Ident{ + NamePos: 82, + NameEnd: 86, + Name: "Name", + }, + }, + }, + Right: &ast.StringLiteral{ + ValuePos: 92, + ValueEnd: 96, + Value: "D%", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 102, + NameEnd: 109, + Name: "results", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +RETURN EXISTS { +MATCH (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%" +} AS results diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt new file mode 100644 index 00000000..78542519 --- /dev/null +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -0,0 +1,230 @@ +--- return_exists_query_expr.sql +GRAPH FinGraph +RETURN EXISTS { + MATCH (p:Person)-[o:Owns]->(a:Account) + WHERE p.Name LIKE 'D%' + RETURN p.Name + LIMIT 1 +} AS results +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 15, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.ExistsGqlSubQuery{ + Exists: 22, + RBrace: 123, + Query: &ast.GqlQueryExpr{ + GraphClause: (*ast.GqlGraphClause)(nil), + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 33, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 39, + RParen: 48, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 40, + NameEnd: 41, + Name: "p", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 41, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 42, + NameEnd: 48, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeRight{ + First: 49, + Last: 59, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 51, + NameEnd: 52, + Name: "o", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 52, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 53, + NameEnd: 57, + Name: "Owns", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 60, + RParen: 70, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 61, + NameEnd: 62, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 62, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 63, + NameEnd: 70, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 74, + Expr: &ast.BinaryExpr{ + Op: "LIKE", + Left: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 80, + NameEnd: 81, + Name: "p", + }, + &ast.Ident{ + NamePos: 82, + NameEnd: 86, + Name: "Name", + }, + }, + }, + Right: &ast.StringLiteral{ + ValuePos: 92, + ValueEnd: 96, + Value: "D%", + }, + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 99, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 106, + NameEnd: 107, + Name: "p", + }, + &ast.Ident{ + NamePos: 108, + NameEnd: 112, + Name: "Name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: &ast.GqlLimitClause{ + Limit: &ast.Limit{ + Limit: 115, + Count: &ast.IntLiteral{ + ValuePos: 121, + ValueEnd: 122, + Base: 10, + Value: "1", + }, + Offset: (*ast.Offset)(nil), + }, + }, + }, + }, + }, + }, + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 128, + NameEnd: 135, + Name: "results", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +RETURN EXISTS { +MATCH (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%" +RETURN p.Name LIMIT 1 +} AS results From b12a4eb3eec876ad0cfc1469e82f80c9ed35f162 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 11:56:17 +0900 Subject: [PATCH 19/53] Implement IsSourceExpr and IsDestinationExpr, and add tests --- ast/ast.go | 24 ++ ast/pos.go | 6 + ast/sql.go | 24 +- .../match_where_is_destination_of_return.sql | 4 + .../gql/match_where_is_source_of_return.sql | 4 + .../input/gql/match_where_not_same_return.sql | 4 + .../match_where_property_exists_return.sql | 3 + ...tch_where_is_destination_of_return.sql.txt | 203 ++++++++++++++++ .../match_where_is_source_of_return.sql.txt | 203 ++++++++++++++++ .../gql/match_where_not_same_return.sql.txt | 219 ++++++++++++++++++ ...match_where_property_exists_return.sql.txt | 136 +++++++++++ 11 files changed, 829 insertions(+), 1 deletion(-) create mode 100644 testdata/input/gql/match_where_is_destination_of_return.sql create mode 100644 testdata/input/gql/match_where_is_source_of_return.sql create mode 100644 testdata/input/gql/match_where_not_same_return.sql create mode 100644 testdata/input/gql/match_where_property_exists_return.sql create mode 100644 testdata/result/gql/match_where_is_destination_of_return.sql.txt create mode 100644 testdata/result/gql/match_where_is_source_of_return.sql.txt create mode 100644 testdata/result/gql/match_where_not_same_return.sql.txt create mode 100644 testdata/result/gql/match_where_property_exists_return.sql.txt diff --git a/ast/ast.go b/ast/ast.go index dc090235..3f40d546 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -129,6 +129,8 @@ func (UnaryExpr) isExpr() {} func (InExpr) isExpr() {} func (IsNullExpr) isExpr() {} func (IsBoolExpr) isExpr() {} +func (IsSourceExpr) isExpr() {} +func (IsDestinationExpr) isExpr() {} func (BetweenExpr) isExpr() {} func (SelectorExpr) isExpr() {} func (IndexExpr) isExpr() {} @@ -941,6 +943,28 @@ type IsBoolExpr struct { Right bool } +// IsSourceExpr is IS SOURCE expression node. +// +// {{.Node | sql}} IS {{if .Not}}NOT{{end}} SOURCE OF {{.Edge | sql}} +type IsSourceExpr struct { + // pos = Node.pos + // end = Edge.end + + Node, Edge Expr + Not bool +} + +// IsDestinationExpr is IS DESTINATION expression node. +// +// {{.Node | sql}} IS {{if .Not}}NOT{{end}} DESTINATION OF {{.Edge | sql}} +type IsDestinationExpr struct { + // pos = Node.pos + // end = Edge.end + + Node, Edge Expr + Not bool +} + // BetweenExpr is BETWEEN expression node. // // {{.Left | sql}} {{if .Not}}NOT{{end}} BETWEEN {{.RightStart | sql}} AND {{.RightEnd | sql}} diff --git a/ast/pos.go b/ast/pos.go index c8f44c4f..1dbe805c 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -313,6 +313,12 @@ func (i *IsBoolExpr) End() token.Pos { } } +func (i *IsSourceExpr) Pos() token.Pos { return i.Node.Pos() } +func (i *IsSourceExpr) End() token.Pos { return i.Edge.End() } + +func (i *IsDestinationExpr) Pos() token.Pos { return i.Node.Pos() } +func (i *IsDestinationExpr) End() token.Pos { return i.Edge.End() } + func (b *BetweenExpr) Pos() token.Pos { return b.Left.Pos() } func (b *BetweenExpr) End() token.Pos { return b.RightEnd.End() } diff --git a/ast/sql.go b/ast/sql.go index 9f948ba8..618892b9 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -28,7 +28,7 @@ func exprPrec(e Expr) prec { return precLit case *IndexExpr, *SelectorExpr: return precSelector - case *InExpr, *IsNullExpr, *IsBoolExpr, *BetweenExpr: + case *InExpr, *IsNullExpr, *IsBoolExpr, *IsSourceExpr, *IsDestinationExpr, *BetweenExpr: return precComparison case *BinaryExpr: switch e.Op { @@ -448,6 +448,28 @@ func (i *IsBoolExpr) SQL() string { return sql } +func (i *IsSourceExpr) SQL() string { + p := exprPrec(i) + sql := paren(p, i.Node) + sql += " IS " + if i.Not { + sql += "NOT " + } + sql += "SOURCE OF " + i.Edge.SQL() + return sql +} + +func (i *IsDestinationExpr) SQL() string { + p := exprPrec(i) + sql := paren(p, i.Node) + sql += " IS " + if i.Not { + sql += "NOT " + } + sql += "DESTINATION OF " + i.Edge.SQL() + return sql +} + func (b *BetweenExpr) SQL() string { p := exprPrec(b) sql := paren(p, b.Left) diff --git a/testdata/input/gql/match_where_is_destination_of_return.sql b/testdata/input/gql/match_where_is_destination_of_return.sql new file mode 100644 index 00000000..0cd925de --- /dev/null +++ b/testdata/input/gql/match_where_is_destination_of_return.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (a:Account)-[transfer:Transfers]-(b:Account) +WHERE a IS DESTINATION of transfer +RETURN a.id AS a_id, b.id AS b_id \ No newline at end of file diff --git a/testdata/input/gql/match_where_is_source_of_return.sql b/testdata/input/gql/match_where_is_source_of_return.sql new file mode 100644 index 00000000..cfb0510d --- /dev/null +++ b/testdata/input/gql/match_where_is_source_of_return.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (a:Account)-[transfer:Transfers]-(b:Account) +WHERE a IS SOURCE of transfer +RETURN a.id AS a_id, b.id AS b_id \ No newline at end of file diff --git a/testdata/input/gql/match_where_not_same_return.sql b/testdata/input/gql/match_where_not_same_return.sql new file mode 100644 index 00000000..94f0efa0 --- /dev/null +++ b/testdata/input/gql/match_where_not_same_return.sql @@ -0,0 +1,4 @@ +GRAPH FinGraph +MATCH (src:Account)<-[transfer:Transfers]-(dest:Account) +WHERE NOT SAME(src, dest) +RETURN src.id AS source_id, dest.id AS destination_id \ No newline at end of file diff --git a/testdata/input/gql/match_where_property_exists_return.sql b/testdata/input/gql/match_where_property_exists_return.sql new file mode 100644 index 00000000..23930744 --- /dev/null +++ b/testdata/input/gql/match_where_property_exists_return.sql @@ -0,0 +1,3 @@ +GRAPH FinGraph +MATCH (n:Person|Account WHERE PROPERTY_EXISTS(n, name)) +RETURN n.name \ No newline at end of file diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt new file mode 100644 index 00000000..cf22a97e --- /dev/null +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -0,0 +1,203 @@ +--- match_where_is_destination_of_return.sql +GRAPH FinGraph +MATCH (a:Account)-[transfer:Transfers]-(b:Account) +WHERE a IS DESTINATION of transfer +RETURN a.id AS a_id, b.id AS b_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 31, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 31, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeAny{ + First: 32, + Last: 53, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 34, + NameEnd: 42, + Name: "transfer", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 42, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 43, + NameEnd: 52, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 54, + RParen: 64, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 55, + NameEnd: 56, + Name: "b", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 56, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 57, + NameEnd: 64, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 66, + Expr: &ast.IsDestinationExpr{ + Node: &ast.Ident{ + NamePos: 72, + NameEnd: 73, + Name: "a", + }, + Edge: &ast.Ident{ + NamePos: 92, + NameEnd: 100, + Name: "transfer", + }, + Not: false, + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 101, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 108, + NameEnd: 109, + Name: "a", + }, + &ast.Ident{ + NamePos: 110, + NameEnd: 112, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 116, + NameEnd: 120, + Name: "a_id", + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 122, + NameEnd: 123, + Name: "b", + }, + &ast.Ident{ + NamePos: 124, + NameEnd: 126, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 130, + NameEnd: 134, + Name: "b_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS DESTINATION OF transfer +RETURN a.id AS a_id, b.id AS b_id diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt new file mode 100644 index 00000000..d6192b68 --- /dev/null +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -0,0 +1,203 @@ +--- match_where_is_source_of_return.sql +GRAPH FinGraph +MATCH (a:Account)-[transfer:Transfers]-(b:Account) +WHERE a IS SOURCE of transfer +RETURN a.id AS a_id, b.id AS b_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 31, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 31, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeAny{ + First: 32, + Last: 53, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 34, + NameEnd: 42, + Name: "transfer", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 42, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 43, + NameEnd: 52, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 54, + RParen: 64, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 55, + NameEnd: 56, + Name: "b", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 56, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 57, + NameEnd: 64, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 66, + Expr: &ast.IsSourceExpr{ + Node: &ast.Ident{ + NamePos: 72, + NameEnd: 73, + Name: "a", + }, + Edge: &ast.Ident{ + NamePos: 87, + NameEnd: 95, + Name: "transfer", + }, + Not: false, + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 96, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 103, + NameEnd: 104, + Name: "a", + }, + &ast.Ident{ + NamePos: 105, + NameEnd: 107, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 111, + NameEnd: 115, + Name: "a_id", + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 117, + NameEnd: 118, + Name: "b", + }, + &ast.Ident{ + NamePos: 119, + NameEnd: 121, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 125, + NameEnd: 129, + Name: "b_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS SOURCE OF transfer +RETURN a.id AS a_id, b.id AS b_id diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt new file mode 100644 index 00000000..46c2960c --- /dev/null +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -0,0 +1,219 @@ +--- match_where_not_same_return.sql +GRAPH FinGraph +MATCH (src:Account)<-[transfer:Transfers]-(dest:Account) +WHERE NOT SAME(src, dest) +RETURN src.id AS source_id, dest.id AS destination_id +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 33, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 25, + Name: "src", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 25, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 26, + NameEnd: 33, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlFullEdgeLeft{ + First: 34, + Last: 56, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 37, + NameEnd: 45, + Name: "transfer", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 45, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 46, + NameEnd: 55, + Name: "Transfers", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 57, + RParen: 70, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 58, + NameEnd: 62, + Name: "dest", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 62, + LabelExpression: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 63, + NameEnd: 70, + Name: "Account", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: &ast.Where{ + Where: 72, + Expr: &ast.UnaryExpr{ + OpPos: 78, + Op: "NOT", + Expr: &ast.CallExpr{ + Rparen: 96, + Func: &ast.Ident{ + NamePos: 82, + NameEnd: 86, + Name: "SAME", + }, + Distinct: false, + Args: []ast.Arg{ + &ast.ExprArg{ + Expr: &ast.Ident{ + NamePos: 87, + NameEnd: 90, + Name: "src", + }, + }, + &ast.ExprArg{ + Expr: &ast.Ident{ + NamePos: 92, + NameEnd: 96, + Name: "dest", + }, + }, + }, + }, + }, + }, + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 98, + ReturnItemList: []ast.GqlReturnItem{ + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 105, + NameEnd: 108, + Name: "src", + }, + &ast.Ident{ + NamePos: 109, + NameEnd: 111, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 115, + NameEnd: 124, + Name: "source_id", + }, + }, + }, + &ast.Alias{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 126, + NameEnd: 130, + Name: "dest", + }, + &ast.Ident{ + NamePos: 131, + NameEnd: 133, + Name: "id", + }, + }, + }, + As: &ast.AsAlias{ + As: -1, + Alias: &ast.Ident{ + NamePos: 137, + NameEnd: 151, + Name: "destination_id", + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (src:Account)<-[transfer:Transfers]-(dest:Account) WHERE NOT SAME(src, dest) +RETURN src.id AS source_id, dest.id AS destination_id diff --git a/testdata/result/gql/match_where_property_exists_return.sql.txt b/testdata/result/gql/match_where_property_exists_return.sql.txt new file mode 100644 index 00000000..930f0824 --- /dev/null +++ b/testdata/result/gql/match_where_property_exists_return.sql.txt @@ -0,0 +1,136 @@ +--- match_where_property_exists_return.sql +GRAPH FinGraph +MATCH (n:Person|Account WHERE PROPERTY_EXISTS(n, name)) +RETURN n.name +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + GqlGraph: 0, + GqlPropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 69, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "n", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelOrExpression{ + Left: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + Right: &ast.GqlLabelName{ + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 31, + NameEnd: 38, + Name: "Account", + }, + }, + }, + }, + Filter: &ast.Where{ + Where: 39, + Expr: &ast.CallExpr{ + Rparen: 68, + Func: &ast.Ident{ + NamePos: 45, + NameEnd: 60, + Name: "PROPERTY_EXISTS", + }, + Distinct: false, + Args: []ast.Arg{ + &ast.ExprArg{ + Expr: &ast.Ident{ + NamePos: 61, + NameEnd: 62, + Name: "n", + }, + }, + &ast.ExprArg{ + Expr: &ast.Ident{ + NamePos: 64, + NameEnd: 68, + Name: "name", + }, + }, + }, + }, + }, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlReturnStatement{ + AllOrDistinct: 0, + Return: 71, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 78, + NameEnd: 79, + Name: "n", + }, + &ast.Ident{ + NamePos: 80, + NameEnd: 84, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (n:Person|Account WHERE PROPERTY_EXISTS(n, name)) +RETURN n.name From aba43ad8569683b23c99f4ff4d2c52e81258017b Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 11:56:17 +0900 Subject: [PATCH 20/53] Fix IsSourceExpr and IsDestinationExpr, rename parseGqlSubQueryInCondition --- parser.go | 30 +++++++++++++++++++++++++++--- parser_gql.go | 2 +- 2 files changed, 28 insertions(+), 4 deletions(-) diff --git a/parser.go b/parser.go index e84c35cf..667be9fe 100644 --- a/parser.go +++ b/parser.go @@ -1187,9 +1187,33 @@ func (p *Parser) parseComparison() ast.Expr { Not: not, Right: false, } - default: - p.panicfAtToken(&p.Token, "expected token: NULL, TRUE, FALSE, but: %s", p.Token.Kind) + case token.TokenIdent: + switch { + case p.Token.IsKeywordLike("SOURCE") || p.Token.IsKeywordLike("DESTINATION"): + var isSource bool + if p.Token.IsKeywordLike("SOURCE") { + isSource = true + } + p.nextToken() + if p.Token.Kind == "OF" { + p.expect("OF") + } + edge := p.parseExpr() + if isSource { + return &ast.IsSourceExpr{ + Node: expr, + Edge: edge, + Not: not, + } + } + return &ast.IsDestinationExpr{ + Node: expr, + Edge: edge, + Not: not, + } + } } + p.panicfAtToken(&p.Token, "expected token: NULL, TRUE, FALSE, SOURCE, DESTINATION, but: %s", p.Token.Kind) default: return expr } @@ -1214,7 +1238,7 @@ func (p *Parser) parseInCondition() ast.InCondition { } if p.Token.Kind == "{" { - return p.parseGqlSubquery() + return p.parseGqlSubQueryInCondition() } if p.Token.Kind == "(" { lparen := p.Token.Pos diff --git a/parser_gql.go b/parser_gql.go index 60afc21c..bd5497d4 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -19,7 +19,7 @@ func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { return &ast.GqlGraphQuery{GraphClause: graphClause, GqlMultiLinearQueryStatement: multiQueryStatement} } -func (p *Parser) parseGqlSubquery() *ast.GqlSubQueryInCondition { +func (p *Parser) parseGqlSubQueryInCondition() *ast.GqlSubQueryInCondition { lbrace := p.expect("{").Pos query := p.parseGqlQueryExpr() rbrace := p.expect("}").Pos From 6e6b351e5f0b4217c5f9cdf71697190fb65a1f0c Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 16:25:22 +0900 Subject: [PATCH 21/53] Implement Pos()/End()/SQL() --- ast/ast.go | 620 +++++++++++++++++++++++++++++++++- ast/const.go | 41 +++ ast/gql.go | 607 ---------------------------------- ast/graph_patterns.go | 752 ------------------------------------------ ast/pos.go | 199 +++++++++++ ast/sql.go | 245 ++++++++++++++ ast/util.go | 10 +- parser_gql.go | 46 ++- 8 files changed, 1140 insertions(+), 1380 deletions(-) delete mode 100644 ast/gql.go delete mode 100644 ast/graph_patterns.go diff --git a/ast/ast.go b/ast/ast.go index 3f40d546..7d47f2d6 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -75,6 +75,9 @@ func (CreateChangeStream) isStatement() {} func (AlterChangeStream) isStatement() {} func (DropChangeStream) isStatement() {} +// GRAPH query is top level statement which can be executed by ExecuteSQL API. +func (*GqlGraphQuery) isStatement() {} + // QueryExpr represents set operator operands. type QueryExpr interface { Node @@ -572,8 +575,6 @@ type Where struct { Expr Expr } -func (w *Where) isGqlPatternFillerFilter() {} - // GroupBy is GROUP BY clause node. // // GROUP BY {{.Exprs | sqlJoin ","}} @@ -2533,3 +2534,618 @@ type SequenceOptions struct { Records []*SequenceOption // len(Records) > 0 } + +// ================================================================================ +// +// GQL +// +// ================================================================================ + +// GqlGraphQuery is toplevel node of GRAPH query. +type GqlGraphQuery struct { + // pos = (GraphClause ?? MultiLinearQueryStatement).pos + // end = MultiLinearQueryStatement.end + + GraphClause *GqlGraphClause + MultiLinearQueryStatement *GqlMultiLinearQueryStatement +} + +// GqlQueryExpr is similar to GqlGraphQuery, +// but it is appeared in GQL subqueries and it can optionally have GRAPH clause +type GqlQueryExpr struct { + // pos = (GraphClause ?? MultiLinearQueryStatement).pos + // end = MultiLinearQueryStatement.end + + GraphClause *GqlGraphClause // optional + MultiLinearQueryStatement *GqlMultiLinearQueryStatement +} + +type GqlGraphClause struct { + // pos = Graph + // end = PropertyGraphName.end + + Graph token.Pos + PropertyGraphName *Ident +} + +type GqlMultiLinearQueryStatement struct { + // pos = LinearQueryStatementList[0].pos + // pos = LinearQueryStatementList[$].end + + LinearQueryStatementList []GqlLinearQueryStatement +} + +type GqlLinearQueryStatement interface { + Node + isGqlLinearQueryStatement() +} + +func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} +func (*GqlCompositeLinearQueryStatement) isGqlLinearQueryStatement() {} + +type GqlSimpleLinearQueryStatement struct { + // pos = PrimitiveQueryStatementList[0].pos + // end = PrimitiveQueryStatementList[$].end + + PrimitiveQueryStatementList []GqlPrimitiveQueryStatement +} + +type GqlSimpleLinearQueryStatementWithSetOperator struct { + // pos = StartPos + // end = Statement.end + + StartPos token.Pos + SetOperator GqlSetOperatorEnum + DistinctOrAll GqlAllOrDistinctEnum + Statement *GqlSimpleLinearQueryStatement +} + +type GqlCompositeLinearQueryStatement struct { + // pos = HeadSimpleLinearStatement.pos + // end = TailSimpleLinearStatement.pos + + HeadSimpleLinearQueryStatement *GqlSimpleLinearQueryStatement + TailSimpleLinearQueryStatementList []*GqlSimpleLinearQueryStatementWithSetOperator +} + +// ================================================================================ +// +// GQL statements +// +// ================================================================================ + +type GqlPrimitiveQueryStatement interface { + Node + isGqlPrimitiveQueryStatement() +} + +func (*GqlWithStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlOrderByStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlOffsetStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlLimitStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlForStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlFilterStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlMatchStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlLetStatement) isGqlPrimitiveQueryStatement() {} +func (*GqlReturnStatement) isGqlPrimitiveQueryStatement() {} + +type GqlMatchStatement struct { + // pos = (Optional ?? Match) + // end = GraphPattern.end + + Optional token.Pos //optional + Match token.Pos + + MatchHint *Hint // optional + PrefixOrMode GqlPathSearchPrefixOrPathMode // optional + GraphPattern *GqlGraphPattern +} + +type GqlLimitAndOffsetClause interface { + Node + isGqlLimitAndOffsetClause() +} + +func (g *GqlLimitClause) isGqlLimitAndOffsetClause() {} +func (g *GqlOffsetClause) isGqlLimitAndOffsetClause() {} +func (g *GqlLimitWithOffsetClause) isGqlLimitAndOffsetClause() {} + +type GqlFilterStatement struct { + // pos = Filter + // end = Expr.end + + Filter token.Pos + Where token.Pos + Expr Expr +} + +type GqlForStatement struct { + // pos = For + // end = (WithOffsetClause ?? ArrayExpression).end + + For token.Pos + ElementName *Ident + ArrayExpression Expr + WithOffsetClause *GqlWithOffsetClause +} + +type GqlWithOffsetClause struct { + // pos = With.pos + // end = OffsetName.end ?? Offset + 6 + + With token.Pos + Offset token.Pos + OffsetName *Ident +} + +// GqlLimitClause is wrapper of Limit for GQL +type GqlLimitClause struct { + // pos = Limit.pos + // end = Limit.end + Limit *Limit +} + +// GqlOffsetClause is wrapper of Offset for GQL +type GqlOffsetClause struct { + // pos = Offset.pos + // end = Offset.end + Offset *Offset +} + +// GqlLimitClauseWithOffset +type GqlLimitWithOffsetClause struct { + // pos = Limit.pos + // end = Offset.end + + Limit *Limit + Offset *Offset +} + +type GqlLimitStatement struct { + // pos = Limit + // end = Count.end + + Limit token.Pos + Count IntValue +} + +// GqlOffsetStatement represents OFFSET statement. +// It also represents SKIP statement as the synonym. +type GqlOffsetStatement struct { + // pos = Offset.pos + // end = Count.end + + Offset token.Pos + IsSkip bool + Count IntValue +} + +type GqlOrderByStatement struct { + // pos = Order + // end = OrderBySpecificationList[$].end + + Order token.Pos + OrderBySpecificationList []*GqlOrderBySpecification +} + +// TODO +type GqlOrderBySpecification struct { + // pos = Expr.pos + // TODO + + Expr Expr + // TODO + // CollationSpecification *GqlCollationSpecification + DirectionPos token.Pos + Direction GqlDirection +} + +func (g *GqlOrderBySpecification) Pos() token.Pos { return g.Expr.Pos() } + +func (g *GqlOrderBySpecification) End() token.Pos { + //TODO implement me + panic("implement me") +} + +func (g *GqlOrderBySpecification) SQL() string { + sql := g.Expr.SQL() + // TODO Collation + if g.Direction != GqlSortOrderUnspecified { + sql += " " + string(g.Direction) + } + return sql +} + +type GqlWithStatement struct { + // pos = With + // end = (GroupByClause ?? ReturnItemList[$]).end + With token.Pos + AllOrDistinct GqlAllOrDistinctEnum + ReturnItemList []GqlReturnItem + GroupByClause *GroupBy // optional +} + +// GqlReturnItem is similar to SelectItem, +// but it don't permit DotStar and AsAlias without AS. +type GqlReturnItem SelectItem + +type GqlReturnStatement struct { + // pos = Return.pos + // end = (LimitAndOffsetClause ?? OrderByClause ?? GroupByClause ?? ReturnItemList[$]).end + Return token.Pos + AllOrDistinct GqlAllOrDistinctEnum + ReturnItemList []GqlReturnItem + + // Use GoogleSQL GroupBy because it is referenced in docs + GroupByClause *GroupBy //optional + + // Use GoogleSQL OrderBy because it is referenced in docs + OrderByClause *OrderBy //optional + + LimitAndOffsetClause GqlLimitAndOffsetClause // optional +} + +type GqlLinearGraphVariable struct { + VariableName *Ident + Value Expr +} + +type GqlLetStatement struct { + // pos = Let.pos + // end = if len(LinearGraphVariableList) > 0 then LinearGraphVariableList[$].end + // else Let + 3 + + Let token.Pos + LinearGraphVariableList []*GqlLinearGraphVariable +} + +// ================================================================================ +// +// GQL graph patterns +// +// ================================================================================ + +// GqlGraphPattern represents is the toplevel node of GQL graph patterns. +type GqlGraphPattern struct { + // pos = GqlTopLevelPathPattern[0].pos + // end = (WhereClause ?? PathPatternList[$]).end + + PathPatternList []*GqlTopLevelPathPattern + WhereClause *Where // optional +} + +// GqlTopLevelPathPattern is a PathPattern optionally prefixed by PathSearchPrefixOrPathMode. +type GqlTopLevelPathPattern struct { + // pos = (PathSearchPrefixOrPathMode ?? PathPattern).pos + // end = PathPattern.end + + PathSearchPrefixOrPathMode GqlPathSearchPrefixOrPathMode // optional + PathPattern *GqlPathPattern +} + +// GqlPathSearchPrefixOrPathMode represents `{ path_search_prefix | path_mode }` +type GqlPathSearchPrefixOrPathMode interface { + Node + isGqlPathSearchPrefixOrPathMode() +} + +func (*GqlPathMode) isGqlPathSearchPrefixOrPathMode() {} +func (*GqlPathSearchPrefix) isGqlPathSearchPrefixOrPathMode() {} + +// GqlEdgePattern represents edge pattern nodes. +// +// edge_pattern: +// { +// full_edge_any | +// full_edge_left | +// full_edge_right | +// abbreviated_edge_any | +// abbreviated_edge_left | +// abbreviated_edge_right +// } +type GqlEdgePattern interface { + GqlElementPattern + isGqlEdgePattern() +} + +func (*GqlAbbreviatedEdgeLeft) isGqlEdgePattern() {} +func (*GqlAbbreviatedEdgeAny) isGqlEdgePattern() {} +func (*GqlFullEdgeRight) isGqlEdgePattern() {} +func (*GqlFullEdgeLeft) isGqlEdgePattern() {} +func (*GqlFullEdgeAny) isGqlEdgePattern() {} +func (*GqlAbbreviatedEdgeRight) isGqlEdgePattern() {} + +// GqlFullEdgeAny is node representing`-[pattern_filler]-` . +type GqlFullEdgeAny struct { + // pos = First.pos + // end = Last.pos + 1 + First, Last token.Pos + PatternFiller *GqlPatternFiller +} + +type GqlFullEdgeLeft struct { + // pos = First + // end = Last + 1 + First token.Pos // position of "<" + Last token.Pos // position of the last "-" + PatternFiller *GqlPatternFiller +} + +type GqlFullEdgeRight struct { + // pos = First + // end = Last + 1 + + First token.Pos // position of the first "-" + Last token.Pos // position of ">" + PatternFiller *GqlPatternFiller +} + +type GqlAbbreviatedEdgeAny struct { + // pos = Hyphen + // end = Hyphen +1 + + Hyphen token.Pos // position of "-" +} + +type GqlAbbreviatedEdgeLeft struct { + // pos = First + // end = Last + 1 + + First token.Pos // position of "<" + Last token.Pos // position of "-" +} + +type GqlAbbreviatedEdgeRight struct { + // pos = First + // end = Last + 1 + + First token.Pos // position of "-" + Last token.Pos // position of ">" +} + +type GqlQuantifiablePathTerm struct { + // pos = (Hint ?? PathTerm).pos + // end = (Quantifier ?? PathTerm).end + + Hint *Hint // optional + PathTerm GqlPathTerm + Quantifier GqlQuantifier // optional +} + +type GqlPathPattern struct { + // pos = PathTermList[0].pos + // end = PathTermList[$].end + PathTermList []*GqlQuantifiablePathTerm +} + +type GqlPathTerm interface { + Node + isGqlPathTerm() +} + +func (*GqlSubpathPattern) isGqlPathTerm() {} +func (*GqlNodePattern) isGqlPathTerm() {} +func (*GqlAbbreviatedEdgeRight) isGqlPathTerm() {} +func (*GqlAbbreviatedEdgeLeft) isGqlPathTerm() {} +func (*GqlAbbreviatedEdgeAny) isGqlPathTerm() {} +func (*GqlFullEdgeRight) isGqlPathTerm() {} +func (*GqlFullEdgeLeft) isGqlPathTerm() {} +func (*GqlFullEdgeAny) isGqlPathTerm() {} + +type GqlWhereClause struct { + // pos = Where + // end = BoolExpression.end + + Where token.Pos + BoolExpression Expr +} + +type GqlElementPattern interface { + Node + GqlPathTerm + isGqlElementPattern() +} + +func (*GqlFullEdgeAny) isGqlElementPattern() {} +func (*GqlFullEdgeLeft) isGqlElementPattern() {} +func (*GqlFullEdgeRight) isGqlElementPattern() {} +func (*GqlAbbreviatedEdgeAny) isGqlElementPattern() {} +func (*GqlAbbreviatedEdgeLeft) isGqlElementPattern() {} +func (*GqlAbbreviatedEdgeRight) isGqlElementPattern() {} + +type GqlPathMode struct { + // pos = ModeToken.pos + // end = (PathOrPathsToken ?? ModeToken).end + + Mode GqlPathModeEnum + ModeToken *Ident + PathOrPathsToken *Ident // optional +} + +/* + type GqlQuantifiedPathPrimary struct { + PathPrimary + } +*/ +type GqlQuantifier interface { + Node + isGqlQuantifier() +} + +func (g *GqlFixedQuantifier) isGqlQuantifier() {} +func (g *GqlBoundedQuantifier) isGqlQuantifier() {} + +type GqlFixedQuantifier struct { + // pos = LBrace + // end = RBrace + 1 + + LBrace, RBrace token.Pos + Bound IntValue +} + +type GqlBoundedQuantifier struct { + // pos = LBrace + // end = RBrace + 1 + LBrace, RBrace token.Pos + LowerBound IntValue // optional + UpperBound IntValue +} + +type GqlSubpathPattern struct { + // pos = LParen + // end = RParen + 1 + + LParen, RParen token.Pos // position of "(" and ")" + PathMode *GqlPathMode // optional + PathPattern *GqlPathPattern + WhereClause *Where // optional +} + +type GqlNodePattern struct { + // pos = LParen + // end = RParen + 1 + + LParen, RParen token.Pos + PatternFiller *GqlPatternFiller +} + +// EdgePattern TODO +/* +edge_pattern: + { + full_edge_any | + full_edge_left | + full_edge_right | + abbreviated_edge_any | + abbreviated_edge_left | + abbreviated_edge_right + } +*/ +/* +type EdgePattern interface { + Node + isEdgePattern() +} + +*/ + +type GqlPatternFiller struct { + // pos = (Hint ?? GraphPatternVariable ?? IsLabelCondition ?? Filter).pos + // end = (Filter ?? IsLabelCondition ?? GraphPatternVariable ?? Hint).end + + // Hint is graph element hint which is a table hint. + Hint *Hint // optional + GraphPatternVariable *Ident // optional + IsLabelCondition *GqlIsLabelCondition // optional + Filter GqlPatternFillerFilter // optional +} + +type GqlIsLabelCondition struct { + // pos = IsOrColon + // end = LabelExpression.end + + IsOrColon token.Pos + LabelExpression GqlLabelExpression +} + +// GqlLabelExpression represents +// +// label_expression: +// { +// label_name +// | or_expression +// | and_expression +// | not_expression +// } +// +// Note: Spanner Graph documentation don't say about paren expression, but there is. +type GqlLabelExpression interface { + Node + isGqlLabelExpression() +} + +func (g *GqlLabelParenExpression) isGqlLabelExpression() {} +func (g *GqlLabelOrExpression) isGqlLabelExpression() {} +func (g *GqlLabelAndExpression) isGqlLabelExpression() {} +func (g *GqlLabelNotExpression) isGqlLabelExpression() {} +func (g *GqlLabelName) isGqlLabelExpression() {} + +type GqlLabelOrExpression struct { + // pos = LParen + // end = RParen + + Left, Right GqlLabelExpression +} + +type GqlLabelParenExpression struct { + // pos = LParen + // end = RParen + 1 + + LParen, RParen token.Pos + LabelExpr GqlLabelExpression +} + +type GqlLabelAndExpression struct { + // pos = Left.pos + // end = Right.end + + Left, Right GqlLabelExpression +} + +type GqlLabelNotExpression struct { + // pos = Not + // end = LabelExpression.end + + Not token.Pos // position of "!" + LabelExpression GqlLabelExpression +} + +type GqlLabelName struct { + // pos = StartPos + // end = if IsPercent then StartPos + 1 + // else LabelName.end + + StartPos token.Pos + IsPercent bool + LabelName *Ident +} + +// GqlPatternFillerFilter represents +type GqlPatternFillerFilter interface { + Node + isGqlPatternFillerFilter() +} + +func (g *GqlPropertyFilters) isGqlPatternFillerFilter() {} +func (g *GqlWhereClause) isGqlPatternFillerFilter() {} +func (w *Where) isGqlPatternFillerFilter() {} + +type GqlPropertyFilters struct { + // pos = LBrace + // end = RBrace + 1 + + LBrace token.Pos // position of "{" + PropertyFilterElemList []*GqlElementProperty + RBrace token.Pos // position of "}" +} + +// GqlElementProperty represents an element of GqlPropertyFilters. +type GqlElementProperty struct { + // pos = ElementPropertyName.pos + // end = ElementPropertyValue.pos + + ElementPropertyName *Ident + ElementPropertyValue Expr +} + +// GqlPathSearchPrefix represents +// +// `{"ALL" | "ANY" | "ANY SHORTEST"}`. +type GqlPathSearchPrefix struct { + // pos = StartPos + // end = LastEnd + + StartPos token.Pos + LastEnd token.Pos // end of last token + SearchPrefix GqlSearchPrefixEnum +} diff --git a/ast/const.go b/ast/const.go index 7d1ae6f7..83f16d39 100644 --- a/ast/const.go +++ b/ast/const.go @@ -130,3 +130,44 @@ const ( InsertOrTypeUpdate InsertOrType = "UPDATE" InsertOrTypeIgnore InsertOrType = "IGNORE" ) + +type GqlAllOrDistinctEnum int + +const ( + GqlAllOrDistinctImplicitAll GqlAllOrDistinctEnum = iota + GqlAllOrDistinctAll = iota + GqlAllOrDistinctDistinct +) + +type GqlSetOperatorEnum int + +const ( + GqlSetOperatorUnion GqlSetOperatorEnum = iota + GqlSetOperatorIntersect + GqlSetOperatorExcept +) + +type GqlDirection string + +const ( + GqlSortOrderUnspecified GqlDirection = "" + GqlSortOrderAsc GqlDirection = "ASC" + GqlSortOrderAscending GqlDirection = "ASCENDING" + GqlSortOrderDesc GqlDirection = "DESC" + GqlSortOrderDescending GqlDirection = "DESCENDING" +) + +type GqlPathModeEnum int + +const ( + GqlPathModeWalk GqlPathModeEnum = iota + GqlPathModeTrail +) + +type GqlSearchPrefixEnum int + +const ( + GqlPathSearchPrefixAll GqlSearchPrefixEnum = iota + GqlPathSearchPrefixAny + GqlPathSearchPrefixAnyShortest +) diff --git a/ast/gql.go b/ast/gql.go deleted file mode 100644 index d54e02f8..00000000 --- a/ast/gql.go +++ /dev/null @@ -1,607 +0,0 @@ -package ast - -import ( - "fmt" - "github.com/cloudspannerecosystem/memefish/token" -) - -// GqlGraphQuery is toplevel node of GRAPH query. -type GqlGraphQuery struct { - // pos = (GraphClause ?? GqlMultiLinearQueryStatement).pos - // end = GqlMultiLinearQueryStatement.pos - GraphClause *GqlGraphClause - GqlMultiLinearQueryStatement *GqlMultiLinearQueryStatement -} - -func (g *GqlGraphQuery) Pos() token.Pos { - return g.GraphClause.Pos() -} - -func (g *GqlGraphQuery) End() token.Pos { - return g.GqlMultiLinearQueryStatement.End() -} - -func (g *GqlGraphQuery) isStatement() {} -func (s *GqlGraphQuery) SQL() string { - return s.GraphClause.SQL() + "\n" + s.GqlMultiLinearQueryStatement.SQL() -} - -// GqlQueryExpr is similar to GqlGraphQuery, -// but it is appeared in GQL subqueries and it can optionally have GRAPH clause -type GqlQueryExpr struct { - // pos = (GraphClause ?? GqlMultiLinearQueryStatement).pos - // end = GqlMultiLinearQueryStatement.pos - GraphClause *GqlGraphClause // optional - GqlMultiLinearQueryStatement *GqlMultiLinearQueryStatement -} - -func (g *GqlQueryExpr) Pos() token.Pos { - return firstValidPos(g.GraphClause, g.GqlMultiLinearQueryStatement) -} - -func (g *GqlQueryExpr) End() token.Pos { - return g.GqlMultiLinearQueryStatement.End() -} - -func (g *GqlQueryExpr) SQL() string { - return sqlOpt("", g.GraphClause, "\n") + g.GqlMultiLinearQueryStatement.SQL() -} - -type GqlGraphClause struct { - GqlGraph token.Pos - GqlPropertyGraphName *Ident -} - -func (s *GqlGraphClause) Pos() token.Pos { - return s.GqlGraph -} - -func (s *GqlGraphClause) End() token.Pos { - return s.GqlPropertyGraphName.End() -} - -func (s *GqlGraphClause) SQL() string { - return fmt.Sprintf("GRAPH %v", s.GqlPropertyGraphName.SQL()) -} - -type GqlNextStatement struct { - GqlNext *token.Pos -} - -func (s *GqlNextStatement) SQL() string { - return "NEXT" -} - -type GqlMultiLinearQueryStatement struct { - GqlLinearQueryStatements []GqlLinearQueryStatement -} - -func (s *GqlMultiLinearQueryStatement) Pos() token.Pos { - return s.GqlLinearQueryStatements[0].Pos() -} - -func (s *GqlMultiLinearQueryStatement) End() token.Pos { - return s.GqlLinearQueryStatements[len(s.GqlLinearQueryStatements)-1].End() -} - -func (s *GqlMultiLinearQueryStatement) SQL() string { - return sqlJoin(s.GqlLinearQueryStatements, "\nNEXT\n") -} - -type GqlLinearQueryStatement interface { - Node - isGqlLinearQueryStatement() -} - -type GqlSimpleLinearQueryStatement struct { - PrimitiveQueryStatementList []GqlPrimitiveQueryStatement -} - -func (s *GqlSimpleLinearQueryStatement) Pos() token.Pos { - return firstPos(s.PrimitiveQueryStatementList) -} - -func (s *GqlSimpleLinearQueryStatement) End() token.Pos { - return lastEnd(s.PrimitiveQueryStatementList) -} - -func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} - -func (s *GqlSimpleLinearQueryStatement) SQL() string { - return sqlJoin(s.PrimitiveQueryStatementList, "\n") -} - -type GqlAllOrDistinctEnum int - -const ( - GqlAllOrDistinctImplicitAll = iota - GqlAllOrDistinctAll = iota - GqlAllOrDistinctDistinct -) - -type GqlSetOperatorEnum int - -const ( - GqlSetOperatorUnion = iota - GqlSetOperatorIntersect - GqlSetOperatorExcept -) - -type GqlSimpleLinearQueryStatementWithSetOperator struct { - StartPos token.Pos - SetOperator GqlSetOperatorEnum - DistinctOrAll GqlAllOrDistinctEnum - Statement *GqlSimpleLinearQueryStatement -} - -type GqlCompositeLinearQueryStatement struct { - HeadSimpleLinearQueryStatement *GqlSimpleLinearQueryStatement - TailSimpleLinearQueryStatementList []*GqlSimpleLinearQueryStatementWithSetOperator -} - -func (s *GqlCompositeLinearQueryStatement) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (s *GqlCompositeLinearQueryStatement) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (s *GqlCompositeLinearQueryStatement) SQL() string { - var sql string - sql += s.HeadSimpleLinearQueryStatement.SQL() - for _, s := range s.TailSimpleLinearQueryStatementList { - sql += "\n" - switch s.SetOperator { - case GqlSetOperatorUnion: - sql += "UNION" - case GqlSetOperatorIntersect: - sql += "INTERSECT" - case GqlSetOperatorExcept: - sql += "INTERSECT" - } - - switch s.DistinctOrAll { - case GqlAllOrDistinctAll: - sql += " " + "ALL" - case GqlAllOrDistinctDistinct: - sql += " " + "DISTINCT" - } - sql += "\n" + s.Statement.SQL() - } - return sql -} - -func (*GqlCompositeLinearQueryStatement) isGqlLinearQueryStatement() {} - -type GqlPrimitiveQueryStatement interface { - Node - isGqlPrimitiveQueryStatement() -} - -type GqlMatchStatement struct { - Optional token.Pos - Match token.Pos - MatchHint *Hint - PrefixOrMode GqlPathSearchPrefixOrPathMode // optional - GraphPattern *GqlGraphPattern -} - -func (g GqlMatchStatement) Pos() token.Pos { - return g.Match -} - -func (g GqlMatchStatement) End() token.Pos { - return g.GraphPattern.Pos() -} - -func (g GqlMatchStatement) SQL() string { - var sql string - if g.Optional != token.InvalidPos { - sql = "OPTIONAL MATCH" - } else { - sql = "MATCH" - } - if g.MatchHint != nil { - sql += g.MatchHint.SQL() - } - if g.PrefixOrMode != nil { - sql += " " + g.PrefixOrMode.SQL() - } - sql += " " + g.GraphPattern.SQL() - return sql -} - -func (g GqlMatchStatement) isGqlPrimitiveQueryStatement() {} - -type GqlLimitAndOffsetClause interface { - Node - isGqlLimitAndOffsetClause() -} - -// GqlLimitClause is wrapper of Limit for GQL -type GqlLimitClause struct { - // pos = Limit.pos - // end = Limit.end - Limit *Limit -} - -// GqlOffsetClause is wrapper of Offset for GQL -type GqlOffsetClause struct { - // pos = Offset.pos - // end = Offset.end - Offset *Offset -} - -func (g *GqlOffsetClause) Pos() token.Pos { - return g.Pos() -} - -func (g *GqlOffsetClause) End() token.Pos { - return g.End() -} - -func (g *GqlOffsetClause) SQL() string { - return g.SQL() -} - -func (g *GqlOffsetClause) isGqlLimitAndOffsetClause() {} - -// GqlLimitClauseWithOffset -type GqlLimitWithOffsetClause struct { - // pos = Limit.pos - // end = Offset.end - Limit *Limit - Offset *Offset -} - -func (g GqlLimitWithOffsetClause) Pos() token.Pos { - return g.Limit.Pos() -} - -func (g GqlLimitWithOffsetClause) End() token.Pos { - return g.Offset.End() -} - -func (g *GqlLimitWithOffsetClause) SQL() string { - return g.Limit.SQL() + " " + g.Offset.SQL() -} - -func (g *GqlLimitWithOffsetClause) isGqlLimitAndOffsetClause() {} - -func (g *GqlLimitClause) Pos() token.Pos { - return g.Limit.Pos() -} - -func (g *GqlLimitClause) End() token.Pos { - return g.Limit.End() -} - -func (g *GqlLimitClause) SQL() string { - return g.Limit.SQL() -} - -func (g *GqlLimitClause) isGqlLimitAndOffsetClause() {} - -type GqlFilterStatement struct { - Filter token.Pos - Where token.Pos - Expr Expr -} - -func (g *GqlFilterStatement) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g *GqlFilterStatement) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g *GqlFilterStatement) SQL() string { - if g.Where != token.InvalidPos { - return "FILTER WHERE " + g.Expr.SQL() - } - return "FILTER " + g.Expr.SQL() -} - -func (g *GqlFilterStatement) isGqlPrimitiveQueryStatement() { - //TODO implement me - panic("implement me") -} - -type GqlForStatement struct { - For token.Pos - ElementName *Ident - ArrayExpression Expr - WithOffsetClause *GqlWithOffsetClause -} - -func (g GqlForStatement) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlForStatement) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlForStatement) SQL() string { - return "FOR " + g.ElementName.SQL() + " IN " + g.ArrayExpression.SQL() + sqlOpt(" ", g.WithOffsetClause, "") -} - -func (g GqlForStatement) isGqlPrimitiveQueryStatement() { - //TODO implement me - panic("implement me") -} - -type GqlLimitStatement struct { - Limit token.Pos - Count IntValue -} - -func (g *GqlLimitStatement) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g *GqlLimitStatement) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g *GqlLimitStatement) SQL() string { - return "LIMIT " + g.Count.SQL() -} - -func (g *GqlLimitStatement) isGqlPrimitiveQueryStatement() { - //TODO implement me - panic("implement me") -} - -/* OFFSET/SKIP statement */ - -// GqlOffsetStatement represents OFFSET statement. -// It also represents SKIP statement as the synonym. -type GqlOffsetStatement struct { - // pos = Offset.pos - // end = Count.end - Offset token.Pos - IsSkip bool - Count IntValue -} - -func (g GqlOffsetStatement) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlOffsetStatement) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlOffsetStatement) SQL() string { - if g.IsSkip { - return "SKIP " + g.Count.SQL() - } - return "OFFSET " + g.Count.SQL() -} - -func (g GqlOffsetStatement) isGqlPrimitiveQueryStatement() { - //TODO implement me - panic("implement me") -} - -type GqlOrderByStatement struct { - Order token.Pos - OrderBySpecificationList []*GqlOrderBySpecification -} - -func (g GqlOrderByStatement) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlOrderByStatement) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlOrderByStatement) SQL() string { - return "ORDER BY " + sqlJoin(g.OrderBySpecificationList, ", ") -} - -func (g GqlOrderByStatement) isGqlPrimitiveQueryStatement() { - //TODO implement me - panic("implement me") -} - -type GqlDirection string - -const ( - GqlSortOrderUnspecified = "" - GqlSortOrderAsc = "ASC" - GqlSortOrderAscending = "ASCENDING" - GqlSortOrderDesc = "DESC" - GqlSortOrderDescending = "DESCENDING" -) - -// TODO -type GqlOrderBySpecification struct { - Expr Expr - // TODO - // CollationSpecification *GqlCollationSpecification - DirectionPos token.Pos - Direction GqlDirection -} - -func (g GqlOrderBySpecification) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlOrderBySpecification) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlOrderBySpecification) SQL() string { - sql := g.Expr.SQL() - if g.Direction != GqlSortOrderUnspecified { - sql += " " + string(g.Direction) - } - return sql -} - -type GqlWithStatement struct { - With token.Pos - AllOrDistinct GqlAllOrDistinctEnum - ReturnItemList []GqlReturnItem - GroupByClause *GroupBy // optional -} - -func (g GqlWithStatement) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlWithStatement) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlWithStatement) SQL() string { - var allOrDistinctStr string - switch g.AllOrDistinct { - case GqlAllOrDistinctDistinct: - allOrDistinctStr = "DISTINCT " - case GqlAllOrDistinctAll: - allOrDistinctStr = "ALL " - case GqlAllOrDistinctImplicitAll: - allOrDistinctStr = "" - } - return "WITH " + allOrDistinctStr + sqlJoin(g.ReturnItemList, ", ") + sqlOpt(" ", g.GroupByClause, "") -} - -func (g GqlWithStatement) isGqlPrimitiveQueryStatement() { - //TODO implement me - panic("implement me") -} - -type GqlWithOffsetClause struct { - // pos = With.pos - // end = OffsetName.end ?? Offset + 6 - With token.Pos - Offset token.Pos - OffsetName *Ident -} - -func (g *GqlWithOffsetClause) Pos() token.Pos { - return g.With -} - -func (g *GqlWithOffsetClause) End() token.Pos { - if g.OffsetName != nil { - return g.OffsetName.End() - } - return g.Offset + 6 -} - -func (g *GqlWithOffsetClause) SQL() string { - return "WITH OFFSET" + sqlOpt(" AS ", g.OffsetName, "") -} - -// GqlReturnItem is similar to SelectItem, -// but it don't permit DotStar and AsAlias without AS. -type GqlReturnItem SelectItem - -type GqlReturnStatement struct { - AllOrDistinct GqlAllOrDistinctEnum - Return token.Pos - ReturnItemList []GqlReturnItem - - // Use GoogleSQL GroupBy because it is referenced in docs - GroupByClause *GroupBy //optional - - // Use GoogleSQL OrderBy because it is referenced in docs - OrderByClause *OrderBy //optional - - LimitAndOffsetClause GqlLimitAndOffsetClause -} - -func (s *GqlReturnStatement) Pos() token.Pos { - return s.Return -} - -func (s *GqlReturnStatement) End() token.Pos { - return s.ReturnItemList[len(s.ReturnItemList)-1].End() -} - -type GqlLinearGraphVariable struct { - VariableName *Ident - Value Expr -} - -func (s *GqlLinearGraphVariable) Pos() token.Pos { return s.VariableName.Pos() } - -func (s *GqlLinearGraphVariable) End() token.Pos { return s.Value.End() } - -func (s *GqlLinearGraphVariable) SQL() string { - return fmt.Sprintf("%v = %v", s.VariableName.SQL(), s.Value.SQL()) -} - -type GqlLetStatement struct { - // pos = Let.pos - // end = LinearGraphVariableList[$].end - - Let token.Pos - LinearGraphVariableList []*GqlLinearGraphVariable -} - -func (s *GqlLetStatement) Pos() token.Pos { - return s.Let -} - -func (s *GqlLetStatement) End() token.Pos { - if len(s.LinearGraphVariableList) == 0 { - return s.Let + 3 - } - return s.LinearGraphVariableList[len(s.LinearGraphVariableList)].End() -} - -func (s *GqlLetStatement) SQL() string { - return "LET " + sqlJoin(s.LinearGraphVariableList, ", ") -} -func (*GqlLetStatement) isGqlPrimitiveQueryStatement() {} - -func (*GqlReturnStatement) isGqlPrimitiveQueryStatement() {} - -func (s *GqlReturnStatement) SQL() string { - sql := "RETURN " - switch s.AllOrDistinct { - case GqlAllOrDistinctAll: - sql += "ALL " - case GqlAllOrDistinctDistinct: - sql += "DISTINCT " - case GqlAllOrDistinctImplicitAll: - // empty - } - - sql += sqlJoin(s.ReturnItemList, ", ") - - if s.GroupByClause != nil { - sql += " " + s.GroupByClause.SQL() - } - if s.OrderByClause != nil { - sql += " " + s.OrderByClause.SQL() - } - if s.LimitAndOffsetClause != nil { - sql += " " + s.LimitAndOffsetClause.SQL() - } - return sql -} diff --git a/ast/graph_patterns.go b/ast/graph_patterns.go deleted file mode 100644 index e85bda7e..00000000 --- a/ast/graph_patterns.go +++ /dev/null @@ -1,752 +0,0 @@ -package ast - -import ( - "fmt" - "github.com/cloudspannerecosystem/memefish/token" - "strings" -) - -// https://cloud.google.com/spanner/docs/reference/standard-sql/graph-patterns - -// GqlGraphPattern represents is the toplevel node of GQL graph patterns. -type GqlGraphPattern struct { - // pos = GqlTopLevelPathPattern[0].pos - // end = (WhereClause ?? PathPatternList[$]).end - PathPatternList []*GqlTopLevelPathPattern - WhereClause *Where // optional -} - -func (g GqlGraphPattern) Pos() token.Pos { - return firstPos(g.PathPatternList) -} - -func (g GqlGraphPattern) End() token.Pos { - if g.WhereClause != nil { - return g.WhereClause.End() - } - return lastEnd(g.PathPatternList) -} - -func (g GqlGraphPattern) SQL() string { - return sqlJoin(g.PathPatternList, ", ") + sqlOpt(" ", g.WhereClause, "") -} - -// GqlTopLevelPathPattern is a PathPattern optionally prefixed by PathSearchPrefixOrPathMode. -type GqlTopLevelPathPattern struct { - // pos = (PathSearchPrefixOrPathMode ?? PathPattern).pos - // end = PathPattern.end - PathSearchPrefixOrPathMode GqlPathSearchPrefixOrPathMode // optional - PathPattern *GqlPathPattern -} - -func (g GqlTopLevelPathPattern) Pos() token.Pos { - return firstValidPos(g.PathSearchPrefixOrPathMode, g.PathPattern) -} - -func (g GqlTopLevelPathPattern) End() token.Pos { - return g.PathPattern.End() -} - -func (g GqlTopLevelPathPattern) SQL() string { - return sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() -} - -// GqlPathSearchPrefixOrPathMode represents `{ path_search_prefix | path_mode }` -type GqlPathSearchPrefixOrPathMode interface { - Node - isGqlPathSearchPrefixOrPathMode() -} - -// GqlEdgePattern represents edge pattern nodes. -// -// edge_pattern: -// { -// full_edge_any | -// full_edge_left | -// full_edge_right | -// abbreviated_edge_any | -// abbreviated_edge_left | -// abbreviated_edge_right -// } -type GqlEdgePattern interface { - GqlElementPattern - isGqlEdgePattern() -} - -// GqlFullEdgeAny is node representing`-[pattern_filler]-` . -type GqlFullEdgeAny struct { - // pos = First.pos - // end = Last.pos + 1 - First, Last token.Pos - PatternFiller *GqlPatternFiller -} - -func (g GqlFullEdgeAny) Pos() token.Pos { - return g.First -} - -func (g GqlFullEdgeAny) End() token.Pos { - return g.Last + 1 -} - -func (g GqlFullEdgeAny) SQL() string { - return fmt.Sprintf("-[%v]-", g.PatternFiller.SQL()) -} - -func (g GqlFullEdgeAny) isGqlPathTerm() {} -func (g GqlFullEdgeAny) isGqlElementPattern() {} -func (g GqlFullEdgeAny) isGqlEdgePattern() {} - -type GqlFullEdgeLeft struct { - // pos = First - // end = Last + 1 - First token.Pos // position of "<" - Last token.Pos // position of the last "-" - PatternFiller *GqlPatternFiller -} - -func (g GqlFullEdgeLeft) Pos() token.Pos { - return g.First -} - -func (g GqlFullEdgeLeft) End() token.Pos { - return g.Last + 1 -} - -func (g GqlFullEdgeLeft) SQL() string { - return fmt.Sprintf("<-[%v]-", g.PatternFiller.SQL()) -} - -func (g GqlFullEdgeLeft) isGqlPathTerm() {} - -func (g GqlFullEdgeLeft) isGqlElementPattern() {} - -func (g GqlFullEdgeLeft) isGqlEdgePattern() {} - -type GqlFullEdgeRight struct { - // pos = First - // end = Last + 1 - First token.Pos // position of the first "-" - Last token.Pos // position of ">" - PatternFiller *GqlPatternFiller -} - -func (g GqlFullEdgeRight) Pos() token.Pos { - return g.First -} - -func (g GqlFullEdgeRight) End() token.Pos { - return g.Last + 1 -} - -func (g GqlFullEdgeRight) SQL() string { - return fmt.Sprintf("-[%v]->", g.PatternFiller.SQL()) -} - -func (g GqlFullEdgeRight) isGqlPathTerm() {} - -func (g GqlFullEdgeRight) isGqlElementPattern() {} - -func (g GqlFullEdgeRight) isGqlEdgePattern() {} - -type GqlAbbreviatedEdgeAny struct { - // pos = Hyphen - // end = Hyphen +1 - Hyphen token.Pos // position of "-" -} - -func (g GqlAbbreviatedEdgeAny) Pos() token.Pos { - return g.Hyphen -} - -func (g GqlAbbreviatedEdgeAny) End() token.Pos { - return g.Hyphen + 1 -} - -func (g GqlAbbreviatedEdgeAny) SQL() string { - return "-" -} - -func (g GqlAbbreviatedEdgeAny) isGqlPathTerm() {} - -func (g GqlAbbreviatedEdgeAny) isGqlElementPattern() {} - -func (g GqlAbbreviatedEdgeAny) isGqlEdgePattern() {} - -type GqlAbbreviatedEdgeLeft struct { - // pos = First - // end = Last + 1 - First token.Pos // position of "<" - Last token.Pos // position of "-" -} - -func (g GqlAbbreviatedEdgeLeft) Pos() token.Pos { - return g.First -} - -func (g GqlAbbreviatedEdgeLeft) End() token.Pos { - return g.Last + 1 -} - -func (g GqlAbbreviatedEdgeLeft) SQL() string { - return "<-" -} - -func (g GqlAbbreviatedEdgeLeft) isGqlPathTerm() {} - -func (g GqlAbbreviatedEdgeLeft) isGqlElementPattern() {} - -func (g GqlAbbreviatedEdgeLeft) isGqlEdgePattern() {} - -type GqlAbbreviatedEdgeRight struct { - // pos = First - // end = Last + 1 - First token.Pos // position of "-" - Last token.Pos // position of ">" -} - -func (g GqlAbbreviatedEdgeRight) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlAbbreviatedEdgeRight) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlAbbreviatedEdgeRight) SQL() string { - return "->" -} - -func (g GqlAbbreviatedEdgeRight) isGqlPathTerm() {} - -func (g GqlAbbreviatedEdgeRight) isGqlElementPattern() {} - -func (g GqlAbbreviatedEdgeRight) isGqlEdgePattern() {} - -type GqlQuantifiablePathTerm struct { - Hint *Hint // optional - PathTerm GqlPathTerm - Quantifier GqlQuantifier // optional -} - -func (g GqlQuantifiablePathTerm) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlQuantifiablePathTerm) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlQuantifiablePathTerm) SQL() string { - var sql string - sql += sqlOpt("", g.Hint, "") - sql += g.PathTerm.SQL() - if g.Quantifier != nil { - sql += g.Quantifier.SQL() - } - return sql -} - -type GqlPathPattern struct { - PathTermList []*GqlQuantifiablePathTerm -} - -func (g GqlPathPattern) Pos() token.Pos { - return firstPos(g.PathTermList) -} - -func (g GqlPathPattern) End() token.Pos { - return lastEnd(g.PathTermList) -} - -func (g GqlPathPattern) SQL() string { - var sql string - sql += g.PathTermList[0].SQL() - for _, elem := range g.PathTermList[1:] { - sql += elem.SQL() - } - return sql -} - -type GqlPathTerm interface { - Node - isGqlPathTerm() -} - -type GqlWhereClause struct { - Where token.Pos - BoolExpression Expr -} - -func (g GqlWhereClause) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlWhereClause) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlWhereClause) SQL() string { - //TODO implement me - panic("implement me") -} - -func (g GqlWhereClause) isGqlPatternFillerFilter() {} - -type GqlElementPattern interface { - Node - GqlPathTerm - isGqlElementPattern() -} - -type gqlPathModeEnum int - -const ( - GqlPathModeWalk gqlPathModeEnum = iota - GqlPathModeTrail -) - -type GqlPathMode struct { - Mode gqlPathModeEnum - ModeToken *Ident - PathOrPathToken *Ident -} - -func (g *GqlPathMode) isGqlPathSearchPrefixOrPathMode() { - //TODO implement me - panic("implement me") -} - -func (g *GqlPathMode) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g *GqlPathMode) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g *GqlPathMode) SQL() string { - switch g.Mode { - case GqlPathModeTrail: - return "TRAIL" - case GqlPathModeWalk: - return "WALK" - default: - panic("UNKNOWN GqlPathMode") - } -} - -/* - type GqlQuantifiedPathPrimary struct { - PathPrimary - } -*/ -type GqlQuantifier interface { - Node - isGqlQuantifier() -} -type GqlFixedQuantifier struct { - LBrace, RBrace token.Pos - Bound IntValue -} - -func (g GqlFixedQuantifier) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlFixedQuantifier) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlFixedQuantifier) SQL() string { - return "{" + g.Bound.SQL() + "}" -} - -func (g GqlFixedQuantifier) isGqlQuantifier() { - //TODO implement me - panic("implement me") -} - -type GqlBoundedQuantifier struct { - // pos = LBrace - // end = RBrace + 1 - LBrace, RBrace token.Pos - LowerBound IntValue // optional - UpperBound IntValue -} - -func (g *GqlBoundedQuantifier) Pos() token.Pos { - return g.LBrace -} - -func (g *GqlBoundedQuantifier) End() token.Pos { - return g.RBrace + 1 -} - -func (g *GqlBoundedQuantifier) SQL() string { - return fmt.Sprintf("{%v,%v}", sqlOpt("", g.LowerBound, ""), g.UpperBound.SQL()) -} - -func (g *GqlBoundedQuantifier) isGqlQuantifier() { -} - -type GqlSubpathPattern struct { - // pos = LParen - // end = RParen + 1 - LParen, RParen token.Pos - PathMode *GqlPathMode - PathPattern *GqlPathPattern - WhereClause *Where -} - -func (g GqlSubpathPattern) Pos() token.Pos { - return g.LParen -} - -func (g GqlSubpathPattern) End() token.Pos { - return g.RParen + 1 -} - -func (g GqlSubpathPattern) SQL() string { - return "(" + - sqlOpt("", g.PathMode, " ") + - g.PathPattern.SQL() + - sqlOpt(" ", g.WhereClause, "") + - ")" -} - -func (g GqlSubpathPattern) isGqlPathTerm() { -} - -type GqlNodePattern struct { - LParen, RParen token.Pos - PatternFiller *GqlPatternFiller -} - -func (g GqlNodePattern) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlNodePattern) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlNodePattern) SQL() string { - var sql string - sql += fmt.Sprintf("(%v)", g.PatternFiller.SQL()) - return sql -} - -func (g GqlNodePattern) isGqlPathTerm() {} - -// EdgePattern TODO -/* -edge_pattern: - { - full_edge_any | - full_edge_left | - full_edge_right | - abbreviated_edge_any | - abbreviated_edge_left | - abbreviated_edge_right - } -*/ -/* -type EdgePattern interface { - Node - isEdgePattern() -} - -*/ - -type GqlPatternFiller struct { - // Hint is graph element hint which is a table hint. - Hint *Hint - GraphPatternVariable *Ident // optional - IsLabelCondition *GqlIsLabelCondition // optional - Filter GqlPatternFillerFilter // optional -} - -func (g GqlPatternFiller) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlPatternFiller) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlPatternFiller) SQL() string { - var sql string - sql += sqlOpt("", g.Hint, "") - if g.GraphPatternVariable != nil { - sql += g.GraphPatternVariable.SQL() - } - if g.IsLabelCondition != nil { - sql += g.IsLabelCondition.SQL() - } - if g.Filter != nil { - if sql == "" { - sql = g.Filter.SQL() - } else { - sql += " " + g.Filter.SQL() - } - } - return sql -} - -type GqlIsLabelCondition struct { - IsOrColon token.Pos - LabelExpression GqlLabelExpression -} - -func (g GqlIsLabelCondition) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlIsLabelCondition) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlIsLabelCondition) SQL() string { - return ":" + g.LabelExpression.SQL() -} - -// GqlLabelExpression TODO -/* -label_expression: - { - label_name - | or_expression - | and_expression - | not_expression - } -*/ -type GqlLabelExpression interface { - Node - isGqlLabelExpression() -} - -type GqlLabelOrExpression struct { - Left, Right GqlLabelExpression -} - -type GqlLabelParenExpression struct { - LParen, RParen token.Pos - LabelExpr GqlLabelExpression -} - -func (g GqlLabelParenExpression) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelParenExpression) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelParenExpression) SQL() string { - return "(" + g.LabelExpr.SQL() + ")" -} - -func (g GqlLabelParenExpression) isGqlLabelExpression() { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelOrExpression) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelOrExpression) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelOrExpression) SQL() string { - return g.Left.SQL() + "|" + g.Right.SQL() -} - -func (g GqlLabelOrExpression) isGqlLabelExpression() { - //TODO implement me - panic("implement me") -} - -type GqlLabelAndExpression struct { - Left, Right GqlLabelExpression -} - -func (g GqlLabelAndExpression) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelAndExpression) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelAndExpression) SQL() string { - return g.Left.SQL() + "&" + g.Right.SQL() -} - -func (g GqlLabelAndExpression) isGqlLabelExpression() { - //TODO implement me - panic("implement me") -} - -type GqlLabelNotExpression struct { - NotPos token.Pos - LabelExpression GqlLabelExpression -} - -func (g GqlLabelNotExpression) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelNotExpression) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelNotExpression) SQL() string { - return "!" + g.LabelExpression.SQL() -} - -func (g GqlLabelNotExpression) isGqlLabelExpression() { - //TODO implement me - panic("implement me") -} - -type GqlLabelName struct { - IsPercent bool - LabelName *Ident -} - -func (g GqlLabelName) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelName) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlLabelName) SQL() string { - if g.IsPercent { - return "%" - } - return g.LabelName.SQL() -} - -func (g GqlLabelName) isGqlLabelExpression() {} - -type GqlPatternFillerFilter interface { - Node - isGqlPatternFillerFilter() -} - -type GqlPropertyFilters struct { - LBrace token.Pos - PropertyFilterElemList []*GqlElementProperty - RBrace token.Pos -} - -func (g GqlPropertyFilters) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlPropertyFilters) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlPropertyFilters) SQL() string { - var elemSqls []string - for _, elem := range g.PropertyFilterElemList { - elemSqls = append(elemSqls, elem.SQL()) - } - - return fmt.Sprintf("{%v}", strings.Join(elemSqls, ", ")) -} - -func (g GqlPropertyFilters) isGqlPatternFillerFilter() {} - -type GqlElementProperty struct { - ElementPropertyName *Ident - ElementPropertyValue Expr -} - -func (g GqlElementProperty) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlElementProperty) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (g GqlElementProperty) SQL() string { - var sql string - sql += g.ElementPropertyName.SQL() + ": " + g.ElementPropertyValue.SQL() - return sql -} - -type gqlSearchPrefixEnum int - -const ( - GqlPathSearchPrefixAll = iota - GqlPathSearchPrefixAny - GqlPathSearchPrefixAnyShortest -) - -type GqlPathSearchPrefix struct { - StartPos token.Pos - SearchPrefix gqlSearchPrefixEnum -} - -func (p *GqlPathSearchPrefix) Pos() token.Pos { - //TODO implement me - panic("implement me") -} - -func (p *GqlPathSearchPrefix) End() token.Pos { - //TODO implement me - panic("implement me") -} - -func (p *GqlPathSearchPrefix) SQL() string { - switch p.SearchPrefix { - case GqlPathSearchPrefixAny: - return "ANY" - case GqlPathSearchPrefixAnyShortest: - return "ANY SHORTEST" - case GqlPathSearchPrefixAll: - return "ALL" - default: - panic("invalid GqlPathSearchPrefix") - } -} - -func (p *GqlPathSearchPrefix) isGqlPathSearchPrefixOrPathMode() {} diff --git a/ast/pos.go b/ast/pos.go index 1dbe805c..523cf6e3 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -896,3 +896,202 @@ func (o *SequenceOption) End() token.Pos { return o.Value.End() } func (o *SequenceOptions) Pos() token.Pos { return o.Options } func (o *SequenceOptions) End() token.Pos { return o.Rparen + 1 } + +// GQL + +func (g *GqlGraphQuery) Pos() token.Pos { return g.GraphClause.Pos() } +func (g *GqlGraphQuery) End() token.Pos { return g.MultiLinearQueryStatement.End() } + +func (g *GqlQueryExpr) Pos() token.Pos { + return firstValidPos(g.GraphClause, g.MultiLinearQueryStatement) +} +func (g *GqlQueryExpr) End() token.Pos { return g.MultiLinearQueryStatement.End() } + +func (s *GqlGraphClause) Pos() token.Pos { return s.Graph } +func (s *GqlGraphClause) End() token.Pos { return s.PropertyGraphName.End() } + +func (s *GqlMultiLinearQueryStatement) Pos() token.Pos { + return firstPos(s.LinearQueryStatementList) +} +func (s *GqlMultiLinearQueryStatement) End() token.Pos { return lastEnd(s.LinearQueryStatementList) } + +func (s *GqlSimpleLinearQueryStatement) Pos() token.Pos { + return firstPos(s.PrimitiveQueryStatementList) +} +func (s *GqlSimpleLinearQueryStatement) End() token.Pos { + return lastEnd(s.PrimitiveQueryStatementList) +} + +func (s *GqlCompositeLinearQueryStatement) Pos() token.Pos { + return s.HeadSimpleLinearQueryStatement.Pos() +} + +func (s *GqlCompositeLinearQueryStatement) End() token.Pos { + return lastEnd(s.TailSimpleLinearQueryStatementList) +} + +func (s *GqlLinearGraphVariable) Pos() token.Pos { return s.VariableName.Pos() } +func (s *GqlLinearGraphVariable) End() token.Pos { return s.Value.End() } + +func (g *GqlSimpleLinearQueryStatementWithSetOperator) Pos() token.Pos { return g.StartPos } +func (g *GqlSimpleLinearQueryStatementWithSetOperator) End() token.Pos { return g.Statement.End() } + +// GQL statements + +func (g *GqlMatchStatement) Pos() token.Pos { + if !g.Optional.Invalid() { + return g.Optional + } else { + return g.Match + } +} +func (g *GqlMatchStatement) End() token.Pos { + return g.GraphPattern.End() +} + +func (g *GqlLimitClause) Pos() token.Pos { return g.Limit.Pos() } +func (g *GqlLimitClause) End() token.Pos { return g.Limit.End() } + +func (g *GqlOffsetClause) Pos() token.Pos { return g.Pos() } +func (g *GqlOffsetClause) End() token.Pos { return g.End() } + +func (g *GqlLimitWithOffsetClause) Pos() token.Pos { return g.Limit.Pos() } +func (g *GqlLimitWithOffsetClause) End() token.Pos { return g.Offset.End() } + +func (g *GqlFilterStatement) Pos() token.Pos { return g.Filter } +func (g *GqlFilterStatement) End() token.Pos { return g.Expr.End() } + +func (g *GqlForStatement) Pos() token.Pos { return g.For } +func (g *GqlForStatement) End() token.Pos { + return firstValidPos(g.WithOffsetClause, g.ArrayExpression) +} + +func (g *GqlWithOffsetClause) Pos() token.Pos { return g.With } +func (g *GqlWithOffsetClause) End() token.Pos { + if g.OffsetName != nil { + return g.OffsetName.End() + } + return g.Offset + 6 +} + +func (g *GqlLimitStatement) Pos() token.Pos { return g.Limit } +func (g *GqlLimitStatement) End() token.Pos { return g.Count.End() } + +func (g *GqlOffsetStatement) Pos() token.Pos { return g.Offset } +func (g *GqlOffsetStatement) End() token.Pos { return g.Count.End() } + +func (g *GqlOrderByStatement) Pos() token.Pos { return g.Order } +func (g *GqlOrderByStatement) End() token.Pos { return lastEnd(g.OrderBySpecificationList) } + +func (g *GqlWithStatement) Pos() token.Pos { return g.With } +func (g *GqlWithStatement) End() token.Pos { + return firstValidPos(g.GroupByClause, lastElem(g.ReturnItemList)) +} + +func (g *GqlReturnStatement) Pos() token.Pos { + return g.Return +} +func (g *GqlReturnStatement) End() token.Pos { + return firstValidEnd(g.LimitAndOffsetClause, g.OrderByClause, g.GroupByClause, lastElem(g.ReturnItemList)) +} + +func (s *GqlLetStatement) Pos() token.Pos { return s.Let } +func (s *GqlLetStatement) End() token.Pos { + if len(s.LinearGraphVariableList) > 0 { + return lastEnd(s.LinearGraphVariableList) + } + return s.Let + 3 +} + +// GQL graph patterns + +func (g *GqlGraphPattern) Pos() token.Pos { return firstPos(g.PathPatternList) } +func (g *GqlGraphPattern) End() token.Pos { + return firstValidPos(g.WhereClause, lastElem(g.PathPatternList)) +} + +func (g *GqlTopLevelPathPattern) Pos() token.Pos { + return firstValidPos(g.PathSearchPrefixOrPathMode, g.PathPattern) +} +func (g *GqlTopLevelPathPattern) End() token.Pos { return g.PathPattern.End() } + +func (g *GqlFullEdgeAny) Pos() token.Pos { return g.First } +func (g *GqlFullEdgeAny) End() token.Pos { return g.Last + 1 } + +func (g *GqlFullEdgeLeft) Pos() token.Pos { return g.First } +func (g *GqlFullEdgeLeft) End() token.Pos { return g.Last + 1 } + +func (g *GqlFullEdgeRight) Pos() token.Pos { return g.First } +func (g *GqlFullEdgeRight) End() token.Pos { return g.Last + 1 } + +func (g *GqlAbbreviatedEdgeAny) Pos() token.Pos { return g.Hyphen } +func (g *GqlAbbreviatedEdgeAny) End() token.Pos { return g.Hyphen + 1 } + +func (g *GqlAbbreviatedEdgeLeft) Pos() token.Pos { return g.First } +func (g *GqlAbbreviatedEdgeLeft) End() token.Pos { return g.Last + 1 } + +func (g *GqlAbbreviatedEdgeRight) Pos() token.Pos { return g.First } +func (g *GqlAbbreviatedEdgeRight) End() token.Pos { return g.Last + 1 } + +func (g *GqlQuantifiablePathTerm) Pos() token.Pos { return firstValidPos(g.Hint, g.PathTerm) } +func (g *GqlQuantifiablePathTerm) End() token.Pos { return firstValidEnd(g.Quantifier, g.PathTerm) } + +func (g *GqlPathPattern) Pos() token.Pos { return firstPos(g.PathTermList) } +func (g *GqlPathPattern) End() token.Pos { return lastEnd(g.PathTermList) } + +func (g *GqlWhereClause) Pos() token.Pos { return g.Where } +func (g *GqlWhereClause) End() token.Pos { return g.BoolExpression.End() } + +func (g *GqlPathMode) Pos() token.Pos { return g.ModeToken.Pos() } +func (g *GqlPathMode) End() token.Pos { return firstValidEnd(g.PathOrPathsToken, g.ModeToken) } + +func (g *GqlFixedQuantifier) Pos() token.Pos { return g.LBrace } +func (g *GqlFixedQuantifier) End() token.Pos { return g.RBrace + 1 } + +func (g *GqlBoundedQuantifier) Pos() token.Pos { return g.LBrace } +func (g *GqlBoundedQuantifier) End() token.Pos { return g.RBrace + 1 } + +func (g *GqlSubpathPattern) Pos() token.Pos { return g.LParen } +func (g *GqlSubpathPattern) End() token.Pos { return g.RParen + 1 } + +func (g *GqlNodePattern) Pos() token.Pos { return g.LParen } +func (g *GqlNodePattern) End() token.Pos { return g.RParen + 1 } + +func (g *GqlPatternFiller) Pos() token.Pos { + return firstValidPos(g.Hint, g.GraphPatternVariable, g.IsLabelCondition, g.Filter) +} +func (g *GqlPatternFiller) End() token.Pos { + return firstValidEnd(g.Filter, g.IsLabelCondition, g.GraphPatternVariable, g.Hint) +} + +func (g *GqlIsLabelCondition) Pos() token.Pos { return g.IsOrColon } +func (g *GqlIsLabelCondition) End() token.Pos { return g.LabelExpression.End() } + +func (g *GqlLabelParenExpression) Pos() token.Pos { return g.LParen } +func (g *GqlLabelParenExpression) End() token.Pos { return g.RParen + 1 } + +func (g *GqlLabelOrExpression) Pos() token.Pos { return g.Left.Pos() } +func (g *GqlLabelOrExpression) End() token.Pos { return g.Right.End() } + +func (g *GqlLabelAndExpression) Pos() token.Pos { return g.Left.Pos() } +func (g *GqlLabelAndExpression) End() token.Pos { return g.Right.End() } + +func (g *GqlLabelNotExpression) Pos() token.Pos { return g.Not } +func (g *GqlLabelNotExpression) End() token.Pos { return g.LabelExpression.End() } + +func (g *GqlLabelName) Pos() token.Pos { return g.StartPos } +func (g *GqlLabelName) End() token.Pos { + if g.IsPercent { + return g.StartPos + 1 + } + return g.LabelName.End() +} + +func (g *GqlPropertyFilters) Pos() token.Pos { return g.LBrace } +func (g *GqlPropertyFilters) End() token.Pos { return g.RBrace + 1 } + +func (g *GqlElementProperty) Pos() token.Pos { return g.ElementPropertyName.Pos() } +func (g *GqlElementProperty) End() token.Pos { return g.ElementPropertyValue.End() } + +func (p *GqlPathSearchPrefix) Pos() token.Pos { return p.StartPos } +func (p *GqlPathSearchPrefix) End() token.Pos { return p.LastEnd + 1 } diff --git a/ast/sql.go b/ast/sql.go index 618892b9..0144d59a 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1408,3 +1408,248 @@ func (u *UpdateItem) SQL() string { sql += " = " + u.Expr.SQL() return sql } + +// GQL + +func (s *GqlGraphQuery) SQL() string { + return s.GraphClause.SQL() + "\n" + s.MultiLinearQueryStatement.SQL() +} + +func (g *GqlQueryExpr) SQL() string { + return sqlOpt("", g.GraphClause, "\n") + g.MultiLinearQueryStatement.SQL() +} + +func (s *GqlGraphClause) SQL() string { return "GRAPH " + s.PropertyGraphName.SQL() } + +func (s *GqlMultiLinearQueryStatement) SQL() string { + return sqlJoin(s.LinearQueryStatementList, "\nNEXT\n") +} + +func (s *GqlSimpleLinearQueryStatement) SQL() string { + return sqlJoin(s.PrimitiveQueryStatementList, "\n") +} + +func (s *GqlCompositeLinearQueryStatement) SQL() string { + sql := s.HeadSimpleLinearQueryStatement.SQL() + if len(s.TailSimpleLinearQueryStatementList) > 0 { + sql += "\n" + sqlJoin(s.TailSimpleLinearQueryStatementList, "\n") + } + return sql +} + +func (g *GqlSimpleLinearQueryStatementWithSetOperator) SQL() string { + var sql string + switch g.SetOperator { + case GqlSetOperatorUnion: + sql += "UNION" + case GqlSetOperatorIntersect: + sql += "INTERSECT" + case GqlSetOperatorExcept: + sql += "EXCEPT" + } + + switch g.DistinctOrAll { + case GqlAllOrDistinctAll: + sql += " " + "ALL" + case GqlAllOrDistinctDistinct: + sql += " " + "DISTINCT" + default: + // no action + } + + sql += "\n" + g.Statement.SQL() + return sql +} + +func (s *GqlLinearGraphVariable) SQL() string { return s.VariableName.SQL() + " = " + s.Value.SQL() } + +// GQL statements + +func (g *GqlMatchStatement) SQL() string { + var sql string + if !g.Optional.Invalid() { + sql = "OPTIONAL MATCH" + } else { + sql = "MATCH" + } + sql += sqlOpt("", g.MatchHint, "") + sql += sqlOpt(" ", g.PrefixOrMode, "") + sql += " " + g.GraphPattern.SQL() + return sql +} + +func (g *GqlLimitClause) SQL() string { return g.Limit.SQL() } + +func (g *GqlOffsetClause) SQL() string { return g.Offset.SQL() } + +func (g *GqlLimitWithOffsetClause) SQL() string { return g.Limit.SQL() + " " + g.Offset.SQL() } + +func (g *GqlFilterStatement) SQL() string { + if g.Where.Invalid() { + return "FILTER " + g.Expr.SQL() + } + return "FILTER WHERE " + g.Expr.SQL() +} + +func (g *GqlForStatement) SQL() string { + return "FOR " + g.ElementName.SQL() + " IN " + g.ArrayExpression.SQL() + sqlOpt(" ", g.WithOffsetClause, "") +} + +func (g *GqlWithOffsetClause) SQL() string { + return "WITH OFFSET" + sqlOpt(" AS ", g.OffsetName, "") +} + +func (g *GqlLimitStatement) SQL() string { return "LIMIT " + g.Count.SQL() } + +func (g *GqlOffsetStatement) SQL() string { + if g.IsSkip { + return "SKIP " + g.Count.SQL() + } + return "OFFSET " + g.Count.SQL() +} + +func (g *GqlOrderByStatement) SQL() string { + return "ORDER BY " + sqlJoin(g.OrderBySpecificationList, ", ") +} + +func (g *GqlWithStatement) SQL() string { + var allOrDistinctStr string + switch g.AllOrDistinct { + case GqlAllOrDistinctDistinct: + allOrDistinctStr = "DISTINCT " + case GqlAllOrDistinctAll: + allOrDistinctStr = "ALL " + case GqlAllOrDistinctImplicitAll: + allOrDistinctStr = "" + } + return "WITH " + allOrDistinctStr + + sqlJoin(g.ReturnItemList, ", ") + + sqlOpt(" ", g.GroupByClause, "") +} + +func (s *GqlLetStatement) SQL() string { return "LET " + sqlJoin(s.LinearGraphVariableList, ", ") } + +func (g *GqlReturnStatement) SQL() string { + sql := "RETURN " + switch g.AllOrDistinct { + case GqlAllOrDistinctAll: + sql += "ALL " + case GqlAllOrDistinctDistinct: + sql += "DISTINCT " + case GqlAllOrDistinctImplicitAll: + // empty + } + + sql += sqlJoin(g.ReturnItemList, ", ") + + sqlOpt(" ", g.GroupByClause, "") + + sqlOpt(" ", g.OrderByClause, "") + + sqlOpt(" ", g.LimitAndOffsetClause, "") + return sql +} + +// GQL graph patterns + +func (g *GqlGraphPattern) SQL() string { + return sqlJoin(g.PathPatternList, ", ") + sqlOpt(" ", g.WhereClause, "") +} + +func (g *GqlTopLevelPathPattern) SQL() string { + return sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() +} + +func (g *GqlFullEdgeAny) SQL() string { return "-[" + g.PatternFiller.SQL() + "]-" } + +func (g *GqlFullEdgeLeft) SQL() string { return "<-[" + g.PatternFiller.SQL() + "]-" } + +func (g *GqlFullEdgeRight) SQL() string { return "-[" + g.PatternFiller.SQL() + "]->" } + +func (g *GqlAbbreviatedEdgeAny) SQL() string { return "-" } + +func (g *GqlAbbreviatedEdgeLeft) SQL() string { return "<-" } + +func (g *GqlAbbreviatedEdgeRight) SQL() string { return "->" } + +func (g *GqlQuantifiablePathTerm) SQL() string { + return sqlOpt("", g.Hint, "") + g.PathTerm.SQL() + sqlOpt("", g.Quantifier, "") +} + +func (g *GqlPathPattern) SQL() string { return sqlJoin(g.PathTermList, "") } + +func (g *GqlWhereClause) SQL() string { return "WHERE " + g.BoolExpression.SQL() } + +func (g *GqlPathMode) SQL() string { + switch g.Mode { + case GqlPathModeTrail: + return "TRAIL" + case GqlPathModeWalk: + return "WALK" + default: + panic("UNKNOWN GqlPathMode") + } +} + +func (g *GqlFixedQuantifier) SQL() string { return "{" + g.Bound.SQL() + "}" } + +func (g *GqlBoundedQuantifier) SQL() string { + return "{" + sqlOpt("", g.LowerBound, "") + "," + g.UpperBound.SQL() + "}" +} + +func (g *GqlSubpathPattern) SQL() string { + return "(" + + sqlOpt("", g.PathMode, " ") + + g.PathPattern.SQL() + + sqlOpt(" ", g.WhereClause, "") + + ")" +} + +func (g *GqlNodePattern) SQL() string { return "(" + g.PatternFiller.SQL() + ")" } + +func (g *GqlPatternFiller) SQL() string { + sql := sqlOpt("", g.Hint, "") + + sqlOpt("", g.GraphPatternVariable, "") + + sqlOpt("", g.IsLabelCondition, "") + + if sql == "" { + return sqlOpt("", g.Filter, "") + } + + return sql + sqlOpt(" ", g.Filter, "") +} + +func (g *GqlIsLabelCondition) SQL() string { return ":" + g.LabelExpression.SQL() } + +func (g *GqlLabelParenExpression) SQL() string { return "(" + g.LabelExpr.SQL() + ")" } + +func (g *GqlLabelOrExpression) SQL() string { return g.Left.SQL() + "|" + g.Right.SQL() } + +func (g *GqlLabelAndExpression) SQL() string { return g.Left.SQL() + "&" + g.Right.SQL() } + +func (g *GqlLabelNotExpression) SQL() string { return "!" + g.LabelExpression.SQL() } + +func (g *GqlLabelName) SQL() string { + if g.IsPercent { + return "%" + } + return g.LabelName.SQL() +} + +func (g *GqlPropertyFilters) SQL() string { + return "{" + sqlJoin(g.PropertyFilterElemList, ", ") + "}" +} + +func (g *GqlElementProperty) SQL() string { + return g.ElementPropertyName.SQL() + ": " + g.ElementPropertyValue.SQL() +} + +func (p *GqlPathSearchPrefix) SQL() string { + switch p.SearchPrefix { + case GqlPathSearchPrefixAny: + return "ANY" + case GqlPathSearchPrefixAnyShortest: + return "ANY SHORTEST" + case GqlPathSearchPrefixAll: + return "ALL" + default: + panic("invalid GqlPathSearchPrefix") + } +} diff --git a/ast/util.go b/ast/util.go index 27c62ab8..e56b0847 100644 --- a/ast/util.go +++ b/ast/util.go @@ -28,13 +28,21 @@ func lastElem[T any](s []T) T { func firstValidPos(ns ...Node) token.Pos { for _, n := range ns { - if n != nil { + if n != nil && n.Pos() != token.InvalidPos { return n.Pos() } } return token.InvalidPos } +func firstValidEnd(ns ...Node) token.Pos { + for _, n := range ns { + if n != nil && n.End() != token.InvalidPos { + return n.End() + } + } + return token.InvalidPos +} func firstPos[T Node](s []T) token.Pos { return s[0].Pos() } diff --git a/parser_gql.go b/parser_gql.go index bd5497d4..266e576b 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -16,7 +16,7 @@ func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { graphClause := p.parseGqlGraphClause() multiQueryStatement := p.parseGqlMultiLinearQueryStatement() - return &ast.GqlGraphQuery{GraphClause: graphClause, GqlMultiLinearQueryStatement: multiQueryStatement} + return &ast.GqlGraphQuery{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} } func (p *Parser) parseGqlSubQueryInCondition() *ast.GqlSubQueryInCondition { @@ -33,15 +33,15 @@ func (p *Parser) parseGqlQueryExpr() *ast.GqlQueryExpr { } multiQueryStatement := p.parseGqlMultiLinearQueryStatement() - return &ast.GqlQueryExpr{GraphClause: graphClause, GqlMultiLinearQueryStatement: multiQueryStatement} + return &ast.GqlQueryExpr{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} } func (p *Parser) parseGqlGraphClause() *ast.GqlGraphClause { graphPos := p.expectKeywordLike("GRAPH").Pos graphName := p.parseIdent() return &ast.GqlGraphClause{ - GqlGraph: graphPos, - GqlPropertyGraphName: graphName, + Graph: graphPos, + PropertyGraphName: graphName, } } @@ -291,18 +291,18 @@ func (p *Parser) tryParseGqlPathMode() *ast.GqlPathMode { pathModeToken := p.parseIdent() pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() return &ast.GqlPathMode{ - ModeToken: pathModeToken, - PathOrPathToken: pathOrPathsToken, - Mode: ast.GqlPathModeWalk, + ModeToken: pathModeToken, + PathOrPathsToken: pathOrPathsToken, + Mode: ast.GqlPathModeWalk, } case p.Token.IsKeywordLike("TRAIL"): pathModeToken := p.parseIdent() pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() return &ast.GqlPathMode{ - ModeToken: pathModeToken, - PathOrPathToken: pathOrPathsToken, - Mode: ast.GqlPathModeTrail, + ModeToken: pathModeToken, + PathOrPathsToken: pathOrPathsToken, + Mode: ast.GqlPathModeTrail, } default: return nil @@ -312,22 +312,25 @@ func (p *Parser) tryParseGqlPathSearchPrefixOrPathMode() ast.GqlPathSearchPrefix startPos := p.Token.Pos switch { case p.Token.Kind == "ALL": - p.nextToken() + end := p.expect("ALL").End return &ast.GqlPathSearchPrefix{ StartPos: startPos, + LastEnd: end, SearchPrefix: ast.GqlPathSearchPrefixAll, } case p.Token.Kind == "ANY": - p.nextToken() + anyEnd := p.expect("ANY").End if p.Token.IsKeywordLike("SHORTEST") { - p.nextToken() + shortestEnd := p.expectKeywordLike("SHORTEST").End return &ast.GqlPathSearchPrefix{ StartPos: startPos, + LastEnd: shortestEnd, SearchPrefix: ast.GqlPathSearchPrefixAnyShortest, } } else { return &ast.GqlPathSearchPrefix{ StartPos: startPos, + LastEnd: anyEnd, SearchPrefix: ast.GqlPathSearchPrefixAny, } } @@ -363,13 +366,20 @@ func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { } func (p *Parser) parseGqlLabelName() *ast.GqlLabelName { + pos := p.Token.Pos + if p.Token.Kind == "%" { p.nextToken() - return &ast.GqlLabelName{IsPercent: true} + return &ast.GqlLabelName{ + StartPos: pos, + IsPercent: true, + } } + + ident := p.parseIdent() return &ast.GqlLabelName{ - IsPercent: false, - LabelName: p.parseIdent(), + StartPos: pos, + LabelName: ident, } } @@ -389,7 +399,7 @@ func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { case p.Token.Kind == "!": notPos := p.expect("!").Pos expr := p.parseGqlLabelExpression() - labelTerm = &ast.GqlLabelNotExpression{NotPos: notPos, LabelExpression: expr} + labelTerm = &ast.GqlLabelNotExpression{Not: notPos, LabelExpression: expr} case p.Token.Kind == "(": lparen := p.expect("(").Pos expr := p.parseGqlLabelExpression() @@ -803,5 +813,5 @@ func (p *Parser) parseGqlMultiLinearQueryStatement() *ast.GqlMultiLinearQuerySta items = append(items, p.parseGqlLinearQueryStatement()) } - return &ast.GqlMultiLinearQueryStatement{GqlLinearQueryStatements: items} + return &ast.GqlMultiLinearQueryStatement{LinearQueryStatementList: items} } From b04f85e9be6ed00f3857814844a3370675fb9edd Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 16:25:57 +0900 Subject: [PATCH 22/53] Update testdata --- testdata/result/gql/filter.sql.txt | 13 ++++++---- testdata/result/gql/filter_where.sql.txt | 13 ++++++---- testdata/result/gql/for_with_offset.sql.txt | 13 ++++++---- .../result/gql/for_with_offset_as.sql.txt | 11 +++++---- .../result/gql/graph_hints_between.sql.txt | 15 ++++++++---- testdata/result/gql/graph_hints_match.sql.txt | 16 +++++++++---- .../gql/graph_hints_traversal_hint.sql.txt | 16 +++++++++---- testdata/result/gql/let.sql.txt | 13 ++++++---- testdata/result/gql/limit.sql.txt | 13 ++++++---- testdata/result/gql/match.sql.txt | 11 +++++---- .../result/gql/match_any_shortest.sql.txt | 14 +++++++---- .../match_any_shortest_subpath_trail.sql.txt | 13 +++++----- testdata/result/gql/match_optional.sql.txt | 14 +++++++---- .../result/gql/match_or_expression.sql.txt | 12 ++++++---- .../result/gql/match_subpath_trail.sql.txt | 17 ++++++++----- .../gql/match_trail_subpath_walk.sql.txt | 17 +++++++------ ...tch_where_is_destination_of_return.sql.txt | 13 ++++++---- .../match_where_is_source_of_return.sql.txt | 13 ++++++---- .../gql/match_where_not_same_return.sql.txt | 13 ++++++---- ...match_where_property_exists_return.sql.txt | 12 ++++++---- testdata/result/gql/next.sql.txt | 22 ++++++++++------- testdata/result/gql/next_1.sql.txt | 18 +++++++++----- testdata/result/gql/offset_1.sql.txt | 11 +++++---- testdata/result/gql/order_by.sql.txt | 13 ++++++---- testdata/result/gql/return.sql.txt | 18 +++++++++----- .../result/gql/return_array_subquery.sql.txt | 24 ++++++++++++------- testdata/result/gql/return_distinct.sql.txt | 13 ++++++---- .../gql/return_exists_graph_pattern.sql.txt | 13 ++++++---- .../result/gql/return_exists_match.sql.txt | 19 ++++++++------- .../gql/return_exists_query_expr.sql.txt | 21 +++++++++------- .../result/gql/return_in_gql_subquery.sql.txt | 21 +++++++++------- .../result/gql/return_value_subquery.sql.txt | 19 ++++++++------- testdata/result/gql/skip_1.sql.txt | 11 +++++---- testdata/result/gql/with_1.sql.txt | 13 ++++++---- .../result/gql_path_pattern/pattern_1.sql.txt | 1 + .../result/gql_path_pattern/pattern_2.sql.txt | 7 ++++-- .../query/select_from_graph_table.sql.txt | 4 ++-- .../query/select_in_gql_subquery.sql.txt | 13 ++++++---- .../statement/select_from_graph_table.sql.txt | 4 ++-- .../statement/select_in_gql_subquery.sql.txt | 13 ++++++---- 40 files changed, 336 insertions(+), 214 deletions(-) diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index 649bda2a..175bfe62 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -6,15 +6,15 @@ RETURN p.name --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN p.name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -71,6 +72,7 @@ RETURN p.name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 34, LabelExpression: &ast.GqlLabelName{ + StartPos: 35, IsPercent: false, LabelName: &ast.Ident{ NamePos: 35, @@ -99,6 +101,7 @@ RETURN p.name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 44, LabelExpression: &ast.GqlLabelName{ + StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ NamePos: 45, @@ -146,8 +149,8 @@ RETURN p.name }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 87, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index 3b20533d..1d9a3ebd 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -6,15 +6,15 @@ RETURN p.name --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN p.name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -71,6 +72,7 @@ RETURN p.name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 34, LabelExpression: &ast.GqlLabelName{ + StartPos: 35, IsPercent: false, LabelName: &ast.Ident{ NamePos: 35, @@ -99,6 +101,7 @@ RETURN p.name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 44, LabelExpression: &ast.GqlLabelName{ + StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ NamePos: 45, @@ -146,8 +149,8 @@ RETURN p.name }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 93, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index f87fb408..59530fef 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -8,15 +8,15 @@ ORDER BY p.name, element, offset --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -45,6 +45,7 @@ ORDER BY p.name, element, offset IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -73,6 +74,7 @@ ORDER BY p.name, element, offset IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 34, LabelExpression: &ast.GqlLabelName{ + StartPos: 35, IsPercent: false, LabelName: &ast.Ident{ NamePos: 35, @@ -101,6 +103,7 @@ ORDER BY p.name, element, offset IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 44, LabelExpression: &ast.GqlLabelName{ + StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ NamePos: 45, @@ -153,8 +156,8 @@ ORDER BY p.name, element, offset }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 96, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index 8d39c825..793d332f 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -6,15 +6,15 @@ RETURN p.name, element, off --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN p.name, element, off IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -88,8 +89,8 @@ RETURN p.name, element, off }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 69, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index d321ea2f..34bb5810 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -8,15 +8,15 @@ RETURN oa.id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -45,6 +45,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 25, LabelExpression: &ast.GqlLabelName{ + StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ NamePos: 26, @@ -91,6 +92,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 44, LabelExpression: &ast.GqlLabelName{ + StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ NamePos: 45, @@ -144,6 +146,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 86, LabelExpression: &ast.GqlLabelName{ + StartPos: 87, IsPercent: false, LabelName: &ast.Ident{ NamePos: 87, @@ -172,6 +175,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 98, LabelExpression: &ast.GqlLabelName{ + StartPos: 99, IsPercent: false, LabelName: &ast.Ident{ NamePos: 99, @@ -200,6 +204,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 114, LabelExpression: &ast.GqlLabelName{ + StartPos: 115, IsPercent: false, LabelName: &ast.Ident{ NamePos: 115, @@ -227,8 +232,8 @@ RETURN oa.id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 125, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index c684487e..eb3748d8 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -6,15 +6,15 @@ RETURN oa.id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -85,6 +86,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 41, LabelExpression: &ast.GqlLabelName{ + StartPos: 42, IsPercent: false, LabelName: &ast.Ident{ NamePos: 42, @@ -113,6 +115,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 51, LabelExpression: &ast.GqlLabelName{ + StartPos: 52, IsPercent: false, LabelName: &ast.Ident{ NamePos: 52, @@ -176,6 +179,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 94, LabelExpression: &ast.GqlLabelName{ + StartPos: 95, IsPercent: false, LabelName: &ast.Ident{ NamePos: 95, @@ -204,6 +208,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 106, LabelExpression: &ast.GqlLabelName{ + StartPos: 107, IsPercent: false, LabelName: &ast.Ident{ NamePos: 107, @@ -232,6 +237,7 @@ RETURN oa.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 122, LabelExpression: &ast.GqlLabelName{ + StartPos: 123, IsPercent: false, LabelName: &ast.Ident{ NamePos: 123, @@ -253,8 +259,8 @@ RETURN oa.id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 132, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index 4cac92c0..8dcdced3 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -8,15 +8,15 @@ RETURN c.id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -45,6 +45,7 @@ RETURN c.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 25, LabelExpression: &ast.GqlLabelName{ + StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ NamePos: 26, @@ -87,6 +88,7 @@ RETURN c.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 43, LabelExpression: &ast.GqlLabelName{ + StartPos: 44, IsPercent: false, LabelName: &ast.Ident{ NamePos: 44, @@ -115,6 +117,7 @@ RETURN c.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 53, LabelExpression: &ast.GqlLabelName{ + StartPos: 54, IsPercent: false, LabelName: &ast.Ident{ NamePos: 54, @@ -179,6 +182,7 @@ RETURN c.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 183, LabelExpression: &ast.GqlLabelName{ + StartPos: 184, IsPercent: false, LabelName: &ast.Ident{ NamePos: 184, @@ -207,6 +211,7 @@ RETURN c.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 195, LabelExpression: &ast.GqlLabelName{ + StartPos: 196, IsPercent: false, LabelName: &ast.Ident{ NamePos: 196, @@ -235,6 +240,7 @@ RETURN c.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 210, LabelExpression: &ast.GqlLabelName{ + StartPos: 211, IsPercent: false, LabelName: &ast.Ident{ NamePos: 211, @@ -256,8 +262,8 @@ RETURN c.id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 258, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 27e5d183..566cbe87 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -6,15 +6,15 @@ RETURN a.id AS a_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN a.id AS a_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 28, LabelExpression: &ast.GqlLabelName{ + StartPos: 29, IsPercent: false, LabelName: &ast.Ident{ NamePos: 29, @@ -71,6 +72,7 @@ RETURN a.id AS a_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 40, LabelExpression: &ast.GqlLabelName{ + StartPos: 41, IsPercent: false, LabelName: &ast.Ident{ NamePos: 41, @@ -99,6 +101,7 @@ RETURN a.id AS a_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 65, LabelExpression: &ast.GqlLabelName{ + StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ NamePos: 66, @@ -137,8 +140,8 @@ RETURN a.id AS a_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 90, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index 53d87f57..f2fe4929 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -7,15 +7,15 @@ RETURN source.nick_name --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -44,6 +44,7 @@ RETURN source.nick_name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 28, LabelExpression: &ast.GqlLabelName{ + StartPos: 29, IsPercent: false, LabelName: &ast.Ident{ NamePos: 29, @@ -72,6 +73,7 @@ RETURN source.nick_name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 40, LabelExpression: &ast.GqlLabelName{ + StartPos: 41, IsPercent: false, LabelName: &ast.Ident{ NamePos: 41, @@ -100,6 +102,7 @@ RETURN source.nick_name IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 65, LabelExpression: &ast.GqlLabelName{ + StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ NamePos: 66, @@ -153,8 +156,8 @@ RETURN source.nick_name }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 109, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt index 49b909b5..1f9e9fe7 100644 --- a/testdata/result/gql/match.sql.txt +++ b/testdata/result/gql/match.sql.txt @@ -5,15 +5,15 @@ RETURN p.name, p.id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -42,6 +42,7 @@ RETURN p.name, p.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -63,8 +64,8 @@ RETURN p.name, p.id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 32, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index f4ac32de..2da803ac 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -7,15 +7,15 @@ RETURN a.id AS a_id, total, b.id AS b_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -24,6 +24,7 @@ RETURN a.id AS a_id, total, b.id AS b_id MatchHint: (*ast.Hint)(nil), PrefixOrMode: &ast.GqlPathSearchPrefix{ StartPos: 21, + LastEnd: 33, SearchPrefix: 2, }, GraphPattern: &ast.GqlGraphPattern{ @@ -47,6 +48,7 @@ RETURN a.id AS a_id, total, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 36, LabelExpression: &ast.GqlLabelName{ + StartPos: 37, IsPercent: false, LabelName: &ast.Ident{ NamePos: 37, @@ -75,6 +77,7 @@ RETURN a.id AS a_id, total, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 48, LabelExpression: &ast.GqlLabelName{ + StartPos: 49, IsPercent: false, LabelName: &ast.Ident{ NamePos: 49, @@ -118,6 +121,7 @@ RETURN a.id AS a_id, total, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 70, LabelExpression: &ast.GqlLabelName{ + StartPos: 71, IsPercent: false, LabelName: &ast.Ident{ NamePos: 71, @@ -194,8 +198,8 @@ RETURN a.id AS a_id, total, b.id AS b_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 125, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt index c3ee6d6d..847f72cc 100644 --- a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -5,15 +5,15 @@ RETURN COUNT(1) as num_paths --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -22,6 +22,7 @@ RETURN COUNT(1) as num_paths MatchHint: (*ast.Hint)(nil), PrefixOrMode: &ast.GqlPathSearchPrefix{ StartPos: 21, + LastEnd: 33, SearchPrefix: 2, }, GraphPattern: &ast.GqlGraphPattern{ @@ -42,7 +43,7 @@ RETURN COUNT(1) as num_paths NameEnd: 40, Name: "TRAIL", }, - PathOrPathToken: (*ast.Ident)(nil), + PathOrPathsToken: (*ast.Ident)(nil), }, PathPattern: &ast.GqlPathPattern{ PathTermList: []*ast.GqlQuantifiablePathTerm{ @@ -83,8 +84,8 @@ RETURN COUNT(1) as num_paths }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 50, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index 4a185fe1..c403cdd2 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -6,15 +6,15 @@ RETURN n.name, a.id AS blocked_account_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN n.name, a.id AS blocked_account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -89,6 +90,7 @@ RETURN n.name, a.id AS blocked_account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 49, LabelExpression: &ast.GqlLabelName{ + StartPos: 50, IsPercent: false, LabelName: &ast.Ident{ NamePos: 50, @@ -113,6 +115,7 @@ RETURN n.name, a.id AS blocked_account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 59, LabelExpression: &ast.GqlLabelName{ + StartPos: 60, IsPercent: false, LabelName: &ast.Ident{ NamePos: 60, @@ -141,6 +144,7 @@ RETURN n.name, a.id AS blocked_account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 69, LabelExpression: &ast.GqlLabelName{ + StartPos: 70, IsPercent: false, LabelName: &ast.Ident{ NamePos: 70, @@ -178,8 +182,8 @@ RETURN n.name, a.id AS blocked_account_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 98, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt index d0afc2cd..e603d166 100644 --- a/testdata/result/gql/match_or_expression.sql.txt +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -5,15 +5,15 @@ RETURN n.id, n.name, n.nick_name --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN n.id, n.name, n.nick_name IsOrColon: 23, LabelExpression: &ast.GqlLabelOrExpression{ Left: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -51,6 +52,7 @@ RETURN n.id, n.name, n.nick_name }, }, Right: &ast.GqlLabelName{ + StartPos: 31, IsPercent: false, LabelName: &ast.Ident{ NamePos: 31, @@ -73,8 +75,8 @@ RETURN n.id, n.name, n.nick_name }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 40, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index bb06991d..5411ceb2 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -7,15 +7,15 @@ RETURN COUNT(1) as num_paths --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -41,7 +41,7 @@ RETURN COUNT(1) as num_paths NameEnd: 29, Name: "TRAIL", }, - PathOrPathToken: (*ast.Ident)(nil), + PathOrPathsToken: (*ast.Ident)(nil), }, PathPattern: &ast.GqlPathPattern{ PathTermList: []*ast.GqlQuantifiablePathTerm{ @@ -60,6 +60,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 33, LabelExpression: &ast.GqlLabelName{ + StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ NamePos: 34, @@ -88,6 +89,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 46, LabelExpression: &ast.GqlLabelName{ + StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ NamePos: 47, @@ -125,6 +127,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 65, LabelExpression: &ast.GqlLabelName{ + StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ NamePos: 66, @@ -159,6 +162,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 82, LabelExpression: &ast.GqlLabelName{ + StartPos: 83, IsPercent: false, LabelName: &ast.Ident{ NamePos: 83, @@ -187,6 +191,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 98, LabelExpression: &ast.GqlLabelName{ + StartPos: 99, IsPercent: false, LabelName: &ast.Ident{ NamePos: 99, @@ -208,8 +213,8 @@ RETURN COUNT(1) as num_paths }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 108, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 993b2a2e..1c15ba1c 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -5,15 +5,15 @@ RETURN COUNT(1) as num_paths --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -27,7 +27,7 @@ RETURN COUNT(1) as num_paths NameEnd: 26, Name: "TRAIL", }, - PathOrPathToken: (*ast.Ident)(nil), + PathOrPathsToken: (*ast.Ident)(nil), }, GraphPattern: &ast.GqlGraphPattern{ PathPatternList: []*ast.GqlTopLevelPathPattern{ @@ -47,7 +47,7 @@ RETURN COUNT(1) as num_paths NameEnd: 32, Name: "WALK", }, - PathOrPathToken: (*ast.Ident)(nil), + PathOrPathsToken: (*ast.Ident)(nil), }, PathPattern: &ast.GqlPathPattern{ PathTermList: []*ast.GqlQuantifiablePathTerm{ @@ -66,6 +66,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 36, LabelExpression: &ast.GqlLabelName{ + StartPos: 37, IsPercent: false, LabelName: &ast.Ident{ NamePos: 37, @@ -94,6 +95,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 49, LabelExpression: &ast.GqlLabelName{ + StartPos: 50, IsPercent: false, LabelName: &ast.Ident{ NamePos: 50, @@ -131,6 +133,7 @@ RETURN COUNT(1) as num_paths IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 68, LabelExpression: &ast.GqlLabelName{ + StartPos: 69, IsPercent: false, LabelName: &ast.Ident{ NamePos: 69, @@ -158,8 +161,8 @@ RETURN COUNT(1) as num_paths }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 79, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index cf22a97e..aea445ab 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -6,15 +6,15 @@ RETURN a.id AS a_id, b.id AS b_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN a.id AS a_id, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -71,6 +72,7 @@ RETURN a.id AS a_id, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 42, LabelExpression: &ast.GqlLabelName{ + StartPos: 43, IsPercent: false, LabelName: &ast.Ident{ NamePos: 43, @@ -99,6 +101,7 @@ RETURN a.id AS a_id, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 56, LabelExpression: &ast.GqlLabelName{ + StartPos: 57, IsPercent: false, LabelName: &ast.Ident{ NamePos: 57, @@ -135,8 +138,8 @@ RETURN a.id AS a_id, b.id AS b_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 101, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index d6192b68..88895295 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -6,15 +6,15 @@ RETURN a.id AS a_id, b.id AS b_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN a.id AS a_id, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -71,6 +72,7 @@ RETURN a.id AS a_id, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 42, LabelExpression: &ast.GqlLabelName{ + StartPos: 43, IsPercent: false, LabelName: &ast.Ident{ NamePos: 43, @@ -99,6 +101,7 @@ RETURN a.id AS a_id, b.id AS b_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 56, LabelExpression: &ast.GqlLabelName{ + StartPos: 57, IsPercent: false, LabelName: &ast.Ident{ NamePos: 57, @@ -135,8 +138,8 @@ RETURN a.id AS a_id, b.id AS b_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 96, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index 46c2960c..7d58568f 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -6,15 +6,15 @@ RETURN src.id AS source_id, dest.id AS destination_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN src.id AS source_id, dest.id AS destination_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 25, LabelExpression: &ast.GqlLabelName{ + StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ NamePos: 26, @@ -71,6 +72,7 @@ RETURN src.id AS source_id, dest.id AS destination_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 45, LabelExpression: &ast.GqlLabelName{ + StartPos: 46, IsPercent: false, LabelName: &ast.Ident{ NamePos: 46, @@ -99,6 +101,7 @@ RETURN src.id AS source_id, dest.id AS destination_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 62, LabelExpression: &ast.GqlLabelName{ + StartPos: 63, IsPercent: false, LabelName: &ast.Ident{ NamePos: 63, @@ -151,8 +154,8 @@ RETURN src.id AS source_id, dest.id AS destination_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 98, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_where_property_exists_return.sql.txt b/testdata/result/gql/match_where_property_exists_return.sql.txt index 930f0824..a4d96400 100644 --- a/testdata/result/gql/match_where_property_exists_return.sql.txt +++ b/testdata/result/gql/match_where_property_exists_return.sql.txt @@ -5,15 +5,15 @@ RETURN n.name --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN n.name IsOrColon: 23, LabelExpression: &ast.GqlLabelOrExpression{ Left: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -51,6 +52,7 @@ RETURN n.name }, }, Right: &ast.GqlLabelName{ + StartPos: 31, IsPercent: false, LabelName: &ast.Ident{ NamePos: 31, @@ -100,8 +102,8 @@ RETURN n.name }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 71, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index ab1ab263..92332a6e 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -20,15 +20,15 @@ RETURN "Bob" AS owner_name, 100 AS account_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -53,6 +53,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 22, LabelExpression: &ast.GqlLabelName{ + StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ NamePos: 23, @@ -77,6 +78,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 33, LabelExpression: &ast.GqlLabelName{ + StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ NamePos: 34, @@ -105,6 +107,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 54, LabelExpression: &ast.GqlLabelName{ + StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ NamePos: 55, @@ -126,8 +129,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 64, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -194,6 +197,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 153, LabelExpression: &ast.GqlLabelName{ + StartPos: 154, IsPercent: false, LabelName: &ast.Ident{ NamePos: 154, @@ -218,6 +222,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 165, LabelExpression: &ast.GqlLabelName{ + StartPos: 166, IsPercent: false, LabelName: &ast.Ident{ NamePos: 166, @@ -246,6 +251,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 178, LabelExpression: &ast.GqlLabelName{ + StartPos: 179, IsPercent: false, LabelName: &ast.Ident{ NamePos: 179, @@ -267,8 +273,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 187, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ @@ -354,8 +360,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 314, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -386,8 +392,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id Statement: &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 354, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.StringLiteral{ diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 39864132..e2c32602 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -13,15 +13,15 @@ RETURN --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -46,6 +46,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 22, LabelExpression: &ast.GqlLabelName{ + StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ NamePos: 23, @@ -70,6 +71,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 33, LabelExpression: &ast.GqlLabelName{ + StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ NamePos: 34, @@ -98,6 +100,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 54, LabelExpression: &ast.GqlLabelName{ + StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ NamePos: 55, @@ -119,8 +122,8 @@ RETURN }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 64, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -187,6 +190,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 153, LabelExpression: &ast.GqlLabelName{ + StartPos: 154, IsPercent: false, LabelName: &ast.Ident{ NamePos: 154, @@ -211,6 +215,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 165, LabelExpression: &ast.GqlLabelName{ + StartPos: 166, IsPercent: false, LabelName: &ast.Ident{ NamePos: 166, @@ -239,6 +244,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 178, LabelExpression: &ast.GqlLabelName{ + StartPos: 179, IsPercent: false, LabelName: &ast.Ident{ NamePos: 179, @@ -260,8 +266,8 @@ RETURN }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 187, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt index 231053db..93f98498 100644 --- a/testdata/result/gql/offset_1.sql.txt +++ b/testdata/result/gql/offset_1.sql.txt @@ -6,15 +6,15 @@ RETURN p.name, p.id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN p.name, p.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -74,8 +75,8 @@ RETURN p.name, p.id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 41, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index 9f7f5eec..0717b9e9 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -7,15 +7,15 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -44,6 +44,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 33, LabelExpression: &ast.GqlLabelName{ + StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ NamePos: 34, @@ -72,6 +73,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 52, LabelExpression: &ast.GqlLabelName{ + StartPos: 53, IsPercent: false, LabelName: &ast.Ident{ NamePos: 53, @@ -100,6 +102,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 77, LabelExpression: &ast.GqlLabelName{ + StartPos: 78, IsPercent: false, LabelName: &ast.Ident{ NamePos: 78, @@ -153,8 +156,8 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 125, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index 3f6ee5ba..36525ebb 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -12,15 +12,15 @@ ORDER BY num_incoming_transfers DESC --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -45,6 +45,7 @@ ORDER BY num_incoming_transfers DESC IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 22, LabelExpression: &ast.GqlLabelName{ + StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ NamePos: 23, @@ -69,6 +70,7 @@ ORDER BY num_incoming_transfers DESC IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 33, LabelExpression: &ast.GqlLabelName{ + StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ NamePos: 34, @@ -97,6 +99,7 @@ ORDER BY num_incoming_transfers DESC IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 54, LabelExpression: &ast.GqlLabelName{ + StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ NamePos: 55, @@ -118,8 +121,8 @@ ORDER BY num_incoming_transfers DESC }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 64, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -186,6 +189,7 @@ ORDER BY num_incoming_transfers DESC IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 153, LabelExpression: &ast.GqlLabelName{ + StartPos: 154, IsPercent: false, LabelName: &ast.Ident{ NamePos: 154, @@ -210,6 +214,7 @@ ORDER BY num_incoming_transfers DESC IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 165, LabelExpression: &ast.GqlLabelName{ + StartPos: 166, IsPercent: false, LabelName: &ast.Ident{ NamePos: 166, @@ -238,6 +243,7 @@ ORDER BY num_incoming_transfers DESC IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 178, LabelExpression: &ast.GqlLabelName{ + StartPos: 179, IsPercent: false, LabelName: &ast.Ident{ NamePos: 179, @@ -259,8 +265,8 @@ ORDER BY num_incoming_transfers DESC }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 187, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index eded80a0..ee43e678 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -11,15 +11,15 @@ RETURN --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -48,6 +48,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -72,6 +73,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 33, LabelExpression: &ast.GqlLabelName{ + StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ NamePos: 34, @@ -100,6 +102,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 49, LabelExpression: &ast.GqlLabelName{ + StartPos: 50, IsPercent: false, LabelName: &ast.Ident{ NamePos: 50, @@ -121,8 +124,8 @@ RETURN }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 59, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ @@ -169,9 +172,9 @@ RETURN Array: 102, RBrace: 225, Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + GraphClause: (*ast.GqlGraphClause)(nil), + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -200,6 +203,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 121, LabelExpression: &ast.GqlLabelName{ + StartPos: 122, IsPercent: false, LabelName: &ast.Ident{ NamePos: 122, @@ -228,6 +232,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 140, LabelExpression: &ast.GqlLabelName{ + StartPos: 141, IsPercent: false, LabelName: &ast.Ident{ NamePos: 141, @@ -252,6 +257,7 @@ RETURN IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 154, LabelExpression: &ast.GqlLabelName{ + StartPos: 155, IsPercent: false, LabelName: &ast.Ident{ NamePos: 155, @@ -288,8 +294,8 @@ RETURN }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 188, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index 90106db3..3b364bd3 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -5,15 +5,15 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -42,6 +42,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 25, LabelExpression: &ast.GqlLabelName{ + StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ NamePos: 26, @@ -88,6 +89,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 45, LabelExpression: &ast.GqlLabelName{ + StartPos: 46, IsPercent: false, LabelName: &ast.Ident{ NamePos: 46, @@ -131,6 +133,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 68, LabelExpression: &ast.GqlLabelName{ + StartPos: 69, IsPercent: false, LabelName: &ast.Ident{ NamePos: 69, @@ -152,8 +155,8 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 2, Return: 78, + AllOrDistinct: 2, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index a2e79982..9439fc7f 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -6,20 +6,20 @@ RETURN EXISTS { --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 15, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.ExistsGqlSubQuery{ @@ -46,6 +46,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 35, LabelExpression: &ast.GqlLabelName{ + StartPos: 36, IsPercent: false, LabelName: &ast.Ident{ NamePos: 36, @@ -74,6 +75,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 46, LabelExpression: &ast.GqlLabelName{ + StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ NamePos: 47, @@ -102,6 +104,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 56, LabelExpression: &ast.GqlLabelName{ + StartPos: 57, IsPercent: false, LabelName: &ast.Ident{ NamePos: 57, diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index ac446899..6f592143 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -7,29 +7,29 @@ RETURN EXISTS { --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 15, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.ExistsGqlSubQuery{ Exists: 22, RBrace: 97, Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + GraphClause: (*ast.GqlGraphClause)(nil), + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -58,6 +58,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 41, LabelExpression: &ast.GqlLabelName{ + StartPos: 42, IsPercent: false, LabelName: &ast.Ident{ NamePos: 42, @@ -86,6 +87,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 52, LabelExpression: &ast.GqlLabelName{ + StartPos: 53, IsPercent: false, LabelName: &ast.Ident{ NamePos: 53, @@ -114,6 +116,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 62, LabelExpression: &ast.GqlLabelName{ + StartPos: 63, IsPercent: false, LabelName: &ast.Ident{ NamePos: 63, diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index 78542519..7c15ee66 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -9,29 +9,29 @@ RETURN EXISTS { --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 15, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.ExistsGqlSubQuery{ Exists: 22, RBrace: 123, Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + GraphClause: (*ast.GqlGraphClause)(nil), + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -60,6 +60,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 41, LabelExpression: &ast.GqlLabelName{ + StartPos: 42, IsPercent: false, LabelName: &ast.Ident{ NamePos: 42, @@ -88,6 +89,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 52, LabelExpression: &ast.GqlLabelName{ + StartPos: 53, IsPercent: false, LabelName: &ast.Ident{ NamePos: 53, @@ -116,6 +118,7 @@ RETURN EXISTS { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 62, LabelExpression: &ast.GqlLabelName{ + StartPos: 63, IsPercent: false, LabelName: &ast.Ident{ NamePos: 63, @@ -161,8 +164,8 @@ RETURN EXISTS { }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 99, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index 48c3ebb5..8aa1eab7 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -7,20 +7,20 @@ RETURN 'Dana' IN { --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 15, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.InExpr{ @@ -34,9 +34,9 @@ RETURN 'Dana' IN { LBrace: 32, RBrace: 91, Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + GraphClause: (*ast.GqlGraphClause)(nil), + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -65,6 +65,7 @@ RETURN 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 44, LabelExpression: &ast.GqlLabelName{ + StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ NamePos: 45, @@ -93,6 +94,7 @@ RETURN 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 55, LabelExpression: &ast.GqlLabelName{ + StartPos: 56, IsPercent: false, LabelName: &ast.Ident{ NamePos: 56, @@ -121,6 +123,7 @@ RETURN 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 65, LabelExpression: &ast.GqlLabelName{ + StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ NamePos: 66, @@ -142,8 +145,8 @@ RETURN 'Dana' IN { }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 77, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_value_subquery.sql.txt b/testdata/result/gql/return_value_subquery.sql.txt index 67150631..aced54e0 100644 --- a/testdata/result/gql/return_value_subquery.sql.txt +++ b/testdata/result/gql/return_value_subquery.sql.txt @@ -9,29 +9,29 @@ RETURN VALUE { --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 15, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.ValueGqlSubQuery{ Array: 22, RBrace: 101, Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + GraphClause: (*ast.GqlGraphClause)(nil), + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -60,6 +60,7 @@ RETURN VALUE { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 40, LabelExpression: &ast.GqlLabelName{ + StartPos: 41, IsPercent: false, LabelName: &ast.Ident{ NamePos: 41, @@ -105,8 +106,8 @@ RETURN VALUE { }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 77, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt index c35411ff..09e155ad 100644 --- a/testdata/result/gql/skip_1.sql.txt +++ b/testdata/result/gql/skip_1.sql.txt @@ -6,15 +6,15 @@ RETURN p.name, p.id --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -43,6 +43,7 @@ RETURN p.name, p.id IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GqlLabelName{ + StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ NamePos: 24, @@ -74,8 +75,8 @@ RETURN p.name, p.id }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 39, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index d67fb070..9ae17931 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -6,15 +6,15 @@ RETURN account.id AS account_id, num_incoming_transfers --- AST &ast.GqlGraphQuery{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 0, - GqlPropertyGraphName: &ast.Ident{ + Graph: 0, + PropertyGraphName: &ast.Ident{ NamePos: 6, NameEnd: 14, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -39,6 +39,7 @@ RETURN account.id AS account_id, num_incoming_transfers IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 22, LabelExpression: &ast.GqlLabelName{ + StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ NamePos: 23, @@ -63,6 +64,7 @@ RETURN account.id AS account_id, num_incoming_transfers IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 33, LabelExpression: &ast.GqlLabelName{ + StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ NamePos: 34, @@ -91,6 +93,7 @@ RETURN account.id AS account_id, num_incoming_transfers IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 54, LabelExpression: &ast.GqlLabelName{ + StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ NamePos: 55, @@ -149,8 +152,8 @@ RETURN account.id AS account_id, num_incoming_transfers }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 130, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql_path_pattern/pattern_1.sql.txt b/testdata/result/gql_path_pattern/pattern_1.sql.txt index bde1718d..be2b9c00 100644 --- a/testdata/result/gql_path_pattern/pattern_1.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_1.sql.txt @@ -18,6 +18,7 @@ IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 2, LabelExpression: &ast.GqlLabelName{ + StartPos: 3, IsPercent: true, LabelName: (*ast.Ident)(nil), }, diff --git a/testdata/result/gql_path_pattern/pattern_2.sql.txt b/testdata/result/gql_path_pattern/pattern_2.sql.txt index eb689478..4c80f75d 100644 --- a/testdata/result/gql_path_pattern/pattern_2.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_2.sql.txt @@ -22,6 +22,7 @@ RParen: 30, LabelExpr: &ast.GqlLabelOrExpression{ Left: &ast.GqlLabelName{ + StartPos: 4, IsPercent: false, LabelName: &ast.Ident{ NamePos: 4, @@ -33,9 +34,10 @@ LParen: 11, RParen: 29, LabelExpr: &ast.GqlLabelNotExpression{ - NotPos: 12, + Not: 12, LabelExpression: &ast.GqlLabelAndExpression{ Left: &ast.GqlLabelName{ + StartPos: 13, IsPercent: false, LabelName: &ast.Ident{ NamePos: 13, @@ -44,8 +46,9 @@ }, }, Right: &ast.GqlLabelNotExpression{ - NotPos: 20, + Not: 20, LabelExpression: &ast.GqlLabelName{ + StartPos: 21, IsPercent: false, LabelName: &ast.Ident{ NamePos: 21, diff --git a/testdata/result/query/select_from_graph_table.sql.txt b/testdata/result/query/select_from_graph_table.sql.txt index f51ad952..3f8ec63b 100644 --- a/testdata/result/query/select_from_graph_table.sql.txt +++ b/testdata/result/query/select_from_graph_table.sql.txt @@ -25,12 +25,12 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) Lparen: 25, Rparen: 48, Query: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 35, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.IntLiteral{ diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index 29cba542..9cca0d52 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -26,15 +26,15 @@ SELECT 'Dana' IN { RBrace: 93, Query: &ast.GqlQueryExpr{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 21, - GqlPropertyGraphName: &ast.Ident{ + Graph: 21, + PropertyGraphName: &ast.Ident{ NamePos: 27, NameEnd: 35, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -63,6 +63,7 @@ SELECT 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 46, LabelExpression: &ast.GqlLabelName{ + StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ NamePos: 47, @@ -91,6 +92,7 @@ SELECT 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 57, LabelExpression: &ast.GqlLabelName{ + StartPos: 58, IsPercent: false, LabelName: &ast.Ident{ NamePos: 58, @@ -119,6 +121,7 @@ SELECT 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 67, LabelExpression: &ast.GqlLabelName{ + StartPos: 68, IsPercent: false, LabelName: &ast.Ident{ NamePos: 68, @@ -140,8 +143,8 @@ SELECT 'Dana' IN { }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 79, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/statement/select_from_graph_table.sql.txt b/testdata/result/statement/select_from_graph_table.sql.txt index f51ad952..3f8ec63b 100644 --- a/testdata/result/statement/select_from_graph_table.sql.txt +++ b/testdata/result/statement/select_from_graph_table.sql.txt @@ -25,12 +25,12 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) Lparen: 25, Rparen: 48, Query: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 35, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.Alias{ Expr: &ast.IntLiteral{ diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index 29cba542..9cca0d52 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -26,15 +26,15 @@ SELECT 'Dana' IN { RBrace: 93, Query: &ast.GqlQueryExpr{ GraphClause: &ast.GqlGraphClause{ - GqlGraph: 21, - GqlPropertyGraphName: &ast.Ident{ + Graph: 21, + PropertyGraphName: &ast.Ident{ NamePos: 27, NameEnd: 35, Name: "FinGraph", }, }, - GqlMultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - GqlLinearQueryStatements: []ast.GqlLinearQueryStatement{ + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ &ast.GqlSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ &ast.GqlMatchStatement{ @@ -63,6 +63,7 @@ SELECT 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 46, LabelExpression: &ast.GqlLabelName{ + StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ NamePos: 47, @@ -91,6 +92,7 @@ SELECT 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 57, LabelExpression: &ast.GqlLabelName{ + StartPos: 58, IsPercent: false, LabelName: &ast.Ident{ NamePos: 58, @@ -119,6 +121,7 @@ SELECT 'Dana' IN { IsLabelCondition: &ast.GqlIsLabelCondition{ IsOrColon: 67, LabelExpression: &ast.GqlLabelName{ + StartPos: 68, IsPercent: false, LabelName: &ast.Ident{ NamePos: 68, @@ -140,8 +143,8 @@ SELECT 'Dana' IN { }, }, &ast.GqlReturnStatement{ - AllOrDistinct: 0, Return: 79, + AllOrDistinct: 0, ReturnItemList: []ast.GqlReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ From c9db3206adf988b76e20b0a52cdfc090c304c02e Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 16:32:04 +0900 Subject: [PATCH 23/53] Some clean up of util.go --- ast/util.go | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/ast/util.go b/ast/util.go index e56b0847..6754cd8a 100644 --- a/ast/util.go +++ b/ast/util.go @@ -5,12 +5,10 @@ import ( "strings" ) -// sqlOpt output: +// sqlOpt outputs: // // when node != nil: left + node.SQL() + right -// when node == nil: empty string -// -// requires Go 1.20 +// else : empty string func sqlOpt[T interface { Node comparable @@ -43,13 +41,21 @@ func firstValidEnd(ns ...Node) token.Pos { } return token.InvalidPos } + func firstPos[T Node](s []T) token.Pos { + if len(s) == 0 { + return token.InvalidPos + } return s[0].Pos() } func lastEnd[T Node](s []T) token.Pos { + if len(s) == 0 { + return token.InvalidPos + } return lastElem(s).End() } + func sqlJoin[T Node](elems []T, sep string) string { var b strings.Builder for i, r := range elems { From 4a99dcc0141be27bd60f2a050cac72d54781c140 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 16:57:07 +0900 Subject: [PATCH 24/53] Implement GqlCollationSpecification --- ast/ast.go | 29 ++--- ast/pos.go | 11 ++ ast/sql.go | 12 ++ parser_gql.go | 18 ++- testdata/input/gql/order_by_collate.sql | 1 + testdata/result/gql/limit.sql.txt | 5 +- testdata/result/gql/order_by.sql.txt | 5 +- testdata/result/gql/order_by_collate.sql.txt | 130 +++++++++++++++++++ 8 files changed, 187 insertions(+), 24 deletions(-) create mode 100644 testdata/input/gql/order_by_collate.sql create mode 100644 testdata/result/gql/order_by_collate.sql.txt diff --git a/ast/ast.go b/ast/ast.go index 7d47f2d6..1dabf991 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -2728,32 +2728,23 @@ type GqlOrderByStatement struct { OrderBySpecificationList []*GqlOrderBySpecification } -// TODO type GqlOrderBySpecification struct { // pos = Expr.pos - // TODO + // DirectionPos ?? CollationSpecification.end Expr Expr - // TODO - // CollationSpecification *GqlCollationSpecification - DirectionPos token.Pos - Direction GqlDirection -} - -func (g *GqlOrderBySpecification) Pos() token.Pos { return g.Expr.Pos() } -func (g *GqlOrderBySpecification) End() token.Pos { - //TODO implement me - panic("implement me") + CollationSpecification *GqlCollationSpecification // optional + DirectionPos token.Pos // optional + Direction GqlDirection } -func (g *GqlOrderBySpecification) SQL() string { - sql := g.Expr.SQL() - // TODO Collation - if g.Direction != GqlSortOrderUnspecified { - sql += " " + string(g.Direction) - } - return sql +type GqlCollationSpecification struct { + // pos = Collate + // end = Specification.end + + Collate token.Pos + Specification StringValue } type GqlWithStatement struct { diff --git a/ast/pos.go b/ast/pos.go index 523cf6e3..02adc1be 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -983,6 +983,17 @@ func (g *GqlOffsetStatement) End() token.Pos { return g.Count.End() } func (g *GqlOrderByStatement) Pos() token.Pos { return g.Order } func (g *GqlOrderByStatement) End() token.Pos { return lastEnd(g.OrderBySpecificationList) } +func (g *GqlOrderBySpecification) Pos() token.Pos { return g.Expr.Pos() } +func (g *GqlOrderBySpecification) End() token.Pos { + if g.DirectionPos != token.InvalidPos { + return g.DirectionPos + token.Pos(len(string(g.Direction))) + } + return firstValidEnd(g.CollationSpecification, g.Expr) +} + +func (g *GqlCollationSpecification) Pos() token.Pos { return g.Collate } +func (g *GqlCollationSpecification) End() token.Pos { return g.Specification.End() } + func (g *GqlWithStatement) Pos() token.Pos { return g.With } func (g *GqlWithStatement) End() token.Pos { return firstValidPos(g.GroupByClause, lastElem(g.ReturnItemList)) diff --git a/ast/sql.go b/ast/sql.go index 0144d59a..d709cbc2 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1512,6 +1512,18 @@ func (g *GqlOrderByStatement) SQL() string { return "ORDER BY " + sqlJoin(g.OrderBySpecificationList, ", ") } +func (g *GqlOrderBySpecification) SQL() string { + sql := g.Expr.SQL() + sqlOpt(" ", g.CollationSpecification, "") + if g.Direction != GqlSortOrderUnspecified { + sql += " " + string(g.Direction) + } + return sql +} + +func (g *GqlCollationSpecification) SQL() string { + return "COLLATE " + g.Specification.SQL() +} + func (g *GqlWithStatement) SQL() string { var allOrDistinctStr string switch g.AllOrDistinct { diff --git a/parser_gql.go b/parser_gql.go index 266e576b..c0983464 100644 --- a/parser_gql.go +++ b/parser_gql.go @@ -135,6 +135,17 @@ func (p *Parser) tryParseGqlOrderBySpecificationList() []*ast.GqlOrderBySpecific var list []*ast.GqlOrderBySpecification for { expr := p.parseExpr() + + var collateSpec *ast.GqlCollationSpecification + if p.Token.Kind == "COLLATE" { + collatePos := p.expect("COLLATE").Pos + spec := p.parseStringValue() + collateSpec = &ast.GqlCollationSpecification{ + Collate: collatePos, + Specification: spec, + } + } + var direction ast.GqlDirection directionPos := p.Token.Pos switch { @@ -153,7 +164,12 @@ func (p *Parser) tryParseGqlOrderBySpecificationList() []*ast.GqlOrderBySpecific default: directionPos = token.InvalidPos } - list = append(list, &ast.GqlOrderBySpecification{Expr: expr, DirectionPos: directionPos, Direction: direction}) + list = append(list, &ast.GqlOrderBySpecification{ + Expr: expr, + DirectionPos: directionPos, + CollationSpecification: collateSpec, + Direction: direction, + }) if p.Token.Kind != "," { break } diff --git a/testdata/input/gql/order_by_collate.sql b/testdata/input/gql/order_by_collate.sql new file mode 100644 index 00000000..b288cdd5 --- /dev/null +++ b/testdata/input/gql/order_by_collate.sql @@ -0,0 +1 @@ +GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name \ No newline at end of file diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index f2fe4929..22bcbb39 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -141,8 +141,9 @@ RETURN source.nick_name }, }, }, - DirectionPos: -1, - Direction: "", + CollationSpecification: (*ast.GqlCollationSpecification)(nil), + DirectionPos: -1, + Direction: "", }, }, }, diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index 0717b9e9..19d16f2e 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -141,8 +141,9 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, }, }, - DirectionPos: 112, - Direction: "DESC", + CollationSpecification: (*ast.GqlCollationSpecification)(nil), + DirectionPos: 112, + Direction: "DESC", }, }, }, diff --git a/testdata/result/gql/order_by_collate.sql.txt b/testdata/result/gql/order_by_collate.sql.txt new file mode 100644 index 00000000..599e4020 --- /dev/null +++ b/testdata/result/gql/order_by_collate.sql.txt @@ -0,0 +1,130 @@ +--- order_by_collate.sql +GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name +--- AST +&ast.GqlGraphQuery{ + GraphClause: &ast.GqlGraphClause{ + Graph: 0, + PropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GqlLinearQueryStatement{ + &ast.GqlSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ + &ast.GqlMatchStatement{ + Optional: -1, + Match: 15, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GqlGraphPattern{ + PathPatternList: []*ast.GqlTopLevelPathPattern{ + &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GqlPathPattern{ + PathTermList: []*ast.GqlQuantifiablePathTerm{ + &ast.GqlQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GqlNodePattern{ + LParen: 21, + RParen: 30, + PatternFiller: &ast.GqlPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "a", + }, + IsLabelCondition: &ast.GqlIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GqlLabelName{ + StartPos: 24, + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + Filter: nil, + }, + }, + Quantifier: nil, + }, + }, + }, + }, + }, + WhereClause: (*ast.Where)(nil), + }, + }, + &ast.GqlOrderByStatement{ + Order: 32, + OrderBySpecificationList: []*ast.GqlOrderBySpecification{ + &ast.GqlOrderBySpecification{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 41, + NameEnd: 42, + Name: "a", + }, + &ast.Ident{ + NamePos: 43, + NameEnd: 47, + Name: "name", + }, + }, + }, + CollationSpecification: &ast.GqlCollationSpecification{ + Collate: 48, + Specification: &ast.StringLiteral{ + ValuePos: 56, + ValueEnd: 64, + Value: "und:ci", + }, + }, + DirectionPos: -1, + Direction: "", + }, + }, + }, + &ast.GqlReturnStatement{ + Return: 65, + AllOrDistinct: 0, + ReturnItemList: []ast.GqlReturnItem{ + &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 72, + NameEnd: 73, + Name: "a", + }, + &ast.Ident{ + NamePos: 74, + NameEnd: 78, + Name: "name", + }, + }, + }, + }, + }, + GroupByClause: (*ast.GroupBy)(nil), + OrderByClause: (*ast.OrderBy)(nil), + LimitAndOffsetClause: nil, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (a:Person) +ORDER BY a.name COLLATE "und:ci" +RETURN a.name From 006feb60d14752b41baa7630c38a2662ecd534f3 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 16:58:42 +0900 Subject: [PATCH 25/53] Bump go version to 1.20 --- .github/workflows/go.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index c253430b..e18fdf55 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -11,10 +11,10 @@ jobs: runs-on: ubuntu-latest steps: - - name: Set up Go 1.19 + - name: Set up Go 1.20 uses: actions/setup-go@v4 with: - go-version: 1.19 + go-version: 1.20 id: go - name: Check out code into the Go module directory From 82c7d91f77e0e14dbfadd3c37096b44e83ae1957 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:04:27 +0900 Subject: [PATCH 26/53] Fix unexpected change of tools/parse --- tools/parse/main.go | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/parse/main.go b/tools/parse/main.go index c3f502fb..983a85fe 100644 --- a/tools/parse/main.go +++ b/tools/parse/main.go @@ -43,6 +43,7 @@ func main() { case "ddl": node, err = p.ParseDDL() case "dml": + node, err = p.ParseDML() case "gql": node, err = p.ParseGqlStatement() case "gql_path_pattern": From b3c5df8e529808cbdf555e2439daa4609bfb21f0 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:08:50 +0900 Subject: [PATCH 27/53] Merge into parser.go --- parser.go | 826 +++++++++++++++++++++++++++++++++++++++++++++++++ parser_gql.go | 833 -------------------------------------------------- 2 files changed, 826 insertions(+), 833 deletions(-) delete mode 100644 parser_gql.go diff --git a/parser.go b/parser.go index 667be9fe..4d11c9a9 100644 --- a/parser.go +++ b/parser.go @@ -3827,6 +3827,832 @@ func (p *Parser) parseStringValue() ast.StringValue { panic(p.errorfAtToken(&p.Token, "expected token: , , but: %s", p.Token.Kind)) } +// ================================================================================ +// +// GRAPH +// +// ================================================================================ + +func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { + graphClause := p.parseGqlGraphClause() + multiQueryStatement := p.parseGqlMultiLinearQueryStatement() + + return &ast.GqlGraphQuery{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} +} + +func (p *Parser) parseGqlSubQueryInCondition() *ast.GqlSubQueryInCondition { + lbrace := p.expect("{").Pos + query := p.parseGqlQueryExpr() + rbrace := p.expect("}").Pos + + return &ast.GqlSubQueryInCondition{LBrace: lbrace, RBrace: rbrace, Query: query} +} +func (p *Parser) parseGqlQueryExpr() *ast.GqlQueryExpr { + var graphClause *ast.GqlGraphClause + if p.Token.IsKeywordLike("GRAPH") { + graphClause = p.parseGqlGraphClause() + } + multiQueryStatement := p.parseGqlMultiLinearQueryStatement() + + return &ast.GqlQueryExpr{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} +} + +func (p *Parser) parseGqlGraphClause() *ast.GqlGraphClause { + graphPos := p.expectKeywordLike("GRAPH").Pos + graphName := p.parseIdent() + return &ast.GqlGraphClause{ + Graph: graphPos, + PropertyGraphName: graphName, + } +} + +func (p *Parser) parseGqlLinearQueryStatement() ast.GqlLinearQueryStatement { + stmt := p.parseGqlSimpleLinearQueryStatement() + if p.Token.Kind != ("UNION") && p.Token.Kind != ("EXCEPT") && p.Token.Kind != ("DISTINCT") { + return stmt + } + var tail []*ast.GqlSimpleLinearQueryStatementWithSetOperator + for p.Token.Kind == ("UNION") || p.Token.Kind == ("EXCEPT") || p.Token.Kind == ("DISTINCT") { + tail = append(tail, p.parseGqlSimpleLinearQueryStatementWithSetOperator()) + } + return &ast.GqlCompositeLinearQueryStatement{HeadSimpleLinearQueryStatement: stmt, TailSimpleLinearQueryStatementList: tail} +} + +func (p *Parser) parseGqlSimpleLinearQueryStatementWithSetOperator() *ast.GqlSimpleLinearQueryStatementWithSetOperator { + pos := p.Token.Pos + var op ast.GqlSetOperatorEnum + switch p.Token.Kind { + case "UNION": + p.nextToken() + op = ast.GqlSetOperatorUnion + case "INTERSECT": + p.nextToken() + op = ast.GqlSetOperatorIntersect + case "EXCEPT": + p.nextToken() + op = ast.GqlSetOperatorExcept + default: + panic("unknown SetOperatorEnum") + } + + allOrDistinct := p.tryParseGqlAllOrDistinctEnum() + if allOrDistinct == ast.GqlAllOrDistinctImplicitAll { + p.panicfAtToken(&p.Token, `expect "ALL" or "DISTINCT, but: %v`, p.Token.Kind) + } + + stmt := p.parseGqlSimpleLinearQueryStatement() + return &ast.GqlSimpleLinearQueryStatementWithSetOperator{ + StartPos: pos, + SetOperator: op, + DistinctOrAll: allOrDistinct, + Statement: stmt, + } +} +func (p *Parser) parseGqlSimpleLinearQueryStatement() *ast.GqlSimpleLinearQueryStatement { + var stmts []ast.GqlPrimitiveQueryStatement + for stmt := p.tryParseGqlPrimitiveQueryStatement(); stmt != nil; stmt = p.tryParseGqlPrimitiveQueryStatement() { + stmts = append(stmts, stmt) + } + + return &ast.GqlSimpleLinearQueryStatement{PrimitiveQueryStatementList: stmts} +} + +func (p *Parser) tryParseGqlWithOffsetClause() *ast.GqlWithOffsetClause { + if p.Token.Kind != "WITH" { + return nil + } + with := p.expect("WITH").Pos + offset := p.expectKeywordLike("OFFSET").Pos + var offsetName *ast.Ident + if p.Token.Kind == "AS" { + p.nextToken() + offsetName = p.parseIdent() + } + + return &ast.GqlWithOffsetClause{ + With: with, + Offset: offset, + OffsetName: offsetName, + } +} + +func (p *Parser) parseGqlForStatement() *ast.GqlForStatement { + forPos := p.expect("FOR").Pos + name := p.parseIdent() + p.expect("IN") + expr := p.parseExpr() + + withOffset := p.tryParseGqlWithOffsetClause() + + return &ast.GqlForStatement{ + For: forPos, + ElementName: name, + ArrayExpression: expr, + WithOffsetClause: withOffset, + } +} + +func (p *Parser) tryParseGqlOrderBySpecificationList() []*ast.GqlOrderBySpecification { + var list []*ast.GqlOrderBySpecification + for { + expr := p.parseExpr() + + var collateSpec *ast.GqlCollationSpecification + if p.Token.Kind == "COLLATE" { + collatePos := p.expect("COLLATE").Pos + spec := p.parseStringValue() + collateSpec = &ast.GqlCollationSpecification{ + Collate: collatePos, + Specification: spec, + } + } + + var direction ast.GqlDirection + directionPos := p.Token.Pos + switch { + case p.Token.Kind == "ASC": + p.nextToken() + direction = ast.GqlSortOrderAsc + case p.Token.Kind == "DESC": + p.nextToken() + direction = ast.GqlSortOrderDesc + case p.Token.Kind == "ASCENDING": + p.nextToken() + direction = ast.GqlSortOrderAscending + case p.Token.Kind == "DESCENDING": + p.nextToken() + direction = ast.GqlSortOrderDescending + default: + directionPos = token.InvalidPos + } + list = append(list, &ast.GqlOrderBySpecification{ + Expr: expr, + DirectionPos: directionPos, + CollationSpecification: collateSpec, + Direction: direction, + }) + if p.Token.Kind != "," { + break + } + } + return list +} + +func (p *Parser) parseGqlOrderByStatement() *ast.GqlOrderByStatement { + order := p.expect("ORDER").Pos + p.expect("BY") + spec := p.tryParseGqlOrderBySpecificationList() + if spec == nil { + p.panicfAtToken(&p.Token, "expect at least one order_by_specification") + } + + return &ast.GqlOrderByStatement{ + Order: order, + OrderBySpecificationList: spec, + } +} + +func (p *Parser) parseGqlLimitStatement() *ast.GqlLimitStatement { + limit := p.expect("LIMIT").Pos + expr := p.parseIntValue() + + return &ast.GqlLimitStatement{ + Limit: limit, + Count: expr, + } +} + +func (p *Parser) parseGqlFilterStatement() *ast.GqlFilterStatement { + filter := p.expectKeywordLike("FILTER").Pos + where := token.InvalidPos + if p.Token.Kind == "WHERE" { + where = p.expect("WHERE").Pos + } + expr := p.parseExpr() + + return &ast.GqlFilterStatement{ + Filter: filter, + Where: where, + Expr: expr, + } +} + +func (p *Parser) parseGqlOffsetStatement() *ast.GqlOffsetStatement { + var pos token.Pos + var isSkip bool + switch { + case p.Token.IsKeywordLike("OFFSET"): + pos = p.expectKeywordLike("OFFSET").Pos + case p.Token.IsKeywordLike("SKIP"): + pos = p.expectKeywordLike("SKIP").Pos + isSkip = true + default: + p.panicfAtToken(&p.Token, `expected "OFFSET" or "SKIP", but: %v`, p.Token.Kind) + } + + count := p.parseIntValue() + + return &ast.GqlOffsetStatement{ + Offset: pos, + IsSkip: isSkip, + Count: count, + } +} + +func (p *Parser) parseGqlReturnItem() ast.GqlReturnItem { + if p.Token.Kind == "*" { + pos := p.expect("*").Pos + return &ast.Star{ + Star: pos, + } + } + + expr := p.parseExpr() + if p.Token.Kind == "AS" { + if as := p.tryParseAsAlias(); as != nil { + return &ast.Alias{ + Expr: expr, + As: as, + } + } + } + + return &ast.ExprSelectItem{ + Expr: expr, + } +} + +func (p *Parser) tryParseAsAliasAsMandatory() *ast.AsAlias { + if p.Token.Kind != "AS" { + return nil + } + return p.tryParseAsAlias() +} + +func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryStatement { + switch { + case p.Token.IsKeywordLike("RETURN"): + return p.parseGqlReturnStatement() + case p.Token.IsKeywordLike("LET"): + return p.parseGqlLetStatement() + case p.Token.IsKeywordLike("FILTER"): + return p.parseGqlFilterStatement() + case p.Token.Kind == "ORDER": + return p.parseGqlOrderByStatement() + case p.Token.Kind == "LIMIT": + return p.parseGqlLimitStatement() + case p.Token.IsKeywordLike("SKIP"), p.Token.IsKeywordLike("OFFSET"): + return p.parseGqlOffsetStatement() + case p.Token.Kind == "FOR": + return p.parseGqlForStatement() + case p.Token.IsKeywordLike("OPTIONAL") || p.Token.IsKeywordLike("MATCH"): + return p.parseGqlMatchStatement() + case p.Token.Kind == "WITH": + return p.parseGqlWithStatement() + default: + return nil + } +} + +func (p *Parser) tryParseGqlPathModePathOrPaths() *ast.Ident { + switch { + case p.Token.IsKeywordLike("PATH"), p.Token.IsKeywordLike("PATHS"): + return p.parseIdent() + default: + return nil + } +} +func (p *Parser) tryParseGqlPathMode() *ast.GqlPathMode { + switch { + case p.Token.IsKeywordLike("WALK"): + pathModeToken := p.parseIdent() + pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() + return &ast.GqlPathMode{ + ModeToken: pathModeToken, + PathOrPathsToken: pathOrPathsToken, + Mode: ast.GqlPathModeWalk, + } + + case p.Token.IsKeywordLike("TRAIL"): + pathModeToken := p.parseIdent() + pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() + return &ast.GqlPathMode{ + ModeToken: pathModeToken, + PathOrPathsToken: pathOrPathsToken, + Mode: ast.GqlPathModeTrail, + } + default: + return nil + } +} +func (p *Parser) tryParseGqlPathSearchPrefixOrPathMode() ast.GqlPathSearchPrefixOrPathMode { + startPos := p.Token.Pos + switch { + case p.Token.Kind == "ALL": + end := p.expect("ALL").End + return &ast.GqlPathSearchPrefix{ + StartPos: startPos, + LastEnd: end, + SearchPrefix: ast.GqlPathSearchPrefixAll, + } + case p.Token.Kind == "ANY": + anyEnd := p.expect("ANY").End + if p.Token.IsKeywordLike("SHORTEST") { + shortestEnd := p.expectKeywordLike("SHORTEST").End + return &ast.GqlPathSearchPrefix{ + StartPos: startPos, + LastEnd: shortestEnd, + SearchPrefix: ast.GqlPathSearchPrefixAnyShortest, + } + } else { + return &ast.GqlPathSearchPrefix{ + StartPos: startPos, + LastEnd: anyEnd, + SearchPrefix: ast.GqlPathSearchPrefixAny, + } + } + default: + if pathMode := p.tryParseGqlPathMode(); pathMode != nil { + return pathMode + } + return nil + } + +} + +func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { + var optionalPos token.Pos + if p.Token.IsKeywordLike("OPTIONAL") { + optionalPos = p.Token.Pos + p.nextToken() + } else { + optionalPos = token.InvalidPos + } + + match := p.expectKeywordLike("MATCH").Pos + hint := p.tryParseHint() + var prefixOrMode = p.tryParseGqlPathSearchPrefixOrPathMode() + pattern := p.parseGqlGraphPattern() + return &ast.GqlMatchStatement{ + Optional: optionalPos, + Match: match, + MatchHint: hint, + PrefixOrMode: prefixOrMode, + GraphPattern: pattern, + } +} + +func (p *Parser) parseGqlLabelName() *ast.GqlLabelName { + pos := p.Token.Pos + + if p.Token.Kind == "%" { + p.nextToken() + return &ast.GqlLabelName{ + StartPos: pos, + IsPercent: true, + } + } + + ident := p.parseIdent() + return &ast.GqlLabelName{ + StartPos: pos, + LabelName: ident, + } +} + +func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { + // TODO + /* + label_expression: + { + label_name + | or_expression + | and_expression + | not_expression + } + */ + var labelTerm ast.GqlLabelExpression + switch { + case p.Token.Kind == "!": + notPos := p.expect("!").Pos + expr := p.parseGqlLabelExpression() + labelTerm = &ast.GqlLabelNotExpression{Not: notPos, LabelExpression: expr} + case p.Token.Kind == "(": + lparen := p.expect("(").Pos + expr := p.parseGqlLabelExpression() + rparen := p.expect(")").Pos + labelTerm = &ast.GqlLabelParenExpression{ + LParen: lparen, + RParen: rparen, + LabelExpr: expr, + } + case p.Token.Kind == token.TokenIdent || p.Token.Kind == "%": + labelTerm = p.parseGqlLabelName() + default: + p.panicfAtToken(&p.Token, `expected token: ",", "(", or "", but: %v`, p.Token.Kind) + return nil + } + switch { + case p.Token.Kind == "|": + p.nextToken() + right := p.parseGqlLabelExpression() + return &ast.GqlLabelOrExpression{ + Left: labelTerm, + Right: right, + } + case p.Token.Kind == "&": + p.nextToken() + right := p.parseGqlLabelExpression() + return &ast.GqlLabelAndExpression{ + Left: labelTerm, + Right: right, + } + } + return labelTerm +} +func (p *Parser) parseGqlIsLabelCondition() *ast.GqlIsLabelCondition { + + pos := p.Token.Pos + p.nextToken() + labelExpr := p.parseGqlLabelExpression() + return &ast.GqlIsLabelCondition{ + IsOrColon: pos, + LabelExpression: labelExpr, + } +} +func (p *Parser) parseGqlPatternFiller() *ast.GqlPatternFiller { + hint := p.tryParseHint() + var patternVar *ast.Ident + if p.Token.Kind == token.TokenIdent { + patternVar = p.parseIdent() + } + var isLabelCondition *ast.GqlIsLabelCondition + if p.Token.Kind == ":" || p.Token.Kind == "IS" { + isLabelCondition = p.parseGqlIsLabelCondition() + } + + filter := p.tryParseGqlPatternFillerFilter() + return &ast.GqlPatternFiller{ + Hint: hint, + GraphPatternVariable: patternVar, // TODO + IsLabelCondition: isLabelCondition, // TODO + Filter: filter, // TODO + } +} + +func (p *Parser) lookaheadGqlSubpathPattern() bool { + lexer := p.Lexer.Clone() + defer func() { + p.Lexer = lexer + }() + + if p.Token.Kind != "(" { + return false + } + p.nextToken() + if p.Token.Kind == "(" || p.Token.Kind == "-" || p.Token.Kind == "<" || p.Token.IsKeywordLike("WALK") || p.Token.IsKeywordLike("TRAIL") { + return true + } + return false +} + +func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { + lparen := p.expect("(").Pos + filter := p.parseGqlPatternFiller() + rparen := p.expect(")").Pos + return &ast.GqlNodePattern{ + LParen: lparen, + RParen: rparen, + PatternFiller: filter, + } +} + +func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { + if p.Token.Kind != "{" { + return nil + } + lbrace := p.expect("{").Pos + if p.Token.Kind == "," { + upperBound := p.parseIntValue() + rbrace := p.expect("}").Pos + return &ast.GqlBoundedQuantifier{ + LBrace: lbrace, + RBrace: rbrace, + UpperBound: upperBound, + } + } + bound := p.parseIntValue() + if p.Token.Kind != "," { + rbrace := p.expect("}").Pos + return &ast.GqlFixedQuantifier{ + LBrace: lbrace, + RBrace: rbrace, + Bound: bound, + } + } + p.expect(",") + upperBound := p.parseIntValue() + rbrace := p.expect("}").Pos + + return &ast.GqlBoundedQuantifier{ + LBrace: lbrace, + RBrace: rbrace, + LowerBound: bound, + UpperBound: upperBound, + } +} + +func (p *Parser) tryParseGqlQuantifiablePathTerm() *ast.GqlQuantifiablePathTerm { + hint := p.tryParseHint() + pt := p.tryParseGqlPathTerm() + if pt == nil { + return nil + } + q := p.tryParseGqlQuantifier() + return &ast.GqlQuantifiablePathTerm{ + Hint: hint, + PathTerm: pt, + Quantifier: q, + } +} + +func (p *Parser) tryParseGqlPathTerm() ast.GqlPathTerm { + // TODO + /* + path_term: + { + element_pattern + | subpath_pattern + } + */ + + if p.lookaheadGqlSubpathPattern() { + return p.parseGqlSubPathPattern() + } + if p.Token.Kind == "(" { + return p.parseGqlNodePattern() + } + if p.Token.Kind == "-" || p.Token.Kind == "<" { + return p.parseGqlEdgePattern() + } + return nil +} + +func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { + lparen := p.expect("(").Pos + pathMode := p.tryParseGqlPathMode() + pattern := p.parseGqlPathPattern() + where := p.tryParseWhere() + rparen := p.expect(")").Pos + + return &ast.GqlSubpathPattern{ + LParen: lparen, + RParen: rparen, + PathMode: pathMode, + PathPattern: pattern, + WhereClause: where, + } +} + +func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { + // NOTE: Currently, this implementation allows whitespace in any place of "<-[" and "]->". + // It is more relaxed syntax than spec. + // It will be fixed when we are sure that the modification of lexer is safe. + firstPos := p.Token.Pos + switch p.Token.Kind { + case "<": + p.nextToken() + firstHyphenPos := p.expect("-").Pos + if p.Token.Kind != "[" { + return &ast.GqlAbbreviatedEdgeLeft{ + First: firstPos, + Last: firstHyphenPos, + } + } + p.nextToken() + patternFilter := p.parseGqlPatternFiller() + p.expect("]") + lastPos := p.expect("-").Pos + return &ast.GqlFullEdgeLeft{ + First: firstPos, + Last: lastPos, + PatternFiller: patternFilter, + } + case "-": + p.nextToken() + switch p.Token.Kind { + case ">": + lastPos := p.expect(">").Pos + return &ast.GqlAbbreviatedEdgeRight{ + First: firstPos, + Last: lastPos, + } + case "[": + p.nextToken() + patternFiller := p.parseGqlPatternFiller() + p.expect("]") + lastHyphenPos := p.expect("-").Pos + if p.Token.Kind == ">" { + lastPos := p.Token.Pos + p.nextToken() + return &ast.GqlFullEdgeRight{ + First: firstPos, + Last: lastPos, + PatternFiller: patternFiller, + } + } + return &ast.GqlFullEdgeAny{ + First: firstPos, + Last: lastHyphenPos, + PatternFiller: patternFiller, + } + default: + return &ast.GqlAbbreviatedEdgeAny{Hyphen: firstPos} + } + default: + panic(fmt.Sprintf("not implemented kind: %v %v", p.Token.Kind, p.Token.Raw)) + } +} + +func (p *Parser) parseGqlPathPattern() *ast.GqlPathPattern { + list := []*ast.GqlQuantifiablePathTerm{p.tryParseGqlQuantifiablePathTerm()} + for p.Token.Kind != ")" && !p.Token.IsKeywordLike("WHERE") { + term := p.tryParseGqlQuantifiablePathTerm() + if term == nil { + break + } + list = append(list, term) + } + return &ast.GqlPathPattern{ + PathTermList: list, + } +} +func (p *Parser) parseGqlTopLevelPathPattern() *ast.GqlTopLevelPathPattern { + pattern := p.parseGqlPathPattern() + return &ast.GqlTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, // TODO + PathPattern: pattern, + } +} + +func (p *Parser) parseGqlElementProperty() *ast.GqlElementProperty { + ident := p.parseIdent() + _ = p.expect(":") + expr := p.parseExpr() + return &ast.GqlElementProperty{ + ElementPropertyName: ident, + ElementPropertyValue: expr, + } +} +func (p *Parser) parseGqlPropertyFilters() *ast.GqlPropertyFilters { + lbrace := p.expect("{").Pos + + elementPropertyList := []*ast.GqlElementProperty{p.parseGqlElementProperty()} + for p.Token.Kind == "," { + p.nextToken() + elementPropertyList = append(elementPropertyList, p.parseGqlElementProperty()) + } + + rbrace := p.expect("}").Pos + return &ast.GqlPropertyFilters{ + LBrace: lbrace, + PropertyFilterElemList: elementPropertyList, + RBrace: rbrace, + } +} + +func (p *Parser) tryParseGqlPatternFillerFilter() ast.GqlPatternFillerFilter { + switch { + case p.Token.Kind == "WHERE": + return p.parseWhere() + case p.Token.Kind == "{": + return p.parseGqlPropertyFilters() + default: + return nil + } +} + +func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { + patterns := []*ast.GqlTopLevelPathPattern{p.parseGqlTopLevelPathPattern()} + for p.Token.Kind == "," { + p.nextToken() + patterns = append(patterns, p.parseGqlTopLevelPathPattern()) + } + return &ast.GqlGraphPattern{ + PathPatternList: patterns, + WhereClause: p.tryParseWhere(), // TODO + } +} + +/* +*** +GQL statements +*** +*/ + +/* +*** +GQL RETURN statement +*** +*/ +func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { + ret := p.expectKeywordLike("RETURN").Pos + + allOrDistinct := p.tryParseGqlAllOrDistinctEnum() + returnItems := p.parseGqlReturnItemList() + groupBy := p.tryParseGroupBy() + orderBy := p.tryParseOrderBy() + limit := p.tryParseLimit() + offset := p.tryParseOffset() + var limitAndOffset ast.GqlLimitAndOffsetClause + switch { + case limit != nil && offset != nil: + limitAndOffset = &ast.GqlLimitWithOffsetClause{ + Limit: limit, + Offset: offset, + } + case limit != nil: + limitAndOffset = &ast.GqlLimitClause{Limit: limit} + case offset != nil: + limitAndOffset = &ast.GqlOffsetClause{Offset: offset} + default: + } + return &ast.GqlReturnStatement{Return: ret, + AllOrDistinct: allOrDistinct, + GroupByClause: groupBy, + OrderByClause: orderBy, + LimitAndOffsetClause: limitAndOffset, + ReturnItemList: returnItems} +} + +func (p *Parser) parseGqlReturnItemList() []ast.GqlReturnItem { + var results []ast.GqlReturnItem + for { + results = append(results, p.parseGqlReturnItem()) + if p.Token.Kind != "," { + break + } + p.nextToken() + } + return results +} + +func (p *Parser) tryParseGqlAllOrDistinctEnum() ast.GqlAllOrDistinctEnum { + switch p.Token.Kind { + case "ALL": + p.nextToken() + return ast.GqlAllOrDistinctAll + case "DISTINCT": + p.nextToken() + return ast.GqlAllOrDistinctDistinct + default: + return ast.GqlAllOrDistinctImplicitAll + } +} + +func (p *Parser) parseGqlWithStatement() *ast.GqlWithStatement { + with := p.expect("WITH").Pos + allOrDistinct := p.tryParseGqlAllOrDistinctEnum() + returnItems := p.parseGqlReturnItemList() + groupBy := p.tryParseGroupBy() + + return &ast.GqlWithStatement{ + With: with, + AllOrDistinct: allOrDistinct, + GroupByClause: groupBy, + ReturnItemList: returnItems} +} + +func (p *Parser) parseGqlLinearGraphVariable() *ast.GqlLinearGraphVariable { + name := p.parseIdent() + p.expect("=") + value := p.parseExpr() + + return &ast.GqlLinearGraphVariable{VariableName: name, Value: value} +} + +func (p *Parser) parseGqlLetStatement() *ast.GqlLetStatement { + let := p.expectKeywordLike("LET").Pos + vars := []*ast.GqlLinearGraphVariable{p.parseGqlLinearGraphVariable()} + + for p.Token.Kind == "," { + p.nextToken() + vars = append(vars, p.parseGqlLinearGraphVariable()) + } + + return &ast.GqlLetStatement{Let: let, LinearGraphVariableList: vars} +} + +func (p *Parser) parseGqlMultiLinearQueryStatement() *ast.GqlMultiLinearQueryStatement { + items := []ast.GqlLinearQueryStatement{p.parseGqlLinearQueryStatement()} + for p.Token.IsKeywordLike("NEXT") { + p.expectKeywordLike("NEXT") + items = append(items, p.parseGqlLinearQueryStatement()) + } + + return &ast.GqlMultiLinearQueryStatement{LinearQueryStatementList: items} +} + func (p *Parser) expect(kind token.TokenKind) *token.Token { if p.Token.Kind != kind { p.panicfAtToken(&p.Token, "expected token: %s, but: %s", kind, p.Token.Kind) diff --git a/parser_gql.go b/parser_gql.go deleted file mode 100644 index c0983464..00000000 --- a/parser_gql.go +++ /dev/null @@ -1,833 +0,0 @@ -package memefish - -import ( - "fmt" - "github.com/cloudspannerecosystem/memefish/ast" - "github.com/cloudspannerecosystem/memefish/token" -) - -// ================================================================================ -// -// GRAPH -// -// ================================================================================ - -func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { - graphClause := p.parseGqlGraphClause() - multiQueryStatement := p.parseGqlMultiLinearQueryStatement() - - return &ast.GqlGraphQuery{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} -} - -func (p *Parser) parseGqlSubQueryInCondition() *ast.GqlSubQueryInCondition { - lbrace := p.expect("{").Pos - query := p.parseGqlQueryExpr() - rbrace := p.expect("}").Pos - - return &ast.GqlSubQueryInCondition{LBrace: lbrace, RBrace: rbrace, Query: query} -} -func (p *Parser) parseGqlQueryExpr() *ast.GqlQueryExpr { - var graphClause *ast.GqlGraphClause - if p.Token.IsKeywordLike("GRAPH") { - graphClause = p.parseGqlGraphClause() - } - multiQueryStatement := p.parseGqlMultiLinearQueryStatement() - - return &ast.GqlQueryExpr{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} -} - -func (p *Parser) parseGqlGraphClause() *ast.GqlGraphClause { - graphPos := p.expectKeywordLike("GRAPH").Pos - graphName := p.parseIdent() - return &ast.GqlGraphClause{ - Graph: graphPos, - PropertyGraphName: graphName, - } -} - -func (p *Parser) parseGqlLinearQueryStatement() ast.GqlLinearQueryStatement { - stmt := p.parseGqlSimpleLinearQueryStatement() - if p.Token.Kind != ("UNION") && p.Token.Kind != ("EXCEPT") && p.Token.Kind != ("DISTINCT") { - return stmt - } - var tail []*ast.GqlSimpleLinearQueryStatementWithSetOperator - for p.Token.Kind == ("UNION") || p.Token.Kind == ("EXCEPT") || p.Token.Kind == ("DISTINCT") { - tail = append(tail, p.parseGqlSimpleLinearQueryStatementWithSetOperator()) - } - return &ast.GqlCompositeLinearQueryStatement{HeadSimpleLinearQueryStatement: stmt, TailSimpleLinearQueryStatementList: tail} -} - -func (p *Parser) parseGqlSimpleLinearQueryStatementWithSetOperator() *ast.GqlSimpleLinearQueryStatementWithSetOperator { - pos := p.Token.Pos - var op ast.GqlSetOperatorEnum - switch p.Token.Kind { - case "UNION": - p.nextToken() - op = ast.GqlSetOperatorUnion - case "INTERSECT": - p.nextToken() - op = ast.GqlSetOperatorIntersect - case "EXCEPT": - p.nextToken() - op = ast.GqlSetOperatorExcept - default: - panic("unknown SetOperatorEnum") - } - - allOrDistinct := p.tryParseGqlAllOrDistinctEnum() - if allOrDistinct == ast.GqlAllOrDistinctImplicitAll { - p.panicfAtToken(&p.Token, `expect "ALL" or "DISTINCT, but: %v`, p.Token.Kind) - } - - stmt := p.parseGqlSimpleLinearQueryStatement() - return &ast.GqlSimpleLinearQueryStatementWithSetOperator{ - StartPos: pos, - SetOperator: op, - DistinctOrAll: allOrDistinct, - Statement: stmt, - } -} -func (p *Parser) parseGqlSimpleLinearQueryStatement() *ast.GqlSimpleLinearQueryStatement { - var stmts []ast.GqlPrimitiveQueryStatement - for stmt := p.tryParseGqlPrimitiveQueryStatement(); stmt != nil; stmt = p.tryParseGqlPrimitiveQueryStatement() { - stmts = append(stmts, stmt) - } - - return &ast.GqlSimpleLinearQueryStatement{PrimitiveQueryStatementList: stmts} -} - -func (p *Parser) tryParseGqlWithOffsetClause() *ast.GqlWithOffsetClause { - if p.Token.Kind != "WITH" { - return nil - } - with := p.expect("WITH").Pos - offset := p.expectKeywordLike("OFFSET").Pos - var offsetName *ast.Ident - if p.Token.Kind == "AS" { - p.nextToken() - offsetName = p.parseIdent() - } - - return &ast.GqlWithOffsetClause{ - With: with, - Offset: offset, - OffsetName: offsetName, - } -} - -func (p *Parser) parseGqlForStatement() *ast.GqlForStatement { - forPos := p.expect("FOR").Pos - name := p.parseIdent() - p.expect("IN") - expr := p.parseExpr() - - withOffset := p.tryParseGqlWithOffsetClause() - - return &ast.GqlForStatement{ - For: forPos, - ElementName: name, - ArrayExpression: expr, - WithOffsetClause: withOffset, - } -} - -func (p *Parser) tryParseGqlOrderBySpecificationList() []*ast.GqlOrderBySpecification { - var list []*ast.GqlOrderBySpecification - for { - expr := p.parseExpr() - - var collateSpec *ast.GqlCollationSpecification - if p.Token.Kind == "COLLATE" { - collatePos := p.expect("COLLATE").Pos - spec := p.parseStringValue() - collateSpec = &ast.GqlCollationSpecification{ - Collate: collatePos, - Specification: spec, - } - } - - var direction ast.GqlDirection - directionPos := p.Token.Pos - switch { - case p.Token.Kind == "ASC": - p.nextToken() - direction = ast.GqlSortOrderAsc - case p.Token.Kind == "DESC": - p.nextToken() - direction = ast.GqlSortOrderDesc - case p.Token.Kind == "ASCENDING": - p.nextToken() - direction = ast.GqlSortOrderAscending - case p.Token.Kind == "DESCENDING": - p.nextToken() - direction = ast.GqlSortOrderDescending - default: - directionPos = token.InvalidPos - } - list = append(list, &ast.GqlOrderBySpecification{ - Expr: expr, - DirectionPos: directionPos, - CollationSpecification: collateSpec, - Direction: direction, - }) - if p.Token.Kind != "," { - break - } - } - return list -} - -func (p *Parser) parseGqlOrderByStatement() *ast.GqlOrderByStatement { - order := p.expect("ORDER").Pos - p.expect("BY") - spec := p.tryParseGqlOrderBySpecificationList() - if spec == nil { - p.panicfAtToken(&p.Token, "expect at least one order_by_specification") - } - - return &ast.GqlOrderByStatement{ - Order: order, - OrderBySpecificationList: spec, - } -} - -func (p *Parser) parseGqlLimitStatement() *ast.GqlLimitStatement { - limit := p.expect("LIMIT").Pos - expr := p.parseIntValue() - - return &ast.GqlLimitStatement{ - Limit: limit, - Count: expr, - } -} - -func (p *Parser) parseGqlFilterStatement() *ast.GqlFilterStatement { - filter := p.expectKeywordLike("FILTER").Pos - where := token.InvalidPos - if p.Token.Kind == "WHERE" { - where = p.expect("WHERE").Pos - } - expr := p.parseExpr() - - return &ast.GqlFilterStatement{ - Filter: filter, - Where: where, - Expr: expr, - } -} - -func (p *Parser) parseGqlOffsetStatement() *ast.GqlOffsetStatement { - var pos token.Pos - var isSkip bool - switch { - case p.Token.IsKeywordLike("OFFSET"): - pos = p.expectKeywordLike("OFFSET").Pos - case p.Token.IsKeywordLike("SKIP"): - pos = p.expectKeywordLike("SKIP").Pos - isSkip = true - default: - p.panicfAtToken(&p.Token, `expected "OFFSET" or "SKIP", but: %v`, p.Token.Kind) - } - - count := p.parseIntValue() - - return &ast.GqlOffsetStatement{ - Offset: pos, - IsSkip: isSkip, - Count: count, - } -} - -func (p *Parser) parseGqlReturnItem() ast.GqlReturnItem { - if p.Token.Kind == "*" { - pos := p.expect("*").Pos - return &ast.Star{ - Star: pos, - } - } - - expr := p.parseExpr() - if p.Token.Kind == "AS" { - if as := p.tryParseAsAlias(); as != nil { - return &ast.Alias{ - Expr: expr, - As: as, - } - } - } - - return &ast.ExprSelectItem{ - Expr: expr, - } -} - -func (p *Parser) tryParseAsAliasAsMandatory() *ast.AsAlias { - if p.Token.Kind != "AS" { - return nil - } - return p.tryParseAsAlias() -} - -func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryStatement { - switch { - case p.Token.IsKeywordLike("RETURN"): - return p.parseGqlReturnStatement() - case p.Token.IsKeywordLike("LET"): - return p.parseGqlLetStatement() - case p.Token.IsKeywordLike("FILTER"): - return p.parseGqlFilterStatement() - case p.Token.Kind == "ORDER": - return p.parseGqlOrderByStatement() - case p.Token.Kind == "LIMIT": - return p.parseGqlLimitStatement() - case p.Token.IsKeywordLike("SKIP"), p.Token.IsKeywordLike("OFFSET"): - return p.parseGqlOffsetStatement() - case p.Token.Kind == "FOR": - return p.parseGqlForStatement() - case p.Token.IsKeywordLike("OPTIONAL") || p.Token.IsKeywordLike("MATCH"): - return p.parseGqlMatchStatement() - case p.Token.Kind == "WITH": - return p.parseGqlWithStatement() - default: - return nil - } -} - -func (p *Parser) tryParseGqlPathModePathOrPaths() *ast.Ident { - switch { - case p.Token.IsKeywordLike("PATH"), p.Token.IsKeywordLike("PATHS"): - return p.parseIdent() - default: - return nil - } -} -func (p *Parser) tryParseGqlPathMode() *ast.GqlPathMode { - switch { - case p.Token.IsKeywordLike("WALK"): - pathModeToken := p.parseIdent() - pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() - return &ast.GqlPathMode{ - ModeToken: pathModeToken, - PathOrPathsToken: pathOrPathsToken, - Mode: ast.GqlPathModeWalk, - } - - case p.Token.IsKeywordLike("TRAIL"): - pathModeToken := p.parseIdent() - pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() - return &ast.GqlPathMode{ - ModeToken: pathModeToken, - PathOrPathsToken: pathOrPathsToken, - Mode: ast.GqlPathModeTrail, - } - default: - return nil - } -} -func (p *Parser) tryParseGqlPathSearchPrefixOrPathMode() ast.GqlPathSearchPrefixOrPathMode { - startPos := p.Token.Pos - switch { - case p.Token.Kind == "ALL": - end := p.expect("ALL").End - return &ast.GqlPathSearchPrefix{ - StartPos: startPos, - LastEnd: end, - SearchPrefix: ast.GqlPathSearchPrefixAll, - } - case p.Token.Kind == "ANY": - anyEnd := p.expect("ANY").End - if p.Token.IsKeywordLike("SHORTEST") { - shortestEnd := p.expectKeywordLike("SHORTEST").End - return &ast.GqlPathSearchPrefix{ - StartPos: startPos, - LastEnd: shortestEnd, - SearchPrefix: ast.GqlPathSearchPrefixAnyShortest, - } - } else { - return &ast.GqlPathSearchPrefix{ - StartPos: startPos, - LastEnd: anyEnd, - SearchPrefix: ast.GqlPathSearchPrefixAny, - } - } - default: - if pathMode := p.tryParseGqlPathMode(); pathMode != nil { - return pathMode - } - return nil - } - -} - -func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { - var optionalPos token.Pos - if p.Token.IsKeywordLike("OPTIONAL") { - optionalPos = p.Token.Pos - p.nextToken() - } else { - optionalPos = token.InvalidPos - } - - match := p.expectKeywordLike("MATCH").Pos - hint := p.tryParseHint() - var prefixOrMode = p.tryParseGqlPathSearchPrefixOrPathMode() - pattern := p.parseGqlGraphPattern() - return &ast.GqlMatchStatement{ - Optional: optionalPos, - Match: match, - MatchHint: hint, - PrefixOrMode: prefixOrMode, - GraphPattern: pattern, - } -} - -func (p *Parser) parseGqlLabelName() *ast.GqlLabelName { - pos := p.Token.Pos - - if p.Token.Kind == "%" { - p.nextToken() - return &ast.GqlLabelName{ - StartPos: pos, - IsPercent: true, - } - } - - ident := p.parseIdent() - return &ast.GqlLabelName{ - StartPos: pos, - LabelName: ident, - } -} - -func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { - // TODO - /* - label_expression: - { - label_name - | or_expression - | and_expression - | not_expression - } - */ - var labelTerm ast.GqlLabelExpression - switch { - case p.Token.Kind == "!": - notPos := p.expect("!").Pos - expr := p.parseGqlLabelExpression() - labelTerm = &ast.GqlLabelNotExpression{Not: notPos, LabelExpression: expr} - case p.Token.Kind == "(": - lparen := p.expect("(").Pos - expr := p.parseGqlLabelExpression() - rparen := p.expect(")").Pos - labelTerm = &ast.GqlLabelParenExpression{ - LParen: lparen, - RParen: rparen, - LabelExpr: expr, - } - case p.Token.Kind == token.TokenIdent || p.Token.Kind == "%": - labelTerm = p.parseGqlLabelName() - default: - p.panicfAtToken(&p.Token, `expected token: ",", "(", or "", but: %v`, p.Token.Kind) - return nil - } - switch { - case p.Token.Kind == "|": - p.nextToken() - right := p.parseGqlLabelExpression() - return &ast.GqlLabelOrExpression{ - Left: labelTerm, - Right: right, - } - case p.Token.Kind == "&": - p.nextToken() - right := p.parseGqlLabelExpression() - return &ast.GqlLabelAndExpression{ - Left: labelTerm, - Right: right, - } - } - return labelTerm -} -func (p *Parser) parseGqlIsLabelCondition() *ast.GqlIsLabelCondition { - - pos := p.Token.Pos - p.nextToken() - labelExpr := p.parseGqlLabelExpression() - return &ast.GqlIsLabelCondition{ - IsOrColon: pos, - LabelExpression: labelExpr, - } -} -func (p *Parser) parseGqlPatternFiller() *ast.GqlPatternFiller { - hint := p.tryParseHint() - var patternVar *ast.Ident - if p.Token.Kind == token.TokenIdent { - patternVar = p.parseIdent() - } - var isLabelCondition *ast.GqlIsLabelCondition - if p.Token.Kind == ":" || p.Token.Kind == "IS" { - isLabelCondition = p.parseGqlIsLabelCondition() - } - - filter := p.tryParseGqlPatternFillerFilter() - return &ast.GqlPatternFiller{ - Hint: hint, - GraphPatternVariable: patternVar, // TODO - IsLabelCondition: isLabelCondition, // TODO - Filter: filter, // TODO - } -} - -func (p *Parser) lookaheadGqlSubpathPattern() bool { - lexer := p.Lexer.Clone() - defer func() { - p.Lexer = lexer - }() - - if p.Token.Kind != "(" { - return false - } - p.nextToken() - if p.Token.Kind == "(" || p.Token.Kind == "-" || p.Token.Kind == "<" || p.Token.IsKeywordLike("WALK") || p.Token.IsKeywordLike("TRAIL") { - return true - } - return false -} - -func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { - lparen := p.expect("(").Pos - filter := p.parseGqlPatternFiller() - rparen := p.expect(")").Pos - return &ast.GqlNodePattern{ - LParen: lparen, - RParen: rparen, - PatternFiller: filter, - } -} - -func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { - if p.Token.Kind != "{" { - return nil - } - lbrace := p.expect("{").Pos - if p.Token.Kind == "," { - upperBound := p.parseIntValue() - rbrace := p.expect("}").Pos - return &ast.GqlBoundedQuantifier{ - LBrace: lbrace, - RBrace: rbrace, - UpperBound: upperBound, - } - } - bound := p.parseIntValue() - if p.Token.Kind != "," { - rbrace := p.expect("}").Pos - return &ast.GqlFixedQuantifier{ - LBrace: lbrace, - RBrace: rbrace, - Bound: bound, - } - } - p.expect(",") - upperBound := p.parseIntValue() - rbrace := p.expect("}").Pos - - return &ast.GqlBoundedQuantifier{ - LBrace: lbrace, - RBrace: rbrace, - LowerBound: bound, - UpperBound: upperBound, - } -} - -func (p *Parser) tryParseGqlQuantifiablePathTerm() *ast.GqlQuantifiablePathTerm { - hint := p.tryParseHint() - pt := p.tryParseGqlPathTerm() - if pt == nil { - return nil - } - q := p.tryParseGqlQuantifier() - return &ast.GqlQuantifiablePathTerm{ - Hint: hint, - PathTerm: pt, - Quantifier: q, - } -} - -func (p *Parser) tryParseGqlPathTerm() ast.GqlPathTerm { - // TODO - /* - path_term: - { - element_pattern - | subpath_pattern - } - */ - - if p.lookaheadGqlSubpathPattern() { - return p.parseGqlSubPathPattern() - } - if p.Token.Kind == "(" { - return p.parseGqlNodePattern() - } - if p.Token.Kind == "-" || p.Token.Kind == "<" { - return p.parseGqlEdgePattern() - } - return nil -} - -func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { - lparen := p.expect("(").Pos - pathMode := p.tryParseGqlPathMode() - pattern := p.parseGqlPathPattern() - where := p.tryParseWhere() - rparen := p.expect(")").Pos - - return &ast.GqlSubpathPattern{ - LParen: lparen, - RParen: rparen, - PathMode: pathMode, - PathPattern: pattern, - WhereClause: where, - } -} - -func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { - // NOTE: Currently, this implementation allows whitespace in any place of "<-[" and "]->". - // It is more relaxed syntax than spec. - // It will be fixed when we are sure that the modification of lexer is safe. - firstPos := p.Token.Pos - switch p.Token.Kind { - case "<": - p.nextToken() - firstHyphenPos := p.expect("-").Pos - if p.Token.Kind != "[" { - return &ast.GqlAbbreviatedEdgeLeft{ - First: firstPos, - Last: firstHyphenPos, - } - } - p.nextToken() - patternFilter := p.parseGqlPatternFiller() - p.expect("]") - lastPos := p.expect("-").Pos - return &ast.GqlFullEdgeLeft{ - First: firstPos, - Last: lastPos, - PatternFiller: patternFilter, - } - case "-": - p.nextToken() - switch p.Token.Kind { - case ">": - lastPos := p.expect(">").Pos - return &ast.GqlAbbreviatedEdgeRight{ - First: firstPos, - Last: lastPos, - } - case "[": - p.nextToken() - patternFiller := p.parseGqlPatternFiller() - p.expect("]") - lastHyphenPos := p.expect("-").Pos - if p.Token.Kind == ">" { - lastPos := p.Token.Pos - p.nextToken() - return &ast.GqlFullEdgeRight{ - First: firstPos, - Last: lastPos, - PatternFiller: patternFiller, - } - } - return &ast.GqlFullEdgeAny{ - First: firstPos, - Last: lastHyphenPos, - PatternFiller: patternFiller, - } - default: - return &ast.GqlAbbreviatedEdgeAny{Hyphen: firstPos} - } - default: - panic(fmt.Sprintf("not implemented kind: %v %v", p.Token.Kind, p.Token.Raw)) - } -} - -func (p *Parser) parseGqlPathPattern() *ast.GqlPathPattern { - list := []*ast.GqlQuantifiablePathTerm{p.tryParseGqlQuantifiablePathTerm()} - for p.Token.Kind != ")" && !p.Token.IsKeywordLike("WHERE") { - term := p.tryParseGqlQuantifiablePathTerm() - if term == nil { - break - } - list = append(list, term) - } - return &ast.GqlPathPattern{ - PathTermList: list, - } -} -func (p *Parser) parseGqlTopLevelPathPattern() *ast.GqlTopLevelPathPattern { - pattern := p.parseGqlPathPattern() - return &ast.GqlTopLevelPathPattern{ - PathSearchPrefixOrPathMode: nil, // TODO - PathPattern: pattern, - } -} - -func (p *Parser) parseGqlElementProperty() *ast.GqlElementProperty { - ident := p.parseIdent() - _ = p.expect(":") - expr := p.parseExpr() - return &ast.GqlElementProperty{ - ElementPropertyName: ident, - ElementPropertyValue: expr, - } -} -func (p *Parser) parseGqlPropertyFilters() *ast.GqlPropertyFilters { - lbrace := p.expect("{").Pos - - elementPropertyList := []*ast.GqlElementProperty{p.parseGqlElementProperty()} - for p.Token.Kind == "," { - p.nextToken() - elementPropertyList = append(elementPropertyList, p.parseGqlElementProperty()) - } - - rbrace := p.expect("}").Pos - return &ast.GqlPropertyFilters{ - LBrace: lbrace, - PropertyFilterElemList: elementPropertyList, - RBrace: rbrace, - } -} - -func (p *Parser) tryParseGqlPatternFillerFilter() ast.GqlPatternFillerFilter { - switch { - case p.Token.Kind == "WHERE": - return p.parseWhere() - case p.Token.Kind == "{": - return p.parseGqlPropertyFilters() - default: - return nil - } -} - -func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { - patterns := []*ast.GqlTopLevelPathPattern{p.parseGqlTopLevelPathPattern()} - for p.Token.Kind == "," { - p.nextToken() - patterns = append(patterns, p.parseGqlTopLevelPathPattern()) - } - return &ast.GqlGraphPattern{ - PathPatternList: patterns, - WhereClause: p.tryParseWhere(), // TODO - } -} - -/* -*** -GQL statements -*** -*/ - -/* -*** -GQL RETURN statement -*** -*/ -func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { - ret := p.expectKeywordLike("RETURN").Pos - - allOrDistinct := p.tryParseGqlAllOrDistinctEnum() - returnItems := p.parseGqlReturnItemList() - groupBy := p.tryParseGroupBy() - orderBy := p.tryParseOrderBy() - limit := p.tryParseLimit() - offset := p.tryParseOffset() - var limitAndOffset ast.GqlLimitAndOffsetClause - switch { - case limit != nil && offset != nil: - limitAndOffset = &ast.GqlLimitWithOffsetClause{ - Limit: limit, - Offset: offset, - } - case limit != nil: - limitAndOffset = &ast.GqlLimitClause{Limit: limit} - case offset != nil: - limitAndOffset = &ast.GqlOffsetClause{Offset: offset} - default: - } - return &ast.GqlReturnStatement{Return: ret, - AllOrDistinct: allOrDistinct, - GroupByClause: groupBy, - OrderByClause: orderBy, - LimitAndOffsetClause: limitAndOffset, - ReturnItemList: returnItems} -} - -func (p *Parser) parseGqlReturnItemList() []ast.GqlReturnItem { - var results []ast.GqlReturnItem - for { - results = append(results, p.parseGqlReturnItem()) - if p.Token.Kind != "," { - break - } - p.nextToken() - } - return results -} - -func (p *Parser) tryParseGqlAllOrDistinctEnum() ast.GqlAllOrDistinctEnum { - switch p.Token.Kind { - case "ALL": - p.nextToken() - return ast.GqlAllOrDistinctAll - case "DISTINCT": - p.nextToken() - return ast.GqlAllOrDistinctDistinct - default: - return ast.GqlAllOrDistinctImplicitAll - } -} - -func (p *Parser) parseGqlWithStatement() *ast.GqlWithStatement { - with := p.expect("WITH").Pos - allOrDistinct := p.tryParseGqlAllOrDistinctEnum() - returnItems := p.parseGqlReturnItemList() - groupBy := p.tryParseGroupBy() - - return &ast.GqlWithStatement{ - With: with, - AllOrDistinct: allOrDistinct, - GroupByClause: groupBy, - ReturnItemList: returnItems} -} - -func (p *Parser) parseGqlLinearGraphVariable() *ast.GqlLinearGraphVariable { - name := p.parseIdent() - p.expect("=") - value := p.parseExpr() - - return &ast.GqlLinearGraphVariable{VariableName: name, Value: value} -} - -func (p *Parser) parseGqlLetStatement() *ast.GqlLetStatement { - let := p.expectKeywordLike("LET").Pos - vars := []*ast.GqlLinearGraphVariable{p.parseGqlLinearGraphVariable()} - - for p.Token.Kind == "," { - p.nextToken() - vars = append(vars, p.parseGqlLinearGraphVariable()) - } - - return &ast.GqlLetStatement{Let: let, LinearGraphVariableList: vars} -} - -func (p *Parser) parseGqlMultiLinearQueryStatement() *ast.GqlMultiLinearQueryStatement { - items := []ast.GqlLinearQueryStatement{p.parseGqlLinearQueryStatement()} - for p.Token.IsKeywordLike("NEXT") { - p.expectKeywordLike("NEXT") - items = append(items, p.parseGqlLinearQueryStatement()) - } - - return &ast.GqlMultiLinearQueryStatement{LinearQueryStatementList: items} -} From 4b2c2adb7132c1257684723ebeb0805d5c48b858 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:19:28 +0900 Subject: [PATCH 28/53] Quote go-version --- .github/workflows/go.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index e18fdf55..c826e202 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -14,7 +14,7 @@ jobs: - name: Set up Go 1.20 uses: actions/setup-go@v4 with: - go-version: 1.20 + go-version: "1.20" id: go - name: Check out code into the Go module directory From ce5771097ba9bcf6e2de873eb78800d699584f9f Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:32:07 +0900 Subject: [PATCH 29/53] Remove unused member function --- parser.go | 7 ------- 1 file changed, 7 deletions(-) diff --git a/parser.go b/parser.go index 4d11c9a9..ac33f0df 100644 --- a/parser.go +++ b/parser.go @@ -4082,13 +4082,6 @@ func (p *Parser) parseGqlReturnItem() ast.GqlReturnItem { } } -func (p *Parser) tryParseAsAliasAsMandatory() *ast.AsAlias { - if p.Token.Kind != "AS" { - return nil - } - return p.tryParseAsAlias() -} - func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryStatement { switch { case p.Token.IsKeywordLike("RETURN"): From 51efb46282e175230bd40bcbb3326342fd46889a Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:32:41 +0900 Subject: [PATCH 30/53] Fix infinite recursion bug --- ast/pos.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ast/pos.go b/ast/pos.go index 02adc1be..2b4d295f 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -952,8 +952,8 @@ func (g *GqlMatchStatement) End() token.Pos { func (g *GqlLimitClause) Pos() token.Pos { return g.Limit.Pos() } func (g *GqlLimitClause) End() token.Pos { return g.Limit.End() } -func (g *GqlOffsetClause) Pos() token.Pos { return g.Pos() } -func (g *GqlOffsetClause) End() token.Pos { return g.End() } +func (g *GqlOffsetClause) Pos() token.Pos { return g.Offset.Pos() } +func (g *GqlOffsetClause) End() token.Pos { return g.Offset.End() } func (g *GqlLimitWithOffsetClause) Pos() token.Pos { return g.Limit.Pos() } func (g *GqlLimitWithOffsetClause) End() token.Pos { return g.Offset.End() } From fbc6fbe178be982d13ff9ea593da09969ba7358d Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:34:51 +0900 Subject: [PATCH 31/53] Fix parser.go --- parser.go | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/parser.go b/parser.go index ac33f0df..49b88f84 100644 --- a/parser.go +++ b/parser.go @@ -48,7 +48,7 @@ func (p *Parser) ParseGqlStatement() (stmt ast.Statement, err error) { }() p.nextToken() - stmt = p.parseGqlStatement() + stmt = p.parseGqlQuery() if p.Token.Kind != token.TokenEOF { p.panicfAtToken(&p.Token, "expected token: , but: %s", p.Token.Kind) } @@ -261,18 +261,12 @@ func (p *Parser) parseStatement() ast.Statement { // GQL queries are first level statements // because it is supported by Cloud Spanner's ExecuteSql API. case p.Token.IsKeywordLike("GRAPH"): - return p.parseGqlStatement() + return p.parseGqlQuery() } panic(p.errorfAtToken(&p.Token, "unexpected token: %s", p.Token.Kind)) } -func (p *Parser) parseGqlStatement() ast.Statement { - return p.parseGqlQuery() - - panic(p.errorfAtToken(&p.Token, "unexpected token: %s", p.Token.Kind)) -} - func (p *Parser) parseStatements(doParse func()) { for p.Token.Kind != token.TokenEOF { if p.Token.Kind == ";" { From f3d67a99b96301b0c5b0ef0cd8f89b1221a8d73a Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:52:03 +0900 Subject: [PATCH 32/53] Rename Gql to GQL --- ast/ast.go | 410 ++++++++--------- ast/ast_test.go | 2 +- ast/const.go | 42 +- ast/pos.go | 212 ++++----- ast/sql.go | 144 +++--- parser.go | 416 +++++++++--------- parser_test.go | 8 +- testdata/result/gql/filter.sql.txt | 60 +-- testdata/result/gql/filter_where.sql.txt | 60 +-- testdata/result/gql/for_with_offset.sql.txt | 62 +-- .../result/gql/for_with_offset_as.sql.txt | 42 +- .../result/gql/graph_hints_between.sql.txt | 94 ++-- testdata/result/gql/graph_hints_match.sql.txt | 106 ++--- .../gql/graph_hints_traversal_hint.sql.txt | 100 ++--- testdata/result/gql/let.sql.txt | 64 +-- testdata/result/gql/limit.sql.txt | 68 +-- testdata/result/gql/match.sql.txt | 38 +- .../result/gql/match_any_shortest.sql.txt | 68 +-- .../match_any_shortest_subpath_trail.sql.txt | 46 +- testdata/result/gql/match_optional.sql.txt | 86 ++-- .../result/gql/match_or_expression.sql.txt | 42 +- .../result/gql/match_subpath_trail.sql.txt | 90 ++-- .../gql/match_trail_subpath_walk.sql.txt | 72 +-- ...tch_where_is_destination_of_return.sql.txt | 58 +-- .../match_where_is_source_of_return.sql.txt | 58 +-- .../gql/match_where_not_same_return.sql.txt | 58 +-- ...match_where_property_exists_return.sql.txt | 42 +- testdata/result/gql/next.sql.txt | 132 +++--- testdata/result/gql/next_1.sql.txt | 108 ++--- testdata/result/gql/offset_1.sql.txt | 40 +- testdata/result/gql/order_by.sql.txt | 68 +-- testdata/result/gql/order_by_collate.sql.txt | 46 +- testdata/result/gql/return.sql.txt | 108 ++--- .../result/gql/return_array_subquery.sql.txt | 118 ++--- testdata/result/gql/return_distinct.sql.txt | 66 +-- .../gql/return_exists_graph_pattern.sql.txt | 58 +-- .../result/gql/return_exists_match.sql.txt | 72 +-- .../gql/return_exists_query_expr.sql.txt | 78 ++-- .../result/gql/return_in_gql_subquery.sql.txt | 76 ++-- .../result/gql/return_value_subquery.sql.txt | 58 +-- testdata/result/gql/skip_1.sql.txt | 40 +- testdata/result/gql/with_1.sql.txt | 62 +-- .../gql_path_pattern/abbr_edge_any.sql.txt | 8 +- .../abbreviated_edge_left.sql.txt | 8 +- .../abbreviated_edge_right.sql.txt | 8 +- .../gql_path_pattern/full_edge_any.sql.txt | 12 +- .../gql_path_pattern/full_edge_left.sql.txt | 12 +- .../gql_path_pattern/full_edge_right.sql.txt | 12 +- .../node_pattern_unnamed.sql.txt | 12 +- .../result/gql_path_pattern/pattern_1.sql.txt | 14 +- .../result/gql_path_pattern/pattern_2.sql.txt | 30 +- .../query/select_from_graph_table.sql.txt | 12 +- .../query/select_in_gql_subquery.sql.txt | 60 +-- .../statement/select_from_graph_table.sql.txt | 12 +- .../statement/select_in_gql_subquery.sql.txt | 60 +-- tools/parse/main.go | 4 +- 56 files changed, 1972 insertions(+), 1970 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index 1dabf991..94a5fd1c 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -76,7 +76,7 @@ func (AlterChangeStream) isStatement() {} func (DropChangeStream) isStatement() {} // GRAPH query is top level statement which can be executed by ExecuteSQL API. -func (*GqlGraphQuery) isStatement() {} +func (*GQLGraphQuery) isStatement() {} // QueryExpr represents set operator operands. type QueryExpr interface { @@ -160,9 +160,9 @@ func (BytesLiteral) isExpr() {} func (DateLiteral) isExpr() {} func (TimestampLiteral) isExpr() {} func (NumericLiteral) isExpr() {} -func (*ArrayGqlSubQuery) isExpr() {} -func (*ValueGqlSubQuery) isExpr() {} -func (*ExistsGqlSubQuery) isExpr() {} +func (*ArrayGQLSubQuery) isExpr() {} +func (*ValueGQLSubQuery) isExpr() {} +func (*ExistsGQLSubQuery) isExpr() {} // Arg represents argument of function call. type Arg interface { @@ -183,7 +183,7 @@ type InCondition interface { func (UnnestInCondition) isInCondition() {} func (SubQueryInCondition) isInCondition() {} func (ValuesInCondition) isInCondition() {} -func (*GqlSubQueryInCondition) isInCondition() {} +func (*GQLSubQueryInCondition) isInCondition() {} // Type represents type node. type Type interface { @@ -753,7 +753,7 @@ type GraphTableExpr struct { Lparen, Rparen token.Pos // position of "(" and ")" - Query *GqlMultiLinearQueryStatement + Query *GQLMultiLinearQueryStatement As *AsAlias // optional } @@ -905,16 +905,16 @@ type ValuesInCondition struct { Exprs []Expr // len(Exprs) > 0 } -// GqlSubQueryInCondition is GQL subquery at IN condition. +// GQLSubQueryInCondition is GQL subquery at IN condition. // // {{"{"}}{{.Query | sql}}}{{"}"}} -type GqlSubQueryInCondition struct { +type GQLSubQueryInCondition struct { // pos = LBrace // end = RBrace + 1 LBrace, RBrace token.Pos // position of "{" and "}" - Query *GqlQueryExpr + Query *GQLQueryExpr } // IsNullExpr is IS NULL expression node. @@ -1180,50 +1180,50 @@ type ArraySubQuery struct { Query QueryExpr } -// ArrayGqlSubQuery is GQL subquery as ARRAY. +// ArrayGQLSubQuery is GQL subquery as ARRAY. // // ARRAY{{"{"}}{{.Query | sql}}{{"}"}} -type ArrayGqlSubQuery struct { +type ArrayGQLSubQuery struct { // pos = Array // end = RBrace + 1 Array token.Pos // position of "ARRAY" keyword RBrace token.Pos // position of "{" and "}" - Query *GqlQueryExpr + Query *GQLQueryExpr } -// ValueGqlSubQuery is GQL subquery as VALUE. +// ValueGQLSubQuery is GQL subquery as VALUE. // // VALUE{{"{"}}{{.Query | sql}}{{"}"}} -type ValueGqlSubQuery struct { +type ValueGQLSubQuery struct { // pos = Array // end = RBrace + 1 Array token.Pos // position of "ARRAY" keyword RBrace token.Pos // position of "{" and "}" - Query *GqlQueryExpr + Query *GQLQueryExpr } -// ExistsGqlSubQuery is GQL subquery as EXISTS. +// ExistsGQLSubQuery is GQL subquery as EXISTS. // // EXISTS{{"{"}}{{.Expr | sql}}{{"}"}} -type ExistsGqlSubQuery struct { +type ExistsGQLSubQuery struct { // pos = Array // end = RBrace + 1 Exists token.Pos // position of "ARRAY" keyword RBrace token.Pos // position of "{" and "}" - Query GqlExistsExpr + Query GQLExistsExpr } -type GqlExistsExpr interface { +type GQLExistsExpr interface { Node - isGqlExistsExpr() + isGQLExistsExpr() } -func (*GqlQueryExpr) isGqlExistsExpr() {} -func (*GqlMatchStatement) isGqlExistsExpr() {} -func (*GqlGraphPattern) isGqlExistsExpr() {} +func (*GQLQueryExpr) isGQLExistsExpr() {} +func (*GQLMatchStatement) isGQLExistsExpr() {} +func (*GQLGraphPattern) isGQLExistsExpr() {} // ExistsSubQuery is subquery in EXISTS call. // @@ -2539,28 +2539,30 @@ type SequenceOptions struct { // // GQL // +// https://cloud.google.com/spanner/docs/reference/standard-sql/graph-query-statements +// // ================================================================================ -// GqlGraphQuery is toplevel node of GRAPH query. -type GqlGraphQuery struct { +// GQLGraphQuery is toplevel node of GRAPH query. +type GQLGraphQuery struct { // pos = (GraphClause ?? MultiLinearQueryStatement).pos // end = MultiLinearQueryStatement.end - GraphClause *GqlGraphClause - MultiLinearQueryStatement *GqlMultiLinearQueryStatement + GraphClause *GQLGraphClause + MultiLinearQueryStatement *GQLMultiLinearQueryStatement } -// GqlQueryExpr is similar to GqlGraphQuery, +// GQLQueryExpr is similar to GQLGraphQuery, // but it is appeared in GQL subqueries and it can optionally have GRAPH clause -type GqlQueryExpr struct { +type GQLQueryExpr struct { // pos = (GraphClause ?? MultiLinearQueryStatement).pos // end = MultiLinearQueryStatement.end - GraphClause *GqlGraphClause // optional - MultiLinearQueryStatement *GqlMultiLinearQueryStatement + GraphClause *GQLGraphClause // optional + MultiLinearQueryStatement *GQLMultiLinearQueryStatement } -type GqlGraphClause struct { +type GQLGraphClause struct { // pos = Graph // end = PropertyGraphName.end @@ -2568,44 +2570,44 @@ type GqlGraphClause struct { PropertyGraphName *Ident } -type GqlMultiLinearQueryStatement struct { +type GQLMultiLinearQueryStatement struct { // pos = LinearQueryStatementList[0].pos // pos = LinearQueryStatementList[$].end - LinearQueryStatementList []GqlLinearQueryStatement + LinearQueryStatementList []GQLLinearQueryStatement } -type GqlLinearQueryStatement interface { +type GQLLinearQueryStatement interface { Node - isGqlLinearQueryStatement() + isGQLLinearQueryStatement() } -func (*GqlSimpleLinearQueryStatement) isGqlLinearQueryStatement() {} -func (*GqlCompositeLinearQueryStatement) isGqlLinearQueryStatement() {} +func (*GQLSimpleLinearQueryStatement) isGQLLinearQueryStatement() {} +func (*GQLCompositeLinearQueryStatement) isGQLLinearQueryStatement() {} -type GqlSimpleLinearQueryStatement struct { +type GQLSimpleLinearQueryStatement struct { // pos = PrimitiveQueryStatementList[0].pos // end = PrimitiveQueryStatementList[$].end - PrimitiveQueryStatementList []GqlPrimitiveQueryStatement + PrimitiveQueryStatementList []GQLPrimitiveQueryStatement } -type GqlSimpleLinearQueryStatementWithSetOperator struct { +type GQLSimpleLinearQueryStatementWithSetOperator struct { // pos = StartPos // end = Statement.end StartPos token.Pos - SetOperator GqlSetOperatorEnum - DistinctOrAll GqlAllOrDistinctEnum - Statement *GqlSimpleLinearQueryStatement + SetOperator GQLSetOperatorEnum + DistinctOrAll GQLAllOrDistinctEnum + Statement *GQLSimpleLinearQueryStatement } -type GqlCompositeLinearQueryStatement struct { +type GQLCompositeLinearQueryStatement struct { // pos = HeadSimpleLinearStatement.pos // end = TailSimpleLinearStatement.pos - HeadSimpleLinearQueryStatement *GqlSimpleLinearQueryStatement - TailSimpleLinearQueryStatementList []*GqlSimpleLinearQueryStatementWithSetOperator + HeadSimpleLinearQueryStatement *GQLSimpleLinearQueryStatement + TailSimpleLinearQueryStatementList []*GQLSimpleLinearQueryStatementWithSetOperator } // ================================================================================ @@ -2614,22 +2616,22 @@ type GqlCompositeLinearQueryStatement struct { // // ================================================================================ -type GqlPrimitiveQueryStatement interface { +type GQLPrimitiveQueryStatement interface { Node - isGqlPrimitiveQueryStatement() + isGQLPrimitiveQueryStatement() } -func (*GqlWithStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlOrderByStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlOffsetStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlLimitStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlForStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlFilterStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlMatchStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlLetStatement) isGqlPrimitiveQueryStatement() {} -func (*GqlReturnStatement) isGqlPrimitiveQueryStatement() {} +func (*GQLWithStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLOrderByStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLOffsetStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLLimitStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLForStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLFilterStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLMatchStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLLetStatement) isGQLPrimitiveQueryStatement() {} +func (*GQLReturnStatement) isGQLPrimitiveQueryStatement() {} -type GqlMatchStatement struct { +type GQLMatchStatement struct { // pos = (Optional ?? Match) // end = GraphPattern.end @@ -2637,20 +2639,20 @@ type GqlMatchStatement struct { Match token.Pos MatchHint *Hint // optional - PrefixOrMode GqlPathSearchPrefixOrPathMode // optional - GraphPattern *GqlGraphPattern + PrefixOrMode GQLPathSearchPrefixOrPathMode // optional + GraphPattern *GQLGraphPattern } -type GqlLimitAndOffsetClause interface { +type GQLLimitAndOffsetClause interface { Node - isGqlLimitAndOffsetClause() + isGQLLimitAndOffsetClause() } -func (g *GqlLimitClause) isGqlLimitAndOffsetClause() {} -func (g *GqlOffsetClause) isGqlLimitAndOffsetClause() {} -func (g *GqlLimitWithOffsetClause) isGqlLimitAndOffsetClause() {} +func (g *GQLLimitClause) isGQLLimitAndOffsetClause() {} +func (g *GQLOffsetClause) isGQLLimitAndOffsetClause() {} +func (g *GQLLimitWithOffsetClause) isGQLLimitAndOffsetClause() {} -type GqlFilterStatement struct { +type GQLFilterStatement struct { // pos = Filter // end = Expr.end @@ -2659,17 +2661,17 @@ type GqlFilterStatement struct { Expr Expr } -type GqlForStatement struct { +type GQLForStatement struct { // pos = For // end = (WithOffsetClause ?? ArrayExpression).end For token.Pos ElementName *Ident ArrayExpression Expr - WithOffsetClause *GqlWithOffsetClause + WithOffsetClause *GQLWithOffsetClause } -type GqlWithOffsetClause struct { +type GQLWithOffsetClause struct { // pos = With.pos // end = OffsetName.end ?? Offset + 6 @@ -2678,22 +2680,22 @@ type GqlWithOffsetClause struct { OffsetName *Ident } -// GqlLimitClause is wrapper of Limit for GQL -type GqlLimitClause struct { +// GQLLimitClause is wrapper of Limit for GQL +type GQLLimitClause struct { // pos = Limit.pos // end = Limit.end Limit *Limit } -// GqlOffsetClause is wrapper of Offset for GQL -type GqlOffsetClause struct { +// GQLOffsetClause is wrapper of Offset for GQL +type GQLOffsetClause struct { // pos = Offset.pos // end = Offset.end Offset *Offset } -// GqlLimitClauseWithOffset -type GqlLimitWithOffsetClause struct { +// GQLLimitClauseWithOffset +type GQLLimitWithOffsetClause struct { // pos = Limit.pos // end = Offset.end @@ -2701,7 +2703,7 @@ type GqlLimitWithOffsetClause struct { Offset *Offset } -type GqlLimitStatement struct { +type GQLLimitStatement struct { // pos = Limit // end = Count.end @@ -2709,9 +2711,9 @@ type GqlLimitStatement struct { Count IntValue } -// GqlOffsetStatement represents OFFSET statement. +// GQLOffsetStatement represents OFFSET statement. // It also represents SKIP statement as the synonym. -type GqlOffsetStatement struct { +type GQLOffsetStatement struct { // pos = Offset.pos // end = Count.end @@ -2720,26 +2722,26 @@ type GqlOffsetStatement struct { Count IntValue } -type GqlOrderByStatement struct { +type GQLOrderByStatement struct { // pos = Order // end = OrderBySpecificationList[$].end Order token.Pos - OrderBySpecificationList []*GqlOrderBySpecification + OrderBySpecificationList []*GQLOrderBySpecification } -type GqlOrderBySpecification struct { +type GQLOrderBySpecification struct { // pos = Expr.pos // DirectionPos ?? CollationSpecification.end Expr Expr - CollationSpecification *GqlCollationSpecification // optional + CollationSpecification *GQLCollationSpecification // optional DirectionPos token.Pos // optional - Direction GqlDirection + Direction GQLDirection } -type GqlCollationSpecification struct { +type GQLCollationSpecification struct { // pos = Collate // end = Specification.end @@ -2747,25 +2749,25 @@ type GqlCollationSpecification struct { Specification StringValue } -type GqlWithStatement struct { +type GQLWithStatement struct { // pos = With // end = (GroupByClause ?? ReturnItemList[$]).end With token.Pos - AllOrDistinct GqlAllOrDistinctEnum - ReturnItemList []GqlReturnItem + AllOrDistinct GQLAllOrDistinctEnum + ReturnItemList []GQLReturnItem GroupByClause *GroupBy // optional } -// GqlReturnItem is similar to SelectItem, +// GQLReturnItem is similar to SelectItem, // but it don't permit DotStar and AsAlias without AS. -type GqlReturnItem SelectItem +type GQLReturnItem SelectItem -type GqlReturnStatement struct { +type GQLReturnStatement struct { // pos = Return.pos // end = (LimitAndOffsetClause ?? OrderByClause ?? GroupByClause ?? ReturnItemList[$]).end Return token.Pos - AllOrDistinct GqlAllOrDistinctEnum - ReturnItemList []GqlReturnItem + AllOrDistinct GQLAllOrDistinctEnum + ReturnItemList []GQLReturnItem // Use GoogleSQL GroupBy because it is referenced in docs GroupByClause *GroupBy //optional @@ -2773,21 +2775,21 @@ type GqlReturnStatement struct { // Use GoogleSQL OrderBy because it is referenced in docs OrderByClause *OrderBy //optional - LimitAndOffsetClause GqlLimitAndOffsetClause // optional + LimitAndOffsetClause GQLLimitAndOffsetClause // optional } -type GqlLinearGraphVariable struct { +type GQLLinearGraphVariable struct { VariableName *Ident Value Expr } -type GqlLetStatement struct { +type GQLLetStatement struct { // pos = Let.pos // end = if len(LinearGraphVariableList) > 0 then LinearGraphVariableList[$].end // else Let + 3 Let token.Pos - LinearGraphVariableList []*GqlLinearGraphVariable + LinearGraphVariableList []*GQLLinearGraphVariable } // ================================================================================ @@ -2796,34 +2798,34 @@ type GqlLetStatement struct { // // ================================================================================ -// GqlGraphPattern represents is the toplevel node of GQL graph patterns. -type GqlGraphPattern struct { - // pos = GqlTopLevelPathPattern[0].pos +// GQLGraphPattern represents is the toplevel node of GQL graph patterns. +type GQLGraphPattern struct { + // pos = GQLTopLevelPathPattern[0].pos // end = (WhereClause ?? PathPatternList[$]).end - PathPatternList []*GqlTopLevelPathPattern + PathPatternList []*GQLTopLevelPathPattern WhereClause *Where // optional } -// GqlTopLevelPathPattern is a PathPattern optionally prefixed by PathSearchPrefixOrPathMode. -type GqlTopLevelPathPattern struct { +// GQLTopLevelPathPattern is a PathPattern optionally prefixed by PathSearchPrefixOrPathMode. +type GQLTopLevelPathPattern struct { // pos = (PathSearchPrefixOrPathMode ?? PathPattern).pos // end = PathPattern.end - PathSearchPrefixOrPathMode GqlPathSearchPrefixOrPathMode // optional - PathPattern *GqlPathPattern + PathSearchPrefixOrPathMode GQLPathSearchPrefixOrPathMode // optional + PathPattern *GQLPathPattern } -// GqlPathSearchPrefixOrPathMode represents `{ path_search_prefix | path_mode }` -type GqlPathSearchPrefixOrPathMode interface { +// GQLPathSearchPrefixOrPathMode represents `{ path_search_prefix | path_mode }` +type GQLPathSearchPrefixOrPathMode interface { Node - isGqlPathSearchPrefixOrPathMode() + isGQLPathSearchPrefixOrPathMode() } -func (*GqlPathMode) isGqlPathSearchPrefixOrPathMode() {} -func (*GqlPathSearchPrefix) isGqlPathSearchPrefixOrPathMode() {} +func (*GQLPathMode) isGQLPathSearchPrefixOrPathMode() {} +func (*GQLPathSearchPrefix) isGQLPathSearchPrefixOrPathMode() {} -// GqlEdgePattern represents edge pattern nodes. +// GQLEdgePattern represents edge pattern nodes. // // edge_pattern: // { @@ -2834,51 +2836,51 @@ func (*GqlPathSearchPrefix) isGqlPathSearchPrefixOrPathMode() {} // abbreviated_edge_left | // abbreviated_edge_right // } -type GqlEdgePattern interface { - GqlElementPattern - isGqlEdgePattern() +type GQLEdgePattern interface { + GQLElementPattern + isGQLEdgePattern() } -func (*GqlAbbreviatedEdgeLeft) isGqlEdgePattern() {} -func (*GqlAbbreviatedEdgeAny) isGqlEdgePattern() {} -func (*GqlFullEdgeRight) isGqlEdgePattern() {} -func (*GqlFullEdgeLeft) isGqlEdgePattern() {} -func (*GqlFullEdgeAny) isGqlEdgePattern() {} -func (*GqlAbbreviatedEdgeRight) isGqlEdgePattern() {} +func (*GQLAbbreviatedEdgeLeft) isGQLEdgePattern() {} +func (*GQLAbbreviatedEdgeAny) isGQLEdgePattern() {} +func (*GQLFullEdgeRight) isGQLEdgePattern() {} +func (*GQLFullEdgeLeft) isGQLEdgePattern() {} +func (*GQLFullEdgeAny) isGQLEdgePattern() {} +func (*GQLAbbreviatedEdgeRight) isGQLEdgePattern() {} -// GqlFullEdgeAny is node representing`-[pattern_filler]-` . -type GqlFullEdgeAny struct { +// GQLFullEdgeAny is node representing`-[pattern_filler]-` . +type GQLFullEdgeAny struct { // pos = First.pos // end = Last.pos + 1 First, Last token.Pos - PatternFiller *GqlPatternFiller + PatternFiller *GQLPatternFiller } -type GqlFullEdgeLeft struct { +type GQLFullEdgeLeft struct { // pos = First // end = Last + 1 First token.Pos // position of "<" Last token.Pos // position of the last "-" - PatternFiller *GqlPatternFiller + PatternFiller *GQLPatternFiller } -type GqlFullEdgeRight struct { +type GQLFullEdgeRight struct { // pos = First // end = Last + 1 First token.Pos // position of the first "-" Last token.Pos // position of ">" - PatternFiller *GqlPatternFiller + PatternFiller *GQLPatternFiller } -type GqlAbbreviatedEdgeAny struct { +type GQLAbbreviatedEdgeAny struct { // pos = Hyphen // end = Hyphen +1 Hyphen token.Pos // position of "-" } -type GqlAbbreviatedEdgeLeft struct { +type GQLAbbreviatedEdgeLeft struct { // pos = First // end = Last + 1 @@ -2886,7 +2888,7 @@ type GqlAbbreviatedEdgeLeft struct { Last token.Pos // position of "-" } -type GqlAbbreviatedEdgeRight struct { +type GQLAbbreviatedEdgeRight struct { // pos = First // end = Last + 1 @@ -2894,36 +2896,36 @@ type GqlAbbreviatedEdgeRight struct { Last token.Pos // position of ">" } -type GqlQuantifiablePathTerm struct { +type GQLQuantifiablePathTerm struct { // pos = (Hint ?? PathTerm).pos // end = (Quantifier ?? PathTerm).end Hint *Hint // optional - PathTerm GqlPathTerm - Quantifier GqlQuantifier // optional + PathTerm GQLPathTerm + Quantifier GQLQuantifier // optional } -type GqlPathPattern struct { +type GQLPathPattern struct { // pos = PathTermList[0].pos // end = PathTermList[$].end - PathTermList []*GqlQuantifiablePathTerm + PathTermList []*GQLQuantifiablePathTerm } -type GqlPathTerm interface { +type GQLPathTerm interface { Node - isGqlPathTerm() + isGQLPathTerm() } -func (*GqlSubpathPattern) isGqlPathTerm() {} -func (*GqlNodePattern) isGqlPathTerm() {} -func (*GqlAbbreviatedEdgeRight) isGqlPathTerm() {} -func (*GqlAbbreviatedEdgeLeft) isGqlPathTerm() {} -func (*GqlAbbreviatedEdgeAny) isGqlPathTerm() {} -func (*GqlFullEdgeRight) isGqlPathTerm() {} -func (*GqlFullEdgeLeft) isGqlPathTerm() {} -func (*GqlFullEdgeAny) isGqlPathTerm() {} +func (*GQLSubpathPattern) isGQLPathTerm() {} +func (*GQLNodePattern) isGQLPathTerm() {} +func (*GQLAbbreviatedEdgeRight) isGQLPathTerm() {} +func (*GQLAbbreviatedEdgeLeft) isGQLPathTerm() {} +func (*GQLAbbreviatedEdgeAny) isGQLPathTerm() {} +func (*GQLFullEdgeRight) isGQLPathTerm() {} +func (*GQLFullEdgeLeft) isGQLPathTerm() {} +func (*GQLFullEdgeAny) isGQLPathTerm() {} -type GqlWhereClause struct { +type GQLWhereClause struct { // pos = Where // end = BoolExpression.end @@ -2931,42 +2933,42 @@ type GqlWhereClause struct { BoolExpression Expr } -type GqlElementPattern interface { +type GQLElementPattern interface { Node - GqlPathTerm - isGqlElementPattern() + GQLPathTerm + isGQLElementPattern() } -func (*GqlFullEdgeAny) isGqlElementPattern() {} -func (*GqlFullEdgeLeft) isGqlElementPattern() {} -func (*GqlFullEdgeRight) isGqlElementPattern() {} -func (*GqlAbbreviatedEdgeAny) isGqlElementPattern() {} -func (*GqlAbbreviatedEdgeLeft) isGqlElementPattern() {} -func (*GqlAbbreviatedEdgeRight) isGqlElementPattern() {} +func (*GQLFullEdgeAny) isGQLElementPattern() {} +func (*GQLFullEdgeLeft) isGQLElementPattern() {} +func (*GQLFullEdgeRight) isGQLElementPattern() {} +func (*GQLAbbreviatedEdgeAny) isGQLElementPattern() {} +func (*GQLAbbreviatedEdgeLeft) isGQLElementPattern() {} +func (*GQLAbbreviatedEdgeRight) isGQLElementPattern() {} -type GqlPathMode struct { +type GQLPathMode struct { // pos = ModeToken.pos // end = (PathOrPathsToken ?? ModeToken).end - Mode GqlPathModeEnum + Mode GQLPathModeEnum ModeToken *Ident PathOrPathsToken *Ident // optional } /* - type GqlQuantifiedPathPrimary struct { + type GQLQuantifiedPathPrimary struct { PathPrimary } */ -type GqlQuantifier interface { +type GQLQuantifier interface { Node - isGqlQuantifier() + isGQLQuantifier() } -func (g *GqlFixedQuantifier) isGqlQuantifier() {} -func (g *GqlBoundedQuantifier) isGqlQuantifier() {} +func (g *GQLFixedQuantifier) isGQLQuantifier() {} +func (g *GQLBoundedQuantifier) isGQLQuantifier() {} -type GqlFixedQuantifier struct { +type GQLFixedQuantifier struct { // pos = LBrace // end = RBrace + 1 @@ -2974,7 +2976,7 @@ type GqlFixedQuantifier struct { Bound IntValue } -type GqlBoundedQuantifier struct { +type GQLBoundedQuantifier struct { // pos = LBrace // end = RBrace + 1 LBrace, RBrace token.Pos @@ -2982,22 +2984,22 @@ type GqlBoundedQuantifier struct { UpperBound IntValue } -type GqlSubpathPattern struct { +type GQLSubpathPattern struct { // pos = LParen // end = RParen + 1 LParen, RParen token.Pos // position of "(" and ")" - PathMode *GqlPathMode // optional - PathPattern *GqlPathPattern + PathMode *GQLPathMode // optional + PathPattern *GQLPathPattern WhereClause *Where // optional } -type GqlNodePattern struct { +type GQLNodePattern struct { // pos = LParen // end = RParen + 1 LParen, RParen token.Pos - PatternFiller *GqlPatternFiller + PatternFiller *GQLPatternFiller } // EdgePattern TODO @@ -3020,26 +3022,26 @@ type EdgePattern interface { */ -type GqlPatternFiller struct { +type GQLPatternFiller struct { // pos = (Hint ?? GraphPatternVariable ?? IsLabelCondition ?? Filter).pos // end = (Filter ?? IsLabelCondition ?? GraphPatternVariable ?? Hint).end // Hint is graph element hint which is a table hint. Hint *Hint // optional GraphPatternVariable *Ident // optional - IsLabelCondition *GqlIsLabelCondition // optional - Filter GqlPatternFillerFilter // optional + IsLabelCondition *GQLIsLabelCondition // optional + Filter GQLPatternFillerFilter // optional } -type GqlIsLabelCondition struct { +type GQLIsLabelCondition struct { // pos = IsOrColon // end = LabelExpression.end IsOrColon token.Pos - LabelExpression GqlLabelExpression + LabelExpression GQLLabelExpression } -// GqlLabelExpression represents +// GQLLabelExpression represents // // label_expression: // { @@ -3050,48 +3052,48 @@ type GqlIsLabelCondition struct { // } // // Note: Spanner Graph documentation don't say about paren expression, but there is. -type GqlLabelExpression interface { +type GQLLabelExpression interface { Node - isGqlLabelExpression() + isGQLLabelExpression() } -func (g *GqlLabelParenExpression) isGqlLabelExpression() {} -func (g *GqlLabelOrExpression) isGqlLabelExpression() {} -func (g *GqlLabelAndExpression) isGqlLabelExpression() {} -func (g *GqlLabelNotExpression) isGqlLabelExpression() {} -func (g *GqlLabelName) isGqlLabelExpression() {} +func (g *GQLLabelParenExpression) isGQLLabelExpression() {} +func (g *GQLLabelOrExpression) isGQLLabelExpression() {} +func (g *GQLLabelAndExpression) isGQLLabelExpression() {} +func (g *GQLLabelNotExpression) isGQLLabelExpression() {} +func (g *GQLLabelName) isGQLLabelExpression() {} -type GqlLabelOrExpression struct { +type GQLLabelOrExpression struct { // pos = LParen // end = RParen - Left, Right GqlLabelExpression + Left, Right GQLLabelExpression } -type GqlLabelParenExpression struct { +type GQLLabelParenExpression struct { // pos = LParen // end = RParen + 1 LParen, RParen token.Pos - LabelExpr GqlLabelExpression + LabelExpr GQLLabelExpression } -type GqlLabelAndExpression struct { +type GQLLabelAndExpression struct { // pos = Left.pos // end = Right.end - Left, Right GqlLabelExpression + Left, Right GQLLabelExpression } -type GqlLabelNotExpression struct { +type GQLLabelNotExpression struct { // pos = Not // end = LabelExpression.end Not token.Pos // position of "!" - LabelExpression GqlLabelExpression + LabelExpression GQLLabelExpression } -type GqlLabelName struct { +type GQLLabelName struct { // pos = StartPos // end = if IsPercent then StartPos + 1 // else LabelName.end @@ -3101,27 +3103,27 @@ type GqlLabelName struct { LabelName *Ident } -// GqlPatternFillerFilter represents -type GqlPatternFillerFilter interface { +// GQLPatternFillerFilter represents +type GQLPatternFillerFilter interface { Node - isGqlPatternFillerFilter() + isGQLPatternFillerFilter() } -func (g *GqlPropertyFilters) isGqlPatternFillerFilter() {} -func (g *GqlWhereClause) isGqlPatternFillerFilter() {} -func (w *Where) isGqlPatternFillerFilter() {} +func (g *GQLPropertyFilters) isGQLPatternFillerFilter() {} +func (g *GQLWhereClause) isGQLPatternFillerFilter() {} +func (w *Where) isGQLPatternFillerFilter() {} -type GqlPropertyFilters struct { +type GQLPropertyFilters struct { // pos = LBrace // end = RBrace + 1 LBrace token.Pos // position of "{" - PropertyFilterElemList []*GqlElementProperty + PropertyFilterElemList []*GQLElementProperty RBrace token.Pos // position of "}" } -// GqlElementProperty represents an element of GqlPropertyFilters. -type GqlElementProperty struct { +// GQLElementProperty represents an element of GQLPropertyFilters. +type GQLElementProperty struct { // pos = ElementPropertyName.pos // end = ElementPropertyValue.pos @@ -3129,14 +3131,14 @@ type GqlElementProperty struct { ElementPropertyValue Expr } -// GqlPathSearchPrefix represents +// GQLPathSearchPrefix represents // // `{"ALL" | "ANY" | "ANY SHORTEST"}`. -type GqlPathSearchPrefix struct { +type GQLPathSearchPrefix struct { // pos = StartPos // end = LastEnd StartPos token.Pos LastEnd token.Pos // end of last token - SearchPrefix GqlSearchPrefixEnum + SearchPrefix GQLSearchPrefixEnum } diff --git a/ast/ast_test.go b/ast/ast_test.go index 4265cd08..9d00b70b 100644 --- a/ast/ast_test.go +++ b/ast/ast_test.go @@ -24,7 +24,7 @@ func TestStatement(t *testing.T) { Statement(&Grant{}).isStatement() Statement(&Revoke{}).isStatement() - Statement(&GqlGraphQuery{}).isStatement() + Statement(&GQLGraphQuery{}).isStatement() } func TestQueryExpr(t *testing.T) { diff --git a/ast/const.go b/ast/const.go index 83f16d39..0b6bd7b8 100644 --- a/ast/const.go +++ b/ast/const.go @@ -131,43 +131,43 @@ const ( InsertOrTypeIgnore InsertOrType = "IGNORE" ) -type GqlAllOrDistinctEnum int +type GQLAllOrDistinctEnum int const ( - GqlAllOrDistinctImplicitAll GqlAllOrDistinctEnum = iota - GqlAllOrDistinctAll = iota - GqlAllOrDistinctDistinct + GQLAllOrDistinctImplicitAll GQLAllOrDistinctEnum = iota + GQLAllOrDistinctAll = iota + GQLAllOrDistinctDistinct ) -type GqlSetOperatorEnum int +type GQLSetOperatorEnum int const ( - GqlSetOperatorUnion GqlSetOperatorEnum = iota - GqlSetOperatorIntersect - GqlSetOperatorExcept + GQLSetOperatorUnion GQLSetOperatorEnum = iota + GQLSetOperatorIntersect + GQLSetOperatorExcept ) -type GqlDirection string +type GQLDirection string const ( - GqlSortOrderUnspecified GqlDirection = "" - GqlSortOrderAsc GqlDirection = "ASC" - GqlSortOrderAscending GqlDirection = "ASCENDING" - GqlSortOrderDesc GqlDirection = "DESC" - GqlSortOrderDescending GqlDirection = "DESCENDING" + GQLSortOrderUnspecified GQLDirection = "" + GQLSortOrderAsc GQLDirection = "ASC" + GQLSortOrderAscending GQLDirection = "ASCENDING" + GQLSortOrderDesc GQLDirection = "DESC" + GQLSortOrderDescending GQLDirection = "DESCENDING" ) -type GqlPathModeEnum int +type GQLPathModeEnum int const ( - GqlPathModeWalk GqlPathModeEnum = iota - GqlPathModeTrail + GQLPathModeWalk GQLPathModeEnum = iota + GQLPathModeTrail ) -type GqlSearchPrefixEnum int +type GQLSearchPrefixEnum int const ( - GqlPathSearchPrefixAll GqlSearchPrefixEnum = iota - GqlPathSearchPrefixAny - GqlPathSearchPrefixAnyShortest + GQLPathSearchPrefixAll GQLSearchPrefixEnum = iota + GQLPathSearchPrefixAny + GQLPathSearchPrefixAnyShortest ) diff --git a/ast/pos.go b/ast/pos.go index 2b4d295f..ef562e46 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -295,8 +295,8 @@ func (s *SubQueryInCondition) End() token.Pos { return s.Rparen + 1 } func (v *ValuesInCondition) Pos() token.Pos { return v.Lparen } func (v *ValuesInCondition) End() token.Pos { return v.Rparen + 1 } -func (g *GqlSubQueryInCondition) Pos() token.Pos { return g.LBrace } -func (g *GqlSubQueryInCondition) End() token.Pos { return g.RBrace + 1 } +func (g *GQLSubQueryInCondition) Pos() token.Pos { return g.LBrace } +func (g *GQLSubQueryInCondition) End() token.Pos { return g.RBrace + 1 } func (i *IsNullExpr) Pos() token.Pos { return i.Left.Pos() } func (i *IsNullExpr) End() token.Pos { return i.Null + 4 } @@ -495,14 +495,14 @@ func (c *CastNumValue) End() token.Pos { return c.Rparen + 1 } // // ================================================================================ -func (v *ValueGqlSubQuery) Pos() token.Pos { return v.Array } -func (v *ValueGqlSubQuery) End() token.Pos { return v.Query.End() } +func (v *ValueGQLSubQuery) Pos() token.Pos { return v.Array } +func (v *ValueGQLSubQuery) End() token.Pos { return v.Query.End() } -func (a *ArrayGqlSubQuery) Pos() token.Pos { return a.Array } -func (a *ArrayGqlSubQuery) End() token.Pos { return a.RBrace + 1 } +func (a *ArrayGQLSubQuery) Pos() token.Pos { return a.Array } +func (a *ArrayGQLSubQuery) End() token.Pos { return a.RBrace + 1 } -func (e *ExistsGqlSubQuery) Pos() token.Pos { return e.Exists } -func (e *ExistsGqlSubQuery) End() token.Pos { return e.RBrace + 1 } +func (e *ExistsGQLSubQuery) Pos() token.Pos { return e.Exists } +func (e *ExistsGQLSubQuery) End() token.Pos { return e.RBrace + 1 } // ================================================================================ // @@ -899,115 +899,115 @@ func (o *SequenceOptions) End() token.Pos { return o.Rparen + 1 } // GQL -func (g *GqlGraphQuery) Pos() token.Pos { return g.GraphClause.Pos() } -func (g *GqlGraphQuery) End() token.Pos { return g.MultiLinearQueryStatement.End() } +func (g *GQLGraphQuery) Pos() token.Pos { return g.GraphClause.Pos() } +func (g *GQLGraphQuery) End() token.Pos { return g.MultiLinearQueryStatement.End() } -func (g *GqlQueryExpr) Pos() token.Pos { +func (g *GQLQueryExpr) Pos() token.Pos { return firstValidPos(g.GraphClause, g.MultiLinearQueryStatement) } -func (g *GqlQueryExpr) End() token.Pos { return g.MultiLinearQueryStatement.End() } +func (g *GQLQueryExpr) End() token.Pos { return g.MultiLinearQueryStatement.End() } -func (s *GqlGraphClause) Pos() token.Pos { return s.Graph } -func (s *GqlGraphClause) End() token.Pos { return s.PropertyGraphName.End() } +func (s *GQLGraphClause) Pos() token.Pos { return s.Graph } +func (s *GQLGraphClause) End() token.Pos { return s.PropertyGraphName.End() } -func (s *GqlMultiLinearQueryStatement) Pos() token.Pos { +func (s *GQLMultiLinearQueryStatement) Pos() token.Pos { return firstPos(s.LinearQueryStatementList) } -func (s *GqlMultiLinearQueryStatement) End() token.Pos { return lastEnd(s.LinearQueryStatementList) } +func (s *GQLMultiLinearQueryStatement) End() token.Pos { return lastEnd(s.LinearQueryStatementList) } -func (s *GqlSimpleLinearQueryStatement) Pos() token.Pos { +func (s *GQLSimpleLinearQueryStatement) Pos() token.Pos { return firstPos(s.PrimitiveQueryStatementList) } -func (s *GqlSimpleLinearQueryStatement) End() token.Pos { +func (s *GQLSimpleLinearQueryStatement) End() token.Pos { return lastEnd(s.PrimitiveQueryStatementList) } -func (s *GqlCompositeLinearQueryStatement) Pos() token.Pos { +func (s *GQLCompositeLinearQueryStatement) Pos() token.Pos { return s.HeadSimpleLinearQueryStatement.Pos() } -func (s *GqlCompositeLinearQueryStatement) End() token.Pos { +func (s *GQLCompositeLinearQueryStatement) End() token.Pos { return lastEnd(s.TailSimpleLinearQueryStatementList) } -func (s *GqlLinearGraphVariable) Pos() token.Pos { return s.VariableName.Pos() } -func (s *GqlLinearGraphVariable) End() token.Pos { return s.Value.End() } +func (s *GQLLinearGraphVariable) Pos() token.Pos { return s.VariableName.Pos() } +func (s *GQLLinearGraphVariable) End() token.Pos { return s.Value.End() } -func (g *GqlSimpleLinearQueryStatementWithSetOperator) Pos() token.Pos { return g.StartPos } -func (g *GqlSimpleLinearQueryStatementWithSetOperator) End() token.Pos { return g.Statement.End() } +func (g *GQLSimpleLinearQueryStatementWithSetOperator) Pos() token.Pos { return g.StartPos } +func (g *GQLSimpleLinearQueryStatementWithSetOperator) End() token.Pos { return g.Statement.End() } // GQL statements -func (g *GqlMatchStatement) Pos() token.Pos { +func (g *GQLMatchStatement) Pos() token.Pos { if !g.Optional.Invalid() { return g.Optional } else { return g.Match } } -func (g *GqlMatchStatement) End() token.Pos { +func (g *GQLMatchStatement) End() token.Pos { return g.GraphPattern.End() } -func (g *GqlLimitClause) Pos() token.Pos { return g.Limit.Pos() } -func (g *GqlLimitClause) End() token.Pos { return g.Limit.End() } +func (g *GQLLimitClause) Pos() token.Pos { return g.Limit.Pos() } +func (g *GQLLimitClause) End() token.Pos { return g.Limit.End() } -func (g *GqlOffsetClause) Pos() token.Pos { return g.Offset.Pos() } -func (g *GqlOffsetClause) End() token.Pos { return g.Offset.End() } +func (g *GQLOffsetClause) Pos() token.Pos { return g.Offset.Pos() } +func (g *GQLOffsetClause) End() token.Pos { return g.Offset.End() } -func (g *GqlLimitWithOffsetClause) Pos() token.Pos { return g.Limit.Pos() } -func (g *GqlLimitWithOffsetClause) End() token.Pos { return g.Offset.End() } +func (g *GQLLimitWithOffsetClause) Pos() token.Pos { return g.Limit.Pos() } +func (g *GQLLimitWithOffsetClause) End() token.Pos { return g.Offset.End() } -func (g *GqlFilterStatement) Pos() token.Pos { return g.Filter } -func (g *GqlFilterStatement) End() token.Pos { return g.Expr.End() } +func (g *GQLFilterStatement) Pos() token.Pos { return g.Filter } +func (g *GQLFilterStatement) End() token.Pos { return g.Expr.End() } -func (g *GqlForStatement) Pos() token.Pos { return g.For } -func (g *GqlForStatement) End() token.Pos { +func (g *GQLForStatement) Pos() token.Pos { return g.For } +func (g *GQLForStatement) End() token.Pos { return firstValidPos(g.WithOffsetClause, g.ArrayExpression) } -func (g *GqlWithOffsetClause) Pos() token.Pos { return g.With } -func (g *GqlWithOffsetClause) End() token.Pos { +func (g *GQLWithOffsetClause) Pos() token.Pos { return g.With } +func (g *GQLWithOffsetClause) End() token.Pos { if g.OffsetName != nil { return g.OffsetName.End() } return g.Offset + 6 } -func (g *GqlLimitStatement) Pos() token.Pos { return g.Limit } -func (g *GqlLimitStatement) End() token.Pos { return g.Count.End() } +func (g *GQLLimitStatement) Pos() token.Pos { return g.Limit } +func (g *GQLLimitStatement) End() token.Pos { return g.Count.End() } -func (g *GqlOffsetStatement) Pos() token.Pos { return g.Offset } -func (g *GqlOffsetStatement) End() token.Pos { return g.Count.End() } +func (g *GQLOffsetStatement) Pos() token.Pos { return g.Offset } +func (g *GQLOffsetStatement) End() token.Pos { return g.Count.End() } -func (g *GqlOrderByStatement) Pos() token.Pos { return g.Order } -func (g *GqlOrderByStatement) End() token.Pos { return lastEnd(g.OrderBySpecificationList) } +func (g *GQLOrderByStatement) Pos() token.Pos { return g.Order } +func (g *GQLOrderByStatement) End() token.Pos { return lastEnd(g.OrderBySpecificationList) } -func (g *GqlOrderBySpecification) Pos() token.Pos { return g.Expr.Pos() } -func (g *GqlOrderBySpecification) End() token.Pos { +func (g *GQLOrderBySpecification) Pos() token.Pos { return g.Expr.Pos() } +func (g *GQLOrderBySpecification) End() token.Pos { if g.DirectionPos != token.InvalidPos { return g.DirectionPos + token.Pos(len(string(g.Direction))) } return firstValidEnd(g.CollationSpecification, g.Expr) } -func (g *GqlCollationSpecification) Pos() token.Pos { return g.Collate } -func (g *GqlCollationSpecification) End() token.Pos { return g.Specification.End() } +func (g *GQLCollationSpecification) Pos() token.Pos { return g.Collate } +func (g *GQLCollationSpecification) End() token.Pos { return g.Specification.End() } -func (g *GqlWithStatement) Pos() token.Pos { return g.With } -func (g *GqlWithStatement) End() token.Pos { +func (g *GQLWithStatement) Pos() token.Pos { return g.With } +func (g *GQLWithStatement) End() token.Pos { return firstValidPos(g.GroupByClause, lastElem(g.ReturnItemList)) } -func (g *GqlReturnStatement) Pos() token.Pos { +func (g *GQLReturnStatement) Pos() token.Pos { return g.Return } -func (g *GqlReturnStatement) End() token.Pos { +func (g *GQLReturnStatement) End() token.Pos { return firstValidEnd(g.LimitAndOffsetClause, g.OrderByClause, g.GroupByClause, lastElem(g.ReturnItemList)) } -func (s *GqlLetStatement) Pos() token.Pos { return s.Let } -func (s *GqlLetStatement) End() token.Pos { +func (s *GQLLetStatement) Pos() token.Pos { return s.Let } +func (s *GQLLetStatement) End() token.Pos { if len(s.LinearGraphVariableList) > 0 { return lastEnd(s.LinearGraphVariableList) } @@ -1016,93 +1016,93 @@ func (s *GqlLetStatement) End() token.Pos { // GQL graph patterns -func (g *GqlGraphPattern) Pos() token.Pos { return firstPos(g.PathPatternList) } -func (g *GqlGraphPattern) End() token.Pos { +func (g *GQLGraphPattern) Pos() token.Pos { return firstPos(g.PathPatternList) } +func (g *GQLGraphPattern) End() token.Pos { return firstValidPos(g.WhereClause, lastElem(g.PathPatternList)) } -func (g *GqlTopLevelPathPattern) Pos() token.Pos { +func (g *GQLTopLevelPathPattern) Pos() token.Pos { return firstValidPos(g.PathSearchPrefixOrPathMode, g.PathPattern) } -func (g *GqlTopLevelPathPattern) End() token.Pos { return g.PathPattern.End() } +func (g *GQLTopLevelPathPattern) End() token.Pos { return g.PathPattern.End() } -func (g *GqlFullEdgeAny) Pos() token.Pos { return g.First } -func (g *GqlFullEdgeAny) End() token.Pos { return g.Last + 1 } +func (g *GQLFullEdgeAny) Pos() token.Pos { return g.First } +func (g *GQLFullEdgeAny) End() token.Pos { return g.Last + 1 } -func (g *GqlFullEdgeLeft) Pos() token.Pos { return g.First } -func (g *GqlFullEdgeLeft) End() token.Pos { return g.Last + 1 } +func (g *GQLFullEdgeLeft) Pos() token.Pos { return g.First } +func (g *GQLFullEdgeLeft) End() token.Pos { return g.Last + 1 } -func (g *GqlFullEdgeRight) Pos() token.Pos { return g.First } -func (g *GqlFullEdgeRight) End() token.Pos { return g.Last + 1 } +func (g *GQLFullEdgeRight) Pos() token.Pos { return g.First } +func (g *GQLFullEdgeRight) End() token.Pos { return g.Last + 1 } -func (g *GqlAbbreviatedEdgeAny) Pos() token.Pos { return g.Hyphen } -func (g *GqlAbbreviatedEdgeAny) End() token.Pos { return g.Hyphen + 1 } +func (g *GQLAbbreviatedEdgeAny) Pos() token.Pos { return g.Hyphen } +func (g *GQLAbbreviatedEdgeAny) End() token.Pos { return g.Hyphen + 1 } -func (g *GqlAbbreviatedEdgeLeft) Pos() token.Pos { return g.First } -func (g *GqlAbbreviatedEdgeLeft) End() token.Pos { return g.Last + 1 } +func (g *GQLAbbreviatedEdgeLeft) Pos() token.Pos { return g.First } +func (g *GQLAbbreviatedEdgeLeft) End() token.Pos { return g.Last + 1 } -func (g *GqlAbbreviatedEdgeRight) Pos() token.Pos { return g.First } -func (g *GqlAbbreviatedEdgeRight) End() token.Pos { return g.Last + 1 } +func (g *GQLAbbreviatedEdgeRight) Pos() token.Pos { return g.First } +func (g *GQLAbbreviatedEdgeRight) End() token.Pos { return g.Last + 1 } -func (g *GqlQuantifiablePathTerm) Pos() token.Pos { return firstValidPos(g.Hint, g.PathTerm) } -func (g *GqlQuantifiablePathTerm) End() token.Pos { return firstValidEnd(g.Quantifier, g.PathTerm) } +func (g *GQLQuantifiablePathTerm) Pos() token.Pos { return firstValidPos(g.Hint, g.PathTerm) } +func (g *GQLQuantifiablePathTerm) End() token.Pos { return firstValidEnd(g.Quantifier, g.PathTerm) } -func (g *GqlPathPattern) Pos() token.Pos { return firstPos(g.PathTermList) } -func (g *GqlPathPattern) End() token.Pos { return lastEnd(g.PathTermList) } +func (g *GQLPathPattern) Pos() token.Pos { return firstPos(g.PathTermList) } +func (g *GQLPathPattern) End() token.Pos { return lastEnd(g.PathTermList) } -func (g *GqlWhereClause) Pos() token.Pos { return g.Where } -func (g *GqlWhereClause) End() token.Pos { return g.BoolExpression.End() } +func (g *GQLWhereClause) Pos() token.Pos { return g.Where } +func (g *GQLWhereClause) End() token.Pos { return g.BoolExpression.End() } -func (g *GqlPathMode) Pos() token.Pos { return g.ModeToken.Pos() } -func (g *GqlPathMode) End() token.Pos { return firstValidEnd(g.PathOrPathsToken, g.ModeToken) } +func (g *GQLPathMode) Pos() token.Pos { return g.ModeToken.Pos() } +func (g *GQLPathMode) End() token.Pos { return firstValidEnd(g.PathOrPathsToken, g.ModeToken) } -func (g *GqlFixedQuantifier) Pos() token.Pos { return g.LBrace } -func (g *GqlFixedQuantifier) End() token.Pos { return g.RBrace + 1 } +func (g *GQLFixedQuantifier) Pos() token.Pos { return g.LBrace } +func (g *GQLFixedQuantifier) End() token.Pos { return g.RBrace + 1 } -func (g *GqlBoundedQuantifier) Pos() token.Pos { return g.LBrace } -func (g *GqlBoundedQuantifier) End() token.Pos { return g.RBrace + 1 } +func (g *GQLBoundedQuantifier) Pos() token.Pos { return g.LBrace } +func (g *GQLBoundedQuantifier) End() token.Pos { return g.RBrace + 1 } -func (g *GqlSubpathPattern) Pos() token.Pos { return g.LParen } -func (g *GqlSubpathPattern) End() token.Pos { return g.RParen + 1 } +func (g *GQLSubpathPattern) Pos() token.Pos { return g.LParen } +func (g *GQLSubpathPattern) End() token.Pos { return g.RParen + 1 } -func (g *GqlNodePattern) Pos() token.Pos { return g.LParen } -func (g *GqlNodePattern) End() token.Pos { return g.RParen + 1 } +func (g *GQLNodePattern) Pos() token.Pos { return g.LParen } +func (g *GQLNodePattern) End() token.Pos { return g.RParen + 1 } -func (g *GqlPatternFiller) Pos() token.Pos { +func (g *GQLPatternFiller) Pos() token.Pos { return firstValidPos(g.Hint, g.GraphPatternVariable, g.IsLabelCondition, g.Filter) } -func (g *GqlPatternFiller) End() token.Pos { +func (g *GQLPatternFiller) End() token.Pos { return firstValidEnd(g.Filter, g.IsLabelCondition, g.GraphPatternVariable, g.Hint) } -func (g *GqlIsLabelCondition) Pos() token.Pos { return g.IsOrColon } -func (g *GqlIsLabelCondition) End() token.Pos { return g.LabelExpression.End() } +func (g *GQLIsLabelCondition) Pos() token.Pos { return g.IsOrColon } +func (g *GQLIsLabelCondition) End() token.Pos { return g.LabelExpression.End() } -func (g *GqlLabelParenExpression) Pos() token.Pos { return g.LParen } -func (g *GqlLabelParenExpression) End() token.Pos { return g.RParen + 1 } +func (g *GQLLabelParenExpression) Pos() token.Pos { return g.LParen } +func (g *GQLLabelParenExpression) End() token.Pos { return g.RParen + 1 } -func (g *GqlLabelOrExpression) Pos() token.Pos { return g.Left.Pos() } -func (g *GqlLabelOrExpression) End() token.Pos { return g.Right.End() } +func (g *GQLLabelOrExpression) Pos() token.Pos { return g.Left.Pos() } +func (g *GQLLabelOrExpression) End() token.Pos { return g.Right.End() } -func (g *GqlLabelAndExpression) Pos() token.Pos { return g.Left.Pos() } -func (g *GqlLabelAndExpression) End() token.Pos { return g.Right.End() } +func (g *GQLLabelAndExpression) Pos() token.Pos { return g.Left.Pos() } +func (g *GQLLabelAndExpression) End() token.Pos { return g.Right.End() } -func (g *GqlLabelNotExpression) Pos() token.Pos { return g.Not } -func (g *GqlLabelNotExpression) End() token.Pos { return g.LabelExpression.End() } +func (g *GQLLabelNotExpression) Pos() token.Pos { return g.Not } +func (g *GQLLabelNotExpression) End() token.Pos { return g.LabelExpression.End() } -func (g *GqlLabelName) Pos() token.Pos { return g.StartPos } -func (g *GqlLabelName) End() token.Pos { +func (g *GQLLabelName) Pos() token.Pos { return g.StartPos } +func (g *GQLLabelName) End() token.Pos { if g.IsPercent { return g.StartPos + 1 } return g.LabelName.End() } -func (g *GqlPropertyFilters) Pos() token.Pos { return g.LBrace } -func (g *GqlPropertyFilters) End() token.Pos { return g.RBrace + 1 } +func (g *GQLPropertyFilters) Pos() token.Pos { return g.LBrace } +func (g *GQLPropertyFilters) End() token.Pos { return g.RBrace + 1 } -func (g *GqlElementProperty) Pos() token.Pos { return g.ElementPropertyName.Pos() } -func (g *GqlElementProperty) End() token.Pos { return g.ElementPropertyValue.End() } +func (g *GQLElementProperty) Pos() token.Pos { return g.ElementPropertyName.Pos() } +func (g *GQLElementProperty) End() token.Pos { return g.ElementPropertyValue.End() } -func (p *GqlPathSearchPrefix) Pos() token.Pos { return p.StartPos } -func (p *GqlPathSearchPrefix) End() token.Pos { return p.LastEnd + 1 } +func (p *GQLPathSearchPrefix) Pos() token.Pos { return p.StartPos } +func (p *GQLPathSearchPrefix) End() token.Pos { return p.LastEnd + 1 } diff --git a/ast/sql.go b/ast/sql.go index d709cbc2..b2f4d3cf 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -418,7 +418,7 @@ func (v *ValuesInCondition) SQL() string { return sql } -func (g *GqlSubQueryInCondition) SQL() string { +func (g *GQLSubQueryInCondition) SQL() string { return "{" + g.Query.SQL() + "}" } @@ -758,15 +758,15 @@ func (c *CastNumValue) SQL() string { // // ================================================================================ -func (a *ArrayGqlSubQuery) SQL() string { +func (a *ArrayGQLSubQuery) SQL() string { return "ARRAY {\n" + a.Query.SQL() + "\n}" } -func (v *ValueGqlSubQuery) SQL() string { +func (v *ValueGQLSubQuery) SQL() string { return "VALUE {\n" + v.Query.SQL() + "\n}" } -func (v *ExistsGqlSubQuery) SQL() string { +func (v *ExistsGQLSubQuery) SQL() string { return "EXISTS {\n" + v.Query.SQL() + "\n}" } @@ -1411,25 +1411,25 @@ func (u *UpdateItem) SQL() string { // GQL -func (s *GqlGraphQuery) SQL() string { +func (s *GQLGraphQuery) SQL() string { return s.GraphClause.SQL() + "\n" + s.MultiLinearQueryStatement.SQL() } -func (g *GqlQueryExpr) SQL() string { +func (g *GQLQueryExpr) SQL() string { return sqlOpt("", g.GraphClause, "\n") + g.MultiLinearQueryStatement.SQL() } -func (s *GqlGraphClause) SQL() string { return "GRAPH " + s.PropertyGraphName.SQL() } +func (s *GQLGraphClause) SQL() string { return "GRAPH " + s.PropertyGraphName.SQL() } -func (s *GqlMultiLinearQueryStatement) SQL() string { +func (s *GQLMultiLinearQueryStatement) SQL() string { return sqlJoin(s.LinearQueryStatementList, "\nNEXT\n") } -func (s *GqlSimpleLinearQueryStatement) SQL() string { +func (s *GQLSimpleLinearQueryStatement) SQL() string { return sqlJoin(s.PrimitiveQueryStatementList, "\n") } -func (s *GqlCompositeLinearQueryStatement) SQL() string { +func (s *GQLCompositeLinearQueryStatement) SQL() string { sql := s.HeadSimpleLinearQueryStatement.SQL() if len(s.TailSimpleLinearQueryStatementList) > 0 { sql += "\n" + sqlJoin(s.TailSimpleLinearQueryStatementList, "\n") @@ -1437,21 +1437,21 @@ func (s *GqlCompositeLinearQueryStatement) SQL() string { return sql } -func (g *GqlSimpleLinearQueryStatementWithSetOperator) SQL() string { +func (g *GQLSimpleLinearQueryStatementWithSetOperator) SQL() string { var sql string switch g.SetOperator { - case GqlSetOperatorUnion: + case GQLSetOperatorUnion: sql += "UNION" - case GqlSetOperatorIntersect: + case GQLSetOperatorIntersect: sql += "INTERSECT" - case GqlSetOperatorExcept: + case GQLSetOperatorExcept: sql += "EXCEPT" } switch g.DistinctOrAll { - case GqlAllOrDistinctAll: + case GQLAllOrDistinctAll: sql += " " + "ALL" - case GqlAllOrDistinctDistinct: + case GQLAllOrDistinctDistinct: sql += " " + "DISTINCT" default: // no action @@ -1461,11 +1461,11 @@ func (g *GqlSimpleLinearQueryStatementWithSetOperator) SQL() string { return sql } -func (s *GqlLinearGraphVariable) SQL() string { return s.VariableName.SQL() + " = " + s.Value.SQL() } +func (s *GQLLinearGraphVariable) SQL() string { return s.VariableName.SQL() + " = " + s.Value.SQL() } // GQL statements -func (g *GqlMatchStatement) SQL() string { +func (g *GQLMatchStatement) SQL() string { var sql string if !g.Optional.Invalid() { sql = "OPTIONAL MATCH" @@ -1478,60 +1478,60 @@ func (g *GqlMatchStatement) SQL() string { return sql } -func (g *GqlLimitClause) SQL() string { return g.Limit.SQL() } +func (g *GQLLimitClause) SQL() string { return g.Limit.SQL() } -func (g *GqlOffsetClause) SQL() string { return g.Offset.SQL() } +func (g *GQLOffsetClause) SQL() string { return g.Offset.SQL() } -func (g *GqlLimitWithOffsetClause) SQL() string { return g.Limit.SQL() + " " + g.Offset.SQL() } +func (g *GQLLimitWithOffsetClause) SQL() string { return g.Limit.SQL() + " " + g.Offset.SQL() } -func (g *GqlFilterStatement) SQL() string { +func (g *GQLFilterStatement) SQL() string { if g.Where.Invalid() { return "FILTER " + g.Expr.SQL() } return "FILTER WHERE " + g.Expr.SQL() } -func (g *GqlForStatement) SQL() string { +func (g *GQLForStatement) SQL() string { return "FOR " + g.ElementName.SQL() + " IN " + g.ArrayExpression.SQL() + sqlOpt(" ", g.WithOffsetClause, "") } -func (g *GqlWithOffsetClause) SQL() string { +func (g *GQLWithOffsetClause) SQL() string { return "WITH OFFSET" + sqlOpt(" AS ", g.OffsetName, "") } -func (g *GqlLimitStatement) SQL() string { return "LIMIT " + g.Count.SQL() } +func (g *GQLLimitStatement) SQL() string { return "LIMIT " + g.Count.SQL() } -func (g *GqlOffsetStatement) SQL() string { +func (g *GQLOffsetStatement) SQL() string { if g.IsSkip { return "SKIP " + g.Count.SQL() } return "OFFSET " + g.Count.SQL() } -func (g *GqlOrderByStatement) SQL() string { +func (g *GQLOrderByStatement) SQL() string { return "ORDER BY " + sqlJoin(g.OrderBySpecificationList, ", ") } -func (g *GqlOrderBySpecification) SQL() string { +func (g *GQLOrderBySpecification) SQL() string { sql := g.Expr.SQL() + sqlOpt(" ", g.CollationSpecification, "") - if g.Direction != GqlSortOrderUnspecified { + if g.Direction != GQLSortOrderUnspecified { sql += " " + string(g.Direction) } return sql } -func (g *GqlCollationSpecification) SQL() string { +func (g *GQLCollationSpecification) SQL() string { return "COLLATE " + g.Specification.SQL() } -func (g *GqlWithStatement) SQL() string { +func (g *GQLWithStatement) SQL() string { var allOrDistinctStr string switch g.AllOrDistinct { - case GqlAllOrDistinctDistinct: + case GQLAllOrDistinctDistinct: allOrDistinctStr = "DISTINCT " - case GqlAllOrDistinctAll: + case GQLAllOrDistinctAll: allOrDistinctStr = "ALL " - case GqlAllOrDistinctImplicitAll: + case GQLAllOrDistinctImplicitAll: allOrDistinctStr = "" } return "WITH " + allOrDistinctStr + @@ -1539,16 +1539,16 @@ func (g *GqlWithStatement) SQL() string { sqlOpt(" ", g.GroupByClause, "") } -func (s *GqlLetStatement) SQL() string { return "LET " + sqlJoin(s.LinearGraphVariableList, ", ") } +func (s *GQLLetStatement) SQL() string { return "LET " + sqlJoin(s.LinearGraphVariableList, ", ") } -func (g *GqlReturnStatement) SQL() string { +func (g *GQLReturnStatement) SQL() string { sql := "RETURN " switch g.AllOrDistinct { - case GqlAllOrDistinctAll: + case GQLAllOrDistinctAll: sql += "ALL " - case GqlAllOrDistinctDistinct: + case GQLAllOrDistinctDistinct: sql += "DISTINCT " - case GqlAllOrDistinctImplicitAll: + case GQLAllOrDistinctImplicitAll: // empty } @@ -1561,52 +1561,52 @@ func (g *GqlReturnStatement) SQL() string { // GQL graph patterns -func (g *GqlGraphPattern) SQL() string { +func (g *GQLGraphPattern) SQL() string { return sqlJoin(g.PathPatternList, ", ") + sqlOpt(" ", g.WhereClause, "") } -func (g *GqlTopLevelPathPattern) SQL() string { +func (g *GQLTopLevelPathPattern) SQL() string { return sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() } -func (g *GqlFullEdgeAny) SQL() string { return "-[" + g.PatternFiller.SQL() + "]-" } +func (g *GQLFullEdgeAny) SQL() string { return "-[" + g.PatternFiller.SQL() + "]-" } -func (g *GqlFullEdgeLeft) SQL() string { return "<-[" + g.PatternFiller.SQL() + "]-" } +func (g *GQLFullEdgeLeft) SQL() string { return "<-[" + g.PatternFiller.SQL() + "]-" } -func (g *GqlFullEdgeRight) SQL() string { return "-[" + g.PatternFiller.SQL() + "]->" } +func (g *GQLFullEdgeRight) SQL() string { return "-[" + g.PatternFiller.SQL() + "]->" } -func (g *GqlAbbreviatedEdgeAny) SQL() string { return "-" } +func (g *GQLAbbreviatedEdgeAny) SQL() string { return "-" } -func (g *GqlAbbreviatedEdgeLeft) SQL() string { return "<-" } +func (g *GQLAbbreviatedEdgeLeft) SQL() string { return "<-" } -func (g *GqlAbbreviatedEdgeRight) SQL() string { return "->" } +func (g *GQLAbbreviatedEdgeRight) SQL() string { return "->" } -func (g *GqlQuantifiablePathTerm) SQL() string { +func (g *GQLQuantifiablePathTerm) SQL() string { return sqlOpt("", g.Hint, "") + g.PathTerm.SQL() + sqlOpt("", g.Quantifier, "") } -func (g *GqlPathPattern) SQL() string { return sqlJoin(g.PathTermList, "") } +func (g *GQLPathPattern) SQL() string { return sqlJoin(g.PathTermList, "") } -func (g *GqlWhereClause) SQL() string { return "WHERE " + g.BoolExpression.SQL() } +func (g *GQLWhereClause) SQL() string { return "WHERE " + g.BoolExpression.SQL() } -func (g *GqlPathMode) SQL() string { +func (g *GQLPathMode) SQL() string { switch g.Mode { - case GqlPathModeTrail: + case GQLPathModeTrail: return "TRAIL" - case GqlPathModeWalk: + case GQLPathModeWalk: return "WALK" default: - panic("UNKNOWN GqlPathMode") + panic("UNKNOWN GQLPathMode") } } -func (g *GqlFixedQuantifier) SQL() string { return "{" + g.Bound.SQL() + "}" } +func (g *GQLFixedQuantifier) SQL() string { return "{" + g.Bound.SQL() + "}" } -func (g *GqlBoundedQuantifier) SQL() string { +func (g *GQLBoundedQuantifier) SQL() string { return "{" + sqlOpt("", g.LowerBound, "") + "," + g.UpperBound.SQL() + "}" } -func (g *GqlSubpathPattern) SQL() string { +func (g *GQLSubpathPattern) SQL() string { return "(" + sqlOpt("", g.PathMode, " ") + g.PathPattern.SQL() + @@ -1614,9 +1614,9 @@ func (g *GqlSubpathPattern) SQL() string { ")" } -func (g *GqlNodePattern) SQL() string { return "(" + g.PatternFiller.SQL() + ")" } +func (g *GQLNodePattern) SQL() string { return "(" + g.PatternFiller.SQL() + ")" } -func (g *GqlPatternFiller) SQL() string { +func (g *GQLPatternFiller) SQL() string { sql := sqlOpt("", g.Hint, "") + sqlOpt("", g.GraphPatternVariable, "") + sqlOpt("", g.IsLabelCondition, "") @@ -1628,40 +1628,40 @@ func (g *GqlPatternFiller) SQL() string { return sql + sqlOpt(" ", g.Filter, "") } -func (g *GqlIsLabelCondition) SQL() string { return ":" + g.LabelExpression.SQL() } +func (g *GQLIsLabelCondition) SQL() string { return ":" + g.LabelExpression.SQL() } -func (g *GqlLabelParenExpression) SQL() string { return "(" + g.LabelExpr.SQL() + ")" } +func (g *GQLLabelParenExpression) SQL() string { return "(" + g.LabelExpr.SQL() + ")" } -func (g *GqlLabelOrExpression) SQL() string { return g.Left.SQL() + "|" + g.Right.SQL() } +func (g *GQLLabelOrExpression) SQL() string { return g.Left.SQL() + "|" + g.Right.SQL() } -func (g *GqlLabelAndExpression) SQL() string { return g.Left.SQL() + "&" + g.Right.SQL() } +func (g *GQLLabelAndExpression) SQL() string { return g.Left.SQL() + "&" + g.Right.SQL() } -func (g *GqlLabelNotExpression) SQL() string { return "!" + g.LabelExpression.SQL() } +func (g *GQLLabelNotExpression) SQL() string { return "!" + g.LabelExpression.SQL() } -func (g *GqlLabelName) SQL() string { +func (g *GQLLabelName) SQL() string { if g.IsPercent { return "%" } return g.LabelName.SQL() } -func (g *GqlPropertyFilters) SQL() string { +func (g *GQLPropertyFilters) SQL() string { return "{" + sqlJoin(g.PropertyFilterElemList, ", ") + "}" } -func (g *GqlElementProperty) SQL() string { +func (g *GQLElementProperty) SQL() string { return g.ElementPropertyName.SQL() + ": " + g.ElementPropertyValue.SQL() } -func (p *GqlPathSearchPrefix) SQL() string { +func (p *GQLPathSearchPrefix) SQL() string { switch p.SearchPrefix { - case GqlPathSearchPrefixAny: + case GQLPathSearchPrefixAny: return "ANY" - case GqlPathSearchPrefixAnyShortest: + case GQLPathSearchPrefixAnyShortest: return "ANY SHORTEST" - case GqlPathSearchPrefixAll: + case GQLPathSearchPrefixAll: return "ALL" default: - panic("invalid GqlPathSearchPrefix") + panic("invalid GQLPathSearchPrefix") } } diff --git a/parser.go b/parser.go index 49b88f84..cf9c267e 100644 --- a/parser.go +++ b/parser.go @@ -34,8 +34,8 @@ func (p *Parser) ParseStatement() (stmt ast.Statement, err error) { return } -// ParseGqlStatement parses a GQL statement. -func (p *Parser) ParseGqlStatement() (stmt ast.Statement, err error) { +// ParseGQLStatement parses a GQL statement. +func (p *Parser) ParseGQLStatement() (stmt ast.Statement, err error) { defer func() { if r := recover(); r != nil { stmt = nil @@ -48,15 +48,15 @@ func (p *Parser) ParseGqlStatement() (stmt ast.Statement, err error) { }() p.nextToken() - stmt = p.parseGqlQuery() + stmt = p.parseGQLQuery() if p.Token.Kind != token.TokenEOF { p.panicfAtToken(&p.Token, "expected token: , but: %s", p.Token.Kind) } return } -// ParseGqlStatement parses a GQL statement. -func (p *Parser) ParseGqlPathPattern() (stmt *ast.GqlPathPattern, err error) { +// ParseGQLPathPattern parses a GQL statement. +func (p *Parser) ParseGQLPathPattern() (stmt *ast.GQLPathPattern, err error) { defer func() { if r := recover(); r != nil { stmt = nil @@ -69,7 +69,7 @@ func (p *Parser) ParseGqlPathPattern() (stmt *ast.GqlPathPattern, err error) { }() p.nextToken() - stmt = p.parseGqlPathPattern() + stmt = p.parseGQLPathPattern() if p.Token.Kind != token.TokenEOF { p.panicfAtToken(&p.Token, "expected token: , but: %s", p.Token.Kind) } @@ -261,7 +261,7 @@ func (p *Parser) parseStatement() ast.Statement { // GQL queries are first level statements // because it is supported by Cloud Spanner's ExecuteSql API. case p.Token.IsKeywordLike("GRAPH"): - return p.parseGqlQuery() + return p.parseGQLQuery() } panic(p.errorfAtToken(&p.Token, "unexpected token: %s", p.Token.Kind)) @@ -847,7 +847,7 @@ func (p *Parser) parseSimpleTableExpr() ast.TableExpr { graphTable := p.expectKeywordLike("GRAPH_TABLE").Pos lparen := p.expect("(").Pos graphName := p.parseIdent() - query := p.parseGqlMultiLinearQueryStatement() + query := p.parseGQLMultiLinearQueryStatement() rparen := p.expect(")").Pos as := p.tryParseAsAlias() return &ast.GraphTableExpr{ @@ -1232,7 +1232,7 @@ func (p *Parser) parseInCondition() ast.InCondition { } if p.Token.Kind == "{" { - return p.parseGqlSubQueryInCondition() + return p.parseGQLSubQueryInCondition() } if p.Token.Kind == "(" { lparen := p.Token.Pos @@ -1503,9 +1503,9 @@ func (p *Parser) parseLit() ast.Expr { p.nextToken() if id.IsKeywordLike("VALUE") && p.Token.Kind == "{" { p.nextToken() - query := p.parseGqlQueryExpr() + query := p.parseGQLQueryExpr() rbrace := p.expect("}").Pos - return &ast.ValueGqlSubQuery{ + return &ast.ValueGQLSubQuery{ Array: id.Pos, RBrace: rbrace, Query: query, @@ -1687,7 +1687,7 @@ func (p *Parser) parseCastExpr() *ast.CastExpr { } } -func (p *Parser) lookaheadGqlGraphPattern() bool { +func (p *Parser) lookaheadGQLGraphPattern() bool { // path_search_prefix return p.Token.IsKeywordLike("ANY") || p.Token.IsKeywordLike("ALL") || // path_search_prefix p.Token.IsKeywordLike("WALK") || p.Token.IsKeywordLike("TRAIL") || // path_mode @@ -1698,13 +1698,13 @@ func (p *Parser) lookaheadGqlGraphPattern() bool { } -func (p *Parser) parseGqlExistsExpr() ast.GqlExistsExpr { - // NOTE: Single MATCH statement pattern is covered by GqlQueryExpr +func (p *Parser) parseGQLExistsExpr() ast.GQLExistsExpr { + // NOTE: Single MATCH statement pattern is covered by GQLQueryExpr // because there is no check that SimpleLinearQueryStatement is terminated by RETURN statement. - if p.lookaheadGqlGraphPattern() { - return p.parseGqlGraphPattern() + if p.lookaheadGQLGraphPattern() { + return p.parseGQLGraphPattern() } else { - return p.parseGqlQueryExpr() + return p.parseGQLQueryExpr() } } @@ -1713,9 +1713,9 @@ func (p *Parser) parseExistsSubQuery() ast.Expr { exists := p.expect("EXISTS").Pos if p.Token.Kind == "{" { p.expect("{") - expr := p.parseGqlExistsExpr() + expr := p.parseGQLExistsExpr() rbrace := p.expect("}").Pos - return &ast.ExistsGqlSubQuery{ + return &ast.ExistsGQLSubQuery{ Exists: exists, RBrace: rbrace, Query: expr, @@ -1824,9 +1824,9 @@ func (p *Parser) parseArrayLiteralOrSubQuery() ast.Expr { if p.Token.Kind == "{" { p.nextToken() - query := p.parseGqlQueryExpr() + query := p.parseGQLQueryExpr() rbrace := p.expect("}").Pos - return &ast.ArrayGqlSubQuery{ + return &ast.ArrayGQLSubQuery{ Array: pos, RBrace: rbrace, Query: query, @@ -3827,91 +3827,91 @@ func (p *Parser) parseStringValue() ast.StringValue { // // ================================================================================ -func (p *Parser) parseGqlQuery() *ast.GqlGraphQuery { - graphClause := p.parseGqlGraphClause() - multiQueryStatement := p.parseGqlMultiLinearQueryStatement() +func (p *Parser) parseGQLQuery() *ast.GQLGraphQuery { + graphClause := p.parseGQLGraphClause() + multiQueryStatement := p.parseGQLMultiLinearQueryStatement() - return &ast.GqlGraphQuery{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} + return &ast.GQLGraphQuery{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} } -func (p *Parser) parseGqlSubQueryInCondition() *ast.GqlSubQueryInCondition { +func (p *Parser) parseGQLSubQueryInCondition() *ast.GQLSubQueryInCondition { lbrace := p.expect("{").Pos - query := p.parseGqlQueryExpr() + query := p.parseGQLQueryExpr() rbrace := p.expect("}").Pos - return &ast.GqlSubQueryInCondition{LBrace: lbrace, RBrace: rbrace, Query: query} + return &ast.GQLSubQueryInCondition{LBrace: lbrace, RBrace: rbrace, Query: query} } -func (p *Parser) parseGqlQueryExpr() *ast.GqlQueryExpr { - var graphClause *ast.GqlGraphClause +func (p *Parser) parseGQLQueryExpr() *ast.GQLQueryExpr { + var graphClause *ast.GQLGraphClause if p.Token.IsKeywordLike("GRAPH") { - graphClause = p.parseGqlGraphClause() + graphClause = p.parseGQLGraphClause() } - multiQueryStatement := p.parseGqlMultiLinearQueryStatement() + multiQueryStatement := p.parseGQLMultiLinearQueryStatement() - return &ast.GqlQueryExpr{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} + return &ast.GQLQueryExpr{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} } -func (p *Parser) parseGqlGraphClause() *ast.GqlGraphClause { +func (p *Parser) parseGQLGraphClause() *ast.GQLGraphClause { graphPos := p.expectKeywordLike("GRAPH").Pos graphName := p.parseIdent() - return &ast.GqlGraphClause{ + return &ast.GQLGraphClause{ Graph: graphPos, PropertyGraphName: graphName, } } -func (p *Parser) parseGqlLinearQueryStatement() ast.GqlLinearQueryStatement { - stmt := p.parseGqlSimpleLinearQueryStatement() +func (p *Parser) parseGQLLinearQueryStatement() ast.GQLLinearQueryStatement { + stmt := p.parseGQLSimpleLinearQueryStatement() if p.Token.Kind != ("UNION") && p.Token.Kind != ("EXCEPT") && p.Token.Kind != ("DISTINCT") { return stmt } - var tail []*ast.GqlSimpleLinearQueryStatementWithSetOperator + var tail []*ast.GQLSimpleLinearQueryStatementWithSetOperator for p.Token.Kind == ("UNION") || p.Token.Kind == ("EXCEPT") || p.Token.Kind == ("DISTINCT") { - tail = append(tail, p.parseGqlSimpleLinearQueryStatementWithSetOperator()) + tail = append(tail, p.parseGQLSimpleLinearQueryStatementWithSetOperator()) } - return &ast.GqlCompositeLinearQueryStatement{HeadSimpleLinearQueryStatement: stmt, TailSimpleLinearQueryStatementList: tail} + return &ast.GQLCompositeLinearQueryStatement{HeadSimpleLinearQueryStatement: stmt, TailSimpleLinearQueryStatementList: tail} } -func (p *Parser) parseGqlSimpleLinearQueryStatementWithSetOperator() *ast.GqlSimpleLinearQueryStatementWithSetOperator { +func (p *Parser) parseGQLSimpleLinearQueryStatementWithSetOperator() *ast.GQLSimpleLinearQueryStatementWithSetOperator { pos := p.Token.Pos - var op ast.GqlSetOperatorEnum + var op ast.GQLSetOperatorEnum switch p.Token.Kind { case "UNION": p.nextToken() - op = ast.GqlSetOperatorUnion + op = ast.GQLSetOperatorUnion case "INTERSECT": p.nextToken() - op = ast.GqlSetOperatorIntersect + op = ast.GQLSetOperatorIntersect case "EXCEPT": p.nextToken() - op = ast.GqlSetOperatorExcept + op = ast.GQLSetOperatorExcept default: panic("unknown SetOperatorEnum") } - allOrDistinct := p.tryParseGqlAllOrDistinctEnum() - if allOrDistinct == ast.GqlAllOrDistinctImplicitAll { + allOrDistinct := p.tryParseGQLAllOrDistinctEnum() + if allOrDistinct == ast.GQLAllOrDistinctImplicitAll { p.panicfAtToken(&p.Token, `expect "ALL" or "DISTINCT, but: %v`, p.Token.Kind) } - stmt := p.parseGqlSimpleLinearQueryStatement() - return &ast.GqlSimpleLinearQueryStatementWithSetOperator{ + stmt := p.parseGQLSimpleLinearQueryStatement() + return &ast.GQLSimpleLinearQueryStatementWithSetOperator{ StartPos: pos, SetOperator: op, DistinctOrAll: allOrDistinct, Statement: stmt, } } -func (p *Parser) parseGqlSimpleLinearQueryStatement() *ast.GqlSimpleLinearQueryStatement { - var stmts []ast.GqlPrimitiveQueryStatement - for stmt := p.tryParseGqlPrimitiveQueryStatement(); stmt != nil; stmt = p.tryParseGqlPrimitiveQueryStatement() { +func (p *Parser) parseGQLSimpleLinearQueryStatement() *ast.GQLSimpleLinearQueryStatement { + var stmts []ast.GQLPrimitiveQueryStatement + for stmt := p.tryParseGQLPrimitiveQueryStatement(); stmt != nil; stmt = p.tryParseGQLPrimitiveQueryStatement() { stmts = append(stmts, stmt) } - return &ast.GqlSimpleLinearQueryStatement{PrimitiveQueryStatementList: stmts} + return &ast.GQLSimpleLinearQueryStatement{PrimitiveQueryStatementList: stmts} } -func (p *Parser) tryParseGqlWithOffsetClause() *ast.GqlWithOffsetClause { +func (p *Parser) tryParseGQLWithOffsetClause() *ast.GQLWithOffsetClause { if p.Token.Kind != "WITH" { return nil } @@ -3923,22 +3923,22 @@ func (p *Parser) tryParseGqlWithOffsetClause() *ast.GqlWithOffsetClause { offsetName = p.parseIdent() } - return &ast.GqlWithOffsetClause{ + return &ast.GQLWithOffsetClause{ With: with, Offset: offset, OffsetName: offsetName, } } -func (p *Parser) parseGqlForStatement() *ast.GqlForStatement { +func (p *Parser) parseGQLForStatement() *ast.GQLForStatement { forPos := p.expect("FOR").Pos name := p.parseIdent() p.expect("IN") expr := p.parseExpr() - withOffset := p.tryParseGqlWithOffsetClause() + withOffset := p.tryParseGQLWithOffsetClause() - return &ast.GqlForStatement{ + return &ast.GQLForStatement{ For: forPos, ElementName: name, ArrayExpression: expr, @@ -3946,40 +3946,40 @@ func (p *Parser) parseGqlForStatement() *ast.GqlForStatement { } } -func (p *Parser) tryParseGqlOrderBySpecificationList() []*ast.GqlOrderBySpecification { - var list []*ast.GqlOrderBySpecification +func (p *Parser) tryParseGQLOrderBySpecificationList() []*ast.GQLOrderBySpecification { + var list []*ast.GQLOrderBySpecification for { expr := p.parseExpr() - var collateSpec *ast.GqlCollationSpecification + var collateSpec *ast.GQLCollationSpecification if p.Token.Kind == "COLLATE" { collatePos := p.expect("COLLATE").Pos spec := p.parseStringValue() - collateSpec = &ast.GqlCollationSpecification{ + collateSpec = &ast.GQLCollationSpecification{ Collate: collatePos, Specification: spec, } } - var direction ast.GqlDirection + var direction ast.GQLDirection directionPos := p.Token.Pos switch { case p.Token.Kind == "ASC": p.nextToken() - direction = ast.GqlSortOrderAsc + direction = ast.GQLSortOrderAsc case p.Token.Kind == "DESC": p.nextToken() - direction = ast.GqlSortOrderDesc + direction = ast.GQLSortOrderDesc case p.Token.Kind == "ASCENDING": p.nextToken() - direction = ast.GqlSortOrderAscending + direction = ast.GQLSortOrderAscending case p.Token.Kind == "DESCENDING": p.nextToken() - direction = ast.GqlSortOrderDescending + direction = ast.GQLSortOrderDescending default: directionPos = token.InvalidPos } - list = append(list, &ast.GqlOrderBySpecification{ + list = append(list, &ast.GQLOrderBySpecification{ Expr: expr, DirectionPos: directionPos, CollationSpecification: collateSpec, @@ -3992,31 +3992,31 @@ func (p *Parser) tryParseGqlOrderBySpecificationList() []*ast.GqlOrderBySpecific return list } -func (p *Parser) parseGqlOrderByStatement() *ast.GqlOrderByStatement { +func (p *Parser) parseGQLOrderByStatement() *ast.GQLOrderByStatement { order := p.expect("ORDER").Pos p.expect("BY") - spec := p.tryParseGqlOrderBySpecificationList() + spec := p.tryParseGQLOrderBySpecificationList() if spec == nil { p.panicfAtToken(&p.Token, "expect at least one order_by_specification") } - return &ast.GqlOrderByStatement{ + return &ast.GQLOrderByStatement{ Order: order, OrderBySpecificationList: spec, } } -func (p *Parser) parseGqlLimitStatement() *ast.GqlLimitStatement { +func (p *Parser) parseGQLLimitStatement() *ast.GQLLimitStatement { limit := p.expect("LIMIT").Pos expr := p.parseIntValue() - return &ast.GqlLimitStatement{ + return &ast.GQLLimitStatement{ Limit: limit, Count: expr, } } -func (p *Parser) parseGqlFilterStatement() *ast.GqlFilterStatement { +func (p *Parser) parseGQLFilterStatement() *ast.GQLFilterStatement { filter := p.expectKeywordLike("FILTER").Pos where := token.InvalidPos if p.Token.Kind == "WHERE" { @@ -4024,14 +4024,14 @@ func (p *Parser) parseGqlFilterStatement() *ast.GqlFilterStatement { } expr := p.parseExpr() - return &ast.GqlFilterStatement{ + return &ast.GQLFilterStatement{ Filter: filter, Where: where, Expr: expr, } } -func (p *Parser) parseGqlOffsetStatement() *ast.GqlOffsetStatement { +func (p *Parser) parseGQLOffsetStatement() *ast.GQLOffsetStatement { var pos token.Pos var isSkip bool switch { @@ -4046,14 +4046,14 @@ func (p *Parser) parseGqlOffsetStatement() *ast.GqlOffsetStatement { count := p.parseIntValue() - return &ast.GqlOffsetStatement{ + return &ast.GQLOffsetStatement{ Offset: pos, IsSkip: isSkip, Count: count, } } -func (p *Parser) parseGqlReturnItem() ast.GqlReturnItem { +func (p *Parser) parseGQLReturnItem() ast.GQLReturnItem { if p.Token.Kind == "*" { pos := p.expect("*").Pos return &ast.Star{ @@ -4076,32 +4076,32 @@ func (p *Parser) parseGqlReturnItem() ast.GqlReturnItem { } } -func (p *Parser) tryParseGqlPrimitiveQueryStatement() ast.GqlPrimitiveQueryStatement { +func (p *Parser) tryParseGQLPrimitiveQueryStatement() ast.GQLPrimitiveQueryStatement { switch { case p.Token.IsKeywordLike("RETURN"): - return p.parseGqlReturnStatement() + return p.parseGQLReturnStatement() case p.Token.IsKeywordLike("LET"): - return p.parseGqlLetStatement() + return p.parseGQLLetStatement() case p.Token.IsKeywordLike("FILTER"): - return p.parseGqlFilterStatement() + return p.parseGQLFilterStatement() case p.Token.Kind == "ORDER": - return p.parseGqlOrderByStatement() + return p.parseGQLOrderByStatement() case p.Token.Kind == "LIMIT": - return p.parseGqlLimitStatement() + return p.parseGQLLimitStatement() case p.Token.IsKeywordLike("SKIP"), p.Token.IsKeywordLike("OFFSET"): - return p.parseGqlOffsetStatement() + return p.parseGQLOffsetStatement() case p.Token.Kind == "FOR": - return p.parseGqlForStatement() + return p.parseGQLForStatement() case p.Token.IsKeywordLike("OPTIONAL") || p.Token.IsKeywordLike("MATCH"): - return p.parseGqlMatchStatement() + return p.parseGQLMatchStatement() case p.Token.Kind == "WITH": - return p.parseGqlWithStatement() + return p.parseGQLWithStatement() default: return nil } } -func (p *Parser) tryParseGqlPathModePathOrPaths() *ast.Ident { +func (p *Parser) tryParseGQLPathModePathOrPaths() *ast.Ident { switch { case p.Token.IsKeywordLike("PATH"), p.Token.IsKeywordLike("PATHS"): return p.parseIdent() @@ -4109,57 +4109,57 @@ func (p *Parser) tryParseGqlPathModePathOrPaths() *ast.Ident { return nil } } -func (p *Parser) tryParseGqlPathMode() *ast.GqlPathMode { +func (p *Parser) tryParseGQLPathMode() *ast.GQLPathMode { switch { case p.Token.IsKeywordLike("WALK"): pathModeToken := p.parseIdent() - pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() - return &ast.GqlPathMode{ + pathOrPathsToken := p.tryParseGQLPathModePathOrPaths() + return &ast.GQLPathMode{ ModeToken: pathModeToken, PathOrPathsToken: pathOrPathsToken, - Mode: ast.GqlPathModeWalk, + Mode: ast.GQLPathModeWalk, } case p.Token.IsKeywordLike("TRAIL"): pathModeToken := p.parseIdent() - pathOrPathsToken := p.tryParseGqlPathModePathOrPaths() - return &ast.GqlPathMode{ + pathOrPathsToken := p.tryParseGQLPathModePathOrPaths() + return &ast.GQLPathMode{ ModeToken: pathModeToken, PathOrPathsToken: pathOrPathsToken, - Mode: ast.GqlPathModeTrail, + Mode: ast.GQLPathModeTrail, } default: return nil } } -func (p *Parser) tryParseGqlPathSearchPrefixOrPathMode() ast.GqlPathSearchPrefixOrPathMode { +func (p *Parser) tryParseGQLPathSearchPrefixOrPathMode() ast.GQLPathSearchPrefixOrPathMode { startPos := p.Token.Pos switch { case p.Token.Kind == "ALL": end := p.expect("ALL").End - return &ast.GqlPathSearchPrefix{ + return &ast.GQLPathSearchPrefix{ StartPos: startPos, LastEnd: end, - SearchPrefix: ast.GqlPathSearchPrefixAll, + SearchPrefix: ast.GQLPathSearchPrefixAll, } case p.Token.Kind == "ANY": anyEnd := p.expect("ANY").End if p.Token.IsKeywordLike("SHORTEST") { shortestEnd := p.expectKeywordLike("SHORTEST").End - return &ast.GqlPathSearchPrefix{ + return &ast.GQLPathSearchPrefix{ StartPos: startPos, LastEnd: shortestEnd, - SearchPrefix: ast.GqlPathSearchPrefixAnyShortest, + SearchPrefix: ast.GQLPathSearchPrefixAnyShortest, } } else { - return &ast.GqlPathSearchPrefix{ + return &ast.GQLPathSearchPrefix{ StartPos: startPos, LastEnd: anyEnd, - SearchPrefix: ast.GqlPathSearchPrefixAny, + SearchPrefix: ast.GQLPathSearchPrefixAny, } } default: - if pathMode := p.tryParseGqlPathMode(); pathMode != nil { + if pathMode := p.tryParseGQLPathMode(); pathMode != nil { return pathMode } return nil @@ -4167,7 +4167,7 @@ func (p *Parser) tryParseGqlPathSearchPrefixOrPathMode() ast.GqlPathSearchPrefix } -func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { +func (p *Parser) parseGQLMatchStatement() *ast.GQLMatchStatement { var optionalPos token.Pos if p.Token.IsKeywordLike("OPTIONAL") { optionalPos = p.Token.Pos @@ -4178,9 +4178,9 @@ func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { match := p.expectKeywordLike("MATCH").Pos hint := p.tryParseHint() - var prefixOrMode = p.tryParseGqlPathSearchPrefixOrPathMode() - pattern := p.parseGqlGraphPattern() - return &ast.GqlMatchStatement{ + var prefixOrMode = p.tryParseGQLPathSearchPrefixOrPathMode() + pattern := p.parseGQLGraphPattern() + return &ast.GQLMatchStatement{ Optional: optionalPos, Match: match, MatchHint: hint, @@ -4189,25 +4189,25 @@ func (p *Parser) parseGqlMatchStatement() *ast.GqlMatchStatement { } } -func (p *Parser) parseGqlLabelName() *ast.GqlLabelName { +func (p *Parser) parseGQLLabelName() *ast.GQLLabelName { pos := p.Token.Pos if p.Token.Kind == "%" { p.nextToken() - return &ast.GqlLabelName{ + return &ast.GQLLabelName{ StartPos: pos, IsPercent: true, } } ident := p.parseIdent() - return &ast.GqlLabelName{ + return &ast.GQLLabelName{ StartPos: pos, LabelName: ident, } } -func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { +func (p *Parser) parseGQLLabelExpression() ast.GQLLabelExpression { // TODO /* label_expression: @@ -4218,23 +4218,23 @@ func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { | not_expression } */ - var labelTerm ast.GqlLabelExpression + var labelTerm ast.GQLLabelExpression switch { case p.Token.Kind == "!": notPos := p.expect("!").Pos - expr := p.parseGqlLabelExpression() - labelTerm = &ast.GqlLabelNotExpression{Not: notPos, LabelExpression: expr} + expr := p.parseGQLLabelExpression() + labelTerm = &ast.GQLLabelNotExpression{Not: notPos, LabelExpression: expr} case p.Token.Kind == "(": lparen := p.expect("(").Pos - expr := p.parseGqlLabelExpression() + expr := p.parseGQLLabelExpression() rparen := p.expect(")").Pos - labelTerm = &ast.GqlLabelParenExpression{ + labelTerm = &ast.GQLLabelParenExpression{ LParen: lparen, RParen: rparen, LabelExpr: expr, } case p.Token.Kind == token.TokenIdent || p.Token.Kind == "%": - labelTerm = p.parseGqlLabelName() + labelTerm = p.parseGQLLabelName() default: p.panicfAtToken(&p.Token, `expected token: ",", "(", or "", but: %v`, p.Token.Kind) return nil @@ -4242,44 +4242,44 @@ func (p *Parser) parseGqlLabelExpression() ast.GqlLabelExpression { switch { case p.Token.Kind == "|": p.nextToken() - right := p.parseGqlLabelExpression() - return &ast.GqlLabelOrExpression{ + right := p.parseGQLLabelExpression() + return &ast.GQLLabelOrExpression{ Left: labelTerm, Right: right, } case p.Token.Kind == "&": p.nextToken() - right := p.parseGqlLabelExpression() - return &ast.GqlLabelAndExpression{ + right := p.parseGQLLabelExpression() + return &ast.GQLLabelAndExpression{ Left: labelTerm, Right: right, } } return labelTerm } -func (p *Parser) parseGqlIsLabelCondition() *ast.GqlIsLabelCondition { +func (p *Parser) parseGQLIsLabelCondition() *ast.GQLIsLabelCondition { pos := p.Token.Pos p.nextToken() - labelExpr := p.parseGqlLabelExpression() - return &ast.GqlIsLabelCondition{ + labelExpr := p.parseGQLLabelExpression() + return &ast.GQLIsLabelCondition{ IsOrColon: pos, LabelExpression: labelExpr, } } -func (p *Parser) parseGqlPatternFiller() *ast.GqlPatternFiller { +func (p *Parser) parseGQLPatternFiller() *ast.GQLPatternFiller { hint := p.tryParseHint() var patternVar *ast.Ident if p.Token.Kind == token.TokenIdent { patternVar = p.parseIdent() } - var isLabelCondition *ast.GqlIsLabelCondition + var isLabelCondition *ast.GQLIsLabelCondition if p.Token.Kind == ":" || p.Token.Kind == "IS" { - isLabelCondition = p.parseGqlIsLabelCondition() + isLabelCondition = p.parseGQLIsLabelCondition() } - filter := p.tryParseGqlPatternFillerFilter() - return &ast.GqlPatternFiller{ + filter := p.tryParseGQLPatternFillerFilter() + return &ast.GQLPatternFiller{ Hint: hint, GraphPatternVariable: patternVar, // TODO IsLabelCondition: isLabelCondition, // TODO @@ -4287,7 +4287,7 @@ func (p *Parser) parseGqlPatternFiller() *ast.GqlPatternFiller { } } -func (p *Parser) lookaheadGqlSubpathPattern() bool { +func (p *Parser) lookaheadGQLSubpathPattern() bool { lexer := p.Lexer.Clone() defer func() { p.Lexer = lexer @@ -4303,18 +4303,18 @@ func (p *Parser) lookaheadGqlSubpathPattern() bool { return false } -func (p *Parser) parseGqlNodePattern() *ast.GqlNodePattern { +func (p *Parser) parseGQLNodePattern() *ast.GQLNodePattern { lparen := p.expect("(").Pos - filter := p.parseGqlPatternFiller() + filter := p.parseGQLPatternFiller() rparen := p.expect(")").Pos - return &ast.GqlNodePattern{ + return &ast.GQLNodePattern{ LParen: lparen, RParen: rparen, PatternFiller: filter, } } -func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { +func (p *Parser) tryParseGQLQuantifier() ast.GQLQuantifier { if p.Token.Kind != "{" { return nil } @@ -4322,7 +4322,7 @@ func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { if p.Token.Kind == "," { upperBound := p.parseIntValue() rbrace := p.expect("}").Pos - return &ast.GqlBoundedQuantifier{ + return &ast.GQLBoundedQuantifier{ LBrace: lbrace, RBrace: rbrace, UpperBound: upperBound, @@ -4331,7 +4331,7 @@ func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { bound := p.parseIntValue() if p.Token.Kind != "," { rbrace := p.expect("}").Pos - return &ast.GqlFixedQuantifier{ + return &ast.GQLFixedQuantifier{ LBrace: lbrace, RBrace: rbrace, Bound: bound, @@ -4341,7 +4341,7 @@ func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { upperBound := p.parseIntValue() rbrace := p.expect("}").Pos - return &ast.GqlBoundedQuantifier{ + return &ast.GQLBoundedQuantifier{ LBrace: lbrace, RBrace: rbrace, LowerBound: bound, @@ -4349,21 +4349,21 @@ func (p *Parser) tryParseGqlQuantifier() ast.GqlQuantifier { } } -func (p *Parser) tryParseGqlQuantifiablePathTerm() *ast.GqlQuantifiablePathTerm { +func (p *Parser) tryParseGQLQuantifiablePathTerm() *ast.GQLQuantifiablePathTerm { hint := p.tryParseHint() - pt := p.tryParseGqlPathTerm() + pt := p.tryParseGQLPathTerm() if pt == nil { return nil } - q := p.tryParseGqlQuantifier() - return &ast.GqlQuantifiablePathTerm{ + q := p.tryParseGQLQuantifier() + return &ast.GQLQuantifiablePathTerm{ Hint: hint, PathTerm: pt, Quantifier: q, } } -func (p *Parser) tryParseGqlPathTerm() ast.GqlPathTerm { +func (p *Parser) tryParseGQLPathTerm() ast.GQLPathTerm { // TODO /* path_term: @@ -4373,26 +4373,26 @@ func (p *Parser) tryParseGqlPathTerm() ast.GqlPathTerm { } */ - if p.lookaheadGqlSubpathPattern() { - return p.parseGqlSubPathPattern() + if p.lookaheadGQLSubpathPattern() { + return p.parseGQLSubPathPattern() } if p.Token.Kind == "(" { - return p.parseGqlNodePattern() + return p.parseGQLNodePattern() } if p.Token.Kind == "-" || p.Token.Kind == "<" { - return p.parseGqlEdgePattern() + return p.parseGQLEdgePattern() } return nil } -func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { +func (p *Parser) parseGQLSubPathPattern() *ast.GQLSubpathPattern { lparen := p.expect("(").Pos - pathMode := p.tryParseGqlPathMode() - pattern := p.parseGqlPathPattern() + pathMode := p.tryParseGQLPathMode() + pattern := p.parseGQLPathPattern() where := p.tryParseWhere() rparen := p.expect(")").Pos - return &ast.GqlSubpathPattern{ + return &ast.GQLSubpathPattern{ LParen: lparen, RParen: rparen, PathMode: pathMode, @@ -4401,7 +4401,7 @@ func (p *Parser) parseGqlSubPathPattern() *ast.GqlSubpathPattern { } } -func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { +func (p *Parser) parseGQLEdgePattern() ast.GQLEdgePattern { // NOTE: Currently, this implementation allows whitespace in any place of "<-[" and "]->". // It is more relaxed syntax than spec. // It will be fixed when we are sure that the modification of lexer is safe. @@ -4411,16 +4411,16 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { p.nextToken() firstHyphenPos := p.expect("-").Pos if p.Token.Kind != "[" { - return &ast.GqlAbbreviatedEdgeLeft{ + return &ast.GQLAbbreviatedEdgeLeft{ First: firstPos, Last: firstHyphenPos, } } p.nextToken() - patternFilter := p.parseGqlPatternFiller() + patternFilter := p.parseGQLPatternFiller() p.expect("]") lastPos := p.expect("-").Pos - return &ast.GqlFullEdgeLeft{ + return &ast.GQLFullEdgeLeft{ First: firstPos, Last: lastPos, PatternFiller: patternFilter, @@ -4430,102 +4430,102 @@ func (p *Parser) parseGqlEdgePattern() ast.GqlEdgePattern { switch p.Token.Kind { case ">": lastPos := p.expect(">").Pos - return &ast.GqlAbbreviatedEdgeRight{ + return &ast.GQLAbbreviatedEdgeRight{ First: firstPos, Last: lastPos, } case "[": p.nextToken() - patternFiller := p.parseGqlPatternFiller() + patternFiller := p.parseGQLPatternFiller() p.expect("]") lastHyphenPos := p.expect("-").Pos if p.Token.Kind == ">" { lastPos := p.Token.Pos p.nextToken() - return &ast.GqlFullEdgeRight{ + return &ast.GQLFullEdgeRight{ First: firstPos, Last: lastPos, PatternFiller: patternFiller, } } - return &ast.GqlFullEdgeAny{ + return &ast.GQLFullEdgeAny{ First: firstPos, Last: lastHyphenPos, PatternFiller: patternFiller, } default: - return &ast.GqlAbbreviatedEdgeAny{Hyphen: firstPos} + return &ast.GQLAbbreviatedEdgeAny{Hyphen: firstPos} } default: panic(fmt.Sprintf("not implemented kind: %v %v", p.Token.Kind, p.Token.Raw)) } } -func (p *Parser) parseGqlPathPattern() *ast.GqlPathPattern { - list := []*ast.GqlQuantifiablePathTerm{p.tryParseGqlQuantifiablePathTerm()} +func (p *Parser) parseGQLPathPattern() *ast.GQLPathPattern { + list := []*ast.GQLQuantifiablePathTerm{p.tryParseGQLQuantifiablePathTerm()} for p.Token.Kind != ")" && !p.Token.IsKeywordLike("WHERE") { - term := p.tryParseGqlQuantifiablePathTerm() + term := p.tryParseGQLQuantifiablePathTerm() if term == nil { break } list = append(list, term) } - return &ast.GqlPathPattern{ + return &ast.GQLPathPattern{ PathTermList: list, } } -func (p *Parser) parseGqlTopLevelPathPattern() *ast.GqlTopLevelPathPattern { - pattern := p.parseGqlPathPattern() - return &ast.GqlTopLevelPathPattern{ +func (p *Parser) parseGQLTopLevelPathPattern() *ast.GQLTopLevelPathPattern { + pattern := p.parseGQLPathPattern() + return &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, // TODO PathPattern: pattern, } } -func (p *Parser) parseGqlElementProperty() *ast.GqlElementProperty { +func (p *Parser) parseGQLElementProperty() *ast.GQLElementProperty { ident := p.parseIdent() _ = p.expect(":") expr := p.parseExpr() - return &ast.GqlElementProperty{ + return &ast.GQLElementProperty{ ElementPropertyName: ident, ElementPropertyValue: expr, } } -func (p *Parser) parseGqlPropertyFilters() *ast.GqlPropertyFilters { +func (p *Parser) parseGQLPropertyFilters() *ast.GQLPropertyFilters { lbrace := p.expect("{").Pos - elementPropertyList := []*ast.GqlElementProperty{p.parseGqlElementProperty()} + elementPropertyList := []*ast.GQLElementProperty{p.parseGQLElementProperty()} for p.Token.Kind == "," { p.nextToken() - elementPropertyList = append(elementPropertyList, p.parseGqlElementProperty()) + elementPropertyList = append(elementPropertyList, p.parseGQLElementProperty()) } rbrace := p.expect("}").Pos - return &ast.GqlPropertyFilters{ + return &ast.GQLPropertyFilters{ LBrace: lbrace, PropertyFilterElemList: elementPropertyList, RBrace: rbrace, } } -func (p *Parser) tryParseGqlPatternFillerFilter() ast.GqlPatternFillerFilter { +func (p *Parser) tryParseGQLPatternFillerFilter() ast.GQLPatternFillerFilter { switch { case p.Token.Kind == "WHERE": return p.parseWhere() case p.Token.Kind == "{": - return p.parseGqlPropertyFilters() + return p.parseGQLPropertyFilters() default: return nil } } -func (p *Parser) parseGqlGraphPattern() *ast.GqlGraphPattern { - patterns := []*ast.GqlTopLevelPathPattern{p.parseGqlTopLevelPathPattern()} +func (p *Parser) parseGQLGraphPattern() *ast.GQLGraphPattern { + patterns := []*ast.GQLTopLevelPathPattern{p.parseGQLTopLevelPathPattern()} for p.Token.Kind == "," { p.nextToken() - patterns = append(patterns, p.parseGqlTopLevelPathPattern()) + patterns = append(patterns, p.parseGQLTopLevelPathPattern()) } - return &ast.GqlGraphPattern{ + return &ast.GQLGraphPattern{ PathPatternList: patterns, WhereClause: p.tryParseWhere(), // TODO } @@ -4542,29 +4542,29 @@ GQL statements GQL RETURN statement *** */ -func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { +func (p *Parser) parseGQLReturnStatement() *ast.GQLReturnStatement { ret := p.expectKeywordLike("RETURN").Pos - allOrDistinct := p.tryParseGqlAllOrDistinctEnum() - returnItems := p.parseGqlReturnItemList() + allOrDistinct := p.tryParseGQLAllOrDistinctEnum() + returnItems := p.parseGQLReturnItemList() groupBy := p.tryParseGroupBy() orderBy := p.tryParseOrderBy() limit := p.tryParseLimit() offset := p.tryParseOffset() - var limitAndOffset ast.GqlLimitAndOffsetClause + var limitAndOffset ast.GQLLimitAndOffsetClause switch { case limit != nil && offset != nil: - limitAndOffset = &ast.GqlLimitWithOffsetClause{ + limitAndOffset = &ast.GQLLimitWithOffsetClause{ Limit: limit, Offset: offset, } case limit != nil: - limitAndOffset = &ast.GqlLimitClause{Limit: limit} + limitAndOffset = &ast.GQLLimitClause{Limit: limit} case offset != nil: - limitAndOffset = &ast.GqlOffsetClause{Offset: offset} + limitAndOffset = &ast.GQLOffsetClause{Offset: offset} default: } - return &ast.GqlReturnStatement{Return: ret, + return &ast.GQLReturnStatement{Return: ret, AllOrDistinct: allOrDistinct, GroupByClause: groupBy, OrderByClause: orderBy, @@ -4572,10 +4572,10 @@ func (p *Parser) parseGqlReturnStatement() *ast.GqlReturnStatement { ReturnItemList: returnItems} } -func (p *Parser) parseGqlReturnItemList() []ast.GqlReturnItem { - var results []ast.GqlReturnItem +func (p *Parser) parseGQLReturnItemList() []ast.GQLReturnItem { + var results []ast.GQLReturnItem for { - results = append(results, p.parseGqlReturnItem()) + results = append(results, p.parseGQLReturnItem()) if p.Token.Kind != "," { break } @@ -4584,60 +4584,60 @@ func (p *Parser) parseGqlReturnItemList() []ast.GqlReturnItem { return results } -func (p *Parser) tryParseGqlAllOrDistinctEnum() ast.GqlAllOrDistinctEnum { +func (p *Parser) tryParseGQLAllOrDistinctEnum() ast.GQLAllOrDistinctEnum { switch p.Token.Kind { case "ALL": p.nextToken() - return ast.GqlAllOrDistinctAll + return ast.GQLAllOrDistinctAll case "DISTINCT": p.nextToken() - return ast.GqlAllOrDistinctDistinct + return ast.GQLAllOrDistinctDistinct default: - return ast.GqlAllOrDistinctImplicitAll + return ast.GQLAllOrDistinctImplicitAll } } -func (p *Parser) parseGqlWithStatement() *ast.GqlWithStatement { +func (p *Parser) parseGQLWithStatement() *ast.GQLWithStatement { with := p.expect("WITH").Pos - allOrDistinct := p.tryParseGqlAllOrDistinctEnum() - returnItems := p.parseGqlReturnItemList() + allOrDistinct := p.tryParseGQLAllOrDistinctEnum() + returnItems := p.parseGQLReturnItemList() groupBy := p.tryParseGroupBy() - return &ast.GqlWithStatement{ + return &ast.GQLWithStatement{ With: with, AllOrDistinct: allOrDistinct, GroupByClause: groupBy, ReturnItemList: returnItems} } -func (p *Parser) parseGqlLinearGraphVariable() *ast.GqlLinearGraphVariable { +func (p *Parser) parseGQLLinearGraphVariable() *ast.GQLLinearGraphVariable { name := p.parseIdent() p.expect("=") value := p.parseExpr() - return &ast.GqlLinearGraphVariable{VariableName: name, Value: value} + return &ast.GQLLinearGraphVariable{VariableName: name, Value: value} } -func (p *Parser) parseGqlLetStatement() *ast.GqlLetStatement { +func (p *Parser) parseGQLLetStatement() *ast.GQLLetStatement { let := p.expectKeywordLike("LET").Pos - vars := []*ast.GqlLinearGraphVariable{p.parseGqlLinearGraphVariable()} + vars := []*ast.GQLLinearGraphVariable{p.parseGQLLinearGraphVariable()} for p.Token.Kind == "," { p.nextToken() - vars = append(vars, p.parseGqlLinearGraphVariable()) + vars = append(vars, p.parseGQLLinearGraphVariable()) } - return &ast.GqlLetStatement{Let: let, LinearGraphVariableList: vars} + return &ast.GQLLetStatement{Let: let, LinearGraphVariableList: vars} } -func (p *Parser) parseGqlMultiLinearQueryStatement() *ast.GqlMultiLinearQueryStatement { - items := []ast.GqlLinearQueryStatement{p.parseGqlLinearQueryStatement()} +func (p *Parser) parseGQLMultiLinearQueryStatement() *ast.GQLMultiLinearQueryStatement { + items := []ast.GQLLinearQueryStatement{p.parseGQLLinearQueryStatement()} for p.Token.IsKeywordLike("NEXT") { p.expectKeywordLike("NEXT") - items = append(items, p.parseGqlLinearQueryStatement()) + items = append(items, p.parseGQLLinearQueryStatement()) } - return &ast.GqlMultiLinearQueryStatement{LinearQueryStatementList: items} + return &ast.GQLMultiLinearQueryStatement{LinearQueryStatementList: items} } func (p *Parser) expect(kind token.TokenKind) *token.Token { diff --git a/parser_test.go b/parser_test.go index aaf38830..a1088a81 100644 --- a/parser_test.go +++ b/parser_test.go @@ -135,21 +135,21 @@ func TestParseQuery(t *testing.T) { }) } -func TestParseGqlStatement(t *testing.T) { +func TestParseGQLStatement(t *testing.T) { inputPath := "./testdata/input/gql" resultPath := "./testdata/result/gql" testParser(t, inputPath, resultPath, func(p *memefish.Parser) (ast.Node, error) { - return p.ParseGqlStatement() + return p.ParseGQLStatement() }) } -func TestParseGqlPathPattern(t *testing.T) { +func TestParseGQLPathPattern(t *testing.T) { inputPath := "./testdata/input/gql_path_pattern" resultPath := "./testdata/result/gql_path_pattern" testParser(t, inputPath, resultPath, func(p *memefish.Parser) (ast.Node, error) { - return p.ParseGqlPathPattern() + return p.ParseGQLPathPattern() }) } diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index 175bfe62..b699fed0 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -4,8 +4,8 @@ MATCH (p:Person)-[o:Owns]->(a:Account) FILTER p.birthday < '1990-01-10' RETURN p.name --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN p.name Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -57,21 +57,21 @@ RETURN p.name }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 41, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 33, NameEnd: 34, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 34, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 35, IsPercent: false, LabelName: &ast.Ident{ @@ -86,21 +86,21 @@ RETURN p.name }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 42, RParen: 52, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, NameEnd: 44, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ @@ -122,7 +122,7 @@ RETURN p.name WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlFilterStatement{ + &ast.GQLFilterStatement{ Filter: 54, Where: -1, Expr: &ast.BinaryExpr{ @@ -148,10 +148,10 @@ RETURN p.name }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 87, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index 1d9a3ebd..5d375f11 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -4,8 +4,8 @@ MATCH (p:Person)-[o:Owns]->(a:Account) FILTER WHERE p.birthday < '1990-01-10' RETURN p.name --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN p.name Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -57,21 +57,21 @@ RETURN p.name }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 41, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 33, NameEnd: 34, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 34, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 35, IsPercent: false, LabelName: &ast.Ident{ @@ -86,21 +86,21 @@ RETURN p.name }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 42, RParen: 52, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, NameEnd: 44, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ @@ -122,7 +122,7 @@ RETURN p.name WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlFilterStatement{ + &ast.GQLFilterStatement{ Filter: 54, Where: 61, Expr: &ast.BinaryExpr{ @@ -148,10 +148,10 @@ RETURN p.name }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 93, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index 59530fef..90605103 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -6,8 +6,8 @@ RETURN p.name, element as alert_type, offset ORDER BY p.name, element, offset --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -15,36 +15,36 @@ ORDER BY p.name, element, offset Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -59,21 +59,21 @@ ORDER BY p.name, element, offset }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 41, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 33, NameEnd: 34, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 34, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 35, IsPercent: false, LabelName: &ast.Ident{ @@ -88,21 +88,21 @@ ORDER BY p.name, element, offset }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 42, RParen: 52, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, NameEnd: 44, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ @@ -124,7 +124,7 @@ ORDER BY p.name, element, offset WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlForStatement{ + &ast.GQLForStatement{ For: 54, ElementName: &ast.Ident{ NamePos: 58, @@ -149,16 +149,16 @@ ORDER BY p.name, element, offset }, }, }, - WithOffsetClause: &ast.GqlWithOffsetClause{ + WithOffsetClause: &ast.GQLWithOffsetClause{ With: 84, Offset: 89, OffsetName: (*ast.Ident)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 96, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index 793d332f..b5632fb9 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -4,8 +4,8 @@ MATCH (p:Person) FOR element in [] WITH OFFSET AS off RETURN p.name, element, off --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN p.name, element, off Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -64,7 +64,7 @@ RETURN p.name, element, off WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlForStatement{ + &ast.GQLForStatement{ For: 32, ElementName: &ast.Ident{ NamePos: 36, @@ -78,7 +78,7 @@ RETURN p.name, element, off Type: nil, Values: []ast.Expr(nil), }, - WithOffsetClause: &ast.GqlWithOffsetClause{ + WithOffsetClause: &ast.GQLWithOffsetClause{ With: 50, Offset: 55, OffsetName: &ast.Ident{ @@ -88,10 +88,10 @@ RETURN p.name, element, off }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 69, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index 34bb5810..ba157931 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -6,8 +6,8 @@ MATCH ((a:Account)-[s:Transfers]->(oa:Account)) RETURN oa.id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -15,36 +15,36 @@ RETURN oa.id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 23, RParen: 40, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 24, NameEnd: 25, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ @@ -54,10 +54,10 @@ RETURN oa.id }, }, }, - Filter: &ast.GqlPropertyFilters{ + Filter: &ast.GQLPropertyFilters{ LBrace: 33, - PropertyFilterElemList: []*ast.GqlElementProperty{ - &ast.GqlElementProperty{ + PropertyFilterElemList: []*ast.GQLElementProperty{ + &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ NamePos: 34, NameEnd: 36, @@ -77,21 +77,21 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 41, Last: 51, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, NameEnd: 44, Name: "e", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ @@ -106,7 +106,7 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: &ast.Hint{ Atmark: 55, Rbrace: 79, @@ -125,27 +125,27 @@ RETURN oa.id }, }, }, - PathTerm: &ast.GqlSubpathPattern{ + PathTerm: &ast.GQLSubpathPattern{ LParen: 83, RParen: 123, - PathMode: (*ast.GqlPathMode)(nil), - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathMode: (*ast.GQLPathMode)(nil), + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 84, RParen: 94, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 85, NameEnd: 86, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 86, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 87, IsPercent: false, LabelName: &ast.Ident{ @@ -160,21 +160,21 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 95, Last: 110, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 97, NameEnd: 98, Name: "s", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 98, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 99, IsPercent: false, LabelName: &ast.Ident{ @@ -189,21 +189,21 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 111, RParen: 122, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 112, NameEnd: 114, Name: "oa", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 114, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 115, IsPercent: false, LabelName: &ast.Ident{ @@ -231,10 +231,10 @@ RETURN oa.id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 125, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index eb3748d8..7f9532eb 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -4,8 +4,8 @@ MATCH (p:Person {id: 1})-[:Owns]->(a:Account) MATCH @{JOIN_METHOD=APPLY_JOIN}(a:Account)-[e:Transfers]->(oa:Account) RETURN oa.id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN oa.id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 38, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -52,10 +52,10 @@ RETURN oa.id }, }, }, - Filter: &ast.GqlPropertyFilters{ + Filter: &ast.GQLPropertyFilters{ LBrace: 31, - PropertyFilterElemList: []*ast.GqlElementProperty{ - &ast.GqlElementProperty{ + PropertyFilterElemList: []*ast.GQLElementProperty{ + &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ NamePos: 32, NameEnd: 34, @@ -75,17 +75,17 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 39, Last: 48, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 41, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 42, IsPercent: false, LabelName: &ast.Ident{ @@ -100,21 +100,21 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 49, RParen: 59, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 50, NameEnd: 51, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 51, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 52, IsPercent: false, LabelName: &ast.Ident{ @@ -136,7 +136,7 @@ RETURN oa.id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlMatchStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 61, MatchHint: &ast.Hint{ @@ -158,27 +158,27 @@ RETURN oa.id }, }, PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 92, RParen: 102, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 93, NameEnd: 94, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 94, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 95, IsPercent: false, LabelName: &ast.Ident{ @@ -193,21 +193,21 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 103, Last: 118, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 105, NameEnd: 106, Name: "e", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 106, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 107, IsPercent: false, LabelName: &ast.Ident{ @@ -222,21 +222,21 @@ RETURN oa.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 119, RParen: 130, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 120, NameEnd: 122, Name: "oa", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 122, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 123, IsPercent: false, LabelName: &ast.Ident{ @@ -258,10 +258,10 @@ RETURN oa.id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 132, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index 8dcdced3..f29741a4 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -6,8 +6,8 @@ MATCH (a:Account)-[e:Transfers]->(c:Account) -- path pattern 2 RETURN c.id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -15,36 +15,36 @@ RETURN c.id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 23, RParen: 40, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 24, NameEnd: 25, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ @@ -54,10 +54,10 @@ RETURN c.id }, }, }, - Filter: &ast.GqlPropertyFilters{ + Filter: &ast.GQLPropertyFilters{ LBrace: 33, - PropertyFilterElemList: []*ast.GqlElementProperty{ - &ast.GqlElementProperty{ + PropertyFilterElemList: []*ast.GQLElementProperty{ + &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ NamePos: 34, NameEnd: 36, @@ -77,17 +77,17 @@ RETURN c.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 41, Last: 50, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 43, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 44, IsPercent: false, LabelName: &ast.Ident{ @@ -102,21 +102,21 @@ RETURN c.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 51, RParen: 61, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 52, NameEnd: 53, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 53, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 54, IsPercent: false, LabelName: &ast.Ident{ @@ -134,11 +134,11 @@ RETURN c.id }, }, }, - &ast.GqlTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: &ast.Hint{ Atmark: 102, Rbrace: 159, @@ -169,19 +169,19 @@ RETURN c.id }, }, }, - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 181, RParen: 191, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 182, NameEnd: 183, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 183, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 184, IsPercent: false, LabelName: &ast.Ident{ @@ -196,21 +196,21 @@ RETURN c.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 192, Last: 207, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 194, NameEnd: 195, Name: "e", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 195, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 196, IsPercent: false, LabelName: &ast.Ident{ @@ -225,21 +225,21 @@ RETURN c.id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 208, RParen: 218, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 209, NameEnd: 210, Name: "c", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 210, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 211, IsPercent: false, LabelName: &ast.Ident{ @@ -261,10 +261,10 @@ RETURN c.id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 258, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 566cbe87..965ca81f 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -4,8 +4,8 @@ MATCH (source:Account)-[e:Transfers]->(destination:Account) LET a = source RETURN a.id AS a_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN a.id AS a_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 36, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 28, Name: "source", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 28, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 29, IsPercent: false, LabelName: &ast.Ident{ @@ -57,21 +57,21 @@ RETURN a.id AS a_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 37, Last: 52, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 39, NameEnd: 40, Name: "e", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 40, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 41, IsPercent: false, LabelName: &ast.Ident{ @@ -86,21 +86,21 @@ RETURN a.id AS a_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 53, RParen: 73, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 54, NameEnd: 65, Name: "destination", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ @@ -122,10 +122,10 @@ RETURN a.id AS a_id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlLetStatement{ + &ast.GQLLetStatement{ Let: 75, - LinearGraphVariableList: []*ast.GqlLinearGraphVariable{ - &ast.GqlLinearGraphVariable{ + LinearGraphVariableList: []*ast.GQLLinearGraphVariable{ + &ast.GQLLinearGraphVariable{ VariableName: &ast.Ident{ NamePos: 79, NameEnd: 80, @@ -139,10 +139,10 @@ RETURN a.id AS a_id }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 90, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index 22bcbb39..20530363 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -5,8 +5,8 @@ ORDER BY source.nick_name LIMIT 3 RETURN source.nick_name --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -14,36 +14,36 @@ RETURN source.nick_name Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 36, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 28, Name: "source", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 28, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 29, IsPercent: false, LabelName: &ast.Ident{ @@ -58,21 +58,21 @@ RETURN source.nick_name }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 37, Last: 52, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 39, NameEnd: 40, Name: "e", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 40, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 41, IsPercent: false, LabelName: &ast.Ident{ @@ -87,21 +87,21 @@ RETURN source.nick_name }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 53, RParen: 73, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 54, NameEnd: 65, Name: "destination", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ @@ -123,10 +123,10 @@ RETURN source.nick_name WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlOrderByStatement{ + &ast.GQLOrderByStatement{ Order: 75, - OrderBySpecificationList: []*ast.GqlOrderBySpecification{ - &ast.GqlOrderBySpecification{ + OrderBySpecificationList: []*ast.GQLOrderBySpecification{ + &ast.GQLOrderBySpecification{ Expr: &ast.Path{ Idents: []*ast.Ident{ &ast.Ident{ @@ -141,13 +141,13 @@ RETURN source.nick_name }, }, }, - CollationSpecification: (*ast.GqlCollationSpecification)(nil), + CollationSpecification: (*ast.GQLCollationSpecification)(nil), DirectionPos: -1, Direction: "", }, }, }, - &ast.GqlLimitStatement{ + &ast.GQLLimitStatement{ Limit: 101, Count: &ast.IntLiteral{ ValuePos: 107, @@ -156,10 +156,10 @@ RETURN source.nick_name Value: "3", }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 109, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt index 1f9e9fe7..103dd1a5 100644 --- a/testdata/result/gql/match.sql.txt +++ b/testdata/result/gql/match.sql.txt @@ -3,8 +3,8 @@ GRAPH FinGraph MATCH (p:Person) RETURN p.name, p.id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -12,36 +12,36 @@ RETURN p.name, p.id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -63,10 +63,10 @@ RETURN p.name, p.id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 32, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index 2da803ac..9f3f5135 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -5,8 +5,8 @@ WHERE a.is_blocked LET total = SUM(t.amount) RETURN a.id AS a_id, total, b.id AS b_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -14,40 +14,40 @@ RETURN a.id AS a_id, total, b.id AS b_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), - PrefixOrMode: &ast.GqlPathSearchPrefix{ + PrefixOrMode: &ast.GQLPathSearchPrefix{ StartPos: 21, LastEnd: 33, SearchPrefix: 2, }, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 34, RParen: 44, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 35, NameEnd: 36, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 36, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 37, IsPercent: false, LabelName: &ast.Ident{ @@ -62,21 +62,21 @@ RETURN a.id AS a_id, total, b.id AS b_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 45, Last: 60, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, NameEnd: 48, Name: "t", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 48, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 49, IsPercent: false, LabelName: &ast.Ident{ @@ -89,7 +89,7 @@ RETURN a.id AS a_id, total, b.id AS b_id Filter: nil, }, }, - Quantifier: &ast.GqlBoundedQuantifier{ + Quantifier: &ast.GQLBoundedQuantifier{ LBrace: 61, RBrace: 66, LowerBound: &ast.IntLiteral{ @@ -106,21 +106,21 @@ RETURN a.id AS a_id, total, b.id AS b_id }, }, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 68, RParen: 78, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 69, NameEnd: 70, Name: "b", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 70, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 71, IsPercent: false, LabelName: &ast.Ident{ @@ -158,10 +158,10 @@ RETURN a.id AS a_id, total, b.id AS b_id }, }, }, - &ast.GqlLetStatement{ + &ast.GQLLetStatement{ Let: 99, - LinearGraphVariableList: []*ast.GqlLinearGraphVariable{ - &ast.GqlLinearGraphVariable{ + LinearGraphVariableList: []*ast.GQLLinearGraphVariable{ + &ast.GQLLinearGraphVariable{ VariableName: &ast.Ident{ NamePos: 103, NameEnd: 108, @@ -197,10 +197,10 @@ RETURN a.id AS a_id, total, b.id AS b_id }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 125, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt index 847f72cc..2f6f3f0b 100644 --- a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -3,8 +3,8 @@ GRAPH FinGraph MATCH ANY SHORTEST (TRAIL ->{1,4}) RETURN COUNT(1) as num_paths --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -12,31 +12,31 @@ RETURN COUNT(1) as num_paths Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), - PrefixOrMode: &ast.GqlPathSearchPrefix{ + PrefixOrMode: &ast.GQLPathSearchPrefix{ StartPos: 21, LastEnd: 33, SearchPrefix: 2, }, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlSubpathPattern{ + PathTerm: &ast.GQLSubpathPattern{ LParen: 34, RParen: 48, - PathMode: &ast.GqlPathMode{ + PathMode: &ast.GQLPathMode{ Mode: 1, ModeToken: &ast.Ident{ NamePos: 35, @@ -45,15 +45,15 @@ RETURN COUNT(1) as num_paths }, PathOrPathsToken: (*ast.Ident)(nil), }, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlAbbreviatedEdgeRight{ + PathTerm: &ast.GQLAbbreviatedEdgeRight{ First: 41, Last: 42, }, - Quantifier: &ast.GqlBoundedQuantifier{ + Quantifier: &ast.GQLBoundedQuantifier{ LBrace: 43, RBrace: 47, LowerBound: &ast.IntLiteral{ @@ -83,10 +83,10 @@ RETURN COUNT(1) as num_paths WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 50, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ Rparen: 64, diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index c403cdd2..937ac62d 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -4,8 +4,8 @@ MATCH (n:Person) OPTIONAL MATCH (n:Person)-[:Owns]->(a:Account {is_blocked: TRUE}) RETURN n.name, a.id AS blocked_account_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN n.name, a.id AS blocked_account_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "n", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -64,32 +64,32 @@ RETURN n.name, a.id AS blocked_account_id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlMatchStatement{ + &ast.GQLMatchStatement{ Optional: 32, Match: 41, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 47, RParen: 56, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 48, NameEnd: 49, Name: "n", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 49, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 50, IsPercent: false, LabelName: &ast.Ident{ @@ -104,17 +104,17 @@ RETURN n.name, a.id AS blocked_account_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 57, Last: 66, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 59, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 60, IsPercent: false, LabelName: &ast.Ident{ @@ -129,21 +129,21 @@ RETURN n.name, a.id AS blocked_account_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 67, RParen: 96, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 68, NameEnd: 69, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 69, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 70, IsPercent: false, LabelName: &ast.Ident{ @@ -153,10 +153,10 @@ RETURN n.name, a.id AS blocked_account_id }, }, }, - Filter: &ast.GqlPropertyFilters{ + Filter: &ast.GQLPropertyFilters{ LBrace: 78, - PropertyFilterElemList: []*ast.GqlElementProperty{ - &ast.GqlElementProperty{ + PropertyFilterElemList: []*ast.GQLElementProperty{ + &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ NamePos: 79, NameEnd: 89, @@ -181,10 +181,10 @@ RETURN n.name, a.id AS blocked_account_id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 98, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt index e603d166..90fafae7 100644 --- a/testdata/result/gql/match_or_expression.sql.txt +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -3,8 +3,8 @@ GRAPH FinGraph MATCH (n:Person|Account) RETURN n.id, n.name, n.nick_name --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -12,37 +12,37 @@ RETURN n.id, n.name, n.nick_name Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 38, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "n", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelOrExpression{ - Left: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelOrExpression{ + Left: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -51,7 +51,7 @@ RETURN n.id, n.name, n.nick_name Name: "Person", }, }, - Right: &ast.GqlLabelName{ + Right: &ast.GQLLabelName{ StartPos: 31, IsPercent: false, LabelName: &ast.Ident{ @@ -74,10 +74,10 @@ RETURN n.id, n.name, n.nick_name WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 40, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index 5411ceb2..b397a05e 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -5,8 +5,8 @@ MATCH -[t4:Transfers]->(a5:Account) RETURN COUNT(1) as num_paths --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -14,27 +14,27 @@ RETURN COUNT(1) as num_paths Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlSubpathPattern{ + PathTerm: &ast.GQLSubpathPattern{ LParen: 23, RParen: 74, - PathMode: &ast.GqlPathMode{ + PathMode: &ast.GQLPathMode{ Mode: 1, ModeToken: &ast.Ident{ NamePos: 24, @@ -43,23 +43,23 @@ RETURN COUNT(1) as num_paths }, PathOrPathsToken: (*ast.Ident)(nil), }, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 30, RParen: 41, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 31, NameEnd: 33, Name: "a1", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ @@ -74,21 +74,21 @@ RETURN COUNT(1) as num_paths }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 42, Last: 58, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 44, NameEnd: 46, Name: "t1", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ @@ -101,7 +101,7 @@ RETURN COUNT(1) as num_paths Filter: nil, }, }, - Quantifier: &ast.GqlFixedQuantifier{ + Quantifier: &ast.GQLFixedQuantifier{ LBrace: 59, RBrace: 61, Bound: &ast.IntLiteral{ @@ -112,21 +112,21 @@ RETURN COUNT(1) as num_paths }, }, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 62, RParen: 73, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 63, NameEnd: 65, Name: "a4", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ @@ -147,21 +147,21 @@ RETURN COUNT(1) as num_paths }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 78, Last: 94, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 80, NameEnd: 82, Name: "t4", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 82, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 83, IsPercent: false, LabelName: &ast.Ident{ @@ -176,21 +176,21 @@ RETURN COUNT(1) as num_paths }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 95, RParen: 106, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 96, NameEnd: 98, Name: "a5", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 98, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 99, IsPercent: false, LabelName: &ast.Ident{ @@ -212,10 +212,10 @@ RETURN COUNT(1) as num_paths WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 108, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ Rparen: 122, diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 1c15ba1c..26523574 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -3,8 +3,8 @@ GRAPH FinGraph MATCH TRAIL (WALK (a1:Account)-[t1:Transfers]->{4}(a5:Account)) RETURN COUNT(1) as num_paths --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -12,15 +12,15 @@ RETURN COUNT(1) as num_paths Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), - PrefixOrMode: &ast.GqlPathMode{ + PrefixOrMode: &ast.GQLPathMode{ Mode: 1, ModeToken: &ast.Ident{ NamePos: 21, @@ -29,18 +29,18 @@ RETURN COUNT(1) as num_paths }, PathOrPathsToken: (*ast.Ident)(nil), }, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlSubpathPattern{ + PathTerm: &ast.GQLSubpathPattern{ LParen: 27, RParen: 77, - PathMode: &ast.GqlPathMode{ + PathMode: &ast.GQLPathMode{ Mode: 0, ModeToken: &ast.Ident{ NamePos: 28, @@ -49,23 +49,23 @@ RETURN COUNT(1) as num_paths }, PathOrPathsToken: (*ast.Ident)(nil), }, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 33, RParen: 44, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 34, NameEnd: 36, Name: "a1", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 36, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 37, IsPercent: false, LabelName: &ast.Ident{ @@ -80,21 +80,21 @@ RETURN COUNT(1) as num_paths }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 45, Last: 61, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, NameEnd: 49, Name: "t1", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 49, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 50, IsPercent: false, LabelName: &ast.Ident{ @@ -107,7 +107,7 @@ RETURN COUNT(1) as num_paths Filter: nil, }, }, - Quantifier: &ast.GqlFixedQuantifier{ + Quantifier: &ast.GQLFixedQuantifier{ LBrace: 62, RBrace: 64, Bound: &ast.IntLiteral{ @@ -118,21 +118,21 @@ RETURN COUNT(1) as num_paths }, }, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 65, RParen: 76, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 66, NameEnd: 68, Name: "a5", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 68, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 69, IsPercent: false, LabelName: &ast.Ident{ @@ -160,10 +160,10 @@ RETURN COUNT(1) as num_paths WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 79, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ Rparen: 93, diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index aea445ab..eef2a54d 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -4,8 +4,8 @@ MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS DESTINATION of transfer RETURN a.id AS a_id, b.id AS b_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN a.id AS a_id, b.id AS b_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 31, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -57,21 +57,21 @@ RETURN a.id AS a_id, b.id AS b_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeAny{ + PathTerm: &ast.GQLFullEdgeAny{ First: 32, Last: 53, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 34, NameEnd: 42, Name: "transfer", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 42, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 43, IsPercent: false, LabelName: &ast.Ident{ @@ -86,21 +86,21 @@ RETURN a.id AS a_id, b.id AS b_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 54, RParen: 64, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 55, NameEnd: 56, Name: "b", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 56, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 57, IsPercent: false, LabelName: &ast.Ident{ @@ -137,10 +137,10 @@ RETURN a.id AS a_id, b.id AS b_id }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 101, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index 88895295..c2035d3e 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -4,8 +4,8 @@ MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS SOURCE of transfer RETURN a.id AS a_id, b.id AS b_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN a.id AS a_id, b.id AS b_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 31, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -57,21 +57,21 @@ RETURN a.id AS a_id, b.id AS b_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeAny{ + PathTerm: &ast.GQLFullEdgeAny{ First: 32, Last: 53, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 34, NameEnd: 42, Name: "transfer", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 42, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 43, IsPercent: false, LabelName: &ast.Ident{ @@ -86,21 +86,21 @@ RETURN a.id AS a_id, b.id AS b_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 54, RParen: 64, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 55, NameEnd: 56, Name: "b", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 56, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 57, IsPercent: false, LabelName: &ast.Ident{ @@ -137,10 +137,10 @@ RETURN a.id AS a_id, b.id AS b_id }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 96, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index 7d58568f..b0d1c68c 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -4,8 +4,8 @@ MATCH (src:Account)<-[transfer:Transfers]-(dest:Account) WHERE NOT SAME(src, dest) RETURN src.id AS source_id, dest.id AS destination_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN src.id AS source_id, dest.id AS destination_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 33, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 25, Name: "src", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ @@ -57,21 +57,21 @@ RETURN src.id AS source_id, dest.id AS destination_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeLeft{ + PathTerm: &ast.GQLFullEdgeLeft{ First: 34, Last: 56, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 37, NameEnd: 45, Name: "transfer", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 45, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 46, IsPercent: false, LabelName: &ast.Ident{ @@ -86,21 +86,21 @@ RETURN src.id AS source_id, dest.id AS destination_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 57, RParen: 70, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 58, NameEnd: 62, Name: "dest", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 62, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 63, IsPercent: false, LabelName: &ast.Ident{ @@ -153,10 +153,10 @@ RETURN src.id AS source_id, dest.id AS destination_id }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 98, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/match_where_property_exists_return.sql.txt b/testdata/result/gql/match_where_property_exists_return.sql.txt index a4d96400..cdb4e1aa 100644 --- a/testdata/result/gql/match_where_property_exists_return.sql.txt +++ b/testdata/result/gql/match_where_property_exists_return.sql.txt @@ -3,8 +3,8 @@ GRAPH FinGraph MATCH (n:Person|Account WHERE PROPERTY_EXISTS(n, name)) RETURN n.name --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -12,37 +12,37 @@ RETURN n.name Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 69, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "n", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelOrExpression{ - Left: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelOrExpression{ + Left: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -51,7 +51,7 @@ RETURN n.name Name: "Person", }, }, - Right: &ast.GqlLabelName{ + Right: &ast.GQLLabelName{ StartPos: 31, IsPercent: false, LabelName: &ast.Ident{ @@ -101,10 +101,10 @@ RETURN n.name WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 71, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 92332a6e..9a3de88d 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -18,8 +18,8 @@ RETURN account_id, owner_name UNION ALL RETURN "Bob" AS owner_name, 100 AS account_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -27,32 +27,32 @@ RETURN "Bob" AS owner_name, 100 AS account_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ @@ -67,17 +67,17 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 45, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ @@ -92,21 +92,21 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 46, RParen: 62, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, NameEnd: 54, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ @@ -128,10 +128,10 @@ RETURN "Bob" AS owner_name, 100 AS account_id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 64, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ NamePos: 71, @@ -169,34 +169,34 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, }, }, - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 139, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 145, RParen: 161, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 146, NameEnd: 153, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 153, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 154, IsPercent: false, LabelName: &ast.Ident{ @@ -211,17 +211,17 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeLeft{ + PathTerm: &ast.GQLFullEdgeLeft{ First: 162, Last: 171, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 165, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 166, IsPercent: false, LabelName: &ast.Ident{ @@ -236,21 +236,21 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 172, RParen: 185, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 173, NameEnd: 178, Name: "owner", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 178, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 179, IsPercent: false, LabelName: &ast.Ident{ @@ -272,10 +272,10 @@ RETURN "Bob" AS owner_name, 100 AS account_id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 187, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ @@ -338,10 +338,10 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, }, }, - &ast.GqlCompositeLinearQueryStatement{ - HeadSimpleLinearQueryStatement: &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlFilterStatement{ + &ast.GQLCompositeLinearQueryStatement{ + HeadSimpleLinearQueryStatement: &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLFilterStatement{ Filter: 280, Where: -1, Expr: &ast.BinaryExpr{ @@ -359,10 +359,10 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 314, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ NamePos: 321, @@ -384,17 +384,17 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, }, }, - TailSimpleLinearQueryStatementList: []*ast.GqlSimpleLinearQueryStatementWithSetOperator{ - &ast.GqlSimpleLinearQueryStatementWithSetOperator{ + TailSimpleLinearQueryStatementList: []*ast.GQLSimpleLinearQueryStatementWithSetOperator{ + &ast.GQLSimpleLinearQueryStatementWithSetOperator{ StartPos: 344, SetOperator: 0, DistinctOrAll: 1, - Statement: &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + Statement: &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 354, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.StringLiteral{ ValuePos: 361, diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index e2c32602..79396f04 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -11,8 +11,8 @@ RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -20,32 +20,32 @@ RETURN Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ @@ -60,17 +60,17 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 45, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ @@ -85,21 +85,21 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 46, RParen: 62, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, NameEnd: 54, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ @@ -121,10 +121,10 @@ RETURN WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 64, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ NamePos: 71, @@ -162,34 +162,34 @@ RETURN }, }, }, - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 139, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 145, RParen: 161, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 146, NameEnd: 153, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 153, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 154, IsPercent: false, LabelName: &ast.Ident{ @@ -204,17 +204,17 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeLeft{ + PathTerm: &ast.GQLFullEdgeLeft{ First: 162, Last: 171, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 165, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 166, IsPercent: false, LabelName: &ast.Ident{ @@ -229,21 +229,21 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 172, RParen: 185, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 173, NameEnd: 178, Name: "owner", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 178, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 179, IsPercent: false, LabelName: &ast.Ident{ @@ -265,10 +265,10 @@ RETURN WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 187, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt index 93f98498..75978da2 100644 --- a/testdata/result/gql/offset_1.sql.txt +++ b/testdata/result/gql/offset_1.sql.txt @@ -4,8 +4,8 @@ MATCH (p:Person) OFFSET 2 RETURN p.name, p.id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN p.name, p.id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -64,7 +64,7 @@ RETURN p.name, p.id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlOffsetStatement{ + &ast.GQLOffsetStatement{ Offset: 32, IsSkip: false, Count: &ast.IntLiteral{ @@ -74,10 +74,10 @@ RETURN p.name, p.id Value: "2", }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 41, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index 19d16f2e..9e2e4c48 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -5,8 +5,8 @@ ORDER BY transfer.amount DESC LIMIT 3 RETURN src_account.id AS account_id, transfer.amount AS transfer_amount --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -14,36 +14,36 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 41, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 33, Name: "src_account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ @@ -58,21 +58,21 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 42, Last: 64, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 44, NameEnd: 52, Name: "transfer", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 52, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 53, IsPercent: false, LabelName: &ast.Ident{ @@ -87,21 +87,21 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 65, RParen: 85, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 66, NameEnd: 77, Name: "dst_account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 77, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 78, IsPercent: false, LabelName: &ast.Ident{ @@ -123,10 +123,10 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlOrderByStatement{ + &ast.GQLOrderByStatement{ Order: 87, - OrderBySpecificationList: []*ast.GqlOrderBySpecification{ - &ast.GqlOrderBySpecification{ + OrderBySpecificationList: []*ast.GQLOrderBySpecification{ + &ast.GQLOrderBySpecification{ Expr: &ast.Path{ Idents: []*ast.Ident{ &ast.Ident{ @@ -141,13 +141,13 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, }, }, - CollationSpecification: (*ast.GqlCollationSpecification)(nil), + CollationSpecification: (*ast.GQLCollationSpecification)(nil), DirectionPos: 112, Direction: "DESC", }, }, }, - &ast.GqlLimitStatement{ + &ast.GQLLimitStatement{ Limit: 117, Count: &ast.IntLiteral{ ValuePos: 123, @@ -156,10 +156,10 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount Value: "3", }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 125, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/order_by_collate.sql.txt b/testdata/result/gql/order_by_collate.sql.txt index 599e4020..31f949e3 100644 --- a/testdata/result/gql/order_by_collate.sql.txt +++ b/testdata/result/gql/order_by_collate.sql.txt @@ -1,8 +1,8 @@ --- order_by_collate.sql GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -10,36 +10,36 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -61,10 +61,10 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlOrderByStatement{ + &ast.GQLOrderByStatement{ Order: 32, - OrderBySpecificationList: []*ast.GqlOrderBySpecification{ - &ast.GqlOrderBySpecification{ + OrderBySpecificationList: []*ast.GQLOrderBySpecification{ + &ast.GQLOrderBySpecification{ Expr: &ast.Path{ Idents: []*ast.Ident{ &ast.Ident{ @@ -79,7 +79,7 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name }, }, }, - CollationSpecification: &ast.GqlCollationSpecification{ + CollationSpecification: &ast.GQLCollationSpecification{ Collate: 48, Specification: &ast.StringLiteral{ ValuePos: 56, @@ -92,10 +92,10 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 65, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index 36525ebb..fe90003a 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -10,8 +10,8 @@ MATCH (account:Account)<-[:Owns]-(owner:Person) RETURN owner.name AS owner_name, num_incoming_transfers ORDER BY num_incoming_transfers DESC --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -19,32 +19,32 @@ ORDER BY num_incoming_transfers DESC Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ @@ -59,17 +59,17 @@ ORDER BY num_incoming_transfers DESC }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 45, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ @@ -84,21 +84,21 @@ ORDER BY num_incoming_transfers DESC }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 46, RParen: 62, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, NameEnd: 54, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ @@ -120,10 +120,10 @@ ORDER BY num_incoming_transfers DESC WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 64, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ NamePos: 71, @@ -161,34 +161,34 @@ ORDER BY num_incoming_transfers DESC }, }, }, - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 139, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 145, RParen: 161, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 146, NameEnd: 153, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 153, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 154, IsPercent: false, LabelName: &ast.Ident{ @@ -203,17 +203,17 @@ ORDER BY num_incoming_transfers DESC }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeLeft{ + PathTerm: &ast.GQLFullEdgeLeft{ First: 162, Last: 171, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 165, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 166, IsPercent: false, LabelName: &ast.Ident{ @@ -228,21 +228,21 @@ ORDER BY num_incoming_transfers DESC }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 172, RParen: 185, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 173, NameEnd: 178, Name: "owner", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 178, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 179, IsPercent: false, LabelName: &ast.Ident{ @@ -264,10 +264,10 @@ ORDER BY num_incoming_transfers DESC WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 187, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index ee43e678..5e1a56bd 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -9,8 +9,8 @@ RETURN RETURN transfer.amount AS transfers } AS transfers --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -18,36 +18,36 @@ RETURN Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -62,17 +62,17 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 40, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ @@ -87,21 +87,21 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 41, RParen: 57, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 42, NameEnd: 49, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 49, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 50, IsPercent: false, LabelName: &ast.Ident{ @@ -123,10 +123,10 @@ RETURN WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 59, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ @@ -168,41 +168,41 @@ RETURN }, }, &ast.Alias{ - Expr: &ast.ArrayGqlSubQuery{ + Expr: &ast.ArrayGQLSubQuery{ Array: 102, RBrace: 225, - Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + Query: &ast.GQLQueryExpr{ + GraphClause: (*ast.GQLGraphClause)(nil), + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 113, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 119, RParen: 129, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 120, NameEnd: 121, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 121, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 122, IsPercent: false, LabelName: &ast.Ident{ @@ -217,21 +217,21 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 130, Last: 152, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 132, NameEnd: 140, Name: "transfer", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 140, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 141, IsPercent: false, LabelName: &ast.Ident{ @@ -246,17 +246,17 @@ RETURN }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 153, RParen: 162, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 154, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 155, IsPercent: false, LabelName: &ast.Ident{ @@ -293,10 +293,10 @@ RETURN }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 188, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index 3b364bd3..bc5673f8 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -3,8 +3,8 @@ GRAPH FinGraph MATCH (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account) RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -12,36 +12,36 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 41, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 25, Name: "src", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 26, IsPercent: false, LabelName: &ast.Ident{ @@ -51,10 +51,10 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, }, }, - Filter: &ast.GqlPropertyFilters{ + Filter: &ast.GQLPropertyFilters{ LBrace: 34, - PropertyFilterElemList: []*ast.GqlElementProperty{ - &ast.GqlElementProperty{ + PropertyFilterElemList: []*ast.GQLElementProperty{ + &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ NamePos: 35, NameEnd: 37, @@ -74,21 +74,21 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 42, Last: 57, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 44, NameEnd: 45, Name: "e", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 45, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 46, IsPercent: false, LabelName: &ast.Ident{ @@ -101,7 +101,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id Filter: nil, }, }, - Quantifier: &ast.GqlBoundedQuantifier{ + Quantifier: &ast.GQLBoundedQuantifier{ LBrace: 58, RBrace: 63, LowerBound: &ast.IntLiteral{ @@ -118,21 +118,21 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, }, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 64, RParen: 76, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 65, NameEnd: 68, Name: "dst", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 68, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 69, IsPercent: false, LabelName: &ast.Ident{ @@ -154,10 +154,10 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 78, AllOrDistinct: 2, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ Rparen: 108, diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index 9439fc7f..61a4c6e4 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -4,8 +4,8 @@ RETURN EXISTS { (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE 'D%' } AS results --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,39 +13,39 @@ RETURN EXISTS { Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 15, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ - Expr: &ast.ExistsGqlSubQuery{ + Expr: &ast.ExistsGQLSubQuery{ Exists: 22, RBrace: 89, - Query: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + Query: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 33, RParen: 42, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 34, NameEnd: 35, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 35, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 36, IsPercent: false, LabelName: &ast.Ident{ @@ -60,21 +60,21 @@ RETURN EXISTS { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 43, Last: 53, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 45, NameEnd: 46, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ @@ -89,21 +89,21 @@ RETURN EXISTS { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 54, RParen: 64, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 55, NameEnd: 56, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 56, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 57, IsPercent: false, LabelName: &ast.Ident{ diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index 6f592143..37018b7a 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -5,8 +5,8 @@ RETURN EXISTS { WHERE p.Name LIKE 'D%' } AS results --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -14,50 +14,50 @@ RETURN EXISTS { Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 15, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ - Expr: &ast.ExistsGqlSubQuery{ + Expr: &ast.ExistsGQLSubQuery{ Exists: 22, RBrace: 97, - Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + Query: &ast.GQLQueryExpr{ + GraphClause: (*ast.GQLGraphClause)(nil), + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 33, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 39, RParen: 48, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 40, NameEnd: 41, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 41, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 42, IsPercent: false, LabelName: &ast.Ident{ @@ -72,21 +72,21 @@ RETURN EXISTS { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 49, Last: 59, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 51, NameEnd: 52, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 52, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 53, IsPercent: false, LabelName: &ast.Ident{ @@ -101,21 +101,21 @@ RETURN EXISTS { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 60, RParen: 70, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 61, NameEnd: 62, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 62, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 63, IsPercent: false, LabelName: &ast.Ident{ diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index 7c15ee66..182b23b7 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -7,8 +7,8 @@ RETURN EXISTS { LIMIT 1 } AS results --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -16,50 +16,50 @@ RETURN EXISTS { Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 15, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ - Expr: &ast.ExistsGqlSubQuery{ + Expr: &ast.ExistsGQLSubQuery{ Exists: 22, RBrace: 123, - Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + Query: &ast.GQLQueryExpr{ + GraphClause: (*ast.GQLGraphClause)(nil), + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 33, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 39, RParen: 48, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 40, NameEnd: 41, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 41, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 42, IsPercent: false, LabelName: &ast.Ident{ @@ -74,21 +74,21 @@ RETURN EXISTS { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 49, Last: 59, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 51, NameEnd: 52, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 52, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 53, IsPercent: false, LabelName: &ast.Ident{ @@ -103,21 +103,21 @@ RETURN EXISTS { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 60, RParen: 70, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 61, NameEnd: 62, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 62, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 63, IsPercent: false, LabelName: &ast.Ident{ @@ -163,10 +163,10 @@ RETURN EXISTS { }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 99, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ @@ -186,7 +186,7 @@ RETURN EXISTS { }, GroupByClause: (*ast.GroupBy)(nil), OrderByClause: (*ast.OrderBy)(nil), - LimitAndOffsetClause: &ast.GqlLimitClause{ + LimitAndOffsetClause: &ast.GQLLimitClause{ Limit: &ast.Limit{ Limit: 115, Count: &ast.IntLiteral{ diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index 8aa1eab7..5c7a8b01 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -5,8 +5,8 @@ RETURN 'Dana' IN { RETURN p.name } AS results --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -14,14 +14,14 @@ RETURN 'Dana' IN { Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 15, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.InExpr{ Not: false, @@ -30,41 +30,41 @@ RETURN 'Dana' IN { ValueEnd: 28, Value: "Dana", }, - Right: &ast.GqlSubQueryInCondition{ + Right: &ast.GQLSubQueryInCondition{ LBrace: 32, RBrace: 91, - Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + Query: &ast.GQLQueryExpr{ + GraphClause: (*ast.GQLGraphClause)(nil), + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 36, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 42, RParen: 51, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 43, NameEnd: 44, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 45, IsPercent: false, LabelName: &ast.Ident{ @@ -79,21 +79,21 @@ RETURN 'Dana' IN { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 52, Last: 62, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 54, NameEnd: 55, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 55, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 56, IsPercent: false, LabelName: &ast.Ident{ @@ -108,21 +108,21 @@ RETURN 'Dana' IN { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 63, RParen: 73, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 64, NameEnd: 65, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 66, IsPercent: false, LabelName: &ast.Ident{ @@ -144,10 +144,10 @@ RETURN 'Dana' IN { WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 77, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/return_value_subquery.sql.txt b/testdata/result/gql/return_value_subquery.sql.txt index aced54e0..37a764cc 100644 --- a/testdata/result/gql/return_value_subquery.sql.txt +++ b/testdata/result/gql/return_value_subquery.sql.txt @@ -7,8 +7,8 @@ RETURN VALUE { LIMIT 1 } AS results --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -16,50 +16,50 @@ RETURN VALUE { Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 15, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ - Expr: &ast.ValueGqlSubQuery{ + Expr: &ast.ValueGQLSubQuery{ Array: 22, RBrace: 101, - Query: &ast.GqlQueryExpr{ - GraphClause: (*ast.GqlGraphClause)(nil), - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + Query: &ast.GQLQueryExpr{ + GraphClause: (*ast.GQLGraphClause)(nil), + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 32, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 38, RParen: 47, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 39, NameEnd: 40, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 40, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 41, IsPercent: false, LabelName: &ast.Ident{ @@ -105,10 +105,10 @@ RETURN VALUE { }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 77, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ @@ -128,7 +128,7 @@ RETURN VALUE { }, GroupByClause: (*ast.GroupBy)(nil), OrderByClause: (*ast.OrderBy)(nil), - LimitAndOffsetClause: &ast.GqlLimitClause{ + LimitAndOffsetClause: &ast.GQLLimitClause{ Limit: &ast.Limit{ Limit: 93, Count: &ast.IntLiteral{ diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt index 09e155ad..10316115 100644 --- a/testdata/result/gql/skip_1.sql.txt +++ b/testdata/result/gql/skip_1.sql.txt @@ -4,8 +4,8 @@ MATCH (p:Person) SKIP 2 RETURN p.name, p.id --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,36 +13,36 @@ RETURN p.name, p.id Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 22, NameEnd: 23, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 24, IsPercent: false, LabelName: &ast.Ident{ @@ -64,7 +64,7 @@ RETURN p.name, p.id WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlOffsetStatement{ + &ast.GQLOffsetStatement{ Offset: 32, IsSkip: true, Count: &ast.IntLiteral{ @@ -74,10 +74,10 @@ RETURN p.name, p.id Value: "2", }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 39, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index 9ae17931..8bce3ea7 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -4,8 +4,8 @@ MATCH (:Account)-[:Transfers]->(account:Account) WITH account, COUNT(*) AS num_incoming_transfers GROUP BY account RETURN account.id AS account_id, num_incoming_transfers --- AST -&ast.GqlGraphQuery{ - GraphClause: &ast.GqlGraphClause{ +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ Graph: 0, PropertyGraphName: &ast.Ident{ NamePos: 6, @@ -13,32 +13,32 @@ RETURN account.id AS account_id, num_incoming_transfers Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 21, RParen: 30, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 23, IsPercent: false, LabelName: &ast.Ident{ @@ -53,17 +53,17 @@ RETURN account.id AS account_id, num_incoming_transfers }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 31, Last: 45, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 34, IsPercent: false, LabelName: &ast.Ident{ @@ -78,21 +78,21 @@ RETURN account.id AS account_id, num_incoming_transfers }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 46, RParen: 62, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 47, NameEnd: 54, Name: "account", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 55, IsPercent: false, LabelName: &ast.Ident{ @@ -114,10 +114,10 @@ RETURN account.id AS account_id, num_incoming_transfers WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlWithStatement{ + &ast.GQLWithStatement{ With: 64, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ NamePos: 69, @@ -151,10 +151,10 @@ RETURN account.id AS account_id, num_incoming_transfers }, }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 130, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/gql_path_pattern/abbr_edge_any.sql.txt b/testdata/result/gql_path_pattern/abbr_edge_any.sql.txt index 76b1ebd4..f4e7a168 100644 --- a/testdata/result/gql_path_pattern/abbr_edge_any.sql.txt +++ b/testdata/result/gql_path_pattern/abbr_edge_any.sql.txt @@ -1,11 +1,11 @@ --- abbr_edge_any.sql - --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlAbbreviatedEdgeAny{ + PathTerm: &ast.GQLAbbreviatedEdgeAny{ Hyphen: 1, }, Quantifier: nil, diff --git a/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt b/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt index aae389f5..48414103 100644 --- a/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt +++ b/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt @@ -1,11 +1,11 @@ --- abbreviated_edge_left.sql <- --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlAbbreviatedEdgeLeft{ + PathTerm: &ast.GQLAbbreviatedEdgeLeft{ First: 1, Last: 2, }, diff --git a/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt index 73ae0445..325279ea 100644 --- a/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt +++ b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt @@ -1,11 +1,11 @@ --- abbreviated_edge_right.sql -> --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlAbbreviatedEdgeRight{ + PathTerm: &ast.GQLAbbreviatedEdgeRight{ First: 1, Last: 2, }, diff --git a/testdata/result/gql_path_pattern/full_edge_any.sql.txt b/testdata/result/gql_path_pattern/full_edge_any.sql.txt index 936a34da..a8ac48ea 100644 --- a/testdata/result/gql_path_pattern/full_edge_any.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_any.sql.txt @@ -1,21 +1,21 @@ --- full_edge_any.sql -[a]- --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeAny{ + PathTerm: &ast.GQLFullEdgeAny{ First: 1, Last: 5, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 3, NameEnd: 4, Name: "a", }, - IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + IsLabelCondition: (*ast.GQLIsLabelCondition)(nil), Filter: nil, }, }, diff --git a/testdata/result/gql_path_pattern/full_edge_left.sql.txt b/testdata/result/gql_path_pattern/full_edge_left.sql.txt index f2449421..ded1e737 100644 --- a/testdata/result/gql_path_pattern/full_edge_left.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_left.sql.txt @@ -1,21 +1,21 @@ --- full_edge_left.sql <-[a]- --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeLeft{ + PathTerm: &ast.GQLFullEdgeLeft{ First: 2, Last: 7, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 5, NameEnd: 6, Name: "a", }, - IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + IsLabelCondition: (*ast.GQLIsLabelCondition)(nil), Filter: nil, }, }, diff --git a/testdata/result/gql_path_pattern/full_edge_right.sql.txt b/testdata/result/gql_path_pattern/full_edge_right.sql.txt index 0eabfb87..bbe04904 100644 --- a/testdata/result/gql_path_pattern/full_edge_right.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_right.sql.txt @@ -1,17 +1,17 @@ --- full_edge_right.sql -[]-> --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 1, Last: 5, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + IsLabelCondition: (*ast.GQLIsLabelCondition)(nil), Filter: nil, }, }, diff --git a/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt index 5eec245a..64933454 100644 --- a/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt +++ b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt @@ -1,17 +1,17 @@ --- node_pattern_unnamed.sql () --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 1, RParen: 2, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), - IsLabelCondition: (*ast.GqlIsLabelCondition)(nil), + IsLabelCondition: (*ast.GQLIsLabelCondition)(nil), Filter: nil, }, }, diff --git a/testdata/result/gql_path_pattern/pattern_1.sql.txt b/testdata/result/gql_path_pattern/pattern_1.sql.txt index be2b9c00..cee9e98a 100644 --- a/testdata/result/gql_path_pattern/pattern_1.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_1.sql.txt @@ -1,23 +1,23 @@ --- pattern_1.sql (p:%) --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 0, RParen: 4, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 1, NameEnd: 2, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 2, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 3, IsPercent: true, LabelName: (*ast.Ident)(nil), diff --git a/testdata/result/gql_path_pattern/pattern_2.sql.txt b/testdata/result/gql_path_pattern/pattern_2.sql.txt index 4c80f75d..6e002636 100644 --- a/testdata/result/gql_path_pattern/pattern_2.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_2.sql.txt @@ -1,27 +1,27 @@ --- pattern_2.sql (p:(Singer|(!Writer&!Producer))) --- AST -&ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 0, RParen: 31, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 1, NameEnd: 2, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 2, - LabelExpression: &ast.GqlLabelParenExpression{ + LabelExpression: &ast.GQLLabelParenExpression{ LParen: 3, RParen: 30, - LabelExpr: &ast.GqlLabelOrExpression{ - Left: &ast.GqlLabelName{ + LabelExpr: &ast.GQLLabelOrExpression{ + Left: &ast.GQLLabelName{ StartPos: 4, IsPercent: false, LabelName: &ast.Ident{ @@ -30,13 +30,13 @@ Name: "Singer", }, }, - Right: &ast.GqlLabelParenExpression{ + Right: &ast.GQLLabelParenExpression{ LParen: 11, RParen: 29, - LabelExpr: &ast.GqlLabelNotExpression{ + LabelExpr: &ast.GQLLabelNotExpression{ Not: 12, - LabelExpression: &ast.GqlLabelAndExpression{ - Left: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelAndExpression{ + Left: &ast.GQLLabelName{ StartPos: 13, IsPercent: false, LabelName: &ast.Ident{ @@ -45,9 +45,9 @@ Name: "Writer", }, }, - Right: &ast.GqlLabelNotExpression{ + Right: &ast.GQLLabelNotExpression{ Not: 20, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 21, IsPercent: false, LabelName: &ast.Ident{ diff --git a/testdata/result/query/select_from_graph_table.sql.txt b/testdata/result/query/select_from_graph_table.sql.txt index 3f8ec63b..41d90400 100644 --- a/testdata/result/query/select_from_graph_table.sql.txt +++ b/testdata/result/query/select_from_graph_table.sql.txt @@ -24,14 +24,14 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) }, Lparen: 25, Rparen: 48, - Query: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + Query: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 35, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.IntLiteral{ ValuePos: 42, diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index 9cca0d52..3bdf7a00 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -21,11 +21,11 @@ SELECT 'Dana' IN { ValueEnd: 13, Value: "Dana", }, - Right: &ast.GqlSubQueryInCondition{ + Right: &ast.GQLSubQueryInCondition{ LBrace: 17, RBrace: 93, - Query: &ast.GqlQueryExpr{ - GraphClause: &ast.GqlGraphClause{ + Query: &ast.GQLQueryExpr{ + GraphClause: &ast.GQLGraphClause{ Graph: 21, PropertyGraphName: &ast.Ident{ NamePos: 27, @@ -33,36 +33,36 @@ SELECT 'Dana' IN { Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 38, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 44, RParen: 53, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 45, NameEnd: 46, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ @@ -77,21 +77,21 @@ SELECT 'Dana' IN { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 54, Last: 64, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 56, NameEnd: 57, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 57, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 58, IsPercent: false, LabelName: &ast.Ident{ @@ -106,21 +106,21 @@ SELECT 'Dana' IN { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 65, RParen: 75, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 66, NameEnd: 67, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 67, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 68, IsPercent: false, LabelName: &ast.Ident{ @@ -142,10 +142,10 @@ SELECT 'Dana' IN { WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 79, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/testdata/result/statement/select_from_graph_table.sql.txt b/testdata/result/statement/select_from_graph_table.sql.txt index 3f8ec63b..41d90400 100644 --- a/testdata/result/statement/select_from_graph_table.sql.txt +++ b/testdata/result/statement/select_from_graph_table.sql.txt @@ -24,14 +24,14 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) }, Lparen: 25, Rparen: 48, - Query: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlReturnStatement{ + Query: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLReturnStatement{ Return: 35, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.IntLiteral{ ValuePos: 42, diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index 9cca0d52..3bdf7a00 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -21,11 +21,11 @@ SELECT 'Dana' IN { ValueEnd: 13, Value: "Dana", }, - Right: &ast.GqlSubQueryInCondition{ + Right: &ast.GQLSubQueryInCondition{ LBrace: 17, RBrace: 93, - Query: &ast.GqlQueryExpr{ - GraphClause: &ast.GqlGraphClause{ + Query: &ast.GQLQueryExpr{ + GraphClause: &ast.GQLGraphClause{ Graph: 21, PropertyGraphName: &ast.Ident{ NamePos: 27, @@ -33,36 +33,36 @@ SELECT 'Dana' IN { Name: "FinGraph", }, }, - MultiLinearQueryStatement: &ast.GqlMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GqlLinearQueryStatement{ - &ast.GqlSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GqlPrimitiveQueryStatement{ - &ast.GqlMatchStatement{ + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ Optional: -1, Match: 38, MatchHint: (*ast.Hint)(nil), PrefixOrMode: nil, - GraphPattern: &ast.GqlGraphPattern{ - PathPatternList: []*ast.GqlTopLevelPathPattern{ - &ast.GqlTopLevelPathPattern{ + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GqlPathPattern{ - PathTermList: []*ast.GqlQuantifiablePathTerm{ - &ast.GqlQuantifiablePathTerm{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 44, RParen: 53, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 45, NameEnd: 46, Name: "p", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 47, IsPercent: false, LabelName: &ast.Ident{ @@ -77,21 +77,21 @@ SELECT 'Dana' IN { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlFullEdgeRight{ + PathTerm: &ast.GQLFullEdgeRight{ First: 54, Last: 64, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 56, NameEnd: 57, Name: "o", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 57, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 58, IsPercent: false, LabelName: &ast.Ident{ @@ -106,21 +106,21 @@ SELECT 'Dana' IN { }, Quantifier: nil, }, - &ast.GqlQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), - PathTerm: &ast.GqlNodePattern{ + PathTerm: &ast.GQLNodePattern{ LParen: 65, RParen: 75, - PatternFiller: &ast.GqlPatternFiller{ + PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ NamePos: 66, NameEnd: 67, Name: "a", }, - IsLabelCondition: &ast.GqlIsLabelCondition{ + IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 67, - LabelExpression: &ast.GqlLabelName{ + LabelExpression: &ast.GQLLabelName{ StartPos: 68, IsPercent: false, LabelName: &ast.Ident{ @@ -142,10 +142,10 @@ SELECT 'Dana' IN { WhereClause: (*ast.Where)(nil), }, }, - &ast.GqlReturnStatement{ + &ast.GQLReturnStatement{ Return: 79, AllOrDistinct: 0, - ReturnItemList: []ast.GqlReturnItem{ + ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ Idents: []*ast.Ident{ diff --git a/tools/parse/main.go b/tools/parse/main.go index 983a85fe..dd645851 100644 --- a/tools/parse/main.go +++ b/tools/parse/main.go @@ -45,9 +45,9 @@ func main() { case "dml": node, err = p.ParseDML() case "gql": - node, err = p.ParseGqlStatement() + node, err = p.ParseGQLStatement() case "gql_path_pattern": - node, err = p.ParseGqlPathPattern() + node, err = p.ParseGQLPathPattern() } if err != nil { log.Fatal(err) From 078a7cfa6bf1ba47242ed5eeb695dffea94514f2 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 17 Sep 2024 17:53:59 +0900 Subject: [PATCH 33/53] Remove redundant iota --- ast/const.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ast/const.go b/ast/const.go index 0b6bd7b8..2212f259 100644 --- a/ast/const.go +++ b/ast/const.go @@ -135,7 +135,7 @@ type GQLAllOrDistinctEnum int const ( GQLAllOrDistinctImplicitAll GQLAllOrDistinctEnum = iota - GQLAllOrDistinctAll = iota + GQLAllOrDistinctAll GQLAllOrDistinctDistinct ) From 57e36495ff87b0056eb86a341b9f0191fca60d32 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 18 Sep 2024 05:47:12 +0900 Subject: [PATCH 34/53] Improve EXISTS { match_statement } pattern --- ast/ast.go | 6 +- ast/pos.go | 2 +- parser.go | 24 +- .../result/gql/return_exists_match.sql.txt | 233 +++++++++--------- 4 files changed, 136 insertions(+), 129 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index 94a5fd1c..2b4d042f 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -1188,7 +1188,7 @@ type ArrayGQLSubQuery struct { // end = RBrace + 1 Array token.Pos // position of "ARRAY" keyword - RBrace token.Pos // position of "{" and "}" + RBrace token.Pos // position of "}" Query *GQLQueryExpr } @@ -1200,7 +1200,7 @@ type ValueGQLSubQuery struct { // end = RBrace + 1 Array token.Pos // position of "ARRAY" keyword - RBrace token.Pos // position of "{" and "}" + RBrace token.Pos // position of "}" Query *GQLQueryExpr } @@ -1212,7 +1212,7 @@ type ExistsGQLSubQuery struct { // end = RBrace + 1 Exists token.Pos // position of "ARRAY" keyword - RBrace token.Pos // position of "{" and "}" + RBrace token.Pos // "}" Query GQLExistsExpr } diff --git a/ast/pos.go b/ast/pos.go index ef562e46..48fb51f4 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -496,7 +496,7 @@ func (c *CastNumValue) End() token.Pos { return c.Rparen + 1 } // ================================================================================ func (v *ValueGQLSubQuery) Pos() token.Pos { return v.Array } -func (v *ValueGQLSubQuery) End() token.Pos { return v.Query.End() } +func (v *ValueGQLSubQuery) End() token.Pos { return v.RBrace + 1 } func (a *ArrayGQLSubQuery) Pos() token.Pos { return a.Array } func (a *ArrayGQLSubQuery) End() token.Pos { return a.RBrace + 1 } diff --git a/parser.go b/parser.go index cf9c267e..101ce15d 100644 --- a/parser.go +++ b/parser.go @@ -1698,10 +1698,28 @@ func (p *Parser) lookaheadGQLGraphPattern() bool { } +// lookaheadGQLExistsExprMatch checks the next statement is a MATCH statement followed by "}". +func (p *Parser) lookaheadGQLExistsExprMatch() bool { + lexer := p.Lexer.Clone() + defer func() { + p.Lexer = lexer + }() + + if !p.Token.IsKeywordLike("MATCH") { + return false + } + p.parseGQLMatchStatement() + + if p.Token.Kind != "}" { + return false + } + return true +} + func (p *Parser) parseGQLExistsExpr() ast.GQLExistsExpr { - // NOTE: Single MATCH statement pattern is covered by GQLQueryExpr - // because there is no check that SimpleLinearQueryStatement is terminated by RETURN statement. - if p.lookaheadGQLGraphPattern() { + if p.lookaheadGQLExistsExprMatch() { + return p.parseGQLMatchStatement() + } else if p.lookaheadGQLGraphPattern() { return p.parseGQLGraphPattern() } else { return p.parseGQLQueryExpr() diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index 37018b7a..e858e672 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -26,144 +26,133 @@ RETURN EXISTS { Expr: &ast.ExistsGQLSubQuery{ Exists: 22, RBrace: 97, - Query: &ast.GQLQueryExpr{ - GraphClause: (*ast.GQLGraphClause)(nil), - MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ - LinearQueryStatementList: []ast.GQLLinearQueryStatement{ - &ast.GQLSimpleLinearQueryStatement{ - PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ - &ast.GQLMatchStatement{ - Optional: -1, - Match: 33, - MatchHint: (*ast.Hint)(nil), - PrefixOrMode: nil, - GraphPattern: &ast.GQLGraphPattern{ - PathPatternList: []*ast.GQLTopLevelPathPattern{ - &ast.GQLTopLevelPathPattern{ - PathSearchPrefixOrPathMode: nil, - PathPattern: &ast.GQLPathPattern{ - PathTermList: []*ast.GQLQuantifiablePathTerm{ - &ast.GQLQuantifiablePathTerm{ - Hint: (*ast.Hint)(nil), - PathTerm: &ast.GQLNodePattern{ - LParen: 39, - RParen: 48, - PatternFiller: &ast.GQLPatternFiller{ - Hint: (*ast.Hint)(nil), - GraphPatternVariable: &ast.Ident{ - NamePos: 40, - NameEnd: 41, - Name: "p", - }, - IsLabelCondition: &ast.GQLIsLabelCondition{ - IsOrColon: 41, - LabelExpression: &ast.GQLLabelName{ - StartPos: 42, - IsPercent: false, - LabelName: &ast.Ident{ - NamePos: 42, - NameEnd: 48, - Name: "Person", - }, - }, - }, - Filter: nil, - }, - }, - Quantifier: nil, - }, - &ast.GQLQuantifiablePathTerm{ - Hint: (*ast.Hint)(nil), - PathTerm: &ast.GQLFullEdgeRight{ - First: 49, - Last: 59, - PatternFiller: &ast.GQLPatternFiller{ - Hint: (*ast.Hint)(nil), - GraphPatternVariable: &ast.Ident{ - NamePos: 51, - NameEnd: 52, - Name: "o", - }, - IsLabelCondition: &ast.GQLIsLabelCondition{ - IsOrColon: 52, - LabelExpression: &ast.GQLLabelName{ - StartPos: 53, - IsPercent: false, - LabelName: &ast.Ident{ - NamePos: 53, - NameEnd: 57, - Name: "Owns", - }, - }, - }, - Filter: nil, - }, - }, - Quantifier: nil, - }, - &ast.GQLQuantifiablePathTerm{ - Hint: (*ast.Hint)(nil), - PathTerm: &ast.GQLNodePattern{ - LParen: 60, - RParen: 70, - PatternFiller: &ast.GQLPatternFiller{ - Hint: (*ast.Hint)(nil), - GraphPatternVariable: &ast.Ident{ - NamePos: 61, - NameEnd: 62, - Name: "a", - }, - IsLabelCondition: &ast.GQLIsLabelCondition{ - IsOrColon: 62, - LabelExpression: &ast.GQLLabelName{ - StartPos: 63, - IsPercent: false, - LabelName: &ast.Ident{ - NamePos: 63, - NameEnd: 70, - Name: "Account", - }, - }, - }, - Filter: nil, - }, - }, - Quantifier: nil, + Query: &ast.GQLMatchStatement{ + Optional: -1, + Match: 33, + MatchHint: (*ast.Hint)(nil), + PrefixOrMode: nil, + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ + PathSearchPrefixOrPathMode: nil, + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GQLNodePattern{ + LParen: 39, + RParen: 48, + PatternFiller: &ast.GQLPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 40, + NameEnd: 41, + Name: "p", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 41, + LabelExpression: &ast.GQLLabelName{ + StartPos: 42, + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 42, + NameEnd: 48, + Name: "Person", }, }, }, + Filter: nil, }, }, - WhereClause: &ast.Where{ - Where: 74, - Expr: &ast.BinaryExpr{ - Op: "LIKE", - Left: &ast.Path{ - Idents: []*ast.Ident{ - &ast.Ident{ - NamePos: 80, - NameEnd: 81, - Name: "p", - }, - &ast.Ident{ - NamePos: 82, - NameEnd: 86, - Name: "Name", + Quantifier: nil, + }, + &ast.GQLQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GQLFullEdgeRight{ + First: 49, + Last: 59, + PatternFiller: &ast.GQLPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 51, + NameEnd: 52, + Name: "o", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 52, + LabelExpression: &ast.GQLLabelName{ + StartPos: 53, + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 53, + NameEnd: 57, + Name: "Owns", }, }, }, - Right: &ast.StringLiteral{ - ValuePos: 92, - ValueEnd: 96, - Value: "D%", + Filter: nil, + }, + }, + Quantifier: nil, + }, + &ast.GQLQuantifiablePathTerm{ + Hint: (*ast.Hint)(nil), + PathTerm: &ast.GQLNodePattern{ + LParen: 60, + RParen: 70, + PatternFiller: &ast.GQLPatternFiller{ + Hint: (*ast.Hint)(nil), + GraphPatternVariable: &ast.Ident{ + NamePos: 61, + NameEnd: 62, + Name: "a", }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 62, + LabelExpression: &ast.GQLLabelName{ + StartPos: 63, + IsPercent: false, + LabelName: &ast.Ident{ + NamePos: 63, + NameEnd: 70, + Name: "Account", + }, + }, + }, + Filter: nil, }, }, + Quantifier: nil, }, }, }, }, }, + WhereClause: &ast.Where{ + Where: 74, + Expr: &ast.BinaryExpr{ + Op: "LIKE", + Left: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 80, + NameEnd: 81, + Name: "p", + }, + &ast.Ident{ + NamePos: 82, + NameEnd: 86, + Name: "Name", + }, + }, + }, + Right: &ast.StringLiteral{ + ValuePos: 92, + ValueEnd: 96, + Value: "D%", + }, + }, + }, }, }, }, From 03a07548c7582268074e21ecd0e74b65b21a23f2 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 18 Sep 2024 06:14:01 +0900 Subject: [PATCH 35/53] Strictify parseGQLSimpleLinearQueryStatement --- ast/ast.go | 3 ++- parser.go | 18 +++++++++++++++++- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index 2b4d042f..e98dcd72 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -2587,8 +2587,9 @@ func (*GQLCompositeLinearQueryStatement) isGQLLinearQueryStatement() {} type GQLSimpleLinearQueryStatement struct { // pos = PrimitiveQueryStatementList[0].pos - // end = PrimitiveQueryStatementList[$].end + // end = PrimitiveQueryStatementList[$].pos + // It contains at least one GQL statements, and It ends with a RETURN statement. PrimitiveQueryStatementList []GQLPrimitiveQueryStatement } diff --git a/parser.go b/parser.go index 101ce15d..cb30348f 100644 --- a/parser.go +++ b/parser.go @@ -3926,7 +3926,23 @@ func (p *Parser) parseGQLSimpleLinearQueryStatement() *ast.GQLSimpleLinearQueryS stmts = append(stmts, stmt) } - return &ast.GQLSimpleLinearQueryStatement{PrimitiveQueryStatementList: stmts} + if len(stmts) == 0 { + p.panicfAtToken(&p.Token, "expect one or more GQL statements, but: %v", p.Token.Kind) + } + + if _, ok := stmts[len(stmts)-1].(*ast.GQLReturnStatement); !ok { + p.panicf("the last GQL statement of simple_linear_query_statement must be a RETURN statement") + } + + for _, stmt := range stmts[:len(stmts)-1] { + if _, ok := stmt.(*ast.GQLReturnStatement); ok { + p.panicf("multiple RETURN statements are not permitted in simple_linear_query_statement") + } + } + + return &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: stmts, + } } func (p *Parser) tryParseGQLWithOffsetClause() *ast.GQLWithOffsetClause { From d9a5811d54e4b72a271862ade96d1ed969769e22 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 18 Sep 2024 13:32:26 +0900 Subject: [PATCH 36/53] Update go doc comments, modify enums --- ast/ast.go | 215 +++++++++++++++++++++++++++++++++++++++++---------- ast/const.go | 43 ++++++----- parser.go | 2 +- 3 files changed, 197 insertions(+), 63 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index e98dcd72..2e43891b 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -1182,7 +1182,7 @@ type ArraySubQuery struct { // ArrayGQLSubQuery is GQL subquery as ARRAY. // -// ARRAY{{"{"}}{{.Query | sql}}{{"}"}} +// ARRAY {{"{"}}{{.Query | sql}}{{"}"}} type ArrayGQLSubQuery struct { // pos = Array // end = RBrace + 1 @@ -1194,7 +1194,7 @@ type ArrayGQLSubQuery struct { // ValueGQLSubQuery is GQL subquery as VALUE. // -// VALUE{{"{"}}{{.Query | sql}}{{"}"}} +// VALUE {{"{"}}{{.Query | sql}}{{"}"}} type ValueGQLSubQuery struct { // pos = Array // end = RBrace + 1 @@ -2544,6 +2544,9 @@ type SequenceOptions struct { // ================================================================================ // GQLGraphQuery is toplevel node of GRAPH query. +// +// {{.Graph | sql}} +// {{.MultiLinearQueryStatement | sql}} type GQLGraphQuery struct { // pos = (GraphClause ?? MultiLinearQueryStatement).pos // end = MultiLinearQueryStatement.end @@ -2554,6 +2557,9 @@ type GQLGraphQuery struct { // GQLQueryExpr is similar to GQLGraphQuery, // but it is appeared in GQL subqueries and it can optionally have GRAPH clause +// +// {{.Graph | sqlOpt}} +// {{.MultiLinearQueryStatement | sql}} type GQLQueryExpr struct { // pos = (GraphClause ?? MultiLinearQueryStatement).pos // end = MultiLinearQueryStatement.end @@ -2562,6 +2568,9 @@ type GQLQueryExpr struct { MultiLinearQueryStatement *GQLMultiLinearQueryStatement } +// GQLGraphClause represents `GRAPH property_graph_name`. +// +// GRAPH {{.PropertyGraphName | sql}} type GQLGraphClause struct { // pos = Graph // end = PropertyGraphName.end @@ -2570,6 +2579,10 @@ type GQLGraphClause struct { PropertyGraphName *Ident } +// GQLMultiLinearQueryStatement is the body of a GQLGraphClause and GQLQueryExpr. +// It contains a list of LinearQueryStatementList chained together with the NEXT statement. +// +// {{.LinearQueryStatementList || sqlJoin "\nNEXT\n"}} type GQLMultiLinearQueryStatement struct { // pos = LinearQueryStatementList[0].pos // pos = LinearQueryStatementList[$].end @@ -2585,14 +2598,20 @@ type GQLLinearQueryStatement interface { func (*GQLSimpleLinearQueryStatement) isGQLLinearQueryStatement() {} func (*GQLCompositeLinearQueryStatement) isGQLLinearQueryStatement() {} +// GQLSimpleLinearQueryStatement represents a list of primitive_query_statements that ends with a RETURN statement. +// +// {{.PrimitiveQueryStatementList | sqlJoin "\n"}} type GQLSimpleLinearQueryStatement struct { // pos = PrimitiveQueryStatementList[0].pos - // end = PrimitiveQueryStatementList[$].pos + // end = PrimitiveQueryStatementList[$].end // It contains at least one GQL statements, and It ends with a RETURN statement. PrimitiveQueryStatementList []GQLPrimitiveQueryStatement } +// GQLSimpleLinearQueryStatementWithSetOperator represents GQLSimpleLinearQueryStatement composited with the set operators. +// +// // TODO: {{string(SetOperator)}} type GQLSimpleLinearQueryStatementWithSetOperator struct { // pos = StartPos // end = Statement.end @@ -2603,6 +2622,10 @@ type GQLSimpleLinearQueryStatementWithSetOperator struct { Statement *GQLSimpleLinearQueryStatement } +// GQLCompositeLinearQueryStatement represents a list of GQLSimpleLinearQueryStatement composited with the set operators. +// +// {{.HeadSimpleLinearQueryStatement | sql}} +// {{.TailSimpleLinearQueryStatementList | sqlJoin "\n"}} type GQLCompositeLinearQueryStatement struct { // pos = HeadSimpleLinearStatement.pos // end = TailSimpleLinearStatement.pos @@ -2632,8 +2655,12 @@ func (*GQLMatchStatement) isGQLPrimitiveQueryStatement() {} func (*GQLLetStatement) isGQLPrimitiveQueryStatement() {} func (*GQLReturnStatement) isGQLPrimitiveQueryStatement() {} +// GQLMatchStatement represents MATCH statement. +// +// {{if .Optional.Invalid | not}}OPTIONAL {{end-}} +// MATCH // {{.MatchHint | sqlOpt}} // {{.PrefixOrMode | sqlOpt}} {{.GraphPattern | sql}} type GQLMatchStatement struct { - // pos = (Optional ?? Match) + // pos = Optional || Match // end = GraphPattern.end Optional token.Pos //optional @@ -2653,6 +2680,9 @@ func (g *GQLLimitClause) isGQLLimitAndOffsetClause() {} func (g *GQLOffsetClause) isGQLLimitAndOffsetClause() {} func (g *GQLLimitWithOffsetClause) isGQLLimitAndOffsetClause() {} +// GQLFilterStatement represents `FILTER [WHERE] bool_expression` +// +// FILTER {{if .Where.Invalid | not}}WHERE{{end}} {{.Expr | sql}} type GQLFilterStatement struct { // pos = Filter // end = Expr.end @@ -2662,6 +2692,9 @@ type GQLFilterStatement struct { Expr Expr } +// GQLForStatement represents GQL FOR statement. +// +// FOR {{.ElementName | sql}} IN {{.ArrayExpression | sqlJoin ", "}} {{.WithOffsetClause | sqlOpt}} type GQLForStatement struct { // pos = For // end = (WithOffsetClause ?? ArrayExpression).end @@ -2672,6 +2705,9 @@ type GQLForStatement struct { WithOffsetClause *GQLWithOffsetClause } +// GQLWithOffsetClause represents `WITH OFFSET [AS offset_name]` in FOR statement. +// +// WITH OFFSET {{if isnil .OffsetName | not}}AS {{.OffsetName | sql}}{{end}} type GQLWithOffsetClause struct { // pos = With.pos // end = OffsetName.end ?? Offset + 6 @@ -2682,20 +2718,27 @@ type GQLWithOffsetClause struct { } // GQLLimitClause is wrapper of Limit for GQL +// +// {{.Limit | sql}} type GQLLimitClause struct { // pos = Limit.pos // end = Limit.end + Limit *Limit } // GQLOffsetClause is wrapper of Offset for GQL +// +// {{.Offset | sql}} type GQLOffsetClause struct { // pos = Offset.pos // end = Offset.end Offset *Offset } -// GQLLimitClauseWithOffset +// GQLLimitWithOffsetClause is wrapper of Limit and Offset +// +// {{.Offset | sql}} {{.Offset | sql}} type GQLLimitWithOffsetClause struct { // pos = Limit.pos // end = Offset.end @@ -2704,6 +2747,9 @@ type GQLLimitWithOffsetClause struct { Offset *Offset } +// GQLLimitStatement represents LIMIT statement +// +// LIMIT {{.Count | sql}} type GQLLimitStatement struct { // pos = Limit // end = Count.end @@ -2714,6 +2760,8 @@ type GQLLimitStatement struct { // GQLOffsetStatement represents OFFSET statement. // It also represents SKIP statement as the synonym. +// +// {{if IsSkip}} type GQLOffsetStatement struct { // pos = Offset.pos // end = Count.end @@ -2723,6 +2771,9 @@ type GQLOffsetStatement struct { Count IntValue } +// GQLOrderByStatement represents ORDER BY statement. +// +// ORDER BY {{.OrderBySpecificationList | sqlJoin ", "}} type GQLOrderByStatement struct { // pos = Order // end = OrderBySpecificationList[$].end @@ -2731,6 +2782,9 @@ type GQLOrderByStatement struct { OrderBySpecificationList []*GQLOrderBySpecification } +// GQLOrderBySpecification represents a single sort criterion for an expression in ORDER BY. +// +// {{.Expr | sql}} {{.CollationSpecification | sqlOpt}} {{if DirectionPos.Invalid | not}}{{string(Direction)}}{{end}} type GQLOrderBySpecification struct { // pos = Expr.pos // DirectionPos ?? CollationSpecification.end @@ -2739,9 +2793,12 @@ type GQLOrderBySpecification struct { CollationSpecification *GQLCollationSpecification // optional DirectionPos token.Pos // optional - Direction GQLDirection + Direction GQLDirectionEnum } +// GQLCollationSpecification represents `COLLATE collation_specification` +// +// COLLATE {{.Specification | sql}} type GQLCollationSpecification struct { // pos = Collate // end = Specification.end @@ -2750,6 +2807,9 @@ type GQLCollationSpecification struct { Specification StringValue } +// GQLWithStatement represents WITH statement. +// +// WITH {{.GQLAllOrDistinctEnum | sql}} {{.ReturnItemList | sqlJoin}} {{.GroupBy | sql}} type GQLWithStatement struct { // pos = With // end = (GroupByClause ?? ReturnItemList[$]).end @@ -2763,9 +2823,16 @@ type GQLWithStatement struct { // but it don't permit DotStar and AsAlias without AS. type GQLReturnItem SelectItem +// GQLReturnStatement represents RETURN statement. +// +// RETURN {{.AllOrDistinct | sql}} {{.ReturnItemList | sqlJoin}} +// {{.GroupByClause | sqlOpt}} +// {{.OrderByClause | sqlOpt}} +// {{.LimitAntOffsetClause | sqlOpt}} type GQLReturnStatement struct { // pos = Return.pos // end = (LimitAndOffsetClause ?? OrderByClause ?? GroupByClause ?? ReturnItemList[$]).end + Return token.Pos AllOrDistinct GQLAllOrDistinctEnum ReturnItemList []GQLReturnItem @@ -2779,18 +2846,23 @@ type GQLReturnStatement struct { LimitAndOffsetClause GQLLimitAndOffsetClause // optional } +// GQLLinearGraphVariable represents a single `variable_name = value` entry in LET statement. +// +// {{.VariableName | sql}} = {{.Value | sql}} type GQLLinearGraphVariable struct { VariableName *Ident Value Expr } +// GQLLetStatement represents LET statement. +// +// LET {{.LinearGraphVariableList | sqlJoin ", "}} type GQLLetStatement struct { // pos = Let.pos - // end = if len(LinearGraphVariableList) > 0 then LinearGraphVariableList[$].end - // else Let + 3 + // end = LinearGraphVariableList[$].end Let token.Pos - LinearGraphVariableList []*GQLLinearGraphVariable + LinearGraphVariableList []*GQLLinearGraphVariable // len(LinearGraphVariableList) > 0 } // ================================================================================ @@ -2800,6 +2872,8 @@ type GQLLetStatement struct { // ================================================================================ // GQLGraphPattern represents is the toplevel node of GQL graph patterns. +// +// {{.PathPatternList | sqlJoin}} {{.WhereClause | sqlOpt}} type GQLGraphPattern struct { // pos = GQLTopLevelPathPattern[0].pos // end = (WhereClause ?? PathPatternList[$]).end @@ -2809,6 +2883,8 @@ type GQLGraphPattern struct { } // GQLTopLevelPathPattern is a PathPattern optionally prefixed by PathSearchPrefixOrPathMode. +// +// {{.PathSearchPrefixOrPathMode | sqlOpt}} {{.PathPattern | sql}} type GQLTopLevelPathPattern struct { // pos = (PathSearchPrefixOrPathMode ?? PathPattern).pos // end = PathPattern.end @@ -2827,16 +2903,6 @@ func (*GQLPathMode) isGQLPathSearchPrefixOrPathMode() {} func (*GQLPathSearchPrefix) isGQLPathSearchPrefixOrPathMode() {} // GQLEdgePattern represents edge pattern nodes. -// -// edge_pattern: -// { -// full_edge_any | -// full_edge_left | -// full_edge_right | -// abbreviated_edge_any | -// abbreviated_edge_left | -// abbreviated_edge_right -// } type GQLEdgePattern interface { GQLElementPattern isGQLEdgePattern() @@ -2850,6 +2916,8 @@ func (*GQLFullEdgeAny) isGQLEdgePattern() {} func (*GQLAbbreviatedEdgeRight) isGQLEdgePattern() {} // GQLFullEdgeAny is node representing`-[pattern_filler]-` . +// +// -[{{.PatternFiller | sql}}]- type GQLFullEdgeAny struct { // pos = First.pos // end = Last.pos + 1 @@ -2857,6 +2925,9 @@ type GQLFullEdgeAny struct { PatternFiller *GQLPatternFiller } +// GQLFullEdgeLeft represents `<-[pattern_filler]-` +// +// <-[{{.PatternFiller | sql}}]- type GQLFullEdgeLeft struct { // pos = First // end = Last + 1 @@ -2865,6 +2936,9 @@ type GQLFullEdgeLeft struct { PatternFiller *GQLPatternFiller } +// GQLFullEdgeRight represents “-[pattern_filler]-> +// +// -[{{.PatternFiller | sql}}]-> type GQLFullEdgeRight struct { // pos = First // end = Last + 1 @@ -2874,6 +2948,9 @@ type GQLFullEdgeRight struct { PatternFiller *GQLPatternFiller } +// GQLAbbreviatedEdgeAny represents `-`. +// +// - type GQLAbbreviatedEdgeAny struct { // pos = Hyphen // end = Hyphen +1 @@ -2881,6 +2958,9 @@ type GQLAbbreviatedEdgeAny struct { Hyphen token.Pos // position of "-" } +// GQLAbbreviatedEdgeLeft represents `<-`. +// +// <- type GQLAbbreviatedEdgeLeft struct { // pos = First // end = Last + 1 @@ -2889,6 +2969,9 @@ type GQLAbbreviatedEdgeLeft struct { Last token.Pos // position of "-" } +// GQLAbbreviatedEdgeRight represents `->`. +// +// -> type GQLAbbreviatedEdgeRight struct { // pos = First // end = Last + 1 @@ -2897,6 +2980,13 @@ type GQLAbbreviatedEdgeRight struct { Last token.Pos // position of ">" } +// GQLQuantifiablePathTerm represents GQLPathTerm with optional Hint and optional GQLQuantifier.. +// NOTE: This node is not documented in spec, but inferred by [quantified_path_primary] and [graph traversal hints]. +// +// [graph traversal hints]: https://cloud.google.com/spanner/docs/reference/standard-sql/graph-query-statements#graph_hints +// [quantified_path_primary] https://cloud.google.com/spanner/docs/reference/standard-sql/graph-patterns#quantified_paths +// +// {{.Hint | sqlOpt}}{{.PathTerm | sql}}{{.Quantifier | sqlOpt}} type GQLQuantifiablePathTerm struct { // pos = (Hint ?? PathTerm).pos // end = (Quantifier ?? PathTerm).end @@ -2906,12 +2996,17 @@ type GQLQuantifiablePathTerm struct { Quantifier GQLQuantifier // optional } +// GQLPathPattern represents a path pattern that matches paths in a property graph. +// +// {{.PathTermList | sqlJoin ""}} type GQLPathPattern struct { // pos = PathTermList[0].pos // end = PathTermList[$].end + PathTermList []*GQLQuantifiablePathTerm } +// GQLPathTerm represents ` { element_pattern | subpath_pattern }` type GQLPathTerm interface { Node isGQLPathTerm() @@ -2926,6 +3021,9 @@ func (*GQLFullEdgeRight) isGQLPathTerm() {} func (*GQLFullEdgeLeft) isGQLPathTerm() {} func (*GQLFullEdgeAny) isGQLPathTerm() {} +// GQLWhereClause represents `WHERE bool_expression` clause. +// +// WHERE {{.BoolExpression | sql}} type GQLWhereClause struct { // pos = Where // end = BoolExpression.end @@ -2934,6 +3032,7 @@ type GQLWhereClause struct { BoolExpression Expr } +// GQLElementPattern represents a node pattern or an edge pattern. type GQLElementPattern interface { Node GQLPathTerm @@ -2947,6 +3046,9 @@ func (*GQLAbbreviatedEdgeAny) isGQLElementPattern() {} func (*GQLAbbreviatedEdgeLeft) isGQLElementPattern() {} func (*GQLAbbreviatedEdgeRight) isGQLElementPattern() {} +// GQLPathMode represents to include or exclude paths that have repeating edges based on the specified mode. +// +// {{.ModeToken | sql}} {{.PathOrPathsToken | sqlOpt}} type GQLPathMode struct { // pos = ModeToken.pos // end = (PathOrPathsToken ?? ModeToken).end @@ -2956,11 +3058,7 @@ type GQLPathMode struct { PathOrPathsToken *Ident // optional } -/* - type GQLQuantifiedPathPrimary struct { - PathPrimary - } -*/ +// GQLQuantifier represents `{ fixed_quantifier | bounded_quantifier }`. type GQLQuantifier interface { Node isGQLQuantifier() @@ -2969,6 +3067,9 @@ type GQLQuantifier interface { func (g *GQLFixedQuantifier) isGQLQuantifier() {} func (g *GQLBoundedQuantifier) isGQLQuantifier() {} +// GQLFixedQuantifier represents the exact number of times the path pattern portion must repeat. +// +// {{"{"}}{{.Bound | sql}}{{"}"}} type GQLFixedQuantifier struct { // pos = LBrace // end = RBrace + 1 @@ -2977,14 +3078,21 @@ type GQLFixedQuantifier struct { Bound IntValue } +// GQLBoundedQuantifier represents the minimum and maximum number of times the path pattern portion can repeat. +// +// {{"{"}}{{.LowerBound | sqlOpt}}, {{.UpperBound | sql}}{{"}"}} type GQLBoundedQuantifier struct { // pos = LBrace // end = RBrace + 1 + LBrace, RBrace token.Pos LowerBound IntValue // optional UpperBound IntValue } +// GQLSubpathPattern represents a path pattern enclosed in parentheses. +// +// ({{.PathMode | sqlOpt}} {{.PathPattern | sql}} {{.WhereClause | sqlOpt}}) type GQLSubpathPattern struct { // pos = LParen // end = RParen + 1 @@ -2995,6 +3103,9 @@ type GQLSubpathPattern struct { WhereClause *Where // optional } +// GQLNodePattern represents a pattern to match nodes in a property graph. +// +// ({{.PatternFiller | sql}}) type GQLNodePattern struct { // pos = LParen // end = RParen + 1 @@ -3023,6 +3134,12 @@ type EdgePattern interface { */ +// GQLPatternFiller represents specifications on the node or edge pattern that you want to match. +// +// {{.Hint | sqlOpt}} +// {{.GraphPatternVariable | sqlOpt}} +// {{.IsLabelCondition | sqlOpt}} +// {{.Filter | sqlOpt}} type GQLPatternFiller struct { // pos = (Hint ?? GraphPatternVariable ?? IsLabelCondition ?? Filter).pos // end = (Filter ?? IsLabelCondition ?? GraphPatternVariable ?? Hint).end @@ -3034,6 +3151,10 @@ type GQLPatternFiller struct { Filter GQLPatternFillerFilter // optional } +// GQLIsLabelCondition represents `{ IS | : } label_expression`. +// It normalizes `IS` to `:`. +// +// : {{.LabelExpression | sql}} type GQLIsLabelCondition struct { // pos = IsOrColon // end = LabelExpression.end @@ -3042,28 +3163,24 @@ type GQLIsLabelCondition struct { LabelExpression GQLLabelExpression } -// GQLLabelExpression represents -// -// label_expression: -// { -// label_name -// | or_expression -// | and_expression -// | not_expression -// } -// -// Note: Spanner Graph documentation don't say about paren expression, but there is. +// GQLLabelExpression represents the expression for the label. +// It is formed by combining one or more labels with logical operators (AND, OR, NOT) and parentheses for grouping. +// See https://cloud.google.com/spanner/docs/reference/standard-sql/graph-patterns#label_expression_definition. type GQLLabelExpression interface { Node isGQLLabelExpression() } +// Note: Spanner Graph documentation don't say about paren expression, but there is. func (g *GQLLabelParenExpression) isGQLLabelExpression() {} func (g *GQLLabelOrExpression) isGQLLabelExpression() {} func (g *GQLLabelAndExpression) isGQLLabelExpression() {} func (g *GQLLabelNotExpression) isGQLLabelExpression() {} func (g *GQLLabelName) isGQLLabelExpression() {} +// GQLLabelAndExpression represents `label_expression|label_expression`. +// +// {{.Left | sql}}|{{.Right | sql}} type GQLLabelOrExpression struct { // pos = LParen // end = RParen @@ -3071,6 +3188,9 @@ type GQLLabelOrExpression struct { Left, Right GQLLabelExpression } +// GQLLabelParenExpression represents `(label_expression)`. +// +// ({{.LabelExpr | sql}}) type GQLLabelParenExpression struct { // pos = LParen // end = RParen + 1 @@ -3079,6 +3199,9 @@ type GQLLabelParenExpression struct { LabelExpr GQLLabelExpression } +// GQLLabelAndExpression represents `label_expression&label_expression`. +// +// {{.Left | sql}}&{{.Right | sql}} type GQLLabelAndExpression struct { // pos = Left.pos // end = Right.end @@ -3086,6 +3209,9 @@ type GQLLabelAndExpression struct { Left, Right GQLLabelExpression } +// GQLLabelNotExpression represents `!label_expression`. +// +// !{{.LabelExpression | sql}} type GQLLabelNotExpression struct { // pos = Not // end = LabelExpression.end @@ -3094,17 +3220,19 @@ type GQLLabelNotExpression struct { LabelExpression GQLLabelExpression } +// GQLLabelName represents the label to match. +// +// {{if .IsPercent}}%{{else}}{{.LabelName | sql}}{{end}} type GQLLabelName struct { // pos = StartPos - // end = if IsPercent then StartPos + 1 - // else LabelName.end + // end = IsPercent ? StartPos + 1 : LabelName.end - StartPos token.Pos + StartPos token.Pos // position of "%" or LabelName IsPercent bool LabelName *Ident } -// GQLPatternFillerFilter represents +// GQLPatternFillerFilter represents `{where_clause | property_filters}` in GQLPatternFiller. type GQLPatternFillerFilter interface { Node isGQLPatternFillerFilter() @@ -3114,6 +3242,9 @@ func (g *GQLPropertyFilters) isGQLPatternFillerFilter() {} func (g *GQLWhereClause) isGQLPatternFillerFilter() {} func (w *Where) isGQLPatternFillerFilter() {} +// GQLPropertyFilters represents `{ element_property[, ...] }` in GQLPatternFiller. +// +// {{"{"}}{{.PropertyFilterElemList | sqlJoin ", "}}{{"}"}} type GQLPropertyFilters struct { // pos = LBrace // end = RBrace + 1 @@ -3124,6 +3255,8 @@ type GQLPropertyFilters struct { } // GQLElementProperty represents an element of GQLPropertyFilters. +// +// {{.ElementPropertyName | sql}}: {{.ElementPropertyValue | sql}} type GQLElementProperty struct { // pos = ElementPropertyName.pos // end = ElementPropertyValue.pos @@ -3132,9 +3265,9 @@ type GQLElementProperty struct { ElementPropertyValue Expr } -// GQLPathSearchPrefix represents +// GQLPathSearchPrefix represents `{"ALL" | "ANY" | "ANY SHORTEST"}`. // -// `{"ALL" | "ANY" | "ANY SHORTEST"}`. +// {{string(.SearchPrefix)}} type GQLPathSearchPrefix struct { // pos = StartPos // end = LastEnd diff --git a/ast/const.go b/ast/const.go index 2212f259..dae71c65 100644 --- a/ast/const.go +++ b/ast/const.go @@ -131,43 +131,44 @@ const ( InsertOrTypeIgnore InsertOrType = "IGNORE" ) -type GQLAllOrDistinctEnum int +type GQLAllOrDistinctEnum string const ( - GQLAllOrDistinctImplicitAll GQLAllOrDistinctEnum = iota - GQLAllOrDistinctAll - GQLAllOrDistinctDistinct + GQLAllOrDistinctImplicitAll GQLAllOrDistinctEnum = "" + GQLAllOrDistinctAll GQLAllOrDistinctEnum = "ALL" + GQLAllOrDistinctDistinct GQLAllOrDistinctEnum = "DISTINCT" ) -type GQLSetOperatorEnum int +type GQLSetOperatorEnum string const ( - GQLSetOperatorUnion GQLSetOperatorEnum = iota - GQLSetOperatorIntersect - GQLSetOperatorExcept + GQLSetOperatorUnion GQLSetOperatorEnum = "UNION" + GQLSetOperatorIntersect GQLSetOperatorEnum = "INTERSECT" + GQLSetOperatorExcept GQLSetOperatorEnum = "EXCEPT" ) -type GQLDirection string +type GQLDirectionEnum string const ( - GQLSortOrderUnspecified GQLDirection = "" - GQLSortOrderAsc GQLDirection = "ASC" - GQLSortOrderAscending GQLDirection = "ASCENDING" - GQLSortOrderDesc GQLDirection = "DESC" - GQLSortOrderDescending GQLDirection = "DESCENDING" + GQLSortOrderUnspecified GQLDirectionEnum = "" + GQLSortOrderAsc GQLDirectionEnum = "ASC" + GQLSortOrderAscending GQLDirectionEnum = "ASCENDING" + GQLSortOrderDesc GQLDirectionEnum = "DESC" + GQLSortOrderDescending GQLDirectionEnum = "DESCENDING" ) -type GQLPathModeEnum int +type GQLPathModeEnum string const ( - GQLPathModeWalk GQLPathModeEnum = iota - GQLPathModeTrail + GQLPathModeUnspecified GQLPathModeEnum = "" + GQLPathModeWalk GQLPathModeEnum = "WALK" + GQLPathModeTrail GQLPathModeEnum = "TRAIL" ) -type GQLSearchPrefixEnum int +type GQLSearchPrefixEnum string const ( - GQLPathSearchPrefixAll GQLSearchPrefixEnum = iota - GQLPathSearchPrefixAny - GQLPathSearchPrefixAnyShortest + GQLPathSearchPrefixAll GQLSearchPrefixEnum = "ALL" + GQLPathSearchPrefixAny GQLSearchPrefixEnum = "ANY" + GQLPathSearchPrefixAnyShortest GQLSearchPrefixEnum = "ANY SHORTEST" ) diff --git a/parser.go b/parser.go index cb30348f..c3602bdc 100644 --- a/parser.go +++ b/parser.go @@ -3995,7 +3995,7 @@ func (p *Parser) tryParseGQLOrderBySpecificationList() []*ast.GQLOrderBySpecific } } - var direction ast.GQLDirection + var direction ast.GQLDirectionEnum directionPos := p.Token.Pos switch { case p.Token.Kind == "ASC": From c40cb6eb3d7d275475019259b3f30c40323bc4ac Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 18 Sep 2024 13:32:58 +0900 Subject: [PATCH 37/53] Update testdata --- testdata/result/gql/filter.sql.txt | 2 +- testdata/result/gql/filter_where.sql.txt | 2 +- testdata/result/gql/for_with_offset.sql.txt | 2 +- testdata/result/gql/for_with_offset_as.sql.txt | 2 +- testdata/result/gql/graph_hints_between.sql.txt | 2 +- testdata/result/gql/graph_hints_match.sql.txt | 2 +- .../result/gql/graph_hints_traversal_hint.sql.txt | 2 +- testdata/result/gql/let.sql.txt | 2 +- testdata/result/gql/limit.sql.txt | 2 +- testdata/result/gql/match.sql.txt | 2 +- testdata/result/gql/match_any_shortest.sql.txt | 4 ++-- .../gql/match_any_shortest_subpath_trail.sql.txt | 6 +++--- testdata/result/gql/match_optional.sql.txt | 2 +- testdata/result/gql/match_or_expression.sql.txt | 2 +- testdata/result/gql/match_subpath_trail.sql.txt | 4 ++-- testdata/result/gql/match_trail_subpath_walk.sql.txt | 6 +++--- .../gql/match_where_is_destination_of_return.sql.txt | 2 +- .../gql/match_where_is_source_of_return.sql.txt | 2 +- .../result/gql/match_where_not_same_return.sql.txt | 2 +- .../gql/match_where_property_exists_return.sql.txt | 2 +- testdata/result/gql/next.sql.txt | 12 ++++++------ testdata/result/gql/next_1.sql.txt | 4 ++-- testdata/result/gql/offset_1.sql.txt | 2 +- testdata/result/gql/order_by.sql.txt | 2 +- testdata/result/gql/order_by_collate.sql.txt | 2 +- testdata/result/gql/return.sql.txt | 4 ++-- testdata/result/gql/return_array_subquery.sql.txt | 4 ++-- testdata/result/gql/return_distinct.sql.txt | 2 +- .../result/gql/return_exists_graph_pattern.sql.txt | 2 +- testdata/result/gql/return_exists_match.sql.txt | 2 +- testdata/result/gql/return_exists_query_expr.sql.txt | 4 ++-- testdata/result/gql/return_in_gql_subquery.sql.txt | 4 ++-- testdata/result/gql/return_value_subquery.sql.txt | 4 ++-- testdata/result/gql/skip_1.sql.txt | 2 +- testdata/result/gql/with_1.sql.txt | 4 ++-- .../result/query/select_from_graph_table.sql.txt | 2 +- testdata/result/query/select_in_gql_subquery.sql.txt | 2 +- .../result/statement/select_from_graph_table.sql.txt | 2 +- .../result/statement/select_in_gql_subquery.sql.txt | 2 +- 39 files changed, 57 insertions(+), 57 deletions(-) diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index b699fed0..3555c8c2 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -150,7 +150,7 @@ RETURN p.name }, &ast.GQLReturnStatement{ Return: 87, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index 5d375f11..ce140b06 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -150,7 +150,7 @@ RETURN p.name }, &ast.GQLReturnStatement{ Return: 93, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index 90605103..1222ae7a 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -157,7 +157,7 @@ ORDER BY p.name, element, offset }, &ast.GQLReturnStatement{ Return: 96, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index b5632fb9..4132d5bc 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -90,7 +90,7 @@ RETURN p.name, element, off }, &ast.GQLReturnStatement{ Return: 69, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index ba157931..06715088 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -233,7 +233,7 @@ RETURN oa.id }, &ast.GQLReturnStatement{ Return: 125, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index 7f9532eb..f1f63f79 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -260,7 +260,7 @@ RETURN oa.id }, &ast.GQLReturnStatement{ Return: 132, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index f29741a4..cd818382 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -263,7 +263,7 @@ RETURN c.id }, &ast.GQLReturnStatement{ Return: 258, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 965ca81f..1a3e3e0d 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -141,7 +141,7 @@ RETURN a.id AS a_id }, &ast.GQLReturnStatement{ Return: 90, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index 20530363..d550df86 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -158,7 +158,7 @@ RETURN source.nick_name }, &ast.GQLReturnStatement{ Return: 109, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt index 103dd1a5..1ef60745 100644 --- a/testdata/result/gql/match.sql.txt +++ b/testdata/result/gql/match.sql.txt @@ -65,7 +65,7 @@ RETURN p.name, p.id }, &ast.GQLReturnStatement{ Return: 32, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index 9f3f5135..ace41c0b 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -25,7 +25,7 @@ RETURN a.id AS a_id, total, b.id AS b_id PrefixOrMode: &ast.GQLPathSearchPrefix{ StartPos: 21, LastEnd: 33, - SearchPrefix: 2, + SearchPrefix: "ANY SHORTEST", }, GraphPattern: &ast.GQLGraphPattern{ PathPatternList: []*ast.GQLTopLevelPathPattern{ @@ -199,7 +199,7 @@ RETURN a.id AS a_id, total, b.id AS b_id }, &ast.GQLReturnStatement{ Return: 125, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt index 2f6f3f0b..e9bafe71 100644 --- a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -23,7 +23,7 @@ RETURN COUNT(1) as num_paths PrefixOrMode: &ast.GQLPathSearchPrefix{ StartPos: 21, LastEnd: 33, - SearchPrefix: 2, + SearchPrefix: "ANY SHORTEST", }, GraphPattern: &ast.GQLGraphPattern{ PathPatternList: []*ast.GQLTopLevelPathPattern{ @@ -37,7 +37,7 @@ RETURN COUNT(1) as num_paths LParen: 34, RParen: 48, PathMode: &ast.GQLPathMode{ - Mode: 1, + Mode: "TRAIL", ModeToken: &ast.Ident{ NamePos: 35, NameEnd: 40, @@ -85,7 +85,7 @@ RETURN COUNT(1) as num_paths }, &ast.GQLReturnStatement{ Return: 50, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index 937ac62d..247af4a1 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -183,7 +183,7 @@ RETURN n.name, a.id AS blocked_account_id }, &ast.GQLReturnStatement{ Return: 98, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt index 90fafae7..19c18949 100644 --- a/testdata/result/gql/match_or_expression.sql.txt +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -76,7 +76,7 @@ RETURN n.id, n.name, n.nick_name }, &ast.GQLReturnStatement{ Return: 40, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index b397a05e..f2aeb23f 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -35,7 +35,7 @@ RETURN COUNT(1) as num_paths LParen: 23, RParen: 74, PathMode: &ast.GQLPathMode{ - Mode: 1, + Mode: "TRAIL", ModeToken: &ast.Ident{ NamePos: 24, NameEnd: 29, @@ -214,7 +214,7 @@ RETURN COUNT(1) as num_paths }, &ast.GQLReturnStatement{ Return: 108, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 26523574..96035510 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -21,7 +21,7 @@ RETURN COUNT(1) as num_paths Match: 15, MatchHint: (*ast.Hint)(nil), PrefixOrMode: &ast.GQLPathMode{ - Mode: 1, + Mode: "TRAIL", ModeToken: &ast.Ident{ NamePos: 21, NameEnd: 26, @@ -41,7 +41,7 @@ RETURN COUNT(1) as num_paths LParen: 27, RParen: 77, PathMode: &ast.GQLPathMode{ - Mode: 0, + Mode: "WALK", ModeToken: &ast.Ident{ NamePos: 28, NameEnd: 32, @@ -162,7 +162,7 @@ RETURN COUNT(1) as num_paths }, &ast.GQLReturnStatement{ Return: 79, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index eef2a54d..85489969 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -139,7 +139,7 @@ RETURN a.id AS a_id, b.id AS b_id }, &ast.GQLReturnStatement{ Return: 101, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index c2035d3e..5b2c99d0 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -139,7 +139,7 @@ RETURN a.id AS a_id, b.id AS b_id }, &ast.GQLReturnStatement{ Return: 96, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index b0d1c68c..94b21d9a 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -155,7 +155,7 @@ RETURN src.id AS source_id, dest.id AS destination_id }, &ast.GQLReturnStatement{ Return: 98, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/match_where_property_exists_return.sql.txt b/testdata/result/gql/match_where_property_exists_return.sql.txt index cdb4e1aa..c476f482 100644 --- a/testdata/result/gql/match_where_property_exists_return.sql.txt +++ b/testdata/result/gql/match_where_property_exists_return.sql.txt @@ -103,7 +103,7 @@ RETURN n.name }, &ast.GQLReturnStatement{ Return: 71, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 9a3de88d..7b7237bf 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -130,7 +130,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, &ast.GQLReturnStatement{ Return: 64, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -274,7 +274,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, &ast.GQLReturnStatement{ Return: 187, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ @@ -361,7 +361,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, &ast.GQLReturnStatement{ Return: 314, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -387,13 +387,13 @@ RETURN "Bob" AS owner_name, 100 AS account_id TailSimpleLinearQueryStatementList: []*ast.GQLSimpleLinearQueryStatementWithSetOperator{ &ast.GQLSimpleLinearQueryStatementWithSetOperator{ StartPos: 344, - SetOperator: 0, - DistinctOrAll: 1, + SetOperator: "UNION", + DistinctOrAll: "ALL", Statement: &ast.GQLSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 354, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.StringLiteral{ diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 79396f04..7fb6e9c0 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -123,7 +123,7 @@ RETURN }, &ast.GQLReturnStatement{ Return: 64, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -267,7 +267,7 @@ RETURN }, &ast.GQLReturnStatement{ Return: 187, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt index 75978da2..ed98a2df 100644 --- a/testdata/result/gql/offset_1.sql.txt +++ b/testdata/result/gql/offset_1.sql.txt @@ -76,7 +76,7 @@ RETURN p.name, p.id }, &ast.GQLReturnStatement{ Return: 41, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index 9e2e4c48..03ea3cc9 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -158,7 +158,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, &ast.GQLReturnStatement{ Return: 125, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/order_by_collate.sql.txt b/testdata/result/gql/order_by_collate.sql.txt index 31f949e3..d413b320 100644 --- a/testdata/result/gql/order_by_collate.sql.txt +++ b/testdata/result/gql/order_by_collate.sql.txt @@ -94,7 +94,7 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name }, &ast.GQLReturnStatement{ Return: 65, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index fe90003a..962a4bdd 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -122,7 +122,7 @@ ORDER BY num_incoming_transfers DESC }, &ast.GQLReturnStatement{ Return: 64, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -266,7 +266,7 @@ ORDER BY num_incoming_transfers DESC }, &ast.GQLReturnStatement{ Return: 187, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index 5e1a56bd..7d68d1ab 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -125,7 +125,7 @@ RETURN }, &ast.GQLReturnStatement{ Return: 59, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ @@ -295,7 +295,7 @@ RETURN }, &ast.GQLReturnStatement{ Return: 188, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index bc5673f8..2814d47a 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -156,7 +156,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, &ast.GQLReturnStatement{ Return: 78, - AllOrDistinct: 2, + AllOrDistinct: "DISTINCT", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.CallExpr{ diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index 61a4c6e4..cd9fe0f3 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -19,7 +19,7 @@ RETURN EXISTS { PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 15, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.ExistsGQLSubQuery{ diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index e858e672..aea02c89 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -20,7 +20,7 @@ RETURN EXISTS { PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 15, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.ExistsGQLSubQuery{ diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index 182b23b7..581d4e4b 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -22,7 +22,7 @@ RETURN EXISTS { PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 15, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.ExistsGQLSubQuery{ @@ -165,7 +165,7 @@ RETURN EXISTS { }, &ast.GQLReturnStatement{ Return: 99, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index 5c7a8b01..2ae5a2e8 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -20,7 +20,7 @@ RETURN 'Dana' IN { PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 15, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.InExpr{ @@ -146,7 +146,7 @@ RETURN 'Dana' IN { }, &ast.GQLReturnStatement{ Return: 77, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/return_value_subquery.sql.txt b/testdata/result/gql/return_value_subquery.sql.txt index 37a764cc..ac492d6a 100644 --- a/testdata/result/gql/return_value_subquery.sql.txt +++ b/testdata/result/gql/return_value_subquery.sql.txt @@ -22,7 +22,7 @@ RETURN VALUE { PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 15, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.ValueGQLSubQuery{ @@ -107,7 +107,7 @@ RETURN VALUE { }, &ast.GQLReturnStatement{ Return: 77, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt index 10316115..cddbdebb 100644 --- a/testdata/result/gql/skip_1.sql.txt +++ b/testdata/result/gql/skip_1.sql.txt @@ -76,7 +76,7 @@ RETURN p.name, p.id }, &ast.GQLReturnStatement{ Return: 39, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index 8bce3ea7..2a54dfaf 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -116,7 +116,7 @@ RETURN account.id AS account_id, num_incoming_transfers }, &ast.GQLWithStatement{ With: 64, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Ident{ @@ -153,7 +153,7 @@ RETURN account.id AS account_id, num_incoming_transfers }, &ast.GQLReturnStatement{ Return: 130, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.Path{ diff --git a/testdata/result/query/select_from_graph_table.sql.txt b/testdata/result/query/select_from_graph_table.sql.txt index 41d90400..b9842a3f 100644 --- a/testdata/result/query/select_from_graph_table.sql.txt +++ b/testdata/result/query/select_from_graph_table.sql.txt @@ -30,7 +30,7 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 35, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.IntLiteral{ diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index 3bdf7a00..34fb6965 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -144,7 +144,7 @@ SELECT 'Dana' IN { }, &ast.GQLReturnStatement{ Return: 79, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ diff --git a/testdata/result/statement/select_from_graph_table.sql.txt b/testdata/result/statement/select_from_graph_table.sql.txt index 41d90400..b9842a3f 100644 --- a/testdata/result/statement/select_from_graph_table.sql.txt +++ b/testdata/result/statement/select_from_graph_table.sql.txt @@ -30,7 +30,7 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ Return: 35, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.Alias{ Expr: &ast.IntLiteral{ diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index 3bdf7a00..34fb6965 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -144,7 +144,7 @@ SELECT 'Dana' IN { }, &ast.GQLReturnStatement{ Return: 79, - AllOrDistinct: 0, + AllOrDistinct: "", ReturnItemList: []ast.GQLReturnItem{ &ast.ExprSelectItem{ Expr: &ast.Path{ From e9921757263ce6f94b17bd7a8f8bf20937a39388 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 18 Sep 2024 13:47:17 +0900 Subject: [PATCH 38/53] Fix gosimple lint error --- parser.go | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/parser.go b/parser.go index c3602bdc..17f7f95b 100644 --- a/parser.go +++ b/parser.go @@ -1710,10 +1710,7 @@ func (p *Parser) lookaheadGQLExistsExprMatch() bool { } p.parseGQLMatchStatement() - if p.Token.Kind != "}" { - return false - } - return true + return p.Token.Kind == "}" } func (p *Parser) parseGQLExistsExpr() ast.GQLExistsExpr { From c61ce4b50b550141d3177dd749ef341fa20f137a Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 30 Oct 2024 10:55:40 +0900 Subject: [PATCH 39/53] Fix merge error --- lexer.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/lexer.go b/lexer.go index 627b532d..4b96e4b4 100644 --- a/lexer.go +++ b/lexer.go @@ -203,15 +203,10 @@ func (l *Lexer) consumeToken() { } return case '!': - switch { - case l.peekIs(1, '='): + if l.peekIs(1, '=') { l.skipN(2) l.Token.Kind = "!=" return - default: - l.skip() - l.Token.Kind = "!" - return } l.skip() l.Token.Kind = "!" From 7c2cb1156aefdaa33ec7067dc772190aec964dc6 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Fri, 1 Nov 2024 13:39:11 +0900 Subject: [PATCH 40/53] Fix tests --- ast/ast.go | 70 +++++++++++++++++++++++++++++++----------------------- ast/pos.go | 22 ++++++++--------- ast/sql.go | 22 ++++++++--------- parser.go | 27 ++++++++++----------- 4 files changed, 73 insertions(+), 68 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index 66ba7a14..666cfba6 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -3203,13 +3203,13 @@ func (*GQLReturnStatement) isGQLPrimitiveQueryStatement() {} // GQLMatchStatement represents MATCH statement. // -// {{if .Optional.Invalid | not}}OPTIONAL {{end-}} -// MATCH // {{.MatchHint | sqlOpt}} // {{.PrefixOrMode | sqlOpt}} {{.GraphPattern | sql}} +// {{if not .Optional.Invalid}}OPTIONAL{{end}} +// MATCH {{.MatchHint | sqlOpt}} {{.PrefixOrMode | sqlOpt}} {{.GraphPattern | sql}} type GQLMatchStatement struct { // pos = Optional || Match // end = GraphPattern.end - Optional token.Pos //optional + Optional token.Pos // optional Match token.Pos MatchHint *Hint // optional @@ -3240,7 +3240,7 @@ type GQLFilterStatement struct { // GQLForStatement represents GQL FOR statement. // -// FOR {{.ElementName | sql}} IN {{.ArrayExpression | sqlJoin ", "}} {{.WithOffsetClause | sqlOpt}} +// FOR {{.ElementName | sql}} IN {{.ArrayExpression | sql}} {{.WithOffsetClause | sqlOpt}} type GQLForStatement struct { // pos = For // end = (WithOffsetClause ?? ArrayExpression).end @@ -3251,16 +3251,16 @@ type GQLForStatement struct { WithOffsetClause *GQLWithOffsetClause } -// GQLWithOffsetClause represents `WITH OFFSET [AS offset_name]` in FOR statement. +// GQLWithOffsetClause represents WITH OFFSET [AS offset_name] in FOR statement. // -// WITH OFFSET {{if isnil .OffsetName | not}}AS {{.OffsetName | sql}}{{end}} +// WITH OFFSET {{.OffsetName | sqlOpt}} type GQLWithOffsetClause struct { // pos = With // end = OffsetName.end || Offset + 6 With token.Pos Offset token.Pos - OffsetName *Ident + OffsetName *AsAlias // optional } // GQLLimitClause is wrapper of Limit for GQL @@ -3279,6 +3279,7 @@ type GQLLimitClause struct { type GQLOffsetClause struct { // pos = Offset.pos // end = Offset.end + Offset *Offset } @@ -3307,7 +3308,7 @@ type GQLLimitStatement struct { // GQLOffsetStatement represents OFFSET statement. // It also represents SKIP statement as the synonym. // -// {{if IsSkip}} +// {{if IsSkip}}SKIP{{else}}OFFSET{{end}} {{.Count | sql}} type GQLOffsetStatement struct { // pos = Offset // end = Count.end @@ -3356,6 +3357,8 @@ type GQLCollationSpecification struct { // GQLWithStatement represents WITH statement. // // WITH {{.GQLAllOrDistinctEnum | sql}} {{.ReturnItemList | sqlJoin}} {{.GroupBy | sql}} +// +// TODO: Refactor type GQLWithStatement struct { // pos = With // end = (GroupByClause ?? ReturnItemList[$]).end @@ -3469,10 +3472,11 @@ func (*GQLAbbreviatedEdgeRight) isGQLEdgePattern() {} // // -[{{.PatternFiller | sql}}]- type GQLFullEdgeAny struct { - // pos = First - // end = Last + 1 + // pos = FirstHyphen + // end = LastHyphen + 1 + + FirstHyphen, LastHyphen token.Pos // position of "-" - First, Last token.Pos PatternFiller *GQLPatternFiller } @@ -3480,11 +3484,12 @@ type GQLFullEdgeAny struct { // // <-[{{.PatternFiller | sql}}]- type GQLFullEdgeLeft struct { - // pos = First - // end = Last + 1 + // pos = Lt + // end = Hyphen + 1 + + Lt token.Pos // position of "<" + Hyphen token.Pos // position of the last "-" - First token.Pos // position of "<" - Last token.Pos // position of the last "-" PatternFiller *GQLPatternFiller } @@ -3492,11 +3497,12 @@ type GQLFullEdgeLeft struct { // // -[{{.PatternFiller | sql}}]-> type GQLFullEdgeRight struct { - // pos = First - // end = Last + 1 + // pos = Hyphen + // end = Gt + 1 + + Hyphen token.Pos // position of the first "-" + Gt token.Pos // position of ">" - First token.Pos // position of the first "-" - Last token.Pos // position of ">" PatternFiller *GQLPatternFiller } @@ -3514,22 +3520,22 @@ type GQLAbbreviatedEdgeAny struct { // // <- type GQLAbbreviatedEdgeLeft struct { - // pos = First - // end = Last + 1 + // pos = Lt + // end = Hyphen + 1 - First token.Pos // position of "<" - Last token.Pos // position of "-" + Lt token.Pos // position of "<" + Hyphen token.Pos // position of "-" } // GQLAbbreviatedEdgeRight represents `->`. // // -> type GQLAbbreviatedEdgeRight struct { - // pos = First - // end = Last + 1 + // pos = Hyphen + // end = Gt + 1 - First token.Pos // position of "-" - Last token.Pos // position of ">" + Hyphen token.Pos // position of "-" + Gt token.Pos // position of ">" } // GQLQuantifiablePathTerm represents GQLPathTerm with optional Hint and optional GQLQuantifier.. @@ -3558,7 +3564,7 @@ type GQLPathPattern struct { PathTermList []*GQLQuantifiablePathTerm } -// GQLPathTerm represents ` { element_pattern | subpath_pattern }` +// GQLPathTerm represents `{ element_pattern | subpath_pattern }` type GQLPathTerm interface { Node isGQLPathTerm() @@ -3730,7 +3736,7 @@ func (g *GQLLabelAndExpression) isGQLLabelExpression() {} func (g *GQLLabelNotExpression) isGQLLabelExpression() {} func (g *GQLLabelName) isGQLLabelExpression() {} -// GQLLabelAndExpression represents `label_expression|label_expression`. +// GQLLabelOrExpression represents `label_expression|label_expression`. // // {{.Left | sql}}|{{.Right | sql}} type GQLLabelOrExpression struct { @@ -3779,6 +3785,8 @@ type GQLLabelName struct { // pos = StartPos // end = LabelName.end || StartPos + 1 + // TODO: Make it interaface + StartPos token.Pos // position of "%" or LabelName IsPercent bool LabelName *Ident // optional @@ -3811,7 +3819,7 @@ type GQLPropertyFilters struct { // {{.ElementPropertyName | sql}}: {{.ElementPropertyValue | sql}} type GQLElementProperty struct { // pos = ElementPropertyName.pos - // end = ElementPropertyValue.pos + // end = ElementPropertyValue.end ElementPropertyName *Ident ElementPropertyValue Expr @@ -3820,6 +3828,8 @@ type GQLElementProperty struct { // GQLPathSearchPrefix represents `{"ALL" | "ANY" | "ANY SHORTEST"}`. // // {{string(.SearchPrefix)}} +// +// TODO: Make it interface type GQLPathSearchPrefix struct { // pos = StartPos // end = LastEnd diff --git a/ast/pos.go b/ast/pos.go index 50266591..8496c953 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -1759,27 +1759,27 @@ func (g *GQLTopLevelPathPattern) End() token.Pos { } func (g *GQLFullEdgeAny) Pos() token.Pos { - return g.First + return g.FirstHyphen } func (g *GQLFullEdgeAny) End() token.Pos { - return posAdd(g.Last, 1) + return posAdd(g.LastHyphen, 1) } func (g *GQLFullEdgeLeft) Pos() token.Pos { - return g.First + return g.Lt } func (g *GQLFullEdgeLeft) End() token.Pos { - return posAdd(g.Last, 1) + return posAdd(g.Hyphen, 1) } func (g *GQLFullEdgeRight) Pos() token.Pos { - return g.First + return g.Hyphen } func (g *GQLFullEdgeRight) End() token.Pos { - return posAdd(g.Last, 1) + return posAdd(g.Gt, 1) } func (g *GQLAbbreviatedEdgeAny) Pos() token.Pos { @@ -1791,19 +1791,19 @@ func (g *GQLAbbreviatedEdgeAny) End() token.Pos { } func (g *GQLAbbreviatedEdgeLeft) Pos() token.Pos { - return g.First + return g.Lt } func (g *GQLAbbreviatedEdgeLeft) End() token.Pos { - return posAdd(g.Last, 1) + return posAdd(g.Hyphen, 1) } func (g *GQLAbbreviatedEdgeRight) Pos() token.Pos { - return g.First + return g.Hyphen } func (g *GQLAbbreviatedEdgeRight) End() token.Pos { - return posAdd(g.Last, 1) + return posAdd(g.Gt, 1) } func (g *GQLQuantifiablePathTerm) Pos() token.Pos { @@ -1939,7 +1939,7 @@ func (g *GQLElementProperty) Pos() token.Pos { } func (g *GQLElementProperty) End() token.Pos { - return nodePos(wrapNode(g.ElementPropertyValue)) + return nodeEnd(wrapNode(g.ElementPropertyValue)) } func (g *GQLPathSearchPrefix) Pos() token.Pos { diff --git a/ast/sql.go b/ast/sql.go index 5c71b910..54fd643c 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1509,27 +1509,25 @@ func (g *GQLMatchStatement) SQL() string { return sql } -func (g *GQLLimitClause) SQL() string { return g.Limit.SQL() } - -func (g *GQLOffsetClause) SQL() string { return g.Offset.SQL() } - -func (g *GQLLimitWithOffsetClause) SQL() string { return g.Limit.SQL() + " " + g.Offset.SQL() } - func (g *GQLFilterStatement) SQL() string { - if g.Where.Invalid() { - return "FILTER " + g.Expr.SQL() - } - return "FILTER WHERE " + g.Expr.SQL() + return "FILTER " + strOpt(!g.Where.Invalid(), "WHERE ") + g.Expr.SQL() } func (g *GQLForStatement) SQL() string { - return "FOR " + g.ElementName.SQL() + " IN " + g.ArrayExpression.SQL() + sqlOpt(" ", g.WithOffsetClause, "") + return "FOR " + g.ElementName.SQL() + " IN " + + g.ArrayExpression.SQL() + sqlOpt(" ", g.WithOffsetClause, "") } func (g *GQLWithOffsetClause) SQL() string { - return "WITH OFFSET" + sqlOpt(" AS ", g.OffsetName, "") + return "WITH OFFSET" + sqlOpt(" ", g.OffsetName, "") } +func (g *GQLLimitClause) SQL() string { return g.Limit.SQL() } + +func (g *GQLOffsetClause) SQL() string { return g.Offset.SQL() } + +func (g *GQLLimitWithOffsetClause) SQL() string { return g.Limit.SQL() + " " + g.Offset.SQL() } + func (g *GQLLimitStatement) SQL() string { return "LIMIT " + g.Count.SQL() } func (g *GQLOffsetStatement) SQL() string { diff --git a/parser.go b/parser.go index f5a3828a..92ed49d5 100644 --- a/parser.go +++ b/parser.go @@ -4383,11 +4383,7 @@ func (p *Parser) tryParseGQLWithOffsetClause() *ast.GQLWithOffsetClause { } with := p.expect("WITH").Pos offset := p.expectKeywordLike("OFFSET").Pos - var offsetName *ast.Ident - if p.Token.Kind == "AS" { - p.nextToken() - offsetName = p.parseIdent() - } + offsetName := p.tryParseAsAlias(withRequiredAs) return &ast.GQLWithOffsetClause{ With: with, @@ -4574,6 +4570,7 @@ func (p *Parser) tryParseGQLPathModePathOrPaths() *ast.Ident { return nil } } + func (p *Parser) tryParseGQLPathMode() *ast.GQLPathMode { switch { case p.Token.IsKeywordLike("WALK"): @@ -4877,8 +4874,8 @@ func (p *Parser) parseGQLEdgePattern() ast.GQLEdgePattern { firstHyphenPos := p.expect("-").Pos if p.Token.Kind != "[" { return &ast.GQLAbbreviatedEdgeLeft{ - First: firstPos, - Last: firstHyphenPos, + Lt: firstPos, + Hyphen: firstHyphenPos, } } p.nextToken() @@ -4886,15 +4883,15 @@ func (p *Parser) parseGQLEdgePattern() ast.GQLEdgePattern { p.expect("]") lastPos := p.expect("-").Pos return &ast.GQLFullEdgeLeft{ - First: firstPos, - Last: lastPos, + Lt: firstPos, + Hyphen: lastPos, PatternFiller: patternFilter, } case "->": lastPos := p.expect("->").Pos return &ast.GQLAbbreviatedEdgeRight{ - First: firstPos, - Last: lastPos, + Hyphen: firstPos, + Gt: lastPos, } case "-": p.nextToken() @@ -4908,15 +4905,15 @@ func (p *Parser) parseGQLEdgePattern() ast.GQLEdgePattern { lastPos := p.Token.Pos p.nextToken() return &ast.GQLFullEdgeRight{ - First: firstPos, - Last: lastPos, + Hyphen: firstPos, + Gt: lastPos, PatternFiller: patternFiller, } case "-": lastPos := p.expect("-").Pos return &ast.GQLFullEdgeAny{ - First: firstPos, - Last: lastPos, + FirstHyphen: firstPos, + LastHyphen: lastPos, PatternFiller: patternFiller, } default: From 2c9ee55754c5c397ba00d09c2e0586de35d665d0 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Fri, 1 Nov 2024 13:40:16 +0900 Subject: [PATCH 41/53] Update testdata --- testdata/result/gql/filter.sql.txt | 4 ++-- testdata/result/gql/filter_where.sql.txt | 4 ++-- testdata/result/gql/for_with_offset.sql.txt | 6 +++--- testdata/result/gql/for_with_offset_as.sql.txt | 11 +++++++---- testdata/result/gql/graph_hints_between.sql.txt | 8 ++++---- testdata/result/gql/graph_hints_match.sql.txt | 8 ++++---- .../result/gql/graph_hints_traversal_hint.sql.txt | 8 ++++---- testdata/result/gql/let.sql.txt | 4 ++-- testdata/result/gql/limit.sql.txt | 4 ++-- testdata/result/gql/match_any_shortest.sql.txt | 4 ++-- .../gql/match_any_shortest_subpath_trail.sql.txt | 4 ++-- testdata/result/gql/match_optional.sql.txt | 4 ++-- testdata/result/gql/match_subpath_trail.sql.txt | 8 ++++---- testdata/result/gql/match_trail_subpath_walk.sql.txt | 4 ++-- .../gql/match_where_is_destination_of_return.sql.txt | 4 ++-- .../gql/match_where_is_source_of_return.sql.txt | 4 ++-- .../result/gql/match_where_not_same_return.sql.txt | 4 ++-- testdata/result/gql/next.sql.txt | 8 ++++---- testdata/result/gql/next_1.sql.txt | 8 ++++---- testdata/result/gql/order_by.sql.txt | 4 ++-- testdata/result/gql/return.sql.txt | 8 ++++---- testdata/result/gql/return_array_subquery.sql.txt | 8 ++++---- testdata/result/gql/return_distinct.sql.txt | 4 ++-- .../result/gql/return_exists_graph_pattern.sql.txt | 4 ++-- testdata/result/gql/return_exists_match.sql.txt | 4 ++-- testdata/result/gql/return_exists_query_expr.sql.txt | 4 ++-- testdata/result/gql/return_in_gql_subquery.sql.txt | 4 ++-- testdata/result/gql/with_1.sql.txt | 4 ++-- .../gql_path_pattern/abbreviated_edge_left.sql.txt | 4 ++-- .../gql_path_pattern/abbreviated_edge_right.sql.txt | 4 ++-- .../result/gql_path_pattern/full_edge_any.sql.txt | 4 ++-- .../result/gql_path_pattern/full_edge_left.sql.txt | 4 ++-- .../result/gql_path_pattern/full_edge_right.sql.txt | 4 ++-- testdata/result/query/select_in_gql_subquery.sql.txt | 4 ++-- .../result/statement/select_in_gql_subquery.sql.txt | 4 ++-- 35 files changed, 92 insertions(+), 89 deletions(-) diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index 39b720ad..5d7efa35 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -60,8 +60,8 @@ RETURN p.name &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 40, + Hyphen: 31, + Gt: 40, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index c4ce3099..c436dc21 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -60,8 +60,8 @@ RETURN p.name &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 40, + Hyphen: 31, + Gt: 40, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index fff848e2..9db24ca9 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -62,8 +62,8 @@ ORDER BY p.name, element, offset &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 40, + Hyphen: 31, + Gt: 40, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ @@ -152,7 +152,7 @@ ORDER BY p.name, element, offset WithOffsetClause: &ast.GQLWithOffsetClause{ With: 84, Offset: 89, - OffsetName: (*ast.Ident)(nil), + OffsetName: (*ast.AsAlias)(nil), }, }, &ast.GQLReturnStatement{ diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index 9611d70f..54d8c56c 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -81,10 +81,13 @@ RETURN p.name, element, off WithOffsetClause: &ast.GQLWithOffsetClause{ With: 50, Offset: 55, - OffsetName: &ast.Ident{ - NamePos: 65, - NameEnd: 68, - Name: "off", + OffsetName: &ast.AsAlias{ + As: 62, + Alias: &ast.Ident{ + NamePos: 65, + NameEnd: 68, + Name: "off", + }, }, }, }, diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index ed6d0d2c..ce458182 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -80,8 +80,8 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 41, - Last: 50, + Hyphen: 41, + Gt: 50, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ @@ -163,8 +163,8 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 95, - Last: 109, + Hyphen: 95, + Gt: 109, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index 6573fc5e..8ccfa59a 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -78,8 +78,8 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 39, - Last: 47, + Hyphen: 39, + Gt: 47, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), @@ -196,8 +196,8 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 103, - Last: 117, + Hyphen: 103, + Gt: 117, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index 334e2534..dd87cc05 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -80,8 +80,8 @@ RETURN c.id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 41, - Last: 49, + Hyphen: 41, + Gt: 49, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), @@ -199,8 +199,8 @@ RETURN c.id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 192, - Last: 206, + Hyphen: 192, + Gt: 206, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 650783d5..4771951d 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -60,8 +60,8 @@ RETURN a.id AS a_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 37, - Last: 51, + Hyphen: 37, + Gt: 51, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index 27c847e1..c994faa8 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -61,8 +61,8 @@ RETURN source.nick_name &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 37, - Last: 51, + Hyphen: 37, + Gt: 51, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index 23dcda25..5912253d 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -65,8 +65,8 @@ RETURN a.id AS a_id, total, b.id AS b_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 45, - Last: 59, + Hyphen: 45, + Gt: 59, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt index e455a3db..b0baf3b4 100644 --- a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -50,8 +50,8 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLAbbreviatedEdgeRight{ - First: 41, - Last: 41, + Hyphen: 41, + Gt: 41, }, Quantifier: &ast.GQLBoundedQuantifier{ LBrace: 43, diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index 0974a58f..9110371e 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -107,8 +107,8 @@ RETURN n.name, a.id AS blocked_account_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 57, - Last: 65, + Hyphen: 57, + Gt: 65, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index 76832a21..a431816c 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -77,8 +77,8 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 42, - Last: 57, + Hyphen: 42, + Gt: 57, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ @@ -150,8 +150,8 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 78, - Last: 93, + Hyphen: 78, + Gt: 93, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 38c2300e..9cf9df03 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -83,8 +83,8 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 45, - Last: 60, + Hyphen: 45, + Gt: 60, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index 84c6a597..8efa905c 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -60,8 +60,8 @@ RETURN a.id AS a_id, b.id AS b_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeAny{ - First: 32, - Last: 53, + FirstHyphen: 32, + LastHyphen: 53, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index 71482b75..7f68ae25 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -60,8 +60,8 @@ RETURN a.id AS a_id, b.id AS b_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeAny{ - First: 32, - Last: 53, + FirstHyphen: 32, + LastHyphen: 53, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index 36c8c1af..4cc81a34 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -60,8 +60,8 @@ RETURN src.id AS source_id, dest.id AS destination_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeLeft{ - First: 34, - Last: 56, + Lt: 34, + Hyphen: 56, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 5592e6b8..4326321a 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -70,8 +70,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 44, + Hyphen: 31, + Gt: 44, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), @@ -214,8 +214,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeLeft{ - First: 162, - Last: 171, + Lt: 162, + Hyphen: 171, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 54a48924..1081f47a 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -63,8 +63,8 @@ RETURN &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 44, + Hyphen: 31, + Gt: 44, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), @@ -207,8 +207,8 @@ RETURN &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeLeft{ - First: 162, - Last: 171, + Lt: 162, + Hyphen: 171, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index cf764237..bc8bd35c 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -61,8 +61,8 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 42, - Last: 63, + Hyphen: 42, + Gt: 63, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index 5547fa79..9eece338 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -62,8 +62,8 @@ ORDER BY num_incoming_transfers DESC &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 44, + Hyphen: 31, + Gt: 44, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), @@ -206,8 +206,8 @@ ORDER BY num_incoming_transfers DESC &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeLeft{ - First: 162, - Last: 171, + Lt: 162, + Hyphen: 171, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index a43270ef..8dad45a4 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -65,8 +65,8 @@ RETURN &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 39, + Hyphen: 31, + Gt: 39, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), @@ -220,8 +220,8 @@ RETURN &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 130, - Last: 151, + Hyphen: 130, + Gt: 151, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index ccfa33ae..2a2538c7 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -77,8 +77,8 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 42, - Last: 56, + Hyphen: 42, + Gt: 56, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index 1e73400b..b4d06afc 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -63,8 +63,8 @@ RETURN EXISTS { &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 43, - Last: 52, + Hyphen: 43, + Gt: 52, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index 34421a29..9758565c 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -69,8 +69,8 @@ RETURN EXISTS { &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 49, - Last: 58, + Hyphen: 49, + Gt: 58, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index d24b612b..6daf1ba7 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -77,8 +77,8 @@ RETURN EXISTS { &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 49, - Last: 58, + Hyphen: 49, + Gt: 58, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index 8f793d41..c99e8384 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -82,8 +82,8 @@ RETURN 'Dana' IN { &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 52, - Last: 61, + Hyphen: 52, + Gt: 61, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index e021eede..0b7f463a 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -56,8 +56,8 @@ RETURN account.id AS account_id, num_incoming_transfers &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 31, - Last: 44, + Hyphen: 31, + Gt: 44, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt b/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt index 48414103..be093e3f 100644 --- a/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt +++ b/testdata/result/gql_path_pattern/abbreviated_edge_left.sql.txt @@ -6,8 +6,8 @@ &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLAbbreviatedEdgeLeft{ - First: 1, - Last: 2, + Lt: 1, + Hyphen: 2, }, Quantifier: nil, }, diff --git a/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt index 95bf4de0..d31e7543 100644 --- a/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt +++ b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt @@ -6,8 +6,8 @@ &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLAbbreviatedEdgeRight{ - First: 1, - Last: 1, + Hyphen: 1, + Gt: 1, }, Quantifier: nil, }, diff --git a/testdata/result/gql_path_pattern/full_edge_any.sql.txt b/testdata/result/gql_path_pattern/full_edge_any.sql.txt index a8ac48ea..a3e27134 100644 --- a/testdata/result/gql_path_pattern/full_edge_any.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_any.sql.txt @@ -6,8 +6,8 @@ &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeAny{ - First: 1, - Last: 5, + FirstHyphen: 1, + LastHyphen: 5, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql_path_pattern/full_edge_left.sql.txt b/testdata/result/gql_path_pattern/full_edge_left.sql.txt index ded1e737..2518283e 100644 --- a/testdata/result/gql_path_pattern/full_edge_left.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_left.sql.txt @@ -6,8 +6,8 @@ &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeLeft{ - First: 2, - Last: 7, + Lt: 2, + Hyphen: 7, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql_path_pattern/full_edge_right.sql.txt b/testdata/result/gql_path_pattern/full_edge_right.sql.txt index d1846dce..95fe09bd 100644 --- a/testdata/result/gql_path_pattern/full_edge_right.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_right.sql.txt @@ -6,8 +6,8 @@ &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 1, - Last: 4, + Hyphen: 1, + Gt: 4, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: (*ast.Ident)(nil), diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index fa7e203e..ea43e293 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -80,8 +80,8 @@ SELECT 'Dana' IN { &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 54, - Last: 63, + Hyphen: 54, + Gt: 63, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index fa7e203e..ea43e293 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -80,8 +80,8 @@ SELECT 'Dana' IN { &ast.GQLQuantifiablePathTerm{ Hint: (*ast.Hint)(nil), PathTerm: &ast.GQLFullEdgeRight{ - First: 54, - Last: 63, + Hyphen: 54, + Gt: 63, PatternFiller: &ast.GQLPatternFiller{ Hint: (*ast.Hint)(nil), GraphPatternVariable: &ast.Ident{ From 1693812e5961f05d5ed5b0e209011992782c7d7d Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Mon, 13 Jan 2025 23:54:37 +0900 Subject: [PATCH 42/53] Update walk_internal.go --- ast/walk_internal.go | 507 +++++++++++++++++++++++++++++-------------- 1 file changed, 342 insertions(+), 165 deletions(-) diff --git a/ast/walk_internal.go b/ast/walk_internal.go index 82c4b945..388b27c4 100644 --- a/ast/walk_internal.go +++ b/ast/walk_internal.go @@ -8,42 +8,57 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *BadStatement: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *BadQueryExpr: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *BadExpr: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")}) case *BadType: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")}) case *BadDDL: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")}) case *BadDML: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.BadNode), visitor: v.Field("BadNode")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *QueryStatement: stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *Query: + stack = append(stack, &stackItem{nodes: wrapNodes(n.PipeOperators), visitor: v.Field("PipeOperators")}) + stack = append(stack, &stackItem{node: wrapNode(n.Limit), visitor: v.Field("Limit")}) + stack = append(stack, &stackItem{node: wrapNode(n.OrderBy), visitor: v.Field("OrderBy")}) stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) + stack = append(stack, &stackItem{node: wrapNode(n.With), visitor: v.Field("With")}) case *Hint: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Records), visitor: v.Field("Records")}) case *HintRecord: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) + stack = append(stack, &stackItem{node: wrapNode(n.Key), visitor: v.Field("Key")}) case *With: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.CTEs), visitor: v.Field("CTEs")}) case *CTE: stack = append(stack, &stackItem{node: wrapNode(n.QueryExpr), visitor: v.Field("QueryExpr")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *Select: + stack = append(stack, &stackItem{node: wrapNode(n.Having), visitor: v.Field("Having")}) + stack = append(stack, &stackItem{node: wrapNode(n.GroupBy), visitor: v.Field("GroupBy")}) + stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")}) + stack = append(stack, &stackItem{node: wrapNode(n.From), visitor: v.Field("From")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Results), visitor: v.Field("Results")}) stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) case *AsStruct: @@ -53,37 +68,42 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *AsTypeName: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.TypeName), visitor: v.Field("TypeName")}) case *FromQuery: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.From), visitor: v.Field("From")}) case *CompoundQuery: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Queries), visitor: v.Field("Queries")}) case *SubQuery: stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *StarModifierExcept: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) case *StarModifierReplaceItem: + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *StarModifierReplace: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) case *Star: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Replace), visitor: v.Field("Replace")}) + stack = append(stack, &stackItem{node: wrapNode(n.Except), visitor: v.Field("Except")}) case *DotStar: + stack = append(stack, &stackItem{node: wrapNode(n.Replace), visitor: v.Field("Replace")}) + stack = append(stack, &stackItem{node: wrapNode(n.Except), visitor: v.Field("Except")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *Alias: + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *AsAlias: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")}) case *ExprSelectItem: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) @@ -95,66 +115,86 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *GroupBy: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Exprs), visitor: v.Field("Exprs")}) case *Having: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *OrderBy: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")}) case *OrderByItem: + stack = append(stack, &stackItem{node: wrapNode(n.Collate), visitor: v.Field("Collate")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *Collate: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) case *Limit: + stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) stack = append(stack, &stackItem{node: wrapNode(n.Count), visitor: v.Field("Count")}) case *Offset: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) case *PipeSelect: + stack = append(stack, &stackItem{nodes: wrapNodes(n.Results), visitor: v.Field("Results")}) stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) case *PipeWhere: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *Unnest: + stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")}) + stack = append(stack, &stackItem{node: wrapNode(n.WithOffset), visitor: v.Field("WithOffset")}) + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *WithOffset: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) case *TableName: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")}) + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) + stack = append(stack, &stackItem{node: wrapNode(n.Table), visitor: v.Field("Table")}) case *PathTableExpr: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")}) + stack = append(stack, &stackItem{node: wrapNode(n.WithOffset), visitor: v.Field("WithOffset")}) + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) + stack = append(stack, &stackItem{node: wrapNode(n.Path), visitor: v.Field("Path")}) case *SubQueryTableExpr: + stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")}) + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *ParenTableExpr: + stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")}) stack = append(stack, &stackItem{node: wrapNode(n.Source), visitor: v.Field("Source")}) case *GraphTableExpr: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) + stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) + stack = append(stack, &stackItem{node: wrapNode(n.PropertyGraphName), visitor: v.Field("PropertyGraphName")}) case *Join: stack = append(stack, &stackItem{node: wrapNode(n.Cond), visitor: v.Field("Cond")}) stack = append(stack, &stackItem{node: wrapNode(n.Right), visitor: v.Field("Right")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")}) case *On: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *Using: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Idents), visitor: v.Field("Idents")}) case *TableSample: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Size), visitor: v.Field("Size")}) case *TableSampleSize: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) @@ -177,10 +217,10 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *ValuesInCondition: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Exprs), visitor: v.Field("Exprs")}) case *GQLSubQueryInCondition: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *IsNullExpr: stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")}) @@ -202,6 +242,7 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Left), visitor: v.Field("Left")}) case *SelectorExpr: + stack = append(stack, &stackItem{node: wrapNode(n.Ident), visitor: v.Field("Ident")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *IndexExpr: @@ -212,16 +253,25 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *CallExpr: + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) stack = append(stack, &stackItem{node: wrapNode(n.Having), visitor: v.Field("Having")}) stack = append(stack, &stackItem{node: wrapNode(n.NullHandling), visitor: v.Field("NullHandling")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.NamedArgs), visitor: v.Field("NamedArgs")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")}) + stack = append(stack, &stackItem{node: wrapNode(n.Func), visitor: v.Field("Func")}) case *TVFCallExpr: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Sample), visitor: v.Field("Sample")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.NamedArgs), visitor: v.Field("NamedArgs")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *ExprArg: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *IntervalArg: + stack = append(stack, &stackItem{node: wrapNode(n.Unit), visitor: v.Field("Unit")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *SequenceArg: @@ -229,15 +279,17 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { case *LambdaArg: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")}) case *ModelArg: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *TableArg: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *NamedArg: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *IgnoreNulls: // nothing to do @@ -255,12 +307,16 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *ExtractExpr: + stack = append(stack, &stackItem{node: wrapNode(n.AtTimeZone), visitor: v.Field("AtTimeZone")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + stack = append(stack, &stackItem{node: wrapNode(n.Part), visitor: v.Field("Part")}) case *ReplaceFieldsArg: + stack = append(stack, &stackItem{node: wrapNode(n.Field), visitor: v.Field("Field")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *ReplaceFieldsExpr: + stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *AtTimeZone: @@ -268,15 +324,19 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { case *WithExprVar: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *WithExpr: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Vars), visitor: v.Field("Vars")}) case *CastExpr: stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *CaseExpr: + stack = append(stack, &stackItem{node: wrapNode(n.Else), visitor: v.Field("Else")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Whens), visitor: v.Field("Whens")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *CaseWhen: @@ -301,16 +361,17 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *ArrayGQLSubQuery: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *ValueGQLSubQuery: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *ExistsGQLSubQuery: // nothing to do case *ExistsSubQuery: stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *Param: // nothing to do @@ -319,19 +380,21 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *Path: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Idents), visitor: v.Field("Idents")}) case *ArrayLiteral: + stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")}) stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")}) case *TupleStructLiteral: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")}) case *TypedStructLiteral: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")}) case *TypelessStructLiteral: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Values), visitor: v.Field("Values")}) case *NullLiteral: // nothing to do @@ -352,28 +415,31 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *DateLiteral: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) case *TimestampLiteral: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) case *NumericLiteral: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) case *JSONLiteral: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) case *NewConstructor: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")}) + stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")}) case *BracedNewConstructor: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Body), visitor: v.Field("Body")}) + stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")}) case *BracedConstructor: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")}) case *BracedConstructorField: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *BracedConstructorFieldValueExpr: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) @@ -385,13 +451,14 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Item), visitor: v.Field("Item")}) case *StructType: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Fields), visitor: v.Field("Fields")}) case *StructField: stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")}) + stack = append(stack, &stackItem{node: wrapNode(n.Ident), visitor: v.Field("Ident")}) case *NamedType: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Path), visitor: v.Field("Path")}) case *CastIntValue: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) @@ -400,68 +467,84 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *Options: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Records), visitor: v.Field("Records")}) case *OptionsDef: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreateSchema: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropSchema: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreateDatabase: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterDatabase: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreatePlacement: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *ProtoBundleTypes: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Types), visitor: v.Field("Types")}) case *CreateProtoBundle: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")}) case *AlterProtoBundle: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Delete), visitor: v.Field("Delete")}) + stack = append(stack, &stackItem{node: wrapNode(n.Update), visitor: v.Field("Update")}) + stack = append(stack, &stackItem{node: wrapNode(n.Insert), visitor: v.Field("Insert")}) case *AlterProtoBundleInsert: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")}) case *AlterProtoBundleUpdate: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")}) case *AlterProtoBundleDelete: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Types), visitor: v.Field("Types")}) case *DropProtoBundle: // nothing to do case *CreateTable: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")}) + stack = append(stack, &stackItem{node: wrapNode(n.Cluster), visitor: v.Field("Cluster")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Synonyms), visitor: v.Field("Synonyms")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.PrimaryKeys), visitor: v.Field("PrimaryKeys")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.TableConstraints), visitor: v.Field("TableConstraints")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *Synonym: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreateSequence: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Params), visitor: v.Field("Params")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *SkipRange: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Max), visitor: v.Field("Max")}) + stack = append(stack, &stackItem{node: wrapNode(n.Min), visitor: v.Field("Min")}) case *StartCounterWith: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Counter), visitor: v.Field("Counter")}) case *BitReversedPositive: // nothing to do case *ColumnDef: + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) stack = append(stack, &stackItem{node: wrapNode(n.DefaultSemantics), visitor: v.Field("DefaultSemantics")}) stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *ColumnDefaultExpr: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) @@ -470,91 +553,106 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *IdentityColumn: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Params), visitor: v.Field("Params")}) case *TableConstraint: stack = append(stack, &stackItem{node: wrapNode(n.Constraint), visitor: v.Field("Constraint")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *ForeignKey: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.ReferenceColumns), visitor: v.Field("ReferenceColumns")}) + stack = append(stack, &stackItem{node: wrapNode(n.ReferenceTable), visitor: v.Field("ReferenceTable")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) case *Check: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *IndexKey: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *Cluster: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) case *CreateRowDeletionPolicy: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")}) case *RowDeletionPolicy: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.NumDays), visitor: v.Field("NumDays")}) + stack = append(stack, &stackItem{node: wrapNode(n.ColumnName), visitor: v.Field("ColumnName")}) case *CreateView: stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropView: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterTable: stack = append(stack, &stackItem{node: wrapNode(n.TableAlteration), visitor: v.Field("TableAlteration")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterIndex: stack = append(stack, &stackItem{node: wrapNode(n.IndexAlteration), visitor: v.Field("IndexAlteration")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterSequence: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.NoSkipRange), visitor: v.Field("NoSkipRange")}) + stack = append(stack, &stackItem{node: wrapNode(n.SkipRange), visitor: v.Field("SkipRange")}) + stack = append(stack, &stackItem{node: wrapNode(n.RestartCounterWith), visitor: v.Field("RestartCounterWith")}) + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterChangeStream: stack = append(stack, &stackItem{node: wrapNode(n.ChangeStreamAlteration), visitor: v.Field("ChangeStreamAlteration")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AddSynonym: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropSynonym: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *RenameTo: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.AddSynonym), visitor: v.Field("AddSynonym")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AddColumn: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Column), visitor: v.Field("Column")}) case *AddTableConstraint: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.TableConstraint), visitor: v.Field("TableConstraint")}) case *AddRowDeletionPolicy: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")}) case *DropColumn: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropConstraint: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropRowDeletionPolicy: // nothing to do case *ReplaceRowDeletionPolicy: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.RowDeletionPolicy), visitor: v.Field("RowDeletionPolicy")}) case *SetOnDelete: // nothing to do case *AlterColumn: stack = append(stack, &stackItem{node: wrapNode(n.Alteration), visitor: v.Field("Alteration")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterColumnType: + stack = append(stack, &stackItem{node: wrapNode(n.DefaultExpr), visitor: v.Field("DefaultExpr")}) stack = append(stack, &stackItem{node: wrapNode(n.Type), visitor: v.Field("Type")}) case *AlterColumnSetOptions: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) case *AlterColumnSetDefault: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.DefaultExpr), visitor: v.Field("DefaultExpr")}) case *AlterColumnDropDefault: // nothing to do @@ -563,43 +661,55 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Alteration), visitor: v.Field("Alteration")}) case *RestartCounterWith: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Counter), visitor: v.Field("Counter")}) case *SetSkipRange: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.SkipRange), visitor: v.Field("SkipRange")}) case *NoSkipRange: // nothing to do case *SetNoSkipRange: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.NoSkipRange), visitor: v.Field("NoSkipRange")}) case *DropTable: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *RenameTable: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Tos), visitor: v.Field("Tos")}) case *RenameTableTo: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.New), visitor: v.Field("New")}) + stack = append(stack, &stackItem{node: wrapNode(n.Old), visitor: v.Field("Old")}) case *CreateIndex: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.InterleaveIn), visitor: v.Field("InterleaveIn")}) + stack = append(stack, &stackItem{node: wrapNode(n.Storing), visitor: v.Field("Storing")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Keys), visitor: v.Field("Keys")}) + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreateVectorIndex: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")}) + stack = append(stack, &stackItem{node: wrapNode(n.ColumnName), visitor: v.Field("ColumnName")}) + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreateChangeStream: + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) stack = append(stack, &stackItem{node: wrapNode(n.For), visitor: v.Field("For")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *ChangeStreamForAll: // nothing to do case *ChangeStreamForTables: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Tables), visitor: v.Field("Tables")}) case *ChangeStreamForTable: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) case *ChangeStreamSetFor: stack = append(stack, &stackItem{node: wrapNode(n.For), visitor: v.Field("For")}) @@ -608,91 +718,101 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *ChangeStreamSetOptions: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) case *Storing: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) case *InterleaveIn: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) case *AddStoredColumn: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropStoredColumn: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropIndex: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropVectorIndex: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropSequence: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreateRole: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropRole: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropChangeStream: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *Grant: + stack = append(stack, &stackItem{nodes: wrapNodes(n.Roles), visitor: v.Field("Roles")}) stack = append(stack, &stackItem{node: wrapNode(n.Privilege), visitor: v.Field("Privilege")}) case *Revoke: + stack = append(stack, &stackItem{nodes: wrapNodes(n.Roles), visitor: v.Field("Roles")}) stack = append(stack, &stackItem{node: wrapNode(n.Privilege), visitor: v.Field("Privilege")}) case *PrivilegeOnTable: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Privileges), visitor: v.Field("Privileges")}) case *SelectPrivilege: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) case *InsertPrivilege: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) case *UpdatePrivilege: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) case *DeletePrivilege: // nothing to do case *SelectPrivilegeOnChangeStream: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")}) case *SelectPrivilegeOnView: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")}) case *ExecutePrivilegeOnTableFunction: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")}) case *RolePrivilege: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Names), visitor: v.Field("Names")}) case *AlterStatistics: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *Analyze: // nothing to do case *CreateModelColumn: + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) stack = append(stack, &stackItem{node: wrapNode(n.DataType), visitor: v.Field("DataType")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreateModelInputOutput: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.OutputColumns), visitor: v.Field("OutputColumns")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.InputColumns), visitor: v.Field("InputColumns")}) case *CreateModel: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.InputOutput), visitor: v.Field("InputOutput")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterModel: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropModel: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *ScalarSchemaType: // nothing to do @@ -701,99 +821,125 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Size), visitor: v.Field("Size")}) case *ArraySchemaType: + stack = append(stack, &stackItem{nodes: wrapNodes(n.NamedArgs), visitor: v.Field("NamedArgs")}) stack = append(stack, &stackItem{node: wrapNode(n.Item), visitor: v.Field("Item")}) case *CreateSearchIndex: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Options), visitor: v.Field("Options")}) + stack = append(stack, &stackItem{node: wrapNode(n.Interleave), visitor: v.Field("Interleave")}) + stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")}) + stack = append(stack, &stackItem{node: wrapNode(n.OrderBy), visitor: v.Field("OrderBy")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.PartitionColumns), visitor: v.Field("PartitionColumns")}) + stack = append(stack, &stackItem{node: wrapNode(n.Storing), visitor: v.Field("Storing")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.TokenListPart), visitor: v.Field("TokenListPart")}) + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *DropSearchIndex: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *AlterSearchIndex: stack = append(stack, &stackItem{node: wrapNode(n.IndexAlteration), visitor: v.Field("IndexAlteration")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *CreatePropertyGraph: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Content), visitor: v.Field("Content")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *PropertyGraphContent: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.EdgeTables), visitor: v.Field("EdgeTables")}) + stack = append(stack, &stackItem{node: wrapNode(n.NodeTables), visitor: v.Field("NodeTables")}) case *PropertyGraphNodeTables: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Tables), visitor: v.Field("Tables")}) case *PropertyGraphEdgeTables: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Tables), visitor: v.Field("Tables")}) case *PropertyGraphElementList: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Elements), visitor: v.Field("Elements")}) case *PropertyGraphElement: stack = append(stack, &stackItem{node: wrapNode(n.Properties), visitor: v.Field("Properties")}) stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")}) + stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *PropertyGraphSingleProperties: stack = append(stack, &stackItem{node: wrapNode(n.Properties), visitor: v.Field("Properties")}) case *PropertyGraphLabelAndPropertiesList: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.LabelAndProperties), visitor: v.Field("LabelAndProperties")}) case *PropertyGraphLabelAndProperties: stack = append(stack, &stackItem{node: wrapNode(n.Properties), visitor: v.Field("Properties")}) stack = append(stack, &stackItem{node: wrapNode(n.Label), visitor: v.Field("Label")}) case *PropertyGraphElementLabelLabelName: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *PropertyGraphElementLabelDefaultLabel: // nothing to do case *PropertyGraphNodeElementKey: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Key), visitor: v.Field("Key")}) case *PropertyGraphEdgeElementKeys: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Destination), visitor: v.Field("Destination")}) + stack = append(stack, &stackItem{node: wrapNode(n.Source), visitor: v.Field("Source")}) + stack = append(stack, &stackItem{node: wrapNode(n.Element), visitor: v.Field("Element")}) case *PropertyGraphElementKey: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")}) case *PropertyGraphSourceKey: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.ReferenceColumns), visitor: v.Field("ReferenceColumns")}) + stack = append(stack, &stackItem{node: wrapNode(n.ElementReference), visitor: v.Field("ElementReference")}) + stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")}) case *PropertyGraphDestinationKey: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.ReferenceColumns), visitor: v.Field("ReferenceColumns")}) + stack = append(stack, &stackItem{node: wrapNode(n.ElementReference), visitor: v.Field("ElementReference")}) + stack = append(stack, &stackItem{node: wrapNode(n.Keys), visitor: v.Field("Keys")}) case *PropertyGraphColumnNameList: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.ColumnNameList), visitor: v.Field("ColumnNameList")}) case *PropertyGraphNoProperties: // nothing to do case *PropertyGraphPropertiesAre: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.ExceptColumns), visitor: v.Field("ExceptColumns")}) case *PropertyGraphDerivedPropertyList: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.DerivedProperties), visitor: v.Field("DerivedProperties")}) case *PropertyGraphDerivedProperty: + 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 *DropPropertyGraph: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *WithAction: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Alias), visitor: v.Field("Alias")}) case *ThenReturn: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Items), visitor: v.Field("Items")}) + stack = append(stack, &stackItem{node: wrapNode(n.WithAction), visitor: v.Field("WithAction")}) case *Insert: + stack = append(stack, &stackItem{node: wrapNode(n.ThenReturn), visitor: v.Field("ThenReturn")}) stack = append(stack, &stackItem{node: wrapNode(n.Input), visitor: v.Field("Input")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Columns), visitor: v.Field("Columns")}) + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *ValuesInput: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Rows), visitor: v.Field("Rows")}) case *ValuesRow: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Exprs), visitor: v.Field("Exprs")}) case *DefaultExpr: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) @@ -802,25 +948,38 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Query), visitor: v.Field("Query")}) case *Delete: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.ThenReturn), visitor: v.Field("ThenReturn")}) + stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")}) + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *Update: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.ThenReturn), visitor: v.Field("ThenReturn")}) + stack = append(stack, &stackItem{node: wrapNode(n.Where), visitor: v.Field("Where")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Updates), visitor: v.Field("Updates")}) + stack = append(stack, &stackItem{node: wrapNode(n.As), visitor: v.Field("As")}) + stack = append(stack, &stackItem{node: wrapNode(n.TableName), visitor: v.Field("TableName")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *UpdateItem: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.DefaultExpr), visitor: v.Field("DefaultExpr")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.Path), visitor: v.Field("Path")}) case *Call: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.Args), visitor: v.Field("Args")}) + stack = append(stack, &stackItem{node: wrapNode(n.Name), visitor: v.Field("Name")}) case *GQLGraphQuery: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.MultiLinearQueryStatement), visitor: v.Field("MultiLinearQueryStatement")}) + stack = append(stack, &stackItem{node: wrapNode(n.GraphClause), visitor: v.Field("GraphClause")}) case *GQLQueryExpr: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.MultiLinearQueryStatement), visitor: v.Field("MultiLinearQueryStatement")}) + stack = append(stack, &stackItem{node: wrapNode(n.GraphClause), visitor: v.Field("GraphClause")}) case *GQLGraphClause: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.PropertyGraphName), visitor: v.Field("PropertyGraphName")}) case *GQLMultiLinearQueryStatement: // nothing to do @@ -829,31 +988,36 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *GQLSimpleLinearQueryStatementWithSetOperator: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Statement), visitor: v.Field("Statement")}) case *GQLCompositeLinearQueryStatement: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.TailSimpleLinearQueryStatementList), visitor: v.Field("TailSimpleLinearQueryStatementList")}) + stack = append(stack, &stackItem{node: wrapNode(n.HeadSimpleLinearQueryStatement), visitor: v.Field("HeadSimpleLinearQueryStatement")}) case *GQLMatchStatement: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.GraphPattern), visitor: v.Field("GraphPattern")}) + stack = append(stack, &stackItem{node: wrapNode(n.MatchHint), visitor: v.Field("MatchHint")}) case *GQLFilterStatement: stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *GQLForStatement: + stack = append(stack, &stackItem{node: wrapNode(n.WithOffsetClause), visitor: v.Field("WithOffsetClause")}) stack = append(stack, &stackItem{node: wrapNode(n.ArrayExpression), visitor: v.Field("ArrayExpression")}) + stack = append(stack, &stackItem{node: wrapNode(n.ElementName), visitor: v.Field("ElementName")}) case *GQLWithOffsetClause: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.OffsetName), visitor: v.Field("OffsetName")}) case *GQLLimitClause: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Limit), visitor: v.Field("Limit")}) case *GQLOffsetClause: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) case *GQLLimitWithOffsetClause: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) + stack = append(stack, &stackItem{node: wrapNode(n.Limit), visitor: v.Field("Limit")}) case *GQLLimitStatement: stack = append(stack, &stackItem{node: wrapNode(n.Count), visitor: v.Field("Count")}) @@ -862,43 +1026,50 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Count), visitor: v.Field("Count")}) case *GQLOrderByStatement: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.OrderBySpecificationList), visitor: v.Field("OrderBySpecificationList")}) case *GQLOrderBySpecification: + stack = append(stack, &stackItem{node: wrapNode(n.CollationSpecification), visitor: v.Field("CollationSpecification")}) stack = append(stack, &stackItem{node: wrapNode(n.Expr), visitor: v.Field("Expr")}) case *GQLCollationSpecification: stack = append(stack, &stackItem{node: wrapNode(n.Specification), visitor: v.Field("Specification")}) case *GQLWithStatement: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.GroupByClause), visitor: v.Field("GroupByClause")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.ReturnItemList), visitor: v.Field("ReturnItemList")}) case *GQLReturnItem: stack = append(stack, &stackItem{node: wrapNode(n.Item), visitor: v.Field("Item")}) case *GQLReturnStatement: stack = append(stack, &stackItem{node: wrapNode(n.LimitAndOffsetClause), visitor: v.Field("LimitAndOffsetClause")}) + stack = append(stack, &stackItem{node: wrapNode(n.OrderByClause), visitor: v.Field("OrderByClause")}) + stack = append(stack, &stackItem{node: wrapNode(n.GroupByClause), visitor: v.Field("GroupByClause")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.ReturnItemList), visitor: v.Field("ReturnItemList")}) case *GQLLinearGraphVariable: stack = append(stack, &stackItem{node: wrapNode(n.Value), visitor: v.Field("Value")}) + stack = append(stack, &stackItem{node: wrapNode(n.VariableName), visitor: v.Field("VariableName")}) case *GQLLetStatement: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.LinearGraphVariableList), visitor: v.Field("LinearGraphVariableList")}) case *GQLGraphPattern: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.WhereClause), visitor: v.Field("WhereClause")}) + stack = append(stack, &stackItem{nodes: wrapNodes(n.PathPatternList), visitor: v.Field("PathPatternList")}) case *GQLTopLevelPathPattern: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.PathPattern), visitor: v.Field("PathPattern")}) case *GQLFullEdgeAny: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.PatternFiller), visitor: v.Field("PatternFiller")}) case *GQLFullEdgeLeft: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.PatternFiller), visitor: v.Field("PatternFiller")}) case *GQLFullEdgeRight: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.PatternFiller), visitor: v.Field("PatternFiller")}) case *GQLAbbreviatedEdgeAny: // nothing to do @@ -910,16 +1081,17 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { // nothing to do case *GQLQuantifiablePathTerm: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *GQLPathPattern: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.PathTermList), visitor: v.Field("PathTermList")}) case *GQLWhereClause: stack = append(stack, &stackItem{node: wrapNode(n.BoolExpression), visitor: v.Field("BoolExpression")}) case *GQLPathMode: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.PathOrPathsToken), visitor: v.Field("PathOrPathsToken")}) + stack = append(stack, &stackItem{node: wrapNode(n.ModeToken), visitor: v.Field("ModeToken")}) case *GQLFixedQuantifier: stack = append(stack, &stackItem{node: wrapNode(n.Bound), visitor: v.Field("Bound")}) @@ -929,13 +1101,17 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.LowerBound), visitor: v.Field("LowerBound")}) case *GQLSubpathPattern: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.WhereClause), visitor: v.Field("WhereClause")}) + stack = append(stack, &stackItem{node: wrapNode(n.PathPattern), visitor: v.Field("PathPattern")}) + stack = append(stack, &stackItem{node: wrapNode(n.PathMode), visitor: v.Field("PathMode")}) case *GQLNodePattern: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.PatternFiller), visitor: v.Field("PatternFiller")}) case *GQLPatternFiller: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.IsLabelCondition), visitor: v.Field("IsLabelCondition")}) + stack = append(stack, &stackItem{node: wrapNode(n.GraphPatternVariable), visitor: v.Field("GraphPatternVariable")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *GQLIsLabelCondition: // nothing to do @@ -955,13 +1131,14 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.LabelExpression), visitor: v.Field("LabelExpression")}) case *GQLLabelName: - // nothing to do + stack = append(stack, &stackItem{node: wrapNode(n.LabelName), visitor: v.Field("LabelName")}) case *GQLPropertyFilters: - // nothing to do + stack = append(stack, &stackItem{nodes: wrapNodes(n.PropertyFilterElemList), visitor: v.Field("PropertyFilterElemList")}) case *GQLElementProperty: stack = append(stack, &stackItem{node: wrapNode(n.ElementPropertyValue), visitor: v.Field("ElementPropertyValue")}) + stack = append(stack, &stackItem{node: wrapNode(n.ElementPropertyName), visitor: v.Field("ElementPropertyName")}) case *GQLPathSearchPrefix: // nothing to do From 46cddebfb5fd96397ee9ecb0d9ec6d258b3d05d6 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 14 Jan 2025 15:30:47 +0900 Subject: [PATCH 43/53] Add Hint to GQLGraphQuery --- parser.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/parser.go b/parser.go index a378e5f6..27dd0fad 100644 --- a/parser.go +++ b/parser.go @@ -5596,10 +5596,15 @@ func (p *Parser) parseStringValue() ast.StringValue { // ================================================================================ func (p *Parser) parseGQLQuery() *ast.GQLGraphQuery { + hint := p.tryParseHint() + return p.parseGQLQueryInternal(hint) +} + +func (p *Parser) parseGQLQueryInternal(hint *ast.Hint) *ast.GQLGraphQuery { graphClause := p.parseGQLGraphClause() multiQueryStatement := p.parseGQLMultiLinearQueryStatement() - return &ast.GQLGraphQuery{GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} + return &ast.GQLGraphQuery{Hint: hint, GraphClause: graphClause, MultiLinearQueryStatement: multiQueryStatement} } func (p *Parser) parseGQLSubQueryInCondition() *ast.GQLSubQueryInCondition { From 487537faac04cc8496155a19921f557c8fbbcd15 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 14 Jan 2025 15:56:57 +0900 Subject: [PATCH 44/53] Implement path variables --- ast/ast.go | 7 +++++-- ast/pos.go | 2 +- ast/sql.go | 4 ++-- ast/walk_internal.go | 2 ++ parser.go | 22 ++++++++++++++++++++++ 5 files changed, 32 insertions(+), 5 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index e3e449b4..8d31fa4d 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -4188,12 +4188,14 @@ type Call struct { // GQLGraphQuery is toplevel node of GRAPH query. // +// {{.Hint | sqlOpt}} // {{.Graph | sql}} // {{.MultiLinearQueryStatement | sql}} type GQLGraphQuery struct { - // pos = (GraphClause ?? MultiLinearQueryStatement).pos + // pos = (Hint ?? GraphClause ?? MultiLinearQueryStatement).pos // end = MultiLinearQueryStatement.end + Hint *Hint GraphClause *GQLGraphClause MultiLinearQueryStatement *GQLMultiLinearQueryStatement } @@ -4542,11 +4544,12 @@ type GQLGraphPattern struct { // GQLTopLevelPathPattern is a PathPattern optionally prefixed by PathSearchPrefixOrPathMode. // -// {{.PathSearchPrefixOrPathMode | sqlOpt}} {{.PathPattern | sql}} +// {{if .Var}}{{.Var}} = {{end}}{{.PathSearchPrefixOrPathMode | sqlOpt}} {{.PathPattern | sql}} type GQLTopLevelPathPattern struct { // pos = (PathSearchPrefixOrPathMode ?? PathPattern).pos // end = PathPattern.end + Var *Ident PathSearchPrefixOrPathMode GQLPathSearchPrefixOrPathMode // optional PathPattern *GQLPathPattern } diff --git a/ast/pos.go b/ast/pos.go index 34a286e9..7ed0b9eb 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -2119,7 +2119,7 @@ func (c *Call) End() token.Pos { } func (g *GQLGraphQuery) Pos() token.Pos { - return nodePos(nodeChoice(wrapNode(g.GraphClause), wrapNode(g.MultiLinearQueryStatement))) + return nodePos(nodeChoice(wrapNode(g.Hint), wrapNode(g.GraphClause), wrapNode(g.MultiLinearQueryStatement))) } func (g *GQLGraphQuery) End() token.Pos { diff --git a/ast/sql.go b/ast/sql.go index 6a45da71..76e8ac3c 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1422,7 +1422,7 @@ func (c *Call) SQL() string { // GQL func (s *GQLGraphQuery) SQL() string { - return s.GraphClause.SQL() + "\n" + s.MultiLinearQueryStatement.SQL() + return sqlOpt("", s.Hint, " ") + s.GraphClause.SQL() + "\n" + s.MultiLinearQueryStatement.SQL() } func (g *GQLQueryExpr) SQL() string { @@ -1578,7 +1578,7 @@ func (g *GQLGraphPattern) SQL() string { } func (g *GQLTopLevelPathPattern) SQL() string { - return sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() + return sqlOpt("", g.Var, " = ") + sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() } func (g *GQLFullEdgeAny) SQL() string { return "-[" + g.PatternFiller.SQL() + "]-" } diff --git a/ast/walk_internal.go b/ast/walk_internal.go index 388b27c4..2f09b56f 100644 --- a/ast/walk_internal.go +++ b/ast/walk_internal.go @@ -973,6 +973,7 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { case *GQLGraphQuery: stack = append(stack, &stackItem{node: wrapNode(n.MultiLinearQueryStatement), visitor: v.Field("MultiLinearQueryStatement")}) stack = append(stack, &stackItem{node: wrapNode(n.GraphClause), visitor: v.Field("GraphClause")}) + stack = append(stack, &stackItem{node: wrapNode(n.Hint), visitor: v.Field("Hint")}) case *GQLQueryExpr: stack = append(stack, &stackItem{node: wrapNode(n.MultiLinearQueryStatement), visitor: v.Field("MultiLinearQueryStatement")}) @@ -1061,6 +1062,7 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { case *GQLTopLevelPathPattern: stack = append(stack, &stackItem{node: wrapNode(n.PathPattern), visitor: v.Field("PathPattern")}) + stack = append(stack, &stackItem{node: wrapNode(n.Var), visitor: v.Field("Var")}) case *GQLFullEdgeAny: stack = append(stack, &stackItem{node: wrapNode(n.PatternFiller), visitor: v.Field("PatternFiller")}) diff --git a/parser.go b/parser.go index 27dd0fad..97aafa1a 100644 --- a/parser.go +++ b/parser.go @@ -6269,9 +6269,31 @@ func (p *Parser) parseGQLPathPattern() *ast.GQLPathPattern { PathTermList: list, } } + +func (p *Parser) lookaheadGQLPathVariable() bool { + lexer := p.Lexer.Clone() + defer func() { + p.Lexer = lexer + }() + + if p.Token.Kind != token.TokenIdent { + return false + } + p.nextToken() + + return p.Token.Kind == "=" +} + func (p *Parser) parseGQLTopLevelPathPattern() *ast.GQLTopLevelPathPattern { + var varName *ast.Ident + if p.lookaheadGQLPathVariable() { + varName = p.parseIdent() + p.expect("=") + } + pattern := p.parseGQLPathPattern() return &ast.GQLTopLevelPathPattern{ + Var: varName, PathSearchPrefixOrPathMode: nil, // TODO PathPattern: pattern, } From 4e22f71978b573fb2040d35d3215dbe490b595a9 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 14 Jan 2025 16:10:22 +0900 Subject: [PATCH 45/53] Fix GQLTopLevelPathPattern --- ast/sql.go | 14 ++++---------- parser.go | 3 ++- 2 files changed, 6 insertions(+), 11 deletions(-) diff --git a/ast/sql.go b/ast/sql.go index 76e8ac3c..92fd7976 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1476,16 +1476,10 @@ func (s *GQLLinearGraphVariable) SQL() string { return s.VariableName.SQL() + " // GQL statements func (g *GQLMatchStatement) SQL() string { - var sql string - if !g.Optional.Invalid() { - sql = "OPTIONAL MATCH" - } else { - sql = "MATCH" - } - sql += sqlOpt("", g.MatchHint, "") - sql += sqlOpt(" ", g.PrefixOrMode, "") - sql += " " + g.GraphPattern.SQL() - return sql + return strIfElse(g.Optional.Invalid(), "MATCH", "OPTIONAL MATCH") + + sqlOpt("", g.MatchHint, "") + + sqlOpt(" ", g.PrefixOrMode, "") + + " " + g.GraphPattern.SQL() } func (g *GQLFilterStatement) SQL() string { diff --git a/parser.go b/parser.go index 97aafa1a..34377159 100644 --- a/parser.go +++ b/parser.go @@ -6291,10 +6291,11 @@ func (p *Parser) parseGQLTopLevelPathPattern() *ast.GQLTopLevelPathPattern { p.expect("=") } + pathMode := p.tryParseGQLPathSearchPrefixOrPathMode() pattern := p.parseGQLPathPattern() return &ast.GQLTopLevelPathPattern{ Var: varName, - PathSearchPrefixOrPathMode: nil, // TODO + PathSearchPrefixOrPathMode: pathMode, PathPattern: pattern, } } From 343792f08f7f844d077055be7672f7b8704a98db Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 14 Jan 2025 16:15:01 +0900 Subject: [PATCH 46/53] Implement ACYCLIC path mode --- ast/ast_const.go | 6 +++--- parser.go | 32 +++++++++++++++++--------------- 2 files changed, 20 insertions(+), 18 deletions(-) diff --git a/ast/ast_const.go b/ast/ast_const.go index f2a35357..cef9d573 100644 --- a/ast/ast_const.go +++ b/ast/ast_const.go @@ -188,9 +188,9 @@ const ( type GQLPathModeEnum string const ( - GQLPathModeUnspecified GQLPathModeEnum = "" - GQLPathModeWalk GQLPathModeEnum = "WALK" - GQLPathModeTrail GQLPathModeEnum = "TRAIL" + GQLPathModeWalk GQLPathModeEnum = "WALK" + GQLPathModeTrail GQLPathModeEnum = "TRAIL" + GQLPathModeAcyclic GQLPathModeEnum = "ACYCLIC" ) type GQLSearchPrefixEnum string diff --git a/parser.go b/parser.go index 34377159..cfe261a1 100644 --- a/parser.go +++ b/parser.go @@ -5901,28 +5901,30 @@ func (p *Parser) tryParseGQLPathModePathOrPaths() *ast.Ident { } func (p *Parser) tryParseGQLPathMode() *ast.GQLPathMode { + var pathModeToken *ast.Ident + var mode ast.GQLPathModeEnum switch { case p.Token.IsKeywordLike("WALK"): - pathModeToken := p.parseIdent() - pathOrPathsToken := p.tryParseGQLPathModePathOrPaths() - return &ast.GQLPathMode{ - ModeToken: pathModeToken, - PathOrPathsToken: pathOrPathsToken, - Mode: ast.GQLPathModeWalk, - } - + pathModeToken = p.parseIdent() + mode = ast.GQLPathModeWalk case p.Token.IsKeywordLike("TRAIL"): - pathModeToken := p.parseIdent() - pathOrPathsToken := p.tryParseGQLPathModePathOrPaths() - return &ast.GQLPathMode{ - ModeToken: pathModeToken, - PathOrPathsToken: pathOrPathsToken, - Mode: ast.GQLPathModeTrail, - } + pathModeToken = p.parseIdent() + mode = ast.GQLPathModeTrail + case p.Token.IsKeywordLike("ACYCLIC"): + pathModeToken = p.parseIdent() + mode = ast.GQLPathModeAcyclic default: return nil } + + pathOrPathsToken := p.tryParseGQLPathModePathOrPaths() + return &ast.GQLPathMode{ + ModeToken: pathModeToken, + PathOrPathsToken: pathOrPathsToken, + Mode: mode, + } } + func (p *Parser) tryParseGQLPathSearchPrefixOrPathMode() ast.GQLPathSearchPrefixOrPathMode { startPos := p.Token.Pos switch { From 18691e8cbb41e397a8e840541ea9582b30788dc6 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Tue, 14 Jan 2025 16:29:26 +0900 Subject: [PATCH 47/53] Fix GQLLimitWithOffsetClause --- ast/ast.go | 6 +- ast/pos.go | 4 +- ast/sql.go | 2 +- ast/walk_internal.go | 2 +- parser.go | 4 +- testdata/input/gql/return_offset_limit.sql | 5 + .../result/gql/return_offset_limit.sql.txt | 128 ++++++++++++++++++ 7 files changed, 142 insertions(+), 9 deletions(-) create mode 100644 testdata/input/gql/return_offset_limit.sql create mode 100644 testdata/result/gql/return_offset_limit.sql.txt diff --git a/ast/ast.go b/ast/ast.go index 8d31fa4d..a6e38f8a 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -4387,11 +4387,11 @@ type GQLOffsetClause struct { // // {{.Offset | sql}} {{.Offset | sql}} type GQLLimitWithOffsetClause struct { - // pos = Limit.pos - // end = Offset.end + // pos = Offset.pos + // end = Limit.end - Limit *Limit Offset *Offset + Limit *Limit } // GQLLimitStatement represents LIMIT statement diff --git a/ast/pos.go b/ast/pos.go index 7ed0b9eb..96769d93 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -2223,11 +2223,11 @@ func (g *GQLOffsetClause) End() token.Pos { } func (g *GQLLimitWithOffsetClause) Pos() token.Pos { - return nodePos(wrapNode(g.Limit)) + return nodePos(wrapNode(g.Offset)) } func (g *GQLLimitWithOffsetClause) End() token.Pos { - return nodeEnd(wrapNode(g.Offset)) + return nodeEnd(wrapNode(g.Limit)) } func (g *GQLLimitStatement) Pos() token.Pos { diff --git a/ast/sql.go b/ast/sql.go index 92fd7976..239df646 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1499,7 +1499,7 @@ func (g *GQLLimitClause) SQL() string { return g.Limit.SQL() } func (g *GQLOffsetClause) SQL() string { return g.Offset.SQL() } -func (g *GQLLimitWithOffsetClause) SQL() string { return g.Limit.SQL() + " " + g.Offset.SQL() } +func (g *GQLLimitWithOffsetClause) SQL() string { return g.Offset.SQL() + " " + g.Limit.SQL() } func (g *GQLLimitStatement) SQL() string { return "LIMIT " + g.Count.SQL() } diff --git a/ast/walk_internal.go b/ast/walk_internal.go index 2f09b56f..2604b112 100644 --- a/ast/walk_internal.go +++ b/ast/walk_internal.go @@ -1017,8 +1017,8 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) case *GQLLimitWithOffsetClause: - stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) stack = append(stack, &stackItem{node: wrapNode(n.Limit), visitor: v.Field("Limit")}) + stack = append(stack, &stackItem{node: wrapNode(n.Offset), visitor: v.Field("Offset")}) case *GQLLimitStatement: stack = append(stack, &stackItem{node: wrapNode(n.Count), visitor: v.Field("Count")}) diff --git a/parser.go b/parser.go index cfe261a1..183f28df 100644 --- a/parser.go +++ b/parser.go @@ -6369,16 +6369,16 @@ func (p *Parser) parseGQLReturnStatement() *ast.GQLReturnStatement { returnItems := p.parseGQLReturnItemList() groupBy := p.tryParseGroupBy() orderBy := p.tryParseOrderBy() - limit := p.tryParseLimit() offset := p.tryParseOffset() + limit := p.tryParseLimit() // TODO: refactor var limitAndOffset ast.GQLLimitAndOffsetClause switch { case limit != nil && offset != nil: limitAndOffset = &ast.GQLLimitWithOffsetClause{ - Limit: limit, Offset: offset, + Limit: limit, } case limit != nil: limitAndOffset = &ast.GQLLimitClause{Limit: limit} diff --git a/testdata/input/gql/return_offset_limit.sql b/testdata/input/gql/return_offset_limit.sql new file mode 100644 index 00000000..f1657fbd --- /dev/null +++ b/testdata/input/gql/return_offset_limit.sql @@ -0,0 +1,5 @@ +GRAPH FinGraph +MATCH (p:Person) +RETURN p.name, p.id +OFFSET 1 +LIMIT 1 \ No newline at end of file diff --git a/testdata/result/gql/return_offset_limit.sql.txt b/testdata/result/gql/return_offset_limit.sql.txt new file mode 100644 index 00000000..32d5ccc6 --- /dev/null +++ b/testdata/result/gql/return_offset_limit.sql.txt @@ -0,0 +1,128 @@ +--- return_offset_limit.sql +GRAPH FinGraph +MATCH (p:Person) +RETURN p.name, p.id +OFFSET 1 +LIMIT 1 +--- AST +&ast.GQLGraphQuery{ + GraphClause: &ast.GQLGraphClause{ + PropertyGraphName: &ast.Ident{ + NamePos: 6, + NameEnd: 14, + Name: "FinGraph", + }, + }, + MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ + LinearQueryStatementList: []ast.GQLLinearQueryStatement{ + &ast.GQLSimpleLinearQueryStatement{ + PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ + &ast.GQLMatchStatement{ + Optional: -1, + Match: 15, + GraphPattern: &ast.GQLGraphPattern{ + PathPatternList: []*ast.GQLTopLevelPathPattern{ + &ast.GQLTopLevelPathPattern{ + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ + PathTerm: &ast.GQLNodePattern{ + LParen: 21, + RParen: 30, + PatternFiller: &ast.GQLPatternFiller{ + GraphPatternVariable: &ast.Ident{ + NamePos: 22, + NameEnd: 23, + Name: "p", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 23, + LabelExpression: &ast.GQLLabelName{ + StartPos: 24, + LabelName: &ast.Ident{ + NamePos: 24, + NameEnd: 30, + Name: "Person", + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + }, + &ast.GQLReturnStatement{ + Return: 32, + ReturnItemList: []*ast.GQLReturnItem{ + &ast.GQLReturnItem{ + Item: &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 39, + NameEnd: 40, + Name: "p", + }, + &ast.Ident{ + NamePos: 41, + NameEnd: 45, + Name: "name", + }, + }, + }, + }, + }, + &ast.GQLReturnItem{ + Item: &ast.ExprSelectItem{ + Expr: &ast.Path{ + Idents: []*ast.Ident{ + &ast.Ident{ + NamePos: 47, + NameEnd: 48, + Name: "p", + }, + &ast.Ident{ + NamePos: 49, + NameEnd: 51, + Name: "id", + }, + }, + }, + }, + }, + }, + LimitAndOffsetClause: &ast.GQLLimitWithOffsetClause{ + Offset: &ast.Offset{ + Offset: 52, + Value: &ast.IntLiteral{ + ValuePos: 59, + ValueEnd: 60, + Base: 10, + Value: "1", + }, + }, + Limit: &ast.Limit{ + Limit: 61, + Count: &ast.IntLiteral{ + ValuePos: 67, + ValueEnd: 68, + Base: 10, + Value: "1", + }, + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +GRAPH FinGraph +MATCH (p:Person) +RETURN p.name, p.id OFFSET 1 LIMIT 1 From fd3edeb8b1307fdd3d81b390eedb1315e17c4e6f Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 15 Jan 2025 00:15:27 +0900 Subject: [PATCH 48/53] Split GQLLabelPrimary --- ast/ast.go | 64 ++++++++----------- ast/pos.go | 16 +++-- ast/sql.go | 8 +-- ast/walk_internal.go | 5 +- parser.go | 10 ++- testdata/result/gql/filter.sql.txt | 9 +-- testdata/result/gql/filter_where.sql.txt | 9 +-- testdata/result/gql/for_with_offset.sql.txt | 9 +-- .../result/gql/for_with_offset_as.sql.txt | 3 +- .../result/gql/graph_hints_between.sql.txt | 15 ++--- testdata/result/gql/graph_hints_match.sql.txt | 18 ++---- .../gql/graph_hints_traversal_hint.sql.txt | 18 ++---- testdata/result/gql/let.sql.txt | 9 +-- testdata/result/gql/limit.sql.txt | 9 +-- testdata/result/gql/match.sql.txt | 3 +- .../result/gql/match_any_shortest.sql.txt | 9 +-- testdata/result/gql/match_optional.sql.txt | 12 ++-- .../result/gql/match_or_expression.sql.txt | 6 +- .../result/gql/match_subpath_trail.sql.txt | 15 ++--- .../gql/match_trail_subpath_walk.sql.txt | 9 +-- ...tch_where_is_destination_of_return.sql.txt | 9 +-- .../match_where_is_source_of_return.sql.txt | 9 +-- .../gql/match_where_not_same_return.sql.txt | 9 +-- ...match_where_property_exists_return.sql.txt | 6 +- testdata/result/gql/next.sql.txt | 18 ++---- testdata/result/gql/next_1.sql.txt | 18 ++---- testdata/result/gql/offset_1.sql.txt | 3 +- testdata/result/gql/order_by.sql.txt | 9 +-- testdata/result/gql/order_by_collate.sql.txt | 3 +- testdata/result/gql/return.sql.txt | 18 ++---- .../result/gql/return_array_subquery.sql.txt | 18 ++---- testdata/result/gql/return_distinct.sql.txt | 9 +-- .../gql/return_exists_graph_pattern.sql.txt | 9 +-- .../result/gql/return_exists_match.sql.txt | 9 +-- .../gql/return_exists_query_expr.sql.txt | 9 +-- .../result/gql/return_in_gql_subquery.sql.txt | 9 +-- .../result/gql/return_offset_limit.sql.txt | 3 +- .../result/gql/return_value_subquery.sql.txt | 3 +- testdata/result/gql/skip_1.sql.txt | 3 +- testdata/result/gql/with_1.sql.txt | 9 +-- .../result/gql_path_pattern/pattern_1.sql.txt | 5 +- .../result/gql_path_pattern/pattern_2.sql.txt | 9 +-- .../query/select_in_gql_subquery.sql.txt | 9 +-- .../statement/select_in_gql_subquery.sql.txt | 9 +-- 44 files changed, 175 insertions(+), 296 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index a6e38f8a..deac47f4 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -4456,9 +4456,7 @@ type GQLCollationSpecification struct { // GQLWithStatement represents WITH statement. // -// WITH {{.GQLAllOrDistinctEnum | sql}} {{.ReturnItemList | sqlJoin}} {{.GroupBy | sql}} -// -// TODO: Refactor +// WITH {{string(.GQLAllOrDistinctEnum)}} {{.ReturnItemList | sqlJoin}} {{.GroupBy | sqlOpt}} type GQLWithStatement struct { // pos = With // end = (GroupByClause ?? ReturnItemList[$]).end @@ -4780,26 +4778,6 @@ type GQLNodePattern struct { PatternFiller *GQLPatternFiller } -// EdgePattern TODO -/* -edge_pattern: - { - full_edge_any | - full_edge_left | - full_edge_right | - abbreviated_edge_any | - abbreviated_edge_left | - abbreviated_edge_right - } -*/ -/* -type EdgePattern interface { - Node - isEdgePattern() -} - -*/ - // GQLPatternFiller represents specifications on the node or edge pattern that you want to match. // // {{.Hint | sqlOpt}} @@ -4842,7 +4820,8 @@ func (GQLLabelParenExpression) isGQLLabelExpression() {} func (GQLLabelOrExpression) isGQLLabelExpression() {} func (GQLLabelAndExpression) isGQLLabelExpression() {} func (GQLLabelNotExpression) isGQLLabelExpression() {} -func (GQLLabelName) isGQLLabelExpression() {} +func (GQLWildcardLabel) isGQLLabelExpression() {} +func (GQLElementLabel) isGQLLabelExpression() {} // GQLLabelOrExpression represents `label_expression|label_expression`. // @@ -4886,17 +4865,31 @@ type GQLLabelNotExpression struct { LabelExpression GQLLabelExpression } -// GQLLabelName represents the label to match. +type GQLLabelPrimary interface { + GQLLabelExpression + isGQLLabelPrimary() +} + +func (GQLElementLabel) isGQLLabelPrimary() {} +func (GQLWildcardLabel) isGQLLabelPrimary() {} + +// GQLWildcardLabel is % node in label expression. // -// {{if .IsPercent}}%{{else}}{{.LabelName | sql}}{{end}} -type GQLLabelName struct { - // pos = StartPos - // end = LabelName.end || StartPos + 1 +// % +type GQLWildcardLabel struct { + // pos = Percent + // end = Percent + 1 - // TODO: Make it interaface + Percent token.Pos // position of "%" +} + +// GQLElementLabel represents the label to match. +// +// {{.LabelName | sql}} +type GQLElementLabel struct { + // pos = LabelName.pos + // end = LabelName.end - StartPos token.Pos // position of "%" or LabelName - IsPercent bool LabelName *Ident // optional } @@ -4936,13 +4929,12 @@ type GQLElementProperty struct { // GQLPathSearchPrefix represents `{"ALL" | "ANY" | "ANY SHORTEST"}`. // // {{string(.SearchPrefix)}} -// -// TODO: Make it interface type GQLPathSearchPrefix struct { // pos = StartPos // end = LastEnd - StartPos token.Pos - LastEnd token.Pos // end of last token + StartPos token.Pos // position of "ALL" or "ANY" + LastEnd token.Pos // end of last token("ALL" or "ANY" or "SHORTEST") + SearchPrefix GQLSearchPrefixEnum } diff --git a/ast/pos.go b/ast/pos.go index 96769d93..4f879cf3 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -2486,12 +2486,20 @@ func (g *GQLLabelNotExpression) End() token.Pos { return nodeEnd(wrapNode(g.LabelExpression)) } -func (g *GQLLabelName) Pos() token.Pos { - return g.StartPos +func (g *GQLWildcardLabel) Pos() token.Pos { + return g.Percent +} + +func (g *GQLWildcardLabel) End() token.Pos { + return posAdd(g.Percent, 1) +} + +func (g *GQLElementLabel) Pos() token.Pos { + return nodePos(wrapNode(g.LabelName)) } -func (g *GQLLabelName) End() token.Pos { - return posChoice(nodeEnd(wrapNode(g.LabelName)), posAdd(g.StartPos, 1)) +func (g *GQLElementLabel) End() token.Pos { + return nodeEnd(wrapNode(g.LabelName)) } func (g *GQLPropertyFilters) Pos() token.Pos { diff --git a/ast/sql.go b/ast/sql.go index 239df646..ee7598ba 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1644,10 +1644,10 @@ func (g *GQLLabelAndExpression) SQL() string { return g.Left.SQL() + "&" + g.Rig func (g *GQLLabelNotExpression) SQL() string { return "!" + g.LabelExpression.SQL() } -func (g *GQLLabelName) SQL() string { - if g.IsPercent { - return "%" - } +func (g *GQLWildcardLabel) SQL() string { + return "%" +} +func (g *GQLElementLabel) SQL() string { return g.LabelName.SQL() } diff --git a/ast/walk_internal.go b/ast/walk_internal.go index 2604b112..66f5bb24 100644 --- a/ast/walk_internal.go +++ b/ast/walk_internal.go @@ -1132,7 +1132,10 @@ func walkInternal(node Node, v Visitor, stack []*stackItem) []*stackItem { case *GQLLabelNotExpression: stack = append(stack, &stackItem{node: wrapNode(n.LabelExpression), visitor: v.Field("LabelExpression")}) - case *GQLLabelName: + case *GQLWildcardLabel: + // nothing to do + + case *GQLElementLabel: stack = append(stack, &stackItem{node: wrapNode(n.LabelName), visitor: v.Field("LabelName")}) case *GQLPropertyFilters: diff --git a/parser.go b/parser.go index 183f28df..45088740 100644 --- a/parser.go +++ b/parser.go @@ -5982,20 +5982,18 @@ func (p *Parser) parseGQLMatchStatement() *ast.GQLMatchStatement { } } -func (p *Parser) parseGQLLabelName() *ast.GQLLabelName { +func (p *Parser) parseGQLLabelName() ast.GQLLabelPrimary { pos := p.Token.Pos if p.Token.Kind == "%" { p.nextToken() - return &ast.GQLLabelName{ - StartPos: pos, - IsPercent: true, + return &ast.GQLWildcardLabel{ + Percent: pos, } } ident := p.parseIdent() - return &ast.GQLLabelName{ - StartPos: pos, + return &ast.GQLElementLabel{ LabelName: ident, } } diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index 26319e7c..f995c630 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -36,8 +36,7 @@ RETURN p.name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, @@ -60,8 +59,7 @@ RETURN p.name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 34, - LabelExpression: &ast.GQLLabelName{ - StartPos: 35, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 35, NameEnd: 39, @@ -84,8 +82,7 @@ RETURN p.name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GQLLabelName{ - StartPos: 45, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 45, NameEnd: 52, diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index 4033ce3e..36b0cc86 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -36,8 +36,7 @@ RETURN p.name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, @@ -60,8 +59,7 @@ RETURN p.name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 34, - LabelExpression: &ast.GQLLabelName{ - StartPos: 35, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 35, NameEnd: 39, @@ -84,8 +82,7 @@ RETURN p.name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GQLLabelName{ - StartPos: 45, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 45, NameEnd: 52, diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index 4e8db909..de021aaa 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -38,8 +38,7 @@ ORDER BY p.name, element, offset }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, @@ -62,8 +61,7 @@ ORDER BY p.name, element, offset }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 34, - LabelExpression: &ast.GQLLabelName{ - StartPos: 35, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 35, NameEnd: 39, @@ -86,8 +84,7 @@ ORDER BY p.name, element, offset }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GQLLabelName{ - StartPos: 45, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 45, NameEnd: 52, diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index c3ae84bf..542a71aa 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -36,8 +36,7 @@ RETURN p.name, element, off }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index d2bf3129..8da5908f 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -38,8 +38,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GQLLabelName{ - StartPos: 26, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 26, NameEnd: 32, @@ -81,8 +80,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GQLLabelName{ - StartPos: 45, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 45, NameEnd: 49, @@ -133,8 +131,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 86, - LabelExpression: &ast.GQLLabelName{ - StartPos: 87, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 87, NameEnd: 94, @@ -157,8 +154,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 98, - LabelExpression: &ast.GQLLabelName{ - StartPos: 99, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 99, NameEnd: 108, @@ -181,8 +177,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 114, - LabelExpression: &ast.GQLLabelName{ - StartPos: 115, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 115, NameEnd: 122, diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index 2c26cba8..a4d50e39 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -36,8 +36,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, @@ -74,8 +73,7 @@ RETURN oa.id PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 41, - LabelExpression: &ast.GQLLabelName{ - StartPos: 42, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 42, NameEnd: 46, @@ -98,8 +96,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 51, - LabelExpression: &ast.GQLLabelName{ - StartPos: 52, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 52, NameEnd: 59, @@ -158,8 +155,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 94, - LabelExpression: &ast.GQLLabelName{ - StartPos: 95, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 95, NameEnd: 102, @@ -182,8 +178,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 106, - LabelExpression: &ast.GQLLabelName{ - StartPos: 107, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 107, NameEnd: 116, @@ -206,8 +201,7 @@ RETURN oa.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 122, - LabelExpression: &ast.GQLLabelName{ - StartPos: 123, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 123, NameEnd: 130, diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index 3729cb29..1d5f7f0c 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -38,8 +38,7 @@ RETURN c.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GQLLabelName{ - StartPos: 26, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 26, NameEnd: 32, @@ -76,8 +75,7 @@ RETURN c.id PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 43, - LabelExpression: &ast.GQLLabelName{ - StartPos: 44, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 44, NameEnd: 48, @@ -100,8 +98,7 @@ RETURN c.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 53, - LabelExpression: &ast.GQLLabelName{ - StartPos: 54, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 54, NameEnd: 61, @@ -168,8 +165,7 @@ RETURN c.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 183, - LabelExpression: &ast.GQLLabelName{ - StartPos: 184, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 184, NameEnd: 191, @@ -192,8 +188,7 @@ RETURN c.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 195, - LabelExpression: &ast.GQLLabelName{ - StartPos: 196, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 196, NameEnd: 205, @@ -216,8 +211,7 @@ RETURN c.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 210, - LabelExpression: &ast.GQLLabelName{ - StartPos: 211, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 211, NameEnd: 218, diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index c68859ef..8522969a 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -36,8 +36,7 @@ RETURN a.id AS a_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 28, - LabelExpression: &ast.GQLLabelName{ - StartPos: 29, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 29, NameEnd: 36, @@ -60,8 +59,7 @@ RETURN a.id AS a_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 40, - LabelExpression: &ast.GQLLabelName{ - StartPos: 41, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 41, NameEnd: 50, @@ -84,8 +82,7 @@ RETURN a.id AS a_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GQLLabelName{ - StartPos: 66, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 66, NameEnd: 73, diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index 4c7952b3..bb973d72 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -37,8 +37,7 @@ RETURN source.nick_name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 28, - LabelExpression: &ast.GQLLabelName{ - StartPos: 29, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 29, NameEnd: 36, @@ -61,8 +60,7 @@ RETURN source.nick_name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 40, - LabelExpression: &ast.GQLLabelName{ - StartPos: 41, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 41, NameEnd: 50, @@ -85,8 +83,7 @@ RETURN source.nick_name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GQLLabelName{ - StartPos: 66, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 66, NameEnd: 73, diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt index 92f01c06..bc3a9966 100644 --- a/testdata/result/gql/match.sql.txt +++ b/testdata/result/gql/match.sql.txt @@ -35,8 +35,7 @@ RETURN p.name, p.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index a74a9209..fea7ec00 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -42,8 +42,7 @@ RETURN a.id AS a_id, total, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 36, - LabelExpression: &ast.GQLLabelName{ - StartPos: 37, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 37, NameEnd: 44, @@ -66,8 +65,7 @@ RETURN a.id AS a_id, total, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 48, - LabelExpression: &ast.GQLLabelName{ - StartPos: 49, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 49, NameEnd: 58, @@ -106,8 +104,7 @@ RETURN a.id AS a_id, total, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 70, - LabelExpression: &ast.GQLLabelName{ - StartPos: 71, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 71, NameEnd: 78, diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index ef4bbf94..65922688 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -36,8 +36,7 @@ RETURN n.name, a.id AS blocked_account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, @@ -74,8 +73,7 @@ RETURN n.name, a.id AS blocked_account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 49, - LabelExpression: &ast.GQLLabelName{ - StartPos: 50, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 50, NameEnd: 56, @@ -93,8 +91,7 @@ RETURN n.name, a.id AS blocked_account_id PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 59, - LabelExpression: &ast.GQLLabelName{ - StartPos: 60, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 60, NameEnd: 64, @@ -117,8 +114,7 @@ RETURN n.name, a.id AS blocked_account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 69, - LabelExpression: &ast.GQLLabelName{ - StartPos: 70, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 70, NameEnd: 77, diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt index 757b7dc1..e89561ae 100644 --- a/testdata/result/gql/match_or_expression.sql.txt +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -36,16 +36,14 @@ RETURN n.id, n.name, n.nick_name IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GQLLabelOrExpression{ - Left: &ast.GQLLabelName{ - StartPos: 24, + Left: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, Name: "Person", }, }, - Right: &ast.GQLLabelName{ - StartPos: 31, + Right: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 31, NameEnd: 38, diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index 3ce44a9b..d1ce4055 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -51,8 +51,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GQLLabelName{ - StartPos: 34, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 34, NameEnd: 41, @@ -75,8 +74,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GQLLabelName{ - StartPos: 47, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 47, NameEnd: 56, @@ -109,8 +107,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GQLLabelName{ - StartPos: 66, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 66, NameEnd: 73, @@ -137,8 +134,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 82, - LabelExpression: &ast.GQLLabelName{ - StartPos: 83, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 83, NameEnd: 92, @@ -161,8 +157,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 98, - LabelExpression: &ast.GQLLabelName{ - StartPos: 99, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 99, NameEnd: 106, diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 9c495d36..c082e858 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -57,8 +57,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 36, - LabelExpression: &ast.GQLLabelName{ - StartPos: 37, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 37, NameEnd: 44, @@ -81,8 +80,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 49, - LabelExpression: &ast.GQLLabelName{ - StartPos: 50, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 50, NameEnd: 59, @@ -115,8 +113,7 @@ RETURN COUNT(1) as num_paths }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 68, - LabelExpression: &ast.GQLLabelName{ - StartPos: 69, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 69, NameEnd: 76, diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index 62092e4e..5ad8ec71 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -36,8 +36,7 @@ RETURN a.id AS a_id, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 31, @@ -60,8 +59,7 @@ RETURN a.id AS a_id, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 42, - LabelExpression: &ast.GQLLabelName{ - StartPos: 43, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 43, NameEnd: 52, @@ -84,8 +82,7 @@ RETURN a.id AS a_id, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 56, - LabelExpression: &ast.GQLLabelName{ - StartPos: 57, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 57, NameEnd: 64, diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index 15f10ead..9d181a44 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -36,8 +36,7 @@ RETURN a.id AS a_id, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 31, @@ -60,8 +59,7 @@ RETURN a.id AS a_id, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 42, - LabelExpression: &ast.GQLLabelName{ - StartPos: 43, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 43, NameEnd: 52, @@ -84,8 +82,7 @@ RETURN a.id AS a_id, b.id AS b_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 56, - LabelExpression: &ast.GQLLabelName{ - StartPos: 57, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 57, NameEnd: 64, diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index 2ed2f00c..0eb70a6b 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -36,8 +36,7 @@ RETURN src.id AS source_id, dest.id AS destination_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GQLLabelName{ - StartPos: 26, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 26, NameEnd: 33, @@ -60,8 +59,7 @@ RETURN src.id AS source_id, dest.id AS destination_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 45, - LabelExpression: &ast.GQLLabelName{ - StartPos: 46, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 46, NameEnd: 55, @@ -84,8 +82,7 @@ RETURN src.id AS source_id, dest.id AS destination_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 62, - LabelExpression: &ast.GQLLabelName{ - StartPos: 63, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 63, NameEnd: 70, diff --git a/testdata/result/gql/match_where_property_exists_return.sql.txt b/testdata/result/gql/match_where_property_exists_return.sql.txt index 2a4f0d81..fb40144f 100644 --- a/testdata/result/gql/match_where_property_exists_return.sql.txt +++ b/testdata/result/gql/match_where_property_exists_return.sql.txt @@ -36,16 +36,14 @@ RETURN n.name IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, LabelExpression: &ast.GQLLabelOrExpression{ - Left: &ast.GQLLabelName{ - StartPos: 24, + Left: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, Name: "Person", }, }, - Right: &ast.GQLLabelName{ - StartPos: 31, + Right: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 31, NameEnd: 38, diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 03b688ea..24f8a8ef 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -45,8 +45,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GQLLabelName{ - StartPos: 23, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 23, NameEnd: 30, @@ -64,8 +63,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GQLLabelName{ - StartPos: 34, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 34, NameEnd: 43, @@ -88,8 +86,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GQLLabelName{ - StartPos: 55, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 55, NameEnd: 62, @@ -170,8 +167,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 153, - LabelExpression: &ast.GQLLabelName{ - StartPos: 154, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 154, NameEnd: 161, @@ -189,8 +185,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 165, - LabelExpression: &ast.GQLLabelName{ - StartPos: 166, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 166, NameEnd: 170, @@ -213,8 +208,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 178, - LabelExpression: &ast.GQLLabelName{ - StartPos: 179, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 179, NameEnd: 185, diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 63ed1359..963ad0f1 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -38,8 +38,7 @@ RETURN PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GQLLabelName{ - StartPos: 23, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 23, NameEnd: 30, @@ -57,8 +56,7 @@ RETURN PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GQLLabelName{ - StartPos: 34, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 34, NameEnd: 43, @@ -81,8 +79,7 @@ RETURN }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GQLLabelName{ - StartPos: 55, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 55, NameEnd: 62, @@ -163,8 +160,7 @@ RETURN }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 153, - LabelExpression: &ast.GQLLabelName{ - StartPos: 154, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 154, NameEnd: 161, @@ -182,8 +178,7 @@ RETURN PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 165, - LabelExpression: &ast.GQLLabelName{ - StartPos: 166, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 166, NameEnd: 170, @@ -206,8 +201,7 @@ RETURN }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 178, - LabelExpression: &ast.GQLLabelName{ - StartPos: 179, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 179, NameEnd: 185, diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt index 42ce1838..1933ca48 100644 --- a/testdata/result/gql/offset_1.sql.txt +++ b/testdata/result/gql/offset_1.sql.txt @@ -36,8 +36,7 @@ RETURN p.name, p.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index 14b6607e..f019b8f1 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -37,8 +37,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GQLLabelName{ - StartPos: 34, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 34, NameEnd: 41, @@ -61,8 +60,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 52, - LabelExpression: &ast.GQLLabelName{ - StartPos: 53, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 53, NameEnd: 62, @@ -85,8 +83,7 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 77, - LabelExpression: &ast.GQLLabelName{ - StartPos: 78, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 78, NameEnd: 85, diff --git a/testdata/result/gql/order_by_collate.sql.txt b/testdata/result/gql/order_by_collate.sql.txt index 755f16aa..975c140b 100644 --- a/testdata/result/gql/order_by_collate.sql.txt +++ b/testdata/result/gql/order_by_collate.sql.txt @@ -33,8 +33,7 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index 3eab6e41..ee6973bb 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -37,8 +37,7 @@ ORDER BY num_incoming_transfers DESC PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GQLLabelName{ - StartPos: 23, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 23, NameEnd: 30, @@ -56,8 +55,7 @@ ORDER BY num_incoming_transfers DESC PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GQLLabelName{ - StartPos: 34, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 34, NameEnd: 43, @@ -80,8 +78,7 @@ ORDER BY num_incoming_transfers DESC }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GQLLabelName{ - StartPos: 55, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 55, NameEnd: 62, @@ -162,8 +159,7 @@ ORDER BY num_incoming_transfers DESC }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 153, - LabelExpression: &ast.GQLLabelName{ - StartPos: 154, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 154, NameEnd: 161, @@ -181,8 +177,7 @@ ORDER BY num_incoming_transfers DESC PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 165, - LabelExpression: &ast.GQLLabelName{ - StartPos: 166, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 166, NameEnd: 170, @@ -205,8 +200,7 @@ ORDER BY num_incoming_transfers DESC }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 178, - LabelExpression: &ast.GQLLabelName{ - StartPos: 179, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 179, NameEnd: 185, diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index bce532d1..bea045f6 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -41,8 +41,7 @@ RETURN }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, @@ -60,8 +59,7 @@ RETURN PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GQLLabelName{ - StartPos: 34, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 34, NameEnd: 38, @@ -84,8 +82,7 @@ RETURN }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 49, - LabelExpression: &ast.GQLLabelName{ - StartPos: 50, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 50, NameEnd: 57, @@ -179,8 +176,7 @@ RETURN }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 121, - LabelExpression: &ast.GQLLabelName{ - StartPos: 122, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 122, NameEnd: 129, @@ -203,8 +199,7 @@ RETURN }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 140, - LabelExpression: &ast.GQLLabelName{ - StartPos: 141, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 141, NameEnd: 150, @@ -222,8 +217,7 @@ RETURN PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 154, - LabelExpression: &ast.GQLLabelName{ - StartPos: 155, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 155, NameEnd: 162, diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index d6de1033..044fffc2 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -35,8 +35,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 25, - LabelExpression: &ast.GQLLabelName{ - StartPos: 26, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 26, NameEnd: 33, @@ -78,8 +77,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 45, - LabelExpression: &ast.GQLLabelName{ - StartPos: 46, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 46, NameEnd: 55, @@ -118,8 +116,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 68, - LabelExpression: &ast.GQLLabelName{ - StartPos: 69, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 69, NameEnd: 76, diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index 0fe04946..062851fe 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -41,8 +41,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 35, - LabelExpression: &ast.GQLLabelName{ - StartPos: 36, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 36, NameEnd: 42, @@ -65,8 +64,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GQLLabelName{ - StartPos: 47, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 47, NameEnd: 51, @@ -89,8 +87,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 56, - LabelExpression: &ast.GQLLabelName{ - StartPos: 57, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 57, NameEnd: 64, diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index cf6c8cb6..96dfc963 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -45,8 +45,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 41, - LabelExpression: &ast.GQLLabelName{ - StartPos: 42, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 42, NameEnd: 48, @@ -69,8 +68,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 52, - LabelExpression: &ast.GQLLabelName{ - StartPos: 53, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 53, NameEnd: 57, @@ -93,8 +91,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 62, - LabelExpression: &ast.GQLLabelName{ - StartPos: 63, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 63, NameEnd: 70, diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index e48e72fe..cae25950 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -52,8 +52,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 41, - LabelExpression: &ast.GQLLabelName{ - StartPos: 42, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 42, NameEnd: 48, @@ -76,8 +75,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 52, - LabelExpression: &ast.GQLLabelName{ - StartPos: 53, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 53, NameEnd: 57, @@ -100,8 +98,7 @@ RETURN EXISTS { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 62, - LabelExpression: &ast.GQLLabelName{ - StartPos: 63, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 63, NameEnd: 70, diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index c62281ce..590cf5bd 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -56,8 +56,7 @@ RETURN 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 44, - LabelExpression: &ast.GQLLabelName{ - StartPos: 45, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 45, NameEnd: 51, @@ -80,8 +79,7 @@ RETURN 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 55, - LabelExpression: &ast.GQLLabelName{ - StartPos: 56, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 56, NameEnd: 60, @@ -104,8 +102,7 @@ RETURN 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 65, - LabelExpression: &ast.GQLLabelName{ - StartPos: 66, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 66, NameEnd: 73, diff --git a/testdata/result/gql/return_offset_limit.sql.txt b/testdata/result/gql/return_offset_limit.sql.txt index 32d5ccc6..9ab34fd9 100644 --- a/testdata/result/gql/return_offset_limit.sql.txt +++ b/testdata/result/gql/return_offset_limit.sql.txt @@ -37,8 +37,7 @@ LIMIT 1 }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, diff --git a/testdata/result/gql/return_value_subquery.sql.txt b/testdata/result/gql/return_value_subquery.sql.txt index fd45c449..4eb38dd3 100644 --- a/testdata/result/gql/return_value_subquery.sql.txt +++ b/testdata/result/gql/return_value_subquery.sql.txt @@ -52,8 +52,7 @@ RETURN VALUE { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 40, - LabelExpression: &ast.GQLLabelName{ - StartPos: 41, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 41, NameEnd: 47, diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt index 161f2dde..38479b7b 100644 --- a/testdata/result/gql/skip_1.sql.txt +++ b/testdata/result/gql/skip_1.sql.txt @@ -36,8 +36,7 @@ RETURN p.name, p.id }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 23, - LabelExpression: &ast.GQLLabelName{ - StartPos: 24, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 24, NameEnd: 30, diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index 09c983c6..cedc43bb 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -31,8 +31,7 @@ RETURN account.id AS account_id, num_incoming_transfers PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, - LabelExpression: &ast.GQLLabelName{ - StartPos: 23, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 23, NameEnd: 30, @@ -50,8 +49,7 @@ RETURN account.id AS account_id, num_incoming_transfers PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, - LabelExpression: &ast.GQLLabelName{ - StartPos: 34, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 34, NameEnd: 43, @@ -74,8 +72,7 @@ RETURN account.id AS account_id, num_incoming_transfers }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 54, - LabelExpression: &ast.GQLLabelName{ - StartPos: 55, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 55, NameEnd: 62, diff --git a/testdata/result/gql_path_pattern/pattern_1.sql.txt b/testdata/result/gql_path_pattern/pattern_1.sql.txt index 0471961c..86b457fa 100644 --- a/testdata/result/gql_path_pattern/pattern_1.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_1.sql.txt @@ -14,9 +14,8 @@ }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 2, - LabelExpression: &ast.GQLLabelName{ - StartPos: 3, - IsPercent: true, + LabelExpression: &ast.GQLWildcardLabel{ + Percent: 3, }, }, }, diff --git a/testdata/result/gql_path_pattern/pattern_2.sql.txt b/testdata/result/gql_path_pattern/pattern_2.sql.txt index 13ecf701..2bc34d53 100644 --- a/testdata/result/gql_path_pattern/pattern_2.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_2.sql.txt @@ -18,8 +18,7 @@ LParen: 3, RParen: 30, LabelExpr: &ast.GQLLabelOrExpression{ - Left: &ast.GQLLabelName{ - StartPos: 4, + Left: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 4, NameEnd: 10, @@ -32,8 +31,7 @@ LabelExpr: &ast.GQLLabelNotExpression{ Not: 12, LabelExpression: &ast.GQLLabelAndExpression{ - Left: &ast.GQLLabelName{ - StartPos: 13, + Left: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 13, NameEnd: 19, @@ -42,8 +40,7 @@ }, Right: &ast.GQLLabelNotExpression{ Not: 20, - LabelExpression: &ast.GQLLabelName{ - StartPos: 21, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 21, NameEnd: 29, diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index 7cdc67cd..f057db61 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -51,8 +51,7 @@ SELECT 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GQLLabelName{ - StartPos: 47, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 47, NameEnd: 53, @@ -75,8 +74,7 @@ SELECT 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 57, - LabelExpression: &ast.GQLLabelName{ - StartPos: 58, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 58, NameEnd: 62, @@ -99,8 +97,7 @@ SELECT 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 67, - LabelExpression: &ast.GQLLabelName{ - StartPos: 68, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 68, NameEnd: 75, diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index 7cdc67cd..f057db61 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -51,8 +51,7 @@ SELECT 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 46, - LabelExpression: &ast.GQLLabelName{ - StartPos: 47, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 47, NameEnd: 53, @@ -75,8 +74,7 @@ SELECT 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 57, - LabelExpression: &ast.GQLLabelName{ - StartPos: 58, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 58, NameEnd: 62, @@ -99,8 +97,7 @@ SELECT 'Dana' IN { }, IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 67, - LabelExpression: &ast.GQLLabelName{ - StartPos: 68, + LabelExpression: &ast.GQLElementLabel{ LabelName: &ast.Ident{ NamePos: 68, NameEnd: 75, From 17a494859d9383f23fc701117577d794e2aec6e4 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 15 Jan 2025 00:29:55 +0900 Subject: [PATCH 49/53] Fix code style --- ast/ast.go | 56 +++++----- ast/pos.go | 34 +++--- parser.go | 102 +++++++++--------- testdata/result/gql/filter.sql.txt | 8 +- testdata/result/gql/filter_where.sql.txt | 8 +- testdata/result/gql/for_with_offset.sql.txt | 8 +- .../result/gql/for_with_offset_as.sql.txt | 4 +- .../result/gql/graph_hints_between.sql.txt | 20 ++-- testdata/result/gql/graph_hints_match.sql.txt | 20 ++-- .../gql/graph_hints_traversal_hint.sql.txt | 20 ++-- testdata/result/gql/let.sql.txt | 8 +- testdata/result/gql/limit.sql.txt | 8 +- testdata/result/gql/match.sql.txt | 4 +- .../result/gql/match_any_shortest.sql.txt | 12 +-- .../match_any_shortest_subpath_trail.sql.txt | 8 +- testdata/result/gql/match_optional.sql.txt | 16 +-- .../result/gql/match_or_expression.sql.txt | 4 +- .../result/gql/match_subpath_trail.sql.txt | 20 ++-- .../gql/match_trail_subpath_walk.sql.txt | 16 +-- ...tch_where_is_destination_of_return.sql.txt | 8 +- .../match_where_is_source_of_return.sql.txt | 8 +- .../gql/match_where_not_same_return.sql.txt | 8 +- ...match_where_property_exists_return.sql.txt | 4 +- testdata/result/gql/next.sql.txt | 16 +-- testdata/result/gql/next_1.sql.txt | 16 +-- testdata/result/gql/offset_1.sql.txt | 4 +- testdata/result/gql/order_by.sql.txt | 8 +- testdata/result/gql/order_by_collate.sql.txt | 4 +- testdata/result/gql/return.sql.txt | 16 +-- .../result/gql/return_array_subquery.sql.txt | 18 ++-- testdata/result/gql/return_distinct.sql.txt | 16 +-- .../gql/return_exists_graph_pattern.sql.txt | 10 +- .../result/gql/return_exists_match.sql.txt | 10 +- .../gql/return_exists_query_expr.sql.txt | 10 +- .../result/gql/return_in_gql_subquery.sql.txt | 12 +-- .../result/gql/return_offset_limit.sql.txt | 4 +- .../result/gql/return_value_subquery.sql.txt | 6 +- testdata/result/gql/skip_1.sql.txt | 4 +- testdata/result/gql/with_1.sql.txt | 8 +- .../node_pattern_unnamed.sql.txt | 4 +- .../result/gql_path_pattern/pattern_1.sql.txt | 2 +- .../result/gql_path_pattern/pattern_2.sql.txt | 10 +- .../query/select_in_gql_subquery.sql.txt | 12 +-- .../statement/select_in_gql_subquery.sql.txt | 12 +-- 44 files changed, 301 insertions(+), 305 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index deac47f4..6383468c 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -1352,10 +1352,10 @@ type ValuesInCondition struct { // // {{"{"}}{{.Query | sql}}}{{"}"}} type GQLSubQueryInCondition struct { - // pos = LBrace - // end = RBrace + 1 + // pos = Lbrace + // end = Rbrace + 1 - LBrace, RBrace token.Pos // position of "{" and "}" + Lbrace, Rbrace token.Pos // position of "{" and "}" Query *GQLQueryExpr } @@ -1844,10 +1844,10 @@ type ArraySubQuery struct { // ARRAY {{"{"}}{{.Query | sql}}{{"}"}} type ArrayGQLSubQuery struct { // pos = Array - // end = RBrace + 1 + // end = Rbrace + 1 Array token.Pos // position of "ARRAY" keyword - RBrace token.Pos // position of "}" + Rbrace token.Pos // position of "}" Query *GQLQueryExpr } @@ -1856,10 +1856,10 @@ type ArrayGQLSubQuery struct { // VALUE {{"{"}}{{.Query | sql}}{{"}"}} type ValueGQLSubQuery struct { // pos = Array - // end = RBrace + 1 + // end = Rbrace + 1 Array token.Pos // position of "ARRAY" keyword - RBrace token.Pos // position of "}" + Rbrace token.Pos // position of "}" Query *GQLQueryExpr } @@ -1868,10 +1868,10 @@ type ValueGQLSubQuery struct { // EXISTS{{"{"}}{{.Expr | sql}}{{"}"}} type ExistsGQLSubQuery struct { // pos = Exists - // end = RBrace + 1 + // end = Rbrace + 1 Exists token.Pos // position of "EXISTS" keyword - RBrace token.Pos // "}" + Rbrace token.Pos // "}" Query GQLExistsExpr } @@ -4735,10 +4735,10 @@ func (GQLBoundedQuantifier) isGQLQuantifier() {} // // {{"{"}}{{.Bound | sql}}{{"}"}} type GQLFixedQuantifier struct { - // pos = LBrace - // end = RBrace + 1 + // pos = Lbrace + // end = Rbrace + 1 - LBrace, RBrace token.Pos + Lbrace, Rbrace token.Pos Bound IntValue } @@ -4746,10 +4746,10 @@ type GQLFixedQuantifier struct { // // {{"{"}}{{.LowerBound | sqlOpt}}, {{.UpperBound | sql}}{{"}"}} type GQLBoundedQuantifier struct { - // pos = LBrace - // end = RBrace + 1 + // pos = Lbrace + // end = Rbrace + 1 - LBrace, RBrace token.Pos + Lbrace, Rbrace token.Pos LowerBound IntValue // optional UpperBound IntValue } @@ -4758,10 +4758,10 @@ type GQLBoundedQuantifier struct { // // ({{.PathMode | sqlOpt}} {{.PathPattern | sql}} {{.WhereClause | sqlOpt}}) type GQLSubpathPattern struct { - // pos = LParen - // end = RParen + 1 + // pos = Lparen + // end = Rparen + 1 - LParen, RParen token.Pos // position of "(" and ")" + Lparen, Rparen token.Pos // position of "(" and ")" PathMode *GQLPathMode // optional PathPattern *GQLPathPattern WhereClause *Where // optional @@ -4771,10 +4771,10 @@ type GQLSubpathPattern struct { // // ({{.PatternFiller | sql}}) type GQLNodePattern struct { - // pos = LParen - // end = RParen + 1 + // pos = Lparen + // end = Rparen + 1 - LParen, RParen token.Pos + Lparen, Rparen token.Pos PatternFiller *GQLPatternFiller } @@ -4837,10 +4837,10 @@ type GQLLabelOrExpression struct { // // ({{.LabelExpr | sql}}) type GQLLabelParenExpression struct { - // pos = LParen - // end = RParen + 1 + // pos = Lparen + // end = Rparen + 1 - LParen, RParen token.Pos + Lparen, Rparen token.Pos LabelExpr GQLLabelExpression } @@ -4907,12 +4907,12 @@ func (Where) isGQLPatternFillerFilter() {} // // {{"{"}}{{.PropertyFilterElemList | sqlJoin ", "}}{{"}"}} type GQLPropertyFilters struct { - // pos = LBrace - // end = RBrace + 1 + // pos = Lbrace + // end = Rbrace + 1 - LBrace token.Pos // position of "{" + Lbrace token.Pos // position of "{" PropertyFilterElemList []*GQLElementProperty - RBrace token.Pos // position of "}" + Rbrace token.Pos // position of "}" } // GQLElementProperty represents an element of GQLPropertyFilters. diff --git a/ast/pos.go b/ast/pos.go index 4f879cf3..7481ef69 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -463,11 +463,11 @@ func (v *ValuesInCondition) End() token.Pos { } func (g *GQLSubQueryInCondition) Pos() token.Pos { - return g.LBrace + return g.Lbrace } func (g *GQLSubQueryInCondition) End() token.Pos { - return posAdd(g.RBrace, 1) + return posAdd(g.Rbrace, 1) } func (i *IsNullExpr) Pos() token.Pos { @@ -763,7 +763,7 @@ func (a *ArrayGQLSubQuery) Pos() token.Pos { } func (a *ArrayGQLSubQuery) End() token.Pos { - return posAdd(a.RBrace, 1) + return posAdd(a.Rbrace, 1) } func (v *ValueGQLSubQuery) Pos() token.Pos { @@ -771,7 +771,7 @@ func (v *ValueGQLSubQuery) Pos() token.Pos { } func (v *ValueGQLSubQuery) End() token.Pos { - return posAdd(v.RBrace, 1) + return posAdd(v.Rbrace, 1) } func (e *ExistsGQLSubQuery) Pos() token.Pos { @@ -779,7 +779,7 @@ func (e *ExistsGQLSubQuery) Pos() token.Pos { } func (e *ExistsGQLSubQuery) End() token.Pos { - return posAdd(e.RBrace, 1) + return posAdd(e.Rbrace, 1) } func (e *ExistsSubQuery) Pos() token.Pos { @@ -2407,35 +2407,35 @@ func (g *GQLPathMode) End() token.Pos { } func (g *GQLFixedQuantifier) Pos() token.Pos { - return g.LBrace + return g.Lbrace } func (g *GQLFixedQuantifier) End() token.Pos { - return posAdd(g.RBrace, 1) + return posAdd(g.Rbrace, 1) } func (g *GQLBoundedQuantifier) Pos() token.Pos { - return g.LBrace + return g.Lbrace } func (g *GQLBoundedQuantifier) End() token.Pos { - return posAdd(g.RBrace, 1) + return posAdd(g.Rbrace, 1) } func (g *GQLSubpathPattern) Pos() token.Pos { - return g.LParen + return g.Lparen } func (g *GQLSubpathPattern) End() token.Pos { - return posAdd(g.RParen, 1) + return posAdd(g.Rparen, 1) } func (g *GQLNodePattern) Pos() token.Pos { - return g.LParen + return g.Lparen } func (g *GQLNodePattern) End() token.Pos { - return posAdd(g.RParen, 1) + return posAdd(g.Rparen, 1) } func (g *GQLPatternFiller) Pos() token.Pos { @@ -2463,11 +2463,11 @@ func (g *GQLLabelOrExpression) End() token.Pos { } func (g *GQLLabelParenExpression) Pos() token.Pos { - return g.LParen + return g.Lparen } func (g *GQLLabelParenExpression) End() token.Pos { - return posAdd(g.RParen, 1) + return posAdd(g.Rparen, 1) } func (g *GQLLabelAndExpression) Pos() token.Pos { @@ -2503,11 +2503,11 @@ func (g *GQLElementLabel) End() token.Pos { } func (g *GQLPropertyFilters) Pos() token.Pos { - return g.LBrace + return g.Lbrace } func (g *GQLPropertyFilters) End() token.Pos { - return posAdd(g.RBrace, 1) + return posAdd(g.Rbrace, 1) } func (g *GQLElementProperty) Pos() token.Pos { diff --git a/parser.go b/parser.go index 45088740..13a7deb5 100644 --- a/parser.go +++ b/parser.go @@ -1869,7 +1869,7 @@ func (p *Parser) parseLit() ast.Expr { rbrace := p.expect("}").Pos return &ast.ValueGQLSubQuery{ Array: id.Pos, - RBrace: rbrace, + Rbrace: rbrace, Query: query, } } @@ -2343,7 +2343,7 @@ func (p *Parser) parseExistsSubQuery() ast.Expr { rbrace := p.expect("}").Pos return &ast.ExistsGQLSubQuery{ Exists: exists, - RBrace: rbrace, + Rbrace: rbrace, Query: expr, } } @@ -2498,7 +2498,7 @@ func (p *Parser) parseArrayLiteralOrSubQuery() ast.Expr { rbrace := p.expect("}").Pos return &ast.ArrayGQLSubQuery{ Array: pos, - RBrace: rbrace, + Rbrace: rbrace, Query: query, } } @@ -5612,7 +5612,7 @@ func (p *Parser) parseGQLSubQueryInCondition() *ast.GQLSubQueryInCondition { query := p.parseGQLQueryExpr() rbrace := p.expect("}").Pos - return &ast.GQLSubQueryInCondition{LBrace: lbrace, RBrace: rbrace, Query: query} + return &ast.GQLSubQueryInCondition{Lbrace: lbrace, Rbrace: rbrace, Query: query} } func (p *Parser) parseGQLQueryExpr() *ast.GQLQueryExpr { var graphClause *ast.GQLGraphClause @@ -5982,7 +5982,7 @@ func (p *Parser) parseGQLMatchStatement() *ast.GQLMatchStatement { } } -func (p *Parser) parseGQLLabelName() ast.GQLLabelPrimary { +func (p *Parser) parseGQLLabelPrimary() ast.GQLLabelPrimary { pos := p.Token.Pos if p.Token.Kind == "%" { @@ -5998,61 +5998,56 @@ func (p *Parser) parseGQLLabelName() ast.GQLLabelPrimary { } } -func (p *Parser) parseGQLLabelExpression() ast.GQLLabelExpression { - // TODO - /* - label_expression: - { - label_name - | or_expression - | and_expression - | not_expression - } - */ - var labelTerm ast.GQLLabelExpression - switch { - case p.Token.Kind == "!": - notPos := p.expect("!").Pos - expr := p.parseGQLLabelExpression() - labelTerm = &ast.GQLLabelNotExpression{Not: notPos, LabelExpression: expr} - case p.Token.Kind == "(": - lparen := p.expect("(").Pos - expr := p.parseGQLLabelExpression() - rparen := p.expect(")").Pos - labelTerm = &ast.GQLLabelParenExpression{ - LParen: lparen, - RParen: rparen, - LabelExpr: expr, - } - case p.Token.Kind == token.TokenIdent || p.Token.Kind == "%": - labelTerm = p.parseGQLLabelName() - default: - p.panicfAtToken(&p.Token, `expected token: ",", "(", or "", but: %v`, p.Token.Kind) - return nil - } +func (p *Parser) parseGQLLabelExpressionBinary() ast.GQLLabelExpression { + labelTerm := p.parseLabelUnary() + switch { case p.Token.Kind == "|": p.nextToken() - right := p.parseGQLLabelExpression() + right := p.parseGQLLabelExpressionBinary() return &ast.GQLLabelOrExpression{ Left: labelTerm, Right: right, } case p.Token.Kind == "&": p.nextToken() - right := p.parseGQLLabelExpression() + right := p.parseGQLLabelExpressionBinary() return &ast.GQLLabelAndExpression{ Left: labelTerm, Right: right, } + default: + return labelTerm + } +} + +func (p *Parser) parseLabelUnary() ast.GQLLabelExpression { + switch { + case p.Token.Kind == "!": + notPos := p.expect("!").Pos + expr := p.parseGQLLabelExpressionBinary() + return &ast.GQLLabelNotExpression{Not: notPos, LabelExpression: expr} + case p.Token.Kind == "(": + lparen := p.expect("(").Pos + expr := p.parseGQLLabelExpressionBinary() + rparen := p.expect(")").Pos + return &ast.GQLLabelParenExpression{ + Lparen: lparen, + Rparen: rparen, + LabelExpr: expr, + } + case p.Token.Kind == token.TokenIdent || p.Token.Kind == "%": + return p.parseGQLLabelPrimary() + default: + panic(p.errorfAtToken(&p.Token, `expected token: ",", "(", or "", but: %v`, p.Token.Kind)) } - return labelTerm } + func (p *Parser) parseGQLIsLabelCondition() *ast.GQLIsLabelCondition { pos := p.Token.Pos p.nextToken() - labelExpr := p.parseGQLLabelExpression() + labelExpr := p.parseGQLLabelExpressionBinary() return &ast.GQLIsLabelCondition{ IsOrColon: pos, LabelExpression: labelExpr, @@ -6099,8 +6094,8 @@ func (p *Parser) parseGQLNodePattern() *ast.GQLNodePattern { filter := p.parseGQLPatternFiller() rparen := p.expect(")").Pos return &ast.GQLNodePattern{ - LParen: lparen, - RParen: rparen, + Lparen: lparen, + Rparen: rparen, PatternFiller: filter, } } @@ -6109,13 +6104,14 @@ func (p *Parser) tryParseGQLQuantifier() ast.GQLQuantifier { if p.Token.Kind != "{" { return nil } + lbrace := p.expect("{").Pos if p.Token.Kind == "," { upperBound := p.parseIntValue() rbrace := p.expect("}").Pos return &ast.GQLBoundedQuantifier{ - LBrace: lbrace, - RBrace: rbrace, + Lbrace: lbrace, + Rbrace: rbrace, UpperBound: upperBound, } } @@ -6123,8 +6119,8 @@ func (p *Parser) tryParseGQLQuantifier() ast.GQLQuantifier { if p.Token.Kind != "," { rbrace := p.expect("}").Pos return &ast.GQLFixedQuantifier{ - LBrace: lbrace, - RBrace: rbrace, + Lbrace: lbrace, + Rbrace: rbrace, Bound: bound, } } @@ -6133,8 +6129,8 @@ func (p *Parser) tryParseGQLQuantifier() ast.GQLQuantifier { rbrace := p.expect("}").Pos return &ast.GQLBoundedQuantifier{ - LBrace: lbrace, - RBrace: rbrace, + Lbrace: lbrace, + Rbrace: rbrace, LowerBound: bound, UpperBound: upperBound, } @@ -6184,8 +6180,8 @@ func (p *Parser) parseGQLSubPathPattern() *ast.GQLSubpathPattern { rparen := p.expect(")").Pos return &ast.GQLSubpathPattern{ - LParen: lparen, - RParen: rparen, + Lparen: lparen, + Rparen: rparen, PathMode: pathMode, PathPattern: pattern, WhereClause: where, @@ -6320,9 +6316,9 @@ func (p *Parser) parseGQLPropertyFilters() *ast.GQLPropertyFilters { rbrace := p.expect("}").Pos return &ast.GQLPropertyFilters{ - LBrace: lbrace, + Lbrace: lbrace, PropertyFilterElemList: elementPropertyList, - RBrace: rbrace, + Rbrace: rbrace, } } diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index f995c630..65b06612 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -26,8 +26,8 @@ RETURN p.name PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -72,8 +72,8 @@ RETURN p.name }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 42, - RParen: 52, + Lparen: 42, + Rparen: 52, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 43, diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index 36b0cc86..2dda7931 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -26,8 +26,8 @@ RETURN p.name PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -72,8 +72,8 @@ RETURN p.name }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 42, - RParen: 52, + Lparen: 42, + Rparen: 52, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 43, diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index de021aaa..68f2993a 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -28,8 +28,8 @@ ORDER BY p.name, element, offset PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -74,8 +74,8 @@ ORDER BY p.name, element, offset }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 42, - RParen: 52, + Lparen: 42, + Rparen: 52, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 43, diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index 542a71aa..15433491 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -26,8 +26,8 @@ RETURN p.name, element, off PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index 8da5908f..2226c36f 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -28,8 +28,8 @@ RETURN oa.id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 23, - RParen: 40, + Lparen: 23, + Rparen: 40, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 24, @@ -47,7 +47,7 @@ RETURN oa.id }, }, Filter: &ast.GQLPropertyFilters{ - LBrace: 33, + Lbrace: 33, PropertyFilterElemList: []*ast.GQLElementProperty{ &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ @@ -63,7 +63,7 @@ RETURN oa.id }, }, }, - RBrace: 39, + Rbrace: 39, }, }, }, @@ -115,14 +115,14 @@ RETURN oa.id }, }, PathTerm: &ast.GQLSubpathPattern{ - LParen: 83, - RParen: 123, + Lparen: 83, + Rparen: 123, PathPattern: &ast.GQLPathPattern{ PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 84, - RParen: 94, + Lparen: 84, + Rparen: 94, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 85, @@ -167,8 +167,8 @@ RETURN oa.id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 111, - RParen: 122, + Lparen: 111, + Rparen: 122, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 112, diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index a4d50e39..c5a89808 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -26,8 +26,8 @@ RETURN oa.id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 38, + Lparen: 21, + Rparen: 38, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -45,7 +45,7 @@ RETURN oa.id }, }, Filter: &ast.GQLPropertyFilters{ - LBrace: 31, + Lbrace: 31, PropertyFilterElemList: []*ast.GQLElementProperty{ &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ @@ -61,7 +61,7 @@ RETURN oa.id }, }, }, - RBrace: 37, + Rbrace: 37, }, }, }, @@ -86,8 +86,8 @@ RETURN oa.id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 49, - RParen: 59, + Lparen: 49, + Rparen: 59, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 50, @@ -145,8 +145,8 @@ RETURN oa.id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 92, - RParen: 102, + Lparen: 92, + Rparen: 102, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 93, @@ -191,8 +191,8 @@ RETURN oa.id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 119, - RParen: 130, + Lparen: 119, + Rparen: 130, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 120, diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index 1d5f7f0c..26f971b9 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -28,8 +28,8 @@ RETURN c.id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 23, - RParen: 40, + Lparen: 23, + Rparen: 40, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 24, @@ -47,7 +47,7 @@ RETURN c.id }, }, Filter: &ast.GQLPropertyFilters{ - LBrace: 33, + Lbrace: 33, PropertyFilterElemList: []*ast.GQLElementProperty{ &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ @@ -63,7 +63,7 @@ RETURN c.id }, }, }, - RBrace: 39, + Rbrace: 39, }, }, }, @@ -88,8 +88,8 @@ RETURN c.id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 51, - RParen: 61, + Lparen: 51, + Rparen: 61, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 52, @@ -155,8 +155,8 @@ RETURN c.id }, }, PathTerm: &ast.GQLNodePattern{ - LParen: 181, - RParen: 191, + Lparen: 181, + Rparen: 191, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 182, @@ -201,8 +201,8 @@ RETURN c.id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 208, - RParen: 218, + Lparen: 208, + Rparen: 218, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 209, diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 8522969a..35a538bf 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -26,8 +26,8 @@ RETURN a.id AS a_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 36, + Lparen: 21, + Rparen: 36, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -72,8 +72,8 @@ RETURN a.id AS a_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 53, - RParen: 73, + Lparen: 53, + Rparen: 73, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 54, diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index bb973d72..bcf9049f 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -27,8 +27,8 @@ RETURN source.nick_name PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 36, + Lparen: 21, + Rparen: 36, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -73,8 +73,8 @@ RETURN source.nick_name }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 53, - RParen: 73, + Lparen: 53, + Rparen: 73, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 54, diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt index bc3a9966..7bccc741 100644 --- a/testdata/result/gql/match.sql.txt +++ b/testdata/result/gql/match.sql.txt @@ -25,8 +25,8 @@ RETURN p.name, p.id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index fea7ec00..f2738e6e 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -32,8 +32,8 @@ RETURN a.id AS a_id, total, b.id AS b_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 34, - RParen: 44, + Lparen: 34, + Rparen: 44, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 35, @@ -76,8 +76,8 @@ RETURN a.id AS a_id, total, b.id AS b_id }, }, Quantifier: &ast.GQLBoundedQuantifier{ - LBrace: 61, - RBrace: 66, + Lbrace: 61, + Rbrace: 66, LowerBound: &ast.IntLiteral{ ValuePos: 62, ValueEnd: 63, @@ -94,8 +94,8 @@ RETURN a.id AS a_id, total, b.id AS b_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 68, - RParen: 78, + Lparen: 68, + Rparen: 78, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 69, diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt index 4e684fda..be910b7c 100644 --- a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -30,8 +30,8 @@ RETURN COUNT(1) as num_paths PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLSubpathPattern{ - LParen: 34, - RParen: 48, + Lparen: 34, + Rparen: 48, PathMode: &ast.GQLPathMode{ Mode: "TRAIL", ModeToken: &ast.Ident{ @@ -48,8 +48,8 @@ RETURN COUNT(1) as num_paths Gt: 41, }, Quantifier: &ast.GQLBoundedQuantifier{ - LBrace: 43, - RBrace: 47, + Lbrace: 43, + Rbrace: 47, LowerBound: &ast.IntLiteral{ ValuePos: 44, ValueEnd: 45, diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index 65922688..6b4dbe3a 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -26,8 +26,8 @@ RETURN n.name, a.id AS blocked_account_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -63,8 +63,8 @@ RETURN n.name, a.id AS blocked_account_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 47, - RParen: 56, + Lparen: 47, + Rparen: 56, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 48, @@ -104,8 +104,8 @@ RETURN n.name, a.id AS blocked_account_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 67, - RParen: 96, + Lparen: 67, + Rparen: 96, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 68, @@ -123,7 +123,7 @@ RETURN n.name, a.id AS blocked_account_id }, }, Filter: &ast.GQLPropertyFilters{ - LBrace: 78, + Lbrace: 78, PropertyFilterElemList: []*ast.GQLElementProperty{ &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ @@ -137,7 +137,7 @@ RETURN n.name, a.id AS blocked_account_id }, }, }, - RBrace: 95, + Rbrace: 95, }, }, }, diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt index e89561ae..9ad7823b 100644 --- a/testdata/result/gql/match_or_expression.sql.txt +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -25,8 +25,8 @@ RETURN n.id, n.name, n.nick_name PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 38, + Lparen: 21, + Rparen: 38, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index d1ce4055..7c06bd99 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -27,8 +27,8 @@ RETURN COUNT(1) as num_paths PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLSubpathPattern{ - LParen: 23, - RParen: 74, + Lparen: 23, + Rparen: 74, PathMode: &ast.GQLPathMode{ Mode: "TRAIL", ModeToken: &ast.Ident{ @@ -41,8 +41,8 @@ RETURN COUNT(1) as num_paths PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 30, - RParen: 41, + Lparen: 30, + Rparen: 41, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 31, @@ -85,8 +85,8 @@ RETURN COUNT(1) as num_paths }, }, Quantifier: &ast.GQLFixedQuantifier{ - LBrace: 59, - RBrace: 61, + Lbrace: 59, + Rbrace: 61, Bound: &ast.IntLiteral{ ValuePos: 60, ValueEnd: 61, @@ -97,8 +97,8 @@ RETURN COUNT(1) as num_paths }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 62, - RParen: 73, + Lparen: 62, + Rparen: 73, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 63, @@ -147,8 +147,8 @@ RETURN COUNT(1) as num_paths }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 95, - RParen: 106, + Lparen: 95, + Rparen: 106, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 96, diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index c082e858..47529e56 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -33,8 +33,8 @@ RETURN COUNT(1) as num_paths PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLSubpathPattern{ - LParen: 27, - RParen: 77, + Lparen: 27, + Rparen: 77, PathMode: &ast.GQLPathMode{ Mode: "WALK", ModeToken: &ast.Ident{ @@ -47,8 +47,8 @@ RETURN COUNT(1) as num_paths PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 33, - RParen: 44, + Lparen: 33, + Rparen: 44, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 34, @@ -91,8 +91,8 @@ RETURN COUNT(1) as num_paths }, }, Quantifier: &ast.GQLFixedQuantifier{ - LBrace: 62, - RBrace: 64, + Lbrace: 62, + Rbrace: 64, Bound: &ast.IntLiteral{ ValuePos: 63, ValueEnd: 64, @@ -103,8 +103,8 @@ RETURN COUNT(1) as num_paths }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 65, - RParen: 76, + Lparen: 65, + Rparen: 76, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 66, diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index 5ad8ec71..43f32b59 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -26,8 +26,8 @@ RETURN a.id AS a_id, b.id AS b_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 31, + Lparen: 21, + Rparen: 31, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -72,8 +72,8 @@ RETURN a.id AS a_id, b.id AS b_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 54, - RParen: 64, + Lparen: 54, + Rparen: 64, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 55, diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index 9d181a44..e019b121 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -26,8 +26,8 @@ RETURN a.id AS a_id, b.id AS b_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 31, + Lparen: 21, + Rparen: 31, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -72,8 +72,8 @@ RETURN a.id AS a_id, b.id AS b_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 54, - RParen: 64, + Lparen: 54, + Rparen: 64, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 55, diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index 0eb70a6b..20626540 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -26,8 +26,8 @@ RETURN src.id AS source_id, dest.id AS destination_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 33, + Lparen: 21, + Rparen: 33, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -72,8 +72,8 @@ RETURN src.id AS source_id, dest.id AS destination_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 57, - RParen: 70, + Lparen: 57, + Rparen: 70, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 58, diff --git a/testdata/result/gql/match_where_property_exists_return.sql.txt b/testdata/result/gql/match_where_property_exists_return.sql.txt index fb40144f..5cbb2214 100644 --- a/testdata/result/gql/match_where_property_exists_return.sql.txt +++ b/testdata/result/gql/match_where_property_exists_return.sql.txt @@ -25,8 +25,8 @@ RETURN n.name PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 69, + Lparen: 21, + Rparen: 69, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 24f8a8ef..51ddf369 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -40,8 +40,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, @@ -76,8 +76,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 46, - RParen: 62, + Lparen: 46, + Rparen: 62, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -157,8 +157,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 145, - RParen: 161, + Lparen: 145, + Rparen: 161, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 146, @@ -198,8 +198,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 172, - RParen: 185, + Lparen: 172, + Rparen: 185, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 173, diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 963ad0f1..05382dc9 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -33,8 +33,8 @@ RETURN PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, @@ -69,8 +69,8 @@ RETURN }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 46, - RParen: 62, + Lparen: 46, + Rparen: 62, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -150,8 +150,8 @@ RETURN PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 145, - RParen: 161, + Lparen: 145, + Rparen: 161, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 146, @@ -191,8 +191,8 @@ RETURN }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 172, - RParen: 185, + Lparen: 172, + Rparen: 185, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 173, diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt index 1933ca48..30427dab 100644 --- a/testdata/result/gql/offset_1.sql.txt +++ b/testdata/result/gql/offset_1.sql.txt @@ -26,8 +26,8 @@ RETURN p.name, p.id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index f019b8f1..07c3dd58 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -27,8 +27,8 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 41, + Lparen: 21, + Rparen: 41, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -73,8 +73,8 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 65, - RParen: 85, + Lparen: 65, + Rparen: 85, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 66, diff --git a/testdata/result/gql/order_by_collate.sql.txt b/testdata/result/gql/order_by_collate.sql.txt index 975c140b..72f06f61 100644 --- a/testdata/result/gql/order_by_collate.sql.txt +++ b/testdata/result/gql/order_by_collate.sql.txt @@ -23,8 +23,8 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index ee6973bb..99e3e553 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -32,8 +32,8 @@ ORDER BY num_incoming_transfers DESC PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, @@ -68,8 +68,8 @@ ORDER BY num_incoming_transfers DESC }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 46, - RParen: 62, + Lparen: 46, + Rparen: 62, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 47, @@ -149,8 +149,8 @@ ORDER BY num_incoming_transfers DESC PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 145, - RParen: 161, + Lparen: 145, + Rparen: 161, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 146, @@ -190,8 +190,8 @@ ORDER BY num_incoming_transfers DESC }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 172, - RParen: 185, + Lparen: 172, + Rparen: 185, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 173, diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index bea045f6..827bc2b4 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -31,8 +31,8 @@ RETURN PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -72,8 +72,8 @@ RETURN }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 41, - RParen: 57, + Lparen: 41, + Rparen: 57, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 42, @@ -150,7 +150,7 @@ RETURN Item: &ast.Alias{ Expr: &ast.ArrayGQLSubQuery{ Array: 102, - RBrace: 225, + Rbrace: 225, Query: &ast.GQLQueryExpr{ MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ LinearQueryStatementList: []ast.GQLLinearQueryStatement{ @@ -166,8 +166,8 @@ RETURN PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 119, - RParen: 129, + Lparen: 119, + Rparen: 129, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 120, @@ -212,8 +212,8 @@ RETURN }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 153, - RParen: 162, + Lparen: 153, + Rparen: 162, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 154, diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index 044fffc2..6e938220 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -25,8 +25,8 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 41, + Lparen: 21, + Rparen: 41, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, @@ -44,7 +44,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, }, Filter: &ast.GQLPropertyFilters{ - LBrace: 34, + Lbrace: 34, PropertyFilterElemList: []*ast.GQLElementProperty{ &ast.GQLElementProperty{ ElementPropertyName: &ast.Ident{ @@ -60,7 +60,7 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, }, }, - RBrace: 40, + Rbrace: 40, }, }, }, @@ -88,8 +88,8 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, }, Quantifier: &ast.GQLBoundedQuantifier{ - LBrace: 58, - RBrace: 63, + Lbrace: 58, + Rbrace: 63, LowerBound: &ast.IntLiteral{ ValuePos: 59, ValueEnd: 60, @@ -106,8 +106,8 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 64, - RParen: 76, + Lparen: 64, + Rparen: 76, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 65, diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index 062851fe..19d4bb09 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -23,7 +23,7 @@ RETURN EXISTS { Item: &ast.Alias{ Expr: &ast.ExistsGQLSubQuery{ Exists: 22, - RBrace: 89, + Rbrace: 89, Query: &ast.GQLGraphPattern{ PathPatternList: []*ast.GQLTopLevelPathPattern{ &ast.GQLTopLevelPathPattern{ @@ -31,8 +31,8 @@ RETURN EXISTS { PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 33, - RParen: 42, + Lparen: 33, + Rparen: 42, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 34, @@ -77,8 +77,8 @@ RETURN EXISTS { }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 54, - RParen: 64, + Lparen: 54, + Rparen: 64, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 55, diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index 96dfc963..6ae3a79a 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -24,7 +24,7 @@ RETURN EXISTS { Item: &ast.Alias{ Expr: &ast.ExistsGQLSubQuery{ Exists: 22, - RBrace: 97, + Rbrace: 97, Query: &ast.GQLMatchStatement{ Optional: -1, Match: 33, @@ -35,8 +35,8 @@ RETURN EXISTS { PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 39, - RParen: 48, + Lparen: 39, + Rparen: 48, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 40, @@ -81,8 +81,8 @@ RETURN EXISTS { }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 60, - RParen: 70, + Lparen: 60, + Rparen: 70, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 61, diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index cae25950..e33f053f 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -26,7 +26,7 @@ RETURN EXISTS { Item: &ast.Alias{ Expr: &ast.ExistsGQLSubQuery{ Exists: 22, - RBrace: 123, + Rbrace: 123, Query: &ast.GQLQueryExpr{ MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ LinearQueryStatementList: []ast.GQLLinearQueryStatement{ @@ -42,8 +42,8 @@ RETURN EXISTS { PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 39, - RParen: 48, + Lparen: 39, + Rparen: 48, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 40, @@ -88,8 +88,8 @@ RETURN EXISTS { }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 60, - RParen: 70, + Lparen: 60, + Rparen: 70, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 61, diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index 590cf5bd..675591ec 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -29,8 +29,8 @@ RETURN 'Dana' IN { Value: "Dana", }, Right: &ast.GQLSubQueryInCondition{ - LBrace: 32, - RBrace: 91, + Lbrace: 32, + Rbrace: 91, Query: &ast.GQLQueryExpr{ MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ LinearQueryStatementList: []ast.GQLLinearQueryStatement{ @@ -46,8 +46,8 @@ RETURN 'Dana' IN { PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 42, - RParen: 51, + Lparen: 42, + Rparen: 51, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 43, @@ -92,8 +92,8 @@ RETURN 'Dana' IN { }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 63, - RParen: 73, + Lparen: 63, + Rparen: 73, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 64, diff --git a/testdata/result/gql/return_offset_limit.sql.txt b/testdata/result/gql/return_offset_limit.sql.txt index 9ab34fd9..4485c428 100644 --- a/testdata/result/gql/return_offset_limit.sql.txt +++ b/testdata/result/gql/return_offset_limit.sql.txt @@ -27,8 +27,8 @@ LIMIT 1 PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/return_value_subquery.sql.txt b/testdata/result/gql/return_value_subquery.sql.txt index 4eb38dd3..d3006959 100644 --- a/testdata/result/gql/return_value_subquery.sql.txt +++ b/testdata/result/gql/return_value_subquery.sql.txt @@ -26,7 +26,7 @@ RETURN VALUE { Item: &ast.Alias{ Expr: &ast.ValueGQLSubQuery{ Array: 22, - RBrace: 101, + Rbrace: 101, Query: &ast.GQLQueryExpr{ MultiLinearQueryStatement: &ast.GQLMultiLinearQueryStatement{ LinearQueryStatementList: []ast.GQLLinearQueryStatement{ @@ -42,8 +42,8 @@ RETURN VALUE { PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 38, - RParen: 47, + Lparen: 38, + Rparen: 47, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 39, diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt index 38479b7b..4200fada 100644 --- a/testdata/result/gql/skip_1.sql.txt +++ b/testdata/result/gql/skip_1.sql.txt @@ -26,8 +26,8 @@ RETURN p.name, p.id PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 22, diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index cedc43bb..2fdc9d37 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -26,8 +26,8 @@ RETURN account.id AS account_id, num_incoming_transfers PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 21, - RParen: 30, + Lparen: 21, + Rparen: 30, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 22, @@ -62,8 +62,8 @@ RETURN account.id AS account_id, num_incoming_transfers }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 46, - RParen: 62, + Lparen: 46, + Rparen: 62, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 47, diff --git a/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt index a0fd17b6..f53470e3 100644 --- a/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt +++ b/testdata/result/gql_path_pattern/node_pattern_unnamed.sql.txt @@ -5,8 +5,8 @@ PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 1, - RParen: 2, + Lparen: 1, + Rparen: 2, PatternFiller: &ast.GQLPatternFiller{}, }, }, diff --git a/testdata/result/gql_path_pattern/pattern_1.sql.txt b/testdata/result/gql_path_pattern/pattern_1.sql.txt index 86b457fa..68d04a01 100644 --- a/testdata/result/gql_path_pattern/pattern_1.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_1.sql.txt @@ -5,7 +5,7 @@ PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - RParen: 4, + Rparen: 4, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 1, diff --git a/testdata/result/gql_path_pattern/pattern_2.sql.txt b/testdata/result/gql_path_pattern/pattern_2.sql.txt index 2bc34d53..5699d63d 100644 --- a/testdata/result/gql_path_pattern/pattern_2.sql.txt +++ b/testdata/result/gql_path_pattern/pattern_2.sql.txt @@ -5,7 +5,7 @@ PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - RParen: 31, + Rparen: 31, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 1, @@ -15,8 +15,8 @@ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 2, LabelExpression: &ast.GQLLabelParenExpression{ - LParen: 3, - RParen: 30, + Lparen: 3, + Rparen: 30, LabelExpr: &ast.GQLLabelOrExpression{ Left: &ast.GQLElementLabel{ LabelName: &ast.Ident{ @@ -26,8 +26,8 @@ }, }, Right: &ast.GQLLabelParenExpression{ - LParen: 11, - RParen: 29, + Lparen: 11, + Rparen: 29, LabelExpr: &ast.GQLLabelNotExpression{ Not: 12, LabelExpression: &ast.GQLLabelAndExpression{ diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index f057db61..d84871fc 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -16,8 +16,8 @@ SELECT 'Dana' IN { Value: "Dana", }, Right: &ast.GQLSubQueryInCondition{ - LBrace: 17, - RBrace: 93, + Lbrace: 17, + Rbrace: 93, Query: &ast.GQLQueryExpr{ GraphClause: &ast.GQLGraphClause{ Graph: 21, @@ -41,8 +41,8 @@ SELECT 'Dana' IN { PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 44, - RParen: 53, + Lparen: 44, + Rparen: 53, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 45, @@ -87,8 +87,8 @@ SELECT 'Dana' IN { }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 65, - RParen: 75, + Lparen: 65, + Rparen: 75, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 66, diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index f057db61..d84871fc 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -16,8 +16,8 @@ SELECT 'Dana' IN { Value: "Dana", }, Right: &ast.GQLSubQueryInCondition{ - LBrace: 17, - RBrace: 93, + Lbrace: 17, + Rbrace: 93, Query: &ast.GQLQueryExpr{ GraphClause: &ast.GQLGraphClause{ Graph: 21, @@ -41,8 +41,8 @@ SELECT 'Dana' IN { PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 44, - RParen: 53, + Lparen: 44, + Rparen: 53, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 45, @@ -87,8 +87,8 @@ SELECT 'Dana' IN { }, &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLNodePattern{ - LParen: 65, - RParen: 75, + Lparen: 65, + Rparen: 75, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 66, From cab4597dea576fb176e52c10366d30a2e2a628d0 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 15 Jan 2025 01:06:46 +0900 Subject: [PATCH 50/53] Improve edge patterns --- ast/ast.go | 30 ++++++----- ast/pos.go | 4 +- ast/sql.go | 6 +-- parser.go | 50 ++++++++++++------- testdata/result/gql/filter.sql.txt | 4 +- testdata/result/gql/filter_where.sql.txt | 4 +- testdata/result/gql/for_with_offset.sql.txt | 4 +- .../result/gql/graph_hints_between.sql.txt | 8 ++- testdata/result/gql/graph_hints_match.sql.txt | 8 ++- .../gql/graph_hints_traversal_hint.sql.txt | 8 ++- testdata/result/gql/let.sql.txt | 4 +- testdata/result/gql/limit.sql.txt | 4 +- .../result/gql/match_any_shortest.sql.txt | 4 +- .../match_any_shortest_subpath_trail.sql.txt | 2 +- testdata/result/gql/match_optional.sql.txt | 4 +- .../result/gql/match_subpath_trail.sql.txt | 8 ++- .../gql/match_trail_subpath_walk.sql.txt | 4 +- ...tch_where_is_destination_of_return.sql.txt | 2 + .../match_where_is_source_of_return.sql.txt | 2 + .../gql/match_where_not_same_return.sql.txt | 2 + testdata/result/gql/next.sql.txt | 6 ++- testdata/result/gql/next_1.sql.txt | 6 ++- testdata/result/gql/order_by.sql.txt | 4 +- testdata/result/gql/return.sql.txt | 6 ++- .../result/gql/return_array_subquery.sql.txt | 8 ++- testdata/result/gql/return_distinct.sql.txt | 4 +- .../gql/return_exists_graph_pattern.sql.txt | 4 +- .../result/gql/return_exists_match.sql.txt | 4 +- .../gql/return_exists_query_expr.sql.txt | 4 +- .../result/gql/return_in_gql_subquery.sql.txt | 4 +- testdata/result/gql/with_1.sql.txt | 4 +- .../abbreviated_edge_right.sql.txt | 2 +- .../gql_path_pattern/full_edge_any.sql.txt | 2 + .../gql_path_pattern/full_edge_left.sql.txt | 2 + .../gql_path_pattern/full_edge_right.sql.txt | 7 +-- .../query/select_in_gql_subquery.sql.txt | 4 +- .../statement/select_in_gql_subquery.sql.txt | 4 +- 37 files changed, 167 insertions(+), 70 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index 6383468c..a23b96e8 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -4576,40 +4576,43 @@ func (GQLAbbreviatedEdgeRight) isGQLEdgePattern() {} // GQLFullEdgeAny is node representing`-[pattern_filler]-` . // -// -[{{.PatternFiller | sql}}]- +// -[{{.PatternFiller | sqlOpt}}]- type GQLFullEdgeAny struct { // pos = FirstHyphen // end = LastHyphen + 1 FirstHyphen, LastHyphen token.Pos // position of "-" + Lbrack, Rbrack token.Pos // position of "[" and "]" - PatternFiller *GQLPatternFiller + PatternFiller *GQLPatternFiller // optional } // GQLFullEdgeLeft represents `<-[pattern_filler]-` // -// <-[{{.PatternFiller | sql}}]- +// <-[{{.PatternFiller | sqlOpt}}]- type GQLFullEdgeLeft struct { // pos = Lt // end = Hyphen + 1 - Lt token.Pos // position of "<" - Hyphen token.Pos // position of the last "-" + Lt token.Pos // position of "<" + Lbrack, Rbrack token.Pos // position of "[" and "]" + Hyphen token.Pos // position of the last "-" - PatternFiller *GQLPatternFiller + PatternFiller *GQLPatternFiller // optional } // GQLFullEdgeRight represents “-[pattern_filler]-> // -// -[{{.PatternFiller | sql}}]-> +// -[{{.PatternFiller | sqlOpt}}]-> type GQLFullEdgeRight struct { // pos = Hyphen - // end = Gt + 1 + // end = Arrow + 2 - Hyphen token.Pos // position of the first "-" - Gt token.Pos // position of ">" + Hyphen token.Pos // position of the first "-" + Lbrack, Rbrack token.Pos // position of "[" and "]" + Arrow token.Pos // position of "->" - PatternFiller *GQLPatternFiller + PatternFiller *GQLPatternFiller // optional } // GQLAbbreviatedEdgeAny represents `-`. @@ -4638,10 +4641,10 @@ type GQLAbbreviatedEdgeLeft struct { // -> type GQLAbbreviatedEdgeRight struct { // pos = Hyphen - // end = Gt + 1 + // end = Arrow + 2 Hyphen token.Pos // position of "-" - Gt token.Pos // position of ">" + Arrow token.Pos // position of "->" } // GQLQuantifiablePathTerm represents GQLPathTerm with optional Hint and optional GQLQuantifier.. @@ -4779,6 +4782,7 @@ type GQLNodePattern struct { } // GQLPatternFiller represents specifications on the node or edge pattern that you want to match. +// Note: All fields are optional, but all non-nil pattern filler must have at least one non-nil field. // // {{.Hint | sqlOpt}} // {{.GraphPatternVariable | sqlOpt}} diff --git a/ast/pos.go b/ast/pos.go index 7481ef69..45682d70 100644 --- a/ast/pos.go +++ b/ast/pos.go @@ -2347,7 +2347,7 @@ func (g *GQLFullEdgeRight) Pos() token.Pos { } func (g *GQLFullEdgeRight) End() token.Pos { - return posAdd(g.Gt, 1) + return posAdd(g.Arrow, 2) } func (g *GQLAbbreviatedEdgeAny) Pos() token.Pos { @@ -2371,7 +2371,7 @@ func (g *GQLAbbreviatedEdgeRight) Pos() token.Pos { } func (g *GQLAbbreviatedEdgeRight) End() token.Pos { - return posAdd(g.Gt, 1) + return posAdd(g.Arrow, 2) } func (g *GQLQuantifiablePathTerm) Pos() token.Pos { diff --git a/ast/sql.go b/ast/sql.go index ee7598ba..09d3cd1a 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1575,11 +1575,11 @@ func (g *GQLTopLevelPathPattern) SQL() string { return sqlOpt("", g.Var, " = ") + sqlOpt("", g.PathSearchPrefixOrPathMode, " ") + g.PathPattern.SQL() } -func (g *GQLFullEdgeAny) SQL() string { return "-[" + g.PatternFiller.SQL() + "]-" } +func (g *GQLFullEdgeAny) SQL() string { return "-[" + sqlOpt("", g.PatternFiller, "") + "]-" } -func (g *GQLFullEdgeLeft) SQL() string { return "<-[" + g.PatternFiller.SQL() + "]-" } +func (g *GQLFullEdgeLeft) SQL() string { return "<-[" + sqlOpt("", g.PatternFiller, "") + "]-" } -func (g *GQLFullEdgeRight) SQL() string { return "-[" + g.PatternFiller.SQL() + "]->" } +func (g *GQLFullEdgeRight) SQL() string { return "-[" + sqlOpt("", g.PatternFiller, "") + "]->" } func (g *GQLAbbreviatedEdgeAny) SQL() string { return "-" } diff --git a/parser.go b/parser.go index 13a7deb5..63ed8b59 100644 --- a/parser.go +++ b/parser.go @@ -6059,6 +6059,7 @@ func (p *Parser) parseGQLPatternFiller() *ast.GQLPatternFiller { if p.Token.Kind == token.TokenIdent { patternVar = p.parseIdent() } + var isLabelCondition *ast.GQLIsLabelCondition if p.Token.Kind == ":" || p.Token.Kind == "IS" { isLabelCondition = p.parseGQLIsLabelCondition() @@ -6067,9 +6068,9 @@ func (p *Parser) parseGQLPatternFiller() *ast.GQLPatternFiller { filter := p.tryParseGQLPatternFillerFilter() return &ast.GQLPatternFiller{ Hint: hint, - GraphPatternVariable: patternVar, // TODO - IsLabelCondition: isLabelCondition, // TODO - Filter: filter, // TODO + GraphPatternVariable: patternVar, + IsLabelCondition: isLabelCondition, + Filter: filter, } } @@ -6188,10 +6189,19 @@ func (p *Parser) parseGQLSubPathPattern() *ast.GQLSubpathPattern { } } +// parseGQLFullEdgeBody parses [pattern_fillter]. +// If pattern_filler is empty, second return value is nil. +func (p *Parser) parseGQLFullEdgeBody() (lbrack token.Pos, filler *ast.GQLPatternFiller, rbrack token.Pos) { + lbrack = p.expect("[").Pos + if p.Token.Kind != "]" { + filler = p.parseGQLPatternFiller() + } + rbrack = p.expect("]").Pos + + return lbrack, filler, rbrack +} + func (p *Parser) parseGQLEdgePattern() ast.GQLEdgePattern { - // NOTE: Currently, this implementation allows whitespace in any place of "<-[" and "]->". - // It is more relaxed syntax than spec. - // It will be fixed when we are sure that the modification of lexer is safe. firstPos := p.Token.Pos switch p.Token.Kind { case "<": @@ -6203,43 +6213,49 @@ func (p *Parser) parseGQLEdgePattern() ast.GQLEdgePattern { Hyphen: firstHyphenPos, } } - p.nextToken() - patternFilter := p.parseGQLPatternFiller() - p.expect("]") + + lbrack, filler, rbrack := p.parseGQLFullEdgeBody() lastPos := p.expect("-").Pos + return &ast.GQLFullEdgeLeft{ Lt: firstPos, + Lbrack: lbrack, + Rbrack: rbrack, Hyphen: lastPos, - PatternFiller: patternFilter, + PatternFiller: filler, } case "->": lastPos := p.expect("->").Pos + return &ast.GQLAbbreviatedEdgeRight{ Hyphen: firstPos, - Gt: lastPos, + Arrow: lastPos, } case "-": p.nextToken() switch p.Token.Kind { case "[": - p.nextToken() - patternFiller := p.parseGQLPatternFiller() - p.expect("]") + lbrack, filler, rbrack := p.parseGQLFullEdgeBody() + switch p.Token.Kind { case "->": lastPos := p.Token.Pos p.nextToken() return &ast.GQLFullEdgeRight{ Hyphen: firstPos, - Gt: lastPos, - PatternFiller: patternFiller, + Lbrack: lbrack, + Rbrack: rbrack, + Arrow: lastPos, + PatternFiller: filler, } case "-": lastPos := p.expect("-").Pos return &ast.GQLFullEdgeAny{ FirstHyphen: firstPos, + Lbrack: lbrack, + Rbrack: rbrack, LastHyphen: lastPos, - PatternFiller: patternFiller, + PatternFiller: filler, } default: panic(p.errorfAtToken(&p.Token, `expected "-", "->", but: %v`, p.Token.AsString)) diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index 65b06612..f0e101ac 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -50,7 +50,9 @@ RETURN p.name &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 40, + Lbrack: 32, + Rbrack: 39, + Arrow: 40, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 33, diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index 2dda7931..a8efd238 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -50,7 +50,9 @@ RETURN p.name &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 40, + Lbrack: 32, + Rbrack: 39, + Arrow: 40, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 33, diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index 68f2993a..637361f1 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -52,7 +52,9 @@ ORDER BY p.name, element, offset &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 40, + Lbrack: 32, + Rbrack: 39, + Arrow: 40, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 33, diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index 2226c36f..8b976db4 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -71,7 +71,9 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 41, - Gt: 50, + Lbrack: 42, + Rbrack: 49, + Arrow: 50, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 43, @@ -145,7 +147,9 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 95, - Gt: 109, + Lbrack: 96, + Rbrack: 108, + Arrow: 109, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 97, diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index c5a89808..be3ae687 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -69,7 +69,9 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 39, - Gt: 47, + Lbrack: 40, + Rbrack: 46, + Arrow: 47, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 41, @@ -169,7 +171,9 @@ RETURN oa.id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 103, - Gt: 117, + Lbrack: 104, + Rbrack: 116, + Arrow: 117, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 105, diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index 26f971b9..c12c515c 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -71,7 +71,9 @@ RETURN c.id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 41, - Gt: 49, + Lbrack: 42, + Rbrack: 48, + Arrow: 49, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 43, @@ -179,7 +181,9 @@ RETURN c.id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 192, - Gt: 206, + Lbrack: 193, + Rbrack: 205, + Arrow: 206, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 194, diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 35a538bf..69796222 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -50,7 +50,9 @@ RETURN a.id AS a_id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 37, - Gt: 51, + Lbrack: 38, + Rbrack: 50, + Arrow: 51, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 39, diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index bcf9049f..89ad5709 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -51,7 +51,9 @@ RETURN source.nick_name &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 37, - Gt: 51, + Lbrack: 38, + Rbrack: 50, + Arrow: 51, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 39, diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index f2738e6e..768b8db3 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -56,7 +56,9 @@ RETURN a.id AS a_id, total, b.id AS b_id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 45, - Gt: 59, + Lbrack: 46, + Rbrack: 58, + Arrow: 59, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 47, diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt index be910b7c..ca459559 100644 --- a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -45,7 +45,7 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLAbbreviatedEdgeRight{ Hyphen: 41, - Gt: 41, + Arrow: 41, }, Quantifier: &ast.GQLBoundedQuantifier{ Lbrace: 43, diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index 6b4dbe3a..10a40760 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -87,7 +87,9 @@ RETURN n.name, a.id AS blocked_account_id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 57, - Gt: 65, + Lbrack: 58, + Rbrack: 64, + Arrow: 65, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 59, diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index 7c06bd99..e905c1a1 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -65,7 +65,9 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 42, - Gt: 57, + Lbrack: 43, + Rbrack: 56, + Arrow: 57, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 44, @@ -125,7 +127,9 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 78, - Gt: 93, + Lbrack: 79, + Rbrack: 92, + Arrow: 93, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 80, diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 47529e56..743569d3 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -71,7 +71,9 @@ RETURN COUNT(1) as num_paths &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 45, - Gt: 60, + Lbrack: 46, + Rbrack: 59, + Arrow: 60, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 47, diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index 43f32b59..90b9ba2c 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -51,6 +51,8 @@ RETURN a.id AS a_id, b.id AS b_id PathTerm: &ast.GQLFullEdgeAny{ FirstHyphen: 32, LastHyphen: 53, + Lbrack: 33, + Rbrack: 52, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 34, diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index e019b121..7cc45154 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -51,6 +51,8 @@ RETURN a.id AS a_id, b.id AS b_id PathTerm: &ast.GQLFullEdgeAny{ FirstHyphen: 32, LastHyphen: 53, + Lbrack: 33, + Rbrack: 52, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 34, diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index 20626540..0f5e2d15 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -50,6 +50,8 @@ RETURN src.id AS source_id, dest.id AS destination_id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeLeft{ Lt: 34, + Lbrack: 36, + Rbrack: 55, Hyphen: 56, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 51ddf369..6c4b30d6 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -59,7 +59,9 @@ RETURN "Bob" AS owner_name, 100 AS account_id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 44, + Lbrack: 32, + Rbrack: 43, + Arrow: 44, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, @@ -181,6 +183,8 @@ RETURN "Bob" AS owner_name, 100 AS account_id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeLeft{ Lt: 162, + Lbrack: 164, + Rbrack: 170, Hyphen: 171, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index 05382dc9..bfc803a3 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -52,7 +52,9 @@ RETURN &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 44, + Lbrack: 32, + Rbrack: 43, + Arrow: 44, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, @@ -174,6 +176,8 @@ RETURN &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeLeft{ Lt: 162, + Lbrack: 164, + Rbrack: 170, Hyphen: 171, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index 07c3dd58..f8663c7f 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -51,7 +51,9 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 42, - Gt: 63, + Lbrack: 43, + Rbrack: 62, + Arrow: 63, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 44, diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index 99e3e553..4a88911f 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -51,7 +51,9 @@ ORDER BY num_incoming_transfers DESC &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 44, + Lbrack: 32, + Rbrack: 43, + Arrow: 44, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, @@ -173,6 +175,8 @@ ORDER BY num_incoming_transfers DESC &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeLeft{ Lt: 162, + Lbrack: 164, + Rbrack: 170, Hyphen: 171, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index 827bc2b4..cf31d377 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -55,7 +55,9 @@ RETURN &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 39, + Lbrack: 32, + Rbrack: 38, + Arrow: 39, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, @@ -190,7 +192,9 @@ RETURN &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 130, - Gt: 151, + Lbrack: 131, + Rbrack: 150, + Arrow: 151, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 132, diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index 6e938220..27a7e4ab 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -68,7 +68,9 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 42, - Gt: 56, + Lbrack: 43, + Rbrack: 55, + Arrow: 56, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 44, diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index 19d4bb09..d9ee8b27 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -55,7 +55,9 @@ RETURN EXISTS { &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 43, - Gt: 52, + Lbrack: 44, + Rbrack: 51, + Arrow: 52, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 45, diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index 6ae3a79a..834872c3 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -59,7 +59,9 @@ RETURN EXISTS { &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 49, - Gt: 58, + Lbrack: 50, + Rbrack: 57, + Arrow: 58, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 51, diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index e33f053f..9de69154 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -66,7 +66,9 @@ RETURN EXISTS { &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 49, - Gt: 58, + Lbrack: 50, + Rbrack: 57, + Arrow: 58, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 51, diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index 675591ec..63fa4a63 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -70,7 +70,9 @@ RETURN 'Dana' IN { &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 52, - Gt: 61, + Lbrack: 53, + Rbrack: 60, + Arrow: 61, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 54, diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index 2fdc9d37..739d518f 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -45,7 +45,9 @@ RETURN account.id AS account_id, num_incoming_transfers &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 31, - Gt: 44, + Lbrack: 32, + Rbrack: 43, + Arrow: 44, PatternFiller: &ast.GQLPatternFiller{ IsLabelCondition: &ast.GQLIsLabelCondition{ IsOrColon: 33, diff --git a/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt index 786debd2..a01ffbf1 100644 --- a/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt +++ b/testdata/result/gql_path_pattern/abbreviated_edge_right.sql.txt @@ -6,7 +6,7 @@ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLAbbreviatedEdgeRight{ Hyphen: 1, - Gt: 1, + Arrow: 1, }, }, }, diff --git a/testdata/result/gql_path_pattern/full_edge_any.sql.txt b/testdata/result/gql_path_pattern/full_edge_any.sql.txt index 984b43ac..5b2107a9 100644 --- a/testdata/result/gql_path_pattern/full_edge_any.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_any.sql.txt @@ -7,6 +7,8 @@ PathTerm: &ast.GQLFullEdgeAny{ FirstHyphen: 1, LastHyphen: 5, + Lbrack: 2, + Rbrack: 4, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 3, diff --git a/testdata/result/gql_path_pattern/full_edge_left.sql.txt b/testdata/result/gql_path_pattern/full_edge_left.sql.txt index 87555ca5..8c15dfba 100644 --- a/testdata/result/gql_path_pattern/full_edge_left.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_left.sql.txt @@ -6,6 +6,8 @@ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeLeft{ Lt: 2, + Lbrack: 4, + Rbrack: 6, Hyphen: 7, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ diff --git a/testdata/result/gql_path_pattern/full_edge_right.sql.txt b/testdata/result/gql_path_pattern/full_edge_right.sql.txt index e901dbba..83f6da0b 100644 --- a/testdata/result/gql_path_pattern/full_edge_right.sql.txt +++ b/testdata/result/gql_path_pattern/full_edge_right.sql.txt @@ -5,9 +5,10 @@ PathTermList: []*ast.GQLQuantifiablePathTerm{ &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ - Hyphen: 1, - Gt: 4, - PatternFiller: &ast.GQLPatternFiller{}, + Hyphen: 1, + Lbrack: 2, + Rbrack: 3, + Arrow: 4, }, }, }, diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index d84871fc..3adc9ce8 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -65,7 +65,9 @@ SELECT 'Dana' IN { &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 54, - Gt: 63, + Lbrack: 55, + Rbrack: 62, + Arrow: 63, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 56, diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index d84871fc..3adc9ce8 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -65,7 +65,9 @@ SELECT 'Dana' IN { &ast.GQLQuantifiablePathTerm{ PathTerm: &ast.GQLFullEdgeRight{ Hyphen: 54, - Gt: 63, + Lbrack: 55, + Rbrack: 62, + Arrow: 63, PatternFiller: &ast.GQLPatternFiller{ GraphPatternVariable: &ast.Ident{ NamePos: 56, From d6a0af7a4bdeedbef33c8ead25a402f2700092e8 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 15 Jan 2025 01:09:18 +0900 Subject: [PATCH 51/53] Improve GQLPathMode --- ast/sql.go | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/ast/sql.go b/ast/sql.go index 09d3cd1a..408aafd3 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -1596,14 +1596,7 @@ func (g *GQLPathPattern) SQL() string { return sqlJoin(g.PathTermList, "") } func (g *GQLWhereClause) SQL() string { return "WHERE " + g.BoolExpression.SQL() } func (g *GQLPathMode) SQL() string { - switch g.Mode { - case GQLPathModeTrail: - return "TRAIL" - case GQLPathModeWalk: - return "WALK" - default: - panic("UNKNOWN GQLPathMode") - } + return string(g.Mode) + sqlOpt(" ", g.PathOrPathsToken, "") } func (g *GQLFixedQuantifier) SQL() string { return "{" + g.Bound.SQL() + "}" } From a10e98bdbefd3a792290a06752fb85a9c0d34715 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 15 Jan 2025 01:13:19 +0900 Subject: [PATCH 52/53] Fix optional lower bound in GQLBoundedQuantifier --- parser.go | 2 + .../quantified_subpath_lower_default.sql | 1 + .../quantified_subpath_lower_default.sql.txt | 146 ++++++++++++++++++ 3 files changed, 149 insertions(+) create mode 100644 testdata/input/gql_path_pattern/quantified_subpath_lower_default.sql create mode 100644 testdata/result/gql_path_pattern/quantified_subpath_lower_default.sql.txt diff --git a/parser.go b/parser.go index 63ed8b59..5854495f 100644 --- a/parser.go +++ b/parser.go @@ -6108,8 +6108,10 @@ func (p *Parser) tryParseGQLQuantifier() ast.GQLQuantifier { lbrace := p.expect("{").Pos if p.Token.Kind == "," { + p.nextToken() upperBound := p.parseIntValue() rbrace := p.expect("}").Pos + return &ast.GQLBoundedQuantifier{ Lbrace: lbrace, Rbrace: rbrace, diff --git a/testdata/input/gql_path_pattern/quantified_subpath_lower_default.sql b/testdata/input/gql_path_pattern/quantified_subpath_lower_default.sql new file mode 100644 index 00000000..b77e4b30 --- /dev/null +++ b/testdata/input/gql_path_pattern/quantified_subpath_lower_default.sql @@ -0,0 +1 @@ +(source_person:Person)((p:Person)-[k:Knows]->(f:Person)){, 4}(dest_person:Person) \ No newline at end of file diff --git a/testdata/result/gql_path_pattern/quantified_subpath_lower_default.sql.txt b/testdata/result/gql_path_pattern/quantified_subpath_lower_default.sql.txt new file mode 100644 index 00000000..43acf65c --- /dev/null +++ b/testdata/result/gql_path_pattern/quantified_subpath_lower_default.sql.txt @@ -0,0 +1,146 @@ +--- quantified_subpath_lower_default.sql +(source_person:Person)((p:Person)-[k:Knows]->(f:Person)){, 4}(dest_person:Person) +--- AST +&ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ + PathTerm: &ast.GQLNodePattern{ + Rparen: 21, + PatternFiller: &ast.GQLPatternFiller{ + GraphPatternVariable: &ast.Ident{ + NamePos: 1, + NameEnd: 14, + Name: "source_person", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 14, + LabelExpression: &ast.GQLElementLabel{ + LabelName: &ast.Ident{ + NamePos: 15, + NameEnd: 21, + Name: "Person", + }, + }, + }, + }, + }, + }, + &ast.GQLQuantifiablePathTerm{ + PathTerm: &ast.GQLSubpathPattern{ + Lparen: 22, + Rparen: 55, + PathPattern: &ast.GQLPathPattern{ + PathTermList: []*ast.GQLQuantifiablePathTerm{ + &ast.GQLQuantifiablePathTerm{ + PathTerm: &ast.GQLNodePattern{ + Lparen: 23, + Rparen: 32, + PatternFiller: &ast.GQLPatternFiller{ + GraphPatternVariable: &ast.Ident{ + NamePos: 24, + NameEnd: 25, + Name: "p", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 25, + LabelExpression: &ast.GQLElementLabel{ + LabelName: &ast.Ident{ + NamePos: 26, + NameEnd: 32, + Name: "Person", + }, + }, + }, + }, + }, + }, + &ast.GQLQuantifiablePathTerm{ + PathTerm: &ast.GQLFullEdgeRight{ + Hyphen: 33, + Lbrack: 34, + Rbrack: 42, + Arrow: 43, + PatternFiller: &ast.GQLPatternFiller{ + GraphPatternVariable: &ast.Ident{ + NamePos: 35, + NameEnd: 36, + Name: "k", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 36, + LabelExpression: &ast.GQLElementLabel{ + LabelName: &ast.Ident{ + NamePos: 37, + NameEnd: 42, + Name: "Knows", + }, + }, + }, + }, + }, + }, + &ast.GQLQuantifiablePathTerm{ + PathTerm: &ast.GQLNodePattern{ + Lparen: 45, + Rparen: 54, + PatternFiller: &ast.GQLPatternFiller{ + GraphPatternVariable: &ast.Ident{ + NamePos: 46, + NameEnd: 47, + Name: "f", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 47, + LabelExpression: &ast.GQLElementLabel{ + LabelName: &ast.Ident{ + NamePos: 48, + NameEnd: 54, + Name: "Person", + }, + }, + }, + }, + }, + }, + }, + }, + }, + Quantifier: &ast.GQLBoundedQuantifier{ + Lbrace: 56, + Rbrace: 60, + UpperBound: &ast.IntLiteral{ + ValuePos: 59, + ValueEnd: 60, + Base: 10, + Value: "4", + }, + }, + }, + &ast.GQLQuantifiablePathTerm{ + PathTerm: &ast.GQLNodePattern{ + Lparen: 61, + Rparen: 80, + PatternFiller: &ast.GQLPatternFiller{ + GraphPatternVariable: &ast.Ident{ + NamePos: 62, + NameEnd: 73, + Name: "dest_person", + }, + IsLabelCondition: &ast.GQLIsLabelCondition{ + IsOrColon: 73, + LabelExpression: &ast.GQLElementLabel{ + LabelName: &ast.Ident{ + NamePos: 74, + NameEnd: 80, + Name: "Person", + }, + }, + }, + }, + }, + }, + }, +} + +--- SQL +(source_person:Person)((p:Person)-[k:Knows]->(f:Person)){,4}(dest_person:Person) From b36d20c8bf85e8374a10cb436f45a851ca333591 Mon Sep 17 00:00:00 2001 From: apstndb <803393+apstndb@users.noreply.github.com> Date: Wed, 15 Jan 2025 02:04:58 +0900 Subject: [PATCH 53/53] Refactor AllOrDistinct and SQL() --- ast/ast.go | 6 +- ast/ast_const.go | 17 +-- ast/sql.go | 108 ++++++------------ parser.go | 26 +---- testdata/result/gql/filter.sql.txt | 5 +- testdata/result/gql/filter_where.sql.txt | 5 +- testdata/result/gql/for_with_offset.sql.txt | 5 +- .../result/gql/for_with_offset_as.sql.txt | 5 +- .../result/gql/graph_hints_between.sql.txt | 4 +- testdata/result/gql/graph_hints_match.sql.txt | 5 +- .../gql/graph_hints_traversal_hint.sql.txt | 4 +- testdata/result/gql/let.sql.txt | 5 +- testdata/result/gql/limit.sql.txt | 6 +- testdata/result/gql/match.sql.txt | 4 +- .../result/gql/match_any_shortest.sql.txt | 5 +- .../match_any_shortest_subpath_trail.sql.txt | 4 +- testdata/result/gql/match_optional.sql.txt | 5 +- .../result/gql/match_or_expression.sql.txt | 4 +- .../result/gql/match_subpath_trail.sql.txt | 4 +- .../gql/match_trail_subpath_walk.sql.txt | 4 +- ...tch_where_is_destination_of_return.sql.txt | 4 +- .../match_where_is_source_of_return.sql.txt | 4 +- .../gql/match_where_not_same_return.sql.txt | 4 +- ...match_where_property_exists_return.sql.txt | 4 +- testdata/result/gql/next.sql.txt | 14 +-- testdata/result/gql/next_1.sql.txt | 7 +- testdata/result/gql/offset_1.sql.txt | 5 +- testdata/result/gql/order_by.sql.txt | 6 +- testdata/result/gql/order_by_collate.sql.txt | 5 +- testdata/result/gql/return.sql.txt | 7 +- .../result/gql/return_array_subquery.sql.txt | 7 +- testdata/result/gql/return_distinct.sql.txt | 4 +- .../gql/return_exists_graph_pattern.sql.txt | 5 +- .../result/gql/return_exists_match.sql.txt | 5 +- .../gql/return_exists_query_expr.sql.txt | 6 +- .../result/gql/return_in_gql_subquery.sql.txt | 4 +- .../result/gql/return_offset_limit.sql.txt | 4 +- .../result/gql/return_value_subquery.sql.txt | 6 +- testdata/result/gql/skip_1.sql.txt | 5 +- testdata/result/gql/with_1.sql.txt | 5 +- .../query/select_from_graph_table.sql.txt | 5 +- .../query/select_in_gql_subquery.sql.txt | 4 +- .../statement/select_from_graph_table.sql.txt | 5 +- .../statement/select_in_gql_subquery.sql.txt | 4 +- 44 files changed, 89 insertions(+), 271 deletions(-) diff --git a/ast/ast.go b/ast/ast.go index a23b96e8..56cad326 100644 --- a/ast/ast.go +++ b/ast/ast.go @@ -4264,7 +4264,7 @@ type GQLSimpleLinearQueryStatementWithSetOperator struct { StartPos token.Pos SetOperator GQLSetOperatorEnum - DistinctOrAll GQLAllOrDistinctEnum + AllOrDistinct AllOrDistinct Statement *GQLSimpleLinearQueryStatement } @@ -4462,7 +4462,7 @@ type GQLWithStatement struct { // end = (GroupByClause ?? ReturnItemList[$]).end With token.Pos - AllOrDistinct GQLAllOrDistinctEnum + AllOrDistinct AllOrDistinct ReturnItemList []*GQLReturnItem GroupByClause *GroupBy // optional } @@ -4489,7 +4489,7 @@ type GQLReturnStatement struct { // end = (LimitAndOffsetClause ?? OrderByClause ?? GroupByClause ?? ReturnItemList[$]).end Return token.Pos // position of "RETURN" keyword - AllOrDistinct GQLAllOrDistinctEnum + AllOrDistinct AllOrDistinct ReturnItemList []*GQLReturnItem // Use GoogleSQL GroupBy because it is referenced in docs diff --git a/ast/ast_const.go b/ast/ast_const.go index cef9d573..e51e17e8 100644 --- a/ast/ast_const.go +++ b/ast/ast_const.go @@ -159,14 +159,6 @@ const ( InsertOrTypeIgnore InsertOrType = "IGNORE" ) -type GQLAllOrDistinctEnum string - -const ( - GQLAllOrDistinctImplicitAll GQLAllOrDistinctEnum = "" - GQLAllOrDistinctAll GQLAllOrDistinctEnum = "ALL" - GQLAllOrDistinctDistinct GQLAllOrDistinctEnum = "DISTINCT" -) - type GQLSetOperatorEnum string const ( @@ -178,11 +170,10 @@ const ( type GQLDirectionEnum string const ( - GQLSortOrderUnspecified GQLDirectionEnum = "" - GQLSortOrderAsc GQLDirectionEnum = "ASC" - GQLSortOrderAscending GQLDirectionEnum = "ASCENDING" - GQLSortOrderDesc GQLDirectionEnum = "DESC" - GQLSortOrderDescending GQLDirectionEnum = "DESCENDING" + GQLSortOrderAsc GQLDirectionEnum = "ASC" + GQLSortOrderAscending GQLDirectionEnum = "ASCENDING" + GQLSortOrderDesc GQLDirectionEnum = "DESC" + GQLSortOrderDescending GQLDirectionEnum = "DESCENDING" ) type GQLPathModeEnum string diff --git a/ast/sql.go b/ast/sql.go index 408aafd3..63dcb591 100644 --- a/ast/sql.go +++ b/ast/sql.go @@ -392,9 +392,9 @@ func (t *TableSampleSize) SQL() string { } func (g *GraphTableExpr) SQL() string { - return "GRAPH_TABLE(\n" + - g.PropertyGraphName.SQL() + "\n" + - g.Query.SQL() + "\n" + + return "GRAPH_TABLE(" + + g.PropertyGraphName.SQL() + " " + + g.Query.SQL() + ")" + sqlOpt(" ", g.As, "") } @@ -765,15 +765,15 @@ func (c *CastNumValue) SQL() string { // ================================================================================ func (a *ArrayGQLSubQuery) SQL() string { - return "ARRAY {\n" + a.Query.SQL() + "\n}" + return "ARRAY {" + a.Query.SQL() + "}" } func (v *ValueGQLSubQuery) SQL() string { - return "VALUE {\n" + v.Query.SQL() + "\n}" + return "VALUE {" + v.Query.SQL() + "}" } func (v *ExistsGQLSubQuery) SQL() string { - return "EXISTS {\n" + v.Query.SQL() + "\n}" + return "EXISTS {" + v.Query.SQL() + "}" } // ================================================================================ @@ -1419,61 +1419,49 @@ func (c *Call) SQL() string { return "CALL " + c.Name.SQL() + "(" + sqlJoin(c.Args, ", ") + ")" } +// ================================================================================ +// // GQL +// +// ================================================================================ func (s *GQLGraphQuery) SQL() string { - return sqlOpt("", s.Hint, " ") + s.GraphClause.SQL() + "\n" + s.MultiLinearQueryStatement.SQL() + return sqlOpt("", s.Hint, " ") + s.GraphClause.SQL() + " " + s.MultiLinearQueryStatement.SQL() } func (g *GQLQueryExpr) SQL() string { - return sqlOpt("", g.GraphClause, "\n") + g.MultiLinearQueryStatement.SQL() + return sqlOpt("", g.GraphClause, " ") + g.MultiLinearQueryStatement.SQL() } func (s *GQLGraphClause) SQL() string { return "GRAPH " + s.PropertyGraphName.SQL() } func (s *GQLMultiLinearQueryStatement) SQL() string { - return sqlJoin(s.LinearQueryStatementList, "\nNEXT\n") + return sqlJoin(s.LinearQueryStatementList, " NEXT ") } func (s *GQLSimpleLinearQueryStatement) SQL() string { - return sqlJoin(s.PrimitiveQueryStatementList, "\n") + return sqlJoin(s.PrimitiveQueryStatementList, " ") } func (s *GQLCompositeLinearQueryStatement) SQL() string { - sql := s.HeadSimpleLinearQueryStatement.SQL() - if len(s.TailSimpleLinearQueryStatementList) > 0 { - sql += "\n" + sqlJoin(s.TailSimpleLinearQueryStatementList, "\n") - } - return sql + return s.HeadSimpleLinearQueryStatement.SQL() + + strOpt(len(s.TailSimpleLinearQueryStatementList) > 0, " ") + + sqlJoin(s.TailSimpleLinearQueryStatementList, " ") } func (g *GQLSimpleLinearQueryStatementWithSetOperator) SQL() string { - var sql string - switch g.SetOperator { - case GQLSetOperatorUnion: - sql += "UNION" - case GQLSetOperatorIntersect: - sql += "INTERSECT" - case GQLSetOperatorExcept: - sql += "EXCEPT" - } - - switch g.DistinctOrAll { - case GQLAllOrDistinctAll: - sql += " " + "ALL" - case GQLAllOrDistinctDistinct: - sql += " " + "DISTINCT" - default: - // no action - } - - sql += "\n" + g.Statement.SQL() - return sql + return string(g.SetOperator) + + strOpt(g.AllOrDistinct != "", " "+string(g.AllOrDistinct)) + + " " + g.Statement.SQL() } func (s *GQLLinearGraphVariable) SQL() string { return s.VariableName.SQL() + " = " + s.Value.SQL() } +// ================================================================================ +// // GQL statements +// +// ================================================================================ func (g *GQLMatchStatement) SQL() string { return strIfElse(g.Optional.Invalid(), "MATCH", "OPTIONAL MATCH") + @@ -1515,11 +1503,8 @@ func (g *GQLOrderByStatement) SQL() string { } func (g *GQLOrderBySpecification) SQL() string { - sql := g.Expr.SQL() + sqlOpt(" ", g.CollationSpecification, "") - if g.Direction != GQLSortOrderUnspecified { - sql += " " + string(g.Direction) - } - return sql + return g.Expr.SQL() + sqlOpt(" ", g.CollationSpecification, "") + + strOpt(g.Direction != "", " "+string(g.Direction)) } func (g *GQLCollationSpecification) SQL() string { @@ -1527,16 +1512,7 @@ func (g *GQLCollationSpecification) SQL() string { } func (g *GQLWithStatement) SQL() string { - var allOrDistinctStr string - switch g.AllOrDistinct { - case GQLAllOrDistinctDistinct: - allOrDistinctStr = "DISTINCT " - case GQLAllOrDistinctAll: - allOrDistinctStr = "ALL " - case GQLAllOrDistinctImplicitAll: - allOrDistinctStr = "" - } - return "WITH " + allOrDistinctStr + + return "WITH " + strOpt(g.AllOrDistinct != "", string(g.AllOrDistinct)+" ") + sqlJoin(g.ReturnItemList, ", ") + sqlOpt(" ", g.GroupByClause, "") } @@ -1548,21 +1524,12 @@ func (g *GQLReturnItem) SQL() string { } func (g *GQLReturnStatement) SQL() string { - sql := "RETURN " - switch g.AllOrDistinct { - case GQLAllOrDistinctAll: - sql += "ALL " - case GQLAllOrDistinctDistinct: - sql += "DISTINCT " - case GQLAllOrDistinctImplicitAll: - // empty - } - - sql += sqlJoin(g.ReturnItemList, ", ") + + return "RETURN " + + strOpt(g.AllOrDistinct != "", string(g.AllOrDistinct)+" ") + + sqlJoin(g.ReturnItemList, ", ") + sqlOpt(" ", g.GroupByClause, "") + sqlOpt(" ", g.OrderByClause, "") + sqlOpt(" ", g.LimitAndOffsetClause, "") - return sql } // GQL graph patterns @@ -1616,15 +1583,12 @@ func (g *GQLSubpathPattern) SQL() string { func (g *GQLNodePattern) SQL() string { return "(" + g.PatternFiller.SQL() + ")" } func (g *GQLPatternFiller) SQL() string { - sql := sqlOpt("", g.Hint, "") + + return sqlOpt("", g.Hint, "") + sqlOpt("", g.GraphPatternVariable, "") + - sqlOpt("", g.IsLabelCondition, "") - - if sql == "" { - return sqlOpt("", g.Filter, "") - } - - return sql + sqlOpt(" ", g.Filter, "") + sqlOpt("", g.IsLabelCondition, "") + + sqlOpt( + strOpt(g.Hint != nil || g.GraphPatternVariable != nil || g.IsLabelCondition != nil, " "), + g.Filter, "") } func (g *GQLIsLabelCondition) SQL() string { return ":" + g.LabelExpression.SQL() } @@ -1661,6 +1625,6 @@ func (p *GQLPathSearchPrefix) SQL() string { case GQLPathSearchPrefixAll: return "ALL" default: - panic("invalid GQLPathSearchPrefix") + panic("unreached condition: invalid GQLPathSearchPrefix") } } diff --git a/parser.go b/parser.go index 5854495f..3f8a2632 100644 --- a/parser.go +++ b/parser.go @@ -5662,16 +5662,13 @@ func (p *Parser) parseGQLSimpleLinearQueryStatementWithSetOperator() *ast.GQLSim panic("unknown SetOperatorEnum") } - allOrDistinct := p.tryParseGQLAllOrDistinctEnum() - if allOrDistinct == ast.GQLAllOrDistinctImplicitAll { - p.panicfAtToken(&p.Token, `expect "ALL" or "DISTINCT, but: %v`, p.Token.Kind) - } - + allOrDistinct := p.parseAllOrDistinct() stmt := p.parseGQLSimpleLinearQueryStatement() + return &ast.GQLSimpleLinearQueryStatementWithSetOperator{ StartPos: pos, SetOperator: op, - DistinctOrAll: allOrDistinct, + AllOrDistinct: allOrDistinct, Statement: stmt, } } @@ -6377,7 +6374,7 @@ GQL RETURN statement func (p *Parser) parseGQLReturnStatement() *ast.GQLReturnStatement { ret := p.expectKeywordLike("RETURN").Pos - allOrDistinct := p.tryParseGQLAllOrDistinctEnum() + allOrDistinct := p.tryParseAllOrDistinct() returnItems := p.parseGQLReturnItemList() groupBy := p.tryParseGroupBy() orderBy := p.tryParseOrderBy() @@ -6412,22 +6409,9 @@ func (p *Parser) parseGQLReturnItemList() []*ast.GQLReturnItem { return parseCommaSeparatedList(p, p.parseGQLReturnItem) } -func (p *Parser) tryParseGQLAllOrDistinctEnum() ast.GQLAllOrDistinctEnum { - switch p.Token.Kind { - case "ALL": - p.nextToken() - return ast.GQLAllOrDistinctAll - case "DISTINCT": - p.nextToken() - return ast.GQLAllOrDistinctDistinct - default: - return ast.GQLAllOrDistinctImplicitAll - } -} - func (p *Parser) parseGQLWithStatement() *ast.GQLWithStatement { with := p.expect("WITH").Pos - allOrDistinct := p.tryParseGQLAllOrDistinctEnum() + allOrDistinct := p.tryParseAllOrDistinct() returnItems := p.parseGQLReturnItemList() groupBy := p.tryParseGroupBy() diff --git a/testdata/result/gql/filter.sql.txt b/testdata/result/gql/filter.sql.txt index f0e101ac..3a0b1595 100644 --- a/testdata/result/gql/filter.sql.txt +++ b/testdata/result/gql/filter.sql.txt @@ -157,7 +157,4 @@ RETURN p.name } --- SQL -GRAPH FinGraph -MATCH (p:Person)-[o:Owns]->(a:Account) -FILTER p.birthday < "1990-01-10" -RETURN p.name +GRAPH FinGraph MATCH (p:Person)-[o:Owns]->(a:Account) FILTER p.birthday < "1990-01-10" RETURN p.name diff --git a/testdata/result/gql/filter_where.sql.txt b/testdata/result/gql/filter_where.sql.txt index a8efd238..e3760f64 100644 --- a/testdata/result/gql/filter_where.sql.txt +++ b/testdata/result/gql/filter_where.sql.txt @@ -157,7 +157,4 @@ RETURN p.name } --- SQL -GRAPH FinGraph -MATCH (p:Person)-[o:Owns]->(a:Account) -FILTER WHERE p.birthday < "1990-01-10" -RETURN p.name +GRAPH FinGraph MATCH (p:Person)-[o:Owns]->(a:Account) FILTER WHERE p.birthday < "1990-01-10" RETURN p.name diff --git a/testdata/result/gql/for_with_offset.sql.txt b/testdata/result/gql/for_with_offset.sql.txt index 637361f1..00bf9fb1 100644 --- a/testdata/result/gql/for_with_offset.sql.txt +++ b/testdata/result/gql/for_with_offset.sql.txt @@ -226,7 +226,4 @@ ORDER BY p.name, element, offset } --- SQL -GRAPH FinGraph -MATCH (p:Person)-[o:Owns]->(a:Account) -FOR element IN ["all", "some"] WITH OFFSET -RETURN p.name, element AS alert_type, offset ORDER BY p.name, element, offset +GRAPH FinGraph MATCH (p:Person)-[o:Owns]->(a:Account) FOR element IN ["all", "some"] WITH OFFSET RETURN p.name, element AS alert_type, offset ORDER BY p.name, element, offset diff --git a/testdata/result/gql/for_with_offset_as.sql.txt b/testdata/result/gql/for_with_offset_as.sql.txt index 15433491..16d22eed 100644 --- a/testdata/result/gql/for_with_offset_as.sql.txt +++ b/testdata/result/gql/for_with_offset_as.sql.txt @@ -126,7 +126,4 @@ RETURN p.name, element, off } --- SQL -GRAPH FinGraph -MATCH (p:Person) -FOR element IN [] WITH OFFSET AS off -RETURN p.name, element, off +GRAPH FinGraph MATCH (p:Person) FOR element IN [] WITH OFFSET AS off RETURN p.name, element, off diff --git a/testdata/result/gql/graph_hints_between.sql.txt b/testdata/result/gql/graph_hints_between.sql.txt index 8b976db4..1b94fb2d 100644 --- a/testdata/result/gql/graph_hints_between.sql.txt +++ b/testdata/result/gql/graph_hints_between.sql.txt @@ -232,6 +232,4 @@ RETURN oa.id } --- SQL -GRAPH FinGraph -MATCH (p:Person {id: 1})-[e:Owns]->@{JOIN_METHOD=APPLY_JOIN}((a:Account)-[s:Transfers]->(oa:Account)) -RETURN oa.id +GRAPH FinGraph MATCH (p:Person {id: 1})-[e:Owns]->@{JOIN_METHOD=APPLY_JOIN}((a:Account)-[s:Transfers]->(oa:Account)) RETURN oa.id diff --git a/testdata/result/gql/graph_hints_match.sql.txt b/testdata/result/gql/graph_hints_match.sql.txt index be3ae687..2954b71c 100644 --- a/testdata/result/gql/graph_hints_match.sql.txt +++ b/testdata/result/gql/graph_hints_match.sql.txt @@ -252,7 +252,4 @@ RETURN oa.id } --- SQL -GRAPH FinGraph -MATCH (p:Person {id: 1})-[:Owns]->(a:Account) -MATCH@{JOIN_METHOD=APPLY_JOIN} (a:Account)-[e:Transfers]->(oa:Account) -RETURN oa.id +GRAPH FinGraph MATCH (p:Person {id: 1})-[:Owns]->(a:Account) MATCH@{JOIN_METHOD=APPLY_JOIN} (a:Account)-[e:Transfers]->(oa:Account) RETURN oa.id diff --git a/testdata/result/gql/graph_hints_traversal_hint.sql.txt b/testdata/result/gql/graph_hints_traversal_hint.sql.txt index c12c515c..f4c1ec2a 100644 --- a/testdata/result/gql/graph_hints_traversal_hint.sql.txt +++ b/testdata/result/gql/graph_hints_traversal_hint.sql.txt @@ -262,6 +262,4 @@ RETURN c.id } --- SQL -GRAPH FinGraph -MATCH (p:Person {id: 1})-[:Owns]->(a:Account), @{JOIN_METHOD=HASH_JOIN, HASH_JOIN_BUILD_SIDE=BUILD_RIGHT}(a:Account)-[e:Transfers]->(c:Account) -RETURN c.id +GRAPH FinGraph MATCH (p:Person {id: 1})-[:Owns]->(a:Account), @{JOIN_METHOD=HASH_JOIN, HASH_JOIN_BUILD_SIDE=BUILD_RIGHT}(a:Account)-[e:Transfers]->(c:Account) RETURN c.id diff --git a/testdata/result/gql/let.sql.txt b/testdata/result/gql/let.sql.txt index 69796222..cd7d35ce 100644 --- a/testdata/result/gql/let.sql.txt +++ b/testdata/result/gql/let.sql.txt @@ -156,7 +156,4 @@ RETURN a.id AS a_id } --- SQL -GRAPH FinGraph -MATCH (source:Account)-[e:Transfers]->(destination:Account) -LET a = source -RETURN a.id AS a_id +GRAPH FinGraph MATCH (source:Account)-[e:Transfers]->(destination:Account) LET a = source RETURN a.id AS a_id diff --git a/testdata/result/gql/limit.sql.txt b/testdata/result/gql/limit.sql.txt index 89ad5709..e7908020 100644 --- a/testdata/result/gql/limit.sql.txt +++ b/testdata/result/gql/limit.sql.txt @@ -163,8 +163,4 @@ RETURN source.nick_name } --- SQL -GRAPH FinGraph -MATCH (source:Account)-[e:Transfers]->(destination:Account) -ORDER BY source.nick_name -LIMIT 3 -RETURN source.nick_name +GRAPH FinGraph MATCH (source:Account)-[e:Transfers]->(destination:Account) ORDER BY source.nick_name LIMIT 3 RETURN source.nick_name diff --git a/testdata/result/gql/match.sql.txt b/testdata/result/gql/match.sql.txt index 7bccc741..614b8a46 100644 --- a/testdata/result/gql/match.sql.txt +++ b/testdata/result/gql/match.sql.txt @@ -100,6 +100,4 @@ RETURN p.name, p.id } --- SQL -GRAPH FinGraph -MATCH (p:Person) -RETURN p.name, p.id +GRAPH FinGraph MATCH (p:Person) RETURN p.name, p.id diff --git a/testdata/result/gql/match_any_shortest.sql.txt b/testdata/result/gql/match_any_shortest.sql.txt index 768b8db3..ee2c5d10 100644 --- a/testdata/result/gql/match_any_shortest.sql.txt +++ b/testdata/result/gql/match_any_shortest.sql.txt @@ -255,7 +255,4 @@ RETURN a.id AS a_id, total, b.id AS b_id } --- SQL -GRAPH FinGraph -MATCH ANY SHORTEST (a:Account)-[t:Transfers]->{1,4}(b:Account) WHERE a.is_blocked -LET total = SUM(t.amount) -RETURN a.id AS a_id, total, b.id AS b_id +GRAPH FinGraph MATCH ANY SHORTEST (a:Account)-[t:Transfers]->{1,4}(b:Account) WHERE a.is_blocked LET total = SUM(t.amount) RETURN a.id AS a_id, total, b.id AS b_id diff --git a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt index ca459559..f4d6d78d 100644 --- a/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt +++ b/testdata/result/gql/match_any_shortest_subpath_trail.sql.txt @@ -120,6 +120,4 @@ RETURN COUNT(1) as num_paths } --- SQL -GRAPH FinGraph -MATCH ANY SHORTEST (TRAIL ->{1,4}) -RETURN COUNT(1) AS num_paths +GRAPH FinGraph MATCH ANY SHORTEST (TRAIL ->{1,4}) RETURN COUNT(1) AS num_paths diff --git a/testdata/result/gql/match_optional.sql.txt b/testdata/result/gql/match_optional.sql.txt index 10a40760..f9b3d2cd 100644 --- a/testdata/result/gql/match_optional.sql.txt +++ b/testdata/result/gql/match_optional.sql.txt @@ -206,7 +206,4 @@ RETURN n.name, a.id AS blocked_account_id } --- SQL -GRAPH FinGraph -MATCH (n:Person) -OPTIONAL MATCH (n:Person)-[:Owns]->(a:Account {is_blocked: TRUE}) -RETURN n.name, a.id AS blocked_account_id +GRAPH FinGraph MATCH (n:Person) OPTIONAL MATCH (n:Person)-[:Owns]->(a:Account {is_blocked: TRUE}) RETURN n.name, a.id AS blocked_account_id diff --git a/testdata/result/gql/match_or_expression.sql.txt b/testdata/result/gql/match_or_expression.sql.txt index 9ad7823b..be3b3fc8 100644 --- a/testdata/result/gql/match_or_expression.sql.txt +++ b/testdata/result/gql/match_or_expression.sql.txt @@ -127,6 +127,4 @@ RETURN n.id, n.name, n.nick_name } --- SQL -GRAPH FinGraph -MATCH (n:Person|Account) -RETURN n.id, n.name, n.nick_name +GRAPH FinGraph MATCH (n:Person|Account) RETURN n.id, n.name, n.nick_name diff --git a/testdata/result/gql/match_subpath_trail.sql.txt b/testdata/result/gql/match_subpath_trail.sql.txt index e905c1a1..bb820ff0 100644 --- a/testdata/result/gql/match_subpath_trail.sql.txt +++ b/testdata/result/gql/match_subpath_trail.sql.txt @@ -224,6 +224,4 @@ RETURN COUNT(1) as num_paths } --- SQL -GRAPH FinGraph -MATCH (TRAIL (a1:Account)-[t1:Transfers]->{3}(a4:Account))-[t4:Transfers]->(a5:Account) -RETURN COUNT(1) AS num_paths +GRAPH FinGraph MATCH (TRAIL (a1:Account)-[t1:Transfers]->{3}(a4:Account))-[t4:Transfers]->(a5:Account) RETURN COUNT(1) AS num_paths diff --git a/testdata/result/gql/match_trail_subpath_walk.sql.txt b/testdata/result/gql/match_trail_subpath_walk.sql.txt index 743569d3..b75e94e3 100644 --- a/testdata/result/gql/match_trail_subpath_walk.sql.txt +++ b/testdata/result/gql/match_trail_subpath_walk.sql.txt @@ -182,6 +182,4 @@ RETURN COUNT(1) as num_paths } --- SQL -GRAPH FinGraph -MATCH TRAIL (WALK (a1:Account)-[t1:Transfers]->{4}(a5:Account)) -RETURN COUNT(1) AS num_paths +GRAPH FinGraph MATCH TRAIL (WALK (a1:Account)-[t1:Transfers]->{4}(a5:Account)) RETURN COUNT(1) AS num_paths diff --git a/testdata/result/gql/match_where_is_destination_of_return.sql.txt b/testdata/result/gql/match_where_is_destination_of_return.sql.txt index 90b9ba2c..72b80631 100644 --- a/testdata/result/gql/match_where_is_destination_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_destination_of_return.sql.txt @@ -180,6 +180,4 @@ RETURN a.id AS a_id, b.id AS b_id } --- SQL -GRAPH FinGraph -MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS DESTINATION OF transfer -RETURN a.id AS a_id, b.id AS b_id +GRAPH FinGraph MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS DESTINATION OF transfer RETURN a.id AS a_id, b.id AS b_id diff --git a/testdata/result/gql/match_where_is_source_of_return.sql.txt b/testdata/result/gql/match_where_is_source_of_return.sql.txt index 7cc45154..0970ea1d 100644 --- a/testdata/result/gql/match_where_is_source_of_return.sql.txt +++ b/testdata/result/gql/match_where_is_source_of_return.sql.txt @@ -180,6 +180,4 @@ RETURN a.id AS a_id, b.id AS b_id } --- SQL -GRAPH FinGraph -MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS SOURCE OF transfer -RETURN a.id AS a_id, b.id AS b_id +GRAPH FinGraph MATCH (a:Account)-[transfer:Transfers]-(b:Account) WHERE a IS SOURCE OF transfer RETURN a.id AS a_id, b.id AS b_id diff --git a/testdata/result/gql/match_where_not_same_return.sql.txt b/testdata/result/gql/match_where_not_same_return.sql.txt index 0f5e2d15..c9e02e96 100644 --- a/testdata/result/gql/match_where_not_same_return.sql.txt +++ b/testdata/result/gql/match_where_not_same_return.sql.txt @@ -200,6 +200,4 @@ RETURN src.id AS source_id, dest.id AS destination_id } --- SQL -GRAPH FinGraph -MATCH (src:Account)<-[transfer:Transfers]-(dest:Account) WHERE NOT SAME(src, dest) -RETURN src.id AS source_id, dest.id AS destination_id +GRAPH FinGraph MATCH (src:Account)<-[transfer:Transfers]-(dest:Account) WHERE NOT SAME(src, dest) RETURN src.id AS source_id, dest.id AS destination_id diff --git a/testdata/result/gql/match_where_property_exists_return.sql.txt b/testdata/result/gql/match_where_property_exists_return.sql.txt index 5cbb2214..1bf27c9a 100644 --- a/testdata/result/gql/match_where_property_exists_return.sql.txt +++ b/testdata/result/gql/match_where_property_exists_return.sql.txt @@ -122,6 +122,4 @@ RETURN n.name } --- SQL -GRAPH FinGraph -MATCH (n:Person|Account WHERE PROPERTY_EXISTS(n, name)) -RETURN n.name +GRAPH FinGraph MATCH (n:Person|Account WHERE PROPERTY_EXISTS(n, name)) RETURN n.name diff --git a/testdata/result/gql/next.sql.txt b/testdata/result/gql/next.sql.txt index 6c4b30d6..1113ae75 100644 --- a/testdata/result/gql/next.sql.txt +++ b/testdata/result/gql/next.sql.txt @@ -347,7 +347,7 @@ RETURN "Bob" AS owner_name, 100 AS account_id &ast.GQLSimpleLinearQueryStatementWithSetOperator{ StartPos: 344, SetOperator: "UNION", - DistinctOrAll: "ALL", + AllOrDistinct: "ALL", Statement: &ast.GQLSimpleLinearQueryStatement{ PrimitiveQueryStatementList: []ast.GQLPrimitiveQueryStatement{ &ast.GQLReturnStatement{ @@ -400,14 +400,4 @@ RETURN "Bob" AS owner_name, 100 AS account_id } --- SQL -GRAPH FinGraph -MATCH (:Account)-[:Transfers]->(account:Account) -RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account -NEXT -MATCH (account:Account)<-[:Owns]-(owner:Person) -RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers -NEXT -FILTER num_incoming_transfers < 2 -RETURN account_id, owner_name -UNION ALL -RETURN "Bob" AS owner_name, 100 AS account_id +GRAPH FinGraph MATCH (:Account)-[:Transfers]->(account:Account) RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account NEXT MATCH (account:Account)<-[:Owns]-(owner:Person) RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers NEXT FILTER num_incoming_transfers < 2 RETURN account_id, owner_name UNION ALL RETURN "Bob" AS owner_name, 100 AS account_id diff --git a/testdata/result/gql/next_1.sql.txt b/testdata/result/gql/next_1.sql.txt index bfc803a3..d9a689c8 100644 --- a/testdata/result/gql/next_1.sql.txt +++ b/testdata/result/gql/next_1.sql.txt @@ -295,9 +295,4 @@ RETURN } --- SQL -GRAPH FinGraph -MATCH (:Account)-[:Transfers]->(account:Account) -RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account -NEXT -MATCH (account:Account)<-[:Owns]-(owner:Person) -RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers +GRAPH FinGraph MATCH (:Account)-[:Transfers]->(account:Account) RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account NEXT MATCH (account:Account)<-[:Owns]-(owner:Person) RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers diff --git a/testdata/result/gql/offset_1.sql.txt b/testdata/result/gql/offset_1.sql.txt index 30427dab..81f6a471 100644 --- a/testdata/result/gql/offset_1.sql.txt +++ b/testdata/result/gql/offset_1.sql.txt @@ -110,7 +110,4 @@ RETURN p.name, p.id } --- SQL -GRAPH FinGraph -MATCH (p:Person) -OFFSET 2 -RETURN p.name, p.id +GRAPH FinGraph MATCH (p:Person) OFFSET 2 RETURN p.name, p.id diff --git a/testdata/result/gql/order_by.sql.txt b/testdata/result/gql/order_by.sql.txt index f8663c7f..2e6d8373 100644 --- a/testdata/result/gql/order_by.sql.txt +++ b/testdata/result/gql/order_by.sql.txt @@ -198,8 +198,4 @@ RETURN src_account.id AS account_id, transfer.amount AS transfer_amount } --- SQL -GRAPH FinGraph -MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account) -ORDER BY transfer.amount DESC -LIMIT 3 -RETURN src_account.id AS account_id, transfer.amount AS transfer_amount +GRAPH FinGraph MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account) ORDER BY transfer.amount DESC LIMIT 3 RETURN src_account.id AS account_id, transfer.amount AS transfer_amount diff --git a/testdata/result/gql/order_by_collate.sql.txt b/testdata/result/gql/order_by_collate.sql.txt index 72f06f61..93f121d3 100644 --- a/testdata/result/gql/order_by_collate.sql.txt +++ b/testdata/result/gql/order_by_collate.sql.txt @@ -110,7 +110,4 @@ GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE 'und:ci' RETURN a.name } --- SQL -GRAPH FinGraph -MATCH (a:Person) -ORDER BY a.name COLLATE "und:ci" -RETURN a.name +GRAPH FinGraph MATCH (a:Person) ORDER BY a.name COLLATE "und:ci" RETURN a.name diff --git a/testdata/result/gql/return.sql.txt b/testdata/result/gql/return.sql.txt index 4a88911f..f4283f44 100644 --- a/testdata/result/gql/return.sql.txt +++ b/testdata/result/gql/return.sql.txt @@ -282,9 +282,4 @@ ORDER BY num_incoming_transfers DESC } --- SQL -GRAPH FinGraph -MATCH (:Account)-[:Transfers]->(account:Account) -RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account -NEXT -MATCH (account:Account)<-[:Owns]-(owner:Person) -RETURN owner.name AS owner_name, num_incoming_transfers ORDER BY num_incoming_transfers DESC +GRAPH FinGraph MATCH (:Account)-[:Transfers]->(account:Account) RETURN account, COUNT(*) AS num_incoming_transfers GROUP BY account NEXT MATCH (account:Account)<-[:Owns]-(owner:Person) RETURN owner.name AS owner_name, num_incoming_transfers ORDER BY num_incoming_transfers DESC diff --git a/testdata/result/gql/return_array_subquery.sql.txt b/testdata/result/gql/return_array_subquery.sql.txt index cf31d377..995c812c 100644 --- a/testdata/result/gql/return_array_subquery.sql.txt +++ b/testdata/result/gql/return_array_subquery.sql.txt @@ -310,9 +310,4 @@ RETURN } --- SQL -GRAPH FinGraph -MATCH (p:Person)-[:Owns]->(account:Account) -RETURN p.name, account.id AS account_id, ARRAY { -MATCH (a:Account)-[transfer:Transfers]->(:Account) WHERE a = account -RETURN transfer.amount AS transfers -} AS transfers +GRAPH FinGraph MATCH (p:Person)-[:Owns]->(account:Account) RETURN p.name, account.id AS account_id, ARRAY {MATCH (a:Account)-[transfer:Transfers]->(:Account) WHERE a = account RETURN transfer.amount AS transfers} AS transfers diff --git a/testdata/result/gql/return_distinct.sql.txt b/testdata/result/gql/return_distinct.sql.txt index 27a7e4ab..32c1e9cf 100644 --- a/testdata/result/gql/return_distinct.sql.txt +++ b/testdata/result/gql/return_distinct.sql.txt @@ -207,6 +207,4 @@ RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id } --- SQL -GRAPH FinGraph -MATCH (src:Account {id: 7})-[e:Transfers]->{1,3}(dst:Account) -RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id +GRAPH FinGraph MATCH (src:Account {id: 7})-[e:Transfers]->{1,3}(dst:Account) RETURN DISTINCT ARRAY_LENGTH(e) AS hops, dst.id AS destination_account_id diff --git a/testdata/result/gql/return_exists_graph_pattern.sql.txt b/testdata/result/gql/return_exists_graph_pattern.sql.txt index d9ee8b27..46f78a18 100644 --- a/testdata/result/gql/return_exists_graph_pattern.sql.txt +++ b/testdata/result/gql/return_exists_graph_pattern.sql.txt @@ -150,7 +150,4 @@ RETURN EXISTS { } --- SQL -GRAPH FinGraph -RETURN EXISTS { -(p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%" -} AS results +GRAPH FinGraph RETURN EXISTS {(p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%"} AS results diff --git a/testdata/result/gql/return_exists_match.sql.txt b/testdata/result/gql/return_exists_match.sql.txt index 834872c3..a0356c3c 100644 --- a/testdata/result/gql/return_exists_match.sql.txt +++ b/testdata/result/gql/return_exists_match.sql.txt @@ -155,7 +155,4 @@ RETURN EXISTS { } --- SQL -GRAPH FinGraph -RETURN EXISTS { -MATCH (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%" -} AS results +GRAPH FinGraph RETURN EXISTS {MATCH (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%"} AS results diff --git a/testdata/result/gql/return_exists_query_expr.sql.txt b/testdata/result/gql/return_exists_query_expr.sql.txt index 9de69154..3d0b4254 100644 --- a/testdata/result/gql/return_exists_query_expr.sql.txt +++ b/testdata/result/gql/return_exists_query_expr.sql.txt @@ -201,8 +201,4 @@ RETURN EXISTS { } --- SQL -GRAPH FinGraph -RETURN EXISTS { -MATCH (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%" -RETURN p.Name LIMIT 1 -} AS results +GRAPH FinGraph RETURN EXISTS {MATCH (p:Person)-[o:Owns]->(a:Account) WHERE p.Name LIKE "D%" RETURN p.Name LIMIT 1} AS results diff --git a/testdata/result/gql/return_in_gql_subquery.sql.txt b/testdata/result/gql/return_in_gql_subquery.sql.txt index 63fa4a63..2e9463c5 100644 --- a/testdata/result/gql/return_in_gql_subquery.sql.txt +++ b/testdata/result/gql/return_in_gql_subquery.sql.txt @@ -170,6 +170,4 @@ RETURN 'Dana' IN { } --- SQL -GRAPH FinGraph -RETURN "Dana" IN {MATCH (p:Person)-[o:Owns]->(a:Account) -RETURN p.name} AS results +GRAPH FinGraph RETURN "Dana" IN {MATCH (p:Person)-[o:Owns]->(a:Account) RETURN p.name} AS results diff --git a/testdata/result/gql/return_offset_limit.sql.txt b/testdata/result/gql/return_offset_limit.sql.txt index 4485c428..ad1e4ee7 100644 --- a/testdata/result/gql/return_offset_limit.sql.txt +++ b/testdata/result/gql/return_offset_limit.sql.txt @@ -122,6 +122,4 @@ LIMIT 1 } --- SQL -GRAPH FinGraph -MATCH (p:Person) -RETURN p.name, p.id OFFSET 1 LIMIT 1 +GRAPH FinGraph MATCH (p:Person) RETURN p.name, p.id OFFSET 1 LIMIT 1 diff --git a/testdata/result/gql/return_value_subquery.sql.txt b/testdata/result/gql/return_value_subquery.sql.txt index d3006959..dae5de82 100644 --- a/testdata/result/gql/return_value_subquery.sql.txt +++ b/testdata/result/gql/return_value_subquery.sql.txt @@ -153,8 +153,4 @@ RETURN VALUE { } --- SQL -GRAPH FinGraph -RETURN VALUE { -MATCH (p:Person) WHERE p.name LIKE "%e%" -RETURN p.name LIMIT 1 -} AS results +GRAPH FinGraph RETURN VALUE {MATCH (p:Person) WHERE p.name LIKE "%e%" RETURN p.name LIMIT 1} AS results diff --git a/testdata/result/gql/skip_1.sql.txt b/testdata/result/gql/skip_1.sql.txt index 4200fada..da65cb57 100644 --- a/testdata/result/gql/skip_1.sql.txt +++ b/testdata/result/gql/skip_1.sql.txt @@ -111,7 +111,4 @@ RETURN p.name, p.id } --- SQL -GRAPH FinGraph -MATCH (p:Person) -SKIP 2 -RETURN p.name, p.id +GRAPH FinGraph MATCH (p:Person) SKIP 2 RETURN p.name, p.id diff --git a/testdata/result/gql/with_1.sql.txt b/testdata/result/gql/with_1.sql.txt index 739d518f..0b7c91a2 100644 --- a/testdata/result/gql/with_1.sql.txt +++ b/testdata/result/gql/with_1.sql.txt @@ -178,7 +178,4 @@ RETURN account.id AS account_id, num_incoming_transfers } --- SQL -GRAPH FinGraph -MATCH (:Account)-[:Transfers]->(account:Account) -WITH account, COUNT(*) AS num_incoming_transfers GROUP BY account -RETURN account.id AS account_id, num_incoming_transfers +GRAPH FinGraph MATCH (:Account)-[:Transfers]->(account:Account) WITH account, COUNT(*) AS num_incoming_transfers GROUP BY account RETURN account.id AS account_id, num_incoming_transfers diff --git a/testdata/result/query/select_from_graph_table.sql.txt b/testdata/result/query/select_from_graph_table.sql.txt index 1b9f51bf..8864740f 100644 --- a/testdata/result/query/select_from_graph_table.sql.txt +++ b/testdata/result/query/select_from_graph_table.sql.txt @@ -56,7 +56,4 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) } --- SQL -SELECT * FROM GRAPH_TABLE( -FinGraph -RETURN 1 AS a -) +SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) diff --git a/testdata/result/query/select_in_gql_subquery.sql.txt b/testdata/result/query/select_in_gql_subquery.sql.txt index 3adc9ce8..e446eb6e 100644 --- a/testdata/result/query/select_in_gql_subquery.sql.txt +++ b/testdata/result/query/select_in_gql_subquery.sql.txt @@ -160,6 +160,4 @@ SELECT 'Dana' IN { } --- SQL -SELECT "Dana" IN {GRAPH FinGraph -MATCH (p:Person)-[o:Owns]->(a:Account) -RETURN p.name} AS results +SELECT "Dana" IN {GRAPH FinGraph MATCH (p:Person)-[o:Owns]->(a:Account) RETURN p.name} AS results diff --git a/testdata/result/statement/select_from_graph_table.sql.txt b/testdata/result/statement/select_from_graph_table.sql.txt index 1b9f51bf..8864740f 100644 --- a/testdata/result/statement/select_from_graph_table.sql.txt +++ b/testdata/result/statement/select_from_graph_table.sql.txt @@ -56,7 +56,4 @@ SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) } --- SQL -SELECT * FROM GRAPH_TABLE( -FinGraph -RETURN 1 AS a -) +SELECT * FROM GRAPH_TABLE(FinGraph RETURN 1 AS a) diff --git a/testdata/result/statement/select_in_gql_subquery.sql.txt b/testdata/result/statement/select_in_gql_subquery.sql.txt index 3adc9ce8..e446eb6e 100644 --- a/testdata/result/statement/select_in_gql_subquery.sql.txt +++ b/testdata/result/statement/select_in_gql_subquery.sql.txt @@ -160,6 +160,4 @@ SELECT 'Dana' IN { } --- SQL -SELECT "Dana" IN {GRAPH FinGraph -MATCH (p:Person)-[o:Owns]->(a:Account) -RETURN p.name} AS results +SELECT "Dana" IN {GRAPH FinGraph MATCH (p:Person)-[o:Owns]->(a:Account) RETURN p.name} AS results