This is an automated email from the ASF dual-hosted git repository. ravipesala pushed a commit to branch branch-1.6 in repository https://gitbox.apache.org/repos/asf/carbondata.git
commit 9e4664742f04b4995bd8a2ecd465e8797ce7c2d2 Author: Vikram Ahuja <vikramahuja8...@gmail.com> AuthorDate: Tue Aug 6 12:21:11 2019 +0530 [CARBONDATA-3489] Optimized the comparator instances in sort Root cause: In case of sorting in the comparator classes(NewRowComparator, RawRowComparator, IntermediateSortTempRowComparator and UnsafeRowComparator) a new SerializableComparator object is been created in the compare method everytime two objects are passed for comparison. Solution: We can reduce the number of SerializeableComparator objects that are been created by storing the SerializeableComparators of primitive datatypes in a map and getting it from the map instead of creating a new SerializeableComparator everytime. This closes #3354 --- .../core/util/comparator/Comparator.java | 49 +++--- .../partition/impl/RawRowComparatorTest.java | 142 ++++++++++++++++ .../IntermediateSortTempRowComparatorTest.java | 178 +++++++++++++++++++++ .../sort/sortdata/NewRowComparatorTest.java | 109 +++++++++++++ 4 files changed, 453 insertions(+), 25 deletions(-) diff --git a/core/src/main/java/org/apache/carbondata/core/util/comparator/Comparator.java b/core/src/main/java/org/apache/carbondata/core/util/comparator/Comparator.java index 6981405..d7e8f80 100644 --- a/core/src/main/java/org/apache/carbondata/core/util/comparator/Comparator.java +++ b/core/src/main/java/org/apache/carbondata/core/util/comparator/Comparator.java @@ -25,24 +25,23 @@ import org.apache.carbondata.core.util.ByteUtil; public final class Comparator { + //Comparators are made static so that only one instance is generated + private static final SerializableComparator BOOLEAN = new BooleanSerializableComparator(); + private static final SerializableComparator INT = new IntSerializableComparator(); + private static final SerializableComparator SHORT = new ShortSerializableComparator(); + private static final SerializableComparator DOUBLE = new DoubleSerializableComparator(); + private static final SerializableComparator FLOAT = new FloatSerializableComparator(); + private static final SerializableComparator LONG = new LongSerializableComparator(); + private static final SerializableComparator DECIMAL = new BigDecimalSerializableComparator(); + private static final SerializableComparator BYTE = new ByteArraySerializableComparator(); + public static SerializableComparator getComparator(DataType dataType) { - if (dataType == DataTypes.BOOLEAN) { - return new BooleanSerializableComparator(); - } else if (dataType == DataTypes.INT) { - return new IntSerializableComparator(); - } else if (dataType == DataTypes.SHORT) { - return new ShortSerializableComparator(); - } else if (dataType == DataTypes.DOUBLE) { - return new DoubleSerializableComparator(); - } else if (dataType == DataTypes.FLOAT) { - return new FloatSerializableComparator(); - } else if (dataType == DataTypes.LONG || dataType == DataTypes.DATE - || dataType == DataTypes.TIMESTAMP) { - return new LongSerializableComparator(); - } else if (DataTypes.isDecimal(dataType)) { - return new BigDecimalSerializableComparator(); + if (dataType == DataTypes.DATE || dataType == DataTypes.TIMESTAMP) { + return LONG; + } else if (dataType == DataTypes.STRING) { + return BYTE; } else { - return new ByteArraySerializableComparator(); + return getComparatorByDataTypeForMeasure(dataType); } } @@ -54,21 +53,21 @@ public final class Comparator { */ public static SerializableComparator getComparatorByDataTypeForMeasure(DataType dataType) { if (dataType == DataTypes.BOOLEAN) { - return new BooleanSerializableComparator(); + return BOOLEAN; } else if (dataType == DataTypes.INT) { - return new IntSerializableComparator(); + return INT; } else if (dataType == DataTypes.SHORT) { - return new ShortSerializableComparator(); + return SHORT; } else if (dataType == DataTypes.LONG) { - return new LongSerializableComparator(); + return LONG; } else if (dataType == DataTypes.DOUBLE) { - return new DoubleSerializableComparator(); + return DOUBLE; } else if (dataType == DataTypes.FLOAT) { - return new FloatSerializableComparator(); + return FLOAT; } else if (DataTypes.isDecimal(dataType)) { - return new BigDecimalSerializableComparator(); + return DECIMAL; } else if (dataType == DataTypes.BYTE) { - return new ByteArraySerializableComparator(); + return BYTE; } else { throw new IllegalArgumentException("Unsupported data type: " + dataType.getName()); } @@ -198,4 +197,4 @@ class BigDecimalSerializableComparator implements SerializableComparator { } return ((BigDecimal) key1).compareTo((BigDecimal) key2); } -} \ No newline at end of file +} diff --git a/processing/src/test/java/org/apache/carbondata/processing/loading/partition/impl/RawRowComparatorTest.java b/processing/src/test/java/org/apache/carbondata/processing/loading/partition/impl/RawRowComparatorTest.java new file mode 100644 index 0000000..ba0fce0 --- /dev/null +++ b/processing/src/test/java/org/apache/carbondata/processing/loading/partition/impl/RawRowComparatorTest.java @@ -0,0 +1,142 @@ +/* + * 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.carbondata.processing.loading.partition.impl; + +import org.apache.carbondata.core.datastore.row.CarbonRow; +import org.apache.carbondata.core.metadata.datatype.DataType; +import org.apache.carbondata.core.metadata.datatype.DataTypes; +import org.apache.carbondata.core.util.comparator.SerializableComparator; + +import org.junit.Assert; +import org.junit.Test; + +public class RawRowComparatorTest { + private RawRowComparator new_comparator; + + @Test public void checkTypes() { + DataType noDicDataTypes[] = + { DataTypes.INT, DataTypes.SHORT, DataTypes.LONG, DataTypes.BOOLEAN, DataTypes.BYTE, + DataTypes.FLOAT }; + for (int i = 0; i < noDicDataTypes.length; i++) { + SerializableComparator comparator = org.apache.carbondata.core.util.comparator.Comparator + .getComparator(noDicDataTypes[i]); + SerializableComparator comparator1 = org.apache.carbondata.core.util.comparator.Comparator + .getComparator(noDicDataTypes[i]); + Assert.assertTrue(comparator1==comparator); + } + } + + @Test public void compareint() { + DataType noDicDataTypes[] = { DataTypes.INT }; + boolean noDicSortColumnMapping[] = { true }; + int sortColumnIndices[] = { 1 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + + Integer arr[] = { 1, 7, 5 }; + Integer arr1[] = { 2, 4, 6 }; + int res = new_comparator.compare(new CarbonRow(arr), new CarbonRow(arr1)); + Assert.assertTrue(res > 0); + } + + @Test public void compareintreverse() { + DataType noDicDataTypes[] = { DataTypes.INT }; + boolean noDicSortColumnMapping[] = { true }; + int sortColumnIndices[] = { 1 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + + Integer arr[] = { 2, 7, 5 }; + Integer arr1[] = { 1, 4, 6 }; + int res = new_comparator.compare(new CarbonRow(arr1), new CarbonRow(arr)); + Assert.assertTrue(res < 0); + } + + @Test public void compareshort() { + DataType noDicDataTypes[] = { DataTypes.SHORT }; + boolean noDicSortColumnMapping[] = { true }; + int sortColumnIndices[] = { 1 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + + Short arr[] = { 1, 7, 5 }; + Short arr1[] = { 2, 4, 6 }; + int res = new_comparator.compare(new CarbonRow(arr), new CarbonRow(arr1)); + Assert.assertTrue(res > 0); + } + + @Test public void comparelong() { + DataType noDicDataTypes[] = { DataTypes.LONG }; + boolean noDicSortColumnMapping[] = { true }; + int sortColumnIndices[] = { 1 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + Long arr[] = { 1L, 7L, 5L }; + Long arr1[] = { 2L, 4L, 6L }; + int res = new_comparator.compare(new CarbonRow(arr), new CarbonRow(arr1)); + Assert.assertTrue(res > 0); + } + + @Test public void comparefloat() { + DataType noDicDataTypes[] = { DataTypes.FLOAT }; + boolean noDicSortColumnMapping[] = { true }; + int sortColumnIndices[] = { 1 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + Float arr[] = { 1F, 7F, 5F }; + Float arr1[] = { 2F, 4F, 6F }; + int res = new_comparator.compare(new CarbonRow(arr), new CarbonRow(arr1)); + Assert.assertTrue(res > 0); + } + + @Test public void compareboolean() { + DataType noDicDataTypes[] = { DataTypes.BOOLEAN }; + boolean noDicSortColumnMapping[] = { true }; + int sortColumnIndices[] = { 1 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + Boolean arr[] = { false, false }; + Boolean arr1[] = { true, true }; + int res = new_comparator.compare(new CarbonRow(arr), new CarbonRow(arr1)); + Assert.assertTrue(res < 0); + } + + @Test public void comparebyte() { + DataType noDicDataTypes[] = { DataTypes.BYTE }; + boolean noDicSortColumnMapping[] = { true }; + int sortColumnIndices[] = { 1 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + Byte arr[] = { 1, 2, 3 }; + Byte arr1[] = { 4, 5, 6 }; + int res = new_comparator.compare(new CarbonRow(arr), new CarbonRow(arr1)); + Assert.assertTrue(res < 0); + } + + @Test public void comparemixed() { + DataType noDicDataTypes[] = { DataTypes.INT, DataTypes.SHORT, DataTypes.BOOLEAN }; + boolean noDicSortColumnMapping[] = { true, true, true }; + int sortColumnIndices[] = { 1, 2, 3 }; + new_comparator = + new RawRowComparator(sortColumnIndices, noDicSortColumnMapping, noDicDataTypes); + Object arr[] = { 1, 2, false }; + Object arr1[] = { 4, 5, true }; + int res = new_comparator.compare(new CarbonRow(arr), new CarbonRow(arr1)); + Assert.assertTrue(res < 0); + } +} diff --git a/processing/src/test/java/org/apache/carbondata/processing/sort/sortdata/IntermediateSortTempRowComparatorTest.java b/processing/src/test/java/org/apache/carbondata/processing/sort/sortdata/IntermediateSortTempRowComparatorTest.java new file mode 100644 index 0000000..a0d1137 --- /dev/null +++ b/processing/src/test/java/org/apache/carbondata/processing/sort/sortdata/IntermediateSortTempRowComparatorTest.java @@ -0,0 +1,178 @@ +/* + * 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.carbondata.processing.sort.sortdata; + +import org.apache.carbondata.core.metadata.datatype.DataType; +import org.apache.carbondata.core.metadata.datatype.DataTypes; +import org.apache.carbondata.processing.loading.row.IntermediateSortTempRow; + +import org.junit.Assert; +import org.junit.Test; + +public class IntermediateSortTempRowComparatorTest { + private IntermediateSortTempRowComparator new_comparator; + + @Test public void compareint() { + DataType noDicDataTypes[] = { DataTypes.INT }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Object[] noDictSortDims1 = {1,2,3}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Object[] noDictSortDims = {4,5,6}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + + int res = new_comparator.compare( a, a1); + Assert.assertTrue(res > 0); + } + + @Test public void compareintreverse() { + DataType noDicDataTypes[] = { DataTypes.INT }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Object[] noDictSortDims1 = {1,2,3}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Object[] noDictSortDims = {4,5,6}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + + int res = new_comparator.compare( a1, a); + Assert.assertTrue(res < 0); + } + + @Test public void comparelong() { + DataType noDicDataTypes[] = { DataTypes.LONG }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Object[] noDictSortDims1 = {1L,2L,3L}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Object[] noDictSortDims = {4L,5L,6L}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + + int res = new_comparator.compare( a1, a); + Assert.assertTrue(res < 0); + } + + @Test public void comparefloat() { + DataType noDicDataTypes[] = { DataTypes.FLOAT }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Object[] noDictSortDims1 = {1F,2F,3F}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Object[] noDictSortDims = {4F,5F,6F}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + + int res = new_comparator.compare( a1, a); + Assert.assertTrue(res < 0); + } + + @Test public void compareboolean() { + DataType noDicDataTypes[] = { DataTypes.BOOLEAN}; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Object[] noDictSortDims1 = {true}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Object[] noDictSortDims = {false}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + int res = new_comparator.compare( a1, a); + Assert.assertTrue(res> 0); + } + + @Test public void comparebyte() { + DataType noDicDataTypes[] = { DataTypes.BYTE}; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Byte[] noDictSortDims1 = {1,2,3}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Byte[] noDictSortDims = {3,4,5}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + int res = new_comparator.compare( a1, a); + Assert.assertTrue(res < 0); + } + + @Test public void comparemixed() { + DataType noDicDataTypes[] = { DataTypes.BOOLEAN, DataTypes.INT, DataTypes.LONG}; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Object[] noDictSortDims1 = {true, 1, 2L}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Object[] noDictSortDims = {false, 3, 5L}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + int res = new_comparator.compare( a1, a); + Assert.assertTrue(res > 0); + } + + @Test public void compareshort() { + DataType noDicDataTypes[] = { DataTypes.SHORT}; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new IntermediateSortTempRowComparator(noDicSortColumnMapping, noDicDataTypes); + + int[] dictSortDims1 = {1,2,3}; + Short[] noDictSortDims1 = {2}; + byte[] noSortDimsAndMeasures1 = {1,2,3}; + IntermediateSortTempRow a1 = new IntermediateSortTempRow(dictSortDims1, noDictSortDims1, noSortDimsAndMeasures1); + + int[] dictSortDims = {1,2,3}; + Short[] noDictSortDims = {1}; + byte[] noSortDimsAndMeasures = {1,2,3}; + IntermediateSortTempRow a = new IntermediateSortTempRow(dictSortDims, noDictSortDims, noSortDimsAndMeasures); + + int res = new_comparator.compare( a1, a); + Assert.assertTrue(res > 0); + } +} diff --git a/processing/src/test/java/org/apache/carbondata/processing/sort/sortdata/NewRowComparatorTest.java b/processing/src/test/java/org/apache/carbondata/processing/sort/sortdata/NewRowComparatorTest.java new file mode 100644 index 0000000..c2bd860 --- /dev/null +++ b/processing/src/test/java/org/apache/carbondata/processing/sort/sortdata/NewRowComparatorTest.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.carbondata.processing.sort.sortdata; + +import org.apache.carbondata.core.metadata.datatype.DataType; +import org.apache.carbondata.core.metadata.datatype.DataTypes; +import org.apache.carbondata.core.util.comparator.SerializableComparator; + +import org.junit.Assert; +import org.junit.Test; + +public class NewRowComparatorTest { + private NewRowComparator new_comparator; + + @Test public void compareint() { + DataType noDicDataTypes[] = { DataTypes.INT }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Integer arr[] = { 1, 7, 5 }; + Integer arr1[] = { 2, 4, 6 }; + int res = new_comparator.compare(arr, arr1); + Assert.assertTrue(res < 0); + } + + @Test public void compareintreverse() { + DataType noDicDataTypes[] = { DataTypes.INT }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Integer arr[] = { 1, 2, 3 }; + Integer arr1[] = { 4, 5, 6 }; + int res = new_comparator.compare(arr1, arr); + Assert.assertTrue(res > 0); + } + + @Test public void compareshort() { + DataType noDicDataTypes[] = { DataTypes.SHORT }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Short arr[] = { 1, 2, 3 }; + Short arr1[] = { 4, 5, 6 }; + int res = new_comparator.compare(arr, arr1); + Assert.assertTrue(res < 0); + } + + @Test public void comparelong() { + DataType noDicDataTypes[] = { DataTypes.LONG }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Long arr[] = { 1L, 2L, 3L }; + Long arr1[] = { 4L, 5L, 6L }; + int res = new_comparator.compare(arr, arr1); + Assert.assertTrue(res < 0); + } + + @Test public void comparefloat() { + DataType noDicDataTypes[] = { DataTypes.FLOAT }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Float arr[] = { 1F, 2F, 3F }; + Float arr1[] = { 4F, 5F, 6F }; + int res = new_comparator.compare(arr, arr1); + Assert.assertTrue(res < 0); + } + + @Test public void compareboolean() { + DataType noDicDataTypes[] = { DataTypes.BOOLEAN }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Boolean arr[] = { false }; + Boolean arr1[] = { true }; + int res = new_comparator.compare(arr, arr1); + Assert.assertTrue(res < 0); + } + + @Test public void comparebyte() { + DataType noDicDataTypes[] = { DataTypes.BYTE }; + boolean noDicSortColumnMapping[] = { true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Byte arr[] = { 1, 2, 3 }; + Byte arr1[] = { 4, 5, 6 }; + int res = new_comparator.compare(arr, arr1); + Assert.assertTrue(res < 0); + } + + @Test public void comparemixed() { + DataType noDicDataTypes[] = { DataTypes.INT, DataTypes.FLOAT, DataTypes.BOOLEAN }; + boolean noDicSortColumnMapping[] = { true, true, true }; + new_comparator = new NewRowComparator(noDicSortColumnMapping, noDicDataTypes); + Object arr[] = { 1, 2F, false }; + Object arr1[] = { 4, 5F, true }; + int res = new_comparator.compare(arr, arr1); + Assert.assertTrue(res < 0); + } +}