Add modulo operator to query language

Author: [email protected]

src/main/java/com/google/visualization/datasource/query/parser/QueryParser.jj

@@ -58,6 +58,7 @@ import com.google.visualization.datasource.query.scalarfunction.CurrentDateTime;
 import com.google.visualization.datasource.query.scalarfunction.DateDiff;
 import com.google.visualization.datasource.query.scalarfunction.Difference;
 import com.google.visualization.datasource.query.scalarfunction.Lower;
+import com.google.visualization.datasource.query.scalarfunction.Modulo;
 import com.google.visualization.datasource.query.scalarfunction.Product;
 import com.google.visualization.datasource.query.scalarfunction.Quotient;
 import com.google.visualization.datasource.query.scalarfunction.ScalarFunction;
@@ -192,6 +193,7 @@ TOKEN:
   | <OP_PLUS:              "+">
   | <OP_MINUS:             "-">
   | <OP_SLASH:             "/">
+  | <OP_MODULO:            "%">
 }
 
 // The entire query
@@ -592,36 +594,36 @@ AbstractColumn arithmeticExpression() throws InvalidQueryException :
   AbstractColumn column;
 }
 {
-  column = possibleSummationOrSubtraction()
+  column = possibleSecondOrderArithmeticExpression()
   { return column; }
 }
 
 // A possible sum or subtraction expression of possible multiplication or division expressions.
 // It is "possible" because it can also match a single expression without any
 // multiplications and divisions, and then it is just returned as is.
-AbstractColumn possibleSummationOrSubtraction() throws
+AbstractColumn possibleSecondOrderArithmeticExpression() throws
     InvalidQueryException :
 {
   AbstractColumn column;
   AbstractColumn column1;
 }
 {
-  column = possibleMultiplicationOrDivision()
+  column = possibleFirstOrderArithmeticExpression()
   (
-  ( (<OP_PLUS> column1 = possibleMultiplicationOrDivision() {
+  ( (<OP_PLUS> column1 = possibleFirstOrderArithmeticExpression() {
     column =
       new ScalarFunctionColumn(GenericsHelper.makeAbstractColumnList(
           new AbstractColumn[] {column, column1}), Sum.getInstance() );} )
-  | (<OP_MINUS> column1 = possibleMultiplicationOrDivision() {
+  | (<OP_MINUS> column1 = possibleFirstOrderArithmeticExpression() {
     column =
       new ScalarFunctionColumn(GenericsHelper.makeAbstractColumnList(
           new AbstractColumn[]{column, column1}),
           Difference.getInstance()); } ) ) )*
   { return column; }
 }
 
-// A possible multiplication or division expression of atomic abstract column descriptors.
-AbstractColumn possibleMultiplicationOrDivision() throws
+// A possible multiplication division or modulo expression of atomic abstract column descriptors.
+AbstractColumn possibleFirstOrderArithmeticExpression() throws
     InvalidQueryException :
 {
   AbstractColumn column;
@@ -638,7 +640,12 @@ AbstractColumn possibleMultiplicationOrDivision() throws
     column =
       new ScalarFunctionColumn(GenericsHelper.makeAbstractColumnList(
           new AbstractColumn[]{column, column1}),
-          Quotient.getInstance()); } ) ) )*
+          Quotient.getInstance()); } )
+  | (<OP_MODULO> column1 = atomicAbstractColumnDescriptor() {
+    column =
+      new ScalarFunctionColumn(GenericsHelper.makeAbstractColumnList(
+          new AbstractColumn[]{column, column1}),
+          Modulo.getInstance()); } ) ) )*
   { return column; }
 }
 

src/main/java/com/google/visualization/datasource/query/scalarfunction/Modulo.java

