This is an automated email from the ASF dual-hosted git repository. xiangfu pushed a commit to branch support_case_when_statement in repository https://gitbox.apache.org/repos/asf/incubator-pinot.git
commit 83f81c157d3755aeaa3f26c777960219777a61af Author: Xiang Fu <fx19880...@gmail.com> AuthorDate: Wed May 27 22:15:59 2020 -0700 Adding transform function support for case-when-else --- .../common/function/TransformFunctionType.java | 8 + .../pinot/sql/parsers/CalciteSqlCompilerTest.java | 20 +- .../function/BinaryOperatorTransformFunction.java | 114 +++++ .../transform/function/CaseTransformFunction.java | 151 ++++++ .../function/EqualsTransformFunction.java | 41 ++ .../GreaterThanOrEqualTransformFunction.java | 49 ++ .../function/GreaterThanTransformFunction.java | 49 ++ .../function/LessThanOrEqualTransformFunction.java | 49 ++ .../function/LessThanTransformFunction.java | 49 ++ .../function/LiteralTransformFunction.java | 36 +- .../function/NotEqualsTransformFunction.java | 41 ++ .../function/TransformFunctionFactory.java | 9 + .../function/BaseTransformFunctionTest.java | 15 + .../BinaryOperatorTransformFunctionTest.java | 109 +++++ .../function/CaseTransformFunctionTest.java | 522 +++++++++++++++++++++ .../function/EqualsTransformFunctionTest.java | 52 ++ .../GreaterThanOrEqualTransformFunctionTest.java | 52 ++ .../function/GreaterThanTransformFunctionTest.java | 52 ++ .../LessThanOrEqualTransformFunctionTest.java | 52 ++ .../function/LessThanTransformFunctionTest.java | 52 ++ .../function/NotEqualsTransformFunctionTest.java | 52 ++ .../tests/OfflineClusterIntegrationTest.java | 31 +- 22 files changed, 1583 insertions(+), 22 deletions(-) diff --git a/pinot-common/src/main/java/org/apache/pinot/common/function/TransformFunctionType.java b/pinot-common/src/main/java/org/apache/pinot/common/function/TransformFunctionType.java index f8081ce..86d5c8d 100644 --- a/pinot-common/src/main/java/org/apache/pinot/common/function/TransformFunctionType.java +++ b/pinot-common/src/main/java/org/apache/pinot/common/function/TransformFunctionType.java @@ -38,7 +38,15 @@ public enum TransformFunctionType { LN("ln"), SQRT("sqrt"), + EQUALS("equals"), + NOT_EQUALS("not_equals"), + GREATER_THAN("greater_than"), + GREATER_THAN_OR_EQUAL("greater_than_or_equal"), + LESS_THAN("less_than"), + LESS_THAN_OR_EQUAL("less_than_or_equal"), + CAST("cast"), + CASE("case"), JSONEXTRACTSCALAR("jsonExtractScalar"), JSONEXTRACTKEY("jsonExtractKey"), TIMECONVERT("timeConvert"), diff --git a/pinot-common/src/test/java/org/apache/pinot/sql/parsers/CalciteSqlCompilerTest.java b/pinot-common/src/test/java/org/apache/pinot/sql/parsers/CalciteSqlCompilerTest.java index 80ef72b..b590be5 100644 --- a/pinot-common/src/test/java/org/apache/pinot/sql/parsers/CalciteSqlCompilerTest.java +++ b/pinot-common/src/test/java/org/apache/pinot/sql/parsers/CalciteSqlCompilerTest.java @@ -52,13 +52,9 @@ public class CalciteSqlCompilerTest { @Test public void testCaseWhenStatements() { PinotQuery pinotQuery = CalciteSqlParser.compileToPinotQuery( - "SELECT OrderID, Quantity,\n" - + "CASE\n" - + " WHEN Quantity > 30 THEN 'The quantity is greater than 30'\n" - + " WHEN Quantity = 30 THEN 'The quantity is 30'\n" - + " ELSE 'The quantity is under 30'\n" - + "END AS QuantityText\n" - + "FROM OrderDetails"); + "SELECT OrderID, Quantity,\n" + "CASE\n" + " WHEN Quantity > 30 THEN 'The quantity is greater than 30'\n" + + " WHEN Quantity = 30 THEN 'The quantity is 30'\n" + " ELSE 'The quantity is under 30'\n" + + "END AS QuantityText\n" + "FROM OrderDetails"); Assert.assertEquals(pinotQuery.getSelectList().get(0).getIdentifier().getName(), "OrderID"); Assert.assertEquals(pinotQuery.getSelectList().get(1).getIdentifier().getName(), "Quantity"); Function asFunc = pinotQuery.getSelectList().get(2).getFunctionCall(); @@ -79,14 +75,8 @@ public class CalciteSqlCompilerTest { Assert.assertEquals(caseFunc.getOperands().get(4).getLiteral().getFieldValue(), "The quantity is under 30"); pinotQuery = CalciteSqlParser.compileToPinotQuery( - "SELECT Quantity,\n" - + "SUM(CASE\n" - + " WHEN Quantity > 30 THEN 3\n" - + " WHEN Quantity > 20 THEN 2\n" - + " WHEN Quantity > 10 THEN 1\n" - + " ELSE 0\n" - + "END) AS new_sum_quant\n" - + "FROM OrderDetails"); + "SELECT Quantity,\n" + "SUM(CASE\n" + " WHEN Quantity > 30 THEN 3\n" + " WHEN Quantity > 20 THEN 2\n" + + " WHEN Quantity > 10 THEN 1\n" + " ELSE 0\n" + "END) AS new_sum_quant\n" + "FROM OrderDetails"); Assert.assertEquals(pinotQuery.getSelectList().get(0).getIdentifier().getName(), "Quantity"); asFunc = pinotQuery.getSelectList().get(1).getFunctionCall(); Assert.assertEquals(asFunc.getOperator(), SqlKind.AS.name()); diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/BinaryOperatorTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/BinaryOperatorTransformFunction.java new file mode 100644 index 0000000..69fcf61 --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/BinaryOperatorTransformFunction.java @@ -0,0 +1,114 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +import java.util.List; +import java.util.Map; +import org.apache.pinot.core.common.DataSource; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; +import org.apache.pinot.core.operator.transform.TransformResultMetadata; +import org.apache.pinot.core.plan.DocIdSetPlanNode; +import org.apache.pinot.spi.data.FieldSpec; +import org.apache.pinot.spi.utils.ByteArray; + + +/** + * <code>BinaryOperatorTransformFunction</code> abstracts common functions for binary operators (=, !=, >=, >, <=, <) + * The results are in boolean format and stored as an integer array with 1 represents true and 0 represents false. + * + */ +public abstract class BinaryOperatorTransformFunction extends BaseTransformFunction { + + protected TransformFunction _leftTransformFunction; + protected TransformFunction _rightTransformFunction; + protected int[] _results; + + @Override + public void init(List<TransformFunction> arguments, Map<String, DataSource> dataSourceMap) { + // Check that there are more than 1 arguments + if (arguments.size() != 2) { + throw new IllegalArgumentException("Exact 2 arguments are required for greater transform function"); + } + _leftTransformFunction = arguments.get(0); + _rightTransformFunction = arguments.get(1); + } + + @Override + public TransformResultMetadata getResultMetadata() { + return INT_SV_NO_DICTIONARY_METADATA; + } + + protected void fillResultArray(ProjectionBlock projectionBlock) { + if (_results == null) { + _results = new int[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + } + FieldSpec.DataType dataType = _leftTransformFunction.getResultMetadata().getDataType(); + int length = projectionBlock.getNumDocs(); + switch (dataType) { + case INT: + int[] leftIntValues = _leftTransformFunction.transformToIntValuesSV(projectionBlock); + int[] rightIntValues = _rightTransformFunction.transformToIntValuesSV(projectionBlock); + for (int i = 0; i < length; i++) { + _results[i] = getBinaryFuncResult(((Integer) leftIntValues[i]).compareTo(rightIntValues[i])); + } + break; + case LONG: + long[] leftLongValues = _leftTransformFunction.transformToLongValuesSV(projectionBlock); + long[] rightLongValues = _rightTransformFunction.transformToLongValuesSV(projectionBlock); + for (int i = 0; i < length; i++) { + _results[i] = getBinaryFuncResult(((Long) leftLongValues[i]).compareTo(rightLongValues[i])); + } + break; + case FLOAT: + float[] leftFloatValues = _leftTransformFunction.transformToFloatValuesSV(projectionBlock); + float[] rightFloatValues = _rightTransformFunction.transformToFloatValuesSV(projectionBlock); + for (int i = 0; i < length; i++) { + _results[i] = getBinaryFuncResult(((Float) leftFloatValues[i]).compareTo(rightFloatValues[i])); + } + break; + case DOUBLE: + double[] leftDoubleValues = _leftTransformFunction.transformToDoubleValuesSV(projectionBlock); + double[] rightDoubleValues = _rightTransformFunction.transformToDoubleValuesSV(projectionBlock); + for (int i = 0; i < length; i++) { + _results[i] = getBinaryFuncResult(((Double) leftDoubleValues[i]).compareTo(rightDoubleValues[i])); + } + break; + case STRING: + String[] leftStringValues = _leftTransformFunction.transformToStringValuesSV(projectionBlock); + String[] rightStringValues = _rightTransformFunction.transformToStringValuesSV(projectionBlock); + for (int i = 0; i < length; i++) { + _results[i] = getBinaryFuncResult(leftStringValues[i].compareTo(rightStringValues[i])); + } + break; + case BYTES: + byte[][] leftBytesValues = _leftTransformFunction.transformToBytesValuesSV(projectionBlock); + byte[][] rightBytesValues = _rightTransformFunction.transformToBytesValuesSV(projectionBlock); + for (int i = 0; i < length; i++) { + _results[i] = + getBinaryFuncResult((new ByteArray(leftBytesValues[i])).compareTo(new ByteArray(rightBytesValues[i]))); + } + break; + // NOTE: Multi-value columns are not comparable, so we should not reach here + default: + throw new IllegalStateException(); + } + } + + abstract int getBinaryFuncResult(int result); +} diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/CaseTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/CaseTransformFunction.java new file mode 100644 index 0000000..ccfb4d3 --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/CaseTransformFunction.java @@ -0,0 +1,151 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import org.apache.pinot.core.common.DataSource; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; +import org.apache.pinot.core.operator.transform.TransformResultMetadata; +import org.apache.pinot.core.plan.DocIdSetPlanNode; + + +/** + * The <code>CaseTransformFunction</code> class implements the CASE-WHEN-THEN-ELSE transformation. + * + * The SQL Syntax is: + * CASE + * WHEN condition1 THEN result1 + * WHEN condition2 THEN result2 + * WHEN conditionN THEN resultN + * ELSE result + * END; + * + * Usage: + * case(${WHEN_STATEMENT_1}, ..., ${WHEN_STATEMENT_N}, + * ${THEN_EXPRESSION_1}, ..., ${THEN_EXPRESSION_N}, + * ${ELSE_EXPRESSION}) + * + * There are 2 * N + 1 arguments: + * <code>WHEN_STATEMENT_$i</code> is a <code>BinaryOperatorTransformFunction</code> represents <code>condition$i</code> + * <code>THEN_EXPRESSION_$i</code> is a <code>LiteralTransformFunction</code> represents <code>result$i</code> + * <code>ELSE_EXPRESSION</code> is a <code>LiteralTransformFunction</code> represents <code>result</code> + * + */ +public class CaseTransformFunction extends BaseTransformFunction { + public static final String FUNCTION_NAME = "case"; + + private int _numberWhenStatements; + private final List<TransformFunction> _whenStatements = new ArrayList<>(); + private final List<LiteralTransformFunction> _elseThenStatements = new ArrayList<>(); + private TransformResultMetadata _resultMetadata; + + @Override + public String getName() { + return FUNCTION_NAME; + } + + @Override + public void init(List<TransformFunction> arguments, Map<String, DataSource> dataSourceMap) { + // Check that there are more than 1 arguments + if (arguments.size() % 2 != 1 || arguments.size() < 3) { + throw new IllegalArgumentException("At least 3 odd number of arguments are required for CASE-WHEN-ELSE function"); + } + _numberWhenStatements = arguments.size() / 2; + for (int i = 0; i < _numberWhenStatements; i++) { + _whenStatements.add(arguments.get(i)); + } + // Add ELSE Statement first + _elseThenStatements.add((LiteralTransformFunction) arguments.get(_numberWhenStatements * 2)); + for (int i = _numberWhenStatements; i < _numberWhenStatements * 2; i++) { + _elseThenStatements.add((LiteralTransformFunction) arguments.get(i)); + } + _resultMetadata = _elseThenStatements.get(0).getResultMetadata(); + } + + @Override + public TransformResultMetadata getResultMetadata() { + return _resultMetadata; + } + + private int[] getSelectedArray(ProjectionBlock projectionBlock) { + int[] selected = new int[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + for (int i = 0; i < _numberWhenStatements; i++) { + TransformFunction transformFunction = _whenStatements.get(i); + int[] conditions = transformFunction.transformToIntValuesSV(projectionBlock); + for (int j = 0; j < conditions.length; j++) { + if (selected[j] == 0 && conditions[j] == 1) { + selected[j] = i + 1; + } + } + } + return selected; + } + + @Override + public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { + int[] selected = getSelectedArray(projectionBlock); + int[] results = new int[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + for (int i = 0; i < selected.length; i++) { + results[i] = Double.valueOf(_elseThenStatements.get(selected[i]).getLiteral()).intValue(); + } + return results; + } + + @Override + public long[] transformToLongValuesSV(ProjectionBlock projectionBlock) { + int[] selected = getSelectedArray(projectionBlock); + long[] results = new long[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + for (int i = 0; i < selected.length; i++) { + results[i] = Double.valueOf(_elseThenStatements.get(selected[i]).getLiteral()).longValue(); + } + return results; + } + + @Override + public float[] transformToFloatValuesSV(ProjectionBlock projectionBlock) { + int[] selected = getSelectedArray(projectionBlock); + float[] results = new float[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + for (int i = 0; i < selected.length; i++) { + results[i] = Double.valueOf(_elseThenStatements.get(selected[i]).getLiteral()).floatValue(); + } + return results; + } + + @Override + public double[] transformToDoubleValuesSV(ProjectionBlock projectionBlock) { + int[] selected = getSelectedArray(projectionBlock); + double[] results = new double[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + for (int i = 0; i < selected.length; i++) { + results[i] = Double.parseDouble(_elseThenStatements.get(selected[i]).getLiteral()); + } + return results; + } + + @Override + public String[] transformToStringValuesSV(ProjectionBlock projectionBlock) { + int[] selected = getSelectedArray(projectionBlock); + String[] results = new String[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + for (int i = 0; i < selected.length; i++) { + results[i] = _elseThenStatements.get(selected[i]).getLiteral(); + } + return results; + } +} diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/EqualsTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/EqualsTransformFunction.java new file mode 100644 index 0000000..7b4d777 --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/EqualsTransformFunction.java @@ -0,0 +1,41 @@ +package org.apache.pinot.core.operator.transform.function; + +import org.apache.pinot.common.function.TransformFunctionType; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; + + +/** + * The <code>EqualsTransformFunction</code> extends <code>BinaryOperatorTransformFunction</code> to implement the + * binary operator(=). + * + * The results are in boolean format and stored as an integer array with 1 represents true and 0 represents false. + * + * SQL Syntax: + * columnA = 12 + * columnA = 12.0 + * columnA = 'fooBar' + * + * Sample Usage: + * EQUALS(columnA, 12) + * EQUALS(columnA, 12.0) + * EQUALS(columnA, 'fooBar') + * + */ +public class EqualsTransformFunction extends BinaryOperatorTransformFunction { + + @Override + public String getName() { + return TransformFunctionType.EQUALS.getName(); + } + + @Override + public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { + fillResultArray(projectionBlock); + return _results; + } + + @Override + int getBinaryFuncResult(int result) { + return (result == 0) ? 1 : 0; + } +} \ No newline at end of file diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/GreaterThanOrEqualTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/GreaterThanOrEqualTransformFunction.java new file mode 100644 index 0000000..340a062 --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/GreaterThanOrEqualTransformFunction.java @@ -0,0 +1,49 @@ +package org.apache.pinot.core.operator.transform.function; + +import java.util.List; +import java.util.Map; +import org.apache.pinot.common.function.TransformFunctionType; +import org.apache.pinot.core.common.DataSource; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; + + +/** + * The <code>GreaterThanOrEqualTransformFunction</code> extends <code>BinaryOperatorTransformFunction</code> to + * implement the binary operator(>=). + * + * The results are in boolean format and stored as an integer array with 1 represents true and 0 represents false. + * + * SQL Syntax: + * columnA >= 12 + * columnA >= 12.0 + * columnA >= 'fooBar' + * + * Sample Usage: + * GREATER_THAN_OR_EQUAL(columnA, 12) + * GREATER_THAN_OR_EQUAL(columnA, 12.0) + * GREATER_THAN_OR_EQUAL(columnA, 'fooBar') + * + */ +public class GreaterThanOrEqualTransformFunction extends BinaryOperatorTransformFunction { + + @Override + public void init(List<TransformFunction> arguments, Map<String, DataSource> dataSourceMap) { + super.init(arguments, dataSourceMap); + } + + @Override + int getBinaryFuncResult(int result) { + return (result >= 0) ? 1 : 0; + } + + @Override + public String getName() { + return TransformFunctionType.GREATER_THAN_OR_EQUAL.getName(); + } + + @Override + public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { + fillResultArray(projectionBlock); + return _results; + } +} \ No newline at end of file diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/GreaterThanTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/GreaterThanTransformFunction.java new file mode 100644 index 0000000..0b7898c --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/GreaterThanTransformFunction.java @@ -0,0 +1,49 @@ +package org.apache.pinot.core.operator.transform.function; + +import java.util.List; +import java.util.Map; +import org.apache.pinot.common.function.TransformFunctionType; +import org.apache.pinot.core.common.DataSource; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; + + +/** + * The <code>GREATER_THAN</code> extends <code>BinaryOperatorTransformFunction</code> to implement the binary + * operator(>). + * + * The results are in boolean format and stored as an integer array with 1 represents true and 0 represents false. + * + * SQL Syntax: + * columnA > 12 + * columnA > 12.0 + * columnA > 'fooBar' + * + * Sample Usage: + * GREATER_THAN(columnA, 12) + * GREATER_THAN(columnA, 12.0) + * GREATER_THAN(columnA, 'fooBar') + * + */ +public class GreaterThanTransformFunction extends BinaryOperatorTransformFunction { + + @Override + public void init(List<TransformFunction> arguments, Map<String, DataSource> dataSourceMap) { + super.init(arguments, dataSourceMap); + } + + @Override + int getBinaryFuncResult(int result) { + return (result > 0) ? 1 : 0; + } + + @Override + public String getName() { + return TransformFunctionType.GREATER_THAN.getName(); + } + + @Override + public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { + fillResultArray(projectionBlock); + return _results; + } +} \ No newline at end of file diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LessThanOrEqualTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LessThanOrEqualTransformFunction.java new file mode 100644 index 0000000..3cdb14c --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LessThanOrEqualTransformFunction.java @@ -0,0 +1,49 @@ +package org.apache.pinot.core.operator.transform.function; + +import java.util.List; +import java.util.Map; +import org.apache.pinot.common.function.TransformFunctionType; +import org.apache.pinot.core.common.DataSource; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; + + +/** + * The <code>GreaterThanOrEqualTransformFunction</code> extends <code>BinaryOperatorTransformFunction</code> to + * implement the binary operator(<=). + * + * The results are in boolean format and stored as an integer array with 1 represents true and 0 represents false. + * + * SQL Syntax: + * columnA <= 12 + * columnA <= 12.0 + * columnA <= 'fooBar' + * + * Sample Usage: + * LESS_THAN_OR_EQUAL(columnA, 12) + * LESS_THAN_OR_EQUAL(columnA, 12.0) + * LESS_THAN_OR_EQUAL(columnA, 'fooBar') + * + */ +public class LessThanOrEqualTransformFunction extends BinaryOperatorTransformFunction { + + @Override + public void init(List<TransformFunction> arguments, Map<String, DataSource> dataSourceMap) { + super.init(arguments, dataSourceMap); + } + + @Override + int getBinaryFuncResult(int result) { + return (result <= 0) ? 1 : 0; + } + + @Override + public String getName() { + return TransformFunctionType.LESS_THAN_OR_EQUAL.getName(); + } + + @Override + public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { + fillResultArray(projectionBlock); + return _results; + } +} \ No newline at end of file diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LessThanTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LessThanTransformFunction.java new file mode 100644 index 0000000..ec5eac3 --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LessThanTransformFunction.java @@ -0,0 +1,49 @@ +package org.apache.pinot.core.operator.transform.function; + +import java.util.List; +import java.util.Map; +import org.apache.pinot.common.function.TransformFunctionType; +import org.apache.pinot.core.common.DataSource; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; + + +/** + * The <code>LESS_THAN</code> extends <code>BinaryOperatorTransformFunction</code> to implement the binary + * operator(<). + * + * The results are in boolean format and stored as an integer array with 1 represents true and 0 represents false. + * + * SQL Syntax: + * columnA < 12 + * columnA < 12.0 + * columnA < 'fooBar' + * + * Sample Usage: + * LESS_THAN(columnA, 12) + * LESS_THAN(columnA, 12.0) + * LESS_THAN(columnA, 'fooBar') + * + */ +public class LessThanTransformFunction extends BinaryOperatorTransformFunction { + + @Override + public void init(List<TransformFunction> arguments, Map<String, DataSource> dataSourceMap) { + super.init(arguments, dataSourceMap); + } + + @Override + int getBinaryFuncResult(int result) { + return (result < 0) ? 1 : 0; + } + + @Override + public String getName() { + return TransformFunctionType.LESS_THAN.getName(); + } + + @Override + public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { + fillResultArray(projectionBlock); + return _results; + } +} \ No newline at end of file diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LiteralTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LiteralTransformFunction.java index 4317a2b..43e8dfc 100644 --- a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LiteralTransformFunction.java +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/LiteralTransformFunction.java @@ -26,6 +26,7 @@ import org.apache.pinot.core.operator.blocks.ProjectionBlock; import org.apache.pinot.core.operator.transform.TransformResultMetadata; import org.apache.pinot.core.plan.DocIdSetPlanNode; import org.apache.pinot.core.segment.index.readers.Dictionary; +import org.apache.pinot.spi.utils.BytesUtils; /** @@ -35,6 +36,11 @@ import org.apache.pinot.core.segment.index.readers.Dictionary; public class LiteralTransformFunction implements TransformFunction { private final String _literal; private String[] _result; + private int[] _intResult; + private long[] _longResult; + private float[] _floatResult; + private double[] _doubleResult; + private byte[][] _bytesResult; public LiteralTransformFunction(String literal) { _literal = literal; @@ -75,22 +81,38 @@ public class LiteralTransformFunction implements TransformFunction { @Override public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { - throw new UnsupportedOperationException(); + if (_intResult == null) { + _intResult = new int[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + Arrays.fill(_intResult, Integer.parseInt(_literal)); + } + return _intResult; } @Override public long[] transformToLongValuesSV(ProjectionBlock projectionBlock) { - throw new UnsupportedOperationException(); + if (_longResult == null) { + _longResult = new long[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + Arrays.fill(_longResult, Long.parseLong(_literal)); + } + return _longResult; } @Override public float[] transformToFloatValuesSV(ProjectionBlock projectionBlock) { - throw new UnsupportedOperationException(); + if (_floatResult == null) { + _floatResult = new float[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + Arrays.fill(_floatResult, Float.parseFloat(_literal)); + } + return _floatResult; } @Override public double[] transformToDoubleValuesSV(ProjectionBlock projectionBlock) { - throw new UnsupportedOperationException(); + if (_doubleResult == null) { + _doubleResult = new double[DocIdSetPlanNode.MAX_DOC_PER_CALL]; + Arrays.fill(_doubleResult, Double.parseDouble(_literal)); + } + return _doubleResult; } @Override @@ -104,7 +126,11 @@ public class LiteralTransformFunction implements TransformFunction { @Override public byte[][] transformToBytesValuesSV(ProjectionBlock projectionBlock) { - throw new UnsupportedOperationException(); + if (_bytesResult == null) { + _bytesResult = new byte[DocIdSetPlanNode.MAX_DOC_PER_CALL][]; + Arrays.fill(_bytesResult, BytesUtils.toBytes(_literal)); + } + return _bytesResult; } @Override diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/NotEqualsTransformFunction.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/NotEqualsTransformFunction.java new file mode 100644 index 0000000..a8132ea --- /dev/null +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/NotEqualsTransformFunction.java @@ -0,0 +1,41 @@ +package org.apache.pinot.core.operator.transform.function; + +import org.apache.pinot.common.function.TransformFunctionType; +import org.apache.pinot.core.operator.blocks.ProjectionBlock; + + +/** + * The <code>NotEqualsTransformFunction</code> extends <code>BinaryOperatorTransformFunction</code> to implement the + * binary operator(<>). + * + * The results are in boolean format and stored as an integer array with 1 represents true and 0 represents false. + * + * SQL Syntax: + * columnA <> 12 + * columnA <> 12.0 + * columnA <> 'fooBar' + * + * Sample Usage: + * NOT_EQUALS(columnA, 12) + * NOT_EQUALS(columnA, 12.0) + * NOT_EQUALS(columnA, 'fooBar') + * + */ +public class NotEqualsTransformFunction extends BinaryOperatorTransformFunction { + + @Override + public String getName() { + return TransformFunctionType.NOT_EQUALS.getName(); + } + + @Override + public int[] transformToIntValuesSV(ProjectionBlock projectionBlock) { + fillResultArray(projectionBlock); + return _results; + } + + @Override + int getBinaryFuncResult(int result) { + return (result != 0) ? 1 : 0; + } +} \ No newline at end of file diff --git a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/TransformFunctionFactory.java b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/TransformFunctionFactory.java index e9bd6bc..059db49 100644 --- a/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/TransformFunctionFactory.java +++ b/pinot-core/src/main/java/org/apache/pinot/core/operator/transform/function/TransformFunctionFactory.java @@ -73,6 +73,15 @@ public class TransformFunctionFactory { put(TransformFunctionType.ARRAYLENGTH.getName().toLowerCase(), ArrayLengthTransformFunction.class); put(TransformFunctionType.VALUEIN.getName().toLowerCase(), ValueInTransformFunction.class); put(TransformFunctionType.MAPVALUE.getName().toLowerCase(), MapValueTransformFunction.class); + + put(TransformFunctionType.CASE.getName().toLowerCase(), CaseTransformFunction.class); + + put(TransformFunctionType.EQUALS.getName().toLowerCase(), EqualsTransformFunction.class); + put(TransformFunctionType.NOT_EQUALS.getName().toLowerCase(), NotEqualsTransformFunction.class); + put(TransformFunctionType.GREATER_THAN.getName().toLowerCase(), GreaterThanTransformFunction.class); + put(TransformFunctionType.GREATER_THAN_OR_EQUAL.getName().toLowerCase(), GreaterThanOrEqualTransformFunction.class); + put(TransformFunctionType.LESS_THAN.getName().toLowerCase(), LessThanTransformFunction.class); + put(TransformFunctionType.LESS_THAN_OR_EQUAL.getName().toLowerCase(), LessThanOrEqualTransformFunction.class); } }; diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/BaseTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/BaseTransformFunctionTest.java index ab9949c..1649d03 100644 --- a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/BaseTransformFunctionTest.java +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/BaseTransformFunctionTest.java @@ -154,6 +154,21 @@ public abstract class BaseTransformFunctionTest { new DocIdSetOperator(new MatchAllFilterOperator(NUM_ROWS), DocIdSetPlanNode.MAX_DOC_PER_CALL)).nextBlock(); } + protected void testTransformFunction(TransformFunction transformFunction, int[] expectedValues) { + int[] intValues = transformFunction.transformToIntValuesSV(_projectionBlock); + long[] longValues = transformFunction.transformToLongValuesSV(_projectionBlock); + float[] floatValues = transformFunction.transformToFloatValuesSV(_projectionBlock); + double[] doubleValues = transformFunction.transformToDoubleValuesSV(_projectionBlock); + String[] stringValues = transformFunction.transformToStringValuesSV(_projectionBlock); + for (int i = 0; i < NUM_ROWS; i++) { + Assert.assertEquals(intValues[i], expectedValues[i]); + Assert.assertEquals(longValues[i], expectedValues[i]); + Assert.assertEquals(floatValues[i], (float) expectedValues[i]); + Assert.assertEquals(doubleValues[i], (double) expectedValues[i]); + Assert.assertEquals(stringValues[i], Integer.toString(expectedValues[i])); + } + } + protected void testTransformFunction(TransformFunction transformFunction, double[] expectedValues) { int[] intValues = transformFunction.transformToIntValuesSV(_projectionBlock); long[] longValues = transformFunction.transformToLongValuesSV(_projectionBlock); diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/BinaryOperatorTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/BinaryOperatorTransformFunctionTest.java new file mode 100644 index 0000000..403dead --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/BinaryOperatorTransformFunctionTest.java @@ -0,0 +1,109 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +import org.apache.pinot.common.request.transform.TransformExpressionTree; +import org.apache.pinot.core.query.exception.BadQueryRequestException; +import org.testng.Assert; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; + + +/** + * BinaryOperatorTransformFunctionTest abstracts common test methods for EqualsTransformFunctionTest, + * NotEqualsTransformFunctionTest, GreaterThanOrEqualTransformFunctionTest, GreaterThanTransformFunctionTest, + * LessThanOrEqualTransformFunctionTest, LessThanTransformFunctionTest + * + */ +public abstract class BinaryOperatorTransformFunctionTest extends BaseTransformFunctionTest { + + abstract int getExpectedValue(int value, int toCompare); + + abstract int getExpectedValue(long value, long toCompare); + + abstract int getExpectedValue(float value, float toCompare); + + abstract int getExpectedValue(double value, double toCompare); + + abstract int getExpectedValue(String value, String toCompare); + + abstract String getFuncName(); + + @Test + public void testBinaryOperatorTransformFunction() { + TransformExpressionTree expression = TransformExpressionTree + .compileToExpressionTree(String.format("%s(%s, %d)", getFuncName(), INT_SV_COLUMN, _intSVValues[0])); + TransformFunction transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + Assert.assertEquals(transformFunction.getName(), getFuncName().toLowerCase()); + int[] expectedIntValues = new int[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + expectedIntValues[i] = getExpectedValue(_intSVValues[i], _intSVValues[0]); + } + testTransformFunction(transformFunction, expectedIntValues); + + expression = TransformExpressionTree + .compileToExpressionTree(String.format("%s(%s, %d)", getFuncName(), LONG_SV_COLUMN, _longSVValues[0])); + transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + int[] expectedLongValues = new int[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + expectedLongValues[i] = getExpectedValue(_longSVValues[i], _longSVValues[0]); + } + testTransformFunction(transformFunction, expectedLongValues); + + expression = TransformExpressionTree + .compileToExpressionTree(String.format("%s(%s, %f)", getFuncName(), FLOAT_SV_COLUMN, _floatSVValues[0])); + transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + int[] expectedFloatValues = new int[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + expectedFloatValues[i] = getExpectedValue(_floatSVValues[i], _floatSVValues[0]); + } + testTransformFunction(transformFunction, expectedFloatValues); + + expression = TransformExpressionTree + .compileToExpressionTree(String.format("%s(%s, %.20f)", getFuncName(), DOUBLE_SV_COLUMN, _doubleSVValues[0])); + transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + int[] expectedDoubleValues = new int[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + expectedDoubleValues[i] = getExpectedValue(_doubleSVValues[i], _doubleSVValues[0]); + } + testTransformFunction(transformFunction, expectedDoubleValues); + + expression = TransformExpressionTree + .compileToExpressionTree(String.format("%s(%s, '%s')", getFuncName(), STRING_SV_COLUMN, _stringSVValues[0])); + transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + int[] expectedStringValues = new int[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + expectedStringValues[i] = getExpectedValue(_stringSVValues[i], _stringSVValues[0]); + } + testTransformFunction(transformFunction, expectedStringValues); + } + + @Test(dataProvider = "testIllegalArguments", expectedExceptions = {BadQueryRequestException.class}) + public void testIllegalArguments(String expressionStr) { + TransformExpressionTree expression = TransformExpressionTree.compileToExpressionTree(expressionStr); + TransformFunctionFactory.get(expression, _dataSourceMap); + } + + @DataProvider(name = "testIllegalArguments") + public Object[][] testIllegalArguments() { + return new Object[][]{new Object[]{String.format("%s(%s)", getFuncName(), + INT_SV_COLUMN)}, new Object[]{String.format("%s(%s, %s, %s)", getFuncName(), LONG_SV_COLUMN, INT_SV_COLUMN, + STRING_SV_COLUMN)}}; + } +} diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/CaseTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/CaseTransformFunctionTest.java new file mode 100644 index 0000000..38ac139 --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/CaseTransformFunctionTest.java @@ -0,0 +1,522 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +import java.util.Random; +import org.apache.pinot.common.function.TransformFunctionType; +import org.apache.pinot.common.request.transform.TransformExpressionTree; +import org.apache.pinot.core.query.exception.BadQueryRequestException; +import org.testng.Assert; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; + + +public class CaseTransformFunctionTest extends BaseTransformFunctionTest { + + private final int INDEX_TO_COMPARE = new Random(System.currentTimeMillis()).nextInt(NUM_ROWS); + private final TransformFunctionType[] BINARY_OPERATOR_TRANSFORM_FUNCTIONS = + new TransformFunctionType[]{TransformFunctionType.EQUALS, TransformFunctionType.NOT_EQUALS, TransformFunctionType.GREATER_THAN, TransformFunctionType.GREATER_THAN_OR_EQUAL, TransformFunctionType.LESS_THAN, TransformFunctionType.LESS_THAN_OR_EQUAL}; + + @Test + public void testCaseTransformFunctionWithIntResults() { + for (TransformFunctionType functionType : BINARY_OPERATOR_TRANSFORM_FUNCTIONS) { + testCaseQueryWithIntResults(String.format("%s(%s, %s)", functionType.getName(), INT_SV_COLUMN, + String.format("%d", _intSVValues[INDEX_TO_COMPARE])), getExpectedIntResults(INT_SV_COLUMN, functionType)); + testCaseQueryWithIntResults(String.format("%s(%s, %s)", functionType.getName(), LONG_SV_COLUMN, + String.format("%d", _longSVValues[INDEX_TO_COMPARE])), getExpectedIntResults(LONG_SV_COLUMN, functionType)); + testCaseQueryWithIntResults(String.format("%s(%s, %s)", functionType.getName(), FLOAT_SV_COLUMN, + String.format("%f", _floatSVValues[INDEX_TO_COMPARE])), getExpectedIntResults(FLOAT_SV_COLUMN, functionType)); + testCaseQueryWithIntResults(String.format("%s(%s, %s)", functionType.getName(), DOUBLE_SV_COLUMN, + String.format("%.20f", _doubleSVValues[INDEX_TO_COMPARE])), + getExpectedIntResults(DOUBLE_SV_COLUMN, functionType)); + testCaseQueryWithIntResults(String.format("%s(%s, %s)", functionType.getName(), STRING_SV_COLUMN, + String.format("'%s'", _stringSVValues[INDEX_TO_COMPARE])), + getExpectedIntResults(STRING_SV_COLUMN, functionType)); + } + } + + @Test + public void testCaseTransformFunctionWithDoubleResults() { + for (TransformFunctionType functionType : BINARY_OPERATOR_TRANSFORM_FUNCTIONS) { + testCaseQueryWithDoubleResults(String.format("%s(%s, %s)", functionType.getName(), INT_SV_COLUMN, + String.format("%d", _intSVValues[INDEX_TO_COMPARE])), getExpectedDoubleResults(INT_SV_COLUMN, functionType)); + testCaseQueryWithDoubleResults(String.format("%s(%s, %s)", functionType.getName(), LONG_SV_COLUMN, + String.format("%d", _longSVValues[INDEX_TO_COMPARE])), + getExpectedDoubleResults(LONG_SV_COLUMN, functionType)); + testCaseQueryWithDoubleResults(String.format("%s(%s, %s)", functionType.getName(), FLOAT_SV_COLUMN, + String.format("%f", _floatSVValues[INDEX_TO_COMPARE])), + getExpectedDoubleResults(FLOAT_SV_COLUMN, functionType)); + testCaseQueryWithDoubleResults(String.format("%s(%s, %s)", functionType.getName(), DOUBLE_SV_COLUMN, + String.format("%.20f", _doubleSVValues[INDEX_TO_COMPARE])), + getExpectedDoubleResults(DOUBLE_SV_COLUMN, functionType)); + testCaseQueryWithDoubleResults(String.format("%s(%s, %s)", functionType.getName(), STRING_SV_COLUMN, + String.format("'%s'", _stringSVValues[INDEX_TO_COMPARE])), + getExpectedDoubleResults(STRING_SV_COLUMN, functionType)); + } + } + + @Test + public void testCaseTransformFunctionWithStringResults() { + for (TransformFunctionType functionType : BINARY_OPERATOR_TRANSFORM_FUNCTIONS) { + testCaseQueryWithStringResults(String.format("%s(%s, %s)", functionType.getName(), INT_SV_COLUMN, + String.format("%d", _intSVValues[INDEX_TO_COMPARE])), getExpectedStringResults(INT_SV_COLUMN, functionType)); + testCaseQueryWithStringResults(String.format("%s(%s, %s)", functionType.getName(), LONG_SV_COLUMN, + String.format("%d", _longSVValues[INDEX_TO_COMPARE])), + getExpectedStringResults(LONG_SV_COLUMN, functionType)); + testCaseQueryWithStringResults(String.format("%s(%s, %s)", functionType.getName(), FLOAT_SV_COLUMN, + String.format("%f", _floatSVValues[INDEX_TO_COMPARE])), + getExpectedStringResults(FLOAT_SV_COLUMN, functionType)); + testCaseQueryWithStringResults(String.format("%s(%s, %s)", functionType.getName(), DOUBLE_SV_COLUMN, + String.format("%.20f", _doubleSVValues[INDEX_TO_COMPARE])), + getExpectedStringResults(DOUBLE_SV_COLUMN, functionType)); + testCaseQueryWithStringResults(String.format("%s(%s, %s)", functionType.getName(), STRING_SV_COLUMN, + String.format("'%s'", _stringSVValues[INDEX_TO_COMPARE])), + getExpectedStringResults(STRING_SV_COLUMN, functionType)); + } + } + + private void testCaseQueryWithIntResults(String predicate, int[] expectedValues) { + TransformExpressionTree expression = + TransformExpressionTree.compileToExpressionTree(String.format("CASE(%s, 100, 10)", predicate)); + expression.getChildren().set(0, TransformExpressionTree.compileToExpressionTree(predicate)); + TransformFunction transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + Assert.assertTrue(transformFunction instanceof CaseTransformFunction); + Assert.assertEquals(transformFunction.getName(), CaseTransformFunction.FUNCTION_NAME); + testTransformFunction(transformFunction, expectedValues); + } + + private void testCaseQueryWithDoubleResults(String predicate, double[] expectedValues) { + TransformExpressionTree expression = + TransformExpressionTree.compileToExpressionTree(String.format("CASE(%s, 100.0, 10.0)", predicate)); + expression.getChildren().set(0, TransformExpressionTree.compileToExpressionTree(predicate)); + TransformFunction transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + Assert.assertTrue(transformFunction instanceof CaseTransformFunction); + Assert.assertEquals(transformFunction.getName(), CaseTransformFunction.FUNCTION_NAME); + testTransformFunction(transformFunction, expectedValues); + } + + private void testCaseQueryWithStringResults(String predicate, String[] expectedValues) { + TransformExpressionTree expression = + TransformExpressionTree.compileToExpressionTree(String.format("CASE(%s, 'aaa', 'bbb')", predicate)); + expression.getChildren().set(0, TransformExpressionTree.compileToExpressionTree(predicate)); + TransformFunction transformFunction = TransformFunctionFactory.get(expression, _dataSourceMap); + Assert.assertTrue(transformFunction instanceof CaseTransformFunction); + Assert.assertEquals(transformFunction.getName(), CaseTransformFunction.FUNCTION_NAME); + testTransformFunction(transformFunction, expectedValues); + } + + @Test(dataProvider = "testIllegalArguments", expectedExceptions = {BadQueryRequestException.class}) + public void testIllegalArguments(String expressionStr) { + TransformExpressionTree expression = TransformExpressionTree.compileToExpressionTree(expressionStr); + TransformFunctionFactory.get(expression, _dataSourceMap); + } + + @DataProvider(name = "testIllegalArguments") + public Object[][] testIllegalArguments() { + return new Object[][]{new Object[]{String.format("case(%s)", INT_SV_COLUMN)}, new Object[]{String.format( + "case(%s, %s)", LONG_SV_COLUMN, 10)}}; + } + + private int[] getExpectedIntResults(String column, TransformFunctionType type) { + int[] result = new int[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + switch (column) { + case INT_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_intSVValues[i] == _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_intSVValues[i] != _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_intSVValues[i] > _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_intSVValues[i] >= _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_intSVValues[i] < _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_intSVValues[i] <= _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case LONG_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_longSVValues[i] == _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_longSVValues[i] != _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_longSVValues[i] > _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_longSVValues[i] >= _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_longSVValues[i] < _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_longSVValues[i] <= _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case FLOAT_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_floatSVValues[i] == _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_floatSVValues[i] != _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_floatSVValues[i] > _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_floatSVValues[i] >= _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_floatSVValues[i] < _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_floatSVValues[i] <= _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case DOUBLE_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_doubleSVValues[i] == _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_doubleSVValues[i] != _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_doubleSVValues[i] > _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_doubleSVValues[i] >= _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_doubleSVValues[i] < _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_doubleSVValues[i] <= _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case STRING_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) == 0) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) != 0) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) > 0) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) >= 0) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) < 0) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) <= 0) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + } + } + return result; + } + + private double[] getExpectedDoubleResults(String column, TransformFunctionType type) { + double[] result = new double[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + switch (column) { + case INT_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_intSVValues[i] == _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_intSVValues[i] != _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_intSVValues[i] > _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_intSVValues[i] >= _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_intSVValues[i] < _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_intSVValues[i] <= _intSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case LONG_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_longSVValues[i] == _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_longSVValues[i] != _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_longSVValues[i] > _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_longSVValues[i] >= _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_longSVValues[i] < _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_longSVValues[i] <= _longSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case FLOAT_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_floatSVValues[i] == _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_floatSVValues[i] != _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_floatSVValues[i] > _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_floatSVValues[i] >= _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_floatSVValues[i] < _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_floatSVValues[i] <= _floatSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case DOUBLE_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_doubleSVValues[i] == _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_doubleSVValues[i] != _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_doubleSVValues[i] > _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_doubleSVValues[i] >= _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_doubleSVValues[i] < _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_doubleSVValues[i] <= _doubleSVValues[INDEX_TO_COMPARE]) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case STRING_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) == 0) ? 100 : 10; + break; + case NOT_EQUALS: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) != 0) ? 100 : 10; + break; + case GREATER_THAN: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) > 0) ? 100 : 10; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) >= 0) ? 100 : 10; + break; + case LESS_THAN: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) < 0) ? 100 : 10; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) <= 0) ? 100 : 10; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + } + } + return result; + } + + private String[] getExpectedStringResults(String column, TransformFunctionType type) { + String[] result = new String[NUM_ROWS]; + for (int i = 0; i < NUM_ROWS; i++) { + switch (column) { + case INT_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_intSVValues[i] == _intSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case NOT_EQUALS: + result[i] = (_intSVValues[i] != _intSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN: + result[i] = (_intSVValues[i] > _intSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_intSVValues[i] >= _intSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN: + result[i] = (_intSVValues[i] < _intSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_intSVValues[i] <= _intSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case LONG_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_longSVValues[i] == _longSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case NOT_EQUALS: + result[i] = (_longSVValues[i] != _longSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN: + result[i] = (_longSVValues[i] > _longSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_longSVValues[i] >= _longSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN: + result[i] = (_longSVValues[i] < _longSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_longSVValues[i] <= _longSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case FLOAT_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_floatSVValues[i] == _floatSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case NOT_EQUALS: + result[i] = (_floatSVValues[i] != _floatSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN: + result[i] = (_floatSVValues[i] > _floatSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_floatSVValues[i] >= _floatSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN: + result[i] = (_floatSVValues[i] < _floatSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_floatSVValues[i] <= _floatSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case DOUBLE_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_doubleSVValues[i] == _doubleSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case NOT_EQUALS: + result[i] = (_doubleSVValues[i] != _doubleSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN: + result[i] = (_doubleSVValues[i] > _doubleSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_doubleSVValues[i] >= _doubleSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN: + result[i] = (_doubleSVValues[i] < _doubleSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_doubleSVValues[i] <= _doubleSVValues[INDEX_TO_COMPARE]) ? "aaa" : "bbb"; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + case STRING_SV_COLUMN: + switch (type) { + case EQUALS: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) == 0) ? "aaa" : "bbb"; + break; + case NOT_EQUALS: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) != 0) ? "aaa" : "bbb"; + break; + case GREATER_THAN: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) > 0) ? "aaa" : "bbb"; + break; + case GREATER_THAN_OR_EQUAL: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) >= 0) ? "aaa" : "bbb"; + break; + case LESS_THAN: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) < 0) ? "aaa" : "bbb"; + break; + case LESS_THAN_OR_EQUAL: + result[i] = (_stringSVValues[i].compareTo(_stringSVValues[INDEX_TO_COMPARE]) <= 0) ? "aaa" : "bbb"; + break; + default: + throw new IllegalStateException("Not supported type - " + type); + } + break; + } + } + return result; + } +} diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/EqualsTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/EqualsTransformFunctionTest.java new file mode 100644 index 0000000..6e9dab5 --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/EqualsTransformFunctionTest.java @@ -0,0 +1,52 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +public class EqualsTransformFunctionTest extends BinaryOperatorTransformFunctionTest { + + @Override + int getExpectedValue(int value, int toCompare) { + return (value == toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(long value, long toCompare) { + return (value == toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(float value, float toCompare) { + return (value == toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(double value, double toCompare) { + return (value == toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(String value, String toCompare) { + return (value.compareTo(toCompare) == 0) ? 1 : 0; + } + + @Override + String getFuncName() { + return new EqualsTransformFunction().getName(); + } +} diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/GreaterThanOrEqualTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/GreaterThanOrEqualTransformFunctionTest.java new file mode 100644 index 0000000..8c26967 --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/GreaterThanOrEqualTransformFunctionTest.java @@ -0,0 +1,52 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +public class GreaterThanOrEqualTransformFunctionTest extends BinaryOperatorTransformFunctionTest { + + @Override + int getExpectedValue(int value, int toCompare) { + return (value >= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(long value, long toCompare) { + return (value >= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(float value, float toCompare) { + return (value >= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(double value, double toCompare) { + return (value >= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(String value, String toCompare) { + return (value.compareTo(toCompare) >= 0) ? 1 : 0; + } + + @Override + String getFuncName() { + return new GreaterThanOrEqualTransformFunction().getName(); + } +} diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/GreaterThanTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/GreaterThanTransformFunctionTest.java new file mode 100644 index 0000000..ee0d5e5 --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/GreaterThanTransformFunctionTest.java @@ -0,0 +1,52 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +public class GreaterThanTransformFunctionTest extends BinaryOperatorTransformFunctionTest { + + @Override + int getExpectedValue(int value, int toCompare) { + return (value > toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(long value, long toCompare) { + return (value > toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(float value, float toCompare) { + return (value > toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(double value, double toCompare) { + return (value > toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(String value, String toCompare) { + return (value.compareTo(toCompare) > 0) ? 1 : 0; + } + + @Override + String getFuncName() { + return new GreaterThanTransformFunction().getName(); + } +} diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/LessThanOrEqualTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/LessThanOrEqualTransformFunctionTest.java new file mode 100644 index 0000000..9c3569b --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/LessThanOrEqualTransformFunctionTest.java @@ -0,0 +1,52 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +public class LessThanOrEqualTransformFunctionTest extends BinaryOperatorTransformFunctionTest { + + @Override + int getExpectedValue(int value, int toCompare) { + return (value <= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(long value, long toCompare) { + return (value <= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(float value, float toCompare) { + return (value <= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(double value, double toCompare) { + return (value <= toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(String value, String toCompare) { + return (value.compareTo(toCompare) <= 0) ? 1 : 0; + } + + @Override + String getFuncName() { + return new LessThanOrEqualTransformFunction().getName(); + } +} diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/LessThanTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/LessThanTransformFunctionTest.java new file mode 100644 index 0000000..f04b06b --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/LessThanTransformFunctionTest.java @@ -0,0 +1,52 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +public class LessThanTransformFunctionTest extends BinaryOperatorTransformFunctionTest { + + @Override + int getExpectedValue(int value, int toCompare) { + return (value < toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(long value, long toCompare) { + return (value < toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(float value, float toCompare) { + return (value < toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(double value, double toCompare) { + return (value < toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(String value, String toCompare) { + return (value.compareTo(toCompare) < 0) ? 1 : 0; + } + + @Override + String getFuncName() { + return new LessThanTransformFunction().getName(); + } +} diff --git a/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/NotEqualsTransformFunctionTest.java b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/NotEqualsTransformFunctionTest.java new file mode 100644 index 0000000..7567730 --- /dev/null +++ b/pinot-core/src/test/java/org/apache/pinot/core/operator/transform/function/NotEqualsTransformFunctionTest.java @@ -0,0 +1,52 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.pinot.core.operator.transform.function; + +public class NotEqualsTransformFunctionTest extends BinaryOperatorTransformFunctionTest { + + @Override + int getExpectedValue(int value, int toCompare) { + return (value != toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(long value, long toCompare) { + return (value != toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(float value, float toCompare) { + return (value != toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(double value, double toCompare) { + return (value != toCompare) ? 1 : 0; + } + + @Override + int getExpectedValue(String value, String toCompare) { + return (value.compareTo(toCompare) != 0) ? 1 : 0; + } + + @Override + String getFuncName() { + return new NotEqualsTransformFunction().getName(); + } +} diff --git a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/OfflineClusterIntegrationTest.java b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/OfflineClusterIntegrationTest.java index 223602c..fb59604 100644 --- a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/OfflineClusterIntegrationTest.java +++ b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/OfflineClusterIntegrationTest.java @@ -95,6 +95,7 @@ public class OfflineClusterIntegrationTest extends BaseClusterIntegrationTestSet private final List<ServiceStatus.ServiceStatusCallback> _serviceStatusCallbacks = new ArrayList<>(getNumBrokers() + getNumServers()); + private String _schemaFileName = DEFAULT_SCHEMA_FILE_NAME; protected int getNumBrokers() { return NUM_BROKERS; @@ -104,8 +105,6 @@ public class OfflineClusterIntegrationTest extends BaseClusterIntegrationTestSet return NUM_SERVERS; } - private String _schemaFileName = DEFAULT_SCHEMA_FILE_NAME; - @Override protected String getSchemaFileName() { return _schemaFileName; @@ -753,6 +752,34 @@ public class OfflineClusterIntegrationTest extends BaseClusterIntegrationTestSet } @Test + public void testCaseWhenStatement() + throws Exception { + testCountVsCaseQuery("origin = 'ATL'"); + testCountVsCaseQuery("origin <> 'ATL'"); + + testCountVsCaseQuery("DaysSinceEpoch > 16312"); + testCountVsCaseQuery("DaysSinceEpoch >= 16312"); + testCountVsCaseQuery("DaysSinceEpoch < 16312"); + testCountVsCaseQuery("DaysSinceEpoch <= 16312"); + testCountVsCaseQuery("DaysSinceEpoch = 16312"); + testCountVsCaseQuery("DaysSinceEpoch <> 16312"); + } + + private void testCountVsCaseQuery(String predicate) + throws Exception { + // System.out.println("predicate = " + predicate); + String sqlQuery = String.format("SELECT COUNT(*) FROM mytable WHERE %s", predicate); + JsonNode response = postSqlQuery(sqlQuery, _brokerBaseApiUrl); + // System.out.println(String.format("query = %s, response = %s",sqlQuery, response)); + long countValue = response.get("resultTable").get("rows").get(0).get(0).asLong(); + sqlQuery = String.format("SELECT SUM(CASE WHEN %s THEN 1 ELSE 0 END) as sum1 FROM mytable", predicate); + response = postSqlQuery(sqlQuery, _brokerBaseApiUrl); + // System.out.println(String.format("query = %s, response = %s",sqlQuery, response)); + long caseSum = response.get("resultTable").get("rows").get(0).get(0).asLong(); + Assert.assertEquals(caseSum, countValue); + } + + @Test public void testFilterWithInvertedIndexUDF() throws Exception { int daysSinceEpoch = 16138; --------------------------------------------------------------------- To unsubscribe, e-mail: commits-unsubscr...@pinot.apache.org For additional commands, e-mail: commits-h...@pinot.apache.org