← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_proto_write.cc

  • Committer: Evan Jones
  • Date: 2011-01-02 18:30:08 UTC
  • mto: (2055.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 2056.
  • Revision ID: evanj@mit.edu-20110102183008-ytvoaig5zxdck3d5
libdrizzle: drizzle_state_read: only call recv() if data is available.

This uses the "read ready" flag that already exists to avoid excess system calls. Without this patch, in non-blocking mode after sending a command, libdrizzle immediately calls recv(), which almost always returns EAGAIN. This patch avoids that, instead returning IO_WAIT. This causes the caller to wait for data on the connection using poll() or epoll() before calling recv().

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_proto_write.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
 
#include <config.h>
 
16
#include "config.h"
17
17
#include <drizzled/error.h>
18
18
#include <drizzled/session.h>
19
19
#include <drizzled/unireg.h>
20
 
#include <drizzled/sql_table.h>
21
 
#include <drizzled/global_charset_info.h>
22
 
#include <drizzled/message/statement_transform.h>
23
 
 
24
 
#include <drizzled/plugin/storage_engine.h>
25
 
 
26
 
#include <drizzled/internal/my_sys.h>
27
 
#include <drizzled/typelib.h>
 
20
#include "drizzled/sql_table.h"
 
21
#include "drizzled/global_charset_info.h"
 
22
#include "drizzled/message/statement_transform.h"
 
23
 
 
24
#include "drizzled/internal/my_sys.h"
 
25
 
28
26
 
29
27
/* For proto */
30
28
#include <string>
39
37
#include <drizzled/table_proto.h>
40
38
#include <drizzled/charset.h>
41
39
 
42
 
#include <drizzled/function/time/typecast.h>
 
40
#include "drizzled/function/time/typecast.h"
43
41
 
44
42
using namespace std;
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
 
  List<CreateField>::iterator it(create_fields.begin());
 
53
  List_iterator<CreateField> it(create_fields);
56
54
  message::Table::TableOptions *table_options= table_proto.mutable_options();
57
55
 
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(),
85
83
 
86
84
      if (field_arg->flags & NOT_NULL_FLAG)
87
85
      {
88
 
        attribute->mutable_constraints()->set_is_notnull(true);
 
86
        attribute->mutable_constraints()->set_is_nullable(false);
 
87
      }
 
88
      else
 
89
      {
 
90
        attribute->mutable_constraints()->set_is_nullable(true);
89
91
      }
90
92
 
91
93
      if (field_arg->flags & UNSIGNED_FLAG and 
98
100
      attribute->set_name(field_arg->field_name);
99
101
    }
100
102
 
101
 
    assert(((field_arg->flags & NOT_NULL_FLAG)) == attribute->constraints().is_notnull());
 
103
    assert((!(field_arg->flags & NOT_NULL_FLAG)) == attribute->constraints().is_nullable());
102
104
    assert(strcmp(attribute->name().c_str(), field_arg->field_name)==0);
103
105
 
104
106
 
107
109
    if (field_arg->sql_type == DRIZZLE_TYPE_NULL)
108
110
    {
109
111
      my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), table_proto.name().c_str(), -1);
110
 
      return true;
 
112
      return -1;
111
113
    }
112
114
 
113
115
    if (field_arg->flags & UNSIGNED_FLAG and 
117
119
 
118
120
      field_arg->sql_type= DRIZZLE_TYPE_LONGLONG;
119
121
      constraints->set_is_unsigned(true);
 
122
 
 
123
      if (field_arg->flags & NOT_NULL_FLAG)
 
124
      {
 
125
        constraints->set_is_nullable(false);
 
126
      }
 
127
      else
 
128
      {
 
129
        constraints->set_is_nullable(true);
 
130
      }
120
131
    }
121
132
 
122
133
    attribute->set_type(message::internalFieldTypeToFieldProtoType(field_arg->sql_type));
123
134
 
124
135
    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:
 
136
    default: /* Only deal with types that need extra information */
132
137
      break;
133
138
    case message::Table::Field::DOUBLE:
134
139
      {
194
199
        enumeration_options->set_collation(field_arg->charset->name);
195
200
        break;
196
201
      }
197
 
 
198
202
    case message::Table::Field::BLOB:
199
203
      {
200
204
        message::Table::Field::StringFieldOptions *string_field_options;
205
209
      }
206
210
 
207
211
      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
212
    }
217
213
 
218
214
    assert (!use_existing_fields || parser_type == attribute->type());
