WL#15426: Implement SHOW PARSE_TREE [1/3, prep]

Preparatory patch: Wrapper functions for contextualize() and itemize()

The original contextualize() functions of all classes are renamed to
do_contextualize(). contextualize() is now just a wrapper around the
virtual function do_contextualize(). Besides calling
do_contextualize(), the class member function contextualize() is meant
to do the work of building json tree node for the corresponding PT_*
class. contextualize() is defined only in Parse_tree_node, and is
defined with final specifier, so that newly defined classes will be
prohibited from overriding this function. They should instead override
do_contextualize().  So e.g. when the code calls obj->contextualize(),
Parse_tree_node::contextualize() will be called, which in turn calls
do_contextualize() of the derived class.  Similar thing is done for
itemize() and do_itemize() for classes based on Item.

Change-Id: If9390a9dde5ca22632ae63c39a53aacb290f79eb

Author: Amit Khandekar

sql/item.cc

@@ -736,9 +736,9 @@ bool Item::aggregate_type(const char *name, Item **items, uint count) {
   return false;
 }
 
-bool Item::itemize(Parse_context *pc, Item **res) {
+bool Item::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::contextualize(pc)) return true;
+  if (super::do_contextualize(pc)) return true;
 
   // Add item to global list
   pc->thd->add_item(this);
@@ -886,9 +886,9 @@ Item *Item::transform(Item_transformer transformer, uchar *arg) {
   return (this->*transformer)(arg);
 }
 
-bool Item_ident::itemize(Parse_context *pc, Item **res) {
+bool Item_ident::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::itemize(pc, res)) return true;
+  if (super::do_itemize(pc, res)) return true;
   context = pc->thd->lex->current_context();
   return false;
 }
@@ -2061,9 +2061,9 @@ Item_name_const::Item_name_const(const POS &pos, Item *name_arg, Item *val)
   set_nullable(true);
 }
 
