Bug#25418534: JSON_EXTRACT USING WILDCARDS TAKES FOREVER

Patch #9:

Inline json_binary::Value's constructors and getters.

BM_JsonBinarySearchEllipsis          16817 [+21.7%]
BM_JsonBinarySearchEllipsis_OnlyOne     70 [ +7.1%]
BM_JsonBinarySearchKey                  64 [ +4.7%]

Change-Id: I5882869fd58caa7fd88f70e3e837ee5d2c4427d0

Author: kahatlen

sql/json_binary.cc

@@ -944,56 +944,6 @@ serialize_json_value(const THD *thd, const Json_dom *dom, size_t type_pos,
 }
 
 
-// Constructor for literals and errors.
-Value::Value(enum_type t)
-  : m_data(nullptr), m_element_count(), m_length(), m_field_type(), m_type(t),
-    m_large()
-{
-  DBUG_ASSERT(t == LITERAL_NULL || t == LITERAL_TRUE || t == LITERAL_FALSE ||
-              t == ERROR);
-}
-
-
-// Constructor for int and uint.
-Value::Value(enum_type t, int64 val)
-  : m_int_value(val), m_element_count(), m_length(), m_field_type(), m_type(t),
-    m_large()
-{
-  DBUG_ASSERT(t == INT || t == UINT);
-}
-
-
-// Constructor for double.
-Value::Value(double d)
-  : m_double_value(d), m_element_count(), m_length(), m_field_type(),
-    m_type(DOUBLE), m_large()
-{}
-
-
-// Constructor for string.
-Value::Value(const char *data, uint32 len)
-  : m_data(data), m_element_count(), m_length(len), m_field_type(),
-    m_type(STRING), m_large()
-{}
-
-
-// Constructor for arrays and objects.
-Value::Value(enum_type t, const char *data, uint32 bytes,
-             uint32 element_count, bool large)
-  : m_data(data), m_element_count(element_count), m_length(bytes),
-    m_field_type(), m_type(t), m_large(large)
-{
-  DBUG_ASSERT(t == ARRAY || t == OBJECT);
-}
-
-
-// Constructor for opaque values.
-Value::Value(enum_field_types ft, const char *data, uint32 len)
-  : m_data(data), m_element_count(), m_length(len), m_field_type(ft),
-    m_type(OPAQUE), m_large()
-{}
-
-
 bool Value::is_valid() const
 {
   switch (m_type)
@@ -1041,80 +991,6 @@ bool Value::is_valid() const
 }
 
 
-/**
-  Get a pointer to the beginning of the STRING or OPAQUE data
-  represented by this instance.
-*/
-const char *Value::get_data() const
-{
-  DBUG_ASSERT(m_type == STRING || m_type == OPAQUE);
-  return m_data;
-}
-
-
-/**
-  Get the length in bytes of the STRING or OPAQUE value represented by
-  this instance.
-*/
-uint32 Value::get_data_length() const
-{
-  DBUG_ASSERT(m_type == STRING || m_type == OPAQUE);
-  return m_length;
-}
-
-
-/**
-  Get the value of an INT.
-*/
-int64 Value::get_int64() const
-{
-  DBUG_ASSERT(m_type == INT);
-  return m_int_value;
-}
-
-
-/**
-  Get the value of a UINT.
-*/
-uint64 Value::get_uint64() const
-{
-  DBUG_ASSERT(m_type == UINT);
-  return static_cast<uint64>(m_int_value);
-}
-
-
-/**
-  Get the value of a DOUBLE.
-*/
-double Value::get_double() const
-{
-  DBUG_ASSERT(m_type == DOUBLE);
-  return m_double_value;
-}
-
-
-/**
-  Get the number of elements in an array, or the number of members in
-  an object.
-*/
-uint32 Value::element_count() const
-{
-  DBUG_ASSERT(m_type == ARRAY || m_type == OBJECT);
-  return m_element_count;
-}
-
-
-/**
-  Get the MySQL field type of an opaque value. Identifies the type of
-  the value stored in the data portion of an opaque value.
-*/
-enum_field_types Value::field_type() const
-{
-  DBUG_ASSERT(m_type == OPAQUE);
-  return m_field_type;
-}
-
-
 /**
   Create a Value object that represents an error condition.
 */

sql/json_binary.h

@@ -138,6 +138,7 @@
 #include <string>
 
 #include "binary_log_types.h"                   // enum_field_types
+#include "my_dbug.h"                            // DBUG_ASSERT
 #include "my_inttypes.h"
 
 class Field_json;
@@ -190,15 +191,70 @@ class Value
   enum_type type() const { return m_type; }
   /// Does this value use the large storage format?
   bool large_format() const { return m_large; }