236
232
        my_error(ER_WRONG_STRING_LENGTH, MYF(0),
237
233
                 field_arg->comment.str,"COLUMN COMMENT",
238
234
                 (uint32_t) COLUMN_COMMENT_MAXLEN);
239
 
        return true;
 
235
        return(1);
240
236
      }
241
237
 
242
238
      if (! use_existing_fields)
268
264
      field_options->set_update_expression("CURRENT_TIMESTAMP");
269
265
    }
270
266
 
271
 
    if (field_arg->def == NULL  && not attribute->constraints().is_notnull())
 
267
    if (field_arg->def == NULL  && attribute->constraints().is_nullable())
272
268
    {
273
269
      message::Table::Field::FieldOptions *field_options;
274
270
      field_options= attribute->mutable_options();
297
293
           < default_value->length()))
298
294
        {
299
295
          my_error(ER_INVALID_DEFAULT, MYF(0), field_arg->field_name);
300
 
          return true;
 
296
          return 1;
301
297
        }
302
298
 
303
 
        if (field::isDateTime(field_arg->sql_type))
 
299
        if (field_arg->sql_type == DRIZZLE_TYPE_DATE
 
300
            || field_arg->sql_type == DRIZZLE_TYPE_TIME
 
301
            || field_arg->sql_type == DRIZZLE_TYPE_DATETIME
 
302
            || field_arg->sql_type == DRIZZLE_TYPE_TIMESTAMP)
304
303
        {
305
304
          type::Time ltime;
306
305
 
307
 
          if (field_arg->def->get_date(ltime, TIME_FUZZY_DATE))
 
306
          if (field_arg->def->get_date(&ltime, TIME_FUZZY_DATE))
308
307
          {
309
308
            my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR),
310
309
                     default_value->c_str());
311
 
            return true;
 
310
            return 1;
312
311
          }
313
312
 
314
313
          /* We now do the casting down to the appropriate type.
382
381
      my_error(ER_WRONG_STRING_LENGTH, MYF(0),
383
382
               table_options->comment().c_str(),"Table COMMENT",
384
383
               (uint32_t) TABLE_COMMENT_MAXLEN);
385
 
      return true;
 
384
      return(1);
386
385
    }
387
386
  }
388
387
 
389
388
  if (create_info->default_table_charset)
390
389
  {
391
 
    table_options->set_collation_id(create_info->default_table_charset->number);
 
390
    table_options->set_collation_id(
 
391
                               create_info->default_table_charset->number);
392
392
    table_options->set_collation(create_info->default_table_charset->name);
393
393
  }
394
394
 
478
478
        my_error(ER_WRONG_STRING_LENGTH, MYF(0),
479
479
                 key_info[i].comment.str,"Index COMMENT",
480
480
                 (uint32_t) TABLE_COMMENT_MAXLEN);
481
 
        return true;
 
481
        return(1);
482
482
      }
483
483
 
484
484
      idx->set_comment(key_info[i].comment.str);
529
529
             table_proto.name().c_str(),
530
530
             table_proto.InitializationErrorString().c_str());
531
531
 
532
 
    return true;
 
532
    return 1;
533
533
  }
534
534
 
535
535
  /*
549
549
               table_proto.name().c_str(),
550
550
               table_proto.InitializationErrorString().c_str());
551
551
 
552
 
      return true;
 
552
      return 1;
553
553
    }
554
554
  }
555
555
 
556
 
  return false;
 
556
  return 0;
557
557
}
558
558
 
559
559
/*
576
576
*/
577
577
 
578
578
bool rea_create_table(Session *session,
579
 
                      const identifier::Table &identifier,
 
579
                      const TableIdentifier &identifier,
580
580
                      message::Table &table_proto,
581
581
                      HA_CREATE_INFO *create_info,
582
582
                      List<CreateField> &create_fields,
585
585
  assert(table_proto.has_name());
586
586
  if (fill_table_proto(table_proto, create_fields, create_info,
587
587
                       keys, key_info))
588
 
  {
589
588
    return false;
590
 
  }
591
589
 
592
590
  assert(table_proto.name() == identifier.getTableName());
593
591
 
594
 
  if (not plugin::StorageEngine::createTable(*session,
595
 
                                             identifier,
596
 
                                             table_proto))
 
592
  if (plugin::StorageEngine::createTable(*session,
 
593
                                         identifier,
 
594
                                         table_proto))
597
595
  {
598
596
    return false;
599
597
  }