Bug#35963257: Add worker functions for JSON_TYPE to the JSON client library

Factor out code from Item_func_json_type to get the type name of a
JSON value, so that it's reusable outside of the server. It's moved to
a helper function called json_type_name(), which is exposed in
json_dom.h.

Change-Id: Ia02d3e396b2ca9323a1ad4415d1c6e86bc48a172

Author: kahatlen

client/json_client_library_main.cc

@@ -33,6 +33,7 @@
 #include <new>
 #include <string>
 #include <string_view>
+#include <utility>
 
 #include "field_types.h"
 #include "mysql/components/services/bits/psi_bits.h"
@@ -43,6 +44,7 @@
 #include "sql-common/json_path.h"
 #include "sql-common/my_decimal.h"
 #include "sql_string.h"
+#include "template_utils.h"
 
 namespace {
 void CoutDefaultDepthHandler() { std::cout << "Doc too deep"; }
@@ -225,13 +227,36 @@ int main() {
     // Sort array and use binary search to lookup values
     arr->sort();
     bool result = arr->binary_search(dom1.get());
-    std::cout << "7 it is: " << std::boolalpha << result
+    std::cout << "7.1. it is: " << std::boolalpha << result
               << " that array contains 1\n";
 
     result = arr->binary_search(dom2.get());
-    std::cout << "7 it is: " << std::boolalpha << result
+    std::cout << "7.2. it is: " << std::boolalpha << result
               << " that array contains 155.2\n";
   }
 
+  // Make sure json_type_name() is visible.
+  {
+    std::cout << "8.1. Type of empty wrapper is "
+              << json_type_name(Json_wrapper{}) << ".\n";
+    {
+      Json_array array;
+      std::cout << "8.2. Type of array is "
+                << json_type_name(Json_wrapper{&array, /*alias=*/true})
+                << ".\n";
+    }
+    {
+      Json_string string;
+      std::cout << "8.3. Type of string is "
+                << json_type_name(Json_wrapper{&string, /*alias=*/true})
+                << ".\n";
+    }
+    {
+      Json_opaque blob{MYSQL_TYPE_BLOB};
+      std::cout << "8.4. Type of blob is "
+                << json_type_name(Json_wrapper{&blob, /*alias=*/true}) << ".\n";
+    }
+  }
+
   return 0;
 }

sql-common/json_dom.cc

@@ -35,6 +35,8 @@
 #include <cmath>       // std::isfinite
 #include <functional>  // std::function
 #include <new>
+#include <numeric>
+#include <string_view>
 #include <utility>
 
 #include "my_rapidjson_size_t.h"  // IWYU pragma: keep
@@ -95,6 +97,9 @@
 #define key_memory_JSON PSI_NOT_INSTRUMENTED
 #endif
 
+using namespace std::literals;
+using std::string_view;
+
 static Json_dom *json_binary_to_dom_template(const json_binary::Value &v);
 
 using Sorted_index_array = Prealloced_array<size_t, 16>;
@@ -3849,3 +3854,82 @@ bool json_wrapper_contains(const Json_wrapper &doc_wrapper,
   *result = (doc_wrapper.compare(containee_wr) == 0);
   return false;
 }
