[arrow] branch master updated: ARROW-5171: [C++] Use LESS instead of LOWER in compare enum

[ko...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

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


The following commit(s) were added to refs/heads/master by this push:
     new fe0dc31  ARROW-5171: [C++] Use LESS instead of LOWER in compare enum
fe0dc31 is described below

commit fe0dc31630fb80a76aa93cb5440e8e7cfd1cf2b0
Author: François Saint-Jacques <fs...@gmail.com>
AuthorDate: Wed Apr 17 06:12:10 2019 +0900

    ARROW-5171: [C++] Use LESS instead of LOWER in compare enum
    
    Author: François Saint-Jacques <fs...@gmail.com>
    
    Closes #4162 from fsaintjacques/ARROW-5171-less-instead-of-lower and squashes the following commits:
    
    a0c15e74 <François Saint-Jacques> ARROW-5171:  Use LESS instead of LOWER in compare enum
---
 cpp/src/arrow/compute/kernels/compare.cc     |  8 ++++----
 cpp/src/arrow/compute/kernels/compare.h      |  8 ++++----
 cpp/src/arrow/compute/kernels/filter-test.cc | 12 ++++++------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/compare.cc b/cpp/src/arrow/compute/kernels/compare.cc
index 10ef766..f27a449 100644
--- a/cpp/src/arrow/compute/kernels/compare.cc
+++ b/cpp/src/arrow/compute/kernels/compare.cc
@@ -99,10 +99,10 @@ static inline std::shared_ptr<FilterFunction> MakeCompareFilterFunctionType(
       return MakeCompareFunctionTypeOp<ArrowType, CompareOperator::GREATER>(ctx);
     case CompareOperator::GREATER_EQUAL:
       return MakeCompareFunctionTypeOp<ArrowType, CompareOperator::GREATER_EQUAL>(ctx);
-    case CompareOperator::LOWER:
-      return MakeCompareFunctionTypeOp<ArrowType, CompareOperator::LOWER>(ctx);
-    case CompareOperator::LOWER_EQUAL:
-      return MakeCompareFunctionTypeOp<ArrowType, CompareOperator::LOWER_EQUAL>(ctx);
+    case CompareOperator::LESS:
+      return MakeCompareFunctionTypeOp<ArrowType, CompareOperator::LESS>(ctx);
+    case CompareOperator::LESS_EQUAL:
+      return MakeCompareFunctionTypeOp<ArrowType, CompareOperator::LESS_EQUAL>(ctx);
   }
 
   return nullptr;
diff --git a/cpp/src/arrow/compute/kernels/compare.h b/cpp/src/arrow/compute/kernels/compare.h
index 7f6b299..06e71d6 100644
--- a/cpp/src/arrow/compute/kernels/compare.h
+++ b/cpp/src/arrow/compute/kernels/compare.h
@@ -39,8 +39,8 @@ enum CompareOperator {
   NOT_EQUAL,
   GREATER,
   GREATER_EQUAL,
-  LOWER,
-  LOWER_EQUAL,
+  LESS,
+  LESS_EQUAL,
 };
 
 template <typename T, CompareOperator Op>
@@ -67,12 +67,12 @@ struct Comparator<T, CompareOperator::GREATER_EQUAL> {
 };
 
 template <typename T>
-struct Comparator<T, CompareOperator::LOWER> {
+struct Comparator<T, CompareOperator::LESS> {
   constexpr static bool Compare(const T& lhs, const T& rhs) { return lhs < rhs; }
 };
 
 template <typename T>
-struct Comparator<T, CompareOperator::LOWER_EQUAL> {
+struct Comparator<T, CompareOperator::LESS_EQUAL> {
   constexpr static bool Compare(const T& lhs, const T& rhs) { return lhs <= rhs; }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/filter-test.cc b/cpp/src/arrow/compute/kernels/filter-test.cc
index 1e35ee9..9c76b9d 100644
--- a/cpp/src/arrow/compute/kernels/filter-test.cc
+++ b/cpp/src/arrow/compute/kernels/filter-test.cc
@@ -49,8 +49,8 @@ TEST(TestComparatorOperator, BasicOperator) {
       EXPECT_EQ((Comparator<T, NOT_EQUAL>::Compare(i, j)), i != j);
       EXPECT_EQ((Comparator<T, GREATER>::Compare(i, j)), i > j);
       EXPECT_EQ((Comparator<T, GREATER_EQUAL>::Compare(i, j)), i >= j);
-      EXPECT_EQ((Comparator<T, LOWER>::Compare(i, j)), i < j);
-      EXPECT_EQ((Comparator<T, LOWER_EQUAL>::Compare(i, j)), i <= j);
+      EXPECT_EQ((Comparator<T, LESS>::Compare(i, j)), i < j);
+      EXPECT_EQ((Comparator<T, LESS_EQUAL>::Compare(i, j)), i <= j);
     }
   }
 }
@@ -84,9 +84,9 @@ static inline bool SlowCompare(CompareOperator op, const T& lhs, const T& rhs) {
       return lhs > rhs;
     case GREATER_EQUAL:
       return lhs >= rhs;
-    case LOWER:
+    case LESS:
       return lhs < rhs;
-    case LOWER_EQUAL:
+    case LESS_EQUAL:
       return lhs <= rhs;
     default:
       return false;
@@ -174,7 +174,7 @@ TYPED_TEST(TestNumericCompareKernel, SimpleCompareArrayScalar) {
   ValidateCompare<TypeParam>(&this->ctx_, gte, "[4,5,6,7,8,9]", one, "[1,1,1,1,1,1]");
   ValidateCompare<TypeParam>(&this->ctx_, gte, "[null,0,1,1]", one, "[null,0,1,1]");
 
-  CompareOptions lt(CompareOperator::LOWER);
+  CompareOptions lt(CompareOperator::LESS);
   ValidateCompare<TypeParam>(&this->ctx_, lt, "[]", one, "[]");
   ValidateCompare<TypeParam>(&this->ctx_, lt, "[null]", one, "[null]");
   ValidateCompare<TypeParam>(&this->ctx_, lt, "[0,0,1,1,2,2]", one, "[1,1,0,0,0,0]");
@@ -182,7 +182,7 @@ TYPED_TEST(TestNumericCompareKernel, SimpleCompareArrayScalar) {
   ValidateCompare<TypeParam>(&this->ctx_, lt, "[4,5,6,7,8,9]", one, "[0,0,0,0,0,0]");
   ValidateCompare<TypeParam>(&this->ctx_, lt, "[null,0,1,1]", one, "[null,1,0,0]");
 
-  CompareOptions lte(CompareOperator::LOWER_EQUAL);
+  CompareOptions lte(CompareOperator::LESS_EQUAL);
   ValidateCompare<TypeParam>(&this->ctx_, lte, "[]", one, "[]");
   ValidateCompare<TypeParam>(&this->ctx_, lte, "[null]", one, "[null]");
   ValidateCompare<TypeParam>(&this->ctx_, lte, "[0,0,1,1,2,2]", one, "[1,1,1,1,0,0]");