Bug#35640263: Refactoring of json_diff/json_binary to enable HW

support for partial json [2/6, remove parameter, noclose]

Json_path::parse_path() takes an unnecessary error handler argument.
It takes the argument because it uses Json_dom::parse_dom()
internally, and parse_dom() takes an error handler because it may
raise an error if the JSON document is too deep. However, parse_path()
uses parse_json() only for parsing member names, which are simple
string scalars, so it does not need to handle nested JSON documents.

This patch makes parse_path() invoke RapidJSON directly, with a
handler that rejects everything except string scalars, and removes the
"depth_handler" parameter in the signature of parse_path().

Change-Id: I0cf61cdcd0cf57b38d19f23bfdc1ecf1eeeec2bf

Author: kahatlen

client/json_client_library_main.cc

@@ -25,15 +25,22 @@
   Json_dom::seek, Json_dom::parse, json_binary::parse_binary,
   json_binary::serialize functions are visible and can be called.
  */
+
+#include <cassert>
 #include <cstring>
 #include <iostream>
+#include <memory>
+#include <new>
 #include <string>
+#include <string_view>
 
+#include "field_types.h"
+#include "mysql/components/services/bits/psi_bits.h"
+#include "mysql_time.h"
 #include "sql-common/json_binary.h"
 #include "sql-common/json_dom.h"
 #include "sql-common/json_path.h"
-
-#include "sql-common/json_error_handler.h"
+#include "sql-common/my_decimal.h"
 #include "sql_string.h"
 
 void CoutDefaultDepthHandler() { std::cout << "Doc too deep"; }
@@ -55,8 +62,7 @@ int main() {
   const char *json_path = R"($**."512")";
   Json_path path(PSI_NOT_INSTRUMENTED);
   size_t bad_index;
-  parse_path(std::strlen(json_path), json_path, &path, &bad_index,
-             [] { assert(false); });
+  parse_path(std::strlen(json_path), json_path, &path, &bad_index);
 
   Json_wrapper wr(&o);
   wr.set_alias();

sql-common/json_diff.cc

@@ -346,7 +346,7 @@ bool Json_diff_vector::read_binary(const char **from, const TABLE *table,
     size_t bad_index;
     DBUG_PRINT("info", ("path='%.*s'", (int)path_length, p));
     if (parse_path(path_length, pointer_cast<const char *>(p), &path,
-                   &bad_index, JsonDepthErrorHandler))
+                   &bad_index))
       goto corrupted;
     p += path_length;
     length -= path_length;

sql-common/json_path.cc

@@ -33,12 +33,15 @@
 #include "my_rapidjson_size_t.h"  // IWYU pragma: keep
 
 #include <assert.h>
-#include <rapidjson/encodings.h>
-#include <rapidjson/memorystream.h>  // rapidjson::MemoryStream
 #include <stddef.h>
 #include <algorithm>  // any_of
-#include <memory>     // unique_ptr
 #include <string>
+#include <string_view>
+
+#include <rapidjson/encodings.h>
+#include <rapidjson/error/error.h>
+#include <rapidjson/memorystream.h>
+#include <rapidjson/reader.h>
 
 #include "my_inttypes.h"
 #include "mysql/strings/m_ctype.h"
@@ -47,7 +50,6 @@
 #include "sql/sql_const.h"       // STRING_BUFFER_USUAL_SIZE
 #include "sql_string.h"          // String
 #include "string_with_len.h"
-#include "template_utils.h"  // down_cast
 
 namespace {
 
@@ -64,15 +66,15 @@ class Stream;
 
 }  // namespace
 
-static bool is_ecmascript_identifier(const std::string &name);
+static bool is_ecmascript_identifier(const std::string_view &name);
 static bool is_digit(unsigned codepoint);
 static bool is_whitespace(char);
 
-static bool parse_path(Stream *, Json_path *, const JsonErrorHandler &);
-static bool parse_path_leg(Stream *, Json_path *, const JsonErrorHandler &);
+static bool parse_path(Stream *, Json_path *);
+static bool parse_path_leg(Stream *, Json_path *);
 static bool parse_ellipsis_leg(Stream *, Json_path *);
 static bool parse_array_leg(Stream *, Json_path *);