-bool Item_name_const::itemize(Parse_context *pc, Item **res) {
+bool Item_name_const::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::itemize(pc, res) || value_item->itemize(pc, &value_item) ||
+  if (super::do_itemize(pc, res) || value_item->itemize(pc, &value_item) ||
       name_item->itemize(pc, &name_item))
     return true;
   /*
@@ -2885,9 +2885,9 @@ Item_field::Item_field(const POS &pos, const char *db_arg,
   collation.set(DERIVATION_IMPLICIT);
 }
 
-bool Item_field::itemize(Parse_context *pc, Item **res) {
+bool Item_field::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::itemize(pc, res)) return true;
+  if (super::do_itemize(pc, res)) return true;
   Query_block *const select = pc->select;
   if (select->parsing_place != CTX_HAVING) select->select_n_where_fields++;
   return false;
@@ -3736,9 +3736,9 @@ Item_param::Item_param(const POS &pos, MEM_ROOT *root, uint pos_in_query_arg)
   set_nullable(true);  // All parameters are nullable
 }
 
-bool Item_param::itemize(Parse_context *pc, Item **res) {
+bool Item_param::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::itemize(pc, res)) return true;
+  if (super::do_itemize(pc, res)) return true;
 
   /*
     see commentaries in PTI_limit_option_param_marker::itemize()
@@ -8939,9 +8939,9 @@ Item *Item_view_ref::replace_view_refs_with_clone(uchar *arg) {
       current_thd, ref_item());
 }
 
-bool Item_default_value::itemize(Parse_context *pc, Item **res) {
+bool Item_default_value::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::itemize(pc, res)) return true;
+  if (super::do_itemize(pc, res)) return true;
 
   if (arg != nullptr) {
     if (arg->itemize(pc, &arg)) return true;
@@ -10990,13 +10990,13 @@ Item_field *FindEqualField(Item_field *item_field, table_map reachable_tables,
   return item_field;
 }
 
-bool Item_asterisk::itemize(Parse_context *pc, Item **res) {
+bool Item_asterisk::do_itemize(Parse_context *pc, Item **res) {
   assert(pc->select->parsing_place == CTX_SELECT_LIST);
 
   if (skip_itemize(res)) {
     return false;
   }
-  if (super::itemize(pc, res)) {
+  if (super::do_itemize(pc, res)) {
     return true;
   }
   pc->select->with_wild++;

sql/item.h

@@ -1111,7 +1111,7 @@ class Item : public Parse_tree_node {
     Hide the contextualize*() functions: call/override the itemize()
     in Item class tree instead.
   */
-  bool contextualize(Parse_context *) override {
+  bool do_contextualize(Parse_context *) override {
     assert(0);
     return true;
   }
@@ -1142,6 +1142,12 @@ class Item : public Parse_tree_node {
    */
   static bool bit_func_returns_binary(const Item *a, const Item *b);
 
+  /**
+    The core function that does the actual itemization. itemize() is just a
+    wrapper over this.
+  */
+  virtual bool do_itemize(Parse_context *pc, Item **res);
+
  public:
   /**
     The same as contextualize() but with additional parameter
@@ -1150,14 +1156,22 @@ class Item : public Parse_tree_node {
     constructor): we can access/change parser contexts from the itemize()
     function.
 
+    Derived classes should not override this. If needed, they should
+    override do_itemize().
+
     @param        pc    current parse context
     @param  [out] res   pointer to "this" or to a newly allocated
                         replacement object to use in the Item tree instead
 
     @retval false       success
     @retval true        syntax/OOM/etc error
   */
-  virtual bool itemize(Parse_context *pc, Item **res);
+  virtual bool itemize(Parse_context *pc, Item **res) final {
+    // Json parse tree related things to be done pre-do_itemize().
+    if (do_itemize(pc, res)) return true;
+    // Json parse tree related things to be done post-do_itemize().
+    return false;
+  }
 
   void rename(char *new_name);
   void init_make_field(Send_field *tmp_field, enum enum_field_types type);
@@ -3860,7 +3874,7 @@ class Item_name_const final : public Item {
  public:
   Item_name_const(const POS &pos, Item *name_arg, Item *val);
 
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
   bool fix_fields(THD *, Item **) override;
 
   enum Type type() const override;
@@ -4065,7 +4079,7 @@ class Item_ident : public Item {
         cached_table(item->cached_table),
         depended_from(item->depended_from) {}
 
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
 
   const char *full_name() const override;
   void set_orignal_db_name(const char *name_arg) { m_orig_db_name = name_arg; }
@@ -4318,7 +4332,7 @@ class Item_field : public Item_ident {
              Field *field);
   Item_field(Field *field);
 
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
 
   enum Type type() const override { return FIELD_ITEM; }
   bool eq(const Item *item, bool binary_cmp) const override;
@@ -4528,7 +4542,7 @@ class Item_asterisk : public Item_field {
                 const char *opt_table_name)
       : super(pos, opt_schema_name, opt_table_name, "*") {}
 
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
   bool fix_fields(THD *, Item **) override {
     assert(false);  // should never happen: see setup_wild()
     return true;
@@ -4778,7 +4792,7 @@ class Item_param final : public Item, private Settable_routine_parameter {
 
   Item_param(const POS &pos, MEM_ROOT *root, uint pos_in_query_arg);
 
-  bool itemize(Parse_context *pc, Item **item) override;
+  bool do_itemize(Parse_context *pc, Item **item) override;
 
   Item_result result_type() const override { return m_result_type; }
   enum Type type() const override { return PARAM_ITEM; }
@@ -6457,7 +6471,7 @@ class Item_default_value final : public Item_field {
  public:
   Item_default_value(const POS &pos, Item *a = nullptr)
       : super(pos, nullptr, nullptr, nullptr), arg(a) {}
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
   enum Type type() const override { return DEFAULT_VALUE_ITEM; }
   bool eq(const Item *item, bool binary_cmp) const override;
   bool fix_fields(THD *, Item **) override;
@@ -6533,9 +6547,9 @@ class Item_insert_value final : public Item_field {
         arg(a),
         m_is_values_function(false) {}
 
-  bool itemize(Parse_context *pc, Item **res) override {
+  bool do_itemize(Parse_context *pc, Item **res) override {
     if (skip_itemize(res)) return false;
-    return Item_field::itemize(pc, res) || arg->itemize(pc, &arg);
+    return Item_field::do_itemize(pc, res) || arg->itemize(pc, &arg);
   }
 
   enum Type type() const override { return INSERT_VALUE_ITEM; }

sql/item_cmpfunc.cc

@@ -2683,10 +2683,10 @@ bool Item_func_opt_neg::eq(const Item *item, bool binary_cmp) const {
   return AllItemsAreEqual(args, item_func->arguments(), arg_count, binary_cmp);
 }
 
-bool Item_func_interval::itemize(Parse_context *pc, Item **res) {
+bool Item_func_interval::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
   if (row == nullptr ||  // OOM in constructor
-      super::itemize(pc, res))
+      super::do_itemize(pc, res))
     return true;
   assert(row == args[0]);  // row->itemize() is not needed
   return false;
@@ -5423,9 +5423,9 @@ Item *make_condition(Parse_context *pc, Item *item) {
   class: we need to overload this function to run a contextualization
   the Item_cond::list items.
 */
-bool Item_cond::itemize(Parse_context *pc, Item **res) {
+bool Item_cond::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::itemize(pc, res)) return true;
+  if (super::do_itemize(pc, res)) return true;
 
   List_iterator<Item> li(list);
   Item *item;
@@ -6425,9 +6425,9 @@ void Item_func_like::print(const THD *thd, String *str,
   str->append(')');
 }
 
-bool Item_func_xor::itemize(Parse_context *pc, Item **res) {
+bool Item_func_xor::do_itemize(Parse_context *pc, Item **res) {
   if (skip_itemize(res)) return false;
-  if (super::itemize(pc, res)) return true;
+  if (super::do_itemize(pc, res)) return true;
 
   if (!args[0]->is_bool_func()) {
     args[0] = make_condition(pc, args[0]);

sql/item_cmpfunc.h

@@ -715,7 +715,7 @@ class Item_func_xor final : public Item_bool_func2 {
 
   enum Functype functype() const override { return XOR_FUNC; }
   const char *func_name() const override { return "xor"; }
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
   longlong val_int() override;
   void apply_is_true() override {}
   Item *truth_transformer(THD *, Bool_test) override;
@@ -1397,7 +1397,7 @@ class Item_func_interval final : public Item_int_func {
     allowed_arg_cols = 0;  // Fetch this value from first argument
   }
 
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
   longlong val_int() override;
   bool resolve_type(THD *) override;
   const char *func_name() const override { return "interval"; }
@@ -2454,7 +2454,7 @@ class Item_cond : public Item_bool_func {
     list.prepend(nlist);
   }
 
-  bool itemize(Parse_context *pc, Item **res) override;
+  bool do_itemize(Parse_context *pc, Item **res) override;
 
   bool fix_fields(THD *, Item **ref) override;
   void fix_after_pullout(Query_block *parent_query_block,