445 lines
12 KiB
C++
445 lines
12 KiB
C++
/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
#include "parse_tree_hints.h"
|
|
#include "sql_class.h"
|
|
#include "mysqld.h" // table_alias_charset
|
|
#include "sql_lex.h"
|
|
|
|
|
|
extern struct st_opt_hint_info opt_hint_info[];
|
|
|
|
|
|
/**
|
|
Returns pointer to Opt_hints_global object,
|
|
create Opt_hints object if not exist.
|
|
|
|
@param lex pointer to Parse_context object
|
|
|
|
@return pointer to Opt_hints object,
|
|
NULL if failed to create the object
|
|
*/
|
|
|
|
static Opt_hints_global *get_global_hints(Parse_context *pc)
|
|
{
|
|
LEX *lex= pc->thd->lex;
|
|
|
|
if (!lex->opt_hints_global)
|
|
lex->opt_hints_global= new Opt_hints_global(pc->thd->mem_root);
|
|
if (lex->opt_hints_global)
|
|
lex->opt_hints_global->set_resolved();
|
|
return lex->opt_hints_global;
|
|
}
|
|
|
|
|
|
/**
|
|
Returns pointer to Opt_hints_qb object
|
|
for query block given by parse context,
|
|
create Opt_hints_qb object if not exist.
|
|
|
|
@param pc pointer to Parse_context object
|
|
|
|
@return pointer to Opt_hints_qb object,
|
|
NULL if failed to create the object
|
|
*/
|
|
|
|
static Opt_hints_qb *get_qb_hints(Parse_context *pc)
|
|
{
|
|
|
|
if (pc->select->opt_hints_qb)
|
|
return pc->select->opt_hints_qb;
|
|
|
|
Opt_hints_global *global_hints= get_global_hints(pc);
|
|
if (global_hints == NULL)
|
|
return NULL;
|
|
|
|
Opt_hints_qb *qb= new Opt_hints_qb(global_hints, pc->thd->mem_root,
|
|
pc->select->select_number);
|
|
if (qb)
|
|
{
|
|
global_hints->register_child(qb);
|
|
pc->select->opt_hints_qb= qb;
|
|
qb->set_resolved();
|
|
}
|
|
return qb;
|
|
}
|
|
|
|
/**
|
|
Find existing Opt_hints_qb object, print warning
|
|
if the query block is not found.
|
|
|
|
@param pc pointer to Parse_context object
|
|
@param table_name query block name
|
|
@param hint processed hint
|
|
|
|
@return pointer to Opt_hints_table object if found,
|
|
NULL otherwise
|
|
*/
|
|
|
|
static Opt_hints_qb *find_qb_hints(Parse_context *pc,
|
|
const LEX_CSTRING *qb_name,
|
|
PT_hint *hint)
|
|
{
|
|
if (qb_name->length == 0) // no QB NAME is used
|
|
return pc->select->opt_hints_qb;
|
|
|
|
Opt_hints_qb *qb= static_cast<Opt_hints_qb *>
|
|
(pc->thd->lex->opt_hints_global->find_by_name(qb_name, system_charset_info));
|
|
|
|
if (qb == NULL)
|
|
{
|
|
hint->print_warn(pc->thd, ER_WARN_UNKNOWN_QB_NAME,
|
|
qb_name, NULL, NULL, NULL);
|
|
}
|
|
|
|
return qb;
|
|
}
|
|
|
|
|
|
/**
|
|
Returns pointer to Opt_hints_table object,
|
|
create Opt_hints_table object if not exist.
|
|
|
|
@param pc pointer to Parse_context object
|
|
@param table_name pointer to Hint_param_table object
|
|
@param qb pointer to Opt_hints_qb object
|
|
|
|
@return pointer to Opt_hints_table object,
|
|
NULL if failed to create the object
|
|
*/
|
|
|
|
static Opt_hints_table *get_table_hints(Parse_context *pc,
|
|
Hint_param_table *table_name,
|
|
Opt_hints_qb *qb)
|
|
{
|
|
Opt_hints_table *tab=
|
|
static_cast<Opt_hints_table *> (qb->find_by_name(&table_name->table,
|
|
table_alias_charset));
|
|
if (!tab)
|
|
{
|
|
tab= new Opt_hints_table(&table_name->table, qb, pc->thd->mem_root);
|
|
qb->register_child(tab);
|
|
}
|
|
|
|
return tab;
|
|
}
|
|
|
|
|
|
void PT_hint::print_warn(THD *thd, uint err_code,
|
|
const LEX_CSTRING *qb_name_arg,
|
|
LEX_CSTRING *table_name_arg,
|
|
LEX_CSTRING *key_name_arg,
|
|
PT_hint *hint) const
|
|
{
|
|
String str;
|
|
|
|
/* Append hint name */
|
|
if (!state)
|
|
str.append(STRING_WITH_LEN("NO_"));
|
|
str.append(opt_hint_info[hint_type].hint_name);
|
|
|
|
/* ER_WARN_UNKNOWN_QB_NAME with two arguments */
|
|
if (err_code == ER_WARN_UNKNOWN_QB_NAME)
|
|
{
|
|
String qb_name_str;
|
|
append_identifier(thd, &qb_name_str, qb_name_arg->str, qb_name_arg->length);
|
|
push_warning_printf(thd, Sql_condition::SL_WARNING,
|
|
err_code, ER_THD(thd, err_code),
|
|
qb_name_str.c_ptr_safe(), str.c_ptr_safe());
|
|
return;
|
|
}
|
|
|
|
/* ER_WARN_CONFLICTING_HINT with one argument */
|
|
str.append('(');
|
|
|
|
/* Append table name */
|
|
if (table_name_arg && table_name_arg->length > 0)
|
|
append_identifier(thd, &str, table_name_arg->str, table_name_arg->length);
|
|
|
|
/* Append QB name */
|
|
if (qb_name_arg && qb_name_arg->length > 0)
|
|
{
|
|
str.append(STRING_WITH_LEN("@"));
|
|
append_identifier(thd, &str, qb_name_arg->str, qb_name_arg->length);
|
|
}
|
|
|
|
/* Append key name */
|
|
if (key_name_arg && key_name_arg->length > 0)
|
|
{
|
|
str.append(' ');
|
|
append_identifier(thd, &str, key_name_arg->str, key_name_arg->length);
|
|
}
|
|
|
|
/* Append additional hint arguments if they exist */
|
|
if (hint)
|
|
{
|
|
if (qb_name_arg || table_name_arg || key_name_arg)
|
|
str.append(' ');
|
|
|
|
hint->append_args(thd, &str);
|
|
}
|
|
|
|
str.append(')');
|
|
|
|
push_warning_printf(thd, Sql_condition::SL_WARNING,
|
|
err_code, ER_THD(thd, err_code), str.c_ptr_safe());
|
|
}
|
|
|
|
|
|
bool PT_qb_level_hint::contextualize(Parse_context *pc)
|
|
{
|
|
if (super::contextualize(pc))
|
|
return true;
|
|
|
|
Opt_hints_qb *qb= find_qb_hints(pc, &qb_name, this);
|
|
if (qb == NULL)
|
|
return false; // TODO: Should this generate a warning?
|
|
|
|
bool conflict= false; // true if this hint conflicts with a previous hint
|
|
switch (type()) {
|
|
case SEMIJOIN_HINT_ENUM:
|
|
if (qb->subquery_hint)
|
|
conflict= true;
|
|
else if(!qb->semijoin_hint)
|
|
qb->semijoin_hint= this;
|
|
break;
|
|
case SUBQUERY_HINT_ENUM:
|
|
if (qb->semijoin_hint)
|
|
conflict= true;
|
|
else if (!qb->subquery_hint)
|
|
qb->subquery_hint= this;
|
|
break;
|
|
default:
|
|
DBUG_ASSERT(0);
|
|
}
|
|
|
|
if (conflict ||
|
|
// Set hint or detect if hint has been set before
|
|
qb->set_switch(switch_on(), type(), false))
|
|
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, &qb_name, NULL, NULL, this);
|
|
|
|
return false;
|
|
}
|
|
|
|
void PT_qb_level_hint::append_args(THD *thd, String *str) const
|
|
{
|
|
switch (type()) {
|
|
case SEMIJOIN_HINT_ENUM:
|
|
{
|
|
int count= 0;
|
|
if (args & OPTIMIZER_SWITCH_FIRSTMATCH)
|
|
{
|
|
str->append(STRING_WITH_LEN(" FIRSTMATCH"));
|
|
++count;
|
|
}
|
|
if (args & OPTIMIZER_SWITCH_LOOSE_SCAN)
|
|
{
|
|
if (count++ > 0)
|
|
str->append(STRING_WITH_LEN(","));
|
|
str->append(STRING_WITH_LEN(" LOOSESCAN"));
|
|
}
|
|
if (args & OPTIMIZER_SWITCH_MATERIALIZATION)
|
|
{
|
|
if (count++ > 0)
|
|
str->append(STRING_WITH_LEN(","));
|
|
str->append(STRING_WITH_LEN(" MATERIALIZATION"));
|
|
}
|
|
if (args & OPTIMIZER_SWITCH_DUPSWEEDOUT)
|
|
{
|
|
if (count++ > 0)
|
|
str->append(STRING_WITH_LEN(","));
|
|
str->append(STRING_WITH_LEN(" DUPSWEEDOUT"));
|
|
}
|
|
break;
|
|
}
|
|
case SUBQUERY_HINT_ENUM:
|
|
switch (args) {
|
|
case Item_exists_subselect::EXEC_MATERIALIZATION:
|
|
str->append(STRING_WITH_LEN(" MATERIALIZATION"));
|
|
break;
|
|
case Item_exists_subselect::EXEC_EXISTS:
|
|
str->append(STRING_WITH_LEN(" INTOEXISTS"));
|
|
break;
|
|
default: // Exactly one of above strategies should always be specified
|
|
DBUG_ASSERT(false);
|
|
}
|
|
break;
|
|
default:
|
|
DBUG_ASSERT(false);
|
|
}
|
|
}
|
|
|
|
|
|
bool PT_hint_list::contextualize(Parse_context *pc)
|
|
{
|
|
if (super::contextualize(pc))
|
|
return true;
|
|
|
|
if (!get_qb_hints(pc))
|
|
return true;
|
|
|
|
for (PT_hint **h= hints.begin(), **end= hints.end(); h < end; h++)
|
|
{
|
|
if (*h != NULL && (*h)->contextualize(pc))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool PT_table_level_hint::contextualize(Parse_context *pc)
|
|
{
|
|
if (super::contextualize(pc))
|
|
return true;
|
|
|
|
if (table_list.empty()) // Query block level hint
|
|
{
|
|
Opt_hints_qb *qb= find_qb_hints(pc, &qb_name, this);
|
|
if (qb == NULL)
|
|
return false;
|
|
|
|
if (qb->set_switch(switch_on(), type(), false))
|
|
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT,
|
|
&qb_name, NULL, NULL, this);
|
|
return false;
|
|
}
|
|
|
|
for (uint i= 0; i < table_list.size(); i++)
|
|
{
|
|
Hint_param_table *table_name= &table_list.at(i);
|
|
/*
|
|
If qb name exists then syntax '@qb_name table_name..' is used and
|
|
we should use qb_name for finding query block. Otherwise syntax
|
|
'table_name@qb_name' is used, so use table_name->opt_query_block.
|
|
*/
|
|
const LEX_CSTRING *qb_name_str=
|
|
qb_name.length > 0 ? &qb_name : &table_name->opt_query_block;
|
|
|
|
Opt_hints_qb *qb= find_qb_hints(pc, qb_name_str, this);
|
|
if (qb == NULL)
|
|
return false;
|
|
|
|
Opt_hints_table *tab= get_table_hints(pc, table_name, qb);
|
|
if (!tab)
|
|
return true;
|
|
|
|
if (tab->set_switch(switch_on(), type(), true))
|
|
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT,
|
|
&table_name->opt_query_block,
|
|
&table_name->table, NULL, this);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool PT_key_level_hint::contextualize(Parse_context *pc)
|
|
{
|
|
if (super::contextualize(pc))
|
|
return true;
|
|
|
|
Opt_hints_qb *qb= find_qb_hints(pc, &table_name.opt_query_block, this);
|
|
if (qb == NULL)
|
|
return false;
|
|
|
|
Opt_hints_table *tab= get_table_hints(pc, &table_name, qb);
|
|
if (!tab)
|
|
return true;
|
|
|
|
if (key_list.empty()) // Table level hint
|
|
{
|
|
if (tab->set_switch(switch_on(), type(), false))
|
|
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT,
|
|
&table_name.opt_query_block,
|
|
&table_name.table, NULL, this);
|
|
return false;
|
|
}
|
|
|
|
for (uint i= 0; i < key_list.size(); i++)
|
|
{
|
|
LEX_CSTRING *key_name= &key_list.at(i);
|
|
Opt_hints_key *key= (Opt_hints_key *)tab->find_by_name(key_name,
|
|
system_charset_info);
|
|
|
|
if (!key)
|
|
{
|
|
key= new Opt_hints_key(key_name, tab, pc->thd->mem_root);
|
|
tab->register_child(key);
|
|
}
|
|
|
|
if (key->set_switch(switch_on(), type(), true))
|
|
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT,
|
|
&table_name.opt_query_block,
|
|
&table_name.table, key_name, this);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool PT_hint_qb_name::contextualize(Parse_context *pc)
|
|
{
|
|
if (super::contextualize(pc))
|
|
return true;
|
|
|
|
Opt_hints_qb *qb= pc->select->opt_hints_qb;
|
|
|
|
DBUG_ASSERT(qb);
|
|
|
|
if (qb->get_name() || // QB name is already set
|
|
qb->get_parent()->find_by_name(&qb_name, // Name is already used
|
|
system_charset_info))
|
|
{
|
|
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT,
|
|
NULL, NULL, NULL, this);
|
|
return false;
|
|
}
|
|
|
|
qb->set_name(&qb_name);
|
|
return false;
|
|
}
|
|
|
|
|
|
bool PT_hint_max_execution_time::contextualize(Parse_context *pc)
|
|
{
|
|
if (super::contextualize(pc))
|
|
return true;
|
|
|
|
if (pc->thd->lex->sql_command != SQLCOM_SELECT || // not a SELECT statement
|
|
pc->thd->lex->sphead || // or in a SP/trigger/event
|
|
pc->select != pc->thd->lex->select_lex) // or in a subquery
|
|
{
|
|
push_warning(pc->thd, Sql_condition::SL_WARNING,
|
|
ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME,
|
|
ER_THD(pc->thd, ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME));
|
|
return false;
|
|
}
|
|
|
|
Opt_hints_global *global_hint= get_global_hints(pc);
|
|
if (global_hint->is_specified(type()))
|
|
{
|
|
// Hint duplication: /*+ MAX_EXECUTION_TIME ... MAX_EXECUTION_TIME */
|
|
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT,
|
|
NULL, NULL, NULL, this);
|
|
return false;
|
|
}
|
|
|
|
pc->thd->lex->max_execution_time= milliseconds;
|
|
global_hint->set_switch(switch_on(), type(), false);
|
|
global_hint->max_exec_time= this;
|
|
return false;
|
|
}
|
|
|