Implement HAVING MIN/MAX and RESPECT/IGNORE NULLS (#154)

* Implement aggregate functions calls(IGNORE/RESPECT NULLS, HAVING MIN/MAX) * Add testdata aggregate_function_calls.sql * Do go test --update * Fix some placement * Update ast/ast.go Co-authored-by: Hiroya Fujinami <[email protected]> --------- Co-authored-by: Hiroya Fujinami <[email protected]>
cloudspannerecosystem · Oct 20, 2024 · 90f4dcb · 90f4dcb
1 parent 60438f4
commit 90f4dcb
Show file tree

Hide file tree

Showing 27 changed files with 625 additions and 48 deletions.
diff --git a/ast/ast.go b/ast/ast.go
@@ -176,6 +176,24 @@ func (ExprArg) isArg()     {}
 func (IntervalArg) isArg() {}
 func (SequenceArg) isArg() {}
 
+// NullHandlingModifier represents IGNORE/RESPECT NULLS of aggregate function calls
+type NullHandlingModifier interface {
+	Node
+	isNullHandlingModifier()
+}
+
+func (IgnoreNulls) isNullHandlingModifier()  {}
+func (RespectNulls) isNullHandlingModifier() {}
+
+// HavingModifier represents HAVING clause of aggregate function calls.
+type HavingModifier interface {
+	Node
+	isHavingModifier()
+}
+
+func (HavingMax) isHavingModifier() {}
+func (HavingMin) isHavingModifier() {}
+
 // InCondition is right-side value of IN operator.
 type InCondition interface {
 	Node
@@ -989,17 +1007,26 @@ type IndexExpr struct {
 
 // CallExpr is function call expression node.
 //
-//	{{.Func | sql}}({{if .Distinct}}DISTINCT{{end}} {{.Args | sqlJoin ", "}}{{if len(.Args) > 0 && len(.NamedArgs) > 0}}, {{end}}{{.NamedArgs || sqlJoin ", "}})
+//		{{.Func | sql}}(
+//		{{if .Distinct}}DISTINCT{{end}}
+//		{{.Args | sqlJoin ", "}}
+//		{{if len(.Args) > 0 && len(.NamedArgs) > 0}}, {{end}}
+//		{{.NamedArgs | sqlJoin ", "}}
+//	    {{.NullHandling | sqlOpt}}
+//	    {{.Having | sqlOpt}}
+//		)
 type CallExpr struct {
 	// pos = Func.pos
 	// end = Rparen + 1
 
 	Rparen token.Pos // position of ")"
 
-	Func      *Ident
-	Distinct  bool
-	Args      []Arg
-	NamedArgs []*NamedArg
+	Func         *Ident
+	Distinct     bool
+	Args         []Arg
+	NamedArgs    []*NamedArg
+	NullHandling NullHandlingModifier // optional
+	Having       HavingModifier       // optional
 }
 
 // ExprArg is argument of the generic function call.
@@ -1048,6 +1075,50 @@ type NamedArg struct {
 	Value Expr
 }
 
+// IgnoreNulls represents IGNORE NULLS of aggregate function calls.
+//
+//	IGNORE NULLS
+type IgnoreNulls struct {
+	// pos = Ignore
+	// end = Nulls + 5
+
+	Ignore token.Pos
+	Nulls  token.Pos
+}
+
+// RespectNulls represents RESPECT NULLS of aggregate function calls
+//
+//	RESPECT NULLS
+type RespectNulls struct {
+	// pos = Respect
+	// end = Nulls + 5
+
+	Respect token.Pos
+	Nulls   token.Pos
+}
+
+// HavingMax represents HAVING MAX of aggregate function calls.
+//
+//	HAVING MAX {{Expr | sql}}
+type HavingMax struct {
+	// pos = Having
+	// end = Expr.end
+
+	Having token.Pos
+	Expr   Expr
+}
+
+// HavingMin represents HAVING MIN of aggregate function calls.
+//
+//	HAVING MIN {{Expr | sql}}
+type HavingMin struct {
+	// pos = Having
+	// end = Expr.end
+
+	Having token.Pos
+	Expr   Expr
+}
+
 // CountStarExpr is node just for COUNT(*).
 //
 //	COUNT(*)

diff --git a/ast/pos.go b/ast/pos.go
@@ -367,6 +367,18 @@ func (s *SequenceArg) End() token.Pos { return s.Expr.End() }
 func (n *NamedArg) Pos() token.Pos { return n.Name.Pos() }
 func (n *NamedArg) End() token.Pos { return n.Value.End() }
 
+func (i *IgnoreNulls) Pos() token.Pos { return i.Ignore }
+func (i *IgnoreNulls) End() token.Pos { return i.Nulls + 5 }
+
+func (r *RespectNulls) Pos() token.Pos { return r.Respect }
+func (r *RespectNulls) End() token.Pos { return r.Nulls + 5 }
+
+func (h *HavingMax) Pos() token.Pos { return h.Having }
+func (h *HavingMax) End() token.Pos { return h.Expr.End() }
+
+func (h *HavingMin) Pos() token.Pos { return h.Having }
+func (h *HavingMin) End() token.Pos { return h.Expr.End() }
+
 func (c *CountStarExpr) Pos() token.Pos { return c.Count }
 func (c *CountStarExpr) End() token.Pos { return c.Rparen + 1 }
 

diff --git a/ast/sql.go b/ast/sql.go
@@ -506,11 +506,21 @@ func (c *CallExpr) SQL() string {
 		sqlJoin(c.Args, ", ") +
 		strOpt(len(c.Args) > 0 && len(c.NamedArgs) > 0, ", ") +
 		sqlJoin(c.NamedArgs, ", ") +
+		sqlOpt(" ", c.NullHandling, "") +
+		sqlOpt(" ", c.Having, "") +
 		")"
 }
 
 func (n *NamedArg) SQL() string { return n.Name.SQL() + " => " + n.Value.SQL() }
 
+func (i *IgnoreNulls) SQL() string { return "IGNORE NULLS" }
+
+func (r *RespectNulls) SQL() string { return "RESPECT NULLS" }
+
+func (h *HavingMax) SQL() string { return "HAVING MAX " + h.Expr.SQL() }
+
+func (h *HavingMin) SQL() string { return "HAVING MIN " + h.Expr.SQL() }
+
 func (s *ExprArg) SQL() string {
 	return s.Expr.SQL()
 }

diff --git a/parser.go b/parser.go
@@ -1492,15 +1492,21 @@ func (p *Parser) parseCall(id token.Token) ast.Expr {
 		p.nextToken()
 	}
 
+	nullHandling := p.tryParseNullHandlingModifier()
+	having := p.tryParseHavingModifier()
+
 	rparen := p.expect(")").Pos
 	return &ast.CallExpr{
-		Rparen:    rparen,
-		Func:      fn,
-		Distinct:  distinct,
-		Args:      args,
-		NamedArgs: namedArgs,
+		Rparen:       rparen,
+		Func:         fn,
+		Distinct:     distinct,
+		Args:         args,
+		NamedArgs:    namedArgs,
+		NullHandling: nullHandling,
+		Having:       having,
 	}
 }
+
 func (p *Parser) lookaheadNamedArg() bool {
 	lexer := p.Lexer.Clone()
 	defer func() {
@@ -1574,6 +1580,58 @@ func (p *Parser) parseExprArg() *ast.ExprArg {
 	}
 }
 
+func (p *Parser) tryParseHavingModifier() ast.HavingModifier {
+	if p.Token.Kind != "HAVING" {
+		return nil
+	}
+
+	having := p.expect("HAVING").Pos
+
+	switch {
+	case p.Token.IsKeywordLike("MIN"):
+		p.nextToken()
+		expr := p.parseExpr()
+
+		return &ast.HavingMin{
+			Having: having,
+			Expr:   expr,
+		}
+	case p.Token.IsKeywordLike("MAX"):
+		p.nextToken()
+		expr := p.parseExpr()
+
+		return &ast.HavingMax{
+			Having: having,
+			Expr:   expr,
+		}
+	default:
+		panic(p.errorfAtToken(&p.Token, `expect MIN or MAX, but: %v`, p.Token.Kind))
+	}
+}
+
+func (p *Parser) tryParseNullHandlingModifier() ast.NullHandlingModifier {
+	switch p.Token.Kind {
+	case "IGNORE":
+		ignore := p.expect("IGNORE").Pos
+		nulls := p.expect("NULLS").Pos
+
+		return &ast.IgnoreNulls{
+			Ignore: ignore,
+			Nulls:  nulls,
+		}
+	case "RESPECT":
+		respect := p.expect("RESPECT").Pos
+		nulls := p.expect("NULLS").Pos
+
+		return &ast.RespectNulls{
+			Respect: respect,
+			Nulls:   nulls,
+		}
+	default:
+		return nil
+	}
+}
+
 func (p *Parser) parseCaseExpr() *ast.CaseExpr {
 	pos := p.expect("CASE").Pos
 	var expr ast.Expr

diff --git a/testdata/input/query/aggregate_function_calls.sql b/testdata/input/query/aggregate_function_calls.sql
@@ -0,0 +1,6 @@
+SELECT
+    ARRAY_AGG(inches HAVING MAX year),
+    ARRAY_AGG(inches HAVING MIN year),
+    ARRAY_AGG(inches IGNORE NULLS),
+    ARRAY_AGG(inches RESPECT NULLS),
+    ARRAY_AGG(inches RESPECT NULLS HAVING MAX year),
diff --git a/testdata/result/ddl/alter_table_add_column_with_if_expression.sql.txt b/testdata/result/ddl/alter_table_add_column_with_if_expression.sql.txt
@@ -99,7 +99,9 @@ ALTER TABLE foo ADD COLUMN expired_at TIMESTAMP AS (IF (status != "OPEN" AND sta
                     },
                   },
                 },
-                NamedArgs: []*ast.NamedArg(nil),
+                NamedArgs:    []*ast.NamedArg(nil),
+                NullHandling: nil,
+                Having:       nil,
               },
             },
             &ast.ExprArg{
@@ -108,7 +110,9 @@ ALTER TABLE foo ADD COLUMN expired_at TIMESTAMP AS (IF (status != "OPEN" AND sta
               },
             },
           },
-          NamedArgs: []*ast.NamedArg(nil),
+          NamedArgs:    []*ast.NamedArg(nil),
+          NullHandling: nil,
+          Having:       nil,
         },
       },
       Options: (*ast.Options)(nil),

