← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_proto_write.cc

  • Committer: lbieber
  • Date: 2010-10-02 19:48:35 UTC
  • mfrom: (1730.6.19 drizzle-make-lcov)
  • Revision ID: lbieber@orisndriz08-20101002194835-q5zd9qc4lvx1xnfo
Merge Hartmut - clean up lex, now require flex to build, also "make lcov" improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_proto_write.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
#include "config.h"
17
17
#include <drizzled/error.h>
21
21
#include "drizzled/global_charset_info.h"
22
22
#include "drizzled/message/statement_transform.h"
23
23
 
24
 
#include <drizzled/plugin/storage_engine.h>
25
 
 
26
24
#include "drizzled/internal/my_sys.h"
27
25
 
28
26
 
45
43
 
46
44
namespace drizzled {
47
45
 
48
 
bool fill_table_proto(message::Table &table_proto,
49
 
                      List<CreateField> &create_fields,
50
 
                      HA_CREATE_INFO *create_info,
51
 
                      uint32_t keys,
52
 
                      KeyInfo *key_info)
 
46
static int fill_table_proto(message::Table &table_proto,
 
47
                            List<CreateField> &create_fields,
 
48
                            HA_CREATE_INFO *create_info,
 
49
                            uint32_t keys,
 
50
                            KeyInfo *key_info)
53
51
{
54
52
  CreateField *field_arg;
55
53
  List_iterator<CreateField> it(create_fields);
58
56
  if (create_fields.elements > MAX_FIELDS)
59
57
  {
60
58
    my_error(ER_TOO_MANY_FIELDS, MYF(0), ER(ER_TOO_MANY_FIELDS));
61
 
    return true;
 
59
    return(1);
62
60
  }
63
61
 
64
62
  assert(strcmp(table_proto.engine().name().c_str(),
75
73
       filled out Field messages */
76
74
 
77
75
    if (use_existing_fields)
78
 
    {
79
76
      attribute= table_proto.mutable_field(field_number++);
80
 
    }
81
77
    else
82
78
    {
83
79
      /* Other code paths still have to fill out the proto */
85
81
 
86
82
      if (field_arg->flags & NOT_NULL_FLAG)
87
83
      {
88
 
        attribute->mutable_constraints()->set_is_notnull(true);
89
 
      }
 
84
        message::Table::Field::FieldConstraints *constraints;
90
85
 
91
 
      if (field_arg->flags & UNSIGNED_FLAG and 
92
 
          (field_arg->sql_type == DRIZZLE_TYPE_LONGLONG or field_arg->sql_type == DRIZZLE_TYPE_LONG))
93
 
      {
94
 
        field_arg->sql_type= DRIZZLE_TYPE_LONGLONG;
95
 
        attribute->mutable_constraints()->set_is_unsigned(true);
 
86
        constraints= attribute->mutable_constraints();
 
87
        constraints->set_is_nullable(false);
96
88
      }
97
89
 
98
90
      attribute->set_name(field_arg->field_name);
99
91
    }
100
92
 
101
 
    assert(((field_arg->flags & NOT_NULL_FLAG)) == attribute->constraints().is_notnull());
 
93
    assert((!(field_arg->flags & NOT_NULL_FLAG)) == attribute->constraints().is_nullable());
102
94
    assert(strcmp(attribute->name().c_str(), field_arg->field_name)==0);
103
95
 
104
96
 
105
97
    message::Table::Field::FieldType parser_type= attribute->type();
106
98
 
107
 
    if (field_arg->sql_type == DRIZZLE_TYPE_NULL)
108
 
    {
109
 
      my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), table_proto.name().c_str(), -1);
110
 
      return true;
111
 
    }
112
 
 
113
 
    if (field_arg->flags & UNSIGNED_FLAG and 
114
 
       (field_arg->sql_type == DRIZZLE_TYPE_LONGLONG or field_arg->sql_type == DRIZZLE_TYPE_LONG))
115
 
    {
116
 
      message::Table::Field::FieldConstraints *constraints= attribute->mutable_constraints();
117
 
 
118
 
      field_arg->sql_type= DRIZZLE_TYPE_LONGLONG;
119
 
      constraints->set_is_unsigned(true);
120
 
    }
121
 
 
122
99
    attribute->set_type(message::internalFieldTypeToFieldProtoType(field_arg->sql_type));
123
100
 
124
101
    switch (attribute->type()) {
125
 
    case message::Table::Field::BIGINT:
126
 
    case message::Table::Field::INTEGER:
127
 
    case message::Table::Field::DATE:
128
 
    case message::Table::Field::DATETIME:
129
 
    case message::Table::Field::UUID:
130
 
    case message::Table::Field::TIME:
131
 
    case message::Table::Field::BOOLEAN:
 
102
    default: /* Only deal with types that need extra information */
132
103
      break;
133
104
    case message::Table::Field::DOUBLE:
134
105
      {
194
165
        enumeration_options->set_collation(field_arg->charset->name);
195
166
        break;
196
167
      }
197
 
 
198
168
    case message::Table::Field::BLOB:
199
169
      {
200
170
        message::Table::Field::StringFieldOptions *string_field_options;
205
175
      }
206
176
 
207
177
      break;
208
 
 
209
 
    case message::Table::Field::EPOCH:
210
 
      {
211
 
        if (field_arg->sql_type == DRIZZLE_TYPE_MICROTIME)
212
 
          attribute->mutable_time_options()->set_microseconds(true);
213
 
      }
214
 
 
215
 
      break;
216
178
    }
217
179
 
218
180
    assert (!use_existing_fields || parser_type == attribute->type());
236
198
        my_error(ER_WRONG_STRING_LENGTH, MYF(0),
237
199
                 field_arg->comment.str,"COLUMN COMMENT",
238
200
                 (uint32_t) COLUMN_COMMENT_MAXLEN);
239
 
        return true;
 
201
        return(1);
240
202
      }
241
203
 
242
204
      if (! use_existing_fields)
268
230
      field_options->set_update_expression("CURRENT_TIMESTAMP");
269
231
    }