-static bool parse_member_leg(Stream *, Json_path *, const JsonErrorHandler &);
+static bool parse_member_leg(Stream *, Json_path *);
 
 static bool append_array_index(String *buf, size_t index, bool from_end) {
   if (!from_end) return buf->append_ulonglong(index);
@@ -253,10 +255,9 @@ class Stream {
 
 /** Top level parsing factory method */
 bool parse_path(size_t path_length, const char *path_expression,
-                Json_path *path, size_t *bad_index,
-                const JsonErrorHandler &depth_handler) {
+                Json_path *path, size_t *bad_index) {
   Stream stream(path_expression, path_length);
-  if (parse_path(&stream, path, depth_handler)) {
+  if (parse_path(&stream, path)) {
     *bad_index = stream.position() - path_expression;
     return true;
   }
@@ -275,13 +276,10 @@ static inline bool is_whitespace(char ch) {
 
    @param[in,out] stream The stream to read the path expression from.
    @param[in,out] path The Json_path object to fill.
-   @param[in] depth_handler Pointer to a function that should handle error
-                            occurred when depth is exceeded.
 
    @return true on error, false on success
 */
-static bool parse_path(Stream *stream, Json_path *path,
-                       const JsonErrorHandler &depth_handler) {
+static bool parse_path(Stream *stream, Json_path *path) {
   path->clear();
 
   // the first non-whitespace character must be $
@@ -291,7 +289,7 @@ static bool parse_path(Stream *stream, Json_path *path,
   // now add the legs
   stream->skip_whitespace();
   while (!stream->exhausted()) {
-    if (parse_path_leg(stream, path, depth_handler)) return true;
+    if (parse_path_leg(stream, path)) return true;
     stream->skip_whitespace();
   }
 
@@ -308,18 +306,15 @@ static bool parse_path(Stream *stream, Json_path *path,
 
    @param[in,out] stream The stream to read the path expression from.
    @param[in,out] path The Json_path object to fill.
-   @param[in] depth_handler Pointer to a function that should handle error
-                            occurred when depth is exceeded.
 
    @return true on error, false on success
 */
-static bool parse_path_leg(Stream *stream, Json_path *path,
-                           const JsonErrorHandler &depth_handler) {
+static bool parse_path_leg(Stream *stream, Json_path *path) {
   switch (stream->peek()) {
     case BEGIN_ARRAY:
       return parse_array_leg(stream, path);
     case BEGIN_MEMBER:
-      return parse_member_leg(stream, path, depth_handler);
+      return parse_member_leg(stream, path);
     case WILDCARD:
       return parse_ellipsis_leg(stream, path);
     default:
@@ -539,6 +534,28 @@ static const char *find_end_of_member_name(const char *start, const char *end) {
   return std::find_if(str, end, is_terminator);
 }
 
+namespace {
+/// A RapidJSON handler which accepts a scalar string and nothing else.
+class MemberNameHandler
+    : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>,
+                                          MemberNameHandler> {
+ public:
+  explicit MemberNameHandler(::String *name) : m_name(name) {}
+
+  bool String(const char *str, size_t length, bool) {
+    return !m_name->copy(str, length, &my_charset_utf8mb4_bin);
+  }
+
+  bool Default() {
+    assert(false);
+    return false;
+  }
+
+ private:
+  ::String *m_name;
+};
+}  // namespace
+
 /**
   Parse a quoted member name using the rapidjson parser, so that we
   get the name without the enclosing quotes and with any escape
@@ -549,34 +566,25 @@ static const char *find_end_of_member_name(const char *start, const char *end) {
 
   @param str the input string
   @param len the length of the input string
-  @param depth_handler Pointer to a function that should handle error
-                       occurred when depth is exceeded.
-  @return a Json_string that represents the member name, or NULL if
-  the input string is not a valid name
+  @param[out] name the member name
+  @return false on success, true on error
 */
-static std::unique_ptr<Json_string> parse_name_with_rapidjson(
-    const char *str, size_t len, const JsonErrorHandler &depth_handler) {
-  Json_dom_ptr dom = Json_dom::parse(
-      str, len, [](const char *, size_t) {}, depth_handler);
-
-  if (dom == nullptr || dom->json_type() != enum_json_type::J_STRING)
-    return nullptr;
-
-  return std::unique_ptr<Json_string>(down_cast<Json_string *>(dom.release()));
+bool parse_name_with_rapidjson(const char *str, size_t len, String *name) {
+  MemberNameHandler handler(name);
+  rapidjson::MemoryStream stream(str, len);
+  rapidjson::Reader reader;
+  return !reader.Parse<rapidjson::kParseDefaultFlags>(stream, handler);
 }
 
 /**
    Parses a single member leg and appends it to a Json_path object.
 
    @param[in,out] stream The stream to read the path expression from.
    @param[in,out] path The Json_path object to fill.
-   @param[in] depth_handler Pointer to a function that should handle error
-                            occurred when depth is exceeded.
 
    @return true on error, false on success
 */
-static bool parse_member_leg(Stream *stream, Json_path *path,
-                             const JsonErrorHandler &depth_handler) {
+static bool parse_member_leg(Stream *stream, Json_path *path) {
   // advance past the .
   assert(stream->peek() == BEGIN_MEMBER);
   stream->skip(1);
@@ -596,15 +604,16 @@ static bool parse_member_leg(Stream *stream, Json_path *path,
     const bool was_quoted = (*key_start == DOUBLE_QUOTE);
     stream->skip(key_end - key_start);
 
-    std::unique_ptr<Json_string> jstr;
+    StringBuffer<STRING_BUFFER_USUAL_SIZE> name;
 
     if (was_quoted) {
       /*
         Send the quoted name through the parser to unquote and
         unescape it.
       */
-      jstr = parse_name_with_rapidjson(key_start, key_end - key_start,
-                                       depth_handler);
+      if (parse_name_with_rapidjson(key_start, key_end - key_start, &name)) {
+        return true;
+      }
     } else {
       /*
         An unquoted name may contain escape sequences. Wrap it in
@@ -616,17 +625,18 @@ static bool parse_member_leg(Stream *stream, Json_path *path,
           strbuff.append(key_start, key_end - key_start) ||
           strbuff.append(DOUBLE_QUOTE))
         return true; /* purecov: inspected */
-      jstr = parse_name_with_rapidjson(strbuff.ptr(), strbuff.length(),
-                                       depth_handler);
+      if (parse_name_with_rapidjson(strbuff.ptr(), strbuff.length(), &name)) {
+        return true;
+      }
     }
 
-    if (jstr == nullptr) return true;
-
     // unquoted names must be valid ECMAScript identifiers
-    if (!was_quoted && !is_ecmascript_identifier(jstr->value())) return true;
+    if (!was_quoted && !is_ecmascript_identifier({name.ptr(), name.length()})) {
+      return true;
+    }
 
     // Looking good.
-    if (path->append(Json_path_leg(jstr->value())))
+    if (path->append(Json_path_leg(name.ptr(), name.length())))
       return true; /* purecov: inspected */
   }
 
@@ -711,7 +721,7 @@ static bool is_connector_punctuation(unsigned codepoint) {
 
    @return True if the name is a valid ECMAScript identifier. False otherwise.
 */
-static bool is_ecmascript_identifier(const std::string &name) {
+static bool is_ecmascript_identifier(const std::string_view &name) {
   // An empty string is not a valid identifier.
   if (name.empty()) return false;
 

sql-common/json_path.h

@@ -34,17 +34,13 @@
 #include <assert.h>
 #include <stddef.h>
 #include <algorithm>
-#include <functional>
 #include <new>
 #include <string>
 #include <utility>
 
 #include "my_alloc.h"  // MEM_ROOT
-                       // assert
-#include "my_inttypes.h"
-#include "my_sys.h"
+#include "mysql/psi/psi_memory.h"
 #include "prealloced_array.h"  // Prealloced_array
-#include "sql-common/json_error_handler.h"
 
 class String;
 
@@ -476,13 +472,10 @@ class Json_path_clone final : public Json_seekable_path {
    @param[in] path_expression The string form of the path expression.
    @param[out] path The Json_path object to be initialized.
    @param[out] bad_index If null is returned, the parsing failed around here.
-   @param[in] depth_handler Pointer to a function that should handle error
-                            occurred when depth is exceeded.
    @return false on success, true on error
 */
 bool parse_path(size_t path_length, const char *path_expression,
-                Json_path *path, size_t *bad_index,
-                const JsonErrorHandler &depth_handler);
+                Json_path *path, size_t *bad_index);
 
 /**
   A helper function that uses the above one as workhorse. Entry point for

sql/item_json_func.cc

@@ -25,22 +25,20 @@
 #include "sql/item_json_func.h"
 
 #include <assert.h>
-#include <stdint.h>
-#include <string.h>
 #include <algorithm>  // std::fill
-#include <cassert>
+#include <cstring>
 #include <limits>
 #include <memory>
 #include <new>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "decimal.h"
 #include "field_types.h"  // enum_field_types
 #include "lex_string.h"
-#include "m_string.h"
 #include "my_alloc.h"
-
+#include "my_dbug.h"
 #include "my_sys.h"
 #include "mysql/mysql_lex_string.h"
 #include "mysql/strings/m_ctype.h"
@@ -53,11 +51,12 @@
 #include "sql-common/json_syntax_check.h"
 #include "sql-common/my_decimal.h"
 #include "sql/current_thd.h"  // current_thd
+#include "sql/debug_sync.h"
 #include "sql/error_handler.h"
 #include "sql/field.h"
+#include "sql/field_common_properties.h"
 #include "sql/item_cmpfunc.h"  // Item_func_like
 #include "sql/item_create.h"
-#include "sql/item_subselect.h"
 #include "sql/json_schema.h"
 #include "sql/parser_yystype.h"
 #include "sql/psi_memory_key.h"  // key_memory_JSON
@@ -550,8 +549,7 @@ bool parse_path(const String &path_value, bool forbid_wildcards,
 
   // OK, we have a string encoded in utf-8. Does it parse?
   size_t bad_idx = 0;
-  if (parse_path(path_length, path_chars, json_path, &bad_idx,
-                 JsonDepthErrorHandler)) {
+  if (parse_path(path_length, path_chars, json_path, &bad_idx)) {
     /*
       Issue an error message. The last argument is no longer used, but kept to
       avoid changing error message format.

sql/item_json_func.h

@@ -26,12 +26,14 @@
 #include <assert.h>
 #include <sys/types.h>
 
-#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <utility>  // std::forward
 
+#include "field_types.h"
+#include "my_alloc.h"
 #include "my_inttypes.h"
+#include "my_table_map.h"
 #include "my_time.h"
 #include "mysql/strings/m_ctype.h"
 #include "mysql/udf_registration_types.h"
@@ -53,7 +55,9 @@
 
 class Json_schema_validator;
 class Json_array;
+class Json_diff_vector;
 class Json_dom;
+class Json_object;
 class Json_scalar_holder;
 class Json_wrapper;
 class PT_item_list;