Feature #72: Support aggregate and analytics functions

doc/changes/changelog.md

@@ -1,6 +1,6 @@
 # Changes
 
-* [4.4.3](changes_4.4.3.md)
+* [4.5.0](changes_4.5.0.md)
 * [4.4.2](changes_4.4.2.md)
 * [4.4.1](changes_4.4.1.md)
 * [4.4.0](changes_4.4.0.md)

doc/changes/changes_4.4.3.md → doc/changes/changes_4.5.0.md

@@ -1,6 +1,16 @@
-# Exasol SQL Statement Builder 4.4.3, released 2021-09-??
+# Exasol SQL Statement Builder 4.5.0, released 2021-09-??
 
-Code name: Internal refactorings on "More Predicates"
+Code name: Support more Aggregate and Analytic functions
+
+## Summary
+
+This release supports all aggregate and analytics functsions provided by Exasol, e.g. `GROUPING[_ID]`, `PERCENTILE_CONT`, `NTH_VALUE` and many more. See the [ticket](https://github.com/exasol/sql-statement-builder/issues/72) for a complete list.
+
+We also addes support for the keywords `DISTINCT` and `ANY` as well as the [over_clause](https://docs.exasol.com/sql_references/functions/analyticfunctions.htm?Highlight=over_clause) for analytic functions.
+
+## Features
+
+* #72: Added support for more Aggregate and Analytic functions
 
 ## Refactoring
 

doc/user_guide/statements/select.md

@@ -70,6 +70,8 @@ A udf takes a name of function and any number of [`ValueExpression`](../../../sr
     selectWithEmits.from().table("people");
     ```
 
+- To add special functions (e.g. analytic functions) to a statement you can use the `function()` method that takes a `Function` as argument. See the [section about creating functions](#creating-functions) for details.
+
 - An `arithmetic expression` is a binary value expression using one of the following arithmetic operators: `+`, `-`, `*`, `/`.
 Add an arithmetic expression using an `arithmeticExpression( ... )` method. You can also set a name for a derived field that contains an arithmetic expression. 
 
@@ -165,3 +167,29 @@ select.from().table("t");
 select.orderBy(column("t", "city"), column("t", "price"))
         .nullsFirst().asc();
 ```
+
+## Creating Functions
+
+When you need to use special functions like analytic functions, you can add them to a statement like this:
+
+```java
+Function function = ... // create function
+Select select = factory.select().function(function, "<column>");
+```
+
+### Analytic functions
+
+#### Keywords `DISTINCT` and `ALL`
+
+You create an analytic function with a keyword `DISTINCT` or `ALL` like this:
+
+```java
+Function function = AnalyticFunction.of(ExasolAnalyticFunction.ANY, Keyword.DISTINCT,
+    BooleanTerm.lt(column("age"), integerLiteral(30)));
+```
+
+This will render to the following SQL code:
+
+```sql
+SELECT ANY(DISTINCT(age < 30))
+```

pom.xml

@@ -4,7 +4,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.exasol</groupId>
     <artifactId>sql-statement-builder</artifactId>
-    <version>4.4.3</version>
+    <version>4.5.0</version>
     <name>Exasol SQL Statement Builder</name>
     <description>This module provides a Builder for SQL statements that helps creating the correct structure and
         validates variable parts of the statements.
@@ -65,6 +65,11 @@
         </repository>
     </repositories>
     <dependencies>
+        <dependency>
+            <groupId>com.exasol</groupId>
+            <artifactId>error-reporting-java</artifactId>
+            <version>0.4.0</version>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>

src/main/java/com/exasol/sql/dql/select/GroupByClause.java

@@ -15,11 +15,12 @@ public class GroupByClause extends AbstractFragment implements SelectFragment {
     private final SqlStatement rootStatement;
     private final List<ColumnReference> columnReferences;
     private BooleanExpression booleanExpression;
+    private WindowClause windowClause;
 
     /**
      * Create a new instance of a {@link GroupByClause}.
      *
-     * @param rootStatement SQL statement this {@code GROUP BY} clause belongs to
+     * @param rootStatement    SQL statement this {@code GROUP BY} clause belongs to
      * @param columnReferences column references for the {@code GROUP BY} clause
      */
     public GroupByClause(final SqlStatement rootStatement, final ColumnReference... columnReferences) {
@@ -54,11 +55,42 @@ public Select having(final BooleanExpression booleanExpression) {
     }
 
     /**
-     * Get the boolean expression.
+     * Get the "having" boolean expression.
      *
-     * @return boolean expression
+     * @return "having" boolean expression
      */
     public BooleanExpression getHavingBooleanExpression() {
         return this.booleanExpression;
     }
+
+    /**
+     * Add a window clause to the having statement. Return the existing window clause if one was added before.
+     *
+     * @return the {@link WindowClause} for fluent programming
+     */
+    public WindowClause window() {
+        if (this.windowClause == null) {
+            this.windowClause = WindowClause.of(this.root);
+        }
+        return this.windowClause;
+    }
+
+    /**
+     * Add the given window clause to the having statement.
+     *
+     * @return this {@link GroupByClause} for fluent programming
+     */
+    public GroupByClause window(final WindowClause windowClause) {
+        this.windowClause = windowClause;
+        return this;
+    }
+
+    /**
+     * Get the window clause of the "having" statement.
+     *
+     * @return the window clause
+     */
+    public WindowClause getWindowClause() {
+        return this.windowClause;
+    }
 }

src/main/java/com/exasol/sql/dql/select/Select.java

@@ -74,9 +74,7 @@ public Select function(final FunctionName functionName, final ValueExpression...
     public Select function(final FunctionName functionName, final String derivedColumnName,
             final ValueExpression... valueExpressions) {
         final Function function = ExpressionTerm.function(functionName, valueExpressions);
-        final DerivedColumn derivedColumn = new DerivedColumn(this, function, derivedColumnName);
-        this.derivedColumns.add(derivedColumn);
-        return this;
+        return this.function(function, derivedColumnName);
     }
 
     /**
@@ -99,8 +97,7 @@ public Select function(final Function function, final String derivedColumnName)
      * @return {@code this} instance for fluent programming
      */
     public Select function(final Function function) {
-        function(function, "");
-        return this;
+        return function(function, "");
     }
 
     /**
@@ -111,7 +108,6 @@ public Select function(final Function function) {
      * @param valueExpressions       zero or more value expressions
      * @return {@code this} instance for fluent programming
      */
-
     public Select udf(final String functionName, final ColumnsDefinition emitsColumnsDefinition,
             final ValueExpression... valueExpressions) {
         final Function udf = ExpressionTerm.udf(functionName, emitsColumnsDefinition, valueExpressions);

src/main/java/com/exasol/sql/dql/select/SelectVisitor.java

@@ -22,4 +22,6 @@ public interface SelectVisitor extends ValueTableVisitor {
     public void visit(DerivedColumn derivedColumn);
 
     public void visit(Table table);
+
+    public void visit(WindowClause windowClause);
 }

src/main/java/com/exasol/sql/dql/select/WindowClause.java

@@ -0,0 +1,23 @@
+package com.exasol.sql.dql.select;
+
+import com.exasol.sql.AbstractFragment;
+import com.exasol.sql.Fragment;
+
+/**
+ * This class represents the {@code WINDOW} clause following the {@code HAVING} clause of an SQL statement.
+ */
+public class WindowClause extends AbstractFragment implements SelectFragment {
+
+    private WindowClause(final Fragment root) {
+        super(root);
+    }
+
+    public static WindowClause of(final Fragment root) {
+        return new WindowClause(root);
+    }
+
+    @Override
+    public void accept(final SelectVisitor visitor) {
+        visitor.visit(this);
+    }
+}

src/main/java/com/exasol/sql/dql/select/rendering/SelectRenderer.java

@@ -2,10 +2,7 @@
 
 import java.util.List;
 
-import com.exasol.sql.DerivedColumn;
-import com.exasol.sql.Table;
-import com.exasol.sql.ValueTable;
-import com.exasol.sql.ValueTableRow;
+import com.exasol.sql.*;
 import com.exasol.sql.dql.select.*;
 import com.exasol.sql.expression.BooleanExpression;
 import com.exasol.sql.rendering.AbstractFragmentRenderer;
@@ -154,7 +151,7 @@ public void leave(final ValueTable valueTable) {
             final List<String> columnNameAliases = valueTable.getColumnNameAliases();
             for (int i = 0; i < columnNameAliases.size(); i++) {
                 appendAutoQuoted(columnNameAliases.get(i));
-                if (i < columnNameAliases.size() - 1) {
+                if (i < (columnNameAliases.size() - 1)) {
                     append(", ");
                 }
             }
@@ -177,6 +174,11 @@ public void leave(final ValueTableRow valueTableRow) {
         setLastVisited(valueTableRow);
     }
 
+    @Override
+    public void visit(final WindowClause windowClause) {
+        throw new UnsupportedOperationException("todo");
+    }
+
     /**
      * Create an {@link SelectRenderer} using the default renderer configuration
      *

src/main/java/com/exasol/sql/expression/function/FunctionVisitor.java

@@ -1,8 +1,6 @@
 package com.exasol.sql.expression.function;
 
-import com.exasol.sql.expression.function.exasol.CastExasolFunction;
-import com.exasol.sql.expression.function.exasol.ExasolFunction;
-import com.exasol.sql.expression.function.exasol.ExasolUdf;
+import com.exasol.sql.expression.function.exasol.*;
 
 /**
  * Visitor interface for {@link Function}.
@@ -13,4 +11,6 @@ public interface FunctionVisitor {
     public void visit(ExasolUdf function);
 
     public void visit(CastExasolFunction castFunction);
+
+    public void visit(AnalyticFunction analyticFunction);
 }

src/main/java/com/exasol/sql/expression/function/exasol/AnalyticFunction.java

@@ -0,0 +1,105 @@
+package com.exasol.sql.expression.function.exasol;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+
+import com.exasol.sql.expression.ValueExpression;
+import com.exasol.sql.expression.function.AbstractFunction;
+import com.exasol.sql.expression.function.FunctionVisitor;
+
+/**
+ * This class represents an analytic function in the Exasol database that supports keywords {@code DISTINCT} and
+ * {@code ALL} and the over clause.
+ */
+public class AnalyticFunction extends AbstractFunction {
+
+    public enum Keyword {
+        DISTINCT, ALL
+    }
+
+    private final Keyword keyword;
+    private OverClause overClause;
+
+    private AnalyticFunction(final ExasolAnalyticAggregateFunctions functionName, final Keyword keyword,
+            final List<ValueExpression> valueExpressions) {
+        super(functionName.toString(), valueExpressions);
+        this.keyword = keyword;
+    }
+
+    /**
+     * Create a new {@link AnalyticFunction} instance.
+     *
+     * @param functionName     name of the function
+     * @param valueExpressions zero or more value expressions
+     * @return new {@link AnalyticFunction}
+     */
+    public static AnalyticFunction of(final ExasolAnalyticAggregateFunctions functionName,
+            final ValueExpression... valueExpressions) {
+        return of(functionName, null, valueExpressions);
+    }
+
+    /**
+     * Create a new {@link AnalyticFunction} instance with a keyword.
+     *
+     * @param functionName     name of the function
+     * @param keyword          keyword used in the function
+     * @param valueExpressions zero or more value expressions
+     * @return new {@link AnalyticFunction}
+     */
+    public static AnalyticFunction of(final ExasolAnalyticAggregateFunctions functionName, final Keyword keyword,
+            final ValueExpression... valueExpressions) {
+        return new AnalyticFunction(functionName, keyword, Arrays.asList(valueExpressions));
+    }
+
+    /**
+     * Get the keyword for the function call, may be {@code null}.
+     *
+     * @return keyword for the function call
+     */
+    public Keyword getKeyword() {
+        return this.keyword;
+    }
+
+    /**
+     * Add the given over clause to the function call.
+     *
+     * @param overClause over clause to add
+     * @return this {@link AnalyticFunction} for fluent programming
+     */
+    public AnalyticFunction over(final OverClause overClause) {
+        this.overClause = overClause;
+        return this;
+    }
+
+    public OverClause over(final String windowName) {
+        return over(over -> over.windowName(windowName)).overClause;
+    }
+
+    public AnalyticFunction over(final Consumer<OverClause> consumer) {
+        if (this.overClause == null) {
+            this.overClause = new OverClause();
+        }
+        consumer.accept(this.overClause);
+        return this;
+    }
+
+    /**
+     * Get the "over clause" appended to the function call, may be {@code null}.
+     *
+     * @return "over clause" appended to the function call
+     */
+    public OverClause getOverClause() {
+        return this.overClause;
+    }
+
+    @Override
+    public boolean hasParenthesis() {
+        return true;
+    }
+
+    @Override
+    public void accept(final FunctionVisitor visitor) {
+        visitor.visit(this);
+    }
+}

src/main/java/com/exasol/sql/expression/function/exasol/ExasolAggregateFunction.java

@@ -5,11 +5,9 @@
 /**
  * This class is a list of Aggregate Functions that the Exasol database supports.
  *
- * <p>
- * Currently unsupported functions: GROUPING, PERCENTILE_CONT, PERCENTILE_DISC, OVER clause for all aggregate functions
- * and keywords. See <a href="https://github.com/exasol/sql-statement-builder/issues/72"> github issue # 72</a>.
- * </p>
+ * @deprecated Use enum {@link ExasolAnalyticAggregateFunctions}.
  */
+@Deprecated
 public enum ExasolAggregateFunction implements FunctionName {
     APPROXIMATE_COUNT_DISTINCT, AVG, CORR, COUNT, COVAR_POP, COVAR_SAMP, FIRST_VALUE, GROUP_CONCAT, LAST_VALUE, MAX,
     MEDIAN, MIN, REGR_SLOPE, REGR_INTERCEPT, REGR_COUNT, REGR_R2, REGR_AVGX, REGR_AVGY, REGR_SXX, REGR_SXY, REGR_SYY,