carbondata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kunalkap...@apache.org
Subject [carbondata] branch master updated: [CARBONDATA-3489] Optimized the comparator instances in sort
Date Thu, 19 Sep 2019 08:31:59 GMT
This is an automated email from the ASF dual-hosted git repository.

kunalkapoor pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/carbondata.git


The following commit(s) were added to refs/heads/master by this push:
     new 02c6c89  [CARBONDATA-3489] Optimized the comparator instances in sort
02c6c89 is described below

commit 02c6c896c31bdc50f5363c5a26931edeb3829fff
Author: Vikram Ahuja <vikramahuja8803@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);
+  }
+}


Mime
View raw message