item_subselect.cc 28.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
/* Copyright (C) 2000 MySQL AB

   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; either version 2 of the License, or
   (at your option) any later version.

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* 
   subselect Item

SUBSELECT TODO:
   - add function from mysql_select that use JOIN* as parameter to JOIN methods
     (sql_select.h/sql_select.cc)
*/

#ifdef __GNUC__
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include "sql_select.h"

unknown's avatar
unknown committed
32 33 34 35 36
inline Item * and_items(Item* cond, Item *item)
{
  return (cond? (new Item_cond_and(cond, item)) : item);
}

37
Item_subselect::Item_subselect():
38
  Item_result_field(), engine_owner(1), value_assigned(0), substitution(0),
39 40
  engine(0), used_tables_cache(0), have_to_be_excluded(0),
  const_item_cache(1), engine_changed(0)
41
{
42
  reset();
43 44 45 46 47 48 49
  /*
    item value is NULL if select_subselect not changed this value 
    (i.e. some rows will be found returned)
  */
  null_value= 1;
}

50

51
void Item_subselect::init(st_select_lex *select_lex,
unknown's avatar
unknown committed
52
			  select_subselect *result)
53 54 55
{

  DBUG_ENTER("Item_subselect::init");
unknown's avatar
unknown committed
56
  DBUG_PRINT("subs", ("select_lex 0x%xl", (ulong) select_lex));
unknown's avatar
unknown committed
57 58

  if (select_lex->next_select())
59
    engine= new subselect_union_engine(select_lex->master_unit(), result,
unknown's avatar
unknown committed
60 61
				       this);
  else
62
    engine= new subselect_single_select_engine(select_lex, result, this);
63 64 65
  DBUG_VOID_RETURN;
}

66

unknown's avatar
unknown committed
67 68 69 70 71 72
Item_subselect::~Item_subselect()
{
  if (engine_owner)
    delete engine;
}

73
Item_subselect::trans_res
unknown's avatar
unknown committed
74
Item_subselect::select_transformer(JOIN *join) 
unknown's avatar
unknown committed
75 76
{
  DBUG_ENTER("Item_subselect::select_transformer");
77
  DBUG_RETURN(RES_OK);
unknown's avatar
unknown committed
78 79 80
}


81
bool Item_subselect::fix_fields(THD *thd_param, TABLE_LIST *tables, Item **ref)
82
{
83
  engine->set_thd((thd= thd_param));
84

85
  char const *save_where= thd->where;
86
  int res= engine->prepare();
87
  if (!res)
unknown's avatar
unknown committed
88
  {
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
    if (substitution)
    {
      (*ref)= substitution;
      substitution->name= name;
      if (have_to_be_excluded)
	engine->exclude();
      substitution= 0;
      fixed= 1;
      thd->where= "checking transformed subquery";
      int ret= (*ref)->fix_fields(thd, tables, ref);
      // We can't substitute aggregate functions (like (SELECT (max(i)))
      if ((*ref)->with_sum_func)
      {
	my_error(ER_INVALID_GROUP_FUNC_USE, MYF(0));
	return 1;
      }
      return ret;
    }
unknown's avatar
unknown committed
107 108 109
    // Is it one field subselect?
    if (engine->cols() > max_columns)
    {  
unknown's avatar
unknown committed
110
      my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
unknown's avatar
unknown committed
111 112
      return 1;
    }
113
    fix_length_and_dec();
unknown's avatar
unknown committed
114
  }
unknown's avatar
unknown committed
115 116 117 118 119
  if (engine->uncacheable())
  {
    const_item_cache= 0;
    used_tables_cache|= RAND_TABLE_BIT;
  }
120
  fixed= 1;
121
  thd->where= save_where;
122 123 124
  return res;
}

125 126
bool Item_subselect::exec()
{
127
  int res;
128 129 130 131
  MEM_ROOT *old_root= my_pthread_getspecific_ptr(MEM_ROOT*, THR_MALLOC);
  if (&thd->mem_root != old_root)
  {
    my_pthread_setspecific_ptr(THR_MALLOC, &thd->mem_root);
132
    res= engine->exec();
133 134 135
    my_pthread_setspecific_ptr(THR_MALLOC, old_root);
  }
  else
136 137 138 139 140 141 142
    res= engine->exec();
  if (engine_changed)
  {
    engine_changed= 0;
    return exec();
  }
  return (res);
143 144
}

145 146 147 148 149
Item::Type Item_subselect::type() const 
{
  return SUBSELECT_ITEM;
}

150 151
void Item_subselect::fix_length_and_dec()
{
152
  engine->fix_length_and_dec(0);
153
}
unknown's avatar
unknown committed
154

155
table_map Item_subselect::used_tables() const
unknown's avatar
unknown committed
156
{
unknown's avatar
unknown committed
157
  return (table_map) (engine->dependent() ? used_tables_cache : 0L);
unknown's avatar
unknown committed
158 159
}

160 161
bool Item_subselect::const_item() const
{
unknown's avatar
unknown committed
162
  return const_item_cache;
163 164 165 166 167 168 169
}

void Item_subselect::update_used_tables()
{
  if (!engine->uncacheable())
  {
    // did all used tables become ststic?
unknown's avatar
unknown committed
170
    if ((used_tables_cache & ~engine->upper_select_const_tables()))
171 172 173 174
      const_item_cache= 1;
  }
}

unknown's avatar
merge  
unknown committed
175
Item_singlerow_subselect::Item_singlerow_subselect(st_select_lex *select_lex)
176
  :Item_subselect(), value(0)
