Bug#35963242: Add workers for JSON_STORAGE_SIZE/JSON_STORAGE_FREE to the JSON client library

Exposed get_free_space function to the json client library
by getting rid of the dependency on THD and by further exposing
Json_wrapper::get_free_space.

Change-Id: Ia0f102ae975eb6c94351aae06e97933acf6c7ac3

Author: Catalin Besleaga

client/json_client_library_main.cc

@@ -167,10 +167,16 @@ int main() {
       std::cout << "ERRROR!!" << std::endl;
 
     json_binary::Value v = json_binary::parse_binary(buf.ptr(), buf.length());
+
+    // Test call to get_free_space.
+    size_t free_space;
+    v.get_free_space(CoutSerializationErrorHandler(), &free_space);
+    std::cout << "5.1. free space: " << free_space << std::endl;
+
     std::string std_string;
     if (v.to_pretty_std_string(&std_string, CoutDefaultDepthHandler))
       std::cout << "ERRROR!!" << std::endl;
-    std::cout << "5. val[" << std_string << "]" << std::endl;
+    std::cout << "5.2. val[" << std_string << "]" << std::endl;
   }
 
   return 0;

sql-common/json_binary.cc

@@ -1978,15 +1978,17 @@ bool Value::remove_in_shadow(const Field_json *field, size_t pos,
   return field->table->add_binary_diff(field, m_data - original,
                                        offset_size(m_large));
 }
+#endif  // ifdef MYSQL_SERVER
 
 /**
   Get the amount of unused space in the binary representation of this value.
 
-  @param      thd    THD handle
+  @param[out] error_handler the handler that is invoked if an error occurs
   @param[out] space  the amount of free space
-  @return false on success, true on error
+  @return false on success, true if the JSON is invalid or the stack si overrun
 */
