← Back to branch summary

~posulliv/drizzle/optimizer-style-cleanup

« back to all changes in this revision

Viewing changes to drizzled/table_proto_write.cc

  • Committer: Padraig O'Sullivan
  • Date: 2010-04-17 01:38:47 UTC
  • mfrom: (1237.9.238 bad-staging)
  • Revision ID: osullivan.padraig@gmail.com-20100417013847-ibjioqsfbmf5yg4g
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_proto_write.cc
40
40
namespace drizzled {
41
41
 
42
42
static int fill_table_proto(message::Table &table_proto,
43
 
                            const char *table_name,
 
43
                            const std::string &table_name,
44
44
                            List<CreateField> &create_fields,
45
45
                            HA_CREATE_INFO *create_info,
46
46
                            uint32_t keys,
59
59
  assert(strcmp(table_proto.engine().name().c_str(),
60
60
                create_info->db_type->getName().c_str())==0);
61
61
 
62
 
  assert(strcmp(table_proto.name().c_str(),table_name)==0);
 
62
  assert(table_proto.name() == table_name);
63
63
 
64
64
  int field_number= 0;
65
65
  bool use_existing_fields= table_proto.field_size() > 0;
78
78
      /* Other code paths still have to fill out the proto */
79
79
      attribute= table_proto.add_field();
80
80
 
81
 
      if(field_arg->flags & NOT_NULL_FLAG)
 
81
      if (field_arg->flags & NOT_NULL_FLAG)
82
82
      {
83
83
        message::Table::Field::FieldConstraints *constraints;
84
84
 
148
148
      }
149
149
    case message::Table::Field::ENUM:
150
150
      {
151
 
        message::Table::Field::SetFieldOptions *set_field_options;
 
151
        message::Table::Field::EnumerationValues *enumeration_options;
152
152
 
153
153
        assert(field_arg->interval);
154
154
 
155
 
        set_field_options= attribute->mutable_set_options();
 
155
        enumeration_options= attribute->mutable_enumeration_values();
156
156
 
157
157
        for (uint32_t pos= 0; pos < field_arg->interval->count; pos++)
158
158
        {
159
159
          const char *src= field_arg->interval->type_names[pos];
160
160
 
161
 
          set_field_options->add_field_value(src);
 
161
          enumeration_options->add_field_value(src);
162
162
        }
163
 
        set_field_options->set_count_elements(set_field_options->field_value_size());
164
 
        set_field_options->set_collation_id(field_arg->charset->number);
165
 
        set_field_options->set_collation(field_arg->charset->name);
 
163
        enumeration_options->set_collation_id(field_arg->charset->number);
 
164
        enumeration_options->set_collation(field_arg->charset->name);
166
165
        break;
167
166
      }
168
167
    case message::Table::Field::BLOB:
224
223
      assert(strcmp(attribute->comment().c_str(), field_arg->comment.str)==0);
225
224
    }
226
225
 
227
 
    if(field_arg->unireg_check == Field::NEXT_NUMBER)
 
226
    if (field_arg->unireg_check == Field::NEXT_NUMBER)
228
227
    {
229
228
      message::Table::Field::NumericFieldOptions *field_options;
230
229
      field_options= attribute->mutable_numeric_options();
231
230
      field_options->set_is_autoincrement(true);
232
231
    }
233
232
 
234
 
