item_subselect.cc 70.9 KB
Newer Older
1 2 3 4
/* 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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
6 7 8 9 10 11 12 13 14 15

   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 */

unknown's avatar
unknown committed
16 17 18 19 20
/**
  @file

  @brief
  subselect Item
21

unknown's avatar
unknown committed
22 23 24
  @todo
    - add function from mysql_select that use JOIN* as parameter to JOIN
    methods (sql_select.h/sql_select.cc)
25 26
*/

27
#ifdef USE_PRAGMA_IMPLEMENTATION
28 29 30 31 32 33
#pragma implementation				// gcc: Class implementation
#endif

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

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

39
Item_subselect::Item_subselect():
unknown's avatar
unknown committed
40 41
  Item_result_field(), value_assigned(0), thd(0), substitution(0),
  engine(0), old_engine(0), used_tables_cache(0), have_to_be_excluded(0),
42
  const_item_cache(1), engine_changed(0), changed(0), is_correlated(FALSE)
43
{
44
  with_subselect= 1;
45
  reset();
46
  /*
47
    item value is NULL if select_subselect not changed this value
48 49 50 51 52
    (i.e. some rows will be found returned)
  */
  null_value= 1;
}

53

54
void Item_subselect::init(st_select_lex *select_lex,
unknown's avatar
unknown committed
55
			  select_subselect *result)
56
{
57 58 59 60
  /*
    Please see Item_singlerow_subselect::invalidate_and_restore_select_lex(),
    which depends on alterations to the parse tree implemented here.
  */
61 62

  DBUG_ENTER("Item_subselect::init");
unknown's avatar
unknown committed
63
  DBUG_PRINT("enter", ("select_lex: 0x%lx", (long) select_lex));
unknown's avatar
unknown committed
64
  unit= select_lex->master_unit();
unknown's avatar
unknown committed
65

66 67 68 69 70 71 72
  if (unit->item)
  {
    /*
      Item can be changed in JOIN::prepare while engine in JOIN::optimize
      => we do not copy old_engine here
    */
    engine= unit->item->engine;
73
    parsing_place= unit->item->parsing_place;
74 75
    unit->item->engine= 0;
    unit->item= this;
unknown's avatar
unknown committed
76
    engine->change_result(this, result);
77
  }
unknown's avatar
unknown committed
78
  else
79
  {
unknown's avatar
unknown committed
80 81 82 83 84 85 86 87
    SELECT_LEX *outer_select= unit->outer_select();
    /*
      do not take into account expression inside aggregate functions because
      they can access original table fields
    */
    parsing_place= (outer_select->in_sum_expr ?
                    NO_MATTER :
                    outer_select->parsing_place);
88
    if (unit->is_union())
89 90 91 92
      engine= new subselect_union_engine(unit, result, this);
    else
      engine= new subselect_single_select_engine(select_lex, result, this);
  }
93 94
  {
    SELECT_LEX *upper= unit->outer_select();
95
    if (upper->parsing_place == IN_HAVING)
96 97
      upper->subquery_in_having= 1;
  }
98 99 100
  DBUG_VOID_RETURN;
}

101 102 103 104 105 106
st_select_lex *
Item_subselect::get_select_lex()
{
  return unit->first_select();
}

unknown's avatar
unknown committed
107 108
void Item_subselect::cleanup()
{
unknown's avatar
unknown committed
109
  DBUG_ENTER("Item_subselect::cleanup");
unknown's avatar
unknown committed
110
  Item_result_field::cleanup();
unknown's avatar
unknown committed
111 112
  if (old_engine)
  {
113 114
    if (engine)
      engine->cleanup();
unknown's avatar
unknown committed
115 116 117
    engine= old_engine;
    old_engine= 0;
  }
118 119
  if (engine)
    engine->cleanup();
unknown's avatar
unknown committed
120 121 122 123 124 125 126 127 128 129 130
  reset();
  value_assigned= 0;
  DBUG_VOID_RETURN;
}

void Item_singlerow_subselect::cleanup()
{
  DBUG_ENTER("Item_singlerow_subselect::cleanup");
  value= 0; row= 0;
  Item_subselect::cleanup();
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
131
}
132

unknown's avatar
unknown committed
133 134
Item_subselect::~Item_subselect()
{
135
  delete engine;
unknown's avatar
unknown committed
136 137
}

138
Item_subselect::trans_res
139
Item_subselect::select_transformer(JOIN *join)
unknown's avatar
unknown committed
140 141
{
  DBUG_ENTER("Item_subselect::select_transformer");
142
  DBUG_RETURN(RES_OK);
unknown's avatar
unknown committed
143 144 145
}


146
bool Item_subselect::fix_fields(THD *thd_param, Item **ref)
147
{
unknown's avatar
unknown committed
148
  char const *save_where= thd_param->where;
unknown's avatar
unknown committed
149
  uint8 uncacheable;
unknown's avatar
unknown committed
150
  bool res;
unknown's avatar
unknown committed
151

152
  DBUG_ASSERT(fixed == 0);
153
  engine->set_thd((thd= thd_param));
154

155
  if (check_stack_overrun(thd, STACK_MIN_SIZE, (uchar*)&res))
unknown's avatar
unknown committed
156
    return TRUE;
157

158
  if (!(res= engine->prepare()))
unknown's avatar
unknown committed
159
  {
160 161 162
    // all transformation is done (used by prepared statements)
    changed= 1;

163 164
    if (substitution)
    {
unknown's avatar
unknown committed
165 166
      int ret= 0;

unknown's avatar
unknown committed
167 168 169
      // did we changed top item of WHERE condition
      if (unit->outer_select()->where == (*ref))
	unit->outer_select()->where= substitution; // correct WHERE for PS
170 171
      else if (unit->outer_select()->having == (*ref))
	unit->outer_select()->having= substitution; // correct HAVING for PS
unknown's avatar
unknown committed
172

173 174 175 176 177
      (*ref)= substitution;
      substitution->name= name;
      if (have_to_be_excluded)
	engine->exclude();
      substitution= 0;
178
      thd->where= "checking transformed subquery";
179
      if (!(*ref)->fixed)
180
	ret= (*ref)->fix_fields(thd, ref);
181
      thd->where= save_where;
182 183
      return ret;
    }
unknown's avatar
unknown committed
184 185
    // Is it one field subselect?
    if (engine->cols() > max_columns)
186
    {
unknown's avatar
unknown committed
187
      my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
unknown's avatar
unknown committed
188
      return TRUE;
unknown's avatar
unknown committed
189
    }
190
    fix_length_and_dec();
unknown's avatar
unknown committed
191
  }
unknown's avatar
unknown committed
192
  else
unknown's avatar
unknown committed
193 194 195
    goto err;
  
  if ((uncacheable= engine->uncacheable()))
unknown's avatar
unknown committed
196 197
  {
    const_item_cache= 0;
198 199
    if (uncacheable & UNCACHEABLE_RAND)
      used_tables_cache|= RAND_TABLE_BIT;
unknown's avatar
unknown committed
200
  }
201
  fixed= 1;
unknown's avatar
unknown committed
202 203

err:
204
  thd->where= save_where;
205 206 207
  return res;
}

208 209

bool Item_subselect::walk(Item_processor processor, bool walk_subquery,
210
                          uchar *argument)
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
{

  if (walk_subquery)
  {
    for (SELECT_LEX *lex= unit->first_select(); lex; lex= lex->next_select())
    {
      List_iterator<Item> li(lex->item_list);
      Item *item;
      ORDER *order;

      if (lex->where && (lex->where)->walk(processor, walk_subquery, argument))
        return 1;
      if (lex->having && (lex->having)->walk(processor, walk_subquery,
                                             argument))
        return 1;

      while ((item=li++))
      {
        if (item->walk(processor, walk_subquery, argument))
          return 1;
      }
      for (order= (ORDER*) lex->order_list.first ; order; order= order->next)
      {
        if ((*order->item)->walk(processor, walk_subquery, argument))
          return 1;
      }
      for (order= (ORDER*) lex->group_list.first ; order; order= order->next)
      {
        if ((*order->item)->walk(processor, walk_subquery, argument))
          return 1;
      }
    }
  }
  return (this->*processor)(argument);
}


248
bool Item_subselect::exec()
249
{
250
  int res;
unknown's avatar
unknown committed
251

252
  if (thd->is_error())
unknown's avatar
unknown committed
253 254
  /* Do not execute subselect in case of a fatal error */
    return 1;
255 256 257 258 259
  /*
    Simulate a failure in sub-query execution. Used to test e.g.
    out of memory or query being killed conditions.
  */
  DBUG_EXECUTE_IF("subselect_exec_fail", return 1;);
unknown's avatar
unknown committed
260

261
  res= engine->exec();
unknown's avatar
unknown committed
262

263 264 265
  if (engine_changed)
  {
    engine_changed= 0;
266
    return exec();
267 268
  }
  return (res);
269 270
}

271
Item::Type Item_subselect::type() const
272 273 274 275
{
  return SUBSELECT_ITEM;
}

unknown's avatar
unknown committed
276

277 278
void Item_subselect::fix_length_and_dec()
{
279
  engine->fix_length_and_dec(0);
280
}
unknown's avatar
unknown committed
281

unknown's avatar
unknown committed
282

283
table_map Item_subselect::used_tables() const
unknown's avatar
unknown committed
284
{
285
  return (table_map) (engine->uncacheable() ? used_tables_cache : 0L);
unknown's avatar
unknown committed
286 287
}

unknown's avatar
merge  
unknown committed
288

289 290
bool Item_subselect::const_item() const
{
unknown's avatar
unknown committed
291
  return const_item_cache;
292 293
}

294
Item *Item_subselect::get_tmp_table_item(THD *thd_arg)
unknown's avatar
unknown committed
295 296
{
  if (!with_sum_func && !const_item())
unknown's avatar
unknown committed
297
    return new Item_field(result_field);
298
  return copy_or_same(thd_arg);
unknown's avatar
unknown committed
299
}
unknown's avatar
merge  
unknown committed
300

301 302 303 304
void Item_subselect::update_used_tables()
{
  if (!engine->uncacheable())
  {
unknown's avatar
unknown committed
305
    // did all used tables become static?
unknown's avatar
unknown committed
306
    if (!(used_tables_cache & ~engine->upper_select_const_tables()))
307 308 309 310
      const_item_cache= 1;
  }
}

unknown's avatar
unknown committed
311

312
void Item_subselect::print(String *str, enum_query_type query_type)
unknown's avatar
unknown committed
313
{
314 315 316 317 318 319 320 321
  if (engine)
  {
    str->append('(');
    engine->print(str, query_type);
    str->append(')');
  }
  else
    str->append("(...)");
unknown's avatar
unknown committed
322 323 324
}


unknown's avatar
merge  
unknown committed
325
Item_singlerow_subselect::Item_singlerow_subselect(st_select_lex *select_lex)
326
  :Item_subselect(), value(0)
unknown's avatar
unknown committed
327
{
unknown's avatar
unknown committed
328
  DBUG_ENTER("Item_singlerow_subselect::Item_singlerow_subselect");
329
  init(select_lex, new select_singlerow_subselect(this));
unknown's avatar
unknown committed
330
  maybe_null= 1;
331
  max_columns= UINT_MAX;
unknown's avatar
unknown committed
332
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
333 334
}

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
st_select_lex *
Item_singlerow_subselect::invalidate_and_restore_select_lex()
{
  DBUG_ENTER("Item_singlerow_subselect::invalidate_and_restore_select_lex");
  st_select_lex *result= get_select_lex();

  DBUG_ASSERT(result);

  /*
    This code restore the parse tree in it's state before the execution of
    Item_singlerow_subselect::Item_singlerow_subselect(),
    and in particular decouples this object from the SELECT_LEX,
    so that the SELECT_LEX can be used with a different flavor
    or Item_subselect instead, as part of query rewriting.
  */
  unit->item= NULL;

  DBUG_RETURN(result);
}

unknown's avatar
unknown committed
355 356
Item_maxmin_subselect::Item_maxmin_subselect(THD *thd_param,
                                             Item_subselect *parent,
357
					     st_select_lex *select_lex,
unknown's avatar
unknown committed
358
					     bool max_arg)
359
  :Item_singlerow_subselect(), was_values(TRUE)
