← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

  • Committer: Brian Aker
  • Date: 2009-02-11 21:23:31 UTC
  • mfrom: (873.1.7 temporal-new)
  • Revision ID: brian@tangent.org-20090211212331-ebvmf4nwqb3nv902
Merge of Jay's work.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
10281
10281
{
10282
10282
  if (cond->type() == Item::COND_ITEM)
10283
10283
  {
10284
 
    bool and_level= ((Item_cond*) cond)->functype()
10285
 
      == Item_func::COND_AND_FUNC;
 
10284
    bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);
 
10285
 
10286
10286
    List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
10287
10287
    Item::cond_result tmp_cond_value;
10288
 
    bool should_fix_fields=0;
 
10288
    bool should_fix_fields= false;
10289
10289
 
10290
 
    *cond_value=Item::COND_UNDEF;
 
10290
    *cond_value= Item::COND_UNDEF;
10291
10291
    Item *item;
10292
 
    while ((item=li++))
 
10292
    while ((item= li++))
10293
10293
    {
10294
 
      Item *new_item=remove_eq_conds(session, item, &tmp_cond_value);
10295
 
      if (!new_item)
10296
 
        li.remove();
 
10294
      Item *new_item= remove_eq_conds(session, item, &tmp_cond_value);
 
10295
      if (! new_item)
 
10296
              li.remove();
10297
10297
      else if (item != new_item)
10298
10298
      {
10299
 
        li.replace(new_item);
10300
 
        should_fix_fields=1;
 
10299
        li.replace(new_item);
 
10300
        should_fix_fields= true;
10301
10301
      }
10302
10302
      if (*cond_value == Item::COND_UNDEF)
10303
 
        *cond_value=tmp_cond_value;
10304
 
      switch (tmp_cond_value) {
10305
 
      case Item::COND_OK:                       // Not true or false
10306
 
        if (and_level || *cond_value == Item::COND_FALSE)
10307
 
          *cond_value=tmp_cond_value;
10308
 
        break;
10309
 
      case Item::COND_FALSE:
10310
 
        if (and_level)
10311
 
        {
10312
 
          *cond_value=tmp_cond_value;
10313
 
          return (COND*) 0;                     // Always false
10314
 
        }
10315
 
        break;
10316
 
      case Item::COND_TRUE:
10317
 
        if (!and_level)
10318
 
        {
10319
 
          *cond_value= tmp_cond_value;
10320
 
          return (COND*) 0;                     // Always true
10321
 
        }
10322
 
        break;
10323
 
      case Item::COND_UNDEF:                    // Impossible
10324
 
        break; /* purecov: deadcode */
 
10303
              *cond_value= tmp_cond_value;
 
10304
 
 
10305
      switch (tmp_cond_value) 
 
10306
      {
 
10307
        case Item::COND_OK:                     /* Not true or false */
 
10308
          if (and_level || (*cond_value == Item::COND_FALSE))
 
10309
            *cond_value= tmp_cond_value;
 
10310
          break;
 
10311
        case Item::COND_FALSE:
 
10312
          if (and_level)
 
10313
          {
 
10314
            *cond_value= tmp_cond_value;
 
10315
            return (COND *) NULL;                       /* Always false */
 
10316
          }
 
10317
          break;
 
10318
        case Item::COND_TRUE:
 
10319
          if (! and_level)
 
10320
          {
 
10321
            *cond_value= tmp_cond_value;
 
10322
            return (COND *) NULL;                       /* Always true */
 
10323
          }
 
10324
          break;
 
10325
        case Item::COND_UNDEF:                  /* Impossible */
 
10326
          break; /* purecov: deadcode */
10325
10327
      }
10326
10328
    }
 
10329
 
10327
10330
    if (should_fix_fields)
10328
10331
      cond->update_used_tables();
10329
10332
 
10330
 
    if (!((Item_cond*) cond)->argument_list()->elements ||
10331
 
        *cond_value != Item::COND_OK)
10332
 
      return (COND*) 0;
 
10333
    if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)
 
10334
      return (COND*) NULL;
 
10335
 
10333
10336
    if (((Item_cond*) cond)->argument_list()->elements == 1)
10334
 
    {                                           // Remove list
 
10337
    {                                           
 
10338
      /* Argument list contains only one element, so reduce it so a single item, then remove list */
10335
10339
      item= ((Item_cond*) cond)->argument_list()->head();
10336
10340
      ((Item_cond*) cond)->argument_list()->empty();
10337
10341
      return item;
10338
10342
    }
10339
10343
  }
10340
 
  else if (cond->type() == Item::FUNC_ITEM &&
10341
 
           ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)
 
10344
  else if (cond->type() == Item::FUNC_ITEM && ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)
10342
10345
  {
10343
10346
    /*
10344
10347
      Handles this special case for some ODBC applications:
10350
10353
      SELECT * from table_name where auto_increment_column = LAST_INSERT_ID
10351
10354
    */
10352
10355
 
10353
 
    Item_func_isnull *func=(Item_func_isnull*) cond;
 
10356
    Item_func_isnull *func= (Item_func_isnull*) cond;
10354
10357
    Item **args= func->arguments();
10355
10358
    if (args[0]->type() == Item::FIELD_ITEM)
10356
10359
    {
10357
 
      Field *field=((Item_field*) args[0])->field;
10358
 
      if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&
10359
 
          (session->options & OPTION_AUTO_IS_NULL) &&
10360
 
          (session->first_successful_insert_id_in_prev_stmt > 0 &&
10361
 
           session->substitute_null_with_insert_id))
 
10360
      Field *field= ((Item_field*) args[0])->field;
 
10361
      if (field->flags & AUTO_INCREMENT_FLAG 
 
10362
          && ! field->table->maybe_null 
 
10363
          && session->options & OPTION_AUTO_IS_NULL
 
10364
          && (
 
10365
            session->first_successful_insert_id_in_prev_stmt > 0 
 
10366
            && session->substitute_null_with_insert_id
 
10367
            )
 
10368
          )
10362
10369
      {
10363
 
        COND *new_cond;
10364
 
        if ((new_cond= new Item_func_eq(args[0],
10365
 
                                        new Item_int("last_insert_id()",
10366
 
                                                     session->read_first_successful_insert_id_in_prev_stmt(),
10367
 
                                                     MY_INT64_NUM_DECIMAL_DIGITS))))
10368
 
        {
10369
 
          cond=new_cond;
 
10370
        COND *new_cond;
 
10371
        if ((new_cond= new Item_func_eq(args[0], new Item_int("last_insert_id()",
 
10372
                                                          session->read_first_successful_insert_id_in_prev_stmt(),
 
10373
                                                          MY_INT64_NUM_DECIMAL_DIGITS))))
 
10374
        {
 
10375
          cond= new_cond;
10370
10376
          /*
10371
10377
            Item_func_eq can't be fixed after creation so we do not check
10372
10378
            cond->fixed, also it do not need tables so we use 0 as second
10373
10379
            argument.
10374
10380
          */
10375
 
          cond->fix_fields(session, &cond);
10376
 
        }
 
10381
          cond->fix_fields(session, &cond);
 
10382
        }
10377
10383
        /*
10378
10384
          IS NULL should be mapped to LAST_INSERT_ID only for first row, so
10379
10385
          clear for next row
10380
10386
        */
10381
10387
        session->substitute_null_with_insert_id= false;
10382
10388
      }
 
10389
#ifdef NOTDEFINED
10383
10390
      /* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */
10384
 
      else if (((field->type() == DRIZZLE_TYPE_DATE) ||
10385
 
                (field->type() == DRIZZLE_TYPE_DATETIME)) &&
10386
 
                (field->flags & NOT_NULL_FLAG) &&
10387
 
               !field->table->maybe_null)
 
10391
      else if (
 
10392
          ((field->type() == DRIZZLE_TYPE_DATE) || (field->type() == DRIZZLE_TYPE_DATETIME)) 
 
10393
          && (field->flags & NOT_NULL_FLAG) 
 
10394
          && ! field->table->maybe_null)
10388
10395
      {
10389
 
        COND *new_cond;
10390
 
        if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))
10391
 
        {
10392
 
          cond=new_cond;
 
10396
        COND *new_cond;
 
10397
        if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))
 