+
+namespace {
+/**
+  Extended type ids so that JSON_TYPE() can give useful type
+  names to certain sub-types of J_OPAQUE.
+*/
+enum class enum_json_opaque_type {
+  J_OPAQUE_BLOB = static_cast<int>(enum_json_type::J_ERROR) + 1,
+  J_OPAQUE_BIT,
+};
+
+/**
+  Maps the enumeration value of type enum_json_type into a string.
+  For example:
+
+      json_type_string_map[J_OBJECT] == "OBJECT"
+*/
+constexpr std::array json_type_string_map = {
+    "NULL"sv,
+    "DECIMAL"sv,
+    "INTEGER"sv,
+    "UNSIGNED INTEGER"sv,
+    "DOUBLE"sv,
+    "STRING"sv,
+    "OBJECT"sv,
+    "ARRAY"sv,
+    "BOOLEAN"sv,
+    "DATE"sv,
+    "TIME"sv,
+    "DATETIME"sv,
+    "TIMESTAMP"sv,
+    "OPAQUE"sv,
+    "ERROR"sv,
+
+    // OPAQUE types with special names.
+    "BLOB"sv,
+    "BIT"sv,
+};
+
+/**
+   Compute an index into json_type_string_map
+   to be applied to certain sub-types of J_OPAQUE.
+
+   @param field_type The refined field type of the opaque value.
+
+   @return An index into json_type_string_map.
+*/
+size_t opaque_index(enum_field_types field_type) {
+  switch (field_type) {
+    case MYSQL_TYPE_VARCHAR:
+    case MYSQL_TYPE_TINY_BLOB:
+    case MYSQL_TYPE_MEDIUM_BLOB:
+    case MYSQL_TYPE_LONG_BLOB:
+    case MYSQL_TYPE_BLOB:
+    case MYSQL_TYPE_VAR_STRING:
+    case MYSQL_TYPE_STRING:
+      return static_cast<size_t>(enum_json_opaque_type::J_OPAQUE_BLOB);
+    case MYSQL_TYPE_BIT:
+      return static_cast<size_t>(enum_json_opaque_type::J_OPAQUE_BIT);
+    default:
+      return static_cast<size_t>(enum_json_type::J_OPAQUE);
+  }
+}
+}  // namespace
+
+// Set max type name length to the length of the longest string in
+// json_type_string_map.
+const size_t kMaxJsonTypeNameLength = std::transform_reduce(
+    json_type_string_map.begin(), json_type_string_map.end(), size_t{0},
+    [](size_t length1, size_t length2) { return std::max(length1, length2); },
+    [](string_view type_name) { return type_name.length(); });
+
+string_view json_type_name(const Json_wrapper &doc) {
+  const enum_json_type type = doc.type();
+  if (type == enum_json_type::J_OPAQUE) {
+    return json_type_string_map[opaque_index(doc.field_type())];
+  }
+  return json_type_string_map[static_cast<size_t>(type)];
+}

sql-common/json_dom.h

@@ -30,6 +30,7 @@
 #include <memory>  // unique_ptr
 #include <new>
 #include <string>
+#include <string_view>
 #include <type_traits>  // is_base_of
 #include <utility>
 #include <vector>
