31#include <drizzled/session.h>
32#include <drizzled/sql_select.h>
33#include <drizzled/error.h>
34#include <drizzled/item/cache.h>
35#include <drizzled/item/subselect.h>
36#include <drizzled/item/cmpfunc.h>
37#include <drizzled/item/ref_null_helper.h>
38#include <drizzled/cached_item.h>
39#include <drizzled/check_stack_overrun.h>
40#include <drizzled/item/ref_null_helper.h>
41#include <drizzled/item/direct_ref.h>
43#include <drizzled/plugin/storage_engine.h>
44#include <drizzled/select_singlerow_subselect.h>
45#include <drizzled/select_max_min_finder_subselect.h>
46#include <drizzled/select_exists_subselect.h>
47#include <drizzled/select_union.h>
48#include <drizzled/sql_lex.h>
49#include <drizzled/system_variables.h>
50#include <drizzled/key_part_info.h>
61Item_subselect::Item_subselect() :
63 value_assigned(false),
71 parsing_place(NO_MATTER),
72 have_to_be_excluded(false),
73 const_item_cache(true),
74 engine_changed(false),
88void Item_subselect::init(Select_Lex *select_lex,
89 select_result_interceptor *result)
96 unit= select_lex->master_unit();
104 engine= unit->item->engine;
105 parsing_place= unit->item->parsing_place;
106 unit->item->engine= 0;
108 engine->change_result(
this, result);
112 Select_Lex *outer_select= unit->outer_select();
117 parsing_place= (outer_select->in_sum_expr ?
119 outer_select->parsing_place);
120 if (unit->is_union())
121 engine=
new subselect_union_engine(unit, result,
this);
123 engine=
new subselect_single_select_engine(select_lex, result,
this);
126 Select_Lex *upper= unit->outer_select();
127 if (upper->parsing_place == IN_HAVING)
128 upper->subquery_in_having= 1;
136 return unit->first_select();
139void Item_subselect::cleanup()
141 Item_result_field::cleanup();
155void Item_singlerow_subselect::cleanup()
158 Item_subselect::cleanup();
162void Item_in_subselect::cleanup()
166 left_expr_cache->delete_elements();
167 delete left_expr_cache;
168 left_expr_cache= NULL;
170 first_execution=
true;
171 Item_subselect::cleanup();
174Item_subselect::~Item_subselect()
179Item_subselect::trans_res
180Item_subselect::select_transformer(Join *)
186bool Item_subselect::fix_fields(Session *session_param, Item **ref)
188 char const *save_where= session_param->where();
192 engine->set_session((session= session_param));
197 res= engine->prepare();
215 if (unit->outer_select()->where == (*ref))
217 unit->outer_select()->where= substitution;
219 else if (unit->outer_select()->having == (*ref))
221 unit->outer_select()->having= substitution;
224 (*ref)= substitution;
225 substitution->name= name;
226 if (have_to_be_excluded)
231 session->setWhere(
"checking transformed subquery");
234 ret= (*ref)->fix_fields(session, ref);
236 session->setWhere(save_where);
241 if (engine->cols() > max_columns)
243 my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
246 fix_length_and_dec();
251 if (engine->uncacheable())
253 const_item_cache=
false;
254 if (engine->uncacheable(UNCACHEABLE_RAND))
256 used_tables_cache|= RAND_TABLE_BIT;
262 session->setWhere(save_where);
267bool Item_subselect::walk(Item_processor processor,
bool walk_subquery,
268 unsigned char *argument)
273 for (Select_Lex *lex= unit->first_select(); lex; lex= lex->next_select())
275 List<Item>::iterator li(lex->item_list.begin());
279 if (lex->where && (lex->where)->walk(processor, walk_subquery, argument))
281 if (lex->having && (lex->having)->walk(processor, walk_subquery,
287 if (item->walk(processor, walk_subquery, argument))
290 for (order= (Order*) lex->order_list.first ; order; order= order->next)
292 if ((*order->item)->walk(processor, walk_subquery, argument))
295 for (order= (Order*) lex->group_list.first ; order; order= order->next)
297 if ((*order->item)->walk(processor, walk_subquery, argument))
302 return (this->*processor)(argument);
306bool Item_subselect::exec()
310 if (session->is_error())
329bool Item_in_subselect::exec()
331 assert(exec_method != MATERIALIZATION ||
332 (exec_method == MATERIALIZATION &&
333 engine->engine_type() == subselect_engine::HASH_SJ_ENGINE));
346 if (!left_expr_cache && exec_method == MATERIALIZATION)
347 init_left_expr_cache();
350 if (left_expr_cache && test_if_item_cache_changed(*left_expr_cache) < 0)
353 if (!first_execution)
355 first_execution=
false;
363 return(Item_subselect::exec());
367Item::Type Item_subselect::type()
const
369 return SUBSELECT_ITEM;
373void Item_subselect::fix_length_and_dec()
375 engine->fix_length_and_dec(0);
381 return (table_map) (engine->uncacheable() ? used_tables_cache : 0L);
387 return const_item_cache;
390Item *Item_subselect::get_tmp_table_item(
Session *session_arg)
392 if (!with_sum_func && !const_item())
394 return copy_or_same(session_arg);
397void Item_subselect::update_used_tables()
399 if (! engine->uncacheable())
402 if (!(used_tables_cache & ~engine->upper_select_const_tables()))
403 const_item_cache=
true;
416Item_singlerow_subselect::Item_singlerow_subselect(Select_Lex *select_lex)
421 max_columns= UINT_MAX;
443Item_maxmin_subselect::Item_maxmin_subselect(
Session *session_param,
445 Select_Lex *select_lex,
459 used_tables_cache= parent->get_used_tables_cache();
460 const_item_cache= parent->get_const_item_cache();
466 session= session_param;
469void Item_maxmin_subselect::cleanup()
471 Item_singlerow_subselect::cleanup();
487 str->append(max?
"<max>":
"<min>", 5);
492void Item_singlerow_subselect::reset()
510Item_subselect::trans_res
516 Select_Lex *select_lex= join->select_lex;
518 if (!select_lex->master_unit()->is_union() &&
519 !select_lex->table_list.elements &&
520 select_lex->item_list.size() == 1 &&
521 !select_lex->item_list.front().with_sum_func &&
529 !(select_lex->item_list.front().type() == FIELD_ITEM ||
530 select_lex->item_list.front().type() == REF_ITEM) &&
531 !join->conds && !join->having
535 have_to_be_excluded= 1;
536 if (session->lex().describe)
538 char warn_buff[DRIZZLE_ERRMSG_SIZE];
539 snprintf(warn_buff,
sizeof(warn_buff), ER(ER_SELECT_REDUCED), select_lex->select_number);
540 push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
541 ER_SELECT_REDUCED, warn_buff);
543 substitution= &select_lex->item_list.front();
548 substitution->walk(&Item::remove_dependence_processor, 0,
549 (
unsigned char *) select_lex->outer_select());
556void Item_singlerow_subselect::store(uint32_t i,
Item *item)
561enum Item_result Item_singlerow_subselect::result_type()
const
563 return engine->type();
570enum_field_types Item_singlerow_subselect::field_type()
const
572 return engine->field_type();
575void Item_singlerow_subselect::fix_length_and_dec()
577 if ((max_columns= engine->cols()) == 1)
579 engine->fix_length_and_dec(row= &value);
583 if (!(row= (Item_cache**) memory::sql_alloc(
sizeof(Item_cache*)*max_columns)))
585 engine->fix_length_and_dec(row);
588 unsigned_flag= value->unsigned_flag;
594 if (engine->no_tables())
598uint32_t Item_singlerow_subselect::cols()
600 return engine->cols();
603bool Item_singlerow_subselect::check_cols(uint32_t c)
605 if (c != engine->cols())
607 my_error(ER_OPERAND_COLUMNS, MYF(0), c);
613bool Item_singlerow_subselect::null_inside()
615 for (uint32_t i= 0; i < max_columns ; i++)
623void Item_singlerow_subselect::bring_value()
631 if (!exec() && !value->null_value)
634 return value->val_real();
646 if (!exec() && !value->null_value)
649 return value->val_int();
660 if (!exec() && !value->null_value)
663 return value->val_str(str);
675 if (!exec() && !value->null_value)
678 return value->val_decimal(decimal_value);
690 if (!exec() && !value->null_value)
693 return value->val_bool();
703Item_exists_subselect::Item_exists_subselect(Select_Lex *select_lex):
707 max_columns= UINT_MAX;
717 str->append(STRING_WITH_LEN(
"exists"));
722bool Item_in_subselect::test_limit(Select_Lex_Unit *unit_arg)
724 if (unit_arg->fake_select_lex &&
725 unit_arg->fake_select_lex->test_limit())
728 Select_Lex *sl= unit_arg->first_select();
729 for (; sl; sl= sl->next_select())
731 if (sl->test_limit())
737Item_in_subselect::Item_in_subselect(
Item * left_exp,
738 Select_Lex *select_lex) :
741 left_expr_cache(NULL),
742 first_execution(true),
744 pushed_cond_guards(NULL),
745 sj_convert_priority(0),
746 expr_join_nest(NULL),
747 exec_method(NOT_TRANSFORMED),
750 init(select_lex,
new select_exists_subselect(
this));
751 max_columns= UINT_MAX;
756 test_limit(select_lex->master_unit());
760Item_allany_subselect::Item_allany_subselect(
Item * left_exp,
761 chooser_compare_func_creator fc,
762 Select_Lex *select_lex,
767 func= func_creator(all_arg);
768 init(select_lex,
new select_exists_subselect(
this));
773 test_limit(select_lex->master_unit());
778void Item_exists_subselect::fix_length_and_dec()
782 max_columns= engine->cols();
784 unit->global_parameters->select_limit=
new Item_int((int32_t) 1);
795 return (
double) value;
817 str->set((uint64_t)value,&my_charset_bin);
830 int2_class_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
831 return decimal_value;
862 if (was_null && !value)
864 return (
double) value;
882 if (was_null && !value)
903 if (was_null && !value)
908 str->set((uint64_t)value, &my_charset_bin);
928 if (was_null && !value)
948 if (was_null && !value)
950 int2_class_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
951 return decimal_value;
989Item_subselect::trans_res
990Item_in_subselect::single_value_transformer(
Join *join,
993 Select_Lex *select_lex= join->select_lex;
999 if (select_lex->item_list.size() > 1)
1001 my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
1016 if ((abort_on_null || (upper_item && upper_item->top_level())) &&
1017 select_lex->master_unit()->uncacheable.none() && !func->eqne_op())
1026 if (!select_lex->group_list.elements &&
1027 !select_lex->having &&
1028 !select_lex->with_sum_func &&
1029 !(select_lex->next_select()) &&
1030 select_lex->table_list.elements)
1032 Item_sum_hybrid *item;
1033 nesting_map save_allow_sum_func;
1040 item=
new Item_sum_max(*select_lex->ref_pointer_array);
1048 item=
new Item_sum_min(*select_lex->ref_pointer_array);
1051 upper_item->set_sum_test(item);
1052 *select_lex->ref_pointer_array= item;
1054 List<Item>::iterator it(select_lex->item_list.begin());
1059 save_allow_sum_func= session->lex().allow_sum_func;
1060 session->lex().allow_sum_func|= 1 << session->lex().current_select->nest_level;
1066 if (item->fix_fields(session, 0))
1068 session->lex().allow_sum_func= save_allow_sum_func;
1073 subs=
new Item_singlerow_subselect(select_lex);
1077 Item_maxmin_subselect *item;
1078 subs= item=
new Item_maxmin_subselect(session,
this, select_lex, func->l_op());
1080 upper_item->set_sub_test(item);
1083 substitution= func->create(left_expr, subs);
1090 Select_Lex_Unit *master_unit= select_lex->master_unit();
1091 substitution= optimizer;
1093 Select_Lex *current= session->lex().current_select, *up;
1095 session->lex().current_select= up= current->return_after_parsing();
1097 if (!optimizer || optimizer->fix_left(session, 0))
1099 session->lex().current_select= current;
1102 session->lex().current_select= current;
1108 expr=
new Item_direct_ref(&select_lex->context, (
Item**)optimizer->get_cache(),
"<no matter>",
in_left_expr_name);
1110 master_unit->uncacheable.set(UNCACHEABLE_DEPENDENT);
1113 if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
1115 pushed_cond_guards=
new (join->session->mem)
bool;
1116 pushed_cond_guards[0]=
true;
1123 if (exec_method == MATERIALIZATION)
1167Item_subselect::trans_res
1170 Select_Lex *select_lex= join->select_lex;
1172 select_lex->uncacheable.set(UNCACHEABLE_DEPENDENT);
1173 if (join->having || select_lex->with_sum_func ||
1174 select_lex->group_list.elements)
1177 Item *item= func->create(expr,
new Item_ref_null_helper(&select_lex->context,
this, select_lex->ref_pointer_array,
"<ref>", this->full_name()));
1178 if (!abort_on_null && left_expr->maybe_null)
1192 select_lex->having= join->having= and_items(join->having, item);
1193 if (join->having == item)
1194 item->name= (
char*)in_having_cond;
1195 select_lex->having->top_level_item();
1196 select_lex->having_fix_field= 1;
1201 tmp= join->having->fix_fields(session, 0);
1202 select_lex->having_fix_field= 0;
1208 Item *item= &select_lex->item_list.front();
1210 if (select_lex->table_list.elements)
1213 Item *having= item, *orig_item= item;
1214 select_lex->item_list.clear();
1215 select_lex->item_list.push_back(
new Item_int(
"Not_used", 1, MY_INT64_NUM_DECIMAL_DIGITS));
1216 select_lex->ref_pointer_array[0]= &select_lex->item_list.front();
1218 item= func->create(expr, item);
1219 if (!abort_on_null && orig_item->maybe_null)
1221 having=
new Item_is_not_null_test(
this, having);
1222 if (left_expr->maybe_null)
1229 having->
name= (
char*)in_having_cond;
1230 select_lex->having= join->having= having;
1231 select_lex->having_fix_field= 1;
1237 tmp= join->having->fix_fields(session, 0);
1238 select_lex->having_fix_field= 0;
1247 if (!abort_on_null && left_expr->maybe_null)
1261 select_lex->where= join->conds= and_items(join->conds, item);
1262 select_lex->where->top_level_item();
1267 if (join->conds->fix_fields(session, 0))
1273 if (select_lex->master_unit()->is_union())
1280 Item *new_having= func->create(expr,
new Item_ref_null_helper(&select_lex->context,
this, select_lex->ref_pointer_array,
"<no matter>",
"<result>"));
1281 if (!abort_on_null && left_expr->maybe_null)
1283 new_having->
name= in_having_cond;
1284 select_lex->having= join->having= new_having;
1285 select_lex->having_fix_field= 1;
1291 tmp= join->having->fix_fields(session, 0);
1292 select_lex->having_fix_field= 0;
1299 item= func->create(left_expr, item);
1302 have_to_be_excluded= 1;
1303 if (session->lex().describe)
1305 char warn_buff[DRIZZLE_ERRMSG_SIZE];
1306 snprintf(warn_buff,
sizeof(warn_buff), ER(ER_SELECT_REDUCED), select_lex->select_number);
1307 push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1308 ER_SELECT_REDUCED, warn_buff);
1319Item_subselect::trans_res
1320Item_in_subselect::row_value_transformer(
Join *join)
1322 Select_Lex *select_lex= join->select_lex;
1323 uint32_t cols_num= left_expr->cols();
1325 if (select_lex->item_list.size() != left_expr->cols())
1327 my_error(ER_OPERAND_COLUMNS, MYF(0), left_expr->cols());
1338 Select_Lex_Unit *master_unit= select_lex->master_unit();
1339 substitution= optimizer;
1341 Select_Lex *current= session->lex().current_select, *up;
1342 session->lex().current_select= up= current->return_after_parsing();
1344 if (!optimizer || optimizer->fix_left(session, 0))
1346 session->lex().current_select= current;
1351 optimizer->keep_top_level_cache();
1353 session->lex().current_select= current;
1354 master_unit->uncacheable.set(UNCACHEABLE_DEPENDENT);
1356 if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
1358 pushed_cond_guards=
new (join->session->mem)
bool[left_expr->cols()];
1359 for (uint32_t i= 0; i < cols_num; i++)
1360 pushed_cond_guards[i]=
true;
1368 if (exec_method == MATERIALIZATION)
1394Item_subselect::trans_res
1397 Select_Lex *select_lex= join->select_lex;
1398 Item *having_item= 0;
1399 uint32_t cols_num= left_expr->cols();
1400 bool is_having_used= (join->having || select_lex->with_sum_func ||
1401 select_lex->group_list.first ||
1402 !select_lex->table_list.elements);
1404 select_lex->uncacheable.set(UNCACHEABLE_DEPENDENT);
1420 Item *item_having_part2= 0;
1421 for (uint32_t i= 0; i < cols_num; i++)
1423 assert((left_expr->fixed && select_lex->ref_pointer_array[i]->fixed) ||
1424 (select_lex->ref_pointer_array[i]->type() == REF_ITEM &&
1425 ((
Item_ref*)(select_lex->ref_pointer_array[i]))->ref_type() ==
1426 Item_ref::OUTER_REF));
1427 if (select_lex->ref_pointer_array[i]->
1428 check_cols(left_expr->element_index(i)->cols()))
1433 (*optimizer->get_cache())->
1439 select_lex->ref_pointer_array + i,
1446 select_lex->ref_pointer_array+i,
1451 if (!abort_on_null && left_expr->element_index(i)->maybe_null)
1453 having_item= and_items(having_item, col_item);
1455 Item *item_nnull_test=
1456 new Item_is_not_null_test(
this,
1459 ref_pointer_array + i,
1462 if (!abort_on_null && left_expr->element_index(i)->maybe_null)
1466 item_having_part2= and_items(item_having_part2, item_nnull_test);
1469 having_item= and_items(having_item, item_having_part2);
1491 Item *where_item= 0;
1492 for (uint32_t i= 0; i < cols_num; i++)
1494 Item *item, *item_isnull;
1495 assert((left_expr->fixed && select_lex->ref_pointer_array[i]->fixed) ||
1496 (select_lex->ref_pointer_array[i]->type() == REF_ITEM &&
1497 ((
Item_ref*)(select_lex->ref_pointer_array[i]))->ref_type() ==
1498 Item_ref::OUTER_REF));
1499 if (select_lex->ref_pointer_array[i]->
1500 check_cols(left_expr->element_index(i)->cols()))
1505 (*optimizer->get_cache())->
1512 ref_pointer_array+i,
1518 Item *having_col_item=
1519 new Item_is_not_null_test(
this,
1522 select_lex->ref_pointer_array + i,
1531 ref_pointer_array+i,
1540 if (left_expr->element_index(i)->maybe_null)
1545 having_item= and_items(having_item, having_col_item);
1547 where_item= and_items(where_item, item);
1554 select_lex->where= join->conds= and_items(join->conds, where_item);
1555 select_lex->where->top_level_item();
1556 if (join->conds->fix_fields(session, 0))
1562 select_lex->having= join->having= and_items(join->having, having_item);
1563 if (having_item == select_lex->having)
1564 having_item->
name= (
char*)in_having_cond;
1565 select_lex->having->top_level_item();
1571 select_lex->having_fix_field= 1;
1572 res= join->having->fix_fields(session, 0);
1573 select_lex->having_fix_field= 0;
1584Item_subselect::trans_res
1585Item_in_subselect::select_transformer(
Join *join)
1612Item_subselect::trans_res
1615 Select_Lex *current= session->lex().current_select, *up;
1616 const char *save_where= session->where();
1617 Item_subselect::trans_res res= RES_ERROR;
1625 Select_Lex *sl= current->master_unit()->first_select();
1626 for (; sl; sl= sl->next_select())
1636 session->setWhere(
"IN/ALL/ANY subquery");
1645 result= (!(optimizer=
new Item_in_optimizer(left_expr,
this)));
1650 session->lex().current_select= up= current->return_after_parsing();
1651 result= (!left_expr->fixed &&
1652 left_expr->fix_fields(session, optimizer->arguments()));
1654 left_expr= optimizer->arguments()[0];
1656 session->lex().current_select= current;
1664 if (exec_method == NOT_TRANSFORMED)
1665 exec_method= IN_TO_EXISTS;
1674 if (left_expr->cols() == 1)
1675 res= single_value_transformer(join, func);
1679 if (func != Eq_creator::instance())
1681 my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
1684 res= row_value_transformer(join);
1687 session->setWhere(save_where);
1694 if (exec_method == IN_TO_EXISTS)
1695 str->append(STRING_WITH_LEN(
"<exists>"));
1698 left_expr->print(str);
1699 str->append(STRING_WITH_LEN(
" in "));
1705bool Item_in_subselect::fix_fields(
Session *session_arg,
Item **ref)
1709 if (exec_method == SEMI_JOIN)
1710 return !( (*ref)=
new Item_int(1));
1712 return result || Item_subselect::fix_fields(session_arg, ref);
1742 subselect_hash_sj_engine *new_engine= NULL;
1745 if (engine->engine_type() == subselect_engine::SINGLE_SELECT_ENGINE)
1751 new_engine=
new subselect_hash_sj_engine(session,
this, old_engine_ptr);
1754 Item_subselect::trans_res new_trans_res;
1762 exec_method= NOT_TRANSFORMED;
1763 if (left_expr->cols() == 1)
1767 res= (new_trans_res != Item_subselect::RES_OK);
1774 assert(engine->engine_type() == subselect_engine::HASH_SJ_ENGINE);
1775 new_engine=
static_cast<subselect_hash_sj_engine *
>(engine);
1789 unit->global_parameters->select_limit= NULL;
1811 Join *outer_join= NULL;
1813 outer_join= unit->outer_select()->join;
1814 if (! outer_join || ! outer_join->
tables || ! outer_join->join_tab)
1819 for (uint32_t i= 0; i < left_expr->cols(); i++)
1822 if (!cur_item_cache)
1824 left_expr_cache->push_front(cur_item_cache);
1843bool Item_in_subselect::is_expensive_processor(
unsigned char *)
1845 return exec_method == MATERIALIZATION;
1849Item_subselect::trans_res
1850Item_allany_subselect::select_transformer(Join *join)
1852 exec_method= IN_TO_EXISTS;
1854 upper_item->show= 1;
1861 if (exec_method == IN_TO_EXISTS)
1863 str->append(STRING_WITH_LEN(
"<exists>"));
1867 left_expr->print(str);
1869 str->append(func->symbol(all), strlen(func->symbol(all)));
1870 str->append(all ?
" all " :
" any ", 5);
1876void subselect_engine::set_session(
Session *session_arg)
1878 session= session_arg;
1881 result->set_session(session_arg);
1886subselect_single_select_engine::
1887subselect_single_select_engine(Select_Lex *select,
1891 prepared(0), executed(0), select_lex(select), join(0)
1893 select_lex->master_unit()->item= item_arg;
1897void subselect_single_select_engine::cleanup()
1899 prepared= executed= 0;
1906void subselect_union_engine::cleanup()
1908 unit->reinit_exec_mechanism();
1914bool subselect_union_engine::is_executed()
const
1916 return unit->executed;
1935bool subselect_union_engine::no_rows()
1938 return test(!unit->fake_select_lex->join->send_records);
1942void subselect_uniquesubquery_engine::cleanup()
1945 if (tab->table->cursor->inited)
1946 tab->table->cursor->endIndexScan();
1951subselect_union_engine::subselect_union_engine(Select_Lex_Unit *u,
1957 unit->item= item_arg;
1991 join=
new Join(session, select_lex->item_list, select_lex->options | SELECT_NO_UNLOCK, result);
1995 Select_Lex *save_select= session->lex().current_select;
1996 session->lex().current_select= select_lex;
1997 if (join->prepare(&select_lex->ref_pointer_array,
1998 (
TableList*) select_lex->table_list.first,
1999 select_lex->with_wild,
2001 select_lex->order_list.elements +
2002 select_lex->group_list.elements,
2003 (
Order*) select_lex->order_list.first,
2004 (
Order*) select_lex->group_list.first,
2006 select_lex, select_lex->master_unit()))
2008 session->lex().current_select= save_select;
2012int subselect_union_engine::prepare()
2014 return unit->prepare(session, result, (uint32_t)SELECT_NO_UNLOCK);
2017int subselect_uniquesubquery_engine::prepare()
2040bool subselect_single_select_engine::no_rows()
2042 return !item->assigned();
2053 List<Item>::iterator li(item_list.begin());
2054 res_type= STRING_RESULT;
2055 res_field_type= DRIZZLE_TYPE_VARCHAR;
2056 for (uint32_t i= 0; (sel_item= li++); i++)
2058 item->max_length= sel_item->max_length;
2059 res_type= sel_item->result_type();
2060 res_field_type= sel_item->field_type();
2061 item->decimals= sel_item->decimals;
2062 item->unsigned_flag= sel_item->unsigned_flag;
2063 maybe_null= sel_item->maybe_null;
2064 if (!(row[i]= Item_cache::get_cache(sel_item)))
2066 row[i]->setup(sel_item);
2068 if (item_list.size() > 1)
2069 res_type= ROW_RESULT;
2072void subselect_single_select_engine::fix_length_and_dec(
Item_cache **row)
2074 assert(row || select_lex->item_list.size() == 1);
2075 set_row(select_lex->item_list, row);
2076 item->collation.set(row[0]->collation);
2081void subselect_union_engine::fix_length_and_dec(
Item_cache **row)
2083 assert(row || unit->first_select()->item_list.size() == 1);
2085 if (unit->first_select()->item_list.size() == 1)
2087 set_row(unit->types, row);
2088 item->collation.set(row[0]->collation);
2092 bool maybe_null_saved= maybe_null;
2093 set_row(unit->types, row);
2094 maybe_null= maybe_null_saved;
2098void subselect_uniquesubquery_engine::fix_length_and_dec(
Item_cache **)
2104int subselect_single_select_engine::exec()
2106 char const *save_where= session->where();
2107 Select_Lex *save_select= session->lex().current_select;
2108 session->lex().current_select= select_lex;
2109 if (!join->optimized)
2111 Select_Lex_Unit *unit= select_lex->master_unit();
2113 unit->set_limit(unit->global_parameters);
2114 if (join->optimize())
2116 session->setWhere(save_where);
2118 session->lex().current_select= save_select;
2119 return(join->error ? join->error : 1);
2121 save_join_if_explain();
2122 if (item->engine_changed)
2127 if (select_lex->uncacheable.any() &&
2133 session->setWhere(save_where);
2134 session->lex().current_select= save_select;
2138 item->assigned((executed= 0));
2142 item->reset_value_registration();
2143 JoinTable *changed_tabs[MAX_TABLES];
2144 JoinTable **last_changed_tab= changed_tabs;
2145 if (item->have_guarded_conds())
2153 for (uint32_t i=join->const_tables ; i < join->tables ; i++)
2155 JoinTable *tab=join->join_tab+i;
2156 if (tab && tab->keyuse)
2158 for (uint32_t key_part= 0;
2159 key_part < tab->ref.key_parts;
2162 bool *cond_guard= tab->ref.cond_guards[key_part];
2163 if (cond_guard && !*cond_guard)
2166 tab->save_read_first_record= tab->read_first_record;
2167 tab->save_read_record= tab->read_record.read_record;
2168 tab->read_first_record= init_read_record_seq;
2169 tab->read_record.record= tab->table->record[0];
2170 tab->read_record.session= join->session;
2171 tab->read_record.ref_length= tab->table->cursor->ref_length;
2172 *(last_changed_tab++)= tab;
2183 for (JoinTable **ptab= changed_tabs; ptab != last_changed_tab; ptab++)
2185 JoinTable *tab= *ptab;
2186 tab->read_record.record= 0;
2187 tab->read_record.ref_length= 0;
2188 tab->read_first_record= tab->save_read_first_record;
2189 tab->read_record.read_record= tab->save_read_record;
2192 session->setWhere(save_where);
2193 session->lex().current_select= save_select;
2194 return(join->error||session->is_fatal_error);
2196 session->setWhere(save_where);
2197 session->lex().current_select= save_select;
2201void subselect_single_select_engine::save_join_if_explain()
2216 if (session->lex().describe &&
2217 select_lex->uncacheable.none() &&
2218 !(join->select_options & SELECT_DESCRIBE) &&
2231 join->init_save_join_tab();
2236int subselect_union_engine::exec()
2238 char const *save_where= session->where();
2239 int res= unit->exec();
2240 session->setWhere(save_where);
2264int subselect_uniquesubquery_engine::scan_table()
2267 Table *table= tab->table;
2269 if (table->cursor->inited)
2270 table->cursor->endIndexScan();
2272 if ((error= table->cursor->startTableScan(1)))
2274 table->print_error(error, MYF(0));
2278 assert(table->getSession());
2279 table->cursor->extra_opt(HA_EXTRA_CACHE,
2280 table->getSession()->variables.read_buff_size);
2284 error=table->cursor->rnd_next(table->record[0]);
2285 if (error && error != HA_ERR_END_OF_FILE)
2287 error= table->report_error(error);
2294 if (!cond || cond->val_int())
2296 empty_result_set=
false;
2301 table->cursor->endTableScan();
2348bool subselect_uniquesubquery_engine::copy_ref_key()
2350 for (StoredKey **copy= tab->ref.key_copy ; *copy ; copy++)
2352 StoredKey::store_key_result store_res= (*copy)->copy();
2353 tab->ref.key_err= store_res;
2363 null_keypart= (*copy)->null_key;
2366 bool top_level= ((Item_in_subselect *) item)->is_top_level_item();
2387 if (store_res == StoredKey::STORE_KEY_FATAL)
2393 tab->table->status= STATUS_NOT_FOUND;
2431int subselect_uniquesubquery_engine::exec()
2434 Table *table= tab->table;
2435 empty_result_set=
true;
2447 ((Item_in_subselect *) item)->value= 0;
2452 return(scan_table());
2454 if (!table->cursor->inited)
2456 error= table->cursor->startIndexScan(tab->ref.key, 0);
2460 error= table->report_error(error);
2461 return (error != 0);
2465 error= table->cursor->index_read_map(table->record[0],
2467 make_prev_keypart_map(tab->ref.key_parts),
2470 error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
2471 error= table->report_error(error);
2476 if (!table->status && (!cond || cond->val_int()))
2478 ((Item_in_subselect *) item)->value= 1;
2479 empty_result_set=
false;
2482 ((Item_in_subselect *) item)->value= 0;
2541int subselect_indexsubquery_engine::exec()
2544 bool null_finding= 0;
2545 Table *table= tab->table;
2547 ((Item_in_subselect *) item)->value= 0;
2548 empty_result_set=
true;
2555 *tab->ref.null_ref_key= 0;
2556 ((Item_in_subselect *) item)->was_null= 0;
2569 ((Item_in_subselect *) item)->value= 0;
2574 return(scan_table());
2576 if (!table->cursor->inited)
2578 error= table->cursor->startIndexScan(tab->ref.key, 1);
2582 error= table->report_error(error);
2586 error= table->cursor->index_read_map(table->record[0],
2588 make_prev_keypart_map(tab->ref.key_parts),
2591 error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
2592 error= table->report_error(error);
2601 if ((!cond || cond->val_int()) && (!having || having->val_int()))
2603 empty_result_set=
false;
2605 ((Item_in_subselect *) item)->was_null= 1;
2607 ((Item_in_subselect *) item)->value= 1;
2610 error= table->cursor->index_next_same(table->record[0],
2612 tab->ref.key_length);
2613 if (error && error != HA_ERR_END_OF_FILE)
2615 error= table->report_error(error);
2621 if (!check_null || null_finding)
2623 *tab->ref.null_ref_key= 1;
2626 if ((error= (safe_index_read(tab) == 1)))
2635uint32_t subselect_single_select_engine::cols()
2637 return select_lex->item_list.size();
2641uint32_t subselect_union_engine::cols()
2643 return unit->types.size();
2647bool subselect_single_select_engine::uncacheable()
2649 return select_lex->uncacheable.any();
2653bool subselect_single_select_engine::uncacheable(uint32_t bit_pos)
2655 return select_lex->uncacheable.test(bit_pos);
2659bool subselect_union_engine::uncacheable()
2661 return unit->uncacheable.any();
2665bool subselect_union_engine::uncacheable(uint32_t bit_pos)
2667 return unit->uncacheable.test(bit_pos);
2671void subselect_single_select_engine::exclude()
2673 select_lex->master_unit()->exclude_level();
2676void subselect_union_engine::exclude()
2678 unit->exclude_level();
2682void subselect_uniquesubquery_engine::exclude()
2689table_map subselect_engine::calc_const_tables(
TableList *table)
2692 for (; table; table= table->next_leaf)
2694 Table *tbl= table->table;
2695 if (tbl && tbl->const_table)
2702table_map subselect_single_select_engine::upper_select_const_tables()
2704 return calc_const_tables((TableList *) select_lex->outer_select()->
2709table_map subselect_union_engine::upper_select_const_tables()
2711 return calc_const_tables((TableList *) unit->outer_select()->leaf_tables);
2715void subselect_single_select_engine::print(
String *str)
2717 select_lex->print(session, str);
2721void subselect_union_engine::print(
String *str)
2727void subselect_uniquesubquery_engine::print(
String *str)
2729 str->append(STRING_WITH_LEN(
"<primary_index_lookup>("));
2730 tab->ref.items[0]->print(str);
2731 str->append(STRING_WITH_LEN(
" in "));
2732 if (tab->table->getShare()->isTemporaryCategory())
2738 str->append(STRING_WITH_LEN(
"<temporary table>"));
2741 str->append(tab->table->getShare()->getTableNameRef());
2742 str->append(STRING_WITH_LEN(
" on "));
2743 str->append(tab->table->key_info[tab->ref.key].name, strlen(tab->table->key_info[tab->ref.key].name));
2746 str->append(STRING_WITH_LEN(
" where "));
2776void subselect_indexsubquery_engine::print(
String *str)
2778 str->append(STRING_WITH_LEN(
"<index_lookup>("));
2779 tab->ref.items[0]->print(str);
2780 str->append(STRING_WITH_LEN(
" in "));
2781 str->append(tab->table->getShare()->getTableNameRef());
2782 KeyInfo *key_info= tab->table->key_info+ tab->ref.key;
2783 str->append(STRING_WITH_LEN(
" on "));
2784 str->append(key_info->name, strlen(key_info->name));
2787 str->append(STRING_WITH_LEN(
" checking NULL"));
2792 str->append(STRING_WITH_LEN(
" where "));
2798 str->append(STRING_WITH_LEN(
" having "));
2822 return select_lex->join->change_result(result);
2842 int rc= unit->change_result(res, result);
2878 return(select_lex->table_list.elements == 0);
2892bool subselect_single_select_engine::may_be_null()
2894 return ((
no_tables() && !join->conds && !join->having) ? maybe_null : 1);
2908 for (Select_Lex *sl= unit->first_select(); sl; sl= sl->next_select())
2910 if (sl->table_list.elements)
2965 uint32_t tmp_key_parts;
2977 if (tmp_result_sink->create_result_table(session, tmp_columns,
true,
2978 session->options | TMP_TABLE_ALL_COLUMNS,
"materialized subselect"))
2981 tmp_table= tmp_result_sink->table;
2983 tmp_key_parts= tmp_key->key_parts;
2992 if (tmp_table->getShare()->sizeKeys() == 0)
2994 assert(tmp_table->getShare()->db_type() == myisam_engine);
2996 tmp_table->getShare()->uniques ||
2997 tmp_table->
key_info->key_length >= tmp_table->
cursor->getEngine()->max_key_length() ||
2998 tmp_table->
key_info->key_parts > tmp_table->
cursor->getEngine()->max_key_parts());
3004 result= tmp_result_sink;
3010 assert(tmp_table->getShare()->sizeKeys() == 1 && tmp_columns->size() == tmp_key_parts);
3023 tab->table= tmp_table;
3025 tab->ref.key_length= tmp_key->key_length;
3026 tab->ref.key_buff= (
unsigned char*) session->mem.calloc(ALIGN_SIZE(tmp_key->key_length) * 2);
3027 tab->ref.key_copy=
new (session->mem)
StoredKey*[tmp_key_parts + 1];
3028 tab->ref.items=
new (session->mem)
Item*[tmp_key_parts];
3032 unsigned char *cur_ref_buff= tab->ref.key_buff;
3034 for (uint32_t i= 0; i < tmp_key_parts; i++, cur_key_part++, ref_key++)
3036 tab->ref.items[i]= item_in->left_expr->element_index(i);
3037 int null_count= test(cur_key_part->field->real_maybe_null());
3045 cur_ref_buff + null_count,
3046 null_count ? tab->ref.key_buff : 0,
3047 cur_key_part->length, tab->ref.items[i]);
3048 cur_ref_buff+= cur_key_part->store_length;
3051 tab->ref.key_err= 1;
3052 tab->ref.key_parts= tmp_key_parts;
3072 materialize_engine->prepare();
3074 materialize_join= materialize_engine->join;
3075 materialize_join->change_result(result);
3079subselect_hash_sj_engine::~subselect_hash_sj_engine()
3098 is_materialized=
false;
3100 materialize_engine->cleanup();
3101 subselect_uniquesubquery_engine::cleanup();
3124 if (!is_materialized)
3127 Select_Lex *save_select= session->lex().current_select;
3128 session->lex().current_select= materialize_engine->select_lex;
3129 if ((res= materialize_join->optimize()))
3132 materialize_engine->save_join_if_explain();
3134 materialize_join->exec();
3135 if ((res= test(materialize_join->error || session->is_fatal_error)))
3147 is_materialized=
true;
3154 tab->table->cursor->info(HA_STATUS_VARIABLE);
3155 if (!tab->table->cursor->stats.records)
3157 empty_result_set=
true;
3158 item_in->value=
false;
3163 tmp_param= &(item_in->unit->outer_select()->join->tmp_table_param);
3164 if (tmp_param && !tmp_param->copy_field)
3168 session->lex().current_select= save_select;
3176 return(subselect_uniquesubquery_engine::exec());
3186 str->append(STRING_WITH_LEN(
" <materialize> ("));
3187 materialize_engine->print(str);
3188 str->append(STRING_WITH_LEN(
" ), "));
3190 subselect_uniquesubquery_engine::print(str);
3192 str->append(STRING_WITH_LEN(
3193 "<the access method for lookups is not yet created>"
virtual void print(String *str)
type::Decimal * val_decimal(type::Decimal *)
virtual void print(String *str)
String * val_str(String *)
trans_res select_in_like_transformer(Join *join, const Comp_creator *func)
virtual void print(String *str)
type::Decimal * val_decimal(type::Decimal *)
bool init_left_expr_cache()
trans_res single_value_in_to_exists_transformer(Join *join, const Comp_creator *func)
trans_res row_value_in_to_exists_transformer(Join *join)
String * val_str(String *)
virtual void print(String *str)
trans_res select_transformer(Join *join)
String * val_str(String *)
type::Decimal * val_decimal(type::Decimal *)
Select_Lex * invalidate_and_restore_select_lex()
Select_Lex * get_select_lex()
table_map used_tables() const
virtual void print(String *str)
virtual void top_level_item(void)
virtual void print(String *str)
bool init_permanent(List< Item > *tmp_columns)
virtual void print(String *str)
bool change_result(Item_subselect *si, select_result_interceptor *result)
bool change_result(Item_subselect *si, select_result_interceptor *result)
bool change_result(Item_subselect *si, select_result_interceptor *result)
#define STACK_MIN_SIZE
Abort if less stack during eval.
void count_field_types(Select_Lex *select_lex, Tmp_Table_Param *param, List< Item > &fields, bool reset_with_sum_func)
TODO: Rename this file - func.h is stupid.
static const uint32_t UNCACHEABLE_EXPLAIN
forcing to save JOIN for explain
const char * in_additional_cond
bool check_stack_overrun(Session *session, long margin, void *)
const char * in_left_expr_name
Cached_item * new_Cached_item(Session *session, Item *item)