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>
53 extern plugin::StorageEngine *myisam_engine;
55 inline Item* and_items(Item* cond, Item *item)
57 return cond ?
new Item_cond_and(cond, item) : item;
60 Item_subselect::Item_subselect() :
62 value_assigned(false),
70 parsing_place(NO_MATTER),
71 have_to_be_excluded(false),
72 const_item_cache(true),
73 engine_changed(false),
87 void Item_subselect::init(Select_Lex *select_lex,
88 select_result_interceptor *result)
95 unit= select_lex->master_unit();
103 engine= unit->item->engine;
104 parsing_place= unit->item->parsing_place;
105 unit->item->engine= 0;
107 engine->change_result(
this, result);
111 Select_Lex *outer_select= unit->outer_select();
116 parsing_place= (outer_select->in_sum_expr ?
118 outer_select->parsing_place);
119 if (unit->is_union())
120 engine=
new subselect_union_engine(unit, result,
this);
122 engine=
new subselect_single_select_engine(select_lex, result,
this);
125 Select_Lex *upper= unit->outer_select();
126 if (upper->parsing_place == IN_HAVING)
127 upper->subquery_in_having= 1;
135 return unit->first_select();
138 void Item_subselect::cleanup()
140 Item_result_field::cleanup();
154 void Item_singlerow_subselect::cleanup()
157 Item_subselect::cleanup();
161 void Item_in_subselect::cleanup()
165 left_expr_cache->delete_elements();
166 delete left_expr_cache;
167 left_expr_cache= NULL;
169 first_execution=
true;
170 Item_subselect::cleanup();
173 Item_subselect::~Item_subselect()
178 Item_subselect::trans_res
179 Item_subselect::select_transformer(Join *)
185 bool Item_subselect::fix_fields(Session *session_param, Item **ref)
187 char const *save_where= session_param->where();
191 engine->set_session((session= session_param));
196 res= engine->prepare();
214 if (unit->outer_select()->where == (*ref))
216 unit->outer_select()->where= substitution;
218 else if (unit->outer_select()->having == (*ref))
220 unit->outer_select()->having= substitution;
223 (*ref)= substitution;
224 substitution->name= name;
225 if (have_to_be_excluded)
230 session->setWhere(
"checking transformed subquery");
233 ret= (*ref)->fix_fields(session, ref);
235 session->setWhere(save_where);
240 if (engine->cols() > max_columns)
242 my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
245 fix_length_and_dec();
250 if (engine->uncacheable())
252 const_item_cache=
false;
253 if (engine->uncacheable(UNCACHEABLE_RAND))
255 used_tables_cache|= RAND_TABLE_BIT;
261 session->setWhere(save_where);
266 bool Item_subselect::walk(Item_processor processor,
bool walk_subquery,
267 unsigned char *argument)
272 for (Select_Lex *lex= unit->first_select(); lex; lex= lex->next_select())
274 List<Item>::iterator li(lex->item_list.begin());
278 if (lex->where && (lex->where)->walk(processor, walk_subquery, argument))
280 if (lex->having && (lex->having)->walk(processor, walk_subquery,
286 if (item->walk(processor, walk_subquery, argument))
289 for (order= (Order*) lex->order_list.first ; order; order= order->next)
291 if ((*order->item)->walk(processor, walk_subquery, argument))
294 for (order= (Order*) lex->group_list.first ; order; order= order->next)
296 if ((*order->item)->walk(processor, walk_subquery, argument))
301 return (this->*processor)(argument);
305 bool Item_subselect::exec()
328 bool Item_in_subselect::exec()
330 assert(exec_method != MATERIALIZATION ||
331 (exec_method == MATERIALIZATION &&
332 engine->engine_type() == subselect_engine::HASH_SJ_ENGINE));
345 if (!left_expr_cache && exec_method == MATERIALIZATION)
346 init_left_expr_cache();
349 if (left_expr_cache && test_if_item_cache_changed(*left_expr_cache) < 0)
352 if (!first_execution)
354 first_execution=
false;
362 return(Item_subselect::exec());
366 Item::Type Item_subselect::type()
const
368 return SUBSELECT_ITEM;
372 void Item_subselect::fix_length_and_dec()
374 engine->fix_length_and_dec(0);
380 return (table_map) (engine->uncacheable() ? used_tables_cache : 0L);
386 return const_item_cache;
389 Item *Item_subselect::get_tmp_table_item(
Session *session_arg)
391 if (!with_sum_func && !const_item())
393 return copy_or_same(session_arg);
396 void Item_subselect::update_used_tables()
398 if (! engine->uncacheable())
401 if (!(used_tables_cache & ~engine->upper_select_const_tables()))
402 const_item_cache=
true;
415 Item_singlerow_subselect::Item_singlerow_subselect(Select_Lex *select_lex)
420 max_columns= UINT_MAX;
442 Item_maxmin_subselect::Item_maxmin_subselect(
Session *session_param,
444 Select_Lex *select_lex,
458 used_tables_cache= parent->get_used_tables_cache();
459 const_item_cache= parent->get_const_item_cache();
465 session= session_param;
468 void Item_maxmin_subselect::cleanup()
470 Item_singlerow_subselect::cleanup();
486 str->append(max?
"<max>":
"<min>", 5);
491 void Item_singlerow_subselect::reset()
509 Item_subselect::trans_res
517 if (!select_lex->master_unit()->is_union() &&
518 !select_lex->table_list.elements &&
519 select_lex->item_list.size() == 1 &&
520 !select_lex->item_list.front().with_sum_func &&
528 !(select_lex->item_list.front().type() == FIELD_ITEM ||
529 select_lex->item_list.front().type() == REF_ITEM) &&
530 !join->conds && !join->having
534 have_to_be_excluded= 1;
535 if (session->lex().describe)
537 char warn_buff[DRIZZLE_ERRMSG_SIZE];
538 snprintf(warn_buff,
sizeof(warn_buff), ER(ER_SELECT_REDUCED), select_lex->select_number);
539 push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
540 ER_SELECT_REDUCED, warn_buff);
542 substitution= &select_lex->item_list.front();
547 substitution->walk(&Item::remove_dependence_processor, 0,
548 (
unsigned char *) select_lex->outer_select());
555 void Item_singlerow_subselect::store(uint32_t i,
Item *item)
560 enum Item_result Item_singlerow_subselect::result_type()
const
562 return engine->type();
569 enum_field_types Item_singlerow_subselect::field_type()
const
571 return engine->field_type();
574 void Item_singlerow_subselect::fix_length_and_dec()
576 if ((max_columns= engine->cols()) == 1)
578 engine->fix_length_and_dec(row= &value);
582 if (!(row= (Item_cache**) memory::sql_alloc(
sizeof(Item_cache*)*max_columns)))
584 engine->fix_length_and_dec(row);
587 unsigned_flag= value->unsigned_flag;
593 if (engine->no_tables())
597 uint32_t Item_singlerow_subselect::cols()
599 return engine->cols();
602 bool Item_singlerow_subselect::check_cols(uint32_t c)
604 if (c != engine->cols())
606 my_error(ER_OPERAND_COLUMNS, MYF(0), c);
612 bool Item_singlerow_subselect::null_inside()
614 for (uint32_t i= 0; i < max_columns ; i++)
622 void Item_singlerow_subselect::bring_value()
702 Item_exists_subselect::Item_exists_subselect(Select_Lex *select_lex):
707 max_columns= UINT_MAX;
717 str->append(STRING_WITH_LEN(
"exists"));
722 bool 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())
737 Item_in_subselect::Item_in_subselect(Item * left_exp,
738 Select_Lex *select_lex) :
739 Item_exists_subselect(),
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());
760 Item_allany_subselect::Item_allany_subselect(Item * left_exp,
761 chooser_compare_func_creator fc,
762 Select_Lex *select_lex,
764 :Item_in_subselect(), func_creator(fc), all(all_arg)
767 func= func_creator(all_arg);
768 init(select_lex,
new select_exists_subselect(
this));
773 test_limit(select_lex->master_unit());
778 void 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;
989 Item_subselect::trans_res
990 Item_in_subselect::single_value_transformer(
Join *join,
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)
1167 Item_subselect::trans_res
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()));
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)
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;
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>"));
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);
1319 Item_subselect::trans_res
1320 Item_in_subselect::row_value_transformer(
Join *join)
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)
1394 Item_subselect::trans_res
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=
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=
1522 select_lex->ref_pointer_array + i,
1531 ref_pointer_array+i,
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;
1584 Item_subselect::trans_res
1585 Item_in_subselect::select_transformer(
Join *join)
1612 Item_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");
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 "));
1705 bool 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);
1745 if (engine->engine_type() == subselect_engine::SINGLE_SELECT_ENGINE)
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);
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);
1843 bool Item_in_subselect::is_expensive_processor(
unsigned char *)
1845 return exec_method == MATERIALIZATION;
1849 Item_subselect::trans_res
1850 Item_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);
1876 void subselect_engine::set_session(
Session *session_arg)
1878 session= session_arg;
1881 result->set_session(session_arg);
1886 subselect_single_select_engine::
1887 subselect_single_select_engine(Select_Lex *select,
1888 select_result_interceptor *result_arg,
1889 Item_subselect *item_arg)
1890 :subselect_engine(item_arg, result_arg),
1891 prepared(0), executed(0), select_lex(select), join(0)
1893 select_lex->master_unit()->item= item_arg;
1897 void subselect_single_select_engine::cleanup()
1899 prepared= executed= 0;
1906 void subselect_union_engine::cleanup()
1908 unit->reinit_exec_mechanism();
1914 bool subselect_union_engine::is_executed()
const
1916 return unit->executed;
1935 bool subselect_union_engine::no_rows()
1938 return test(!unit->fake_select_lex->join->send_records);
1942 void subselect_uniquesubquery_engine::cleanup()
1945 if (tab->table->
cursor->inited)
1946 tab->table->
cursor->endIndexScan();
1951 subselect_union_engine::subselect_union_engine(Select_Lex_Unit *u,
1952 select_result_interceptor *result_arg,
1953 Item_subselect *item_arg)
1954 :subselect_engine(item_arg, result_arg)
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;
2012 int subselect_union_engine::prepare()
2014 return unit->prepare(session, result, (uint32_t)SELECT_NO_UNLOCK);
2017 int subselect_uniquesubquery_engine::prepare()
2040 bool subselect_single_select_engine::no_rows()
2042 return !item->assigned();
2050 void subselect_engine::set_row(List<Item> &item_list, Item_cache **row)
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;
2072 void 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);
2081 void 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;
2098 void subselect_uniquesubquery_engine::fix_length_and_dec(Item_cache **)
2104 int 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;
2196 session->setWhere(save_where);
2197 session->lex().current_select= save_select;
2201 void 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();
2236 int subselect_union_engine::exec()
2238 char const *save_where= session->where();
2239 int res= unit->exec();
2240 session->setWhere(save_where);
2264 int 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();
2348 bool 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;
2431 int 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;
2541 int 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)))
2635 uint32_t subselect_single_select_engine::cols()
2637 return select_lex->item_list.size();
2641 uint32_t subselect_union_engine::cols()
2643 return unit->types.size();
2647 bool subselect_single_select_engine::uncacheable()
2649 return select_lex->uncacheable.any();
2653 bool subselect_single_select_engine::uncacheable(uint32_t bit_pos)
2655 return select_lex->uncacheable.test(bit_pos);
2659 bool subselect_union_engine::uncacheable()
2661 return unit->uncacheable.any();
2665 bool subselect_union_engine::uncacheable(uint32_t bit_pos)
2667 return unit->uncacheable.test(bit_pos);
2671 void subselect_single_select_engine::exclude()
2673 select_lex->master_unit()->exclude_level();
2676 void subselect_union_engine::exclude()
2678 unit->exclude_level();
2682 void subselect_uniquesubquery_engine::exclude()
2689 table_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)
2702 table_map subselect_single_select_engine::upper_select_const_tables()
2704 return calc_const_tables((TableList *) select_lex->outer_select()->
2709 table_map subselect_union_engine::upper_select_const_tables()
2711 return calc_const_tables((TableList *) unit->outer_select()->leaf_tables);
2715 void subselect_single_select_engine::print(String *str)
2717 select_lex->print(session, str);
2721 void subselect_union_engine::print(String *str)
2727 void 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 "));
2776 void 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);
2892 bool 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;
3079 subselect_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>"
Cached_item * new_Cached_item(Session *session, Item *item)
virtual void print(String *str)
bool change_result(Item_subselect *si, select_result_interceptor *result)
virtual int64_t val_int()=0
bool change_result(Item_subselect *si, select_result_interceptor *result)
const char * in_additional_cond
TODO: Rename this file - func.h is stupid.
String * val_str(String *)
bool init_permanent(List< Item > *tmp_columns)
type::Decimal * val_decimal(type::Decimal *)
void count_field_types(Select_Lex *select_lex, Tmp_Table_Param *param, List< Item > &fields, bool reset_with_sum_func)
virtual void print(String *str)
bool change_result(select_result *result)
table_map used_tables() const
virtual void print(String *str)
#define STACK_MIN_SIZE
Abort if less stack during eval.
bool check_stack_overrun(Session *session, long margin, void *)
virtual void top_level_item(void)
type::Decimal * val_decimal(type::Decimal *)
virtual double val_real()=0
String * val_str(String *)
trans_res select_transformer(Join *join)
virtual void print(String *str)
virtual String * val_str(String *str)=0
String * val_str(String *)
Select_Lex * get_select_lex()
type::Decimal * val_decimal(type::Decimal *)
Select_Lex * invalidate_and_restore_select_lex()
trans_res select_in_like_transformer(Join *join, const Comp_creator *func)
virtual void print(String *str)
const char * in_left_expr_name
virtual void print(String *str)
trans_res row_value_in_to_exists_transformer(Join *join)
virtual type::Decimal * val_decimal(type::Decimal *decimal_buffer)=0
bool init_left_expr_cache()
static const uint32_t UNCACHEABLE_EXPLAIN
forcing to save JOIN for explain
virtual void print(String *str)
bool change_result(Item_subselect *si, select_result_interceptor *result)
trans_res single_value_in_to_exists_transformer(Join *join, const Comp_creator *func)