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

support for partial json [3/6, error handler, noclose]

The functions that serialize JSON values currently take one error
handler argument for each error that could be raised by the function.
This does not scale well, as one new argument has to be added for each
new error condition that is added to the function, and many function
signatures have to be modified if errors are added or removed from one
of these functions.

This patch replaces the many error handler arguments with a single
error handler that has one virtual member function per error. This
allows new errors to be added without changing the signatures of the
serialization functions.

Change-Id: If341dbcb98e556c1341934cb69f4427aafe9708c

Author: kahatlen

client/json_client_library_main.cc

@@ -39,14 +39,23 @@
 #include "mysql_time.h"
 #include "sql-common/json_binary.h"
 #include "sql-common/json_dom.h"
+#include "sql-common/json_error_handler.h"
 #include "sql-common/json_path.h"
 #include "sql-common/my_decimal.h"
 #include "sql_string.h"
 
+namespace {
 void CoutDefaultDepthHandler() { std::cout << "Doc too deep"; }
-void CoutDefaultKeyErrorHandler() { std::cout << "Key too big"; }
-void CoutDefaultValueErrorHandler() { std::cout << "Value too big"; }
-void InvalidJsonErrorHandler() { std::cout << "Invalid JSON"; }
+
+class CoutSerializationErrorHandler : public JsonSerializationErrorHandler {
+ public:
+  void KeyTooBig() const override { std::cout << "Key too big"; }
+  void ValueTooBig() const override { std::cout << "Value too big"; }
+  void TooDeep() const override { CoutDefaultDepthHandler(); }
+  void InvalidJson() const override { std::cout << "Invalid JSON"; }
+};
+
+}  // namespace
 
 int main() {
   Json_object o;
@@ -68,8 +77,7 @@ int main() {
   wr.set_alias();
 
   StringBuffer<20000> buf;
-  if (wr.to_binary(&buf, CoutDefaultDepthHandler, CoutDefaultKeyErrorHandler,
-                   CoutDefaultValueErrorHandler, InvalidJsonErrorHandler)) {
+  if (wr.to_binary(CoutSerializationErrorHandler(), &buf)) {
     std::cout << "error";
   } else {
     const json_binary::Value v(
@@ -128,9 +136,7 @@ int main() {
     my_decimal m;
     double2my_decimal(0, 3.14000000001, &m);
     const Json_decimal jd(m);
-    if (json_binary::serialize(&jd, &buf, CoutDefaultDepthHandler,
-                               CoutDefaultKeyErrorHandler,
-                               CoutDefaultValueErrorHandler))
+    if (json_binary::serialize(&jd, CoutSerializationErrorHandler(), &buf))
       std::cout << "ERRROR!!" << std::endl;
 
     json_binary::Value v = json_binary::parse_binary(buf.ptr(), buf.length());
@@ -150,9 +156,7 @@ int main() {
     dt.time_type = MYSQL_TIMESTAMP_DATE;
     const Json_datetime jd(dt, MYSQL_TYPE_DATETIME);
 
-    if (json_binary::serialize(&jd, &buf, CoutDefaultDepthHandler,
-                               CoutDefaultKeyErrorHandler,
-                               CoutDefaultValueErrorHandler))
+    if (json_binary::serialize(&jd, CoutSerializationErrorHandler(), &buf))
       std::cout << "ERRROR!!" << std::endl;
 
     json_binary::Value v = json_binary::parse_binary(buf.ptr(), buf.length());

sql-common/json_binary.cc

@@ -30,24 +30,32 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
+
+#ifdef MYSQL_SERVER
+#include <sys/types.h>
+#endif  // MYSQL_SERVER
 
 #include "my_byteorder.h"
-#include "my_sys.h"
+#include "my_dbug.h"
+#include "my_inttypes.h"
 #include "mysql/strings/m_ctype.h"
-#include "mysqld_error.h"
-#ifdef MYSQL_SERVER
-#include "sql/check_stack.h"
-#endif
 #include "sql-common/json_dom.h"  // Json_dom
+#include "sql-common/json_error_handler.h"
 #include "sql-common/json_syntax_check.h"
-#include "sql/field.h"      // Field_json
-#include "sql/sql_class.h"  // THD
 #include "sql/sql_const.h"
-#include "sql/system_variables.h"
-#include "sql/table.h"  // TABLE::add_binary_diff()
 #include "sql_string.h"
 #include "template_utils.h"  // down_cast
 
+#ifdef MYSQL_SERVER
+#include "my_sys.h"
+#include "mysqld_error.h"
+#include "sql/check_stack.h"
+#include "sql/current_thd.h"
+#include "sql/field.h"
+#include "sql/table.h"
+#endif  // MYSQL_SERVER
+
 namespace {
 
 constexpr char JSONB_TYPE_SMALL_OBJECT = 0x0;
@@ -125,28 +133,36 @@ enum enum_serialization_result {
 };
 
 static enum_serialization_result serialize_json_value(
-    const Json_dom *dom, size_t type_pos, String *dest, size_t depth,
-    bool small_parent, const JsonErrorHandler &json_depth_handler);
+    const Json_dom *dom, size_t type_pos, size_t depth, bool small_parent,
+    const JsonSerializationErrorHandler &error_handler, String *dest);
 static void write_offset_or_size(char *dest, size_t offset_or_size, bool large);
 static uint8 offset_size(bool large);
 
-bool serialize(const Json_dom *dom, String *dest,
-               const JsonErrorHandler &json_depth_handler,
-               const JsonErrorHandler &json_key_handler,
-               const JsonErrorHandler &json_value_handler) {
+bool serialize(const Json_dom *dom,
+               const JsonSerializationErrorHandler &error_handler,
+               String *dest) {
   // Reset the destination buffer.
   dest->length(0);
   dest->set_charset(&my_charset_bin);
 
   // Reserve space (one byte) for the type identifier.
   if (dest->append('\0')) return true; /* purecov: inspected */
-  enum_serialization_result result =
-      serialize_json_value(dom, 0, dest, 0, false, json_depth_handler);
 
-  if (result == JSON_KEY_TOO_BIG) json_key_handler();
-  if (result == VALUE_TOO_BIG) json_value_handler();
+  switch (serialize_json_value(dom, /*type_pos=*/0, /*depth=*/0,
+                               /*small_parent=*/false, error_handler, dest)) {
+    case OK:
+      return false;
+    case VALUE_TOO_BIG:
+      error_handler.ValueTooBig();
+      return true;
+    case JSON_KEY_TOO_BIG:
+      error_handler.KeyTooBig();
+      return true;
+    case FAILURE:
+      return true;
+  }
 
-  return result != OK;
+  return true; /* purecov: deadcode */
 }
 
 /**
@@ -496,16 +512,15 @@ static bool attempt_inline_value(const Json_dom *value, String *dest,
   Serialize a JSON array at the end of the destination string.
 
   @param array  the JSON array to serialize
-  @param dest   the destination string
   @param large  if true, the large storage format will be used
   @param depth  the current nesting level
-  @param json_depth_handler handler which will be called for JSON documents
-                        exceeding the maximum allowed depth
+  @param error_handler a handler that is invoked if an error occurs
+  @param dest   the destination string
   @return serialization status
 */
 static enum_serialization_result serialize_json_array(
-    const Json_array *array, String *dest, bool large, size_t depth,
-    const JsonErrorHandler &json_depth_handler) {
+    const Json_array *array, bool large, size_t depth,
+    const JsonSerializationErrorHandler &error_handler, String *dest) {
 #ifdef MYSQL_SERVER
   if (check_stack_overrun(current_thd, STACK_MIN_SIZE, nullptr))
     return FAILURE; /* purecov: inspected */
@@ -514,7 +529,7 @@ static enum_serialization_result serialize_json_array(
   const size_t start_pos = dest->length();
   const size_t size = array->size();
 
-  if (check_json_depth(++depth, json_depth_handler)) {
+  if (check_json_depth(++depth, error_handler)) {
     return FAILURE;
   }
 
@@ -542,8 +557,8 @@ static enum_serialization_result serialize_json_array(
       size_t offset = dest->length() - start_pos;
       if (is_too_big_for_json(offset, large)) return VALUE_TOO_BIG;
       insert_offset_or_size(dest, entry_pos + 1, offset, large);
-      auto res = serialize_json_value(elt, entry_pos, dest, depth, !large,
-                                      json_depth_handler);
+      auto res = serialize_json_value(elt, entry_pos, depth, !large,
+                                      error_handler, dest);
       if (res != OK) return res;
     }
     entry_pos += entry_size;
@@ -562,16 +577,15 @@ static enum_serialization_result serialize_json_array(
   Serialize a JSON object at the end of the destination string.
 
   @param object the JSON object to serialize
-  @param dest   the destination string
   @param large  if true, the large storage format will be used
   @param depth  the current nesting level
-  @param json_depth_handler handler which will be called for JSON documents
-                            exceeding the maximum allowed depth
+  @param error_handler a handler that is invoked if an error occurs
+  @param dest   the destination string
   @return serialization status
 */
 static enum_serialization_result serialize_json_object(
-    const Json_object *object, String *dest, bool large, size_t depth,
-    const JsonErrorHandler &json_depth_handler) {
+    const Json_object *object, bool large, size_t depth,
+    const JsonSerializationErrorHandler &error_handler, String *dest) {
 #ifdef MYSQL_SERVER
   if (check_stack_overrun(current_thd, STACK_MIN_SIZE, nullptr))
     return FAILURE; /* purecov: inspected */
@@ -580,7 +594,7 @@ static enum_serialization_result serialize_json_object(
   const size_t start_pos = dest->length();
   const size_t size = object->cardinality();
 
-  if (check_json_depth(++depth, json_depth_handler)) {
+  if (check_json_depth(++depth, error_handler)) {
     return FAILURE;
   }
 
@@ -630,8 +644,8 @@ static enum_serialization_result serialize_json_object(
       size_t offset = dest->length() - start_pos;
       if (is_too_big_for_json(offset, large)) return VALUE_TOO_BIG;
       insert_offset_or_size(dest, entry_pos + 1, offset, large);
-      res = serialize_json_value(child, entry_pos, dest, depth, !large,
-                                 json_depth_handler);
+      res = serialize_json_value(child, entry_pos, depth, !large, error_handler,
+                                 dest);
       if (res != OK) return res;
     }
     entry_pos += value_entry_size;
@@ -714,14 +728,13 @@ static enum_serialization_result serialize_datetime(const Json_datetime *jdt,
   @param depth     the current nesting level
   @param small_parent tells if @a dom is contained in an array or object
                       which is stored in the small storage format
-  @param json_depth_handler handler which will be called for JSON documents
-                            exceeding the maximum allowed depth
+  @param error_handler a handler that is invoked if an error occurs
 
   @return          serialization status
 */
 static enum_serialization_result serialize_json_value(
-    const Json_dom *dom, size_t type_pos, String *dest, size_t depth,
-    bool small_parent, const JsonErrorHandler &json_depth_handler) {
+    const Json_dom *dom, size_t type_pos, size_t depth, bool small_parent,
+    const JsonSerializationErrorHandler &error_handler, String *dest) {
   const size_t start_pos = dest->length();
   assert(type_pos < start_pos);
 
@@ -731,8 +744,8 @@ static enum_serialization_result serialize_json_value(
     case enum_json_type::J_ARRAY: {
       const Json_array *array = down_cast<const Json_array *>(dom);
       (*dest)[type_pos] = JSONB_TYPE_SMALL_ARRAY;
-      result =
-          serialize_json_array(array, dest, false, depth, json_depth_handler);
+      result = serialize_json_array(array, /*large=*/false, depth,
+                                    error_handler, dest);
       /*
         If the array was too large to fit in the small storage format,
         reset the destination buffer and retry with the large storage
@@ -747,16 +760,16 @@ static enum_serialization_result serialize_json_value(
         if (small_parent) return VALUE_TOO_BIG;
         dest->length(start_pos);
         (*dest)[type_pos] = JSONB_TYPE_LARGE_ARRAY;
-        result =
-            serialize_json_array(array, dest, true, depth, json_depth_handler);
+        result = serialize_json_array(array, /*large=*/true, depth,
+                                      error_handler, dest);
       }
       break;
     }
     case enum_json_type::J_OBJECT: {
       const Json_object *object = down_cast<const Json_object *>(dom);
       (*dest)[type_pos] = JSONB_TYPE_SMALL_OBJECT;
-      result =
-          serialize_json_object(object, dest, false, depth, json_depth_handler);
+      result = serialize_json_object(object, /*large=*/false, depth,
+                                     error_handler, dest);
       /*
         If the object was too large to fit in the small storage format,
         reset the destination buffer and retry with the large storage
@@ -771,8 +784,8 @@ static enum_serialization_result serialize_json_value(
         if (small_parent) return VALUE_TOO_BIG;
         dest->length(start_pos);
         (*dest)[type_pos] = JSONB_TYPE_LARGE_OBJECT;
-        result = serialize_json_object(object, dest, true, depth,
-                                       json_depth_handler);
+        result = serialize_json_object(object, /*large=*/true, depth,
+                                       error_handler, dest);
       }
       break;
     }
@@ -1262,18 +1275,12 @@ bool Value::is_backed_by(const String *str) const {
   Copy the binary representation of this value into a buffer,
   replacing the contents of the receiving buffer.
 
+  @param error_handler a handler that is invoked if an error occurs
   @param buf  the receiving buffer
-  @param json_depth_handler handler which will be called for JSON documents
-                            exceeding the maximum allowed depth
-  @param json_key_handler  handler which will be called for JSON documents
-                           having keys too large
-  @param json_value_handler handler which will be called for JSON documents
-                            having values too large
   @return false on success, true otherwise
 */
-bool Value::raw_binary(String *buf, const JsonErrorHandler &json_depth_handler,
-                       const JsonErrorHandler &json_key_handler,
-                       const JsonErrorHandler &json_value_handler) const {
+bool Value::raw_binary(const JsonSerializationErrorHandler &error_handler,
+                       String *buf) const {
   // It's not safe to overwrite ourselves.
   assert(!is_backed_by(buf));
 
@@ -1296,29 +1303,24 @@ bool Value::raw_binary(String *buf, const JsonErrorHandler &json_depth_handler,
              buf->append(m_data, m_length);
     case INT: {
       Json_int i(get_int64());
-      return serialize(&i, buf, json_depth_handler, json_key_handler,
-                       json_value_handler);
+      return serialize(&i, error_handler, buf);
     }
     case UINT: {
       Json_uint i(get_uint64());
-      return serialize(&i, buf, json_depth_handler, json_key_handler,
-                       json_value_handler);
+      return serialize(&i, error_handler, buf);
     }
     case DOUBLE: {
       Json_double d(get_double());
-      return serialize(&d, buf, json_depth_handler, json_key_handler,
-                       json_value_handler);
+      return serialize(&d, error_handler, buf);
     }
     case LITERAL_NULL: {
       Json_null n;
-      return serialize(&n, buf, json_depth_handler, json_key_handler,
-                       json_value_handler);
+      return serialize(&n, error_handler, buf);
     }
     case LITERAL_TRUE:
     case LITERAL_FALSE: {
       Json_boolean b(m_type == LITERAL_TRUE);
-      return serialize(&b, buf, json_depth_handler, json_key_handler,
-                       json_value_handler);
+      return serialize(&b, error_handler, buf);
     }
     case OPAQUE:
       return buf->append(JSONB_TYPE_OPAQUE) || buf->append(field_type()) ||
@@ -1567,8 +1569,7 @@ bool space_needed(const Json_wrapper *value, bool large, size_t *needed) {
 
   // Serialize the value to a temporary buffer to find out how big it is.
   StringBuffer<STRING_BUFFER_USUAL_SIZE> buf;
-  if (value->to_binary(&buf, JsonDepthErrorHandler, JsonKeyTooBigErrorHandler,
-                       JsonValueTooBigErrorHandler, InvalidJsonErrorHandler))
+  if (value->to_binary(JsonSerializationDefaultErrorHandler(), &buf))
     return true; /* purecov: inspected */
 
   assert(buf.length() > 1);
@@ -1780,9 +1781,7 @@ bool Value::update_in_shadow(const Field_json *field, size_t pos,
     char *value_dest = destination + value_offset;
 
     StringBuffer<STRING_BUFFER_USUAL_SIZE> buffer;
-    if (new_value->to_binary(
-            &buffer, JsonDepthErrorHandler, JsonKeyTooBigErrorHandler,
-            JsonValueTooBigErrorHandler, InvalidJsonErrorHandler))
+    if (new_value->to_binary(JsonSerializationDefaultErrorHandler(), &buffer))
       return true; /* purecov: inspected */
 
     assert(buffer.length() > 1);