@@ -1958,4 +1959,11 @@ class Json_scalar_holder {
 */
 bool json_wrapper_contains(const Json_wrapper &doc_wrapper,
                            const Json_wrapper &containee_wr, bool *result);
+
+/// Returns the name of the type of the JSON document contained in "doc".
+std::string_view json_type_name(const Json_wrapper &doc);
+
+/// The maximum length of the type name returned from JSON_TYPE.
+extern const size_t kMaxJsonTypeNameLength;
+
 #endif /* JSON_DOM_INCLUDED */

sql/item_json_func.cc

@@ -1037,118 +1037,14 @@ bool get_json_wrapper(Item **args, uint arg_idx, String *str,
   return false;
 }
 
-/**
-  Extended type ids so that JSON_TYPE() can give useful type
-  names to certain sub-types of J_OPAQUE.
-*/
-enum class enum_json_opaque_type {
-  J_OPAQUE_BLOB = static_cast<int>(enum_json_type::J_ERROR) + 1,
-  J_OPAQUE_BIT,
-  J_OPAQUE_GEOMETRY
-};
-
-/**
-  Maps the enumeration value of type enum_json_type into a string.
-  For example:
-  json_type_string_map[J_OBJECT] == "OBJECT"
-*/
-static constexpr const char *json_type_string_map[] = {
-    "NULL",
-    "DECIMAL",
-    "INTEGER",
-    "UNSIGNED INTEGER",
-    "DOUBLE",
-    "STRING",
-    "OBJECT",
-    "ARRAY",
-    "BOOLEAN",
-    "DATE",
-    "TIME",
-    "DATETIME",
-    "TIMESTAMP",
-    "OPAQUE",
-    "ERROR",
-
-    // OPAQUE types with special names
-    "BLOB",
-    "BIT",
-    "GEOMETRY",
-};
-
-/// A constexpr version of std::strlen.
-static constexpr uint32 strlen_const(const char *str) {
-  return *str == '\0' ? 0 : 1 + strlen_const(str + 1);
-}
-
-/// Find the length of the longest string in a range.
-static constexpr uint32 longest_string(const char *const *begin,
-                                       const char *const *end) {
-  return begin == end
-             ? 0
-             : std::max(strlen_const(*begin), longest_string(begin + 1, end));
-}
-
-/**
-   The maximum length of a string in json_type_string_map including
-   a final zero char.
-*/
-static constexpr uint32 typelit_max_length =
-    longest_string(
-        json_type_string_map,
-        json_type_string_map + array_elements(json_type_string_map)) +
-    1;
-
 bool Item_func_json_type::resolve_type(THD *thd) {
   if (param_type_is_default(thd, 0, 1, MYSQL_TYPE_JSON)) return true;
   set_nullable(true);
   m_value.set_charset(&my_charset_utf8mb4_bin);
-  set_data_type_string(typelit_max_length, &my_charset_utf8mb4_bin);
+  set_data_type_string(kMaxJsonTypeNameLength + 1, &my_charset_utf8mb4_bin);
   return false;
 }
 
-/**
-   Compute an index into json_type_string_map
-   to be applied to certain sub-types of J_OPAQUE.
-
-   @param field_type The refined field type of the opaque value.
-
-   @return an index into json_type_string_map
-*/
-static uint opaque_index(enum_field_types field_type) {
-  switch (field_type) {
-    case MYSQL_TYPE_VARCHAR:
-    case MYSQL_TYPE_TINY_BLOB:
-    case MYSQL_TYPE_MEDIUM_BLOB:
-    case MYSQL_TYPE_LONG_BLOB:
-    case MYSQL_TYPE_BLOB:
-    case MYSQL_TYPE_VAR_STRING:
-    case MYSQL_TYPE_STRING:
-      return static_cast<uint>(enum_json_opaque_type::J_OPAQUE_BLOB);
-
-    case MYSQL_TYPE_BIT:
-      return static_cast<uint>(enum_json_opaque_type::J_OPAQUE_BIT);
-
-    case MYSQL_TYPE_GEOMETRY: {
-      /**
-        Should not get here. This path should be orphaned by the
-        work done on implicit CASTing of geometry values to geojson
-        objects. However, that work was done late in the project
-        cycle for WL#7909. Do something sensible in case we missed
-        something.
-
-        FIXME.
-      */
-      /* purecov: begin deadcode */
-      assert(false);
-      return static_cast<uint>(enum_json_opaque_type::J_OPAQUE_GEOMETRY);
-      /* purecov: end */
-    }
-
-    default:
-      return static_cast<uint>(enum_json_type::J_OPAQUE);
-  }
-}
-
 String *Item_func_json_type::val_str(String *) {
   assert(fixed);
 
@@ -1160,14 +1056,8 @@ String *Item_func_json_type::val_str(String *) {
       return nullptr;
     }
 
-    const enum_json_type type = wr.type();
-    uint typename_idx = static_cast<uint>(type);
-    if (type == enum_json_type::J_OPAQUE) {
-      typename_idx = opaque_index(wr.field_type());
-    }
-
     m_value.length(0);
-    if (m_value.append(json_type_string_map[typename_idx]))
+    if (m_value.append(json_type_name(wr)))
       return error_str(); /* purecov: inspected */
 
   } catch (...) {