270
232
 
271
 
    if (field_arg->def == NULL  && not attribute->constraints().is_notnull())
 
233
    if (field_arg->def == NULL  && attribute->constraints().is_nullable())
272
234
    {
273
235
      message::Table::Field::FieldOptions *field_options;
274
236
      field_options= attribute->mutable_options();
297
259
           < default_value->length()))
298
260
        {
299
261
          my_error(ER_INVALID_DEFAULT, MYF(0), field_arg->field_name);
300
 
          return true;
 
262
          return 1;
301
263
        }
302
264
 
303
265
        if (field_arg->sql_type == DRIZZLE_TYPE_DATE
304
 
            || field_arg->sql_type == DRIZZLE_TYPE_TIME
305
266
            || field_arg->sql_type == DRIZZLE_TYPE_DATETIME
306
 
            || field_arg->sql_type == DRIZZLE_TYPE_MICROTIME
307
267
            || field_arg->sql_type == DRIZZLE_TYPE_TIMESTAMP)
308
268
        {
309
 
          type::Time ltime;
 
269
          DRIZZLE_TIME ltime;
310
270
 
311
 
          if (field_arg->def->get_date(ltime, TIME_FUZZY_DATE))
 
271
          if (field_arg->def->get_date(&ltime, TIME_FUZZY_DATE))
312
272
          {
313
273
            my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR),
314
274
                     default_value->c_str());
315
 
            return true;
 
275
            return 1;
316
276
          }
317
277
 
318
278
          /* We now do the casting down to the appropriate type.
386
346
      my_error(ER_WRONG_STRING_LENGTH, MYF(0),
387
347
               table_options->comment().c_str(),"Table COMMENT",
388
348
               (uint32_t) TABLE_COMMENT_MAXLEN);
389
 
      return true;
 
349
      return(1);
390
350
    }
391
351
  }
392
352
 
393
353
  if (create_info->default_table_charset)
394
354
  {
395
 
    table_options->set_collation_id(create_info->default_table_charset->number);
 
355
    table_options->set_collation_id(
 
356
                               create_info->default_table_charset->number);
396
357
    table_options->set_collation(create_info->default_table_charset->name);
397
358
  }
398
359
 
482
443
        my_error(ER_WRONG_STRING_LENGTH, MYF(0),
483
444
                 key_info[i].comment.str,"Index COMMENT",
484
445
                 (uint32_t) TABLE_COMMENT_MAXLEN);
485
 
        return true;
 
446
        return(1);
486
447
      }
487
448
 
488
449
      idx->set_comment(key_info[i].comment.str);
489
450
    }
490
 
    static const uint64_t unknown_index_flag= (HA_NOSAME | HA_PACK_KEY |
491
 
                                               HA_USES_BLOCK_SIZE | 
492
 
                                               HA_BINARY_PACK_KEY |
493
 
                                               HA_VAR_LENGTH_PART |
494
 
                                               HA_NULL_PART_KEY | 
495
 
                                               HA_KEY_HAS_PART_KEY_SEG |
496
 
                                               HA_GENERATED_KEY |
497
 
                                               HA_USES_COMMENT);
498
 
    if (key_info[i].flags & ~unknown_index_flag)
 
451
    if (key_info[i].flags & 
 
452
        ~(HA_NOSAME | HA_PACK_KEY | HA_USES_BLOCK_SIZE | 
 
453
          HA_BINARY_PACK_KEY | HA_VAR_LENGTH_PART | HA_NULL_PART_KEY | 
 
454
          HA_KEY_HAS_PART_KEY_SEG | HA_GENERATED_KEY | HA_USES_COMMENT))
499
455
      abort(); // Invalid (unknown) index flag.
500
456
 
501
457
    for(unsigned int j=0; j< key_info[i].key_parts; j++)
529
485
 
530
486
  if (not table_proto.IsInitialized())
531
487
  {
532
 
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
533
 
             table_proto.name().c_str(),
534
 
             table_proto.InitializationErrorString().c_str());
535
 
 
536
 
    return true;
 
488
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), table_proto.InitializationErrorString().c_str());
 
489
    return 1;
537
490
  }
538
491
 
539
492
  /*
550
503
    catch (...)
551
504
    {
552
505
      my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
553
 
               table_proto.name().c_str(),
554
 
               table_proto.InitializationErrorString().c_str());
 
506
               table_proto.InitializationErrorString().empty() ? "": table_proto.InitializationErrorString().c_str());
555
507
 
556
 
      return true;
 
508
      return 1;
557
509
    }
558
510
  }
559
511
 
560
 
  return false;
 
512
  return 0;
561
513
}
562
514
 
563
515
/*
580
532
*/
581
533
 
582
534
bool rea_create_table(Session *session,
583
 
                      const identifier::Table &identifier,
 
535
                      TableIdentifier &identifier,
584
536
                      message::Table &table_proto,
585
537
                      HA_CREATE_INFO *create_info,
586
538
                      List<CreateField> &create_fields,
589
541
  assert(table_proto.has_name());
590
542
  if (fill_table_proto(table_proto, create_fields, create_info,
591
543
                       keys, key_info))
592
 
  {
593
544
    return false;
594
 
  }
595
545
 
596
546
  assert(table_proto.name() == identifier.getTableName());
597
547
 
598
 
  if (not plugin::StorageEngine::createTable(*session,
599
 
                                             identifier,
600
 
                                             table_proto))
 
548
  if (plugin::StorageEngine::createTable(*session,
 
549
                                         identifier,
 
550
                                         table_proto))
601
551
  {
602
552
    return false;
603
553
  }