ARROW-12657: [C++] Adding String hex to numeric conversion

cpp/src/arrow/util/value_parsing.h

@@ -273,6 +273,96 @@ inline bool ParseUnsigned(const char* s, size_t length, uint64_t* out) {
 #undef PARSE_UNSIGNED_ITERATION
 #undef PARSE_UNSIGNED_ITERATION_LAST
 
+#define PARSE_HEX_ITERATION(C_TYPE)                                     \
+  if (length > 0) {                                                     \
+    char val = *s;                                                      \
+    s++;                                                                \
+    result = static_cast<C_TYPE>(result << 4);                          \
+    length--;                                                           \
+    if (val >= '0' && val <= '9'){                                      \
+      result = static_cast<C_TYPE>(result | (val -'0'));                \
+    } else if (val >= 'A' && val <= 'F'){                               \
+      result = static_cast<C_TYPE>(result | (val -'A' + 10));           \
+    } else if (val >= 'a' && val <= 'f'){                               \
+      result = static_cast<C_TYPE>(result | (val -'a' + 10));           \
+    } else {                                                            \
+      /* Non-digit */                                                   \
+      return false;                                                     \
+    }                                                                   \
+  } else {                                                              \
+    break;                                                              \
+  }
+
+
+inline bool ParseHex(const char* s, size_t length, uint8_t* out) {
+  uint8_t result = 0;
+
+  do {
+    PARSE_HEX_ITERATION(uint8_t);
+    PARSE_HEX_ITERATION(uint8_t);    
+  } while (false);
+  *out = result;
+  return true;
+}
+
+inline bool ParseHex(const char* s, size_t length, uint16_t* out) {
+  uint16_t result = 0;
+  do {
+    PARSE_HEX_ITERATION(uint16_t);
+    PARSE_HEX_ITERATION(uint16_t);
+    PARSE_HEX_ITERATION(uint16_t);
+    PARSE_HEX_ITERATION(uint16_t);
+  } while (false);
+  *out = result;
+  return true;
+}
+
+inline bool ParseHex(const char* s, size_t length, uint32_t* out) {
+  uint32_t result = 0;
+  do {
+    PARSE_HEX_ITERATION(uint32_t);
+    PARSE_HEX_ITERATION(uint32_t);
+    PARSE_HEX_ITERATION(uint32_t);
+    PARSE_HEX_ITERATION(uint32_t);
+
+    PARSE_HEX_ITERATION(uint32_t);
+    PARSE_HEX_ITERATION(uint32_t);
+    PARSE_HEX_ITERATION(uint32_t);
+    PARSE_HEX_ITERATION(uint32_t);    
+  } while (false);
+  *out = result;
+  return true;
+}
+
+inline bool ParseHex(const char* s, size_t length, uint64_t* out) {
+  uint64_t result = 0;
+  do {
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+    PARSE_HEX_ITERATION(uint64_t);
+  } while (false);
+  *out = result;
+  return true;
+}
+
+#undef PARSE_HEX_ITERATION
+
 template <class ARROW_TYPE>
 struct StringToUnsignedIntConverterMixin {
   using value_type = typename ARROW_TYPE::c_type;
@@ -281,6 +371,19 @@ struct StringToUnsignedIntConverterMixin {
     if (ARROW_PREDICT_FALSE(length == 0)) {
       return false;
     }
+    // If its starts with 0x then its hex
+    if (*s == '0' && *(s + 1) == 'x'){
+      length -= 2;
+      s += 2;
+      // lets make sure that the length of the string is not too big
+      if (!ARROW_PREDICT_TRUE(sizeof(value_type)*2 >= length)) {
+        return false;
+      }
+      if (!ARROW_PREDICT_TRUE(ParseHex(s, length, out))) {
+        return false;
+      }
+      return true; 
+    }
     // Skip leading zeros
     while (length > 0 && *s == '0') {
       length--;
@@ -336,6 +439,21 @@ struct StringToSignedIntConverterMixin {
         return false;
       }
     }
+
+    // If its starts with 0x then its hex
+    if (*s == '0' && *(s + 1) == 'x'){
+      length -= 2;
+      s += 2;
+      // lets make sure that the length of the string is not too big
+      if (!ARROW_PREDICT_TRUE(sizeof(unsigned_value)*2 >= length)) {
+        return false;
+      }
+      if (!ARROW_PREDICT_TRUE(ParseHex(s, length, &unsigned_value))) {
+        return false;
+      }
+      *out = static_cast<value_type>(unsigned_value);
+      return true; 
+    }
     // Skip leading zeros
     while (length > 0 && *s == '0') {
       length--;

cpp/src/arrow/util/value_parsing_benchmark.cc

@@ -56,6 +56,29 @@ static std::vector<std::string> MakeIntStrings(int32_t num_items) {
   return strings;
 }
 
+template <typename c_int>
+static std::vector<std::string> MakeHexStrings(int32_t num_items) {
+  int32_t num_bytes = sizeof(c_int);
+  const char* kAsciiTable = "0123456789ABCDEF";
+  std::vector<char> large_hex_chars(num_bytes*2 + 2);
+  large_hex_chars[0]='0';
+  large_hex_chars[1]='x';
+  for (int32_t i = 0; i < num_bytes*2; ++i) {
+    large_hex_chars[i + 2] = kAsciiTable[i];
+  }
+  std::string large_hex(&large_hex_chars[0], large_hex_chars.size());
+
+  std::vector<std::string> base_strings = {"0x0",
+                                           "0xA5",
+                                           "0x5E",
+                                           large_hex};
+  std::vector<std::string> strings;
+  for (int32_t i = 0; i < num_items; ++i) {
+    strings.push_back(base_strings[i % base_strings.size()]);
+  }
+  return strings;
+}
+
 static std::vector<std::string> MakeFloatStrings(int32_t num_items) {
   std::vector<std::string> base_strings = {"0.0",         "5",        "-12.3",
                                            "98765430000", "3456.789", "0.0012345",
@@ -123,6 +146,25 @@ static void IntegerParsing(benchmark::State& state) {  // NOLINT non-const refer
   state.SetItemsProcessed(state.iterations() * strings.size());
 }
 
+template <typename ARROW_TYPE, typename C_TYPE = typename ARROW_TYPE::c_type>
+static void HexParsing(benchmark::State& state) {  // NOLINT non-const reference
+  auto strings = MakeHexStrings<C_TYPE>(1000);
+
+  while (state.KeepRunning()) {
+    C_TYPE total = 0;
+    for (const auto& s : strings) {
+      C_TYPE value;
+      if (!ParseValue<ARROW_TYPE>(s.data(), s.length(), &value)) {
+        std::cerr << "Conversion failed for '" << s << "'";
+        std::abort();
+      }
+      total = static_cast<C_TYPE>(total + value);
+    }
+    benchmark::DoNotOptimize(total);
+  }
+  state.SetItemsProcessed(state.iterations() * strings.size());
+}
+
 template <typename ARROW_TYPE, typename C_TYPE = typename ARROW_TYPE::c_type>
 static void FloatParsing(benchmark::State& state) {  // NOLINT non-const reference
   auto strings = MakeFloatStrings(1000);
@@ -230,6 +272,15 @@ BENCHMARK_TEMPLATE(IntegerParsing, UInt16Type);
 BENCHMARK_TEMPLATE(IntegerParsing, UInt32Type);
 BENCHMARK_TEMPLATE(IntegerParsing, UInt64Type);
 
+BENCHMARK_TEMPLATE(HexParsing, Int8Type);
+BENCHMARK_TEMPLATE(HexParsing, Int16Type);
+BENCHMARK_TEMPLATE(HexParsing, Int32Type);
+BENCHMARK_TEMPLATE(HexParsing, Int64Type);
+BENCHMARK_TEMPLATE(HexParsing, UInt8Type);
+BENCHMARK_TEMPLATE(HexParsing, UInt16Type);
+BENCHMARK_TEMPLATE(HexParsing, UInt32Type);
+BENCHMARK_TEMPLATE(HexParsing, UInt64Type);
+
 BENCHMARK_TEMPLATE(FloatParsing, FloatType);
 BENCHMARK_TEMPLATE(FloatParsing, DoubleType);
 

cpp/src/arrow/util/value_parsing_test.cc

@@ -120,6 +120,14 @@ TEST(StringConversion, ToInt8) {
   AssertConversionFails<Int8Type>("-");
   AssertConversionFails<Int8Type>("0.0");
   AssertConversionFails<Int8Type>("e");
+
+  // Hex
+  AssertConversion<Int8Type>("0x0", 0);
+  AssertConversion<Int8Type>("0x1A", 26);
+  AssertConversion<Int8Type>("0xb", 11);
+  AssertConversion<Int8Type>("0x7F", 127);
+  AssertConversionFails<Int8Type>("0x100");
+  AssertConversionFails<Int8Type>("0x1g");
 }
 
 TEST(StringConversion, ToUInt8) {
@@ -138,6 +146,14 @@ TEST(StringConversion, ToUInt8) {
   AssertConversionFails<UInt8Type>("-");
   AssertConversionFails<UInt8Type>("0.0");
   AssertConversionFails<UInt8Type>("e");
+
+  // Hex
+  AssertConversion<UInt8Type>("0x0", 0);
+  AssertConversion<UInt8Type>("0x1A", 26);
+  AssertConversion<UInt8Type>("0xb", 11);
+  AssertConversion<UInt8Type>("0x7F", 127);
+  AssertConversionFails<UInt8Type>("0x100");
+  AssertConversionFails<UInt8Type>("0x1g");
 }
 
 TEST(StringConversion, ToInt16) {
@@ -155,6 +171,14 @@ TEST(StringConversion, ToInt16) {
   AssertConversionFails<Int16Type>("-");
   AssertConversionFails<Int16Type>("0.0");
   AssertConversionFails<Int16Type>("e");
+
+  // Hex
+  AssertConversion<Int16Type>("0x0", 0);
+  AssertConversion<Int16Type>("0x1aA", 426);
+  AssertConversion<Int16Type>("0xb", 11);
+  AssertConversion<Int16Type>("0x7ffF", 32767);
+  AssertConversionFails<Int16Type>("0x10000");
+  AssertConversionFails<Int16Type>("0x1g");
 }
 
 TEST(StringConversion, ToUInt16) {
@@ -172,6 +196,14 @@ TEST(StringConversion, ToUInt16) {
   AssertConversionFails<UInt16Type>("-");
   AssertConversionFails<UInt16Type>("0.0");
   AssertConversionFails<UInt16Type>("e");
+
+  // Hex
+  AssertConversion<UInt16Type>("0x0", 0);
+  AssertConversion<UInt16Type>("0x1aA", 426);
+  AssertConversion<UInt16Type>("0xb", 11);
+  AssertConversion<UInt16Type>("0x7ffF", 32767);
+  AssertConversionFails<UInt16Type>("0x10000");
+  AssertConversionFails<UInt16Type>("0x1g");
 }
 
 TEST(StringConversion, ToInt32) {
@@ -189,6 +221,17 @@ TEST(StringConversion, ToInt32) {
   AssertConversionFails<Int32Type>("-");
   AssertConversionFails<Int32Type>("0.0");
   AssertConversionFails<Int32Type>("e");
+
+  // Hex
+  AssertConversion<Int32Type>("0x0", 0);
+  AssertConversion<Int32Type>("0x123ABC", 1194684);
+  AssertConversion<Int32Type>("0xA4B35", 674613);
+  AssertConversion<Int32Type>("0x7FFFFFFF", 2147483647);
+  AssertConversion<Int32Type>("0x123abc", 1194684);
+  AssertConversion<Int32Type>("0xA4b35", 674613);
+  AssertConversion<Int32Type>("0x7FFFfFfF", 2147483647);
+  AssertConversionFails<Int32Type>("0x23512ak");
+
 }
 
 TEST(StringConversion, ToUInt32) {
@@ -206,6 +249,16 @@ TEST(StringConversion, ToUInt32) {
   AssertConversionFails<UInt32Type>("-");
   AssertConversionFails<UInt32Type>("0.0");
   AssertConversionFails<UInt32Type>("e");
+
+  // Hex
+  AssertConversion<UInt32Type>("0x0", 0);
+  AssertConversion<UInt32Type>("0x123ABC", 1194684);
+  AssertConversion<UInt32Type>("0xA4B35", 674613);
+  AssertConversion<UInt32Type>("0x7FFFFFFF", 2147483647);
+  AssertConversion<UInt32Type>("0x123abc", 1194684);
+  AssertConversion<UInt32Type>("0xA4b35", 674613);
+  AssertConversion<UInt32Type>("0x7FFFfFfF", 2147483647);
+  AssertConversionFails<UInt32Type>("0x23512ak");
 }
 
 TEST(StringConversion, ToInt64) {
@@ -223,6 +276,14 @@ TEST(StringConversion, ToInt64) {
   AssertConversionFails<Int64Type>("-");
   AssertConversionFails<Int64Type>("0.0");
   AssertConversionFails<Int64Type>("e");
+
+  // Hex
+  AssertConversion<Int64Type>("0x0", 0);
+  AssertConversion<Int64Type>("0x5415a123ABC123cb", 6058926048274359243);
+  AssertConversion<Int64Type>("0xA4B35", 674613);
+  AssertConversion<Int64Type>("0x7FFFFFFFFFFFFFFf", 9223372036854775807);
+  AssertConversionFails<Int64Type>("0x12345678901234567");
+  AssertConversionFails<Int64Type>("0x23512ak");
 }
 
 TEST(StringConversion, ToUInt64) {
@@ -237,6 +298,14 @@ TEST(StringConversion, ToUInt64) {
   AssertConversionFails<UInt64Type>("-");
   AssertConversionFails<UInt64Type>("0.0");
   AssertConversionFails<UInt64Type>("e");
+
+  // Hex
+  AssertConversion<UInt64Type>("0x0", 0);
+  AssertConversion<UInt64Type>("0x5415a123ABC123cb", 6058926048274359243);
+  AssertConversion<UInt64Type>("0xA4B35", 674613);
+  AssertConversion<UInt64Type>("0x7FFFFFFFFFFFFFFf", 9223372036854775807);
+  AssertConversionFails<UInt64Type>("0x12345678901234567");
+  AssertConversionFails<UInt64Type>("0x23512ak");
 }
 
 TEST(StringConversion, ToDate32) {