@@ -0,0 +1,124 @@
+// Copyright 2010 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.visualization.datasource.query.scalarfunction;
+
+import com.google.visualization.datasource.base.InvalidQueryException;
+import com.google.visualization.datasource.datatable.value.NumberValue;
+import com.google.visualization.datasource.datatable.value.Value;
+import com.google.visualization.datasource.datatable.value.ValueType;
+
+import java.util.List;
+
+/**
+ * The binary scalar function modulo().
+ * Returns the modulo between two number values.
+ *
+ * @author Roee E.
+ */
+public class Modulo implements ScalarFunction {
+  
+  /**
+   * The name of this function.
+   */
+  private static final String FUNCTION_NAME = "modulo";
+
+  /**
+   *  A singleton instance of this class.
+   */
+  private static final Modulo INSTANCE = new Modulo();
+
+  /**
+   * A private constructor, to prevent instantiation other than by the singleton.
+   */
+  private Modulo() {}
+
+  /**
+   * Returns the singleton instance of this class.
+   *
+   * @return The singleton instance of this class.
+   */
+  public static Modulo getInstance() {
+    return INSTANCE;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public String getFunctionName() {
+    return FUNCTION_NAME;
+  }
+
+  /**
+   * Executes a binary scalar function modulo() between the first and the second
+   * values in the list. Returns the modulo between the given values. All values
+   * are number values. The method does not validate the parameters,
+   * the user must check the parameters before calling this method.
+   *
+   * @param values A list of values on which the scalar function is performed.
+   *
+   *
+   * @return Value with the modulo between two given values, or number null value
+   *     if one of the values is null.
+   */
+  public Value evaluate(List<Value> values) {
+    if (values.get(0).isNull() || values.get(1).isNull()) {
+      return NumberValue.getNullValue();
+    }
+    double modulo = ((NumberValue) values.get(0)).getValue() %
+        ((NumberValue) values.get(1)).getValue();
+    return new NumberValue(modulo);
+  }
+
+  /**
+   * Returns the return type of the function. In this case, NUMBER. The method
+   * does not validate the parameters, the user must check the parameters
+   * before calling this method.
+   *
+   * @param types A list of the types of the scalar function parameters.
+   *
+   * @return The type of the returned value: Number.
+   */
+  public ValueType getReturnType(List<ValueType> types) {
+    return ValueType.NUMBER;
+  }
+
+  /**
+   * Validates that all function parameters are of type NUMBER, and that there
+   * are exactly 2 parameters. Throws a ScalarFunctionException otherwise.
+   *
+   * @param types A list with parameters types.
+   *
+   * @throws InvalidQueryException Thrown if the parameters are invalid.
+   */
+  public void validateParameters(List<ValueType> types) throws InvalidQueryException {
+    if (types.size() != 2) {
+      throw new InvalidQueryException("The function " + FUNCTION_NAME
+          + " requires 2 parmaeters ");
+    }
+    for (ValueType type : types) {
+      if (type != ValueType.NUMBER) {
+        throw new InvalidQueryException("Can't perform the function "
+            + FUNCTION_NAME + " on values that are not numbers");
+      }
+    }
+  }
+  
+  /**
+   * {@inheritDoc}
+   */
+  public String toQueryString(List<String> argumentsQueryStrings) {
+    return "(" + argumentsQueryStrings.get(0) + " % " + argumentsQueryStrings.get(1) + ")"; 
+  }
+}

src/test/java/com/google/visualization/datasource/query/engine/QueryEngineTest.java

@@ -46,6 +46,7 @@
 import com.google.visualization.datasource.query.scalarfunction.Constant;
 import com.google.visualization.datasource.query.scalarfunction.DateDiff;
 import com.google.visualization.datasource.query.scalarfunction.Difference;
+import com.google.visualization.datasource.query.scalarfunction.Modulo;
 import com.google.visualization.datasource.query.scalarfunction.Product;
 import com.google.visualization.datasource.query.scalarfunction.Quotient;
 import com.google.visualization.datasource.query.scalarfunction.Sum;
@@ -1339,6 +1340,103 @@ public void testFilterArithmeticExpression() throws Exception {
         resultStrings[1]);
   }
 
