You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@phoenix.apache.org by td...@apache.org on 2015/06/24 22:24:38 UTC
[42/49] phoenix git commit: PHOENIX-1660 Implement missing math
built-in functions ABS, POWER, LN, LOG, SQRT, CBRT, EXP (Shuxiong Ye)
http://git-wip-us.apache.org/repos/asf/phoenix/blob/c2927dde/phoenix-core/src/test/java/org/apache/phoenix/expression/ExpFunctionTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/expression/ExpFunctionTest.java b/phoenix-core/src/test/java/org/apache/phoenix/expression/ExpFunctionTest.java
new file mode 100644
index 0000000..b7b95c2
--- /dev/null
+++ b/phoenix-core/src/test/java/org/apache/phoenix/expression/ExpFunctionTest.java
@@ -0,0 +1,150 @@
+/*
+ * 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.phoenix.expression;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigDecimal;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Random;
+
+import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
+import org.apache.phoenix.expression.function.ExpFunction;
+import org.apache.phoenix.schema.SortOrder;
+import org.apache.phoenix.schema.types.PDecimal;
+import org.apache.phoenix.schema.types.PDouble;
+import org.apache.phoenix.schema.types.PFloat;
+import org.apache.phoenix.schema.types.PInteger;
+import org.apache.phoenix.schema.types.PLong;
+import org.apache.phoenix.schema.types.PNumericType;
+import org.apache.phoenix.schema.types.PSmallint;
+import org.apache.phoenix.schema.types.PTinyint;
+import org.apache.phoenix.schema.types.PUnsignedDouble;
+import org.apache.phoenix.schema.types.PUnsignedFloat;
+import org.apache.phoenix.schema.types.PUnsignedInt;
+import org.apache.phoenix.schema.types.PUnsignedLong;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Unit tests for {@link ExpFunction}
+ */
+public class ExpFunctionTest {
+ private static final double ZERO = 1e-9;
+
+ private static boolean twoDoubleEquals(double a, double b) {
+ if (Double.isNaN(a) ^ Double.isNaN(b)) return false;
+ if (Double.isNaN(a)) return true;
+ if (Double.isInfinite(a) ^ Double.isInfinite(b)) return false;
+ if (Double.isInfinite(a)) {
+ if ((a > 0) ^ (b > 0)) return false;
+ else return true;
+ }
+ if (Math.abs(a - b) <= ZERO) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private static boolean testExpression(LiteralExpression literal, double expected)
+ throws SQLException {
+ List<Expression> expressions = Lists.newArrayList((Expression) literal);
+ Expression sqrtFunction = new ExpFunction(expressions);
+ ImmutableBytesWritable ptr = new ImmutableBytesWritable();
+ boolean ret = sqrtFunction.evaluate(null, ptr);
+ if (ret) {
+ Double result =
+ (Double) sqrtFunction.getDataType().toObject(ptr, sqrtFunction.getSortOrder());
+ assertTrue(twoDoubleEquals(result.doubleValue(), expected));
+ }
+ return ret;
+ }
+
+ private static void test(Number value, PNumericType dataType, double expected)
+ throws SQLException {
+ LiteralExpression literal;
+ literal = LiteralExpression.newConstant(value, dataType, SortOrder.ASC);
+ boolean ret1 = testExpression(literal, expected);
+ literal = LiteralExpression.newConstant(value, dataType, SortOrder.DESC);
+ boolean ret2 = testExpression(literal, expected);
+ assertEquals(ret1, ret2);
+ }
+
+ private static void testBatch(Number[] value, PNumericType dataType) throws SQLException {
+ double[] expected = new double[value.length];
+ for (int i = 0; i < expected.length; ++i) {
+ expected[i] = Math.exp(value[i].doubleValue());
+ }
+ assertEquals(value.length, expected.length);
+ for (int i = 0; i < value.length; ++i) {
+ test(value[i], dataType, expected[i]);
+ }
+ }
+
+ @Test
+ public void testSqrtFunction() throws Exception {
+ Random random = new Random();
+
+ testBatch(
+ new BigDecimal[] { BigDecimal.valueOf(1.0), BigDecimal.valueOf(0.0),
+ BigDecimal.valueOf(-1.0), BigDecimal.valueOf(123.1234),
+ BigDecimal.valueOf(-123.1234), BigDecimal.valueOf(random.nextDouble()),
+ BigDecimal.valueOf(random.nextDouble()) }, PDecimal.INSTANCE);
+
+ testBatch(new Float[] { 1.0f, 0.0f, -1.0f, 123.1234f, -123.1234f, random.nextFloat(),
+ random.nextFloat() }, PFloat.INSTANCE);
+
+ testBatch(new Float[] { 1.0f, 0.0f, -1.0f, 123.1234f, -123.1234f, random.nextFloat(),
+ random.nextFloat() }, PFloat.INSTANCE);
+
+ testBatch(new Float[] { 1.0f, 0.0f, 123.1234f, }, PUnsignedFloat.INSTANCE);
+
+ testBatch(
+ new Double[] { 1.0, 0.0, -1.0, 123.1234, -123.1234, random.nextDouble(),
+ random.nextDouble() }, PDouble.INSTANCE);
+
+ testBatch(new Double[] { 1.0, 0.0, 123.1234, }, PUnsignedDouble.INSTANCE);
+
+ testBatch(
+ new Long[] { 1L, 0L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 123L, -123L,
+ random.nextLong(), random.nextLong() }, PLong.INSTANCE);
+
+ testBatch(new Long[] { 1L, 0L, Long.MAX_VALUE, 123L }, PUnsignedLong.INSTANCE);
+
+ testBatch(
+ new Integer[] { 1, 0, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 123, -123,
+ random.nextInt(), random.nextInt() }, PInteger.INSTANCE);
+
+ testBatch(new Integer[] { 1, 0, Integer.MAX_VALUE, 123 }, PUnsignedInt.INSTANCE);
+
+ testBatch(new Short[] { (short) 1, (short) 0, (short) -1, Short.MAX_VALUE, Short.MIN_VALUE,
+ (short) 123, (short) -123 }, PSmallint.INSTANCE);
+
+ testBatch(new Short[] { (short) 1, (short) 0, Short.MAX_VALUE, (short) 123 },
+ PSmallint.INSTANCE);
+
+ testBatch(new Byte[] { (byte) 1, (byte) 0, (byte) -1, Byte.MAX_VALUE, Byte.MIN_VALUE,
+ (byte) 123, (byte) -123 }, PTinyint.INSTANCE);
+
+ testBatch(new Byte[] { (byte) 1, (byte) 0, Byte.MAX_VALUE, (byte) 123 }, PTinyint.INSTANCE);
+ }
+}
http://git-wip-us.apache.org/repos/asf/phoenix/blob/c2927dde/phoenix-core/src/test/java/org/apache/phoenix/expression/LnLogFunctionTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/expression/LnLogFunctionTest.java b/phoenix-core/src/test/java/org/apache/phoenix/expression/LnLogFunctionTest.java
new file mode 100644
index 0000000..a5e6fc7
--- /dev/null
+++ b/phoenix-core/src/test/java/org/apache/phoenix/expression/LnLogFunctionTest.java
@@ -0,0 +1,182 @@
+/*
+ * 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.phoenix.expression;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigDecimal;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Random;
+
+import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
+import org.apache.phoenix.expression.function.LnFunction;
+import org.apache.phoenix.expression.function.LogFunction;
+import org.apache.phoenix.schema.SortOrder;
+import org.apache.phoenix.schema.types.PDecimal;
+import org.apache.phoenix.schema.types.PDouble;
+import org.apache.phoenix.schema.types.PFloat;
+import org.apache.phoenix.schema.types.PInteger;
+import org.apache.phoenix.schema.types.PLong;
+import org.apache.phoenix.schema.types.PNumericType;
+import org.apache.phoenix.schema.types.PSmallint;
+import org.apache.phoenix.schema.types.PTinyint;
+import org.apache.phoenix.schema.types.PUnsignedDouble;
+import org.apache.phoenix.schema.types.PUnsignedFloat;
+import org.apache.phoenix.schema.types.PUnsignedInt;
+import org.apache.phoenix.schema.types.PUnsignedLong;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Unit tests for {@link LnFunction} and {@link LogFunction}
+ */
+public class LnLogFunctionTest {
+ private static final double ZERO = 1e-9;
+ private static final Expression THREE = LiteralExpression.newConstant(3);
+ private static final Expression DEFAULT_VALUE = LiteralExpression.newConstant(10.0);
+
+ private static boolean twoDoubleEquals(double a, double b) {
+ if (Double.isNaN(a) ^ Double.isNaN(b)) return false;
+ if (Double.isNaN(a)) return true;
+ if (Double.isInfinite(a) ^ Double.isInfinite(b)) return false;
+ if (Double.isInfinite(a)) {
+ if ((a > 0) ^ (b > 0)) return false;
+ else return true;
+ }
+ if (Math.abs(a - b) <= ZERO) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private static boolean testExpression(LiteralExpression literal, LiteralExpression literal2,
+ LiteralExpression literal3, double exptForLn, double exptForLog10, double exptForLog3)
+ throws SQLException {
+ List<Expression> expressionsLn = Lists.newArrayList((Expression) literal);
+ List<Expression> expressionsLog10 = Lists.newArrayList(literal2, DEFAULT_VALUE);
+ List<Expression> expressionsLog3 = Lists.newArrayList(literal3, THREE);
+
+ ImmutableBytesWritable ptr = new ImmutableBytesWritable();
+
+ Expression lnFunction = new LnFunction(expressionsLn);
+ boolean retLn = lnFunction.evaluate(null, ptr);
+ if (retLn) {
+ Double result =
+ (Double) lnFunction.getDataType().toObject(ptr, lnFunction.getSortOrder());
+ assertTrue(twoDoubleEquals(result.doubleValue(), exptForLn));
+ }
+
+ Expression log10Function = new LogFunction(expressionsLog10);
+ boolean retLog10 = log10Function.evaluate(null, ptr);
+ if (retLog10) {
+ Double result =
+ (Double) log10Function.getDataType()
+ .toObject(ptr, log10Function.getSortOrder());
+ assertTrue(twoDoubleEquals(result.doubleValue(), exptForLog10));
+ }
+ assertEquals(retLn, retLog10);
+
+ Expression log3Function = new LogFunction(expressionsLog3);
+ boolean retLog3 = log3Function.evaluate(null, ptr);
+ if (retLog3) {
+ Double result =
+ (Double) log3Function.getDataType().toObject(ptr, log3Function.getSortOrder());
+ assertTrue(twoDoubleEquals(result.doubleValue(), exptForLog3));
+ }
+ assertEquals(retLn, retLog3);
+ return retLn;
+ }
+
+ private static void test(Number value, PNumericType dataType, double exptForLn,
+ double exptForLog10, double exptForLog3) throws SQLException {
+ LiteralExpression literal, literal2, literal3;
+ literal = LiteralExpression.newConstant(value, dataType, SortOrder.ASC);
+ literal2 = LiteralExpression.newConstant(value, dataType, SortOrder.ASC);
+ literal3 = LiteralExpression.newConstant(value, dataType, SortOrder.ASC);
+ boolean ret1 =
+ testExpression(literal, literal2, literal3, exptForLn, exptForLog10, exptForLog3);
+ literal = LiteralExpression.newConstant(value, dataType, SortOrder.DESC);
+ literal2 = LiteralExpression.newConstant(value, dataType, SortOrder.DESC);
+ literal3 = LiteralExpression.newConstant(value, dataType, SortOrder.DESC);
+ boolean ret2 =
+ testExpression(literal, literal2, literal3, exptForLn, exptForLog10, exptForLog3);
+ assertEquals(ret1, ret2);
+ }
+
+ private static void testBatch(Number[] value, PNumericType dataType) throws SQLException {
+ double[][] expected = new double[value.length][3];
+ for (int i = 0; i < expected.length; ++i) {
+ expected[i][0] = Math.log(value[i].doubleValue());
+ expected[i][1] = Math.log10(value[i].doubleValue());
+ expected[i][2] = Math.log10(value[i].doubleValue()) / Math.log10(3);
+ }
+ assertEquals(value.length, expected.length);
+ for (int i = 0; i < value.length; ++i) {
+ test(value[i], dataType, expected[i][0], expected[i][1], expected[i][2]);
+ }
+ }
+
+ @Test
+ public void testLnLogFunction() throws Exception {
+ Random random = new Random();
+
+ testBatch(
+ new BigDecimal[] { BigDecimal.valueOf(1.0), BigDecimal.valueOf(0.0),
+ BigDecimal.valueOf(-1.0), BigDecimal.valueOf(123.1234),
+ BigDecimal.valueOf(-123.1234), BigDecimal.valueOf(random.nextDouble()),
+ BigDecimal.valueOf(random.nextDouble()) }, PDecimal.INSTANCE);
+
+ testBatch(new Float[] { 1.0f, 0.0f, -1.0f, 123.1234f, -123.1234f, random.nextFloat(),
+ random.nextFloat() }, PFloat.INSTANCE);
+
+ testBatch(new Float[] { 1.0f, 0.0f, 123.1234f, }, PUnsignedFloat.INSTANCE);
+
+ testBatch(
+ new Double[] { 1.0, 0.0, -1.0, 123.1234, -123.1234, random.nextDouble(),
+ random.nextDouble() }, PDouble.INSTANCE);
+
+ testBatch(new Double[] { 1.0, 0.0, 123.1234, }, PUnsignedDouble.INSTANCE);
+
+ testBatch(
+ new Long[] { 1L, 0L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 123L, -123L,
+ random.nextLong(), random.nextLong() }, PLong.INSTANCE);
+
+ testBatch(new Long[] { 1L, 0L, Long.MAX_VALUE, 123L }, PUnsignedLong.INSTANCE);
+
+ testBatch(
+ new Integer[] { 1, 0, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 123, -123,
+ random.nextInt(), random.nextInt() }, PInteger.INSTANCE);
+
+ testBatch(new Integer[] { 1, 0, Integer.MAX_VALUE, 123 }, PUnsignedInt.INSTANCE);
+
+ testBatch(new Short[] { (short) 1, (short) 0, (short) -1, Short.MAX_VALUE, Short.MIN_VALUE,
+ (short) 123, (short) -123 }, PSmallint.INSTANCE);
+
+ testBatch(new Short[] { (short) 1, (short) 0, Short.MAX_VALUE, (short) 123 },
+ PSmallint.INSTANCE);
+
+ testBatch(new Byte[] { (byte) 1, (byte) 0, (byte) -1, Byte.MAX_VALUE, Byte.MIN_VALUE,
+ (byte) 123, (byte) -123 }, PTinyint.INSTANCE);
+
+ testBatch(new Byte[] { (byte) 1, (byte) 0, Byte.MAX_VALUE, (byte) 123 }, PTinyint.INSTANCE);
+ }
+}
http://git-wip-us.apache.org/repos/asf/phoenix/blob/c2927dde/phoenix-core/src/test/java/org/apache/phoenix/expression/PowerFunctionTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/expression/PowerFunctionTest.java b/phoenix-core/src/test/java/org/apache/phoenix/expression/PowerFunctionTest.java
new file mode 100644
index 0000000..9710e52
--- /dev/null
+++ b/phoenix-core/src/test/java/org/apache/phoenix/expression/PowerFunctionTest.java
@@ -0,0 +1,182 @@
+/*
+ * 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.phoenix.expression;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigDecimal;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Random;
+
+import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
+import org.apache.phoenix.expression.function.PowerFunction;
+import org.apache.phoenix.schema.SortOrder;
+import org.apache.phoenix.schema.types.PDecimal;
+import org.apache.phoenix.schema.types.PDouble;
+import org.apache.phoenix.schema.types.PFloat;
+import org.apache.phoenix.schema.types.PInteger;
+import org.apache.phoenix.schema.types.PLong;
+import org.apache.phoenix.schema.types.PNumericType;
+import org.apache.phoenix.schema.types.PSmallint;
+import org.apache.phoenix.schema.types.PTinyint;
+import org.apache.phoenix.schema.types.PUnsignedDouble;
+import org.apache.phoenix.schema.types.PUnsignedFloat;
+import org.apache.phoenix.schema.types.PUnsignedInt;
+import org.apache.phoenix.schema.types.PUnsignedLong;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Unit tests for {@link PowerFunction}
+ */
+public class PowerFunctionTest {
+ private static final double ZERO = 1e-9;
+ private static final Expression ONE_POINT_FIVE = LiteralExpression.newConstant(1.5);
+ private static final Expression TWO = LiteralExpression.newConstant(2);
+ private static final Expression THREE = LiteralExpression.newConstant(3);
+
+ private static boolean twoDoubleEquals(double a, double b) {
+ if (Double.isNaN(a) ^ Double.isNaN(b)) return false;
+ if (Double.isNaN(a)) return true;
+ if (Double.isInfinite(a) ^ Double.isInfinite(b)) return false;
+ if (Double.isInfinite(a)) {
+ if ((a > 0) ^ (b > 0)) return false;
+ else return true;
+ }
+ if (Math.abs(a - b) <= ZERO) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private static boolean testExpression(LiteralExpression literal, LiteralExpression literal2,
+ LiteralExpression literal3, double exptFor15, double exptFor2, double exptFor3)
+ throws SQLException {
+ List<Expression> expressions15 = Lists.newArrayList(literal, ONE_POINT_FIVE);
+ List<Expression> expressions2 = Lists.newArrayList(literal2, TWO);
+ List<Expression> expressions3 = Lists.newArrayList(literal3, THREE);
+
+ ImmutableBytesWritable ptr = new ImmutableBytesWritable();
+
+ Expression powerFunction15 = new PowerFunction(expressions15);
+ boolean ret15 = powerFunction15.evaluate(null, ptr);
+ if (ret15) {
+ Double result =
+ (Double) powerFunction15.getDataType().toObject(ptr,
+ powerFunction15.getSortOrder());
+ assertTrue(twoDoubleEquals(result.doubleValue(), exptFor15));
+ }
+
+ Expression powerFunction2 = new PowerFunction(expressions2);
+ boolean ret2 = powerFunction2.evaluate(null, ptr);
+ if (ret2) {
+ Double result =
+ (Double) powerFunction2.getDataType().toObject(ptr,
+ powerFunction2.getSortOrder());
+ assertTrue(twoDoubleEquals(result.doubleValue(), exptFor2));
+ }
+ assertEquals(ret15, ret2);
+
+ Expression powerFunction3 = new PowerFunction(expressions3);
+ boolean ret3 = powerFunction3.evaluate(null, ptr);
+ if (ret3) {
+ Double result =
+ (Double) powerFunction3.getDataType().toObject(ptr,
+ powerFunction3.getSortOrder());
+ assertTrue(twoDoubleEquals(result.doubleValue(), exptFor3));
+ }
+ assertEquals(ret15, ret3);
+ return ret15;
+ }
+
+ private static void test(Number value, PNumericType dataType, double exptFor15,
+ double exptFor2, double exptFor3) throws SQLException {
+ LiteralExpression literal, literal2, literal3;
+ literal = LiteralExpression.newConstant(value, dataType, SortOrder.ASC);
+ literal2 = LiteralExpression.newConstant(value, dataType, SortOrder.ASC);
+ literal3 = LiteralExpression.newConstant(value, dataType, SortOrder.ASC);
+ boolean ret1 = testExpression(literal, literal2, literal3, exptFor15, exptFor2, exptFor3);
+ literal = LiteralExpression.newConstant(value, dataType, SortOrder.DESC);
+ literal2 = LiteralExpression.newConstant(value, dataType, SortOrder.DESC);
+ literal3 = LiteralExpression.newConstant(value, dataType, SortOrder.DESC);
+ boolean ret2 = testExpression(literal, literal2, literal3, exptFor15, exptFor2, exptFor3);
+ assertEquals(ret1, ret2);
+ }
+
+ private static void testBatch(Number[] value, PNumericType dataType) throws SQLException {
+ double[][] expected = new double[value.length][3];
+ for (int i = 0; i < expected.length; ++i) {
+ expected[i][0] = Math.pow(value[i].doubleValue(), 1.5);
+ expected[i][1] = Math.pow(value[i].doubleValue(), 2);
+ expected[i][2] = Math.pow(value[i].doubleValue(), 3);
+ }
+ assertEquals(value.length, expected.length);
+ for (int i = 0; i < value.length; ++i) {
+ test(value[i], dataType, expected[i][0], expected[i][1], expected[i][2]);
+ }
+ }
+
+ @Test
+ public void testLnLogFunction() throws Exception {
+ Random random = new Random();
+
+ testBatch(
+ new BigDecimal[] { BigDecimal.valueOf(1.0), BigDecimal.valueOf(0.0),
+ BigDecimal.valueOf(-1.0), BigDecimal.valueOf(123.1234),
+ BigDecimal.valueOf(-123.1234), BigDecimal.valueOf(random.nextDouble()),
+ BigDecimal.valueOf(random.nextDouble()) }, PDecimal.INSTANCE);
+
+ testBatch(new Float[] { 1.0f, 0.0f, -1.0f, 123.1234f, -123.1234f, random.nextFloat(),
+ random.nextFloat() }, PFloat.INSTANCE);
+
+ testBatch(new Float[] { 1.0f, 0.0f, 123.1234f, }, PUnsignedFloat.INSTANCE);
+
+ testBatch(
+ new Double[] { 1.0, 0.0, -1.0, 123.1234, -123.1234, random.nextDouble(),
+ random.nextDouble() }, PDouble.INSTANCE);
+
+ testBatch(new Double[] { 1.0, 0.0, 123.1234, }, PUnsignedDouble.INSTANCE);
+
+ testBatch(
+ new Long[] { 1L, 0L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 123L, -123L,
+ random.nextLong(), random.nextLong() }, PLong.INSTANCE);
+
+ testBatch(new Long[] { 1L, 0L, Long.MAX_VALUE, 123L }, PUnsignedLong.INSTANCE);
+
+ testBatch(
+ new Integer[] { 1, 0, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 123, -123,
+ random.nextInt(), random.nextInt() }, PInteger.INSTANCE);
+
+ testBatch(new Integer[] { 1, 0, Integer.MAX_VALUE, 123 }, PUnsignedInt.INSTANCE);
+
+ testBatch(new Short[] { (short) 1, (short) 0, (short) -1, Short.MAX_VALUE, Short.MIN_VALUE,
+ (short) 123, (short) -123 }, PSmallint.INSTANCE);
+
+ testBatch(new Short[] { (short) 1, (short) 0, Short.MAX_VALUE, (short) 123 },
+ PSmallint.INSTANCE);
+
+ testBatch(new Byte[] { (byte) 1, (byte) 0, (byte) -1, Byte.MAX_VALUE, Byte.MIN_VALUE,
+ (byte) 123, (byte) -123 }, PTinyint.INSTANCE);
+
+ testBatch(new Byte[] { (byte) 1, (byte) 0, Byte.MAX_VALUE, (byte) 123 }, PTinyint.INSTANCE);
+ }
+}