360 361
{
  DBUG_ENTER("Item_maxmin_subselect::Item_maxmin_subselect");
unknown's avatar
unknown committed
362 363
  max= max_arg;
  init(select_lex, new select_max_min_finder_subselect(this, max_arg));
364 365 366
  max_columns= 1;
  maybe_null= 1;
  max_columns= 1;
367 368 369 370 371 372 373

  /*
    Following information was collected during performing fix_fields()
    of Items belonged to subquery, which will be not repeated
  */
  used_tables_cache= parent->get_used_tables_cache();
  const_item_cache= parent->get_const_item_cache();
374

unknown's avatar
unknown committed
375
  /*
unknown's avatar
unknown committed
376
    this subquery always creates during preparation, so we can assign
unknown's avatar
unknown committed
377 378 379 380
    thd here
  */
  thd= thd_param;

381 382 383
  DBUG_VOID_RETURN;
}

384 385
void Item_maxmin_subselect::cleanup()
{
unknown's avatar
unknown committed
386 387 388
  DBUG_ENTER("Item_maxmin_subselect::cleanup");
  Item_singlerow_subselect::cleanup();

389
  /*
unknown's avatar
unknown committed
390
    By default it is TRUE to avoid TRUE reporting by
391 392 393
    Item_func_not_all/Item_func_nop_all if this item was never called.

    Engine exec() set it to FALSE by reset_value_registration() call.
unknown's avatar
unknown committed
394 395
    select_max_min_finder_subselect::send_data() set it back to TRUE if some
    value will be found.
396 397
  */
  was_values= TRUE;
unknown's avatar
unknown committed
398
  DBUG_VOID_RETURN;
399 400 401
}


402
void Item_maxmin_subselect::print(String *str, enum_query_type query_type)
unknown's avatar
unknown committed
403
{
404
  str->append(max?"<max>":"<min>", 5);
405
  Item_singlerow_subselect::print(str, query_type);
unknown's avatar
unknown committed
406 407
}

408

unknown's avatar
unknown committed
409
void Item_singlerow_subselect::reset()
410
{
411 412 413
  null_value= 1;
  if (value)
    value->null_value= 1;
414 415
}

416

unknown's avatar
unknown committed
417 418 419 420 421 422 423 424 425 426
/**
  @todo
  - 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.
  - switch off this optimization for prepare statement,
  because we do not rollback this changes.
  Make rollback for it, or special name resolving mode in 5.0.
*/
427
Item_subselect::trans_res
unknown's avatar
unknown committed
428
Item_singlerow_subselect::select_transformer(JOIN *join)
429
{
unknown's avatar
unknown committed
430 431
  if (changed)
    return RES_OK;
432

433
  SELECT_LEX *select_lex= join->select_lex;
unknown's avatar
unknown committed
434
  Query_arena *arena= thd->stmt_arena;
unknown's avatar
unknown committed
435
 
436
  if (!select_lex->master_unit()->is_union() &&
437
      !select_lex->table_list.elements &&
unknown's avatar
unknown committed
438
      select_lex->item_list.elements == 1 &&
439
      !select_lex->item_list.head()->with_sum_func &&
unknown's avatar
unknown committed
440 441 442 443 444 445 446
      /*
	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
447
      !(select_lex->item_list.head()->type() == FIELD_ITEM ||
448
	select_lex->item_list.head()->type() == REF_ITEM) &&
449
      !join->conds && !join->having &&
450
      /*
unknown's avatar
unknown committed
451
        switch off this optimization for prepare statement,
452 453 454
        because we do not rollback this changes
        TODO: make rollback for it, or special name resolving mode in 5.0.
      */
455
      !arena->is_stmt_prepare_or_first_sp_execute()
unknown's avatar
unknown committed
456
      )
457
  {
458

459
    have_to_be_excluded= 1;
unknown's avatar
unknown committed
460
    if (thd->lex->describe)
461 462 463
    {
      char warn_buff[MYSQL_ERRMSG_SIZE];
      sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number);
unknown's avatar
unknown committed
464
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
465 466 467
		   ER_SELECT_REDUCED, warn_buff);
    }
    substitution= select_lex->item_list.head();
unknown's avatar
unknown committed
468
    /*
unknown's avatar
unknown committed
469
      as far as we moved content to upper level, field which depend of
unknown's avatar
unknown committed
470 471
      'upper' select is not really dependent => we remove this dependence
    */
472
    substitution->walk(&Item::remove_dependence_processor, 0,
473
		       (uchar *) select_lex->outer_select());
474
    return RES_REDUCE;
475
  }
476
  return RES_OK;
477 478
}

unknown's avatar
unknown committed
479

unknown's avatar
unknown committed
480
void Item_singlerow_subselect::store(uint i, Item *item)
unknown's avatar
unknown committed
481
{
482
  row[i]->store(item);
unknown's avatar
unknown committed
483 484
}

unknown's avatar
unknown committed
485
enum Item_result Item_singlerow_subselect::result_type() const
unknown's avatar
unknown committed
486
{
487 488 489
  return engine->type();
}

490 491 492 493 494 495 496 497 498
/* 
 Don't rely on the result type to calculate field type. 
 Ask the engine instead.
*/
enum_field_types Item_singlerow_subselect::field_type() const
{
  return engine->field_type();
}

unknown's avatar
unknown committed
499
void Item_singlerow_subselect::fix_length_and_dec()
500
{
501 502 503 504 505
  if ((max_columns= engine->cols()) == 1)
  {
    engine->fix_length_and_dec(row= &value);
  }
  else
506
  {
507
    if (!(row= (Item_cache**) sql_alloc(sizeof(Item_cache*)*max_columns)))
508 509 510
      return;
    engine->fix_length_and_dec(row);
    value= *row;
511
  }
512
  unsigned_flag= value->unsigned_flag;
513 514 515 516 517 518 519
  /*
    If there are not tables in subquery then ability to have NULL value
    depends on SELECT list (if single row subquery have tables then it
    always can be NULL if there are not records fetched).
  */
  if (engine->no_tables())
    maybe_null= engine->may_be_null();
520 521
}

unknown's avatar
unknown committed
522
uint Item_singlerow_subselect::cols()
unknown's avatar
unknown committed
523
{
524 525 526
  return engine->cols();
}

