From 6ceec0e7f9b8d2fb892c4936f12f9d628465e4e8 Mon Sep 17 00:00:00 2001 From: tarushapptech Date: Fri, 9 Jun 2017 21:32:39 +0530 Subject: [PATCH 1/6] commiting changes for power functions --- .../operator/math/BeamSqlPowerExpression.java | 69 +++++++++++++++++++ .../math/BeamSqlMathBinaryExpressionTest.java | 54 +++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java new file mode 100644 index 000000000000..941043e24748 --- /dev/null +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java @@ -0,0 +1,69 @@ +/* + * 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.beam.dsls.sql.interpreter.operator.math; + +import java.util.List; +import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlExpression; +import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlPrimitive; +import org.apache.calcite.runtime.SqlFunctions; +import org.apache.calcite.sql.type.SqlTypeName; + + +/** + * {@code BeamSqlMathBinaryExpression} for 'POWER' function. + */ +public class BeamSqlPowerExpression extends BeamSqlMathBinaryExpression { + + public BeamSqlPowerExpression(List operands) { + super(operands); + } + + @Override public BeamSqlPrimitive calculate(BeamSqlPrimitive leftOp, + BeamSqlPrimitive rightOp) { + BeamSqlPrimitive result = null; + if (SqlTypeName.INT_TYPES.contains(leftOp.getOutputType()) && SqlTypeName.INT_TYPES + .contains(rightOp.getOutputType())) { + + result = BeamSqlPrimitive.of(SqlTypeName.BIGINT, SqlFunctions.toLong(SqlFunctions + .power(SqlFunctions.toLong(leftOp.getValue()), SqlFunctions.toLong(rightOp.getValue())))); + + } else if (SqlTypeName.APPROX_TYPES.contains(leftOp.getOutputType()) || SqlTypeName.APPROX_TYPES + .contains(rightOp.getOutputType())) { + + result = BeamSqlPrimitive.of(SqlTypeName.DOUBLE, SqlFunctions + .power(SqlFunctions.toDouble(leftOp.getValue()), + SqlFunctions.toDouble(rightOp.getValue()))); + + } else if (SqlTypeName.BIGINT.equals(leftOp.getOutputType()) && SqlTypeName.DECIMAL + .equals(rightOp.getOutputType())) { + + result = BeamSqlPrimitive.of(SqlTypeName.DOUBLE, + SqlFunctions.power(leftOp.getLong(), SqlFunctions.toBigDecimal(rightOp.getValue()))); + + } else if (SqlTypeName.DECIMAL.equals(leftOp.getOutputType()) || SqlTypeName.DECIMAL + .equals(rightOp.getOutputType())) { + + result = BeamSqlPrimitive.of(SqlTypeName.DOUBLE, SqlFunctions + .power(SqlFunctions.toBigDecimal(leftOp.getValue()), + SqlFunctions.toBigDecimal(rightOp.getValue()))); + } + return result; + } + +} diff --git a/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java b/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java index 58107e8e8655..1ec1edab3771 100644 --- a/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java +++ b/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java @@ -135,4 +135,58 @@ public class BeamSqlMathBinaryExpressionTest extends BeamSqlFnExecutorTestBase { assertEquals(1234567L, new BeamSqlRoundExpression(operands).evaluate(record).getValue()); } + @Test public void testPowerFunction() { + // test power functions with operands of type bigint, int, + // tinyint, smallint, double, decimal + List operands = new ArrayList<>(); + + operands.add(BeamSqlPrimitive.of(SqlTypeName.DOUBLE, 2.0)); + operands.add(BeamSqlPrimitive.of(SqlTypeName.DOUBLE, 4.0)); + Assert.assertEquals(16.0, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + // power(integer,integer) => long + operands.clear(); + operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); + operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); + assertEquals(4L, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + // power(integer,long) => long + operands.clear(); + operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); + operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 3L)); + assertEquals(8L, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + + // power(long,long) => long + operands.clear(); + operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 2L)); + operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 2L)); + assertEquals(4L, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + + // power(double, int) => double + operands.clear(); + operands.add(BeamSqlPrimitive.of(SqlTypeName.DOUBLE, 1.1)); + operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 1)); + assertEquals(1.1, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + + // power(double, long) => double + operands.clear(); + operands.add(BeamSqlPrimitive.of(SqlTypeName.DOUBLE, 1.1)); + operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 1L)); + assertEquals(1.1, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + + // power(integer, double) => double + operands.clear(); + operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); + operands.add(BeamSqlPrimitive.of(SqlTypeName.DOUBLE, 2.2)); + assertEquals(4.59479341998814, + new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + + // operand with a BeamSqlInputRefExpression + operands.clear(); + BeamSqlInputRefExpression ref0 = new BeamSqlInputRefExpression(SqlTypeName.BIGINT, 0); + operands.add(ref0); + operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 2L)); + + Assert.assertEquals(1524155677489L, + new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + } + } From 3b24a5e9327cda7e1007a8d9069003b4cffd6c1e Mon Sep 17 00:00:00 2001 From: tarushapptech Date: Sat, 17 Jun 2017 17:27:24 +0530 Subject: [PATCH 2/6] commiting changes for bigint and decimal to all int types and decimal --- .../beam/dsls/sql/interpreter/BeamSqlFnExecutor.java | 7 +++++++ .../interpreter/operator/math/BeamSqlPowerExpression.java | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java index 4678da56ed70..3864b4601b22 100644 --- a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java @@ -63,6 +63,7 @@ import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlLnExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlLogExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlRadiansExpression; +import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlPowerExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlRoundExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlSignExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlSinExpression; @@ -278,6 +279,12 @@ static BeamSqlExpression buildExpression(RexNode rexNode) { case "SIGN": ret = new BeamSqlSignExpression(subExps); break; + case "POWER": + ret = new BeamSqlPowerExpression(subExps); + break; + case "POW": + ret = new BeamSqlPowerExpression(subExps); + break; // string operators case "||": diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java index 941043e24748..0c318885638d 100644 --- a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java @@ -50,7 +50,7 @@ public BeamSqlPowerExpression(List operands) { .power(SqlFunctions.toDouble(leftOp.getValue()), SqlFunctions.toDouble(rightOp.getValue()))); - } else if (SqlTypeName.BIGINT.equals(leftOp.getOutputType()) && SqlTypeName.DECIMAL + } else if (SqlTypeName.INT_TYPES.equals(leftOp.getOutputType()) && SqlTypeName.DECIMAL .equals(rightOp.getOutputType())) { result = BeamSqlPrimitive.of(SqlTypeName.DOUBLE, From b8b859302dcd4b6d408a10dd06eff00a485c28a1 Mon Sep 17 00:00:00 2001 From: tarushapptech Date: Mon, 26 Jun 2017 19:01:36 +0530 Subject: [PATCH 3/6] fixed checksytle issue --- .../org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java index 3864b4601b22..c68d69fbbe4d 100644 --- a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java @@ -62,8 +62,8 @@ import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlExpExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlLnExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlLogExpression; -import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlRadiansExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlPowerExpression; +import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlRadiansExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlRoundExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlSignExpression; import org.apache.beam.dsls.sql.interpreter.operator.math.BeamSqlSinExpression; From 7e9b844bc18938b8cb4927e528e9a9fc2e7de316 Mon Sep 17 00:00:00 2001 From: tarushapptech Date: Thu, 6 Jul 2017 19:11:33 +0530 Subject: [PATCH 4/6] commiting changes for review comments --- .../sql/interpreter/BeamSqlFnExecutor.java | 3 -- .../operator/math/BeamSqlPowerExpression.java | 33 +++---------------- .../math/BeamSqlMathBinaryExpressionTest.java | 17 +++------- 3 files changed, 8 insertions(+), 45 deletions(-) diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java index c68d69fbbe4d..749ff1b35ce7 100644 --- a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/BeamSqlFnExecutor.java @@ -282,9 +282,6 @@ static BeamSqlExpression buildExpression(RexNode rexNode) { case "POWER": ret = new BeamSqlPowerExpression(subExps); break; - case "POW": - ret = new BeamSqlPowerExpression(subExps); - break; // string operators case "||": diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java index 0c318885638d..49cb17343ffc 100644 --- a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java @@ -19,12 +19,12 @@ package org.apache.beam.dsls.sql.interpreter.operator.math; import java.util.List; + import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlExpression; import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlPrimitive; import org.apache.calcite.runtime.SqlFunctions; import org.apache.calcite.sql.type.SqlTypeName; - /** * {@code BeamSqlMathBinaryExpression} for 'POWER' function. */ @@ -36,34 +36,9 @@ public BeamSqlPowerExpression(List operands) { @Override public BeamSqlPrimitive calculate(BeamSqlPrimitive leftOp, BeamSqlPrimitive rightOp) { - BeamSqlPrimitive result = null; - if (SqlTypeName.INT_TYPES.contains(leftOp.getOutputType()) && SqlTypeName.INT_TYPES - .contains(rightOp.getOutputType())) { - - result = BeamSqlPrimitive.of(SqlTypeName.BIGINT, SqlFunctions.toLong(SqlFunctions - .power(SqlFunctions.toLong(leftOp.getValue()), SqlFunctions.toLong(rightOp.getValue())))); - - } else if (SqlTypeName.APPROX_TYPES.contains(leftOp.getOutputType()) || SqlTypeName.APPROX_TYPES - .contains(rightOp.getOutputType())) { - - result = BeamSqlPrimitive.of(SqlTypeName.DOUBLE, SqlFunctions - .power(SqlFunctions.toDouble(leftOp.getValue()), - SqlFunctions.toDouble(rightOp.getValue()))); - - } else if (SqlTypeName.INT_TYPES.equals(leftOp.getOutputType()) && SqlTypeName.DECIMAL - .equals(rightOp.getOutputType())) { - - result = BeamSqlPrimitive.of(SqlTypeName.DOUBLE, - SqlFunctions.power(leftOp.getLong(), SqlFunctions.toBigDecimal(rightOp.getValue()))); - - } else if (SqlTypeName.DECIMAL.equals(leftOp.getOutputType()) || SqlTypeName.DECIMAL - .equals(rightOp.getOutputType())) { - - result = BeamSqlPrimitive.of(SqlTypeName.DOUBLE, SqlFunctions - .power(SqlFunctions.toBigDecimal(leftOp.getValue()), - SqlFunctions.toBigDecimal(rightOp.getValue()))); - } - return result; + return BeamSqlPrimitive.of(SqlTypeName.DOUBLE, SqlFunctions + .power(SqlFunctions.toDouble(leftOp.getValue()), + SqlFunctions.toDouble(rightOp.getValue()))); } } diff --git a/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java b/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java index 1ec1edab3771..6b600a9da168 100644 --- a/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java +++ b/dsls/sql/src/test/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlMathBinaryExpressionTest.java @@ -147,18 +147,18 @@ public class BeamSqlMathBinaryExpressionTest extends BeamSqlFnExecutorTestBase { operands.clear(); operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); - assertEquals(4L, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + assertEquals(4.0, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); // power(integer,long) => long operands.clear(); operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 3L)); - assertEquals(8L, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + assertEquals(8.0, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); // power(long,long) => long operands.clear(); operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 2L)); operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 2L)); - assertEquals(4L, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); + assertEquals(4.0, new BeamSqlPowerExpression(operands).evaluate(record).getValue()); // power(double, int) => double operands.clear(); @@ -176,16 +176,7 @@ public class BeamSqlMathBinaryExpressionTest extends BeamSqlFnExecutorTestBase { operands.clear(); operands.add(BeamSqlPrimitive.of(SqlTypeName.INTEGER, 2)); operands.add(BeamSqlPrimitive.of(SqlTypeName.DOUBLE, 2.2)); - assertEquals(4.59479341998814, - new BeamSqlPowerExpression(operands).evaluate(record).getValue()); - - // operand with a BeamSqlInputRefExpression - operands.clear(); - BeamSqlInputRefExpression ref0 = new BeamSqlInputRefExpression(SqlTypeName.BIGINT, 0); - operands.add(ref0); - operands.add(BeamSqlPrimitive.of(SqlTypeName.BIGINT, 2L)); - - Assert.assertEquals(1524155677489L, + assertEquals(Math.pow(2, 2.2), new BeamSqlPowerExpression(operands).evaluate(record).getValue()); } From ffa18937a54ced4debe18e7974dad3f52bfe9da4 Mon Sep 17 00:00:00 2001 From: tarushapptech Date: Thu, 6 Jul 2017 21:32:41 +0530 Subject: [PATCH 5/6] refactor --- .../sql/interpreter/operator/math/BeamSqlPowerExpression.java | 1 - 1 file changed, 1 deletion(-) diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java index 49cb17343ffc..ff24d6c5e0b2 100644 --- a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java @@ -19,7 +19,6 @@ package org.apache.beam.dsls.sql.interpreter.operator.math; import java.util.List; - import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlExpression; import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlPrimitive; import org.apache.calcite.runtime.SqlFunctions; From e86b19d68fffa66773fe210bd7debd55dda2a7e3 Mon Sep 17 00:00:00 2001 From: tarushapptech Date: Fri, 7 Jul 2017 10:42:50 +0530 Subject: [PATCH 6/6] added outputtype --- .../sql/interpreter/operator/math/BeamSqlPowerExpression.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java index ff24d6c5e0b2..41432980195d 100644 --- a/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java +++ b/dsls/sql/src/main/java/org/apache/beam/dsls/sql/interpreter/operator/math/BeamSqlPowerExpression.java @@ -19,6 +19,7 @@ package org.apache.beam.dsls.sql.interpreter.operator.math; import java.util.List; + import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlExpression; import org.apache.beam.dsls.sql.interpreter.operator.BeamSqlPrimitive; import org.apache.calcite.runtime.SqlFunctions; @@ -31,6 +32,7 @@ public class BeamSqlPowerExpression extends BeamSqlMathBinaryExpression { public BeamSqlPowerExpression(List operands) { super(operands); + this.outputType = SqlTypeName.DOUBLE; } @Override public BeamSqlPrimitive calculate(BeamSqlPrimitive leftOp,