Bug#30030187: REDUCE DEPENDENCIES ON SQL_CLASS.H [noclose]

Move code that accesses data structures in sql_class.h from header
files to .cc files.

Patch 1.

Change-Id: I28edb9dff035f5e239e3d84a77339e8e320e2582

Author: kahatlen

sql/item_pfs_func.cc

@@ -29,9 +29,19 @@
 
 #include "sql/item_pfs_func.h"
 
+#include <stdio.h>
 #include <cmath>
 
-#include "sql/derror.h"  // ER_THD
+#include "m_ctype.h"
+#include "my_dbug.h"
+#include "my_psi_config.h"
+#include "my_sys.h"
+#include "mysql/components/services/psi_thread_bits.h"
+#include "mysqld_error.h"
+#include "pfs_thread_provider.h"
+#include "sql/field.h"
+#include "sql/item.h"
+#include "sql/sql_class.h"
 #include "sql/sql_lex.h"
 
 extern bool pfs_enabled;

sql/item_pfs_func.h

@@ -25,9 +25,14 @@
 
 /* Function items used by mysql */
 
+#include "my_inttypes.h"
 #include "sql/item_func.h"
 #include "sql/item_strfunc.h"
-#include "sql/sql_class.h"
+#include "sql/parse_tree_node_base.h"
+#include "sql_string.h"
+
+class Item;
+class THD;
 
 /** ps_current_thread_id() */
 

sql/parse_tree_handler.cc

@@ -98,10 +98,13 @@ bool PT_handler_read_base::contextualize(Parse_context *pc) {
       !select->add_table_to_list(pc->thd, table, nullptr, 0))
     return true;
 
-  if (itemize_safe(pc, &m_opt_where_clause)) return true;
+  if (m_opt_where_clause != nullptr &&
+      m_opt_where_clause->itemize(pc, &m_opt_where_clause))
+    return true;
   select->set_where_cond(m_opt_where_clause);
 
-  if (contextualize_safe(pc, m_opt_limit_clause)) return true;
+  if (m_opt_limit_clause != nullptr && m_opt_limit_clause->contextualize(pc))
+    return true;
 
   lex->expr_allows_subselect = true;
 

sql/parse_tree_items.cc

@@ -22,20 +22,35 @@
 
 #include "sql/parse_tree_items.h"
 
+#include <sys/types.h>
+
+#include "m_string.h"
 #include "my_dbug.h"
 #include "my_sqlcommand.h"
+#include "my_sys.h"
+#include "my_time.h"
 #include "mysql/udf_registration_types.h"
 #include "mysql_com.h"
+#include "mysqld_error.h"
 #include "sql/auth/auth_acls.h"
 #include "sql/item_cmpfunc.h"  // Item_func_eq
-#include "sql/mysqld.h"        // using_udf_functions
+#include "sql/item_create.h"
+#include "sql/mysqld.h"  // using_udf_functions
 #include "sql/parse_tree_nodes.h"
 #include "sql/protocol.h"
 #include "sql/sp.h"
+#include "sql/sp_head.h"
 #include "sql/sp_pcontext.h"  // sp_pcontext
+#include "sql/sql_class.h"
+#include "sql/sql_error.h"
+#include "sql/sql_lex.h"
+#include "sql/sql_list.h"
 #include "sql/sql_udf.h"
+#include "sql/system_variables.h"
 #include "sql/table.h"
 #include "sql/trigger_def.h"