+  public void testModuloInSelection() throws Exception {
+    DataTable res = MockDataSource.getData(0);
+
+    // selection with modulo ('weight' is a column id): "select weight, weight % 10"
+    Query q = new Query();
+
+    AbstractColumn col1 = new ScalarFunctionColumn(
+        Lists.<AbstractColumn>newArrayList(), new Constant(new NumberValue(10)));
+    AbstractColumn col2 = new ScalarFunctionColumn(
+        Lists.<AbstractColumn>newArrayList(new SimpleColumn("weight"), col1),
+        Modulo.getInstance());
+
+    // Add selection
+    QuerySelection selection = new QuerySelection();
+    selection.addColumn(new SimpleColumn("weight"));
+    selection.addColumn(col2);
+    q.setSelection(selection);
+    
+    q.validate();
+
+    DataTable result = QueryEngine.executeQuery(q, res, ULocale.US);
+
+    // Test column description
+    List<ColumnDescription> cols =  result.getColumnDescriptions();
+
+    assertEquals(2, cols.size());
+    assertEquals("weight", cols.get(0).getId());
+    assertEquals("modulo_weight,10.0_", cols.get(1).getId());
+
+    String[][] resultStrings = MockDataSource.queryResultToStringMatrix(result);
+    assertEquals(7, resultStrings.length);
+
+    assertStringArraysEqual(new String[]{"222.0", "2.0"},
+        resultStrings[0]);
+    assertStringArraysEqual(new String[]{"111.0", "1.0"},
+        resultStrings[1]);
+    assertStringArraysEqual(new String[]{"333.0", "3.0"},
+        resultStrings[2]);
+    assertStringArraysEqual(new String[]{"222.0", "2.0"},
+        resultStrings[3]);
+    assertStringArraysEqual(new String[]{"1234.0", "4.0"},
+        resultStrings[4]);
+    assertStringArraysEqual(new String[]{"1234.0", "4.0"},
+        resultStrings[5]);
+    assertStringArraysEqual(new String[]{"222.0", "2.0"},
+        resultStrings[6]);   
+  }
+  
+  public void testModuloInFilter() throws Exception {
+    DataTable res = MockDataSource.getData(0);
+
+    // Create a query with filter clause using module:
+    // select name, weight where weight%2=0.0
+    Query q = new Query();
+
+    // Add selection
+    QuerySelection selection = new QuerySelection();
+    selection.addColumn(new SimpleColumn("name"));
+    selection.addColumn(new SimpleColumn("weight"));
+    q.setSelection(selection);
+
+    AbstractColumn col1 = new ScalarFunctionColumn(
+      Lists.<AbstractColumn>newArrayList(), new Constant(new NumberValue(2)));
+    AbstractColumn col2 = new ScalarFunctionColumn(
+      Lists.<AbstractColumn>newArrayList(new SimpleColumn("weight"), col1),
+      Modulo.getInstance());
+
+    QueryFilter filter = new ColumnValueFilter(col2,
+      new NumberValue(0), ComparisonFilter.Operator.EQ);
+    q.setFilter(filter);
+  
+    q.validate();
+
+    DataTable result = QueryEngine.executeQuery(q, res, ULocale.US);
+
+    // Test column description
+    List<ColumnDescription> cols =  result.getColumnDescriptions();
+
+    assertEquals(2, cols.size());
+    assertEquals("name", cols.get(0).getId());
+    assertEquals("weight", cols.get(1).getId());
+
+    String[][] resultStrings = MockDataSource.queryResultToStringMatrix(result);
+    assertEquals(5, resultStrings.length);
+
+    assertStringArraysEqual(new String[]{"aaa", "222.0"},
+        resultStrings[0]);
+    assertStringArraysEqual(new String[]{"ddd", "222.0"},
+        resultStrings[1]);
+    assertStringArraysEqual(new String[]{"eee", "1234.0"},
+        resultStrings[2]);
+    assertStringArraysEqual(new String[]{"eee", "1234.0"},
+        resultStrings[3]);
+    assertStringArraysEqual(new String[]{"bbb", "222.0"},
+        resultStrings[4]);
+  }
+
   public void testLabels() throws Exception {
     Query query = new Query();