10398
        {
 
10399
          cond= new_cond;
10393
10400
          /*
10394
10401
            Item_func_eq can't be fixed after creation so we do not check
10395
10402
            cond->fixed, also it do not need tables so we use 0 as second
10396
10403
            argument.
10397
10404
          */
10398
 
          cond->fix_fields(session, &cond);
10399
 
        }
 
10405
          cond->fix_fields(session, &cond);
 
10406
        }
10400
10407
      }
 
10408
#endif /* NOTDEFINED */
10401
10409
    }
10402
10410
    if (cond->const_item())
10403
10411
    {
10404
10412
      *cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;
10405
 
      return (COND*) 0;
 
10413
      return (COND *) NULL;
10406
10414
    }
10407
10415
  }
10408
10416
  else if (cond->const_item() && !cond->is_expensive())
10418
10426
  */
10419
10427
  {
10420
10428
    *cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;
10421
 
    return (COND*) 0;
 
10429
    return (COND *) NULL;
10422
10430
  }
10423
10431
  else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)
10424
 
  {                                             // boolan compare function
 
10432
  {                                             
 
10433
    /* boolan compare function */
10425
10434
    Item *left_item=    ((Item_func*) cond)->arguments()[0];
10426
10435
    Item *right_item= ((Item_func*) cond)->arguments()[1];
10427
10436
    if (left_item->eq(right_item,1))
10428
10437
    {
10429
 
      if (!left_item->maybe_null ||
10430
 
          ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)
10431
 
        return (COND*) 0;                       // Compare of identical items
 
10438
      if (!left_item->maybe_null || ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)
 
10439
              return (COND*) NULL;                      /* Comparison of identical items */
10432
10440
    }
10433
10441
  }
10434
 
  *cond_value=Item::COND_OK;
10435
 
  return cond;                                  // Point at next and level
 
10442
  *cond_value= Item::COND_OK;
 
10443
  return cond;                                  /* Point at next and return into recursion */
10436
10444
}
10437
10445
 
10438
10446
/*