unknown's avatar
unknown committed
527
bool Item_singlerow_subselect::check_cols(uint c)
528 529 530
{
  if (c != engine->cols())
  {
unknown's avatar
unknown committed
531
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
532 533 534 535 536
    return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
537
bool Item_singlerow_subselect::null_inside()
538 539 540 541 542 543 544 545 546
{
  for (uint i= 0; i < max_columns ; i++)
  {
    if (row[i]->null_value)
      return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
547
void Item_singlerow_subselect::bring_value()
548
{
549
  exec();
unknown's avatar
unknown committed
550 551
}

552
double Item_singlerow_subselect::val_real()
unknown's avatar
unknown committed
553
{
554
  DBUG_ASSERT(fixed == 1);
555
  if (!exec() && !value->null_value)
556 557
  {
    null_value= 0;
558
    return value->val_real();
559 560
  }
  else
unknown's avatar
unknown committed
561
  {
562
    reset();
unknown's avatar
unknown committed
563
    return 0;
unknown's avatar
unknown committed
564
  }
unknown's avatar
unknown committed
565 566
}

567
longlong Item_singlerow_subselect::val_int()
unknown's avatar
unknown committed
568
{
569
  DBUG_ASSERT(fixed == 1);
570
  if (!exec() && !value->null_value)
571 572 573 574 575
  {
    null_value= 0;
    return value->val_int();
  }
  else
unknown's avatar
unknown committed
576
  {
577
    reset();
unknown's avatar
unknown committed
578
    return 0;
unknown's avatar
unknown committed
579
  }
unknown's avatar
unknown committed
580 581
}

unknown's avatar
unknown committed
582
String *Item_singlerow_subselect::val_str(String *str)
unknown's avatar
unknown committed
583
{
584
  if (!exec() && !value->null_value)
585 586 587 588 589
  {
    null_value= 0;
    return value->val_str(str);
  }
  else
unknown's avatar
unknown committed
590
  {
591
    reset();
unknown's avatar
unknown committed
592
    return 0;
unknown's avatar
unknown committed
593
  }
unknown's avatar
unknown committed
594 595
}

unknown's avatar
unknown committed
596

unknown's avatar
unknown committed
597 598
my_decimal *Item_singlerow_subselect::val_decimal(my_decimal *decimal_value)
{
599
  if (!exec() && !value->null_value)
unknown's avatar
unknown committed
600 601 602 603 604 605 606 607 608 609 610 611 612 613
  {
    null_value= 0;
    return value->val_decimal(decimal_value);
  }
  else
  {
    reset();
    return 0;
  }
}


bool Item_singlerow_subselect::val_bool()
{
614
  if (!exec() && !value->null_value)
unknown's avatar
unknown committed
615 616 617 618 619 620 621 622 623 624 625 626
  {
    null_value= 0;
    return value->val_bool();
  }
  else
  {
    reset();
    return 0;
  }
}


627
Item_exists_subselect::Item_exists_subselect(st_select_lex *select_lex):
628
  Item_subselect()
unknown's avatar
unknown committed
629
{
unknown's avatar
unknown committed
630
  DBUG_ENTER("Item_exists_subselect::Item_exists_subselect");
unknown's avatar
unknown committed
631
  bool val_bool();
632
  init(select_lex, new select_exists_subselect(this));
unknown's avatar
unknown committed
633 634 635 636
  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
637 638 639
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
640

641
void Item_exists_subselect::print(String *str, enum_query_type query_type)
unknown's avatar
unknown committed
642
{
643
  str->append(STRING_WITH_LEN("exists"));
644
  Item_subselect::print(str, query_type);
unknown's avatar
unknown committed
645 646 647
}


unknown's avatar
unknown committed
648
bool Item_in_subselect::test_limit(st_select_lex_unit *unit_arg)
649
{
650 651
  if (unit_arg->fake_select_lex &&
      unit_arg->fake_select_lex->test_limit())
652
    return(1);
unknown's avatar
unknown committed
653

654
  SELECT_LEX *sl= unit_arg->first_select();
655 656
  for (; sl; sl= sl->next_select())
  {
unknown's avatar
unknown committed
657
    if (sl->test_limit())
658 659 660 661 662
      return(1);
  }
  return(0);
}

663
Item_in_subselect::Item_in_subselect(Item * left_exp,
unknown's avatar
unknown committed
664
				     st_select_lex *select_lex):
665
  Item_exists_subselect(), optimizer(0), transformed(0),
666
  pushed_cond_guards(NULL), upper_item(0)
unknown's avatar
unknown committed
667 668
{
  DBUG_ENTER("Item_in_subselect::Item_in_subselect");
unknown's avatar
unknown committed
669
  left_expr= left_exp;
670
  init(select_lex, new select_exists_subselect(this));
unknown's avatar
unknown committed
671
  max_columns= UINT_MAX;
672
  maybe_null= 1;
673
  abort_on_null= 0;
674
  reset();
unknown's avatar
unknown committed
675
  //if test_limit will fail then error will be reported to client
676
  test_limit(select_lex->master_unit());
unknown's avatar
unknown committed
677 678 679
  DBUG_VOID_RETURN;
}

680
Item_allany_subselect::Item_allany_subselect(Item * left_exp,
681
                                             chooser_compare_func_creator fc,
unknown's avatar
unknown committed
682 683
					     st_select_lex *select_lex,
					     bool all_arg)
unknown's avatar
unknown committed
684
  :Item_in_subselect(), func_creator(fc), all(all_arg)
unknown's avatar
unknown committed
685 686 687
{
  DBUG_ENTER("Item_in_subselect::Item_in_subselect");
  left_expr= left_exp;
688
  func= func_creator(all_arg);
689
  init(select_lex, new select_exists_subselect(this));
unknown's avatar
unknown committed
690
  max_columns= 1;
691
  abort_on_null= 0;
692
  reset();
unknown's avatar
unknown committed
693
  //if test_limit will fail then error will be reported to client
694
  test_limit(select_lex->master_unit());
unknown's avatar
unknown committed
695
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
696 697
}

unknown's avatar
unknown committed
698

699 700
void Item_exists_subselect::fix_length_and_dec()
{
701
   decimals= 0;
702
   max_length= 1;
unknown's avatar
unknown committed
703
   max_columns= engine->cols();
704
  /* We need only 1 row to determine existence */
705
  unit->global_parameters->select_limit= new Item_int((int32) 1);
706 707
}

708
double Item_exists_subselect::val_real()
unknown's avatar
unknown committed
709
{
710
  DBUG_ASSERT(fixed == 1);
711
  if (exec())
unknown's avatar
unknown committed
712
  {
713
    reset();
unknown's avatar
unknown committed
714
    return 0;
unknown's avatar
unknown committed
715
  }
unknown's avatar
unknown committed
716 717 718
  return (double) value;
}

719
longlong Item_exists_subselect::val_int()
unknown's avatar
unknown committed
720
{
721
  DBUG_ASSERT(fixed == 1);
722
  if (exec())
unknown's avatar
unknown committed
723
  {
724
    reset();
unknown's avatar
unknown committed
725
    return 0;
unknown's avatar
unknown committed
726
  }
unknown's avatar
unknown committed
727 728 729
  return value;
}

730 731 732 733 734 735 736 737 738 739 740 741 742 743

/**
  Return the result of EXISTS as a string value

  Converts the true/false result into a string value.
  Note that currently this cannot be NULL, so if the query exection fails
  it will return 0.

  @param decimal_value[out]    buffer to hold the resulting string value
  @retval                      Pointer to the converted string.
                               Can't be a NULL pointer, as currently
                               EXISTS cannot return NULL.
*/

unknown's avatar
unknown committed
744 745
String *Item_exists_subselect::val_str(String *str)
{
746
  DBUG_ASSERT(fixed == 1);
747
  if (exec())
748
    reset();
unknown's avatar
unknown committed
749
  str->set((ulonglong)value,&my_charset_bin);
750 751 752
  return str;
}

unknown's avatar
unknown committed
753

754 755 756 757 758 759 760 761 762 763 764 765 766
/**
  Return the result of EXISTS as a decimal value

  Converts the true/false result into a decimal value.
  Note that currently this cannot be NULL, so if the query exection fails
  it will return 0.

  @param decimal_value[out]    Buffer to hold the resulting decimal value
  @retval                      Pointer to the converted decimal.
                               Can't be a NULL pointer, as currently
                               EXISTS cannot return NULL.
*/

unknown's avatar
unknown committed
767 768 769
my_decimal *Item_exists_subselect::val_decimal(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed == 1);
770
  if (exec())
unknown's avatar
unknown committed
771 772 773 774 775 776 777 778 779
    reset();
  int2my_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
  return decimal_value;
}


bool Item_exists_subselect::val_bool()
{
  DBUG_ASSERT(fixed == 1);
780
  if (exec())
unknown's avatar
unknown committed
781 782 783 784
  {
    reset();
    return 0;
  }
785
  return value != 0;
unknown's avatar
unknown committed
786 787 788
}


789
double Item_in_subselect::val_real()
790
{
unknown's avatar
unknown committed
791 792 793 794 795
  /*
    As far as Item_in_subselect called only from Item_in_optimizer this
    method should not be used
  */
  DBUG_ASSERT(0);
796
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
797
  null_value= 0;
798
  if (exec())
799 800 801 802 803 804 805 806 807 808
  {
    reset();
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
    null_value= 1;
  return (double) value;
}

unknown's avatar
unknown committed
809

810
longlong Item_in_subselect::val_int()
811
{
unknown's avatar
unknown committed
812 813 814 815 816
  /*
    As far as Item_in_subselect called only from Item_in_optimizer this
    method should not be used
  */
  DBUG_ASSERT(0);
817
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
818
  null_value= 0;
819
  if (exec())
820 821 822 823 824 825 826 827 828 829
  {
    reset();
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
    null_value= 1;
  return value;
}

unknown's avatar
unknown committed
830

831 832
String *Item_in_subselect::val_str(String *str)
{
unknown's avatar
unknown committed
833 834 835 836 837
  /*
    As far as Item_in_subselect called only from Item_in_optimizer this
    method should not be used
  */
  DBUG_ASSERT(0);
838
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
839
  null_value= 0;
840
  if (exec())
841 842 843 844 845 846 847 848
  {
    reset();
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
  {
    null_value= 1;
unknown's avatar
unknown committed
849
    return 0;
unknown's avatar
unknown committed
850
  }
unknown's avatar
unknown committed
851
  str->set((ulonglong)value, &my_charset_bin);
unknown's avatar
unknown committed
852 853 854
  return str;
}

unknown's avatar
unknown committed
855

unknown's avatar
unknown committed
856 857 858
bool Item_in_subselect::val_bool()
{
  DBUG_ASSERT(fixed == 1);
859
  null_value= 0;
860
  if (exec())
unknown's avatar
unknown committed
861 862
  {
    reset();
unknown's avatar
unknown committed
863 864 865 866 867
    /* 
      Must mark the IN predicate as NULL so as to make sure an enclosing NOT
      predicate will return FALSE. See the comments in 
      subselect_uniquesubquery_engine::copy_ref_key for further details.
    */
unknown's avatar
unknown committed
868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
    null_value= 1;
  return value;
}

my_decimal *Item_in_subselect::val_decimal(my_decimal *decimal_value)
{
  /*
    As far as Item_in_subselect called only from Item_in_optimizer this
    method should not be used
  */
  DBUG_ASSERT(0);
883
  null_value= 0;
unknown's avatar
unknown committed
884
  DBUG_ASSERT(fixed == 1);
885
  if (exec())
unknown's avatar
unknown committed
886 887 888 889 890 891 892 893 894 895 896 897
  {
    reset();
    null_value= 1;
    return 0;
  }
  if (was_null && !value)
    null_value= 1;
  int2my_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
  return decimal_value;
}


898 899 900 901 902
/* 
  Rewrite a single-column IN/ALL/ANY subselect

  SYNOPSIS
    Item_in_subselect::single_value_transformer()
903 904
      join  Join object of the subquery (i.e. 'child' join).
      func  Subquery comparison creator
905 906 907 908

  DESCRIPTION
    Rewrite a single-column subquery using rule-based approach. The subquery
    
909
       oe $cmp$ (SELECT ie FROM ... WHERE subq_where ... HAVING subq_having)
910 911 912 913 914
    
    First, try to convert the subquery to scalar-result subquery in one of
    the forms:
    
       - oe $cmp$ (SELECT MAX(...) )  // handled by Item_singlerow_subselect
915
       - oe $cmp$ <max>(SELECT ...)   // handled by Item_maxmin_subselect
916 917 918 919 920 921
   
    If that fails, the subquery will be handled with class Item_in_optimizer, 
    Inject the predicates into subquery, i.e. convert it to:

    - If the subquery has aggregates, GROUP BY, or HAVING, convert to

922
       SELECT ie FROM ...  HAVING subq_having AND 
923 924 925 926 927
                                   trigcond(oe $cmp$ ref_or_null_helper<ie>)
                                   
      the addition is wrapped into trigger only when we want to distinguish
      between NULL and FALSE results.

928 929
    - Otherwise (no aggregates/GROUP BY/HAVING) convert it to one of the
      following:
930

931 932 933
      = If we don't need to distinguish between NULL and FALSE subquery:
        
        SELECT 1 FROM ... WHERE (oe $cmp$ ie) AND subq_where
934

935 936 937 938 939
      = If we need to distinguish between those:

        SELECT 1 FROM ...
          WHERE  subq_where AND trigcond((oe $cmp$ ie) OR (ie IS NULL))
          HAVING trigcond(<is_not_null_test>(ie))
940 941

  RETURN
942 943
    RES_OK     - OK, either subquery was transformed, or appopriate
                 predicates where injected into it.
944 945 946
    RES_REDUCE - The subquery was reduced to non-subquery
    RES_ERROR  - Error
*/
947

948
Item_subselect::trans_res
unknown's avatar
unknown committed
949
Item_in_subselect::single_value_transformer(JOIN *join,
unknown's avatar
unknown committed
950
					    Comp_creator *func)
unknown's avatar
unknown committed
951
{
952
  SELECT_LEX *select_lex= join->select_lex;
953
  DBUG_ENTER("Item_in_subselect::single_value_transformer");
unknown's avatar
unknown committed
954

955 956 957 958
  /*
    Check that the right part of the subselect contains no more than one
    column. E.g. in SELECT 1 IN (SELECT * ..) the right part is (SELECT * ...)
  */
959 960 961
  if (select_lex->item_list.elements > 1)
  {
    my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
962
    DBUG_RETURN(RES_ERROR);
963 964
  }

965 966 967 968 969 970 971 972 973 974 975
  /*
    If this is an ALL/ANY single-value subselect, try to rewrite it with
    a MIN/MAX subselect. We can do that if a possible NULL result of the
    subselect can be ignored.
    E.g. SELECT * FROM t1 WHERE b > ANY (SELECT a FROM t2) can be rewritten
    with SELECT * FROM t1 WHERE b > (SELECT MAX(a) FROM t2).
    We can't check that this optimization is safe if it's not a top-level
    item of the WHERE clause (e.g. because the WHERE clause can contain IS
    NULL/IS NOT NULL functions). If so, we rewrite ALL/ANY with NOT EXISTS
    later in this method.
  */
976
  if ((abort_on_null || (upper_item && upper_item->top_level())) &&
977
      !select_lex->master_unit()->uncacheable && !func->eqne_op())
978
  {
979 980 981
    if (substitution)
    {
      // It is second (third, ...) SELECT of UNION => All is done
982
      DBUG_RETURN(RES_OK);
983 984
    }

985 986
    Item *subs;
    if (!select_lex->group_list.elements &&
unknown's avatar
unknown committed
987
        !select_lex->having &&
988
	!select_lex->with_sum_func &&
989 990
	!(select_lex->next_select()) &&
        select_lex->table_list.elements)
991
    {
992
      Item_sum_hybrid *item;
unknown's avatar
unknown committed
993
      nesting_map save_allow_sum_func;
unknown's avatar
unknown committed
994
      if (func->l_op())
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
      {
	/*
	  (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);
      }
1010 1011
      if (upper_item)
        upper_item->set_sum_test(item);
1012
      *select_lex->ref_pointer_array= item;
1013 1014 1015 1016 1017
      {
	List_iterator<Item> it(select_lex->item_list);
	it++;
	it.replace(item);
      }
unknown's avatar
merge  
unknown committed
1018

unknown's avatar
unknown committed
1019 1020
      save_allow_sum_func= thd->lex->allow_sum_func;
      thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
1021 1022
      /*
	Item_sum_(max|min) can't substitute other item => we can use 0 as
unknown's avatar
unknown committed
1023 1024
        reference, also Item_sum_(max|min) can't be fixed after creation, so
        we do not check item->fixed
1025
      */
1026
      if (item->fix_fields(thd, 0))
1027
	DBUG_RETURN(RES_ERROR);
unknown's avatar
unknown committed
1028
      thd->lex->allow_sum_func= save_allow_sum_func; 
1029
      /* we added aggregate function => we have to change statistic */
1030 1031
      count_field_types(select_lex, &join->tmp_table_param, join->all_fields, 
                        0);
unknown's avatar
unknown committed
1032

unknown's avatar
unknown committed
1033
      subs= new Item_singlerow_subselect(select_lex);
1034 1035 1036
    }
    else
    {
1037
      Item_maxmin_subselect *item;
unknown's avatar
unknown committed
1038
      subs= item= new Item_maxmin_subselect(thd, this, select_lex, func->l_op());
1039 1040
      if (upper_item)
        upper_item->set_sub_test(item);
1041
    }
1042
    /* fix fields is already called for  left expression */
unknown's avatar
unknown committed
1043
    substitution= func->create(left_expr, subs);
1044
    DBUG_RETURN(RES_OK);
1045 1046
  }

1047
  if (!substitution)
unknown's avatar
unknown committed
1048
  {
1049
    /* We're invoked for the 1st (or the only) SELECT in the subquery UNION */
1050
    SELECT_LEX_UNIT *master_unit= select_lex->master_unit();
1051
    substitution= optimizer;
1052

unknown's avatar
unknown committed
1053
    SELECT_LEX *current= thd->lex->current_select, *up;
unknown's avatar
unknown committed
1054

unknown's avatar
unknown committed
1055
    thd->lex->current_select= up= current->return_after_parsing();
1056
    //optimizer never use Item **ref => we can pass 0 as parameter
1057
    if (!optimizer || optimizer->fix_left(thd, 0))
1058
    {
unknown's avatar
unknown committed
1059
      thd->lex->current_select= current;
1060
      DBUG_RETURN(RES_ERROR);
1061
    }
unknown's avatar
unknown committed
1062
    thd->lex->current_select= current;
1063

1064
    /*
unknown's avatar
unknown committed
1065
      As far as  Item_ref_in_optimizer do not substitute itself on fix_fields
1066 1067
      we can use same item for all selects.
    */
1068 1069
    expr= new Item_direct_ref(&select_lex->context,
                              (Item**)optimizer->get_cache(),
1070 1071
			      (char *)"<no matter>",
			      (char *)in_left_expr_name);
1072

1073
    master_unit->uncacheable|= UNCACHEABLE_DEPENDENT;
1074
  }
1075
  if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
1076 1077 1078 1079
  {
    if (!(pushed_cond_guards= (bool*)join->thd->alloc(sizeof(bool))))
      DBUG_RETURN(RES_ERROR);
    pushed_cond_guards[0]= TRUE;
1080
  }
1081

1082
  select_lex->uncacheable|= UNCACHEABLE_DEPENDENT;
1083 1084 1085
  if (join->having || select_lex->with_sum_func ||
      select_lex->group_list.elements)
  {
unknown's avatar
unknown committed
1086 1087
    bool tmp;
    Item *item= func->create(expr,
1088 1089
                             new Item_ref_null_helper(&select_lex->context,
                                                      this,
unknown's avatar
unknown committed
1090 1091 1092 1093
                                                      select_lex->
                                                      ref_pointer_array,
                                                      (char *)"<ref>",
                                                      this->full_name()));
1094
    if (!abort_on_null && left_expr->maybe_null)
1095 1096 1097
    {
      /* 
        We can encounter "NULL IN (SELECT ...)". Wrap the added condition
1098
        within a trig_cond.
1099
      */
1100
      item= new Item_func_trig_cond(item, get_cond_guard(0));
1101 1102
    }
    
1103 1104 1105 1106 1107
    /*
      AND and comparison functions can't be changed during fix_fields()
      we can assign select_lex->having here, and pass 0 as last
      argument (reference) to fix_fields()
    */
unknown's avatar
unknown committed
1108
    select_lex->having= join->having= and_items(join->having, item);
1109 1110
    if (join->having == item)
      item->name= (char*)in_having_cond;
1111
    select_lex->having_fix_field= 1;
unknown's avatar
unknown committed
1112 1113 1114 1115
    /*
      we do not check join->having->fixed, because Item_and (from and_items)
      or comparison function (from func->create) can't be fixed after creation
    */
1116
    tmp= join->having->fix_fields(thd, 0);
1117
    select_lex->having_fix_field= 0;
unknown's avatar
unknown committed
1118
    if (tmp)
unknown's avatar
unknown committed
1119
      DBUG_RETURN(RES_ERROR);
1120 1121 1122
  }
  else
  {
unknown's avatar
unknown committed
1123 1124
    Item *item= (Item*) select_lex->item_list.head();

1125
    if (select_lex->table_list.elements)
1126
    {
unknown's avatar
unknown committed
1127
      bool tmp;
1128
      Item *having= item, *orig_item= item;
1129 1130
      select_lex->item_list.empty();
      select_lex->item_list.push_back(new Item_int("Not_used",
1131 1132
                                                   (longlong) 1,
                                                   MY_INT64_NUM_DECIMAL_DIGITS));
1133
      select_lex->ref_pointer_array[0]= select_lex->item_list.head();
1134
       
unknown's avatar
unknown committed
1135
      item= func->create(expr, item);
1136
      if (!abort_on_null && orig_item->maybe_null)
unknown's avatar
unknown committed
1137
      {
1138 1139 1140 1141
	having= new Item_is_not_null_test(this, having);
        if (left_expr->maybe_null)
        {
          if (!(having= new Item_func_trig_cond(having,
1142
                                                get_cond_guard(0))))
1143 1144
            DBUG_RETURN(RES_ERROR);
        }
1145 1146 1147 1148 1149
	/*
	  Item_is_not_null_test can't be changed during fix_fields()
	  we can assign select_lex->having here, and pass 0 as last
	  argument (reference) to fix_fields()
	*/
1150
        having->name= (char*)in_having_cond;
1151
	select_lex->having= join->having= having;
1152
	select_lex->having_fix_field= 1;
unknown's avatar
unknown committed
1153 1154 1155 1156 1157
        /*
          we do not check join->having->fixed, because Item_and (from
          and_items) or comparison function (from func->create) can't be
          fixed after creation
        */
1158
	tmp= join->having->fix_fields(thd, 0);
unknown's avatar
unknown committed
1159 1160
        select_lex->having_fix_field= 0;
        if (tmp)
1161
	  DBUG_RETURN(RES_ERROR);
1162
	item= new Item_cond_or(item,
1163
			       new Item_func_isnull(orig_item));
1164
      }
1165
      /* 
1166 1167
        If we may encounter NULL IN (SELECT ...) and care whether subquery
        result is NULL or FALSE, wrap condition in a trig_cond.
1168 1169 1170
      */
      if (!abort_on_null && left_expr->maybe_null)
      {
1171
        if (!(item= new Item_func_trig_cond(item, get_cond_guard(0))))
1172 1173
          DBUG_RETURN(RES_ERROR);
      }
1174 1175 1176 1177 1178
      /*
        TODO: figure out why the following is done here in 
        single_value_transformer but there is no corresponding action in
        row_value_transformer?
      */
1179
      item->name= (char *)in_additional_cond;
1180

1181 1182 1183 1184 1185
      /*
	AND can't be changed during fix_fields()
	we can assign select_lex->having here, and pass 0 as last
	argument (reference) to fix_fields()
      */
unknown's avatar
unknown committed
1186
      select_lex->where= join->conds= and_items(join->conds, item);
1187
      select_lex->where->top_level_item();
unknown's avatar
unknown committed
1188 1189 1190 1191
      /*
        we do not check join->conds->fixed, because Item_and can't be fixed
        after creation
      */
1192
      if (join->conds->fix_fields(thd, 0))
1193
	DBUG_RETURN(RES_ERROR);
1194 1195 1196
    }
    else
    {
unknown's avatar
unknown committed
1197
      bool tmp;
1198
      if (select_lex->master_unit()->is_union())
1199
      {
1200 1201 1202 1203 1204
	/*
	  comparison functions can't be changed during fix_fields()
	  we can assign select_lex->having here, and pass 0 as last
	  argument (reference) to fix_fields()
	*/
1205 1206
        Item *new_having=
          func->create(expr,
1207
                       new Item_ref_null_helper(&select_lex->context, this,
1208 1209 1210
                                            select_lex->ref_pointer_array,
                                            (char *)"<no matter>",
                                            (char *)"<result>"));
1211 1212 1213
        if (!abort_on_null && left_expr->maybe_null)
        {
          if (!(new_having= new Item_func_trig_cond(new_having,
1214
                                                    get_cond_guard(0))))
1215 1216
            DBUG_RETURN(RES_ERROR);
        }
1217
        new_having->name= (char*)in_having_cond;
1218
	select_lex->having= join->having= new_having;
1219
	select_lex->having_fix_field= 1;
1220
        
unknown's avatar
unknown committed
1221 1222 1223 1224
        /*
          we do not check join->having->fixed, because comparison function
          (from func->create) can't be fixed after creation
        */
1225
	tmp= join->having->fix_fields(thd, 0);
unknown's avatar
unknown committed
1226 1227
        select_lex->having_fix_field= 0;
        if (tmp)
1228
	  DBUG_RETURN(RES_ERROR);
1229 1230 1231 1232
      }
      else
      {
	// it is single select without tables => possible optimization
1233 1234
        // remove the dependence mark since the item is moved to upper
        // select and is not outer anymore.
1235 1236
        item->walk(&Item::remove_dependence_processor, 0,
                           (uchar *) select_lex->outer_select());
unknown's avatar
unknown committed
1237
	item= func->create(left_expr, item);
unknown's avatar
unknown committed
1238
	// fix_field of item will be done in time of substituting
1239 1240
	substitution= item;
	have_to_be_excluded= 1;
unknown's avatar
unknown committed
1241
	if (thd->lex->describe)
unknown's avatar
unknown committed
1242
	{
1243 1244
	  char warn_buff[MYSQL_ERRMSG_SIZE];
	  sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number);
unknown's avatar
unknown committed
1245
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
1246
		       ER_SELECT_REDUCED, warn_buff);
unknown's avatar
unknown committed
1247
	}
1248
	DBUG_RETURN(RES_REDUCE);
unknown's avatar
unknown committed
1249
      }
1250
    }
unknown's avatar
unknown committed
1251
  }
unknown's avatar
unknown committed
1252

1253
  DBUG_RETURN(RES_OK);
unknown's avatar
unknown committed
1254
}
unknown's avatar
unknown committed
1255

1256

1257
Item_subselect::trans_res
unknown's avatar
unknown committed
1258
Item_in_subselect::row_value_transformer(JOIN *join)
unknown's avatar
unknown committed
1259
{
unknown's avatar
unknown committed
1260
  SELECT_LEX *select_lex= join->select_lex;
1261 1262 1263 1264 1265
  Item *having_item= 0;
  uint cols_num= left_expr->cols();
  bool is_having_used= (join->having || select_lex->with_sum_func ||
                        select_lex->group_list.first ||
                        !select_lex->table_list.elements);
unknown's avatar
unknown committed
1266
  DBUG_ENTER("Item_in_subselect::row_value_transformer");
unknown's avatar
unknown committed
1267

1268 1269 1270
  if (select_lex->item_list.elements != left_expr->cols())
  {
    my_error(ER_OPERAND_COLUMNS, MYF(0), left_expr->cols());
1271
    DBUG_RETURN(RES_ERROR);
1272 1273
  }

1274
  if (!substitution)
unknown's avatar
unknown committed
1275
  {
1276
    //first call for this unit
1277
    SELECT_LEX_UNIT *master_unit= select_lex->master_unit();
1278
    substitution= optimizer;
1279

unknown's avatar
unknown committed
1280 1281
    SELECT_LEX *current= thd->lex->current_select, *up;
    thd->lex->current_select= up= current->return_after_parsing();
1282
    //optimizer never use Item **ref => we can pass 0 as parameter
1283
    if (!optimizer || optimizer->fix_left(thd, 0))
1284
    {
unknown's avatar
unknown committed
1285
      thd->lex->current_select= current;
1286
      DBUG_RETURN(RES_ERROR);
1287
    }
1288

unknown's avatar
unknown committed
1289
    // we will refer to upper level cache array => we have to save it in PS
1290 1291
    optimizer->keep_top_level_cache();

unknown's avatar
unknown committed
1292
    thd->lex->current_select= current;
1293
    master_unit->uncacheable|= UNCACHEABLE_DEPENDENT;
1294

1295
    if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
1296 1297 1298 1299 1300 1301 1302
    {
      if (!(pushed_cond_guards= (bool*)join->thd->alloc(sizeof(bool) *
                                                        left_expr->cols())))
        DBUG_RETURN(RES_ERROR);
      for (uint i= 0; i < cols_num; i++)
        pushed_cond_guards[i]= TRUE;
    }
1303 1304
  }

1305
  select_lex->uncacheable|= UNCACHEABLE_DEPENDENT;
1306
  if (is_having_used)
unknown's avatar
unknown committed
1307
  {
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
    /*
      (l1, l2, l3) IN (SELECT v1, v2, v3 ... HAVING having) =>
      EXISTS (SELECT ... HAVING having and
                                (l1 = v1 or is null v1) and
                                (l2 = v2 or is null v2) and
                                (l3 = v3 or is null v3) and
                                is_not_null_test(v1) and
                                is_not_null_test(v2) and
                                is_not_null_test(v3))
      where is_not_null_test used to register nulls in case if we have
      not found matching to return correct NULL value
1319
      TODO: say here explicitly if the order of AND parts matters or not.
1320 1321 1322
    */
    Item *item_having_part2= 0;
    for (uint i= 0; i < cols_num; i++)
unknown's avatar
unknown committed
1323
    {
1324 1325
      DBUG_ASSERT((left_expr->fixed &&
                  select_lex->ref_pointer_array[i]->fixed) ||
unknown's avatar
unknown committed
1326 1327 1328
                  (select_lex->ref_pointer_array[i]->type() == REF_ITEM &&
                   ((Item_ref*)(select_lex->ref_pointer_array[i]))->ref_type() ==
                    Item_ref::OUTER_REF));
1329
      if (select_lex->ref_pointer_array[i]->
1330
          check_cols(left_expr->element_index(i)->cols()))
1331
        DBUG_RETURN(RES_ERROR);
1332 1333
      Item *item_eq=
        new Item_func_eq(new
unknown's avatar
unknown committed
1334 1335 1336 1337 1338
                         Item_ref(&select_lex->context,
                                  (*optimizer->get_cache())->
                                  addr(i),
                                  (char *)"<no matter>",
                                  (char *)in_left_expr_name),
1339
                         new
unknown's avatar
unknown committed
1340 1341 1342 1343
                         Item_ref(&select_lex->context,
                                  select_lex->ref_pointer_array + i,
                                  (char *)"<no matter>",
                                  (char *)"<list ref>")
1344 1345 1346
                        );
      Item *item_isnull=
        new Item_func_isnull(new
unknown's avatar
unknown committed
1347 1348 1349 1350
                             Item_ref(&select_lex->context,
                                      select_lex->ref_pointer_array+i,
                                      (char *)"<no matter>",
                                      (char *)"<list ref>")
1351
                            );
1352
      Item *col_item= new Item_cond_or(item_eq, item_isnull);
unknown's avatar
unknown committed
1353
      if (!abort_on_null && left_expr->element_index(i)->maybe_null)
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
      {
        if (!(col_item= new Item_func_trig_cond(col_item, get_cond_guard(i))))
          DBUG_RETURN(RES_ERROR);
      }
      having_item= and_items(having_item, col_item);
      
      Item *item_nnull_test= 
         new Item_is_not_null_test(this,
                                   new Item_ref(&select_lex->context,
                                                select_lex->
                                                ref_pointer_array + i,
                                                (char *)"<no matter>",
                                                (char *)"<list ref>"));
unknown's avatar
unknown committed
1367
      if (!abort_on_null && left_expr->element_index(i)->maybe_null)
1368 1369 1370 1371 1372 1373
      {
        if (!(item_nnull_test= 
              new Item_func_trig_cond(item_nnull_test, get_cond_guard(i))))
          DBUG_RETURN(RES_ERROR);
      }
      item_having_part2= and_items(item_having_part2, item_nnull_test);
1374
      item_having_part2->top_level_item();
unknown's avatar
unknown committed
1375
    }
1376 1377
    having_item= and_items(having_item, item_having_part2);
    having_item->top_level_item();
1378
  }
1379
  else
1380
  {
1381
    /*
1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
      (l1, l2, l3) IN (SELECT v1, v2, v3 ... WHERE where) =>
      EXISTS (SELECT ... WHERE where and
                               (l1 = v1 or is null v1) and
                               (l2 = v2 or is null v2) and
                               (l3 = v3 or is null v3)
                         HAVING is_not_null_test(v1) and
                                is_not_null_test(v2) and
                                is_not_null_test(v3))
      where is_not_null_test register NULLs values but reject rows

      in case when we do not need correct NULL, we have simplier construction:
      EXISTS (SELECT ... WHERE where and
                               (l1 = v1) and
                               (l2 = v2) and
                               (l3 = v3)
1397
    */
1398 1399 1400 1401
    Item *where_item= 0;
    for (uint i= 0; i < cols_num; i++)
    {
      Item *item, *item_isnull;
1402 1403
      DBUG_ASSERT((left_expr->fixed &&
                  select_lex->ref_pointer_array[i]->fixed) ||
unknown's avatar
unknown committed
1404 1405 1406
                  (select_lex->ref_pointer_array[i]->type() == REF_ITEM &&
                   ((Item_ref*)(select_lex->ref_pointer_array[i]))->ref_type() ==
                    Item_ref::OUTER_REF));
1407
      if (select_lex->ref_pointer_array[i]->
1408
          check_cols(left_expr->element_index(i)->cols()))
1409 1410 1411
        DBUG_RETURN(RES_ERROR);
      item=
        new Item_func_eq(new
unknown's avatar
unknown committed
1412 1413
                         Item_direct_ref(&select_lex->context,
                                         (*optimizer->get_cache())->
1414 1415 1416 1417
                                         addr(i),
                                         (char *)"<no matter>",
                                         (char *)in_left_expr_name),
                         new
unknown's avatar
unknown committed
1418 1419 1420 1421 1422
                         Item_direct_ref(&select_lex->context,
                                         select_lex->
                                         ref_pointer_array+i,
                                         (char *)"<no matter>",
                                         (char *)"<list ref>")
1423 1424 1425
                        );
      if (!abort_on_null)
      {
1426 1427 1428 1429 1430 1431 1432 1433 1434
        Item *having_col_item=
          new Item_is_not_null_test(this,
                                    new
                                    Item_ref(&select_lex->context, 
                                             select_lex->ref_pointer_array + i,
                                             (char *)"<no matter>",
                                             (char *)"<list ref>"));
        
        
1435 1436
        item_isnull= new
          Item_func_isnull(new
unknown's avatar
unknown committed
1437 1438 1439 1440 1441
                           Item_direct_ref(&select_lex->context,
                                           select_lex->
                                           ref_pointer_array+i,
                                           (char *)"<no matter>",
                                           (char *)"<list ref>")
1442 1443
                          );
        item= new Item_cond_or(item, item_isnull);
1444 1445 1446 1447
        /* 
          TODO: why we create the above for cases where the right part
                cant be NULL?
        */
unknown's avatar
unknown committed
1448
        if (left_expr->element_index(i)->maybe_null)
1449 1450 1451 1452 1453 1454 1455 1456
        {
          if (!(item= new Item_func_trig_cond(item, get_cond_guard(i))))
            DBUG_RETURN(RES_ERROR);
          if (!(having_col_item= 
                  new Item_func_trig_cond(having_col_item, get_cond_guard(i))))
            DBUG_RETURN(RES_ERROR);
        }
        having_item= and_items(having_item, having_col_item);
1457 1458 1459
      }
      where_item= and_items(where_item, item);
    }
unknown's avatar
unknown committed
1460
    /*
1461
      AND can't be changed during fix_fields()
1462
      we can assign select_lex->where here, and pass 0 as last
1463
      argument (reference) to fix_fields()
unknown's avatar
unknown committed
1464
    */
1465 1466
    select_lex->where= join->conds= and_items(join->conds, where_item);
    select_lex->where->top_level_item();
1467
    if (join->conds->fix_fields(thd, 0))
1468
      DBUG_RETURN(RES_ERROR);
unknown's avatar
unknown committed
1469
  }
1470
  if (having_item)
1471
  {
1472 1473
    bool res;
    select_lex->having= join->having= and_items(join->having, having_item);
1474 1475
    if (having_item == select_lex->having)
      having_item->name= (char*)in_having_cond;
1476
    select_lex->having->top_level_item();
1477 1478 1479 1480 1481
    /*
      AND can't be changed during fix_fields()
      we can assign select_lex->having here, and pass 0 as last
      argument (reference) to fix_fields()
    */
1482
    select_lex->having_fix_field= 1;
1483
    res= join->having->fix_fields(thd, 0);
1484 1485 1486
    select_lex->having_fix_field= 0;
    if (res)
    {
1487
      DBUG_RETURN(RES_ERROR);
1488
    }
1489
  }
unknown's avatar
unknown committed
1490

1491
  DBUG_RETURN(RES_OK);
unknown's avatar
unknown committed
1492 1493
}

1494

1495
Item_subselect::trans_res
unknown's avatar
unknown committed
1496
Item_in_subselect::select_transformer(JOIN *join)
unknown's avatar
unknown committed
1497
{
1498 1499 1500 1501
  return select_in_like_transformer(join, &eq_creator);
}


unknown's avatar
unknown committed
1502
/**
1503
  Prepare IN/ALL/ANY/SOME subquery transformation and call appropriate
unknown's avatar
unknown committed
1504
  transformation function.
1505 1506 1507 1508 1509 1510

    To decide which transformation procedure (scalar or row) applicable here
    we have to call fix_fields() for left expression to be able to call
    cols() method on it. Also this method make arena management for
    underlying transformation methods.

unknown's avatar
unknown committed
1511 1512 1513 1514
  @param join    JOIN object of transforming subquery
  @param func    creator of condition function of subquery

  @retval
1515
    RES_OK      OK
unknown's avatar
unknown committed
1516 1517 1518 1519
  @retval
    RES_REDUCE  OK, and current subquery was reduced during
    transformation
  @retval
1520 1521 1522 1523 1524 1525
    RES_ERROR   Error
*/

Item_subselect::trans_res
Item_in_subselect::select_in_like_transformer(JOIN *join, Comp_creator *func)
{
unknown's avatar
unknown committed
1526
  Query_arena *arena, backup;
1527 1528 1529 1530 1531 1532
  SELECT_LEX *current= thd->lex->current_select, *up;
  const char *save_where= thd->where;
  Item_subselect::trans_res res= RES_ERROR;
  bool result;

  DBUG_ENTER("Item_in_subselect::select_in_like_transformer");
unknown's avatar
unknown committed
1533

1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
  {
    /*
      IN/SOME/ALL/ANY subqueries aren't support LIMIT clause. Without it
      ORDER BY clause becomes meaningless thus we drop it here.
    */
    SELECT_LEX *sl= current->master_unit()->first_select();
    for (; sl; sl= sl->next_select())
    {
      if (sl->join)
        sl->join->order= 0;
    }
  }

1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
  if (changed)
  {
    DBUG_RETURN(RES_OK);
  }

  thd->where= "IN/ALL/ANY subquery";

  /*
    In some optimisation cases we will not need this Item_in_optimizer
    object, but we can't know it here, but here we need address correct
    reference on left expresion.
  */
  if (!optimizer)
  {
unknown's avatar
unknown committed
1561
    arena= thd->activate_stmt_arena_if_needed(&backup);
1562 1563
    result= (!(optimizer= new Item_in_optimizer(left_expr, this)));
    if (arena)
unknown's avatar
unknown committed
1564
      thd->restore_active_arena(arena, &backup);
1565 1566 1567 1568 1569 1570
    if (result)
      goto err;
  }

  thd->lex->current_select= up= current->return_after_parsing();
  result= (!left_expr->fixed &&
1571
           left_expr->fix_fields(thd, optimizer->arguments()));
1572 1573 1574 1575 1576 1577 1578
  /* fix_fields can change reference to left_expr, we need reassign it */
  left_expr= optimizer->arguments()[0];

  thd->lex->current_select= current;
  if (result)
    goto err;

unknown's avatar
unknown committed
1579
  transformed= 1;
unknown's avatar
unknown committed
1580
  arena= thd->activate_stmt_arena_if_needed(&backup);
1581

1582 1583 1584 1585 1586 1587 1588
  /*
    Both transformers call fix_fields() only for Items created inside them,
    and all that items do not make permanent changes in current item arena
    which allow to us call them with changed arena (if we do not know nature
    of Item, we have to call fix_fields() for it only with original arena to
    avoid memory leack)
  */
unknown's avatar
unknown committed
1589
  if (left_expr->cols() == 1)
1590 1591 1592 1593 1594 1595
    res= single_value_transformer(join, func);
  else
  {
    /* we do not support row operation for ALL/ANY/SOME */
    if (func != &eq_creator)
    {
unknown's avatar
unknown committed
1596
      if (arena)
unknown's avatar
unknown committed
1597
        thd->restore_active_arena(arena, &backup);
1598 1599 1600 1601 1602 1603
      my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
      DBUG_RETURN(RES_ERROR);
    }
    res= row_value_transformer(join);
  }
  if (arena)
unknown's avatar
unknown committed
1604
    thd->restore_active_arena(arena, &backup);
1605 1606 1607
err:
  thd->where= save_where;
  DBUG_RETURN(res);
unknown's avatar
unknown committed
1608 1609
}

1610

1611
void Item_in_subselect::print(String *str, enum_query_type query_type)
unknown's avatar
unknown committed
1612 1613
{
  if (transformed)
1614
    str->append(STRING_WITH_LEN("<exists>"));
unknown's avatar
unknown committed
1615 1616
  else
  {
1617
    left_expr->print(str, query_type);
1618
    str->append(STRING_WITH_LEN(" in "));
unknown's avatar
unknown committed
1619
  }
1620
  Item_subselect::print(str, query_type);
unknown's avatar
unknown committed
1621 1622 1623
}


1624
bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
1625 1626 1627
{
  bool result = 0;
  
1628 1629
  if (thd_arg->lex->view_prepare_mode && left_expr && !left_expr->fixed)
    result = left_expr->fix_fields(thd_arg, &left_expr);
1630

1631
  return result || Item_subselect::fix_fields(thd_arg, ref);
1632 1633 1634
}


1635
Item_subselect::trans_res
unknown's avatar
unknown committed
1636
Item_allany_subselect::select_transformer(JOIN *join)
unknown's avatar
unknown committed
1637
{
unknown's avatar
unknown committed
1638
  transformed= 1;
1639 1640
  if (upper_item)
    upper_item->show= 1;
1641
  return select_in_like_transformer(join, func);
unknown's avatar
unknown committed
1642 1643
}

unknown's avatar
unknown committed
1644

1645
void Item_allany_subselect::print(String *str, enum_query_type query_type)
unknown's avatar
unknown committed
1646 1647
{
  if (transformed)
1648
    str->append(STRING_WITH_LEN("<exists>"));
unknown's avatar
unknown committed
1649 1650
  else
  {
1651
    left_expr->print(str, query_type);
unknown's avatar
unknown committed
1652
    str->append(' ');
unknown's avatar
unknown committed
1653 1654
    str->append(func->symbol(all));
    str->append(all ? " all " : " any ", 5);
unknown's avatar
unknown committed
1655
  }
1656
  Item_subselect::print(str, query_type);
unknown's avatar
unknown committed
1657 1658 1659
}


1660 1661 1662 1663 1664 1665 1666 1667
void subselect_engine::set_thd(THD *thd_arg)
{
  thd= thd_arg;
  if (result)
    result->set_thd(thd_arg);
}


1668
subselect_single_select_engine::
1669
subselect_single_select_engine(st_select_lex *select,
1670 1671 1672
			       select_subselect *result_arg,
			       Item_subselect *item_arg)
  :subselect_engine(item_arg, result_arg),
1673 1674
   prepared(0), optimized(0), executed(0),
   select_lex(select), join(0)
unknown's avatar
unknown committed
1675
{
1676
  select_lex->master_unit()->item= item_arg;
unknown's avatar
unknown committed
1677 1678
}

unknown's avatar
unknown committed
1679

unknown's avatar
unknown committed
1680 1681
void subselect_single_select_engine::cleanup()
{
unknown's avatar
unknown committed
1682 1683
  DBUG_ENTER("subselect_single_select_engine::cleanup");
  prepared= optimized= executed= 0;
1684
  join= 0;
1685
  result->cleanup();
unknown's avatar
unknown committed
1686
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1687
}
1688

unknown's avatar
unknown committed
1689 1690 1691 1692 1693

void subselect_union_engine::cleanup()
{
  DBUG_ENTER("subselect_union_engine::cleanup");
  unit->reinit_exec_mechanism();
1694
  result->cleanup();
unknown's avatar
unknown committed
1695
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1696
}
1697

unknown's avatar
unknown committed
1698

1699 1700 1701 1702 1703 1704
bool subselect_union_engine::is_executed() const
{
  return unit->executed;
}


1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725
/*
  Check if last execution of the subquery engine produced any rows

  SYNOPSIS
    subselect_union_engine::no_rows()

  DESCRIPTION
    Check if last execution of the subquery engine produced any rows. The
    return value is undefined if last execution ended in an error.

  RETURN
    TRUE  - Last subselect execution has produced no rows
    FALSE - Otherwise
*/

bool subselect_union_engine::no_rows()
{
  /* Check if we got any rows when reading UNION result from temp. table: */
  return test(!unit->fake_select_lex->join->send_records);
}

unknown's avatar
unknown committed
1726 1727 1728
void subselect_uniquesubquery_engine::cleanup()
{
  DBUG_ENTER("subselect_uniquesubquery_engine::cleanup");
1729 1730 1731 1732
  /*
    subselect_uniquesubquery_engine have not 'result' assigbed, so we do not
    cleanup() it
  */
unknown's avatar
unknown committed
1733 1734 1735 1736
  DBUG_VOID_RETURN;
}


1737
subselect_union_engine::subselect_union_engine(st_select_lex_unit *u,
1738 1739 1740
					       select_subselect *result_arg,
					       Item_subselect *item_arg)
  :subselect_engine(item_arg, result_arg)
unknown's avatar
unknown committed
1741 1742
{
  unit= u;
1743
  if (!result_arg)				//out of memory
1744
    current_thd->fatal_error();
1745
  unit->item= item_arg;
unknown's avatar
unknown committed
1746 1747
}

1748

unknown's avatar
unknown committed
1749 1750
int subselect_single_select_engine::prepare()
{
unknown's avatar
unknown committed
1751 1752
  if (prepared)
    return 0;
1753 1754
  join= new JOIN(thd, select_lex->item_list,
		 select_lex->options | SELECT_NO_UNLOCK, result);
1755 1756
  if (!join || !result)
  {
1757
    thd->fatal_error();				//out of memory
1758 1759
    return 1;
  }
unknown's avatar
unknown committed
1760
  prepared= 1;
1761 1762
  SELECT_LEX *save_select= thd->lex->current_select;
  thd->lex->current_select= select_lex;
unknown's avatar
unknown committed
1763 1764 1765
  if (join->prepare(&select_lex->ref_pointer_array,
		    (TABLE_LIST*) select_lex->table_list.first,
		    select_lex->with_wild,
unknown's avatar
unknown committed
1766
		    select_lex->where,
unknown's avatar
unknown committed
1767 1768
		    select_lex->order_list.elements +
		    select_lex->group_list.elements,
unknown's avatar
unknown committed
1769 1770 1771
		    (ORDER*) select_lex->order_list.first,
		    (ORDER*) select_lex->group_list.first,
		    select_lex->having,
1772
		    (ORDER*) 0, select_lex,
1773
		    select_lex->master_unit()))
unknown's avatar
unknown committed
1774
    return 1;
1775
  thd->lex->current_select= save_select;
unknown's avatar
unknown committed
1776 1777 1778 1779 1780
  return 0;
}

int subselect_union_engine::prepare()
{
1781
  return unit->prepare(thd, result, SELECT_NO_UNLOCK);
unknown's avatar
unknown committed
1782 1783
}

1784
int subselect_uniquesubquery_engine::prepare()
1785 1786 1787 1788 1789 1790
{
  //this never should be called
  DBUG_ASSERT(0);
  return 1;
}

1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812

/*
  Check if last execution of the subquery engine produced any rows

  SYNOPSIS
    subselect_single_select_engine::no_rows()

  DESCRIPTION
    Check if last execution of the subquery engine produced any rows. The
    return value is undefined if last execution ended in an error.

  RETURN
    TRUE  - Last subselect execution has produced no rows
    FALSE - Otherwise
*/

bool subselect_single_select_engine::no_rows()
{ 
  return !item->assigned();
}


1813 1814 1815 1816 1817
/* 
 makes storage for the output values for the subquery and calcuates 
 their data and column types and their nullability.
*/ 
void subselect_engine::set_row(List<Item> &item_list, Item_cache **row)
1818
{
1819
  Item *sel_item;
1820
  List_iterator_fast<Item> li(item_list);
1821
  res_type= STRING_RESULT;
1822
  res_field_type= MYSQL_TYPE_VAR_STRING;
1823 1824 1825 1826
  for (uint i= 0; (sel_item= li++); i++)
  {
    item->max_length= sel_item->max_length;
    res_type= sel_item->result_type();
1827
    res_field_type= sel_item->field_type();
1828
    item->decimals= sel_item->decimals;
1829
    item->unsigned_flag= sel_item->unsigned_flag;
unknown's avatar
unknown committed
1830
    maybe_null= sel_item->maybe_null;
1831
    if (!(row[i]= Item_cache::get_cache(sel_item)))
1832
      return;
1833
    row[i]->setup(sel_item);
1834
  }
1835
  if (item_list.elements > 1)
1836
    res_type= ROW_RESULT;
1837 1838
}

1839
void subselect_single_select_engine::fix_length_and_dec(Item_cache **row)
1840
{
1841
  DBUG_ASSERT(row || select_lex->item_list.elements==1);
1842
  set_row(select_lex->item_list, row);
1843
  item->collation.set(row[0]->collation);
unknown's avatar
unknown committed
1844 1845
  if (cols() != 1)
    maybe_null= 0;
1846 1847 1848 1849 1850 1851 1852
}

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)
1853
  {
1854
    set_row(unit->types, row);
1855 1856
    item->collation.set(row[0]->collation);
  }
1857 1858
  else
  {
1859 1860 1861
    bool maybe_null_saved= maybe_null;
    set_row(unit->types, row);
    maybe_null= maybe_null_saved;
1862 1863
  }
}
unknown's avatar
unknown committed
1864

1865
void subselect_uniquesubquery_engine::fix_length_and_dec(Item_cache **row)
1866 1867 1868 1869 1870
{
  //this never should be called
  DBUG_ASSERT(0);
}

1871 1872 1873 1874
int  init_read_record_seq(JOIN_TAB *tab);
int join_read_always_key_or_null(JOIN_TAB *tab);
int join_read_next_same_or_null(READ_RECORD *info);

1875
int subselect_single_select_engine::exec()
unknown's avatar
unknown committed
1876 1877
{
  DBUG_ENTER("subselect_single_select_engine::exec");
unknown's avatar
unknown committed
1878 1879 1880
  char const *save_where= thd->where;
  SELECT_LEX *save_select= thd->lex->current_select;
  thd->lex->current_select= select_lex;
unknown's avatar
unknown committed
1881 1882
  if (!optimized)
  {
1883 1884 1885 1886
    SELECT_LEX_UNIT *unit= select_lex->master_unit();

    optimized= 1;
    unit->set_limit(unit->global_parameters);
unknown's avatar
unknown committed
1887 1888
    if (join->optimize())
    {
unknown's avatar
unknown committed
1889
      thd->where= save_where;
unknown's avatar
unknown committed
1890
      executed= 1;
unknown's avatar
unknown committed
1891
      thd->lex->current_select= save_select;
unknown's avatar
unknown committed
1892
      DBUG_RETURN(join->error ? join->error : 1);
unknown's avatar
unknown committed
1893
    }
unknown's avatar
unknown committed
1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
    if (!select_lex->uncacheable && thd->lex->describe && 
        !(join->select_options & SELECT_DESCRIBE) && 
        join->need_tmp && item->const_item())
    {
      /*
        Force join->join_tmp creation, because this subquery will be replaced
        by a simple select from the materialization temp table by optimize()
        called by EXPLAIN and we need to preserve the initial query structure
        so we can display it.
       */
      select_lex->uncacheable|= UNCACHEABLE_EXPLAIN;
      select_lex->master_unit()->uncacheable|= UNCACHEABLE_EXPLAIN;
      if (join->init_save_join_tab())
unknown's avatar
unknown committed
1907
        DBUG_RETURN(1);                        /* purecov: inspected */
unknown's avatar
unknown committed
1908
    }
1909 1910 1911 1912
    if (item->engine_changed)
    {
      DBUG_RETURN(1);
    }
unknown's avatar
unknown committed
1913
  }
1914 1915 1916
  if (select_lex->uncacheable &&
      select_lex->uncacheable != UNCACHEABLE_EXPLAIN
      && executed)
unknown's avatar
unknown committed
1917 1918
  {
    if (join->reinit())
1919
    {
unknown's avatar
unknown committed
1920 1921
      thd->where= save_where;
      thd->lex->current_select= save_select;
unknown's avatar
unknown committed
1922
      DBUG_RETURN(1);
1923
    }
1924
    item->reset();
unknown's avatar
unknown committed
1925 1926 1927 1928
    item->assigned((executed= 0));
  }
  if (!executed)
  {
1929
    item->reset_value_registration();
1930 1931 1932
    JOIN_TAB *changed_tabs[MAX_TABLES];
    JOIN_TAB **last_changed_tab= changed_tabs;
    if (item->have_guarded_conds())
1933 1934
    {
      /*
1935
        For at least one of the pushed predicates the following is true:
1936 1937 1938 1939 1940 1941 1942
        We should not apply optimizations based on the condition that was
        pushed down into the subquery. Those optimizations are ref[_or_null]
        acceses. Change them to be full table scans.
      */
      for (uint i=join->const_tables ; i < join->tables ; i++)
      {
        JOIN_TAB *tab=join->join_tab+i;
1943
        if (tab && tab->keyuse)
1944
        {
1945 1946 1947 1948 1949 1950
          for (uint i= 0; i < tab->ref.key_parts; i++)
          {
            bool *cond_guard= tab->ref.cond_guards[i];
            if (cond_guard && !*cond_guard)
            {
              /* Change the access method to full table scan */
1951 1952
              tab->save_read_first_record= tab->read_first_record;
              tab->save_read_record= tab->read_record.read_record;
1953 1954 1955 1956
              tab->read_first_record= init_read_record_seq;
              tab->read_record.record= tab->table->record[0];
              tab->read_record.thd= join->thd;
              tab->read_record.ref_length= tab->table->file->ref_length;
1957
              tab->read_record.unlock_row= rr_unlock_row;
1958 1959 1960 1961
              *(last_changed_tab++)= tab;
              break;
            }
          }
1962 1963 1964 1965
        }
      }
    }
    
unknown's avatar
unknown committed
1966
    join->exec();
1967

1968 1969
    /* Enable the optimizations back */
    for (JOIN_TAB **ptab= changed_tabs; ptab != last_changed_tab; ptab++)
1970
    {
1971 1972 1973
      JOIN_TAB *tab= *ptab;
      tab->read_record.record= 0;
      tab->read_record.ref_length= 0;
1974 1975
      tab->read_first_record= tab->save_read_first_record; 
      tab->read_record.read_record= tab->save_read_record;
1976
    }
unknown's avatar
unknown committed
1977
    executed= 1;
unknown's avatar
unknown committed
1978 1979
    thd->where= save_where;
    thd->lex->current_select= save_select;
1980
    DBUG_RETURN(join->error||thd->is_fatal_error);
unknown's avatar
unknown committed
1981
  }
unknown's avatar
unknown committed
1982 1983
  thd->where= save_where;
  thd->lex->current_select= save_select;
unknown's avatar
unknown committed
1984 1985 1986
  DBUG_RETURN(0);
}

1987
int subselect_union_engine::exec()
unknown's avatar
unknown committed
1988
{
unknown's avatar
unknown committed
1989
  char const *save_where= thd->where;
1990
  int res= unit->exec();
unknown's avatar
unknown committed
1991
  thd->where= save_where;
1992
  return res;
unknown's avatar
unknown committed
1993 1994
}

1995

1996
/*
1997
  Search for at least one row satisfying select condition
1998 1999 2000 2001 2002 2003 2004 2005
 
  SYNOPSIS
    subselect_uniquesubquery_engine::scan_table()

  DESCRIPTION
    Scan the table using sequential access until we find at least one row
    satisfying select condition.
    
2006 2007
    The caller must set this->empty_result_set=FALSE before calling this
    function. This function will set it to TRUE if it finds a matching row.
2008 2009 2010 2011 2012 2013 2014

  RETURN
    FALSE - OK
    TRUE  - Error
*/

int subselect_uniquesubquery_engine::scan_table()
2015 2016 2017
{
  int error;
  TABLE *table= tab->table;
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027
  DBUG_ENTER("subselect_uniquesubquery_engine::scan_table");

  if (table->file->inited)
    table->file->ha_index_end();
 
  table->file->ha_rnd_init(1);
  table->file->extra_opt(HA_EXTRA_CACHE,
                         current_thd->variables.read_buff_size);
  table->null_row= 0;
  for (;;)
2028
  {
2029 2030
    error=table->file->rnd_next(table->record[0]);
    if (error && error != HA_ERR_END_OF_FILE)
2031
    {
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
      error= report_error(table, error);
      break;
    }
    /* No more rows */
    if (table->status)
      break;

    if (!cond || cond->val_int())
    {
      empty_result_set= FALSE;
      break;
    }
  }

  table->file->ha_rnd_end();
  DBUG_RETURN(error != 0);
}


/*
  Copy ref key and check for null parts in it

  SYNOPSIS
    subselect_uniquesubquery_engine::copy_ref_key()

  DESCRIPTION
    Copy ref key and check for null parts in it.
unknown's avatar
unknown committed
2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
    Depending on the nullability and conversion problems this function
    recognizes and processes the following states :
      1. Partial match on top level. This means IN has a value of FALSE
         regardless of the data in the subquery table.
         Detected by finding a NULL in the left IN operand of a top level
         expression.
         We may actually skip reading the subquery, so return TRUE to skip
         the table scan in subselect_uniquesubquery_engine::exec and make
         the value of the IN predicate a NULL (that is equal to FALSE on
         top level).
      2. No exact match when IN is nested inside another predicate.
         Detected by finding a NULL in the left IN operand when IN is not
         a top level predicate.
         We cannot have an exact match. But we must proceed further with a
         table scan to find out if it's a partial match (and IN has a value
         of NULL) or no match (and IN has a value of FALSE).
         So we return FALSE to continue with the scan and see if there are
         any record that would constitute a partial match (as we cannot
         determine that from the index).
      3. Error converting the left IN operand to the column type of the
         right IN operand. This counts as no match (and IN has the value of
         FALSE). We mark the subquery table cursor as having no more rows
         (to ensure that the processing that follows will not find a match)
         and return FALSE, so IN is not treated as returning NULL.

2084 2085

  RETURN
unknown's avatar
unknown committed
2086 2087 2088 2089 2090
    FALSE - The value of the IN predicate is not known. Proceed to find the
            value of the IN predicate using the determined values of
            null_keypart and table->status.
    TRUE  - IN predicate has a value of NULL. Stop the processing right there
            and return NULL to the outer predicates.
2091 2092 2093 2094 2095 2096 2097
*/

bool subselect_uniquesubquery_engine::copy_ref_key()
{
  DBUG_ENTER("subselect_uniquesubquery_engine::copy_ref_key");

  for (store_key **copy= tab->ref.key_copy ; *copy ; copy++)
2098
  {
2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109
    tab->ref.key_err= (*copy)->copy();

    /*
      When there is a NULL part in the key we don't need to make index
      lookup for such key thus we don't need to copy whole key.
      If we later should do a sequential scan return OK. Fail otherwise.

      See also the comment for the subselect_uniquesubquery_engine::exec()
      function.
    */
    null_keypart= (*copy)->null_key;
unknown's avatar
unknown committed
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133
    if (null_keypart)
    {
      bool top_level= ((Item_in_subselect *) item)->is_top_level_item();
      if (top_level)
      {
        /* Partial match on top level */
        DBUG_RETURN(1);
      }
      else
      {
        /* No exact match when IN is nested inside another predicate */
        break;
      }
    }

    /*
      Check if the error is equal to STORE_KEY_FATAL. This is not expressed 
      using the store_key::store_key_result enum because ref.key_err is a 
      boolean and we want to detect both TRUE and STORE_KEY_FATAL from the 
      space of the union of the values of [TRUE, FALSE] and 
      store_key::store_key_result.  
      TODO: fix the variable an return types.
    */
    if (tab->ref.key_err & 1)
2134
    {
unknown's avatar
unknown committed
2135 2136 2137 2138
      /*
       Error converting the left IN operand to the column type of the right
       IN operand. 
      */
2139
      tab->table->status= STATUS_NOT_FOUND;
unknown's avatar
unknown committed
2140
      break;
2141
    }
2142
  }
2143 2144 2145
  DBUG_RETURN(0);
}

2146

2147 2148 2149 2150 2151
/*
  Execute subselect

  SYNOPSIS
    subselect_uniquesubquery_engine::exec()
2152

2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
  DESCRIPTION
    Find rows corresponding to the ref key using index access.
    If some part of the lookup key is NULL, then we're evaluating
      NULL IN (SELECT ... )
    This is a special case, we don't need to search for NULL in the table,
    instead, the result value is 
      - NULL  if select produces empty row set
      - FALSE otherwise.

    In some cases (IN subselect is a top level item, i.e. abort_on_null==TRUE)
2163
    the caller doesn't distinguish between NULL and FALSE result and we just
2164
    return FALSE. 
2165 2166 2167 2168 2169
    Otherwise we make a full table scan to see if there is at least one 
    matching row.
    
    The result of this function (info about whether a row was found) is
    stored in this->empty_result_set.
2170 2171 2172 2173 2174 2175
  NOTE
    
  RETURN
    FALSE - ok
    TRUE  - an error occured while scanning
*/
2176

2177
int subselect_uniquesubquery_engine::exec()
2178 2179 2180 2181
{
  DBUG_ENTER("subselect_uniquesubquery_engine::exec");
  int error;
  TABLE *table= tab->table;
2182
  empty_result_set= TRUE;
unknown's avatar
unknown committed
2183
  table->status= 0;
2184 2185 2186 2187
 
  /* TODO: change to use of 'full_scan' here? */
  if (copy_ref_key())
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2188 2189 2190 2191 2192 2193 2194 2195 2196
  if (table->status)
  {
    /* 
      We know that there will be no rows even if we scan. 
      Can be set in copy_ref_key.
    */
    ((Item_in_subselect *) item)->value= 0;
    DBUG_RETURN(0);
  }
2197 2198 2199 2200

  if (null_keypart)
    DBUG_RETURN(scan_table());
 
2201
  if (!table->file->inited)
2202
    table->file->ha_index_init(tab->ref.key, 0);
2203 2204 2205 2206
  error= table->file->index_read_map(table->record[0],
                                     tab->ref.key_buff,
                                     make_prev_keypart_map(tab->ref.key_parts),
                                     HA_READ_KEY_EXACT);
2207 2208
  if (error &&
      error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
2209
    error= report_error(table, error);
2210 2211
  else
  {
2212 2213
    error= 0;
    table->null_row= 0;
2214 2215 2216 2217 2218 2219 2220
    if (!table->status && (!cond || cond->val_int()))
    {
      ((Item_in_subselect *) item)->value= 1;
      empty_result_set= FALSE;
    }
    else
      ((Item_in_subselect *) item)->value= 0;
2221
  }
2222

2223
  DBUG_RETURN(error != 0);
2224 2225
}

2226 2227

subselect_uniquesubquery_engine::~subselect_uniquesubquery_engine()
2228
{
2229
  /* Tell handler we don't need the index anymore */
unknown's avatar
unknown committed
2230
  tab->table->file->ha_index_end();
2231 2232
}

2233

2234 2235 2236 2237 2238 2239 2240 2241
/*
  Index-lookup subselect 'engine' - run the subquery

  SYNOPSIS
    subselect_uniquesubquery_engine:exec()
      full_scan 

  DESCRIPTION
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
    The engine is used to resolve subqueries in form

      oe IN (SELECT key FROM tbl WHERE subq_where) 

    The value of the predicate is calculated as follows: 
    1. If oe IS NULL, this is a special case, do a full table scan on
       table tbl and search for row that satisfies subq_where. If such 
       row is found, return NULL, otherwise return FALSE.
    2. Make an index lookup via key=oe, search for a row that satisfies
       subq_where. If found, return TRUE.
    3. If check_null==TRUE, make another lookup via key=NULL, search for a 
       row that satisfies subq_where. If found, return NULL, otherwise
       return FALSE.

  TODO
    The step #1 can be optimized further when the index has several key
    parts. Consider a subquery:
    
      (oe1, oe2) IN (SELECT keypart1, keypart2 FROM tbl WHERE subq_where)

    and suppose we need to evaluate it for {oe1, oe2}=={const1, NULL}.
    Current code will do a full table scan and obtain correct result. There
    is a better option: instead of evaluating

      SELECT keypart1, keypart2 FROM tbl WHERE subq_where            (1)

    and checking if it has produced any matching rows, evaluate
    
      SELECT keypart2 FROM tbl WHERE subq_where AND keypart1=const1  (2)

    If this query produces a row, the result is NULL (as we're evaluating 
    "(const1, NULL) IN { (const1, X), ... }", which has a value of UNKNOWN,
    i.e. NULL).  If the query produces no rows, the result is FALSE.
2275

2276 2277 2278 2279
    We currently evaluate (1) by doing a full table scan. (2) can be
    evaluated by doing a "ref" scan on "keypart1=const1", which can be much
    cheaper. We can use index statistics to quickly check whether "ref" scan
    will be cheaper than full table scan.
2280 2281 2282 2283 2284 2285

  RETURN
    0
    1
*/

2286
int subselect_indexsubquery_engine::exec()
2287
{
2288
  DBUG_ENTER("subselect_indexsubquery_engine::exec");
2289
  int error;
2290
  bool null_finding= 0;
2291
  TABLE *table= tab->table;
2292

2293
  ((Item_in_subselect *) item)->value= 0;
2294 2295
  empty_result_set= TRUE;
  null_keypart= 0;
2296
  table->status= 0;
2297

2298 2299
  if (check_null)
  {
2300
    /* We need to check for NULL if there wasn't a matching value */
2301
    *tab->ref.null_ref_key= 0;			// Search first for not null
2302 2303 2304
    ((Item_in_subselect *) item)->was_null= 0;
  }

2305 2306 2307 2308
  /* Copy the ref key and check for nulls... */
  if (copy_ref_key())
    DBUG_RETURN(1);

2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
  if (table->status)
  {
    /* 
      We know that there will be no rows even if we scan. 
      Can be set in copy_ref_key.
    */
    ((Item_in_subselect *) item)->value= 0;
    DBUG_RETURN(0);
  }

2319 2320
  if (null_keypart)
    DBUG_RETURN(scan_table());
2321 2322

  if (!table->file->inited)
2323
    table->file->ha_index_init(tab->ref.key, 1);
2324 2325 2326 2327
  error= table->file->index_read_map(table->record[0],
                                     tab->ref.key_buff,
                                     make_prev_keypart_map(tab->ref.key_parts),
                                     HA_READ_KEY_EXACT);
2328 2329
  if (error &&
      error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)
2330
    error= report_error(table, error);
2331 2332
  else
  {
2333
    for (;;)
2334
    {
2335 2336 2337
      error= 0;
      table->null_row= 0;
      if (!table->status)
2338
      {
2339
        if ((!cond || cond->val_int()) && (!having || having->val_int()))
2340
        {
2341
          empty_result_set= FALSE;
2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365
          if (null_finding)
            ((Item_in_subselect *) item)->was_null= 1;
          else
            ((Item_in_subselect *) item)->value= 1;
          break;
        }
        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);
          break;
        }
      }
      else
      {
        if (!check_null || null_finding)
          break;			/* We don't need to check nulls */
        *tab->ref.null_ref_key= 1;
        null_finding= 1;
        /* Check if there exists a row with a null value in the index */
        if ((error= (safe_index_read(tab) == 1)))
          break;
2366
      }
2367 2368
    }
  }
2369
  DBUG_RETURN(error != 0);
2370 2371
}

2372

unknown's avatar
unknown committed
2373 2374
uint subselect_single_select_engine::cols()
{
2375
  DBUG_ASSERT(select_lex->join != 0); // should be called after fix_fields()
2376
  return select_lex->join->fields_list.elements;
unknown's avatar
unknown committed
2377 2378
}

unknown's avatar
unknown committed
2379

unknown's avatar
unknown committed
2380 2381
uint subselect_union_engine::cols()
{
2382 2383
  DBUG_ASSERT(unit->is_prepared());  // should be called after fix_fields()
  return unit->types.elements;
unknown's avatar
unknown committed
2384 2385
}

unknown's avatar
unknown committed
2386

2387
uint8 subselect_single_select_engine::uncacheable()
2388 2389 2390 2391
{
  return select_lex->uncacheable;
}

unknown's avatar
unknown committed
2392

2393
uint8 subselect_union_engine::uncacheable()
2394 2395 2396 2397
{
  return unit->uncacheable;
}

unknown's avatar
unknown committed
2398

unknown's avatar
unknown committed
2399 2400 2401 2402 2403 2404 2405 2406 2407
void subselect_single_select_engine::exclude()
{
  select_lex->master_unit()->exclude_level();
}

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

unknown's avatar
unknown committed
2409

2410
void subselect_uniquesubquery_engine::exclude()
2411 2412 2413 2414
{
  //this never should be called
  DBUG_ASSERT(0);
}
2415 2416 2417 2418 2419


table_map subselect_engine::calc_const_tables(TABLE_LIST *table)
{
  table_map map= 0;
unknown's avatar
unknown committed
2420
  for (; table; table= table->next_leaf)
2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432
  {
    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()->
2433
			   leaf_tables);
2434 2435
}

unknown's avatar
merge  
unknown committed
2436

2437 2438
table_map subselect_union_engine::upper_select_const_tables()
{
2439
  return calc_const_tables((TABLE_LIST *) unit->outer_select()->leaf_tables);
2440
}
unknown's avatar
merge  
unknown committed
2441 2442


2443 2444
void subselect_single_select_engine::print(String *str,
                                           enum_query_type query_type)
unknown's avatar
unknown committed
2445
{
2446
  select_lex->print(thd, str, query_type);
unknown's avatar
unknown committed
2447 2448 2449
}


2450
void subselect_union_engine::print(String *str, enum_query_type query_type)
unknown's avatar
unknown committed
2451
{
2452
  unit->print(str, query_type);
unknown's avatar
unknown committed
2453 2454 2455
}


2456 2457
void subselect_uniquesubquery_engine::print(String *str,
                                            enum_query_type query_type)
unknown's avatar
unknown committed
2458
{
2459
  str->append(STRING_WITH_LEN("<primary_index_lookup>("));
2460
  tab->ref.items[0]->print(str, query_type);
2461
  str->append(STRING_WITH_LEN(" in "));
unknown's avatar
unknown committed
2462
  str->append(tab->table->s->table_name.str, tab->table->s->table_name.length);
unknown's avatar
unknown committed
2463
  KEY *key_info= tab->table->key_info+ tab->ref.key;
2464
  str->append(STRING_WITH_LEN(" on "));
unknown's avatar
unknown committed
2465
  str->append(key_info->name);
unknown's avatar
unknown committed
2466 2467
  if (cond)
  {
2468
    str->append(STRING_WITH_LEN(" where "));
2469
    cond->print(str, query_type);
unknown's avatar
unknown committed
2470 2471 2472 2473 2474
  }
  str->append(')');
}


2475 2476
void subselect_indexsubquery_engine::print(String *str,
                                           enum_query_type query_type)
unknown's avatar
unknown committed
2477
{
2478
  str->append(STRING_WITH_LEN("<index_lookup>("));
2479
  tab->ref.items[0]->print(str, query_type);
2480
  str->append(STRING_WITH_LEN(" in "));
unknown's avatar
unknown committed
2481
  str->append(tab->table->s->table_name.str, tab->table->s->table_name.length);
unknown's avatar
unknown committed
2482
  KEY *key_info= tab->table->key_info+ tab->ref.key;
2483
  str->append(STRING_WITH_LEN(" on "));
unknown's avatar
unknown committed
2484
  str->append(key_info->name);
unknown's avatar
unknown committed
2485
  if (check_null)
2486
    str->append(STRING_WITH_LEN(" checking NULL"));
2487
  if (cond)
unknown's avatar
unknown committed
2488
  {
2489
    str->append(STRING_WITH_LEN(" where "));
2490
    cond->print(str, query_type);
unknown's avatar
unknown committed
2491
  }
2492 2493 2494
  if (having)
  {
    str->append(STRING_WITH_LEN(" having "));
2495
    having->print(str, query_type);
2496
  }
unknown's avatar
unknown committed
2497 2498
  str->append(')');
}
2499

unknown's avatar
unknown committed
2500 2501
/**
  change select_result object of engine.
2502

unknown's avatar
unknown committed
2503 2504
  @param si		new subselect Item
  @param res		new select_result object
2505

unknown's avatar
unknown committed
2506
  @retval
unknown's avatar
unknown committed
2507
    FALSE OK
unknown's avatar
unknown committed
2508
  @retval
unknown's avatar
unknown committed
2509
    TRUE  error
2510 2511
*/

unknown's avatar
unknown committed
2512 2513
bool subselect_single_select_engine::change_result(Item_subselect *si,
                                                 select_subselect *res)
2514 2515 2516 2517 2518 2519 2520
{
  item= si;
  result= res;
  return select_lex->join->change_result(result);
}


unknown's avatar
unknown committed
2521 2522
/**
  change select_result object of engine.
2523

unknown's avatar
unknown committed
2524 2525
  @param si		new subselect Item
  @param res		new select_result object
2526

unknown's avatar
unknown committed
2527
  @retval
unknown's avatar
unknown committed
2528
    FALSE OK
unknown's avatar
unknown committed
2529
  @retval
unknown's avatar
unknown committed
2530
    TRUE  error
2531 2532
*/

unknown's avatar
unknown committed
2533 2534
bool subselect_union_engine::change_result(Item_subselect *si,
                                         select_subselect *res)
2535 2536 2537 2538 2539 2540 2541 2542
{
  item= si;
  int rc= unit->change_result(res, result);
  result= res;
  return rc;
}


unknown's avatar
unknown committed
2543 2544
/**
  change select_result emulation, never should be called.
2545

unknown's avatar
unknown committed
2546 2547
  @param si		new subselect Item
  @param res		new select_result object
2548

unknown's avatar
unknown committed
2549
  @retval
unknown's avatar
unknown committed
2550
    FALSE OK
unknown's avatar
unknown committed
2551
  @retval
unknown's avatar
unknown committed
2552
    TRUE  error
2553 2554
*/

unknown's avatar
unknown committed
2555 2556
bool subselect_uniquesubquery_engine::change_result(Item_subselect *si,
                                                  select_subselect *res)
2557 2558
{
  DBUG_ASSERT(0);
unknown's avatar
unknown committed
2559
  return TRUE;
2560
}
2561 2562


unknown's avatar
unknown committed
2563 2564
/**
  Report about presence of tables in subquery.
2565

unknown's avatar
unknown committed
2566
  @retval
2567
    TRUE  there are not tables used in subquery
unknown's avatar
unknown committed
2568
  @retval
2569 2570 2571 2572 2573 2574 2575 2576
    FALSE there are some tables in subquery
*/
bool subselect_single_select_engine::no_tables()
{
  return(select_lex->table_list.elements == 0);
}


2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592
/*
  Check statically whether the subquery can return NULL

  SINOPSYS
    subselect_single_select_engine::may_be_null()

  RETURN
    FALSE  can guarantee that the subquery never return NULL
    TRUE   otherwise
*/
bool subselect_single_select_engine::may_be_null()
{
  return ((no_tables() && !join->conds && !join->having) ? maybe_null : 1);
}


unknown's avatar
unknown committed
2593 2594
/**
  Report about presence of tables in subquery.
2595

unknown's avatar
unknown committed
2596
  @retval
2597
    TRUE  there are not tables used in subquery
unknown's avatar
unknown committed
2598
  @retval
2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611
    FALSE there are some tables in subquery
*/
bool subselect_union_engine::no_tables()
{
  for (SELECT_LEX *sl= unit->first_select(); sl; sl= sl->next_select())
  {
    if (sl->table_list.elements)
      return FALSE;
  }
  return TRUE;
}


unknown's avatar
unknown committed
2612 2613
/**
  Report about presence of tables in subquery.
2614

unknown's avatar
unknown committed
2615
  @retval
2616
    TRUE  there are not tables used in subquery
unknown's avatar
unknown committed
2617
  @retval
2618 2619 2620 2621 2622 2623 2624 2625
    FALSE there are some tables in subquery
*/

bool subselect_uniquesubquery_engine::no_tables()
{
  /* returning value is correct, but this method should never be called */
  return 0;
}