    if(field_arg->unireg_check == Field::TIMESTAMP_DN_FIELD
 
233
    if (field_arg->unireg_check == Field::TIMESTAMP_DN_FIELD
235
234
       || field_arg->unireg_check == Field::TIMESTAMP_DNUN_FIELD)
236
235
    {
237
236
      message::Table::Field::FieldOptions *field_options;
239
238
      field_options->set_default_value("NOW()");
240
239
    }
241
240
 
242
 
    if(field_arg->unireg_check == Field::TIMESTAMP_UN_FIELD
 
241
    if (field_arg->unireg_check == Field::TIMESTAMP_UN_FIELD
243
242
       || field_arg->unireg_check == Field::TIMESTAMP_DNUN_FIELD)
244
243
    {
245
244
      message::Table::Field::FieldOptions *field_options;
254
253
 
255
254
      field_options->set_default_null(true);
256
255
    }
257
 
    if(field_arg->def)
 
256
    if (field_arg->def)
258
257
    {
259
258
      message::Table::Field::FieldOptions *field_options;
260
259
      field_options= attribute->mutable_options();
261
260
 
262
 
      if(field_arg->def->is_null())
 
261
      if (field_arg->def->is_null())
263
262
      {
264
263
        field_options->set_default_null(true);
265
264
      }
270
269
 
271
270
        assert(default_value);
272
271
 
273
 
        if((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
 
272
        if ((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
274
273
           || field_arg->sql_type==DRIZZLE_TYPE_BLOB)
275
274
           && ((field_arg->length / field_arg->charset->mbmaxlen)
276
275
           < default_value->length()))
279
278
          return 1;
280
279
        }
281
280
 
282
 
        if((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
 
281
        if ((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
283
282
            && field_arg->charset==&my_charset_bin)
284
283
           || (field_arg->sql_type==DRIZZLE_TYPE_BLOB
285
284
            && field_arg->charset==&my_charset_bin))
306
305
 
307
306
  assert(! use_existing_fields || (field_number == table_proto.field_size()));
308
307
 
309
 
  switch(create_info->row_type)
310
 
  {
311
 
  case ROW_TYPE_DEFAULT:
312
 
    /* No use setting a default row type... just adds redundant info to message */
313
 
    break;
314
 
  case ROW_TYPE_FIXED:
315
 
    table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_FIXED);
316
 
    break;
317
 
  case ROW_TYPE_DYNAMIC:
318
 
    table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_DYNAMIC);
319
 
    break;
320
 
  case ROW_TYPE_COMPRESSED:
321
 
    table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_COMPRESSED);
322
 
    break;
323
 
  case ROW_TYPE_REDUNDANT:
324
 
    table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_REDUNDANT);
325
 
    break;
326
 
  case ROW_TYPE_COMPACT:
327
 
    table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_COMPACT);
328
 
    break;
329
 
  case ROW_TYPE_PAGE:
330
 
    table_options->set_row_type(message::Table::TableOptions::ROW_TYPE_PAGE);
331
 
    break;
332
 
  default:
333
 
    abort();
334
 
  }
335
 
 
336
308
  if (create_info->table_options & HA_OPTION_PACK_RECORD)
337
309
    table_options->set_pack_record(true);
338
310
 
377
349
 
378
350
    idx->set_key_length(key_info[i].key_length);
379
351
 
380
 
    if(is_primary_key_name(key_info[i].name))
 
352
    if (is_primary_key_name(key_info[i].name))
381
353
      idx->set_is_primary(true);
382
354
    else
383
355
      idx->set_is_primary(false);
407
379
 
408
380
    message::Table::Index::IndexOptions *index_options= idx->mutable_options();
409
381
 
410
 
    if(key_info[i].flags & HA_USES_BLOCK_SIZE)
 
382
    if (key_info[i].flags & HA_USES_BLOCK_SIZE)
411
383
      index_options->set_key_block_size(key_info[i].block_size);
412
384
 
413
 
    if(key_info[i].flags & HA_PACK_KEY)
 
385
    if (key_info[i].flags & HA_PACK_KEY)
414
386
      index_options->set_pack_key(true);
415
387
 
416
 
    if(key_info[i].flags & HA_BINARY_PACK_KEY)
 
388
    if (key_info[i].flags & HA_BINARY_PACK_KEY)
417
389
      index_options->set_binary_pack_key(true);
418
390
 
419
 
    if(key_info[i].flags & HA_VAR_LENGTH_PART)
 
391
    if (key_info[i].flags & HA_VAR_LENGTH_PART)
420
392
      index_options->set_var_length_key(true);
421
393
 
422
 
    if(key_info[i].flags & HA_NULL_PART_KEY)
 
394
    if (key_info[i].flags & HA_NULL_PART_KEY)
423
395
      index_options->set_null_part_key(true);
424
396
 
425
 
    if(key_info[i].flags & HA_KEY_HAS_PART_KEY_SEG)
 
397
    if (key_info[i].flags & HA_KEY_HAS_PART_KEY_SEG)
426
398
      index_options->set_has_partial_segments(true);
427
399
 
428
 
    if(key_info[i].flags & HA_GENERATED_KEY)
 
400
    if (key_info[i].flags & HA_GENERATED_KEY)
429
401
      index_options->set_auto_generated_key(true);
430
402
 
431
403
    if (key_info[i].flags & HA_USES_COMMENT)
471
443
  return 0;
472
444
}
473
445
 
474
 
int rename_table_proto_file(const char *from, const char* to)
475
 
{
476
 
  string from_path(from);
477
 
  string to_path(to);
478
 
  string file_ext = ".dfe";
479
 
 
480
 
  from_path.append(file_ext);
481
 
  to_path.append(file_ext);
482
 
 
483
 
  return internal::my_rename(from_path.c_str(),to_path.c_str(),MYF(MY_WME));
484
 
}
485
 
 
486
 
int delete_table_proto_file(const char *file_name)
487
 
{
488
 
  string new_path(file_name);
489
 
  string file_ext = ".dfe";
490
 
 
491
 
  new_path.append(file_ext);
492
 
  return internal::my_delete(new_path.c_str(), MYF(0));
493
 
}
494
 
 
495
446
/*
496
447
  Create a table definition proto file and the tables
497
448
 
511
462
    1  error
512
463
*/
513
464
 
514
 
int rea_create_table(Session *session,
515
 
                     TableIdentifier &identifier,
516
 
                     message::Table &table_proto,
517
 
                     HA_CREATE_INFO *create_info,
518
 
                     List<CreateField> &create_fields,
519
 
                     uint32_t keys, KEY *key_info)
 
465
bool rea_create_table(Session *session,
 
466
                      TableIdentifier &identifier,
 
467
                      message::Table &table_proto,
 
468
                      HA_CREATE_INFO *create_info,
 
469
                      List<CreateField> &create_fields,
 
470
                      uint32_t keys, KEY *key_info)
520
471
{
521
472
  if (fill_table_proto(table_proto, identifier.getTableName(), create_fields, create_info,
522
 
                      keys, key_info))
523
 
    return 1;
 
473
                       keys, key_info))
 
474
    return false;
524
475
 
525
476
  if (plugin::StorageEngine::createTable(*session,
526
477
                                         identifier,
527
478
                                         false, table_proto))
528
479
  {
529
 
    return 1;
 
480
    return false;
530
481
  }
531
482
 
532
 
  return 0;
 
483
  return true;
533
484
 
534
485
} /* rea_create_table */
535
486