diff --git a/testdata/result/ddl/create_table.sql.txt b/testdata/result/ddl/create_table.sql.txt
@@ -144,7 +144,9 @@ create table foo (
               },
             },
           },
-          NamedArgs: []*ast.NamedArg(nil),
+          NamedArgs:    []*ast.NamedArg(nil),
+          NullHandling: nil,
+          Having:       nil,
         },
       },
       Options: (*ast.Options)(nil),
@@ -187,9 +189,11 @@ create table foo (
             NameEnd: 546,
             Name:    "current_timestamp",
           },
-          Distinct:  false,
-          Args:      []ast.Arg(nil),
-          NamedArgs: []*ast.NamedArg(nil),
+          Distinct:     false,
+          Args:         []ast.Arg(nil),
+          NamedArgs:    []*ast.NamedArg(nil),
+          NullHandling: nil,
+          Having:       nil,
         },
       },
       GeneratedExpr: (*ast.GeneratedColumnExpr)(nil),

diff --git a/testdata/result/ddl/create_table_with_sequence_function.sql.txt b/testdata/result/ddl/create_table_with_sequence_function.sql.txt
@@ -50,7 +50,9 @@ CREATE TABLE foo
               },
             },
           },
-          NamedArgs: []*ast.NamedArg(nil),
+          NamedArgs:    []*ast.NamedArg(nil),
+          NullHandling: nil,
+          Having:       nil,
         },
       },
       GeneratedExpr: (*ast.GeneratedColumnExpr)(nil),

diff --git a/testdata/result/dml/insert_with_sequence_function.sql.txt b/testdata/result/dml/insert_with_sequence_function.sql.txt
@@ -45,7 +45,9 @@ INSERT INTO foo(bar) VALUES (GET_NEXT_SEQUENCE_VALUE(SEQUENCE my_sequence))
                   },
                 },
               },
-              NamedArgs: []*ast.NamedArg(nil),
+              NamedArgs:    []*ast.NamedArg(nil),
+              NullHandling: nil,
+              Having:       nil,
             },
           },
         },