-  const char *get_data() const;
-  uint32 get_data_length() const;
-  int64 get_int64() const;
-  uint64 get_uint64() const;
-  double get_double() const;
-  uint32 element_count() const;
+
+  /**
+    Get a pointer to the beginning of the STRING or OPAQUE data
+    represented by this instance.
+  */
+  const char *get_data() const
+  {
+    DBUG_ASSERT(m_type == STRING || m_type == OPAQUE);
+    return m_data;
+  }
+
+  /**
+    Get the length in bytes of the STRING or OPAQUE value represented by
+    this instance.
+  */
+  uint32 get_data_length() const
+  {
+    DBUG_ASSERT(m_type == STRING || m_type == OPAQUE);
+    return m_length;
+  }
+
+  /** Get the value of an INT. */
+  int64 get_int64() const
+  {
+    DBUG_ASSERT(m_type == INT);
+    return m_int_value;
+  }
+
+  /** Get the value of a UINT. */
+  uint64 get_uint64() const
+  {
+    DBUG_ASSERT(m_type == UINT);
+    return static_cast<uint64>(m_int_value);
+  }
+
+  /** Get the value of a DOUBLE. */
+  double get_double() const
+  {
+    DBUG_ASSERT(m_type == DOUBLE);
+    return m_double_value;
+  }
+
+  /**
+    Get the number of elements in an array, or the number of members in
+    an object.
+  */
+  uint32 element_count() const
+  {
+    DBUG_ASSERT(m_type == ARRAY || m_type == OBJECT);
+    return m_element_count;
+  }
+
+  /**
+    Get the MySQL field type of an opaque value. Identifies the type of
+    the value stored in the data portion of an opaque value.
+  */
+  enum_field_types field_type() const
+  {
+    DBUG_ASSERT(m_type == OPAQUE);
+    return m_field_type;
+  }
+
   Value element(size_t pos) const;
   Value key(size_t pos) const;
-  enum_field_types field_type() const;
   Value lookup(const std::string &key) const;
   size_t lookup_index(const std::string &key) const;
   bool is_backed_by(const String *str) const;
@@ -213,27 +269,50 @@ class Value
                         const char *original, char *destination) const;
 
   /** Constructor for values that represent literals or errors. */
-  explicit Value(enum_type t);
+  explicit Value(enum_type t)
+    : m_data(nullptr), m_type(t)
+  {
+    DBUG_ASSERT(t == LITERAL_NULL || t == LITERAL_TRUE || t == LITERAL_FALSE ||
+                t == ERROR);
+  }
+
   /** Constructor for values that represent ints or uints. */
-  explicit Value(enum_type t, int64 val);
+  explicit Value(enum_type t, int64 val)
+    : m_int_value(val), m_type(t)
+  {
+    DBUG_ASSERT(t == INT || t == UINT);
+  }
+
   /** Constructor for values that represent doubles. */
-  explicit Value(double val);
+  explicit Value(double val) : m_double_value(val), m_type(DOUBLE) {}
+
   /** Constructor for values that represent strings. */
-  Value(const char *data, uint32 len);
+  Value(const char *data, uint32 len)
+    : m_data(data), m_length(len), m_type(STRING)
+  {}
+
   /**
     Constructor for values that represent arrays or objects.
 
     @param t type
     @param data pointer to the start of the binary representation
-    @param element_count the number of elements or members in the value
     @param bytes the number of bytes in the binary representation of the value
+    @param element_count the number of elements or members in the value
     @param large true if the value should be stored in the large
     storage format with 4 byte offsets instead of 2 byte offsets
   */
-  Value(enum_type t, const char *data, uint32 element_count, uint32 bytes,
-        bool large);
+  Value(enum_type t, const char *data, uint32 bytes, uint32 element_count,
+        bool large)
+    : m_data(data), m_element_count(element_count), m_length(bytes),
+      m_type(t), m_large(large)
+  {
+    DBUG_ASSERT(t == ARRAY || t == OBJECT);
+  }
+
   /** Constructor for values that represent opaque data. */
-  Value(enum_field_types ft, const char *data, uint32 len);
+  Value(enum_field_types ft, const char *data, uint32 len)
+    : m_data(data), m_length(len), m_field_type(ft), m_type(OPAQUE)
+  {}
 
   /** Empty constructor. Produces a value that represents an error condition. */
   Value() : Value(ERROR) {}
@@ -276,27 +355,32 @@ class Value
     /** The value if the type is DOUBLE. */
     const double m_double_value;
   };
+
   /**
     Element count for arrays and objects. Unused for other types.
   */
-  const uint32 m_element_count;
+  const uint32 m_element_count{};
+
   /**
     The full length (in bytes) of the binary representation of an array or
     object, or the length of a string or opaque value. Unused for other types.
   */
-  const uint32 m_length;
+  const uint32 m_length{};
+
   /**
     The MySQL field type of the value, in case the type of the value is
     OPAQUE. Otherwise, it is unused.
   */
-  const enum_field_types m_field_type;
+  const enum_field_types m_field_type{};
+
   /** The JSON type of the value. */
   const enum_type m_type;
+
   /**
     True if an array or an object uses the large storage format with 4
     byte offsets instead of 2 byte offsets.
   */
-  const bool m_large;
+  const bool m_large{};
 
   size_t key_entry_offset(size_t pos) const;
   size_t value_entry_offset(size_t pos) const;