unknown's avatar
unknown committed
177
{
unknown's avatar
unknown committed
178
  DBUG_ENTER("Item_singlerow_subselect::Item_singlerow_subselect");
179
  init(select_lex, new select_singlerow_subselect(this));
unknown's avatar
unknown committed
180 181
  max_columns= 1;
  maybe_null= 1;
182
  max_columns= UINT_MAX;
unknown's avatar
unknown committed
183
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
184 185
}

unknown's avatar
unknown committed
186
Item_maxmin_subselect::Item_maxmin_subselect(st_select_lex *select_lex,
187 188 189 190
					     bool max)
  :Item_singlerow_subselect()
{
  DBUG_ENTER("Item_maxmin_subselect::Item_maxmin_subselect");
unknown's avatar
unknown committed
191
  init(select_lex, new select_max_min_finder_subselect(this, max));
192 193 194 195 196 197
  max_columns= 1;
  maybe_null= 1;
  max_columns= 1;
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
198
void Item_singlerow_subselect::reset()
199
{
200 201 202
  null_value= 1;
  if (value)
    value->null_value= 1;
203 204
}

205
Item_subselect::trans_res
unknown's avatar
unknown committed
206
Item_singlerow_subselect::select_transformer(JOIN *join)
207
{
208
  SELECT_LEX *select_lex= join->select_lex;
209
  
210 211
  if (!select_lex->master_unit()->first_select()->next_select() &&
      !select_lex->table_list.elements &&
unknown's avatar
unknown committed
212
      select_lex->item_list.elements == 1 &&
unknown's avatar
unknown committed
213 214 215 216 217 218 219
      /*
	We cant change name of Item_field or Item_ref, because it will
	prevent it's correct resolving, but we should save name of
	removed item => we do not make optimization if top item of
	list is field or reference.
	TODO: solve above problem
      */
unknown's avatar
unknown committed
220
      !(select_lex->item_list.head()->type() == FIELD_ITEM ||
221
	select_lex->item_list.head()->type() == REF_ITEM) 
unknown's avatar
unknown committed
222
      )
223 224 225
  {
    
    have_to_be_excluded= 1;
unknown's avatar
unknown committed
226
    if (join->thd->lex.describe)
227 228 229
    {
      char warn_buff[MYSQL_ERRMSG_SIZE];
      sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number);
unknown's avatar
unknown committed
230
      push_warning(join->thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
231 232 233
		   ER_SELECT_REDUCED, warn_buff);
    }
    substitution= select_lex->item_list.head();
unknown's avatar
unknown committed
234 235 236 237 238 239
    /*
      as far as we moved content to upper leven, field which depend of
      'upper' select is not really dependent => we remove this dependence
    */
    substitution->walk(&Item::remove_dependence_processor,
		       (byte *) select_lex->outer_select());
240 241 242
    if (select_lex->where || select_lex->having)
    {
      Item *cond;
243 244 245 246
      if (!join->having)
	cond= join->conds;
      else if (!join->conds)
	cond= join->having;
247
      else
248
	if (!(cond= new Item_cond_and(join->conds, join->having)))
249
	  return RES_ERROR;
250 251
      if (!(substitution= new Item_func_if(cond, substitution,
					   new Item_null())))
252
	return RES_ERROR;
253
    }
254
    return RES_REDUCE;
255
  }
256
  return RES_OK;
257 258
}

unknown's avatar
unknown committed
259
void Item_singlerow_subselect::store(uint i, Item *item)
unknown's avatar
unknown committed
260
{
261
  row[i]->store(item);
unknown's avatar
unknown committed
262 263
}

unknown's avatar
unknown committed
264
enum Item_result Item_singlerow_subselect::result_type() const
unknown's avatar
unknown committed
265
{
266 267 268
  return engine->type();
}

unknown's avatar
unknown committed
269
void Item_singlerow_subselect::fix_length_and_dec()
270
{
271 272 273 274 275 276 277
  if ((max_columns= engine->cols()) == 1)
  {
    engine->fix_length_and_dec(row= &value);
    if (!(value= Item_cache::get_cache(engine->type())))
      return;
  }
  else
278
  {
279 280 281 282 283
    THD *thd= current_thd;
    if (!(row= (Item_cache**)thd->alloc(sizeof(Item_cache*)*max_columns)))
      return;
    engine->fix_length_and_dec(row);
    value= *row;
284
  }
unknown's avatar
unknown committed
285
  maybe_null= engine->may_be_null();
286 287
}

unknown's avatar
unknown committed
288
uint Item_singlerow_subselect::cols()
unknown's avatar
unknown committed
289
{
290 291 292
  return engine->cols();
}

