Browse Source
MDEV-33281 Implement optimizer hints
MDEV-33281 Implement optimizer hints
This commit introduces:
- the infrastructure for optimizer hints;
- hints for join buffering: BNL(), NO_BNL(), BKA(), NO_BKA();
- NO_ICP() hint for disabling index condition pushdown;
- MRR(), MO_MRR() hint for multi-range reads control;
- NO_RANGE_OPTIMIZATION() for disabling range optimization;
- QB_NAME() for assigning names for query blocks.
pull/3878/head
Oleg Smirnov
1 year ago
21 changed files with 1555 additions and 64 deletions
-
1libmysqld/CMakeLists.txt
-
62mysql-test/main/opt_hints.result
-
1sql/CMakeLists.txt
-
40sql/mem_root_array.h
-
23sql/multi_range_read.cc
-
726sql/opt_hints.cc
-
507sql/opt_hints.h
-
11sql/opt_hints_parser.cc
-
23sql/opt_hints_parser.h
-
4sql/opt_index_cond_pushdown.cc
-
8sql/opt_range.cc
-
6sql/share/errmsg-utf8.txt
-
10sql/sql_base.cc
-
12sql/sql_lex.cc
-
31sql/sql_lex.h
-
49sql/sql_list.h
-
47sql/sql_select.cc
-
5sql/sql_string.h
-
18sql/sql_yacc.yy
-
7sql/table.h
-
28tests/mysql_client_test.c
@ -0,0 +1,726 @@ |
|||
/* 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 "my_global.h"
|
|||
#include "sql_class.h"
|
|||
#include "sql_lex.h"
|
|||
#include "sql_select.h"
|
|||
#include "opt_hints.h"
|
|||
|
|||
/**
|
|||
Information about hints. Sould be |
|||
synchronized with opt_hints_enum enum. |
|||
|
|||
Note: Hint name depends on hint state. 'NO_' prefix is added |
|||
if appropriate hint state bit(see Opt_hints_map::hints) is not |
|||
set. Depending on 'switch_state_arg' argument in 'parse tree |
|||
object' constructors(see parse_tree_h../cnm ints.[h,cc]) implementor |
|||
can control wishful form of the hint name. |
|||
*/ |
|||
|
|||
struct st_opt_hint_info opt_hint_info[]= |
|||
{ |
|||
{"BKA", true, true}, |
|||
{"BNL", true, true}, |
|||
{"ICP", true, true}, |
|||
{"MRR", true, true}, |
|||
{"NO_RANGE_OPTIMIZATION", true, true}, |
|||
{"QB_NAME", false, false}, |
|||
{0, 0, 0} |
|||
}; |
|||
|
|||
/**
|
|||
Prefix for system generated query block name. |
|||
Used in information warning in EXPLAIN oputput. |
|||
*/ |
|||
|
|||
const LEX_CSTRING sys_qb_prefix= {"select#", 7}; |
|||
|
|||
|
|||
/*
|
|||
Compare LEX_CSTRING objects. |
|||
|
|||
@param s Pointer to LEX_CSTRING |
|||
@param t Pointer to LEX_CSTRING |
|||
|
|||
@return 0 if strings are equal |
|||
1 if s is greater |
|||
-1 if t is greater |
|||
*/ |
|||
|
|||
static int cmp_lex_string(const LEX_CSTRING *s, |
|||
const LEX_CSTRING *t) |
|||
{ |
|||
return system_charset_info-> |
|||
coll->strnncollsp(system_charset_info, |
|||
(uchar *) s->str, s->length, |
|||
(uchar *) t->str, t->length); |
|||
} |
|||
|
|||
|
|||
static void print_warn(THD *thd, uint err_code, opt_hints_enum hint_type, |
|||
bool hint_state, |
|||
const LEX_CSTRING *qb_name_arg, |
|||
const LEX_CSTRING *table_name_arg, |
|||
const LEX_CSTRING *key_name_arg/*, PT_hint *hint*/) |
|||
{ |
|||
String str; |
|||
|
|||
/* Append hint name */ |
|||
if (!hint_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::WARN_LEVEL_WARN, |
|||
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 */ |
|||
// OLEGS: todo
|
|||
// 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::WARN_LEVEL_WARN, |
|||
err_code, ER_THD(thd, err_code), str.c_ptr_safe()); |
|||
} |
|||
|
|||
|
|||
/**
|
|||
Returns a pointer to Opt_hints_global object, |
|||
creates Opt_hints object if not exist. |
|||
|
|||
@param pc 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; |
|||
} |
|||
|
|||
|
|||
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 // OLEGS: amend this
|
|||
|
|||
@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, |
|||
opt_hints_enum hint_type, |
|||
bool hint_state) |
|||
{ |
|||
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)); |
|||
|
|||
if (qb == NULL) |
|||
{ |
|||
print_warn(pc->thd, ER_WARN_UNKNOWN_QB_NAME, hint_type, hint_state, |
|||
qb_name, 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, |
|||
const LEX_CSTRING *table_name, |
|||
Opt_hints_qb *qb) |
|||
{ |
|||
Opt_hints_table *tab= |
|||
static_cast<Opt_hints_table *> (qb->find_by_name(table_name)); |
|||
if (!tab) |
|||
{ |
|||
tab= new Opt_hints_table(table_name, qb, pc->thd->mem_root); |
|||
qb->register_child(tab); |
|||
} |
|||
|
|||
return tab; |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
bool Opt_hints::get_switch(opt_hints_enum type_arg) const |
|||
{ |
|||
if (is_specified(type_arg)) |
|||
return hints_map.switch_on(type_arg); |
|||
|
|||
if (opt_hint_info[type_arg].check_upper_lvl) |
|||
return parent->get_switch(type_arg); |
|||
|
|||
return false; |
|||
} |
|||
|
|||
|
|||
Opt_hints* Opt_hints::find_by_name(const LEX_CSTRING *name_arg) const |
|||
{ |
|||
for (uint i= 0; i < child_array.size(); i++) |
|||
{ |
|||
const LEX_CSTRING *name= child_array[i]->get_name(); |
|||
if (name && !cmp_lex_string(name, name_arg)) |
|||
return child_array[i]; |
|||
} |
|||
return NULL; |
|||
} |
|||
|
|||
|
|||
void Opt_hints::print(THD *thd, String *str) |
|||
{ |
|||
for (uint i= 0; i < MAX_HINT_ENUM; i++) |
|||
{ |
|||
if (is_specified(static_cast<opt_hints_enum>(i)) && is_resolved()) |
|||
{ |
|||
append_hint_type(str, static_cast<opt_hints_enum>(i)); |
|||
str->append(STRING_WITH_LEN("(")); |
|||
append_name(thd, str); |
|||
// OLEGS:
|
|||
//if (!opt_hint_info[i].switch_hint)
|
|||
// get_complex_hints(i)->append_args(thd, str);
|
|||
str->append(STRING_WITH_LEN(") ")); |
|||
} |
|||
} |
|||
|
|||
for (uint i= 0; i < child_array.size(); i++) |
|||
child_array[i]->print(thd, str); |
|||
} |
|||
|
|||
|
|||
void Opt_hints::append_hint_type(String *str, opt_hints_enum type) |
|||
{ |
|||
const char* hint_name= opt_hint_info[type].hint_name; |
|||
if(!hints_map.switch_on(type)) |
|||
str->append(STRING_WITH_LEN("NO_")); |
|||
str->append(hint_name); |
|||
} |
|||
|
|||
|
|||
void Opt_hints::print_warn_unresolved(THD *thd) |
|||
{ |
|||
String hint_name_str, hint_type_str; |
|||
append_name(thd, &hint_name_str); |
|||
|
|||
for (uint i= 0; i < MAX_HINT_ENUM; i++) |
|||
{ |
|||
if (is_specified(static_cast<opt_hints_enum>(i))) |
|||
{ |
|||
hint_type_str.length(0); |
|||
append_hint_type(&hint_type_str, static_cast<opt_hints_enum>(i)); |
|||
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, |
|||
get_warn_unresolved_code(), |
|||
ER_THD(thd, get_warn_unresolved_code()), |
|||
hint_name_str.c_ptr_safe(), |
|||
hint_type_str.c_ptr_safe()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
void Opt_hints::check_unresolved(THD *thd) |
|||
{ |
|||
if (!is_resolved()) |
|||
print_warn_unresolved(thd); |
|||
|
|||
if (!is_all_resolved()) |
|||
{ |
|||
for (uint i= 0; i < child_array.size(); i++) |
|||
child_array[i]->check_unresolved(thd); |
|||
} |
|||
} |
|||
|
|||
|
|||
PT_hint *Opt_hints_global::get_complex_hints(uint type) |
|||
{ |
|||
DBUG_ASSERT(0); |
|||
return NULL; |
|||
} |
|||
|
|||
|
|||
Opt_hints_qb::Opt_hints_qb(Opt_hints *opt_hints_arg, |
|||
MEM_ROOT *mem_root_arg, |
|||
uint select_number_arg) |
|||
: Opt_hints(NULL, opt_hints_arg, mem_root_arg), |
|||
select_number(select_number_arg) |
|||
{ |
|||
sys_name.str= buff; |
|||
sys_name.length= my_snprintf(buff, sizeof(buff), "%s%lx", |
|||
sys_qb_prefix.str, select_number); |
|||
} |
|||
|
|||
|
|||
Opt_hints_table *Opt_hints_qb::adjust_table_hints(TABLE *table, |
|||
const LEX_CSTRING *alias) |
|||
{ |
|||
Opt_hints_table *tab= static_cast<Opt_hints_table *>(find_by_name(alias)); |
|||
|
|||
table->pos_in_table_list->opt_hints_qb= this; |
|||
|
|||
if (!tab) // Tables not found
|
|||
return NULL; |
|||
|
|||
tab->adjust_key_hints(table); |
|||
return tab; |
|||
} |
|||
|
|||
|
|||
void Opt_hints_table::adjust_key_hints(TABLE *table) |
|||
{ |
|||
set_resolved(); |
|||
if (child_array_ptr()->size() == 0) // No key level hints
|
|||
{ |
|||
get_parent()->incr_resolved_children(); |
|||
return; |
|||
} |
|||
|
|||
/* Make sure that adjustement is called only once. */ |
|||
DBUG_ASSERT(keyinfo_array.size() == 0); |
|||
keyinfo_array.resize(table->s->keys, NULL); |
|||
|
|||
for (Opt_hints** hint= child_array_ptr()->begin(); |
|||
hint < child_array_ptr()->end(); ++hint) |
|||
{ |
|||
KEY *key_info= table->key_info; |
|||
for (uint j= 0 ; j < table->s->keys ; j++, key_info++) |
|||
{ |
|||
if (!cmp_lex_string((*hint)->get_name(), &key_info->name)) |
|||
{ |
|||
(*hint)->set_resolved(); |
|||
keyinfo_array[j]= static_cast<Opt_hints_key *>(*hint); |
|||
incr_resolved_children(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/*
|
|||
Do not increase number of resolved tables |
|||
if there are unresolved key objects. It's |
|||
important for check_unresolved() function. |
|||
*/ |
|||
if (is_all_resolved()) |
|||
get_parent()->incr_resolved_children(); |
|||
} |
|||
|
|||
|
|||
/**
|
|||
Function returns hint value depending on |
|||
the specfied hint level. If hint is specified |
|||
on current level, current level hint value is |
|||
returned, otherwise parent level hint is checked. |
|||
|
|||
@param hint Pointer to the hint object |
|||
@param parent_hint Pointer to the parent hint object, |
|||
should never be NULL |
|||
@param type_arg hint type |
|||
@param OUT ret_val hint value depending on |
|||
what hint level is used |
|||
|
|||
@return true if hint is specified, false otherwise |
|||
*/ |
|||
|
|||
static bool get_hint_state(Opt_hints *hint, |
|||
Opt_hints *parent_hint, |
|||
opt_hints_enum type_arg, |
|||
bool *ret_val) |
|||
{ |
|||
DBUG_ASSERT(parent_hint); |
|||
|
|||
if (opt_hint_info[type_arg].switch_hint) |
|||
{ |
|||
if (hint && hint->is_specified(type_arg)) |
|||
{ |
|||
*ret_val= hint->get_switch(type_arg); |
|||
return true; |
|||
} |
|||
else if (opt_hint_info[type_arg].check_upper_lvl && |
|||
parent_hint->is_specified(type_arg)) |
|||
{ |
|||
*ret_val= parent_hint->get_switch(type_arg); |
|||
return true; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
/* Complex hint, not implemented atm */ |
|||
DBUG_ASSERT(0); |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
|
|||
bool hint_key_state(const THD *thd, const TABLE *table, |
|||
uint keyno, opt_hints_enum type_arg, |
|||
uint optimizer_switch) |
|||
{ |
|||
Opt_hints_table *table_hints= table->pos_in_table_list->opt_hints_table; |
|||
|
|||
/* Parent should always be initialized */ |
|||
if (table_hints && keyno != MAX_KEY) |
|||
{ |
|||
Opt_hints_key *key_hints= table_hints->keyinfo_array.size() > 0 ? |
|||
table_hints->keyinfo_array[keyno] : NULL; |
|||
bool ret_val= false; |
|||
if (get_hint_state(key_hints, table_hints, type_arg, &ret_val)) |
|||
return ret_val; |
|||
} |
|||
|
|||
return optimizer_flag(thd, optimizer_switch); |
|||
} |
|||
|
|||
|
|||
bool hint_table_state(const THD *thd, const TABLE *table, |
|||
opt_hints_enum type_arg, |
|||
uint optimizer_switch) |
|||
{ |
|||
TABLE_LIST *table_list= table->pos_in_table_list; |
|||
if (table_list->opt_hints_qb) |
|||
{ |
|||
bool ret_val= false; |
|||
if (get_hint_state(table_list->opt_hints_table, |
|||
table_list->opt_hints_qb, |
|||
type_arg, &ret_val)) |
|||
return ret_val; |
|||
} |
|||
|
|||
return optimizer_flag(thd, optimizer_switch); |
|||
} |
|||
|
|||
|
|||
bool hint_table_state_or_fallback(const THD *thd, const TABLE *table, |
|||
opt_hints_enum type_arg, |
|||
bool fallback_value) |
|||
{ |
|||
TABLE_LIST *table_list= table->pos_in_table_list; |
|||
if (table_list->opt_hints_qb) |
|||
{ |
|||
bool ret_val= false; |
|||
if (get_hint_state(table_list->opt_hints_table, |
|||
table_list->opt_hints_qb, |
|||
type_arg, &ret_val)) |
|||
return ret_val; |
|||
} |
|||
|
|||
return fallback_value; |
|||
} |
|||
|
|||
|
|||
bool Optimizer_hint_parser::Table_level_hint::resolve(Parse_context *pc) const |
|||
{ |
|||
const Table_level_hint_type &table_level_hint_type= *this; |
|||
opt_hints_enum hint_type; |
|||
bool hint_state; // ON or OFF
|
|||
|
|||
switch (table_level_hint_type.id()) |
|||
{ |
|||
case TokenID::keyword_BNL: |
|||
hint_type= BNL_HINT_ENUM; |
|||
hint_state= true; |
|||
break; |
|||
case TokenID::keyword_NO_BNL: |
|||
hint_type= BNL_HINT_ENUM; |
|||
hint_state= false; |
|||
break; |
|||
case TokenID::keyword_BKA: |
|||
hint_type= BKA_HINT_ENUM; |
|||
hint_state= true; |
|||
break; |
|||
case TokenID::keyword_NO_BKA: |
|||
hint_type= BKA_HINT_ENUM; |
|||
hint_state= false; |
|||
break; |
|||
default: |
|||
DBUG_ASSERT(0); |
|||
return true; |
|||
} |
|||
|
|||
if (const At_query_block_name_opt_table_name_list & |
|||
at_query_block_name_opt_table_name_list= *this) |
|||
{ |
|||
// this is @ query_block_name opt_table_name_list
|
|||
const Query_block_name &qb_name= *this; |
|||
Opt_hints_qb *qb= find_qb_hints(pc, &qb_name, hint_type, hint_state); |
|||
if (qb == NULL) |
|||
return false; |
|||
if (at_query_block_name_opt_table_name_list.is_empty()) |
|||
{ |
|||
// e.g. BKA(@qb1)
|
|||
if (qb->set_switch(hint_state, hint_type, false)) |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, hint_type, hint_state, |
|||
&qb_name, NULL, NULL/*, this*/); |
|||
return false; |
|||
} |
|||
else |
|||
{ |
|||
// e.g. BKA(@qb1 t1, t2, t3)
|
|||
const Opt_table_name_list &opt_table_name_list= *this; |
|||
for (const Table_name &table : opt_table_name_list) |
|||
{ |
|||
Opt_hints_table *tab= get_table_hints(pc, &table, qb); |
|||
if (!tab) |
|||
return true; // OLEGS: why no warning?
|
|||
if (tab->set_switch(hint_state, hint_type, true)) |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, hint_type, hint_state, |
|||
&qb_name, &table, NULL/*, this*/); |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// this is opt_hint_param_table_list
|
|||
const Opt_table_name_list &table_name_list= *this; |
|||
const Opt_hint_param_table_list &opt_hint_param_table_list= *this; |
|||
Opt_hints_qb *qb= find_qb_hints(pc, &null_clex_str, hint_type, hint_state); |
|||
if (qb == NULL) |
|||
return false; |
|||
if (table_name_list.is_empty() && opt_hint_param_table_list.is_empty()) |
|||
{ |
|||
// e.g. BKA()
|
|||
if (qb->set_switch(hint_state, hint_type, false)) |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, hint_type, hint_state, |
|||
&null_clex_str, NULL, NULL/*, this*/); |
|||
return false; |
|||
} |
|||
for (const Table_name &table : table_name_list) |
|||
{ |
|||
// e.g. BKA(t1, t2)
|
|||
Opt_hints_table *tab= get_table_hints(pc, &table, qb); |
|||
if (!tab) |
|||
return true; // OLEGS: no warning?
|
|||
if (tab->set_switch(hint_state, hint_type, true)) |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, hint_type, hint_state, |
|||
&null_clex_str, &table, NULL/*, this*/); |
|||
} |
|||
|
|||
for (const Hint_param_table &table : opt_hint_param_table_list) |
|||
{ |
|||
// e.g. BKA(t1@qb1, t2@qb2)
|
|||
const Query_block_name &qb_name= table; |
|||
const Table_name &table_name= table; |
|||
Opt_hints_qb *qb= find_qb_hints(pc, &qb_name, hint_type, hint_state); |
|||
if (qb == NULL) |
|||
return false; |
|||
// OLEGS: todo
|
|||
Opt_hints_table *tab= get_table_hints(pc, &table_name, qb); |
|||
if (!tab) |
|||
return true; // OLEGS: why no warning?
|
|||
|
|||
if (tab->set_switch(hint_state, hint_type, true)) |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, hint_type, hint_state, |
|||
&qb_name, &table_name, NULL/*, this*/); |
|||
} |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
|
|||
bool Optimizer_hint_parser::Index_level_hint::resolve(Parse_context *pc) const |
|||
{ |
|||
const Index_level_hint_type &index_level_hint_type= *this; |
|||
opt_hints_enum hint_type; |
|||
bool hint_state; // ON or OFF
|
|||
|
|||
switch (index_level_hint_type.id()) |
|||
{ |
|||
case TokenID::keyword_NO_ICP: |
|||
hint_type= ICP_HINT_ENUM; |
|||
hint_state= false; |
|||
break; |
|||
case TokenID::keyword_MRR: |
|||
hint_type= MRR_HINT_ENUM; |
|||
hint_state= true; |
|||
break; |
|||
case TokenID::keyword_NO_MRR: |
|||
hint_type= MRR_HINT_ENUM; |
|||
hint_state= false; |
|||
break; |
|||
case TokenID::keyword_NO_RANGE_OPTIMIZATION: |
|||
hint_type= NO_RANGE_HINT_ENUM; |
|||
hint_state= true; |
|||
break; |
|||
default: |
|||
DBUG_ASSERT(0); |
|||
return true; |
|||
} |
|||
|
|||
const Hint_param_table_ext &table_ext= *this; |
|||
const Query_block_name &qb_name= table_ext; |
|||
const Table_name &table_name= table_ext; |
|||
|
|||
Opt_hints_qb *qb= find_qb_hints(pc, &qb_name, hint_type, hint_state); |
|||
if (qb == NULL) |
|||
return false; |
|||
|
|||
Opt_hints_table *tab= get_table_hints(pc, &table_name, qb); |
|||
if (!tab) |
|||
return true; // OLEGS: why no warning?
|
|||
|
|||
if (is_empty()) // Table level hint
|
|||
{ |
|||
if (tab->set_switch(hint_state, hint_type, false)) |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, hint_type, hint_state, |
|||
&qb_name, &table_name, NULL/*, this*/); |
|||
return false; |
|||
} |
|||
|
|||
for (const Hint_param_index &index_name : *this) |
|||
{ |
|||
Opt_hints_key *idx= (Opt_hints_key *)tab->find_by_name(&index_name); |
|||
if (!idx) |
|||
{ |
|||
idx= new Opt_hints_key(&index_name, tab, pc->thd->mem_root); |
|||
tab->register_child(idx); |
|||
} |
|||
|
|||
if (idx->set_switch(hint_state, hint_type, true)) |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, hint_type, hint_state, |
|||
&qb_name, &table_name, &index_name/*, this*/); |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
|
|||
bool Optimizer_hint_parser::Qb_name_hint::resolve(Parse_context *pc) const |
|||
{ |
|||
Opt_hints_qb *qb= pc->select->opt_hints_qb; |
|||
|
|||
DBUG_ASSERT(qb); |
|||
|
|||
const Query_block_name &qb_name= *this; |
|||
|
|||
if (qb->get_name() || // QB name is already set
|
|||
qb->get_parent()->find_by_name(&qb_name)) // Name is already used
|
|||
{ |
|||
print_warn(pc->thd, ER_WARN_CONFLICTING_HINT, QB_NAME_HINT_ENUM, false, |
|||
NULL, NULL, NULL/*, this*/); |
|||
return false; |
|||
} |
|||
|
|||
qb->set_name(&qb_name); |
|||
return false; |
|||
} |
|||
|
|||
|
|||
bool Optimizer_hint_parser::Hint_list::resolve(Parse_context *pc) |
|||
{ |
|||
if (!get_qb_hints(pc)) |
|||
return true; |
|||
|
|||
List_iterator_fast<Optimizer_hint_parser::Hint> li(*this); |
|||
while(Optimizer_hint_parser::Hint *hint= li++) |
|||
{ |
|||
if (const Table_level_hint &table_hint= |
|||
static_cast<const Table_level_hint &>(*hint)) |
|||
{ |
|||
if (table_hint.resolve(pc)) |
|||
return true; |
|||
} |
|||
else if (const Index_level_hint &index_hint= |
|||
static_cast<const Index_level_hint &>(*hint)) |
|||
{ |
|||
if (index_hint.resolve(pc)) |
|||
return true; |
|||
} |
|||
else if (const Qb_name_hint &qb_hint= |
|||
static_cast<const Qb_name_hint &>(*hint)) |
|||
{ |
|||
if (qb_hint.resolve(pc)) |
|||
return true; // OLEGS: check this result
|
|||
} |
|||
} |
|||
return false; |
|||
} |
|||
@ -0,0 +1,507 @@ |
|||
/* 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 */ |
|||
|
|||
/* |
|||
Parse tree node classes for optimizer hint syntax |
|||
*/ |
|||
|
|||
|
|||
#ifndef OPT_HINTS_INCLUDED |
|||
#define OPT_HINTS_INCLUDED |
|||
|
|||
#include "my_config.h" |
|||
#include "sql_alloc.h" |
|||
#include "sql_list.h" |
|||
#include "mem_root_array.h" |
|||
#include "sql_string.h" |
|||
#include "sql_bitmap.h" |
|||
#include "sql_show.h" |
|||
#include "mysqld_error.h" |
|||
|
|||
|
|||
struct LEX; |
|||
struct TABLE; |
|||
|
|||
/** |
|||
Hint types, MAX_HINT_ENUM should be always last. |
|||
This enum should be synchronized with opt_hint_info |
|||
array(see opt_hints.cc). |
|||
*/ |
|||
enum opt_hints_enum |
|||
{ |
|||
BKA_HINT_ENUM= 0, |
|||
BNL_HINT_ENUM, |
|||
ICP_HINT_ENUM, |
|||
MRR_HINT_ENUM, |
|||
NO_RANGE_HINT_ENUM, |
|||
QB_NAME_HINT_ENUM, |
|||
MAX_HINT_ENUM |
|||
}; |
|||
|
|||
|
|||
struct st_opt_hint_info |
|||
{ |
|||
const char* hint_name; // Hint name. |
|||
bool check_upper_lvl; // true if upper level hint check is needed (for hints |
|||
// which can be specified on more than one level). |
|||
bool switch_hint; // true if hint is not complex. |
|||
}; |
|||
|
|||
|
|||
/** |
|||
Opt_hints_map contains information |
|||
about hint state(specified or not, hint value). |
|||
*/ |
|||
|
|||
class Opt_hints_map : public Sql_alloc |
|||
{ |
|||
Bitmap<64> hints; // hint state |
|||
Bitmap<64> hints_specified; // true if hint is specified |
|||
|
|||
public: |
|||
Opt_hints_map() |
|||
{ |
|||
hints.clear_all(); |
|||
hints_specified.clear_all(); |
|||
} |
|||
|
|||
/** |
|||
Check if hint is specified. |
|||
|
|||
@param type_arg hint type |
|||
|
|||
@return true if hint is specified, |
|||
false otherwise |
|||
*/ |
|||
my_bool is_specified(opt_hints_enum type_arg) const |
|||
{ |
|||
return hints_specified.is_set(type_arg); |
|||
} |
|||
/** |
|||
Set switch value and set hint into specified state. |
|||
|
|||
@param type_arg hint type |
|||
@param switch_state_arg switch value |
|||
*/ |
|||
void set_switch(opt_hints_enum type_arg, |
|||
bool switch_state_arg) |
|||
{ |
|||
if (switch_state_arg) |
|||
hints.set_bit(type_arg); |
|||
else |
|||
hints.clear_bit(type_arg); |
|||
hints_specified.set_bit(type_arg); |
|||
} |
|||
/** |
|||
Get switch value. |
|||
|
|||
@param type_arg hint type |
|||
|
|||
@return switch value. |
|||
*/ |
|||
bool switch_on(opt_hints_enum type_arg) const |
|||
{ |
|||
return hints.is_set(type_arg); |
|||
} |
|||
}; |
|||
|
|||
|
|||
class PT_hint; |
|||
class PT_hint_max_execution_time; |
|||
class Opt_hints_key; |
|||
|
|||
|
|||
/** |
|||
Opt_hints class is used as ancestor for Opt_hints_global, |
|||
Opt_hints_qb, Opt_hints_table, Opt_hints_key classes. |
|||
|
|||
Opt_hints_global class is hierarchical structure. |
|||
It contains information about global hints and also |
|||
conains array of QUERY BLOCK level objects (Opt_hints_qb class). |
|||
Each QUERY BLOCK level object contains array of TABLE level hints |
|||
(class Opt_hints_table). Each TABLE level hint contains array of |
|||
KEY lelev hints (Opt_hints_key class). |
|||
Hint information(specified, on|off state) is stored in hints_map object. |
|||
*/ |
|||
|
|||
class Opt_hints : public Sql_alloc |
|||
{ |
|||
/* |
|||
Name of object referred by the hint. |
|||
This name is empty for global level, |
|||
query block name for query block level, |
|||
table name for table level and key name |
|||
for key level. |
|||
*/ |
|||
const LEX_CSTRING *name; |
|||
/* |
|||
Parent object. There is no parent for global level, |
|||
for query block level parent is Opt_hints_global object, |
|||
for table level parent is Opt_hints_qb object, |
|||
for key level parent is Opt_hints_key object. |
|||
*/ |
|||
Opt_hints *parent; |
|||
|
|||
Opt_hints_map hints_map; // Hint map |
|||
|
|||
/* Array of child objects. i.e. array of the lower level objects */ |
|||
Mem_root_array<Opt_hints*, true> child_array; |
|||
/* true if hint is connected to the real object */ |
|||
bool resolved; |
|||
/* Number of resolved children */ |
|||
uint resolved_children; |
|||
|
|||
public: |
|||
|
|||
Opt_hints(const LEX_CSTRING *name_arg, |
|||
Opt_hints *parent_arg, |
|||
MEM_ROOT *mem_root_arg) |
|||
: name(name_arg), parent(parent_arg), child_array(mem_root_arg), |
|||
resolved(false), resolved_children(0) |
|||
{ } |
|||
|
|||
bool is_specified(opt_hints_enum type_arg) const |
|||
{ |
|||
return hints_map.is_specified(type_arg); |
|||
} |
|||
|
|||
/** |
|||
Function sets switch hint state. |
|||
|
|||
@param switch_state_arg switch hint state |
|||
@param type_arg hint type |
|||
@param check_parent true if hint can be on parent level |
|||
|
|||
@return true if hint is already specified, |
|||
false otherwise |
|||
*/ |
|||
bool set_switch(bool switch_state_arg, |
|||
opt_hints_enum type_arg, |
|||
bool check_parent) |
|||
{ |
|||
if (is_specified(type_arg) || |
|||
(check_parent && parent->is_specified(type_arg))) |
|||
return true; |
|||
|
|||
hints_map.set_switch(type_arg, switch_state_arg); |
|||
return false; |
|||
} |
|||
|
|||
/** |
|||
Function returns switch hint state. |
|||
|
|||
@param type_arg hint type |
|||
|
|||
@return hint value if hint is specified, |
|||
false otherwise |
|||
*/ |
|||
bool get_switch(opt_hints_enum type_arg) const; |
|||
|
|||
virtual const LEX_CSTRING *get_name() const { return name; } |
|||
void set_name(const LEX_CSTRING *name_arg) { name= name_arg; } |
|||
Opt_hints *get_parent() const { return parent; } |
|||
void set_resolved() { resolved= true; } |
|||
bool is_resolved() const { return resolved; } |
|||
void incr_resolved_children() { resolved_children++; } |
|||
Mem_root_array<Opt_hints*, true> *child_array_ptr() { return &child_array; } |
|||
|
|||
bool is_all_resolved() const |
|||
{ |
|||
return child_array.size() == resolved_children; |
|||
} |
|||
|
|||
void register_child(Opt_hints* hint_arg) |
|||
{ |
|||
child_array.push_back(hint_arg); |
|||
} |
|||
|
|||
// OLEGS: remove it if not used |
|||
/** |
|||
Returns pointer to complex hint for a given type |
|||
|
|||
@param type hint type |
|||
|
|||
@return pointer to complex hint for a given type. |
|||
*/ |
|||
// virtual PT_hint *get_complex_hints(uint type) |
|||
// { |
|||
// DBUG_ASSERT(0); |
|||
// return NULL; /* error C4716: must return a value*/ |
|||
// }; |
|||
|
|||
/** |
|||
Find hint among lower-level hint objects. |
|||
|
|||
@param name_arg hint name |
|||
|
|||
@return hint if found, |
|||
NULL otherwise |
|||
*/ |
|||
Opt_hints *find_by_name(const LEX_CSTRING *name_arg) const; |
|||
/** |
|||
Print all hints except of QB_NAME hint. |
|||
|
|||
@param thd Pointer to THD object |
|||
@param str Pointer to String object |
|||
*/ |
|||
void print(THD *thd, String *str); |
|||
/** |
|||
Check if there are any unresolved hint objects and |
|||
print warnings for them. |
|||
|
|||
@param thd Pointer to THD object |
|||
*/ |
|||
void check_unresolved(THD *thd); |
|||
virtual void append_name(THD *thd, String *str)= 0; |
|||
|
|||
virtual ~Opt_hints() {} |
|||
|
|||
private: |
|||
/** |
|||
Append hint type. |
|||
|
|||
@param str Pointer to String object |
|||
@param type Hint type |
|||
*/ |
|||
void append_hint_type(String *str, opt_hints_enum type); |
|||
/** |
|||
Print warning for unresolved hint name. |
|||
|
|||
@param thd Pointer to THD object |
|||
*/ |
|||
void print_warn_unresolved(THD *thd); |
|||
|
|||
protected: |
|||
/** |
|||
Override this function in descendants so that print_warn_unresolved() |
|||
prints the proper warning text for table/index level unresolved hints |
|||
*/ |
|||
virtual uint get_warn_unresolved_code() const { return 0; } |
|||
}; |
|||
|
|||
|
|||
/** |
|||
Global level hints. |
|||
*/ |
|||
|
|||
class Opt_hints_global : public Opt_hints |
|||
{ |
|||
|
|||
public: |
|||
PT_hint_max_execution_time *max_exec_time; |
|||
|
|||
Opt_hints_global(MEM_ROOT *mem_root_arg) |
|||
: Opt_hints(NULL, NULL, mem_root_arg) |
|||
{ |
|||
max_exec_time= NULL; |
|||
} |
|||
|
|||
virtual void append_name(THD *thd, String *str) {} |
|||
virtual PT_hint *get_complex_hints(uint type); |
|||
}; |
|||
|
|||
|
|||
class Opt_hints_table; |
|||
|
|||
/** |
|||
Query block level hints. |
|||
*/ |
|||
|
|||
class Opt_hints_qb : public Opt_hints |
|||
{ |
|||
uint select_number; // SELECT_LEX number |
|||
LEX_CSTRING sys_name; // System QB name |
|||
char buff[32]; // Buffer to hold sys name |
|||
|
|||
public: |
|||
|
|||
Opt_hints_qb(Opt_hints *opt_hints_arg, |
|||
MEM_ROOT *mem_root_arg, |
|||
uint select_number_arg); |
|||
|
|||
const LEX_CSTRING *get_print_name() |
|||
{ |
|||
const LEX_CSTRING *str= Opt_hints::get_name(); |
|||
return str ? str : &sys_name; |
|||
} |
|||
|
|||
/** |
|||
Append query block hint. |
|||
|
|||
@param thd pointer to THD object |
|||
@param str pointer to String object |
|||
*/ |
|||
void append_qb_hint(THD *thd, String *str) |
|||
{ |
|||
if (get_name()) |
|||
{ |
|||
str->append(STRING_WITH_LEN("QB_NAME(")); |
|||
append_identifier(thd, str, get_name()->str, get_name()->length); |
|||
str->append(STRING_WITH_LEN(") ")); |
|||
} |
|||
} |
|||
/** |
|||
Append query block name. |
|||
|
|||
@param thd pointer to THD object |
|||
@param str pointer to String object |
|||
*/ |
|||
virtual void append_name(THD *thd, String *str) |
|||
{ |
|||
str->append(STRING_WITH_LEN("@")); |
|||
append_identifier(thd, str, get_print_name()->str, get_print_name()->length); |
|||
} |
|||
|
|||
/** |
|||
Function finds Opt_hints_table object corresponding to |
|||
table alias in the query block and attaches corresponding |
|||
key hint objects to appropriate KEY structures. |
|||
|
|||
@param table Pointer to TABLE object |
|||
@param alias Table alias |
|||
|
|||
@return pointer Opt_hints_table object if this object is found, |
|||
NULL otherwise. |
|||
*/ |
|||
Opt_hints_table *adjust_table_hints(TABLE *table, const LEX_CSTRING *alias); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
Table level hints. |
|||
*/ |
|||
|
|||
class Opt_hints_table : public Opt_hints |
|||
{ |
|||
public: |
|||
Mem_root_array<Opt_hints_key*, true> keyinfo_array; |
|||
|
|||
Opt_hints_table(const LEX_CSTRING *table_name_arg, |
|||
Opt_hints_qb *qb_hints_arg, |
|||
MEM_ROOT *mem_root_arg) |
|||
: Opt_hints(table_name_arg, qb_hints_arg, mem_root_arg), |
|||
keyinfo_array(mem_root_arg) |
|||
{ } |
|||
|
|||
/** |
|||
Append table name. |
|||
|
|||
@param thd pointer to THD object |
|||
@param str pointer to String object |
|||
*/ |
|||
virtual void append_name(THD *thd, String *str) |
|||
{ |
|||
append_identifier(thd, str, get_name()->str, get_name()->length); |
|||
get_parent()->append_name(thd, str); |
|||
} |
|||
/** |
|||
Function sets correlation between key hint objects and |
|||
appropriate KEY structures. |
|||
|
|||
@param table Pointer to TABLE object |
|||
*/ |
|||
void adjust_key_hints(TABLE *table); |
|||
|
|||
virtual uint get_warn_unresolved_code() const override |
|||
{ |
|||
return ER_UNRESOLVED_TABLE_HINT_NAME; |
|||
} |
|||
}; |
|||
|
|||
|
|||
/** |
|||
Key level hints. |
|||
*/ |
|||
|
|||
class Opt_hints_key : public Opt_hints |
|||
{ |
|||
public: |
|||
|
|||
Opt_hints_key(const LEX_CSTRING *key_name_arg, |
|||
Opt_hints_table *table_hints_arg, |
|||
MEM_ROOT *mem_root_arg) |
|||
: Opt_hints(key_name_arg, table_hints_arg, mem_root_arg) |
|||
{ } |
|||
|
|||
/** |
|||
Append key name. |
|||
|
|||
@param thd pointer to THD object |
|||
@param str pointer to String object |
|||
*/ |
|||
virtual void append_name(THD *thd, String *str) |
|||
{ |
|||
get_parent()->append_name(thd, str); |
|||
str->append(' '); |
|||
append_identifier(thd, str, get_name()->str, get_name()->length); |
|||
} |
|||
|
|||
virtual uint get_warn_unresolved_code() const override |
|||
{ |
|||
return ER_UNRESOLVED_INDEX_HINT_NAME; |
|||
} |
|||
}; |
|||
|
|||
|
|||
/** |
|||
Returns key hint value if hint is specified, returns |
|||
optimizer switch value if hint is not specified. |
|||
|
|||
@param thd Pointer to THD object |
|||
@param tab Pointer to TABLE object |
|||
@param keyno Key number |
|||
@param type_arg Hint type |
|||
@param optimizer_switch Optimizer switch flag |
|||
|
|||
@return key hint value if hint is specified, |
|||
otherwise optimizer switch value. |
|||
*/ |
|||
bool hint_key_state(const THD *thd, const TABLE *table, |
|||
uint keyno, opt_hints_enum type_arg, |
|||
uint optimizer_switch); |
|||
|
|||
/** |
|||
Returns table hint value if hint is specified, returns |
|||
optimizer switch value if hint is not specified. |
|||
|
|||
@param thd Pointer to THD object |
|||
@param tab Pointer to TABLE object |
|||
@param type_arg Hint type |
|||
@param optimizer_switch Optimizer switch flag |
|||
|
|||
@return table hint value if hint is specified, |
|||
otherwise optimizer switch value. |
|||
*/ |
|||
bool hint_table_state(const THD *thd, const TABLE *table, |
|||
opt_hints_enum type_arg, |
|||
uint optimizer_switch); |
|||
|
|||
/** |
|||
Returns table hint value if hint is specified, returns |
|||
fallback value if hint is not specified. |
|||
|
|||
@param thd Pointer to THD object |
|||
@param tab Pointer to TABLE object |
|||
@param type_arg Hint type |
|||
@param fallback_value Value to be returned if the hint is not set |
|||
|
|||
@return table hint value if hint is specified, |
|||
otherwise fallback value. |
|||
*/ |
|||
bool hint_table_state_or_fallback(const THD *thd, const TABLE *table, |
|||
opt_hints_enum type_arg, |
|||
bool fallback_value); |
|||
|
|||
#endif /* OPT_HINTS_INCLUDED */ |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue