← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_proto_write.cc

  • Committer: Brian Aker
  • Date: 2009-04-13 16:22:40 UTC
  • mfrom: (971.1.78 mordred)
  • Revision ID: brian@gaz-20090413162240-ugi3gvhofmcuglzl
Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_proto_write.cc
22
22
/* For proto */
23
23
#include <string>
24
24
#include <fstream>
25
 
#include <drizzled/serialize/serialize.h>
26
 
#include <drizzled/serialize/table.pb.h>
 
25
#include <drizzled/message/schema.pb.h>
 
26
#include <drizzled/message/table.pb.h>
27
27
#include <google/protobuf/io/zero_copy_stream.h>
28
28
#include <google/protobuf/io/zero_copy_stream_impl.h>
29
29
using namespace std;
30
30
 
31
 
int drizzle_read_table_proto(const char* path, drizzle::Table* table)
 
31
int drizzle_read_table_proto(const char* path, drizzled::message::Table* table)
32
32
{
33
33
  int fd= open(path, O_RDONLY);
34
34
 
50
50
  return 0;
51
51
}
52
52
 
53
 
static int fill_table_proto(drizzle::Table *table_proto,
 
53
static int fill_table_proto(drizzled::message::Table *table_proto,
54
54
                            const char *table_name,
55
55
                            List<Create_field> &create_fields,
56
56
                            HA_CREATE_INFO *create_info,
59
59
{
60
60
  Create_field *field_arg;
61
61
  List_iterator<Create_field> it(create_fields);
62
 
  drizzle::Table::StorageEngine *engine= table_proto->mutable_engine();
63
 
  drizzle::Table::TableOptions *table_options= table_proto->mutable_options();
 
62
  drizzled::message::Table::StorageEngine *engine= table_proto->mutable_engine();
 
63
  drizzled::message::Table::TableOptions *table_options= table_proto->mutable_options();
64
64
 
65
65
  if (create_fields.elements > MAX_FIELDS)
66
66
  {
71
71
  engine->set_name(create_info->db_type->getName());
72
72
 
73
73
  table_proto->set_name(table_name);
74
 
  table_proto->set_type(drizzle::Table::STANDARD);
 
74
  table_proto->set_type(drizzled::message::Table::STANDARD);
75
75
 
76
76
  while ((field_arg= it++))
77
77
  {
78
 
    drizzle::Table::Field *attribute;
 
78
    drizzled::message::Table::Field *attribute;
79
79
 
80
80
    attribute= table_proto->add_field();
81
81
    attribute->set_name(field_arg->field_name);
84
84
 
85
85
    if(f_maybe_null(field_arg->pack_flag))
86
86
    {
87
 
      drizzle::Table::Field::FieldConstraints *constraints;
 
87
      drizzled::message::Table::Field::FieldConstraints *constraints;
88
88
 
89
89
      constraints= attribute->mutable_constraints();
90
90
      constraints->set_is_nullable(true);
92
92
 
93
93
    switch (field_arg->sql_type) {
94
94
    case DRIZZLE_TYPE_TINY:
95
 
      attribute->set_type(drizzle::Table::Field::TINYINT);
 
95
      attribute->set_type(drizzled::message::Table::Field::TINYINT);
96
96
      break;
97
97
    case DRIZZLE_TYPE_LONG:
98
 
      attribute->set_type(drizzle::Table::Field::INTEGER);
 
98
      attribute->set_type(drizzled::message::Table::Field::INTEGER);
99
99
      break;
100
100
    case DRIZZLE_TYPE_DOUBLE:
101
 
      attribute->set_type(drizzle::Table::Field::DOUBLE);
 
101
      attribute->set_type(drizzled::message::Table::Field::DOUBLE);
102
102
      break;
103
103
    case DRIZZLE_TYPE_NULL  :
104
104
      assert(1); /* Not a user definable type */
105
105
    case DRIZZLE_TYPE_TIMESTAMP:
106
 
      attribute->set_type(drizzle::Table::Field::TIMESTAMP);
 
106
      attribute->set_type(drizzled::message::Table::Field::TIMESTAMP);
107
107
      break;
108
108
    case DRIZZLE_TYPE_LONGLONG:
109
 
      attribute->set_type(drizzle::Table::Field::BIGINT);
 
109
      attribute->set_type(drizzled::message::Table::Field::BIGINT);
110
110
      break;
111
111
    case DRIZZLE_TYPE_DATETIME:
112
 
      attribute->set_type(drizzle::Table::Field::DATETIME);
 
112
      attribute->set_type(drizzled::message::Table::Field::DATETIME);
113
113
      break;
114
114
    case DRIZZLE_TYPE_DATE:
115
 
      attribute->set_type(drizzle::Table::Field::DATE);
 
115
      attribute->set_type(drizzled::message::Table::Field::DATE);
116
116
      break;
117
117
    case DRIZZLE_TYPE_VARCHAR:
118
118
      {
119
 
        drizzle::Table::Field::StringFieldOptions *string_field_options;
 
119
        drizzled::message::Table::Field::StringFieldOptions *string_field_options;
120
120
 
121
121
        string_field_options= attribute->mutable_string_options();
122
 
        attribute->set_type(drizzle::Table::Field::VARCHAR);
 
122
        attribute->set_type(drizzled::message::Table::Field::VARCHAR);
123
123
        string_field_options->set_length(field_arg->length
124
124
                                         / field_arg->charset->mbmaxlen);
125
125
        string_field_options->set_collation_id(field_arg->charset->number);
129
129
      }
130
130
    case DRIZZLE_TYPE_NEWDECIMAL:
131
131
      {
132
 
        drizzle::Table::Field::NumericFieldOptions *numeric_field_options;
 
132
        drizzled::message::Table::Field::NumericFieldOptions *numeric_field_options;
133
133
 
134
 
        attribute->set_type(drizzle::Table::Field::DECIMAL);
 
134
        attribute->set_type(drizzled::message::Table::Field::DECIMAL);
135
135
        numeric_field_options= attribute->mutable_numeric_options();
136
136
        /* This is magic, I hate magic numbers -Brian */
137
137
        numeric_field_options->set_precision(field_arg->length + ( field_arg->decimals ? -2 : -1));
140
140
      }
141
141
    case DRIZZLE_TYPE_ENUM:
142
142
      {
143
 
        drizzle::Table::Field::SetFieldOptions *set_field_options;
 
143
        drizzled::message::Table::Field::SetFieldOptions *set_field_options;
144
144
 
145
145
        assert(field_arg->interval);
146
146
 
147
 
        attribute->set_type(drizzle::Table::Field::ENUM);
 
147
        attribute->set_type(drizzled::message::Table::Field::ENUM);
148
148
        set_field_options= attribute->mutable_set_options();
149
149
 
150
150
        for (uint32_t pos= 0; pos < field_arg->interval->count; pos++)
160
160
      }
161
161
    case DRIZZLE_TYPE_BLOB:
162
162
      {
163
 
        attribute->set_type(drizzle::Table::Field::BLOB);
 
163
        attribute->set_type(drizzled::message::Table::Field::BLOB);
164
164
 
165
 
        drizzle::Table::Field::StringFieldOptions *string_field_options;
 
165
        drizzled::message::Table::Field::StringFieldOptions *string_field_options;
166
166
 
167
167
        string_field_options= attribute->mutable_string_options();
168
168
        string_field_options->set_collation_id(field_arg->charset->number);
191
191
        return(1);
192
192
      }
193
193
 
194
 
      drizzle::Table::Field::VirtualFieldOptions *field_options;
 
194
      drizzled::message::Table::Field::VirtualFieldOptions *field_options;
195
195
 
196
196
      field_options= attribute->mutable_virtual_options();
197
197
 
198
198
      field_options->set_type(attribute->type());
199
 
      attribute->set_type(drizzle::Table::Field::VIRTUAL);
 
199
      attribute->set_type(drizzled::message::Table::Field::VIRTUAL);
200
200
 
201
201
      string expr(field_arg->vcol_info->expr_str.str,
202
202
                  field_arg->vcol_info->expr_str.length);
215
215
    case COLUMN_FORMAT_TYPE_NOT_USED:
216
216
      break;
217
217
    case COLUMN_FORMAT_TYPE_DEFAULT:
218
 
      attribute->set_format(drizzle::Table::Field::DefaultFormat);
 
218
      attribute->set_format(drizzled::message::Table::Field::DefaultFormat);
219
219
      break;
220
220
    case COLUMN_FORMAT_TYPE_FIXED:
221
 
      attribute->set_format(drizzle::Table::Field::FixedFormat);
 
221
      attribute->set_format(drizzled::message::Table::Field::FixedFormat);
222
222
      break;
223
223
    case COLUMN_FORMAT_TYPE_DYNAMIC:
224
 
      attribute->set_format(drizzle::Table::Field::DynamicFormat);
 
224
      attribute->set_format(drizzled::message::Table::Field::DynamicFormat);
225
225
      break;
226
226
    default:
227
227
      assert(0); /* Tell us, since this shouldn't happend */
249
249
 
250
250
    if(field_arg->unireg_check == Field::NEXT_NUMBER)
251
251
    {
252
 
      drizzle::Table::Field::NumericFieldOptions *field_options;
 
252
      drizzled::message::Table::Field::NumericFieldOptions *field_options;
253
253
      field_options= attribute->mutable_numeric_options();
254
254
      field_options->set_is_autoincrement(true);
255
255
    }
257
257
    if(field_arg->unireg_check == Field::TIMESTAMP_DN_FIELD
258
258
       || field_arg->unireg_check == Field::TIMESTAMP_DNUN_FIELD)
259
259
    {
260
 
      drizzle::Table::Field::FieldOptions *field_options;
 
260
      drizzled::message::Table::Field::FieldOptions *field_options;
261
261
      field_options= attribute->mutable_options();
262
262
      field_options->set_default_value("NOW()");
263
263
    }
265
265
    if(field_arg->unireg_check == Field::TIMESTAMP_UN_FIELD
266
266
       || field_arg->unireg_check == Field::TIMESTAMP_DNUN_FIELD)
267
267
    {
268
 
      drizzle::Table::Field::FieldOptions *field_options;
 
268
      drizzled::message::Table::Field::FieldOptions *field_options;
269
269
      field_options= attribute->mutable_options();
270
270
      field_options->set_update_value("NOW()");
271
271
    }
272
272
 
273
273
    if(field_arg->def)
274
274
    {
275
 
      drizzle::Table::Field::FieldOptions *field_options;
 
275
      drizzled::message::Table::Field::FieldOptions *field_options;
276
276
      field_options= attribute->mutable_options();
277
277
 
278
278
      if(field_arg->def->is_null())
313
313
    }
314
314
 
315
315
    {
316
 
      drizzle::Table::Field::FieldOptions *field_options;
 
316
      drizzled::message::Table::Field::FieldOptions *field_options;
317
317
      field_options= attribute->mutable_options();
318
318
 
319
319
      field_options->set_length(field_arg->length);
377
377
  switch(create_info->row_type)
378
378
  {
379
379
  case ROW_TYPE_DEFAULT:
380
 
    table_options->set_row_type(drizzle::Table::TableOptions::ROW_TYPE_DEFAULT);
 
380
    table_options->set_row_type(drizzled::message::Table::TableOptions::ROW_TYPE_DEFAULT);
381
381
    break;
382
382
  case ROW_TYPE_FIXED:
383
 
    table_options->set_row_type(drizzle::Table::TableOptions::ROW_TYPE_FIXED);
 
383
    table_options->set_row_type(drizzled::message::Table::TableOptions::ROW_TYPE_FIXED);
384
384
    break;
385
385
  case ROW_TYPE_DYNAMIC:
386
 
    table_options->set_row_type(drizzle::Table::TableOptions::ROW_TYPE_DYNAMIC);
 
386
    table_options->set_row_type(drizzled::message::Table::TableOptions::ROW_TYPE_DYNAMIC);
387
387
    break;
388
388
  case ROW_TYPE_COMPRESSED:
389
 
    table_options->set_row_type(drizzle::Table::TableOptions::ROW_TYPE_COMPRESSED);
 
389
    table_options->set_row_type(drizzled::message::Table::TableOptions::ROW_TYPE_COMPRESSED);
390
390
    break;
391
391
  case ROW_TYPE_REDUNDANT:
392
 
    table_options->set_row_type(drizzle::Table::TableOptions::ROW_TYPE_REDUNDANT);
 
392
    table_options->set_row_type(drizzled::message::Table::TableOptions::ROW_TYPE_REDUNDANT);
393
393
    break;
394
394
  case ROW_TYPE_COMPACT:
395
 
    table_options->set_row_type(drizzle::Table::TableOptions::ROW_TYPE_COMPACT);
 
395
    table_options->set_row_type(drizzled::message::Table::TableOptions::ROW_TYPE_COMPACT);
396
396
    break;
397
397
  case ROW_TYPE_PAGE:
398
 
    table_options->set_row_type(drizzle::Table::TableOptions::ROW_TYPE_PAGE);
 
398
    table_options->set_row_type(drizzled::message::Table::TableOptions::ROW_TYPE_PAGE);
399
399
    break;
400
400
  default:
401
401
    abort();
459
459
 
460
460
  for (unsigned int i= 0; i < keys; i++)
461
461
  {
462
 
    drizzle::Table::Index *idx;
 
462
    drizzled::message::Table::Index *idx;
463
463
 
464
464
    idx= table_proto->add_indexes();
465
465
 
478
478
    switch(key_info[i].algorithm)
479
479
    {
480
480
    case HA_KEY_ALG_HASH:
481
 
      idx->set_type(drizzle::Table::Index::HASH);
 
481
      idx->set_type(drizzled::message::Table::Index::HASH);
482
482
      break;
483
483
 
484
484
    case HA_KEY_ALG_BTREE:
485
 
      idx->set_type(drizzle::Table::Index::BTREE);
 
485
      idx->set_type(drizzled::message::Table::Index::BTREE);
486
486
      break;
487
487
 
488
488
    case HA_KEY_ALG_RTREE:
489
 
      idx->set_type(drizzle::Table::Index::RTREE);
 
489
      idx->set_type(drizzled::message::Table::Index::RTREE);
490
490
    case HA_KEY_ALG_FULLTEXT:
491
 
      idx->set_type(drizzle::Table::Index::FULLTEXT);
 
491
      idx->set_type(drizzled::message::Table::Index::FULLTEXT);
492
492
    case HA_KEY_ALG_UNDEF:
493
 
      idx->set_type(drizzle::Table::Index::UNKNOWN_INDEX);
 
493
      idx->set_type(drizzled::message::Table::Index::UNKNOWN_INDEX);
494
494
      break;
495
495
 
496
496
    default:
502
502
    else
503
503
      idx->set_is_unique(false);
504
504
 
505
 
    drizzle::Table::Index::IndexOptions *index_options= idx->mutable_options();
 
505
    drizzled::message::Table::Index::IndexOptions *index_options= idx->mutable_options();
506
506
 
507
507
    if(key_info[i].flags & HA_USES_BLOCK_SIZE)
508
508
      index_options->set_key_block_size(key_info[i].block_size);
549
549
 
550
550
    for(unsigned int j=0; j< key_info[i].key_parts; j++)
551
551
    {
552
 
      drizzle::Table::Index::IndexPart *idxpart;
 
552
      drizzled::message::Table::Index::IndexPart *idxpart;
553
553
 
554
554
      idxpart= idx->add_index_part();
555
555
 
621
621
                                   uint32_t keys,
622
622
                                   KEY *key_info)
623
623
{
624
 
  drizzle::Table table_proto;
 
624
  drizzled::message::Table table_proto;
625
625
  string new_path(file_name);
626
626
  string file_ext = ".dfe";
627
627