unknown's avatar
unknown committed
293
bool Item_singlerow_subselect::check_cols(uint c)
294 295 296
{
  if (c != engine->cols())
  {
unknown's avatar
unknown committed
297
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
298 299 300 301 302
    return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
303
bool Item_singlerow_subselect::null_inside()
304 305 306 307 308 309 310 311 312
{
  for (uint i= 0; i < max_columns ; i++)
  {
    if (row[i]->null_value)
      return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
313
void Item_singlerow_subselect::bring_value()
314
{
315
  exec();
unknown's avatar
unknown committed
316 317
}

unknown's avatar
unknown committed
318
double Item_singlerow_subselect::val () 
unknown's avatar
unknown committed
319
{
320
  if (!exec() && !value->null_value)
321 322 323 324 325
  {
    null_value= 0;
    return value->val();
  }
  else
unknown's avatar
unknown committed
326
  {
327
    reset();
unknown's avatar
unknown committed
328
    return 0;
unknown's avatar
unknown committed
329
  }
unknown's avatar
unknown committed
330 331
}

unknown's avatar
unknown committed
332
longlong Item_singlerow_subselect::val_int () 
unknown's avatar
unknown committed
333
{
334
  if (!exec() && !value->null_value)
335 336 337 338 339
  {
    null_value= 0;
    return value->val_int();
  }
  else
unknown's avatar
unknown committed
340
  {
341
    reset();
unknown's avatar
unknown committed
342
    return 0;
unknown's avatar
unknown committed
343
  }
unknown's avatar
unknown committed
344 345
}

unknown's avatar
unknown committed
346
String *Item_singlerow_subselect::val_str (String *str) 
unknown's avatar
unknown committed
347
{
348
  if (!exec() && !value->null_value)
349 350 351 352 353
  {
    null_value= 0;
    return value->val_str(str);
  }
  else
unknown's avatar
unknown committed
354
  {
355
    reset();
unknown's avatar
unknown committed
356
    return 0;
unknown's avatar
unknown committed
357
  }
unknown's avatar
unknown committed
358 359
}

360
Item_exists_subselect::Item_exists_subselect(st_select_lex *select_lex):
361
  Item_subselect()
unknown's avatar
unknown committed
362
{
unknown's avatar
unknown committed
363
  DBUG_ENTER("Item_exists_subselect::Item_exists_subselect");
364
  init(select_lex, new select_exists_subselect(this));
unknown's avatar
unknown committed
365 366 367 368
  max_columns= UINT_MAX;
  null_value= 0; //can't be NULL
  maybe_null= 0; //can't be NULL
  value= 0;
unknown's avatar
unknown committed
369 370 371 372 373
  // We need only 1 row to determinate existence
  select_lex->master_unit()->global_parameters->select_limit= 1;
  DBUG_VOID_RETURN;
}

374 375
bool Item_in_subselect::test_limit(SELECT_LEX_UNIT *unit)
{
unknown's avatar
unknown committed
376 377
  if (unit->fake_select_lex &&
      unit->fake_select_lex->test_limit())
378
    return(1);
unknown's avatar
unknown committed
379

380 381 382
  SELECT_LEX *sl= unit->first_select();
  for (; sl; sl= sl->next_select())
  {
unknown's avatar
unknown committed
383
    if (sl->test_limit())
384 385 386 387 388
      return(1);
  }
  return(0);
}

389
Item_in_subselect::Item_in_subselect(Item * left_exp,
unknown's avatar
unknown committed
390
				     st_select_lex *select_lex):
391
  Item_exists_subselect(), upper_not(0)
unknown's avatar
unknown committed
392 393
{
  DBUG_ENTER("Item_in_subselect::Item_in_subselect");
unknown's avatar
unknown committed
394
  left_expr= left_exp;
395
  init(select_lex, new select_exists_subselect(this));
unknown's avatar
unknown committed
396
  max_columns= UINT_MAX;
397
  maybe_null= 1;
398
  abort_on_null= 0;
399
  reset();
unknown's avatar
unknown committed
400
  //if test_limit will fail then error will be reported to client
401
  test_limit(select_lex->master_unit());
unknown's avatar
unknown committed
402 403 404
  DBUG_VOID_RETURN;
}

405
Item_allany_subselect::Item_allany_subselect(Item * left_exp,
406
					     compare_func_creator fn,
407 408
					     st_select_lex *select_lex)
  :Item_in_subselect()
unknown's avatar
unknown committed
409 410 411
{
  DBUG_ENTER("Item_in_subselect::Item_in_subselect");
  left_expr= left_exp;
412
  func= fn;
413
  init(select_lex, new select_exists_subselect(this));
unknown's avatar
unknown committed
414
  max_columns= 1;
415
  abort_on_null= 0;
416
  reset();
unknown's avatar
unknown committed
417
  //if test_limit will fail then error will be reported to client
418
  test_limit(select_lex->master_unit());
unknown's avatar
unknown committed
419
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
420 421
}

unknown's avatar
unknown committed
422

423 424
void Item_exists_subselect::fix_length_and_dec()
{
425
   decimals= 0;
426
   max_length= 1;
unknown's avatar
unknown committed
427
   max_columns= engine->cols();
428 429
}

unknown's avatar
unknown committed
430 431
double Item_exists_subselect::val () 
{
432
  if (exec())
unknown's avatar
unknown committed
433
  {
434
    reset();
unknown's avatar
unknown committed
435
    return 0;
unknown's avatar
unknown committed
436
  }
unknown's avatar
unknown committed
437 438 439 440 441
  return (double) value;
}

longlong Item_exists_subselect::val_int () 
{
442
  if (exec())
unknown's avatar
unknown committed
443
  {
444
    reset();
unknown's avatar
unknown committed
445
    return 0;
unknown's avatar
unknown committed
446
  }
unknown's avatar
unknown committed
447 448 449 450 451
  return value;
}

String *Item_exists_subselect::val_str(String *str)
{
452
  if (exec())
unknown's avatar
unknown committed
453
  {
454 455 456
    reset();
    return 0;
  }
457
  str->set(value,default_charset());
458 459 460 461 462
  return str;
}

double Item_in_subselect::val () 
{
463
  if (exec())
464 465 466 467 468 469 470 471 472 473 474 475
  {
    reset();
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
    null_value= 1;
  return (double) value;
}

longlong Item_in_subselect::val_int () 
{
476
  if (exec())
477 478 479 480 481 482 483 484 485 486 487 488
  {
    reset();
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
    null_value= 1;
  return value;
}

String *Item_in_subselect::val_str(String *str)
{
489
  if (exec())
490 491 492 493 494 495 496 497
  {
    reset();
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
  {
    null_value= 1;
unknown's avatar
unknown committed
498
    return 0;
unknown's avatar
unknown committed
499
  }
500
  str->set(value,default_charset());
unknown's avatar
unknown committed
501 502 503
  return str;
}

unknown's avatar
unknown committed
504

505
Item_subselect::trans_res
unknown's avatar
unknown committed
506
Item_in_subselect::single_value_transformer(JOIN *join,
507 508
					    Item *left_expr,
					    compare_func_creator func)
unknown's avatar
unknown committed
509 510
{
  DBUG_ENTER("Item_in_subselect::single_value_transformer");
511

512
  SELECT_LEX *select_lex= join->select_lex;
unknown's avatar
unknown committed
513

unknown's avatar
unknown committed
514
  THD *thd= join->thd;
515
  thd->where= "scalar IN/ALL/ANY subquery";
unknown's avatar
unknown committed
516

517 518 519 520 521 522
  if (select_lex->item_list.elements > 1)
  {
    my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
    DBUG_RETURN(RES_ERROR);
  }

523 524 525 526 527
  if ((abort_on_null || (upper_not && upper_not->top_level())) &&
      !select_lex->master_unit()->dependent &&
      (func == &Item_bool_func2::gt_creator ||
       func == &Item_bool_func2::lt_creator ||
       func == &Item_bool_func2::ge_creator ||
528
       func == &Item_bool_func2::le_creator))
529
  {
530 531 532
    Item *subs;
    if (!select_lex->group_list.elements &&
	!select_lex->with_sum_func)
533
    {
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
      Item *item;
      subs_type type= substype();
      if (func == &Item_bool_func2::le_creator ||
	  func == &Item_bool_func2::lt_creator)
      {
	/*
	  (ALL && (> || =>)) || (ANY && (< || =<))
	  for ALL condition is inverted
	*/
	item= new Item_sum_max(*select_lex->ref_pointer_array);
      }
      else
      {
	/*
	  (ALL && (< || =<)) || (ANY && (> || =>))
	  for ALL condition is inverted
	*/
	item= new Item_sum_min(*select_lex->ref_pointer_array);
      }
      *select_lex->ref_pointer_array= item;
      select_lex->item_list.empty();
      select_lex->item_list.push_back(item);
    
      if (item->fix_fields(thd, join->tables_list, &item))
      {
unknown's avatar
unknown committed
559
	DBUG_RETURN(RES_ERROR);
560
      }
unknown's avatar
unknown committed
561
      subs= new Item_singlerow_subselect(select_lex);
562 563 564
    }
    else
    {
565 566 567
      // remove LIMIT placed  by ALL/ANY subquery
      select_lex->master_unit()->global_parameters->select_limit=
	HA_POS_ERROR;
unknown's avatar
unknown committed
568
      subs= new Item_maxmin_subselect(select_lex,
569 570
				      (func == &Item_bool_func2::le_creator ||
				       func == &Item_bool_func2::lt_creator));
571 572 573 574 575 576 577
    }
    // left expression belong to outer select
    SELECT_LEX *current= thd->lex.current_select, *up;
    thd->lex.current_select= up= current->return_after_parsing();
    if (left_expr->fix_fields(thd, up->get_table_list(), 0))
    {
      thd->lex.current_select= current;
unknown's avatar
unknown committed
578
      DBUG_RETURN(RES_ERROR);
579 580
    }
    thd->lex.current_select= current;
581
    substitution= (*func)(left_expr, subs);
unknown's avatar
unknown committed
582
    DBUG_RETURN(RES_OK);
583 584
  }

585
  if (!substitution)
unknown's avatar
unknown committed
586
  {
587 588 589 590
    //first call for this unit
    SELECT_LEX_UNIT *unit= select_lex->master_unit();
    substitution= optimizer= new Item_in_optimizer(left_expr, this);

unknown's avatar
unknown committed
591 592
    SELECT_LEX *current= thd->lex.current_select, *up;

593 594 595
    thd->lex.current_select= up= current->return_after_parsing();
    //optimizer never use Item **ref => we can pass 0 as parameter
    if (!optimizer || optimizer->fix_left(thd, up->get_table_list(), 0))
596
    {
597
      thd->lex.current_select= current;
598
      DBUG_RETURN(RES_ERROR);
599
    }
600
    thd->lex.current_select= current;
601

602 603 604 605 606 607
    /*
      As far as  Item_ref_in_optimizer do not substitude itself on fix_fields
      we can use same item for all selects.
    */
    expr= new Item_ref((Item**)optimizer->get_cache(), 
		       (char *)"<no matter>",
608
		       (char *)in_left_expr_name);
609 610 611

    unit->dependent= 1;
  }
612

613 614
  select_lex->dependent= 1;
  Item *item;
unknown's avatar
unknown committed
615 616

  item= (Item*) select_lex->item_list.head();
unknown's avatar
unknown committed
617

618 619 620 621 622 623 624 625 626 627 628
  if (join->having || select_lex->with_sum_func ||
      select_lex->group_list.elements)
  {
    item= (*func)(expr,
		  new Item_ref_null_helper(this,
					   select_lex->ref_pointer_array,
					   (char *)"<ref>",
					   this->full_name()));
    join->having= and_items(join->having, item);
    select_lex->having_fix_field= 1;
    if (join->having->fix_fields(thd, join->tables_list, &join->having))
629
    {
630
      select_lex->having_fix_field= 0;
631
      DBUG_RETURN(RES_ERROR);
632
    }
633 634 635 636 637 638 639 640 641
    select_lex->having_fix_field= 0;
  }
  else
  {
    select_lex->item_list.empty();
    select_lex->item_list.push_back(new Item_int("Not_used",
						 (longlong) 1, 21));
    select_lex->ref_pointer_array[0]= select_lex->item_list.head();
    if (select_lex->table_list.elements)
642
    {
643 644 645
      Item *having= item, *isnull= item;
      item= (*func)(expr, item);
      if (!abort_on_null)
unknown's avatar
unknown committed
646
      {
647 648 649 650 651 652
	having= new Item_is_not_null_test(this, having);
	join->having= (join->having ?
		       new Item_cond_and(having, join->having) :
		       having);
	select_lex->having_fix_field= 1;
	if (join->having->fix_fields(thd, join->tables_list, &join->having))
unknown's avatar
unknown committed
653
	{
654
	  select_lex->having_fix_field= 0;
655
	  DBUG_RETURN(RES_ERROR);
unknown's avatar
unknown committed
656
	}
657 658 659 660
	select_lex->having_fix_field= 0;
	item= new Item_cond_or(item,
			       new Item_func_isnull(isnull));
      }
661
      item->name= (char *)in_additional_cond;
662 663
      join->conds= and_items(join->conds, item);
      if (join->conds->fix_fields(thd, join->tables_list, &join->conds))
664
	DBUG_RETURN(RES_ERROR);
665 666 667 668 669 670
    }
    else
    {
      if (select_lex->master_unit()->first_select()->next_select())
      {
	join->having= (*func)(expr, 
671 672 673
			      new Item_null_helper(this, item,
						   (char *)"<no matter>",
						   (char *)"<result>"));
674 675 676 677
	select_lex->having_fix_field= 1;
	if (join->having->fix_fields(thd, join->tables_list, &join->having))
	{
	  select_lex->having_fix_field= 0;
678
	  DBUG_RETURN(RES_ERROR);
unknown's avatar
unknown committed
679
	}
680 681 682 683 684 685 686 687 688 689
	select_lex->having_fix_field= 0;
      }
      else
      {
	// it is single select without tables => possible optimization
	item= (*func)(left_expr, item);
	// fix_field of item will be done in time of substituting 
	substitution= item;
	have_to_be_excluded= 1;
	if (thd->lex.describe)
unknown's avatar
unknown committed
690
	{
691 692 693 694
	  char warn_buff[MYSQL_ERRMSG_SIZE];
	  sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number);
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_SELECT_REDUCED, warn_buff);
unknown's avatar
unknown committed
695
	}
696
	DBUG_RETURN(RES_REDUCE);
unknown's avatar
unknown committed
697
      }
698
    }
unknown's avatar
unknown committed
699
  }
700
  DBUG_RETURN(RES_OK);
unknown's avatar
unknown committed
701
}
unknown's avatar
unknown committed
702

703
Item_subselect::trans_res
unknown's avatar
unknown committed
704 705
Item_in_subselect::row_value_transformer(JOIN *join,
					 Item *left_expr)
unknown's avatar
unknown committed
706 707
{
  DBUG_ENTER("Item_in_subselect::row_value_transformer");
unknown's avatar
unknown committed
708

unknown's avatar
unknown committed
709
  THD *thd= join->thd;
710
  thd->where= "row IN/ALL/ANY subquery";
unknown's avatar
unknown committed
711

712
  SELECT_LEX *select_lex= join->select_lex;
unknown's avatar
unknown committed
713

714 715 716 717 718 719
  if (select_lex->item_list.elements != left_expr->cols())
  {
    my_error(ER_OPERAND_COLUMNS, MYF(0), left_expr->cols());
    DBUG_RETURN(RES_ERROR);
  }

720
  if (!substitution)
unknown's avatar
unknown committed
721
  {
722 723 724 725
    //first call for this unit
    SELECT_LEX_UNIT *unit= select_lex->master_unit();
    substitution= optimizer= new Item_in_optimizer(left_expr, this);

unknown's avatar
unknown committed
726
    SELECT_LEX *current= thd->lex.current_select, *up;
727 728 729
    thd->lex.current_select= up= current->return_after_parsing();
    //optimizer never use Item **ref => we can pass 0 as parameter
    if (!optimizer || optimizer->fix_left(thd, up->get_table_list(), 0))
730
    {
731
      thd->lex.current_select= current;
732
      DBUG_RETURN(RES_ERROR);
733
    }
734 735 736 737 738 739 740 741
    thd->lex.current_select= current;

    unit->dependent= 1;
  }

  uint n= left_expr->cols();

  select_lex->dependent= 1;
unknown's avatar
unknown committed
742 743 744
  select_lex->setup_ref_array(thd,
			      select_lex->order_list.elements +
			      select_lex->group_list.elements);
745 746 747 748
  Item *item= 0;
  List_iterator_fast<Item> li(select_lex->item_list);
  for (uint i= 0; i < n; i++)
  {
unknown's avatar
unknown committed
749 750 751 752
    Item *func= new Item_ref_null_helper(this, 
					 select_lex->ref_pointer_array+i,
					 (char *) "<no matter>",
					 (char *) "<list ref>");
753 754 755 756
    func=
      Item_bool_func2::eq_creator(new Item_ref((*optimizer->get_cache())->
					       addr(i), 
					       (char *)"<no matter>",
757
					       (char *)in_left_expr_name),
758 759 760
				  func);
    item= and_items(item, func);
  }
unknown's avatar
unknown committed
761

762 763 764 765 766 767 768
  if (join->having || select_lex->with_sum_func ||
      select_lex->group_list.first ||
      !select_lex->table_list.elements)
  {
    join->having= and_items(join->having, item);
    select_lex->having_fix_field= 1;
    if (join->having->fix_fields(thd, join->tables_list, &join->having))
unknown's avatar
unknown committed
769
    {
770
      select_lex->having_fix_field= 0;
771
      DBUG_RETURN(RES_ERROR);
unknown's avatar
unknown committed
772
    }
773
    select_lex->having_fix_field= 0;
unknown's avatar
unknown committed
774
  }
775 776 777 778
  else
  {
    join->conds= and_items(join->conds, item);
    if (join->conds->fix_fields(thd, join->tables_list, &join->having))
779
      DBUG_RETURN(RES_ERROR);
780
  }
781
  DBUG_RETURN(RES_OK);
unknown's avatar
unknown committed
782 783
}

784

785
Item_subselect::trans_res
unknown's avatar
unknown committed
786
Item_in_subselect::select_transformer(JOIN *join)
unknown's avatar
unknown committed
787
{
unknown's avatar
unknown committed
788
  if (left_expr->cols() == 1)
unknown's avatar
unknown committed
789
    return single_value_transformer(join, left_expr,
790
				    &Item_bool_func2::eq_creator);
unknown's avatar
unknown committed
791
  return row_value_transformer(join, left_expr);
unknown's avatar
unknown committed
792 793
}

794

795
Item_subselect::trans_res
unknown's avatar
unknown committed
796
Item_allany_subselect::select_transformer(JOIN *join)
unknown's avatar
unknown committed
797
{
unknown's avatar
unknown committed
798
  return single_value_transformer(join, left_expr, func);
unknown's avatar
unknown committed
799 800
}

801
subselect_single_select_engine::
802 803 804 805 806
subselect_single_select_engine(st_select_lex *select,
			       select_subselect *result,
			       Item_subselect *item)
  :subselect_engine(item, result),
   prepared(0), optimized(0), executed(0), join(0)
unknown's avatar
unknown committed
807 808 809 810 811 812 813 814 815 816
{
  select_lex= select;
  SELECT_LEX_UNIT *unit= select_lex->master_unit();
  unit->offset_limit_cnt= unit->global_parameters->offset_limit;
  unit->select_limit_cnt= unit->global_parameters->select_limit+
    unit->global_parameters ->offset_limit;
  if (unit->select_limit_cnt < unit->global_parameters->select_limit)
    unit->select_limit_cnt= HA_POS_ERROR;		// no limit
  if (unit->select_limit_cnt == HA_POS_ERROR)
    select_lex->options&= ~OPTION_FOUND_ROWS;
unknown's avatar
unknown committed
817
  unit->item= item;
unknown's avatar
unknown committed
818 819 820
  this->select_lex= select_lex;
}

821

822
subselect_union_engine::subselect_union_engine(st_select_lex_unit *u,
unknown's avatar
unknown committed
823
					       select_subselect *result,
824 825
					       Item_subselect *item)
  :subselect_engine(item, result)
unknown's avatar
unknown committed
826 827
{
  unit= u;
unknown's avatar
unknown committed
828
  if (!result)
unknown's avatar
unknown committed
829
    //out of memory
830
    current_thd->fatal_error();
unknown's avatar
unknown committed
831 832 833 834 835
  unit->item= item;
}

int subselect_single_select_engine::prepare()
{
unknown's avatar
unknown committed
836 837
  if (prepared)
    return 0;
838 839 840 841 842 843 844
  join= new JOIN(thd, select_lex->item_list, select_lex->options, result);
  if (!join || !result)
  {
    //out of memory
    thd->fatal_error();
    return 1;
  }
unknown's avatar
unknown committed
845
  prepared= 1;
unknown's avatar
unknown committed
846
  SELECT_LEX *save_select= thd->lex.current_select;
847
  thd->lex.current_select= select_lex;
unknown's avatar
unknown committed
848 849 850
  if (join->prepare(&select_lex->ref_pointer_array,
		    (TABLE_LIST*) select_lex->table_list.first,
		    select_lex->with_wild,
unknown's avatar
unknown committed
851
		    select_lex->where,
unknown's avatar
unknown committed
852 853
		    select_lex->order_list.elements +
		    select_lex->group_list.elements,
unknown's avatar
unknown committed
854 855 856 857
		    (ORDER*) select_lex->order_list.first,
		    (ORDER*) select_lex->group_list.first,
		    select_lex->having,
		    (ORDER*) 0, select_lex, 
858
		    select_lex->master_unit(), 0))
unknown's avatar
unknown committed
859
    return 1;
860
  thd->lex.current_select= save_select;
unknown's avatar
unknown committed
861 862 863 864 865
  return 0;
}

int subselect_union_engine::prepare()
{
866
  return unit->prepare(thd, result, 0);
unknown's avatar
unknown committed
867 868
}

869
int subselect_uniquesubquery_engine::prepare()
870 871 872 873 874 875
{
  //this never should be called
  DBUG_ASSERT(0);
  return 1;
}

876
static Item_result set_row(SELECT_LEX *select_lex, Item * item,
unknown's avatar
unknown committed
877
			   Item_cache **row, bool *maybe_null)
878
{
879 880
  Item_result res_type= STRING_RESULT;
  Item *sel_item;
881
  List_iterator_fast<Item> li(select_lex->item_list);
882 883 884 885 886
  for (uint i= 0; (sel_item= li++); i++)
  {
    item->max_length= sel_item->max_length;
    res_type= sel_item->result_type();
    item->decimals= sel_item->decimals;
unknown's avatar
unknown committed
887
    *maybe_null= sel_item->maybe_null;
888 889 890 891 892
    if (row)
    {
      if (!(row[i]= Item_cache::get_cache(res_type)))
	return STRING_RESULT; // we should return something
      row[i]->set_len_n_dec(sel_item->max_length, sel_item->decimals);
893
      row[i]->collation.set(sel_item->collation);
894 895 896 897 898
    }
  }
  if (select_lex->item_list.elements > 1)
    res_type= ROW_RESULT;
  return res_type;
899 900
}

901
void subselect_single_select_engine::fix_length_and_dec(Item_cache **row)
902
{
903
  DBUG_ASSERT(row || select_lex->item_list.elements==1);
unknown's avatar
unknown committed
904
  res_type= set_row(select_lex, item, row, &maybe_null);
905
  item->collation.set(row[0]->collation);
unknown's avatar
unknown committed
906 907
  if (cols() != 1)
    maybe_null= 0;
908 909 910 911 912 913 914
}

void subselect_union_engine::fix_length_and_dec(Item_cache **row)
{
  DBUG_ASSERT(row || unit->first_select()->item_list.elements==1);

  if (unit->first_select()->item_list.elements == 1)
915
  {
916 917 918 919 920 921 922 923 924 925
    uint32 mlen= 0, len;
    Item *sel_item= 0;
    for (SELECT_LEX *sl= unit->first_select(); sl; sl= sl->next_select())
    {
      List_iterator_fast<Item> li(sl->item_list);
      Item *s_item= li++;
      if ((len= s_item->max_length) > mlen)
	mlen= len;
      if (!sel_item)
	sel_item= s_item;
unknown's avatar
unknown committed
926
      maybe_null= s_item->maybe_null;
927 928 929 930 931 932 933 934 935 936 937 938 939 940
    }
    item->max_length= mlen;
    res_type= sel_item->result_type();
    item->decimals= sel_item->decimals;
    if (row)
    {
      if (!(row[0]= Item_cache::get_cache(res_type)))
	return;
      row[0]->set_len_n_dec(mlen, sel_item->decimals);
    }
  }
  else
  {
    SELECT_LEX *sl= unit->first_select();
unknown's avatar
unknown committed
941 942
    bool fake= 0;
    res_type= set_row(sl, item, row, &fake);
unknown's avatar
unknown committed
943
    for (sl= sl->next_select(); sl; sl= sl->next_select())
944 945 946 947 948 949 950 951 952
    {
      List_iterator_fast<Item> li(sl->item_list);
      Item *sel_item;
      for (uint i= 0; (sel_item= li++); i++)
      {
	if (sel_item->max_length > row[i]->max_length)
	  row[i]->max_length= sel_item->max_length;
      }
    }
953 954
  }
}
unknown's avatar
unknown committed
955

956
void subselect_uniquesubquery_engine::fix_length_and_dec(Item_cache **row)
957 958 959 960 961
{
  //this never should be called
  DBUG_ASSERT(0);
}

unknown's avatar
unknown committed
962 963 964
int subselect_single_select_engine::exec()
{
  DBUG_ENTER("subselect_single_select_engine::exec");
965
  char const *save_where= join->thd->where;
unknown's avatar
unknown committed
966
  SELECT_LEX *save_select= join->thd->lex.current_select;
967
  join->thd->lex.current_select= select_lex;
unknown's avatar
unknown committed
968 969 970 971 972
  if (!optimized)
  {
    optimized=1;
    if (join->optimize())
    {
973
      join->thd->where= save_where;
unknown's avatar
unknown committed
974
      executed= 1;
975
      join->thd->lex.current_select= save_select;
unknown's avatar
unknown committed
976 977
      DBUG_RETURN(join->error?join->error:1);
    }
978 979 980 981
    if (item->engine_changed)
    {
      DBUG_RETURN(1);
    }
unknown's avatar
unknown committed
982
  }
983
  if ((select_lex->dependent || select_lex->uncacheable) && executed)
unknown's avatar
unknown committed
984 985
  {
    if (join->reinit())
986 987
    {
      join->thd->where= save_where;
988
      join->thd->lex.current_select= save_select;
unknown's avatar
unknown committed
989
      DBUG_RETURN(1);
990
    }
991
    item->reset();
unknown's avatar
unknown committed
992 993 994 995 996 997
    item->assigned((executed= 0));
  }
  if (!executed)
  {
    join->exec();
    executed= 1;
998
    join->thd->where= save_where;
999
    join->thd->lex.current_select= save_select;
1000
    DBUG_RETURN(join->error||thd->is_fatal_error);
unknown's avatar
unknown committed
1001
  }
1002
  join->thd->where= save_where;
1003
  join->thd->lex.current_select= save_select;
unknown's avatar
unknown committed
1004 1005 1006 1007 1008
  DBUG_RETURN(0);
}

int subselect_union_engine::exec()
{
1009 1010 1011 1012
  char const *save_where= unit->thd->where;
  int res= unit->exec();
  unit->thd->where= save_where;
  return res;
unknown's avatar
unknown committed
1013 1014
}

1015

1016
int subselect_uniquesubquery_engine::exec()
1017
{
1018
  DBUG_ENTER("subselect_uniquesubquery_engine::exec");
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
  int error;
  TABLE *table= tab->table;
  if ((tab->ref.key_err= (*tab->ref.key_copy)->copy()))
  {
    table->status= STATUS_NOT_FOUND;
    error= -1;
  }
  else
  {
    error= table->file->index_read(table->record[0],
				   tab->ref.key_buff,
				   tab->ref.key_length,HA_READ_KEY_EXACT);
    if (error && error != HA_ERR_KEY_NOT_FOUND)
      error= report_error(table, error);
    else
    {
      error= 0;
      table->null_row= 0;
1037 1038 1039
      ((Item_in_subselect *) item)->value= (!table->status &&
					    (!cond || cond->val_int()) ? 1 :
					    0);
1040 1041
    }
  }
1042
  DBUG_RETURN(error != 0);
1043 1044
}

1045 1046

subselect_uniquesubquery_engine::~subselect_uniquesubquery_engine()
1047
{
1048 1049
  /* Tell handler we don't need the index anymore */
  tab->table->file->index_end();
1050 1051
}

1052

1053
int subselect_indexsubquery_engine::exec()
1054
{
1055
  DBUG_ENTER("subselect_indexsubselect_engine::exec");
1056
  int error;
1057
  bool null_finding= 0;
1058
  TABLE *table= tab->table;
1059

1060
  ((Item_in_subselect *) item)->value= 0;
1061

1062 1063
  if (check_null)
  {
1064 1065
    /* We need to check for NULL if there wasn't a matching value */
    *tab->null_ref_key= 0;			// Search first for not null
1066 1067 1068 1069
    ((Item_in_subselect *) item)->was_null= 0;
  }

  if ((*tab->ref.key_copy) && (tab->ref.key_err= (*tab->ref.key_copy)->copy()))
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
  {
    table->status= STATUS_NOT_FOUND;
    error= -1;
  }
  else
  {
    error= table->file->index_read(table->record[0],
				   tab->ref.key_buff,
				   tab->ref.key_length,HA_READ_KEY_EXACT);
    if (error && error != HA_ERR_KEY_NOT_FOUND)
      error= report_error(table, error);
    else
1082
    {
1083
      for (;;)
1084 1085 1086 1087 1088 1089 1090
      {
	error= 0;
	table->null_row= 0;
	if (!table->status)
	{
	  if (!cond || cond->val_int())
	  {
1091
	    if (null_finding)
1092 1093 1094
	      ((Item_in_subselect *) item)->was_null= 1;
	    else
	      ((Item_in_subselect *) item)->value= 1;
1095
	    break;
1096
	  }
1097 1098 1099 1100 1101 1102
	  error= table->file->index_next_same(table->record[0],
					      tab->ref.key_buff,
					      tab->ref.key_length);
	  if (error && error != HA_ERR_END_OF_FILE)
	  {
	    error= report_error(table, error);
1103
	    break;
1104
	  }
1105 1106
	}
	else
1107
	{
1108
	  if (!check_null || null_finding)
1109
	    break;			/* We don't need to check nulls */
1110
	  *tab->null_ref_key= 1;
1111
	  null_finding= 1;
1112
	  /* Check if there exists a row with a null value in the index */
unknown's avatar
unknown committed
1113
	  if ((error= (safe_index_read(tab) == 1)))
1114
	    break;
1115
	}
1116
      }
1117 1118
    }
  }
1119
  DBUG_RETURN(error != 0);
1120 1121
}

1122

unknown's avatar
unknown committed
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
uint subselect_single_select_engine::cols()
{
  return select_lex->item_list.elements;
}

uint subselect_union_engine::cols()
{
  return unit->first_select()->item_list.elements;
}

1133
bool subselect_single_select_engine::dependent()
unknown's avatar
unknown committed
1134
{
1135
  return select_lex->dependent;
unknown's avatar
unknown committed
1136 1137
}

1138
bool subselect_union_engine::dependent()
unknown's avatar
unknown committed
1139
{
1140
  return unit->dependent;
unknown's avatar
unknown committed
1141
}
unknown's avatar
unknown committed
1142

1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
bool subselect_single_select_engine::uncacheable()
{
  return select_lex->uncacheable;
}

bool subselect_union_engine::uncacheable()
{
  return unit->uncacheable;
}

unknown's avatar
unknown committed
1153 1154 1155 1156 1157 1158 1159 1160 1161
void subselect_single_select_engine::exclude()
{
  select_lex->master_unit()->exclude_level();
}

void subselect_union_engine::exclude()
{
  unit->exclude_level();
}
1162

1163
void subselect_uniquesubquery_engine::exclude()
1164 1165 1166 1167
{
  //this never should be called
  DBUG_ASSERT(0);
}
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193


table_map subselect_engine::calc_const_tables(TABLE_LIST *table)
{
  table_map map= 0;
  for(; table; table= table->next)
  {
    TABLE *tbl= table->table;
    if (tbl && tbl->const_table)
      map|= tbl->map;
  }
  return map;
}


table_map subselect_single_select_engine::upper_select_const_tables()
{
  return calc_const_tables((TABLE_LIST *) select_lex->outer_select()->
			   table_list.first);
}

table_map subselect_union_engine::upper_select_const_tables()
{
  return calc_const_tables((TABLE_LIST *) unit->outer_select()->
			   table_list.first);
}