Bug#25418534: JSON_EXTRACT USING WILDCARDS TAKES FOREVER

Patch #7:

Accessing the JSON path legs requires going through virtual accessor
functions, due to the different storage of path legs in Json_path and
Json_path_clone. The former stores the path legs in an array of
Json_path_leg objects, whereas the latter stores them in an array of
pointers.

This patch makes both of the classes store the path legs in an array
of pointers. Json_path, which is the owner of the path leg instances,
additionally has a MEM_ROOT in which the Json_path_leg objects live.

Now that the path legs are stored the same way in the two classes, it
is possible to iterate over them without using virtual function calls.
Iterators are provided through begin() and end() to facilitate
iteration using standard mechanisms. The seek functions
find_child_doms() and seek_no_dup_elimination() are changed to take
begin and end iterators for iterating over the paths.

Microbenchmarks (64-bit, Intel Core i7-4770 3.4 GHz, GCC 6.3):

BM_JsonDomSearchEllipsis             17634 [+21.0%]
BM_JsonDomSearchEllipsis_OnlyOne       123 [ +5.7%]
BM_JsonDomSearchKey                    116 [  0.0%]
BM_JsonBinarySearchEllipsis          64065 [+10.8%]
BM_JsonBinarySearchEllipsis_OnlyOne     89 [+14.6%]
BM_JsonBinarySearchKey                  77 [ +7.8%]

Change-Id: I864d55a2f07d5f4bda330fee03cdcf0bb0d4f3e6

Author: kahatlen

sql/item_json_func.cc

@@ -2038,8 +2038,8 @@ bool wrapped_top_level_item(Json_path *path MY_ATTRIBUTE((unused)),
     return false;
 
 #ifndef DBUG_OFF
-  for (size_t i= 0; i < path->leg_count(); i++)
-    DBUG_ASSERT(path->get_leg_at(i)->is_autowrap());
+  for (const Json_path_leg *leg : *path)
+    DBUG_ASSERT(leg->is_autowrap());
 #endif
 
   return true;
@@ -2365,9 +2365,8 @@ bool Item_func_json_array_insert::val_json(Json_wrapper *wr)
       m_path.set(current_path);
 
       // the path must end in a cell identifier
-      size_t leg_count= m_path.leg_count();
-      if ((leg_count == 0) ||
-          (m_path.get_leg_at(leg_count - 1)->get_type() != jpl_array_cell))
+      if (m_path.leg_count() == 0 ||
+          m_path.last_leg()->get_type() != jpl_array_cell)
       {
         my_error(ER_INVALID_JSON_PATH_ARRAY_CELL, MYF(0));
         return error_json();
@@ -2466,10 +2465,8 @@ static bool clone_without_autowrapping(Json_path *source_path,
   Json_wrapper_vector hits(key_memory_JSON);
 
   target_path->clear();
-  size_t leg_count= source_path->leg_count();
-  for (size_t leg_idx= 0; leg_idx < leg_count; leg_idx++)
+  for (const Json_path_leg *path_leg : *source_path)
   {
-    const Json_path_leg *path_leg= source_path->get_leg_at(leg_idx);
     if (path_leg->is_autowrap())
     {
       /*
@@ -3429,7 +3426,7 @@ bool Item_func_json_remove::val_json(Json_wrapper *wr)
     }
     else
     {
-      const Json_path_leg *last_leg= path.get_leg_at(path.leg_count() - 1);
+      const Json_path_leg *last_leg= path.last_leg();
       path.pop();
       hits.clear();
       if (dom->seek(path, &hits, false, true))

sql/json_diff.cc

@@ -37,16 +37,17 @@ Json_wrapper Json_diff::value() const
   member names. Auto-wrapping is not performed.
 
   @param dom        the root of the DOM
-  @param path       the path to seek for
-  @param path_legs  the number of path legs to use
+  @param first_leg  the first path leg
+  @param last_leg   the last path leg (exclusive)
   @return the JSON DOM at the given path, or `nullptr` if the path is not found
 */
-static Json_dom *seek_exact_path(Json_dom *dom, const Json_seekable_path &path,
-                                 size_t path_legs)
+static Json_dom *seek_exact_path(Json_dom *dom,
+                                 const Json_path_iterator &first_leg,
+                                 const Json_path_iterator &last_leg)
 {
-  for (size_t i= 0; i < path_legs; ++i)
+  for (auto it= first_leg; it != last_leg; ++it)
   {
-    const auto leg= path.get_leg_at(i);
+    const Json_path_leg *leg= *it;
     const auto leg_type= leg->get_type();
     DBUG_ASSERT(leg_type == jpl_member || leg_type == jpl_array_cell);
     switch (dom->json_type())
@@ -164,7 +165,7 @@ enum_json_diff_status apply_json_diffs(Field_json *field,
     case enum_json_diff_operation::REPLACE:
       {
         DBUG_ASSERT(path.leg_count() > 0);
-        Json_dom *old= seek_exact_path(dom, path, path.leg_count());
+        Json_dom *old= seek_exact_path(dom, path.begin(), path.end());
         if (old == nullptr)
           return enum_json_diff_status::REJECTED;
         DBUG_ASSERT(old->parent() != nullptr);
@@ -174,10 +175,10 @@ enum_json_diff_status apply_json_diffs(Field_json *field,
     case enum_json_diff_operation::INSERT:
       {
         DBUG_ASSERT(path.leg_count() > 0);
-        Json_dom *parent= seek_exact_path(dom, path, path.leg_count() - 1);
+        Json_dom *parent= seek_exact_path(dom, path.begin(), path.end() - 1);
         if (parent == nullptr)
           return enum_json_diff_status::REJECTED;
-        const Json_path_leg *last_leg= path.get_leg_at(path.leg_count() - 1);
+        const Json_path_leg *last_leg= path.last_leg();
         if (parent->json_type() == enum_json_type::J_OBJECT &&
             last_leg->get_type() == jpl_member)
         {
@@ -202,10 +203,10 @@ enum_json_diff_status apply_json_diffs(Field_json *field,
     case enum_json_diff_operation::REMOVE:
       {
         DBUG_ASSERT(path.leg_count() > 0);
-        Json_dom *parent= seek_exact_path(dom, path, path.leg_count() - 1);
+        Json_dom *parent= seek_exact_path(dom, path.begin(), path.end() - 1);
         if (parent == nullptr)
           return enum_json_diff_status::REJECTED;
-        const Json_path_leg *last_leg= path.get_leg_at(path.leg_count() - 1);
+        const Json_path_leg *last_leg= path.last_leg();
         if (parent->json_type() == enum_json_type::J_OBJECT)
         {
           auto object= down_cast<Json_object*>(parent);

sql/json_diff.h

@@ -92,8 +92,8 @@ class Json_diff final
             std::unique_ptr<Json_dom> value)
     : m_path(), m_operation(operation), m_value(std::move(value))
   {
-    for (size_t i= 0; i < path.leg_count(); ++i)
-      m_path.append(*path.get_leg_at(i));
+    for (const Json_path_leg *leg : path)
+      m_path.append(*leg);
   }
 
   /// Get the path that is changed by this diff.