-bool Value::get_free_space(const THD *thd, size_t *space) const {
+bool Value::get_free_space(const JsonSerializationErrorHandler &error_handler,
+                           size_t *space) const {
   *space = 0;
 
   switch (m_type) {
@@ -2006,7 +2008,7 @@ bool Value::get_free_space(const THD *thd, size_t *space) const {
     for (size_t i = 0; i < m_element_count; ++i) {
       Value key = this->key(i);
       if (key.type() == ERROR) {
-        my_error(ER_INVALID_JSON_BINARY_DATA, MYF(0));
+        error_handler.InvalidJson();
         return true;
       }
       *space += key.get_data() - next_key;
@@ -2016,7 +2018,7 @@ bool Value::get_free_space(const THD *thd, size_t *space) const {
 
   size_t next_value_offset;
   if (first_value_offset(&next_value_offset)) {
-    my_error(ER_INVALID_JSON_BINARY_DATA, MYF(0));
+    error_handler.InvalidJson();
     return true;
   }
 
@@ -2026,14 +2028,14 @@ bool Value::get_free_space(const THD *thd, size_t *space) const {
     size_t elt_end;
     bool inlined;
     if (element_offsets(i, &elt_start, &elt_end, &inlined)) {
-      my_error(ER_INVALID_JSON_BINARY_DATA, MYF(0));
+      error_handler.InvalidJson();
       return true;
     }
 
     if (inlined) continue;
 
     if (elt_start < next_value_offset || elt_end > m_length) {
-      my_error(ER_INVALID_JSON_BINARY_DATA, MYF(0));
+      error_handler.InvalidJson();
       return true;
     }
 
@@ -2045,16 +2047,17 @@ bool Value::get_free_space(const THD *thd, size_t *space) const {
       case ARRAY:
       case OBJECT: {
         // Recursively process nested arrays or objects.
-        if (check_stack_overrun(thd, STACK_MIN_SIZE, nullptr))
+        if (error_handler.CheckStack()) {
           return true; /* purecov: inspected */
+        }
         size_t elt_space;
-        if (elt.get_free_space(thd, &elt_space)) return true;
+        if (elt.get_free_space(error_handler, &elt_space)) return true;
         *space += elt_space;
         break;
       }
       case ERROR:
         /* purecov: begin inspected */
-        my_error(ER_INVALID_JSON_BINARY_DATA, MYF(0));
+        error_handler.InvalidJson();
         return true;
         /* purecov: end */
       default:
@@ -2066,6 +2069,7 @@ bool Value::get_free_space(const THD *thd, size_t *space) const {
   return false;
 }
 
+#ifdef MYSQL_SERVER
 /**
   Check whether two binary JSON scalars are equal. This function is used by
   multi-valued index updating code. Unlike JSON comparator implemented in
@@ -2077,7 +2081,6 @@ bool Value::get_free_space(const THD *thd, size_t *space) const {
   Since MV index doesn't support indexing of arrays/objects in arrays, these
   two aren't supported and cause assert.
 */
-
 int Value::eq(const Value &val) const {
   assert(is_valid() && val.is_valid());
 
@@ -2121,6 +2124,7 @@ int Value::eq(const Value &val) const {
   }
   return -1;
 }
+
 #endif  // ifdef MYSQL_SERVER
 
 bool Value::to_std_string(std::string *buffer,

sql-common/json_binary.h

@@ -346,8 +346,10 @@ class Value {
   EXPORT_JSON_FUNCTION
   bool raw_binary(const JsonSerializationErrorHandler &error_handler,
                   String *buf) const;
+  EXPORT_JSON_FUNCTION
+  bool get_free_space(const JsonSerializationErrorHandler &error_handler,
+                      size_t *space) const;
 #ifdef MYSQL_SERVER
-  bool get_free_space(const THD *thd, size_t *space) const;
   bool update_in_shadow(const Field_json *field, size_t pos,
                         Json_wrapper *new_value, size_t data_offset,
                         size_t data_length, const char *original,

sql-common/json_dom.cc

@@ -3448,17 +3448,17 @@ ulonglong Json_wrapper::make_hash_key(ulonglong hash_val) const {
   return result;
 }
 
-#ifdef MYSQL_SERVER
-
-bool Json_wrapper::get_free_space(size_t *space) const {
+bool Json_wrapper::get_free_space(
+    const JsonSerializationErrorHandler &error_handler, size_t *space) const {
   if (m_is_dom) {
     *space = 0;
     return false;
   }
 
-  return m_value.get_free_space(current_thd, space);
+  return m_value.get_free_space(error_handler, space);
 }
 
+#ifdef MYSQL_SERVER
 bool Json_wrapper::attempt_binary_update(const Field_json *field,
                                          const Json_seekable_path &path,
                                          Json_wrapper *new_value, bool replace,

sql-common/json_dom.h

@@ -1702,11 +1702,13 @@ class Json_wrapper {
   /**
     Calculate the amount of unused space inside a JSON binary value.
 
+    @param[in] error_handler the handler that is invoked if an error occurs
     @param[out] space  the amount of unused space, or zero if this is a DOM
     @return false on success
     @return true if the JSON binary value was invalid
   */
-  bool get_free_space(size_t *space) const;
+  bool get_free_space(const JsonSerializationErrorHandler &error_handler,
+                      size_t *space) const;
 
   /**
     Attempt a binary partial update by replacing the value at @a path with @a

sql/item_json_func.cc

@@ -3515,8 +3515,10 @@ longlong Item_func_json_storage_free::val_int() {
   if (null_value) return 0;
 
   size_t space;
-  if (wrapper.get_free_space(&space))
+  if (wrapper.get_free_space(JsonSerializationDefaultErrorHandler(current_thd),
+                             &space)) {
     return error_int(); /* purecov: inspected */
+  }
 
   return space;
 }

unittest/gunit/json_binary-t.cc

@@ -825,7 +825,8 @@ static void check_corrupted_binary(THD *thd, const char *data, size_t length) {
     */
     Invalid_binary_handler handler(thd);
     size_t space;
-    bool err = val.get_free_space(thd, &space);
+    JsonSerializationDefaultErrorHandler error_handler{thd};
+    bool err = val.get_free_space(error_handler, &space);
     // If it returns true, an error should have been raised.
     EXPECT_EQ(err, handler.is_called());
   }