← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/table.cc

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/table.cc
1273
1273
  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
1274
1274
                                             share->column_bitmap_size)))
1275
1275
    goto err;
1276
 
  bitmap_init(&share->all_set, bitmaps, share->fields, FALSE);
 
1276
  bitmap_init(&share->all_set, bitmaps, share->fields, false);
1277
1277
  bitmap_set_all(&share->all_set);
1278
1278
 
1279
1279
  delete handler_file;
1280
 
#ifndef DBUG_OFF
1281
 
  if (use_hash)
1282
 
    (void) hash_check(&share->name_hash);
1283
 
#endif
1284
1280
  if (buff)
1285
1281
    my_free(buff, MYF(0));
1286
1282
  return (0);
1335
1331
{
1336
1332
  int error;
1337
1333
  uint records, i, bitmap_size;
1338
 
  bool error_reported= FALSE;
 
1334
  bool error_reported= false;
1339
1335
  uchar *record, *bitmaps;
1340
1336
  Field **field_ptr;
1341
1337
 
1493
1489
  if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root, bitmap_size*3)))
1494
1490
    goto err;
1495
1491
  bitmap_init(&outparam->def_read_set,
1496
 
              (my_bitmap_map*) bitmaps, share->fields, FALSE);
 
1492
              (my_bitmap_map*) bitmaps, share->fields, false);
1497
1493
  bitmap_init(&outparam->def_write_set,
1498
 
              (my_bitmap_map*) (bitmaps+bitmap_size), share->fields, FALSE);
 
1494
              (my_bitmap_map*) (bitmaps+bitmap_size), share->fields, false);
1499
1495
  bitmap_init(&outparam->tmp_set,
1500
 
              (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields, FALSE);
 
1496
              (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields, false);
1501
1497
  outparam->default_column_bitmaps();
1502
1498
 
1503
1499
  /* The table struct is now initialized;  Open the table */
1541
1537
          break;
1542
1538
        default:
1543
1539
          outparam->file->print_error(ha_err, MYF(0));
1544
 
          error_reported= TRUE;
 
1540
          error_reported= true;
1545
1541
          if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
1546
1542
            error= 7;
1547
1543
          break;
1550
1546
    }
1551
1547
  }
1552
1548
 
1553
 
#if defined(HAVE_purify) && !defined(DBUG_OFF)
 
1549
#if defined(HAVE_purify) 
1554
1550
  bzero((char*) bitmaps, bitmap_size*3);
1555
1551
#endif
1556
1552
 
2305
2301
bool check_column_name(const char *name)
2306
2302
{
2307
2303
  uint name_length= 0;  // name length in symbols
2308
 
  bool last_char_is_space= TRUE;
 
2304
  bool last_char_is_space= true;
2309
2305
  
2310
2306
  while (*name)
2311
2307
  {
2351
2347
  @param[in] table_def         Expected structure of the table (column name
2352
2348
                               and type)
2353
2349
 
2354
 
  @retval  FALSE  OK
 
2350
  @retval  false  OK
2355
2351
  @retval  TRUE   There was an error. An error message is output
2356
2352
                  to the error log.  We do not push an error
2357
2353
                  message into the error stack because this
2364
2360
                   const TABLE_FIELD_W_TYPE *table_def)
2365
2361
{
2366
2362
  uint i;
2367
 
  my_bool error= FALSE;
 
2363
  my_bool error= false;
2368
2364
  my_bool fields_diff_count;
2369
2365
 
2370
2366
  fields_diff_count= (table->s->fields != table_f_count);
2377
2373
      sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE),
2378
2374
                      table->alias, table_f_count, table->s->fields,
2379
2375
                      table->s->mysql_version, MYSQL_VERSION_ID);
2380
 
      return(TRUE);
 
2376
      return(true);
2381
2377
    }
2382
2378
    else if (MYSQL_VERSION_ID == table->s->mysql_version)
2383
2379
    {
2384
2380
      sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED), table->alias,
2385
2381
                      table_f_count, table->s->fields);
2386
 
      return(TRUE);
 
2382
      return(true);
2387
2383
    }
2388
2384
    /*
2389
2385
      Something has definitely changed, but we're running an older
2441
2437
                        "%s, found type %s.", table->s->db.str, table->alias,
2442
2438
                        table_def->name.str, i, table_def->type.str,
2443
2439
                        sql_type.c_ptr_safe());
2444
 
        error= TRUE;
 
2440
        error= true;
2445
2441
      }
2446
2442
      else if (table_def->cset.str && !field->has_charset())
2447
2443
      {
2450
2446
                        "to have character set '%s' but the type has no "
2451
2447
                        "character set.", table->s->db.str, table->alias,
2452
2448
                        table_def->name.str, i, table_def->cset.str);
2453
 
        error= TRUE;
 
2449
        error= true;
2454
2450
      }
2455
2451
      else if (table_def->cset.str &&
2456
2452
               strcmp(field->charset()->csname, table_def->cset.str))
2461
2457
                        "character set '%s'.", table->s->db.str, table->alias,
2462
2458
                        table_def->name.str, i, table_def->cset.str,
2463
2459
                        field->charset()->csname);
2464
 
        error= TRUE;
 
2460
        error= true;
2465
2461
      }
2466
2462
    }
2467
2463
    else
2471
2467
                      " but the column is not found.",
2472
2468
                      table->s->db.str, table->alias,
2473
2469
                      table_def->name.str, i, table_def->type.str);
2474
 
      error= TRUE;
 
2470
      error= true;
2475
2471
    }
2476
2472
  }
2477
2473
  return(error);
2505
2501
  {
2506
2502
    Item_field *item= new Item_field(*ptr);
2507
2503
    if (!item || item_list->push_back(item))
2508
 
      return TRUE;
 
2504
      return true;
2509
2505
  }
2510
 
  return FALSE;
 
2506
  return false;
2511
2507
}
2512
2508
 
2513
2509
/*
2629
2625
    mem_root   memory pool for allocating
2630
2626
 
2631
2627
  RETURN
2632
 
    FALSE - OK
 
2628
    false - OK
2633
2629
    TRUE  - out of memory
2634
2630
*/
2635
2631
 
