Bug#36288405 Add workers for JSON_SCHEMA_VALID to the JSON client library

Moved json_schema.{h,cc} to sql-common and replaced the calls to
my_error with callback functions in order to be able to export it to the
JSON client library, hid the calls to rapidjson behind a struct(PIMPL).

Change-Id: I62eb63ca68a3725f66a7c0619a4b8d11048af620

Author: Catalin Besleaga

client/CMakeLists.txt

@@ -135,6 +135,7 @@ ADD_CONVENIENCE_LIBRARY(json_client_library
   ${CMAKE_SOURCE_DIR}/sql-common/json_binary.cc
   ${CMAKE_SOURCE_DIR}/sql-common/json_dom.cc
   ${CMAKE_SOURCE_DIR}/sql-common/json_path.cc
+  ${CMAKE_SOURCE_DIR}/sql-common/json_schema.cc
   ${CMAKE_SOURCE_DIR}/sql-common/json_syntax_check.cc
   ${CMAKE_SOURCE_DIR}/sql-common/sql_string.cc
 

client/json_client_library_main.cc

@@ -43,6 +43,7 @@
 #include "sql-common/json_dom.h"
 #include "sql-common/json_error_handler.h"
 #include "sql-common/json_path.h"
+#include "sql-common/json_schema.h"
 #include "sql-common/my_decimal.h"
 #include "sql_string.h"
 #include "template_utils.h"
@@ -65,6 +66,16 @@ class CoutSerializationErrorHandler : public JsonSerializationErrorHandler {
   }
 };
 
+class CoutJsonSchemaDefaultErrorHandler final : public JsonSchemaErrorHandler {
+ public:
+  void InvalidJsonText(size_t, const char *, size_t) const override {
+    std::cout << "Invalid JSON text";
+  }
+  void InvalidJsonType() const override { std::cout << "Invalid JSON type"; }
+  void HandleStdExceptions() const override { std::cout << "Std exception"; }
+  void NotSupported() const override { std::cout << "Not supported "; }
+};
+
 }  // namespace
 
 int main() {
@@ -316,6 +327,47 @@ int main() {
       std::cout << "9.6. 2023-12-11 09:23:00.360900 is" << (res ? " NOT " : " ")
                 << "a valid TIME \n";
     }
+    {
+      const std::string json_schema{
+          "{"
+          "\"type\": \"object\","
+          "         \"properties\": {"
+          " \"a_string\": {"
+          "   \"type\": \"string\","
+          "            \"pattern\": \"^[5-9]$\""
+          "  }"
+          " }"
+          "}"};
+      const std::string valid_doc{"{ \"a_string\": \"8\" }"};
+      const std::string invalid_doc{"{ \"a_string\": \"a8\" }"};
+
+      bool is_valid{false};
+      Json_schema_validation_report report;
+      const CoutJsonSchemaDefaultErrorHandler error_handler;
+
+      if (is_valid_json_schema(valid_doc.c_str(), valid_doc.length(),
+                               json_schema.c_str(), json_schema.length(),
+                               error_handler, CoutDefaultDepthHandler,
+                               &is_valid, &report)) {
+        std::cout << "ERROR";
+        assert(false);
+      }
+      if (!is_valid) {
+        std::cout << "ERROR";
+        assert(false);
+      }
+
+      if (is_valid_json_schema(invalid_doc.c_str(), invalid_doc.length(),
+                               json_schema.c_str(), json_schema.length(),
+                               error_handler, CoutDefaultDepthHandler,
+                               &is_valid, &report)) {
+        std::cout << "ERROR";
+        assert(false);
+      }
+      if (!is_valid) {
+        std::cout << "10.1 " << report.human_readable_reason() << "\n";
+      }
+    }
   }
 
   return 0;

sql-common/json_error_handler.cc

@@ -31,6 +31,7 @@
 #include "sql/sql_class.h"
 #include "sql/sql_const.h"
 #include "sql/sql_error.h"
+#include "sql/sql_exception_handler.h"
 
 void JsonParseDefaultErrorHandler::operator()(const char *parse_err,
                                               size_t err_offset) const {
@@ -87,4 +88,22 @@ void JsonCoercionDeprecatedDefaultHandler::operator()(
     MYSQL_TIME_STATUS &status) const {
   check_deprecated_datetime_format(current_thd, &my_charset_utf8mb4_bin,
                                    status);
+}
+void JsonSchemaDefaultErrorHandler::InvalidJsonText(size_t arg_no,
+                                                    const char *wrong_string,
+                                                    size_t offset) const {
+  my_error(ER_INVALID_JSON_TEXT_IN_PARAM, MYF(0), arg_no,
+           m_calling_function_name, wrong_string, offset, "");
+}
+
+void JsonSchemaDefaultErrorHandler::NotSupported() const {
+  my_error(ER_NOT_SUPPORTED_YET, MYF(0), "references in JSON Schema");
+}
+
+void JsonSchemaDefaultErrorHandler::HandleStdExceptions() const {
+  handle_std_exception(m_calling_function_name);
+}
+
+void JsonSchemaDefaultErrorHandler::InvalidJsonType() const {
+  my_error(ER_INVALID_JSON_TYPE, MYF(0), 1, m_calling_function_name, "object");
 }

sql-common/json_error_handler.h

@@ -72,6 +72,25 @@ class JsonSerializationErrorHandler {
   virtual bool CheckStack() const = 0;
 };
 
+/**
+  Error handler to be used when parsing JSON schemas and validating JSON
+  objects using a JSON schema.
+*/
+class JsonSchemaErrorHandler {
+ public:
+  virtual ~JsonSchemaErrorHandler() = default;
+  /// Called when an invalid JSON value is encountered.
+  virtual void InvalidJsonText(size_t arg_no, const char *wrong_string,
+                               size_t offset) const = 0;
+  /// Called if the provided JSON is not a JSON object.
+  virtual void InvalidJsonType() const = 0;
+  /// Called if a std exception is thrown
+  virtual void HandleStdExceptions() const = 0;
+  /// Called if a schema reference is encountered in the JSON document as
+  /// MySQL does not support such constructs.
+  virtual void NotSupported() const = 0;
+};
+
 #ifdef MYSQL_SERVER
 
 class JsonParseDefaultErrorHandler {
@@ -107,6 +126,25 @@ class JsonSerializationDefaultErrorHandler final
   const THD *m_thd;
 };
 
+/**
+  The default error handler to be used when parsing JSON schemas and
+  validating JSON objects using a JSON schema inside the MySQL server.
+*/
+class JsonSchemaDefaultErrorHandler final : public JsonSchemaErrorHandler {
+ public:
+  explicit JsonSchemaDefaultErrorHandler(const char *function_name)
+      : m_calling_function_name(function_name) {}
+  void InvalidJsonText(size_t arg_no, const char *wrong_string,
+                       size_t offset) const override;
+  void InvalidJsonType() const override;
+  virtual void HandleStdExceptions() const override;
+  virtual void NotSupported() const override;
+
+ private:
+  /// Used for error reporting and holds the name of the function.
+  const char *m_calling_function_name;
+};
+
 /// Callback function called when a coercion error occurs. It reports the
 /// error as ERROR
 class JsonCoercionErrorHandler {