+#include "sql_string.h"
+#include "template_utils.h"
 
 /**
   Apply a truth test to given expression. Either the expression can implement
@@ -150,7 +165,7 @@ bool PTI_table_wild::itemize(Parse_context *pc, Item **item) {
   if (super::itemize(pc, item)) return true;
 
   schema = pc->thd->get_protocol()->has_client_capability(CLIENT_NO_SCHEMA)
-               ? NullS
+               ? nullptr
                : schema;
   *item = new (pc->mem_root) Item_field(POS(), schema, table, "*");
   if (*item == NULL || (*item)->itemize(pc, item)) return true;
@@ -395,7 +410,8 @@ bool PTI_simple_ident_q_3d::itemize(Parse_context *pc, Item **res) {
   } else {
     *res = new (pc->mem_root) Item_ref(POS(), schema, table, field);
   }
-  return *res == nullptr || (*res)->itemize(pc, res);
+  if (*res == nullptr) return true;
+  return (*res)->itemize(pc, res);
 }
 
 bool PTI_simple_ident_q_2d::itemize(Parse_context *pc, Item **res) {
@@ -449,9 +465,267 @@ bool PTI_simple_ident_q_2d::itemize(Parse_context *pc, Item **res) {
   return false;
 }
 
+bool PTI_simple_ident_nospvar_ident::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  if ((pc->select->parsing_place != CTX_HAVING) ||
+      (pc->select->get_in_sum_expr() > 0)) {
+    *res = new (pc->mem_root) Item_field(POS(), nullptr, nullptr, ident.str);
+  } else {
+    *res = new (pc->mem_root) Item_ref(POS(), nullptr, nullptr, ident.str);
+  }
+  if (*res == nullptr) return true;
+  return (*res)->itemize(pc, res);
+}
+
 bool PTI_truth_transform::itemize(Parse_context *pc, Item **res) {
   if (super::itemize(pc, res) || expr->itemize(pc, &expr)) return true;
 
   *res = change_truth_value_of_condition(pc, expr, truth_test);
-  return *res == NULL;
+  return *res == nullptr;
+}
+
+bool PTI_function_call_nonkeyword_now::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  pc->thd->lex->safe_to_cache_query = false;
+  return false;
+}
+
+bool PTI_text_literal_text_string::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  THD *thd = pc->thd;
+  LEX_STRING tmp;
+  const CHARSET_INFO *cs_con = thd->variables.collation_connection;
+  const CHARSET_INFO *cs_cli = thd->variables.character_set_client;
+  uint repertoire = is_7bit && my_charset_is_ascii_based(cs_cli)
+                        ? MY_REPERTOIRE_ASCII
+                        : MY_REPERTOIRE_UNICODE30;
+  if (thd->charset_is_collation_connection ||
+      (repertoire == MY_REPERTOIRE_ASCII && my_charset_is_ascii_based(cs_con)))
+    tmp = literal;
+  else {
+    if (thd->convert_string(&tmp, cs_con, literal.str, literal.length, cs_cli))
+      return true;
+  }
+  init(tmp.str, tmp.length, cs_con, DERIVATION_COERCIBLE, repertoire);
+  return false;
+}
+
+bool PTI_text_literal_concat::itemize(Parse_context *pc, Item **res) {
+  Item *tmp_head;
+  if (super::itemize(pc, res) || head->itemize(pc, &tmp_head)) return true;
+
+  DBUG_ASSERT(tmp_head->type() == STRING_ITEM);
+  Item_string *head_str = down_cast<Item_string *>(tmp_head);
+  head_str->append(literal.str, literal.length);
+  if ((head_str->collation.repertoire & MY_REPERTOIRE_EXTENDED) == 0) {
+    // If the string has been pure ASCII so far, check the new part.
+    const CHARSET_INFO *cs = pc->thd->variables.collation_connection;
+    head_str->collation.repertoire |=
+        my_string_repertoire(cs, literal.str, literal.length);
+  }
+  *res = head_str;
+  return false;
+}
+
+bool PTI_temporal_literal::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  *res = create_temporal_literal(pc->thd, literal.str, literal.length, cs,
+                                 field_type, true);
+  return *res == nullptr;
+}
+
+bool PTI_variable_aux_set_var::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  LEX *lex = pc->thd->lex;
+  if (!lex->parsing_options.allows_variable) {
+    my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+    return true;
+  }
+  lex->set_uncacheable(pc->select, UNCACHEABLE_RAND);
+  return lex->set_var_list.push_back(this);
+}
+
+bool PTI_variable_aux_ident_or_text::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  LEX *lex = pc->thd->lex;
+  if (!lex->parsing_options.allows_variable) {
+    my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+    return true;
+  }
+  lex->set_uncacheable(pc->select, UNCACHEABLE_RAND);
+  return false;
+}
+
+bool PTI_variable_aux_3d::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  LEX *lex = pc->thd->lex;
+  if (!lex->parsing_options.allows_variable) {
+    my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+    return true;
+  }
+
+  /* disallow "SELECT @@global.global.variable" */
+  if (ident1.str && ident2.str && check_reserved_words(ident1.str)) {
+    error(pc, ident1_pos);
+    return true;
+  }
+
+  LEX_STRING *domain;
+  LEX_STRING *variable;
+  if (ident2.str && !is_key_cache_variable_suffix(ident2.str)) {
+    LEX_STRING component_var;
+    domain = &ident1;
+    variable = &ident2;
+    String tmp_name;
+    if (tmp_name.reserve(domain->length + 1 + variable->length + 1) ||
+        tmp_name.append(domain->str) || tmp_name.append('.') ||
+        tmp_name.append(variable->str))
+      return true;  // OOM
+    component_var.str = tmp_name.c_ptr();
+    component_var.length = tmp_name.length();
+    variable->str = nullptr;
+    variable->length = 0;
+    *res = get_system_var(pc, var_type, component_var, *variable);
+  } else
+    *res = get_system_var(pc, var_type, ident1, ident2);
+  if (*res == nullptr) return true;
+  if (is_identifier(ident1, "warning_count") ||
+      is_identifier(ident1, "error_count")) {
+    /*
+      "Diagnostics variable" used in a non-diagnostics statement.
+      Save the information we need for the former, but clear the
+      rest of the diagnostics area on account of the latter.
+      See reset_condition_info().
+    */
+    lex->keep_diagnostics = DA_KEEP_COUNTS;
+  }
+  if (!down_cast<Item_func_get_system_var *>(*res)->is_written_to_binlog())
+    lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_VARIABLE);
+
+  return false;
+}
+
+bool PTI_count_sym::itemize(Parse_context *pc, Item **res) {
+  args[0] = new (pc->mem_root) Item_int(int32{0}, 1);
+  if (args[0] == nullptr) return true;
+  return super::itemize(pc, res);
+}
+
+bool PTI_in_sum_expr::itemize(Parse_context *pc, Item **res) {
+  pc->select->in_sum_expr++;
+  if (super::itemize(pc, res) || expr->itemize(pc, &expr)) return true;
+  pc->select->in_sum_expr--;
+  *res = expr;
+  return false;
+}
+
+bool PTI_odbc_date::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res) || expr->itemize(pc, &expr)) return true;
+
+  *res = nullptr;
+  /*
+    If "expr" is reasonably short pure ASCII string literal,
+    try to parse known ODBC style date, time or timestamp literals,
+    e.g:
+    SELECT {d'2001-01-01'};
+    SELECT {t'10:20:30'};
+    SELECT {ts'2001-01-01 10:20:30'};
+  */
+  if (expr->type() == Item::STRING_ITEM &&
+      expr->collation.repertoire == MY_REPERTOIRE_ASCII) {
+    String buf;
+    String *tmp_str = expr->val_str(&buf);
+    if (tmp_str->length() < MAX_DATE_STRING_REP_LENGTH * 4) {
+      enum_field_types type = MYSQL_TYPE_STRING;
+      ErrConvString str(tmp_str);
+      LEX_STRING *ls = &ident;
+      if (ls->length == 1) {
+        if (ls->str[0] == 'd') /* {d'2001-01-01'} */
+          type = MYSQL_TYPE_DATE;
+        else if (ls->str[0] == 't') /* {t'10:20:30'} */
+          type = MYSQL_TYPE_TIME;
+      } else if (ls->length == 2) /* {ts'2001-01-01 10:20:30'} */
+      {
+        if (ls->str[0] == 't' && ls->str[1] == 's') type = MYSQL_TYPE_DATETIME;
+      }
+      if (type != MYSQL_TYPE_STRING)
+        *res = create_temporal_literal(pc->thd, str.ptr(), str.length(),
+                                       system_charset_info, type, false);
+    }
+  }
+  if (*res == nullptr) *res = expr;
+  return false;
+}
+
+bool PTI_limit_option_ident::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  LEX *lex = pc->thd->lex;
+  sp_head *sp = lex->sphead;
+  const char *query_start_ptr =
+      sp ? sp->m_parser_data.get_current_stmt_start_ptr() : nullptr;
+
+  Item_splocal *v = create_item_for_sp_var(
+      pc->thd, ident, nullptr, query_start_ptr, ident_loc.start, ident_loc.end);
+  if (v == nullptr) return true;
+
+  lex->safe_to_cache_query = false;
+
+  if (v->type() != Item::INT_ITEM) {
+    my_error(ER_WRONG_SPVAR_TYPE_IN_LIMIT, MYF(0));
+    return true;
+  }
+
+  v->limit_clause_param = true;
+  *res = v;
+  return false;
+}
+
+bool PTI_limit_option_param_marker::itemize(Parse_context *pc, Item **res) {
+  Item *tmp_param;
+  if (super::itemize(pc, res) || param_marker->itemize(pc, &tmp_param))
+    return true;
+
+  /*
+    The Item_param::type() function may return various values, so we can't
+    simply compare tmp_param->type() with some constant, cast tmp_param
+    to Item_param* and assign the result back to param_marker.
+    OTOH we ensure that Item_param::itemize() always substitute the output
+    parameter with "this" pointer of Item_param object, so we can skip
+    the check and the assignment.
+  */
+  DBUG_ASSERT(tmp_param == param_marker);
+
+  param_marker->limit_clause_param = true;
+  *res = param_marker;
+  return false;
+}
+
+bool PTI_context::itemize(Parse_context *pc, Item **res) {
+  if (super::itemize(pc, res)) return true;
+
+  pc->select->parsing_place = m_parsing_place;
+
+  if (expr->itemize(pc, &expr)) return true;
+
+  if (!expr->is_bool_func()) {
+    expr = make_condition(pc, expr);
+    if (expr == nullptr) return true;
+  }
+
+  // Ensure we're resetting parsing place of the right select
+  DBUG_ASSERT(pc->select->parsing_place == m_parsing_place);
+  pc->select->parsing_place = CTX_NONE;
+  DBUG_ASSERT(expr != nullptr);
+  expr->apply_is_true();
+
+  *res = expr;
+  return false;
 }