2640
2636
    if (!table->insert_values &&
2641
2637
        !(table->insert_values= (uchar *)alloc_root(mem_root,
2642
2638
                                                   table->s->rec_buff_length)))
2643
 
      return TRUE;
 
2639
      return true;
2644
2640
  }
2645
2641
 
2646
 
  return FALSE;
 
2642
  return false;
2647
2643
}
2648
2644
 
2649
2645
 
2661
2657
    columns.
2662
2658
 
2663
2659
  RETURN
2664
 
    TRUE if a leaf, FALSE otherwise.
 
2660
    TRUE if a leaf, false otherwise.
2665
2661
*/
2666
2662
bool TABLE_LIST::is_leaf_for_name_resolution()
2667
2663
{
2790
2786
  view_field= field_param;
2791
2787
  table_field= NULL;
2792
2788
  table_ref= tab;
2793
 
  is_common= FALSE;
 
2789
  is_common= false;
2794
2790
}
2795
2791
 
2796
2792
 
2801
2797
  table_field= field_param;
2802
2798
  view_field= NULL;
2803
2799
  table_ref= tab;
2804
 
  is_common= FALSE;
 
2800
  is_common= false;
2805
2801
}
2806
2802
 
2807
2803
 
3076
3072
Field_iterator_table_ref::get_or_create_column_ref(TABLE_LIST *parent_table_ref)
3077
3073
{
3078
3074
  Natural_join_column *nj_col;
3079
 
  bool is_created= TRUE;
 
3075
  bool is_created= true;
3080
3076
  uint field_count;
3081
3077
  TABLE_LIST *add_table_ref= parent_table_ref ?
3082
3078
                             parent_table_ref : table_ref;
3104
3100
      we just return the already created column reference.
3105
3101
    */
3106
3102
    assert(table_ref->is_join_columns_complete);
3107
 
    is_created= FALSE;
 
3103
    is_created= false;
3108
3104
    nj_col= natural_join_it.column_ref();
3109
3105
    assert(nj_col);
3110
3106
  }
3125
3121
      /* Create a list of natural join columns on demand. */
3126
3122
      if (!(add_table_ref->join_columns= new List<Natural_join_column>))
3127
3123
        return NULL;
3128
 
      add_table_ref->is_join_columns_complete= FALSE;
 
3124
      add_table_ref->is_join_columns_complete= false;
3129
3125
    }
3130
3126
    add_table_ref->join_columns->push_back(nj_col);
3131
3127
    /*
3137
3133
    */
3138
3134
    if (!parent_table_ref &&
3139
3135
        add_table_ref->join_columns->elements == field_count)
3140
 
      add_table_ref->is_join_columns_complete= TRUE;
 
3136
      add_table_ref->is_join_columns_complete= true;
3141
3137
  }
3142
3138
 
3143
3139
  return nj_col;
3513
3509
    then we have to ignore the IGNORE INDEX FROM GROUP/ORDER.
3514
3510
 
3515
3511
  RETURN VALUE
3516
 
    FALSE                no errors found
 
3512
    false                no errors found
3517
3513
    TRUE                 found and reported an error.
3518
3514
*/
3519
3515
bool TABLE_LIST::process_index_hints(TABLE *tbl)
3530
3526
    key_map index_group[INDEX_HINT_FORCE + 1];
3531
3527
    Index_hint *hint;
3532
3528
    int type;
3533
 
    bool have_empty_use_join= FALSE, have_empty_use_order= FALSE, 
3534
 
         have_empty_use_group= FALSE;
 
3529
    bool have_empty_use_join= false, have_empty_use_order= false, 
 
3530
         have_empty_use_group= false;
3535
3531
    List_iterator <Index_hint> iter(*index_hints);
3536
3532
 
3537
3533
    /* initialize temporary variables used to collect hints of each kind */
3553
3549
        if (hint->clause & INDEX_HINT_MASK_JOIN)
3554
3550
        {
3555
3551
          index_join[hint->type].clear_all();
3556
 
          have_empty_use_join= TRUE;
 
3552
          have_empty_use_join= true;
3557
3553
        }
3558
3554
        if (hint->clause & INDEX_HINT_MASK_ORDER)
3559
3555
        {
3560
3556
          index_order[hint->type].clear_all();
3561
 
          have_empty_use_order= TRUE;
 
3557
          have_empty_use_order= true;
3562
3558
        }
3563
3559
        if (hint->clause & INDEX_HINT_MASK_GROUP)
3564
3560
        {
3565
3561
          index_group[hint->type].clear_all();
3566
 
          have_empty_use_group= TRUE;
 
3562
          have_empty_use_group= true;
3567
3563
        }
3568
3564
        continue;
3569
3565
      }
3609
3605
        !index_order[INDEX_HINT_FORCE].is_clear_all() ||
3610
3606
        !index_group[INDEX_HINT_FORCE].is_clear_all())
3611
3607
    {
3612
 
      tbl->force_index= TRUE;
 
3608
      tbl->force_index= true;
3613
3609
      index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
3614
3610
      index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
3615
3611
      index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);