← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

  • Committer: Jay Pipes
  • Date: 2010-03-09 20:02:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1339.
  • Revision ID: jpipes@serialcoder-20100309200229-dfrliy4fads9vyf4
https://launchpad.net/bugs/535296
Fixes Bug #535296 by only incrementing ha_commit_count when its a normal transaction commit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.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
 
17
17
/* Some general useful functions */
18
18
 
19
 
#include <config.h>
 
19
#include "config.h"
20
20
 
21
21
#include <float.h>
22
22
#include <fcntl.h>
28
28
#include <drizzled/error.h>
29
29
#include <drizzled/gettext.h>
30
30
 
31
 
#include <drizzled/plugin/transactional_storage_engine.h>
32
 
#include <drizzled/plugin/authorization.h>
 
31
#include "drizzled/plugin/transactional_storage_engine.h"
 
32
#include "drizzled/plugin/authorization.h"
33
33
#include <drizzled/nested_join.h>
34
34
#include <drizzled/sql_parse.h>
35
35
#include <drizzled/item/sum.h>
42
42
#include <drizzled/field/double.h>
43
43
#include <drizzled/unireg.h>
44
44
#include <drizzled/message/table.pb.h>
45
 
#include <drizzled/sql_table.h>
46
 
#include <drizzled/charset.h>
47
 
#include <drizzled/internal/m_string.h>
48
 
#include <plugin/myisam/myisam.h>
49
 
#include <drizzled/plugin/storage_engine.h>
 
45
#include "drizzled/sql_table.h"
 
46
#include "drizzled/charset.h"
 
47
#include "drizzled/internal/m_string.h"
 
48
#include "plugin/myisam/myisam.h"
50
49
 
51
50
#include <drizzled/item/string.h>
52
51
#include <drizzled/item/int.h>
55
54
#include <drizzled/item/null.h>
56
55
#include <drizzled/temporal.h>
57
56
 
58
 
#include <drizzled/refresh_version.h>
59
 
 
60
 
#include <drizzled/table/singular.h>
61
 
 
62
 
#include <drizzled/table_proto.h>
63
 
#include <drizzled/typelib.h>
 
57
#include "drizzled/table_proto.h"
64
58
 
65
59
using namespace std;
66
60
 
67
61
namespace drizzled
68
62
{
69
63
 
 
64
extern pid_t current_pid;
70
65
extern plugin::StorageEngine *heap_engine;
71
66
extern plugin::StorageEngine *myisam_engine;
72
67
 
73
68
/* Functions defined in this cursor */
74
69
 
 
70
void open_table_error(TableShare *share, int error, int db_errno,
 
71
                      myf errortype, int errarg);
 
72
 
75
73
/*************************************************************************/
76
74
 
77
 
// @note this should all be the destructor
78
 
int Table::delete_table(bool free_share)
 
75
/* Get column name from column hash */
 
76
 
 
77
static unsigned char *get_field_name(Field **buff, size_t *length, bool)
 
78
{
 
79
  *length= (uint32_t) strlen((*buff)->field_name);
 
80
  return (unsigned char*) (*buff)->field_name;
 
81
}
 
82
 
 
83
static TABLE_CATEGORY get_table_category(const LEX_STRING *db)
 
84
{
 
85
  assert(db != NULL);
 
86
 
 
87
  return TABLE_CATEGORY_USER;
 
88
}
 
89
 
 
90
 
 
91
/*
 
92
  Allocate a setup TableShare structure
 
93
 
 
94
  SYNOPSIS
 
95
    alloc_table_share()
 
96
    TableList           Take database and table name from there
 
97
    key                 Table cache key (db \0 table_name \0...)
 
98
    key_length          Length of key
 
99
 
 
100
  RETURN
 
101
    0  Error (out of memory)
 
102
    #  Share
 
103
*/
 
104
 
 
105
TableShare *alloc_table_share(TableList *table_list, char *key,
 
106
                               uint32_t key_length)
 
107
{
 
108
  memory::Root mem_root;
 
109
  TableShare *share;
 
110
  char *key_buff, *path_buff;
 
111
  char path[FN_REFLEN];
 
112
  uint32_t path_length;
 
113
 
 
114
  path_length= build_table_filename(path, sizeof(path) - 1,
 
115
                                    table_list->db,
 
116
                                    table_list->table_name, false);
 
117
  memory::init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
118
  if (multi_alloc_root(&mem_root,
 
119
                       &share, sizeof(*share),
 
120
                       &key_buff, key_length,
 
121
                       &path_buff, path_length + 1,
 
122
                       NULL))
 
123
  {
 
124
    memset(share, 0, sizeof(*share));
 
125
 
 
126
    share->set_table_cache_key(key_buff, key, key_length);
 
127
 
 
128
    share->path.str= path_buff;
 
129
    share->path.length= path_length;
 
130
    strcpy(share->path.str, path);
 
131
    share->normalized_path.str=    share->path.str;
 
132
    share->normalized_path.length= path_length;
 
133
 
 
134
    share->version=       refresh_version;
 
135
 
 
136
    memcpy(&share->mem_root, &mem_root, sizeof(mem_root));
 
137
    pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
 
138
    pthread_cond_init(&share->cond, NULL);
 
139
  }
 
140
  return(share);
 
141
}
 
142
 
 
143
 
 
144
static enum_field_types proto_field_type_to_drizzle_type(uint32_t proto_field_type)
 
145
{
 
146
  enum_field_types field_type;
 
147
 
 
148
  switch(proto_field_type)
 
149
  {
 
150
  case message::Table::Field::INTEGER:
 
151
    field_type= DRIZZLE_TYPE_LONG;
 
152
    break;
 
153
  case message::Table::Field::DOUBLE:
 
154
    field_type= DRIZZLE_TYPE_DOUBLE;
 
155
    break;
 
156
  case message::Table::Field::TIMESTAMP:
 
157
    field_type= DRIZZLE_TYPE_TIMESTAMP;
 
158
    break;
 
159
  case message::Table::Field::BIGINT:
 
160
    field_type= DRIZZLE_TYPE_LONGLONG;
 
161
    break;
 
162
  case message::Table::Field::DATETIME:
 
163
    field_type= DRIZZLE_TYPE_DATETIME;
 
164
    break;
 
165
  case message::Table::Field::DATE:
 
166
    field_type= DRIZZLE_TYPE_DATE;
 
167
    break;
 
168
  case message::Table::Field::VARCHAR:
 
169
    field_type= DRIZZLE_TYPE_VARCHAR;
 
170
    break;
 
171
  case message::Table::Field::DECIMAL:
 
172
    field_type= DRIZZLE_TYPE_DECIMAL;
 
173
    break;
 
174
  case message::Table::Field::ENUM:
 
175
    field_type= DRIZZLE_TYPE_ENUM;
 
176
    break;
 
177
  case message::Table::Field::BLOB:
 
178
    field_type= DRIZZLE_TYPE_BLOB;
 
179
    break;
 
180
  default:
 
181
    field_type= DRIZZLE_TYPE_LONG; /* Set value to kill GCC warning */
 
182
    assert(1);
 
183
  }
 
184
 
 
185
  return field_type;
 
186
}
 
187
 
 
188
static Item *default_value_item(enum_field_types field_type,
 
189
                                const CHARSET_INFO *charset,
 
190
                                bool default_null, const string *default_value,
 
191
                                const string *default_bin_value)
 
192
{
 
193
  Item *default_item= NULL;
 
194
  int error= 0;
 
195
 
 
196
  if (default_null)
 
197
  {
 
198
    return new Item_null();
 
199
  }
 
200
 
 
201
  switch(field_type)
 
202
  {
 
203
  case DRIZZLE_TYPE_LONG:
 
204
  case DRIZZLE_TYPE_LONGLONG:
 
205
    default_item= new Item_int(default_value->c_str(),
 
206
                               (int64_t) internal::my_strtoll10(default_value->c_str(),
 
207
                                                                NULL,
 
208
                                                                &error),
 
209
                               default_value->length());
 
210
    break;
 
211
  case DRIZZLE_TYPE_DOUBLE:
 
212
    default_item= new Item_float(default_value->c_str(),
 
213
                                 default_value->length());
 
214
    break;
 
215
  case DRIZZLE_TYPE_NULL:
 
216
    assert(false);
 
217
  case DRIZZLE_TYPE_TIMESTAMP:
 
218
  case DRIZZLE_TYPE_DATETIME:
 
219
  case DRIZZLE_TYPE_DATE:
 
220
    if (default_value->compare("NOW()") == 0)
 
221
      break;
 
222
  case DRIZZLE_TYPE_ENUM:
 
223
    default_item= new Item_string(default_value->c_str(),
 
224
                                  default_value->length(),
 
225
                                  system_charset_info);
 
226
    break;
 
227
  case DRIZZLE_TYPE_VARCHAR:
 
228
  case DRIZZLE_TYPE_BLOB: /* Blob is here due to TINYTEXT. Feel the hate. */
 
229
    if (charset==&my_charset_bin)
 
230
    {
 
231
      default_item= new Item_string(default_bin_value->c_str(),
 
232
                                    default_bin_value->length(),
 
233
                                    &my_charset_bin);
 
234
    }
 
235
    else
 
236
    {
 
237
      default_item= new Item_string(default_value->c_str(),
 
238
                                    default_value->length(),
 
239
                                    system_charset_info);
 
240
    }
 
241
    break;
 
242
  case DRIZZLE_TYPE_DECIMAL:
 
243
    default_item= new Item_decimal(default_value->c_str(),
 
244
                                   default_value->length(),
 
245
                                   system_charset_info);
 
246
    break;
 
247
  }
 
248
 
 
249
  return default_item;
 
250
}
 
251
 
 
252
int parse_table_proto(Session& session,
 
253
                      message::Table &table,
 
254
                      TableShare *share)
 
255
{
 
256
  int error= 0;
 
257
 
 
258
  if (! table.IsInitialized())
 
259
  {
 
260
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), table.InitializationErrorString().c_str());
 
261
    return ER_CORRUPT_TABLE_DEFINITION;
 
262
  }
 
263
 
 
264
  share->setTableProto(new(nothrow) message::Table(table));
 
265
 
 
266
  share->storage_engine= plugin::StorageEngine::findByName(session, table.engine().name());
 
267
  assert(share->storage_engine); // We use an assert() here because we should never get this far and still have no suitable engine.
 
268
 
 
269
  message::Table::TableOptions table_options;
 
270
 
 
271
  if (table.has_options())
 
272
    table_options= table.options();
 
273
 
 
274
  uint32_t db_create_options= 0;
 
275
 
 
276
  if (table_options.has_pack_keys())
 
277
  {
 
278
    if (table_options.pack_keys())
 
279
      db_create_options|= HA_OPTION_PACK_KEYS;
 
280
    else
 
281
      db_create_options|= HA_OPTION_NO_PACK_KEYS;
 
282
  }
 
283
 
 
284
  if (table_options.pack_record())
 
285
    db_create_options|= HA_OPTION_PACK_RECORD;
 
286
 
 
287
  /* db_create_options was stored as 2 bytes in FRM
 
288
     Any HA_OPTION_ that doesn't fit into 2 bytes was silently truncated away.
 
289
   */
 
290
  share->db_create_options= (db_create_options & 0x0000FFFF);
 
291
  share->db_options_in_use= share->db_create_options;
 
292
 
 
293
  share->row_type= table_options.has_row_type() ?
 
294
    (enum row_type) table_options.row_type() : ROW_TYPE_DEFAULT;
 
295
 
 
296
  share->block_size= table_options.has_block_size() ?
 
297
    table_options.block_size() : 0;
 
298
 
 
299
  share->table_charset= get_charset(table_options.has_collation_id()?
 
300
                                    table_options.collation_id() : 0);
 
301
 
 
302
  if (!share->table_charset)
 
303
  {
 
304
    /* unknown charset in head[38] or pre-3.23 frm */
 
305
    if (use_mb(default_charset_info))
 
306
    {
 
307
      /* Warn that we may be changing the size of character columns */
 
308
      errmsg_printf(ERRMSG_LVL_WARN,
 
309
                    _("'%s' had no or invalid character set, "
 
310
                      "and default character set is multi-byte, "
 
311
                      "so character column sizes may have changed"),
 
312
                    share->path.str);
 
313
    }
 
314
    share->table_charset= default_charset_info;
 
315
  }
 
316
 
 
317
  share->db_record_offset= 1;
 
318
 
 
319
  share->blob_ptr_size= portable_sizeof_char_ptr; // more bonghits.
 
320
 
 
321
  share->keys= table.indexes_size();
 
322
 
 
323
  share->key_parts= 0;
 
324
  for (int indx= 0; indx < table.indexes_size(); indx++)
 
325
    share->key_parts+= table.indexes(indx).index_part_size();
 
326
 
 
327
  share->key_info= (KEY*) alloc_root(&share->mem_root,
 
328
                                     table.indexes_size() * sizeof(KEY)
 
329
                                     +share->key_parts*sizeof(KEY_PART_INFO));
 
330
 
 
331
  KEY_PART_INFO *key_part;
 
332
 
 
333
  key_part= reinterpret_cast<KEY_PART_INFO*>
 
334
    (share->key_info+table.indexes_size());
 
335
 
 
336
 
 
337
  ulong *rec_per_key= (ulong*) alloc_root(&share->mem_root,
 
338
                                            sizeof(ulong*)*share->key_parts);
 
339
 
 
340
  share->keynames.count= table.indexes_size();
 
341
  share->keynames.name= NULL;
 
342
  share->keynames.type_names= (const char**)
 
343
    alloc_root(&share->mem_root, sizeof(char*) * (table.indexes_size()+1));
 
344
 
 
345
  share->keynames.type_lengths= (unsigned int*)
 
346
    alloc_root(&share->mem_root,
 
347
               sizeof(unsigned int) * (table.indexes_size()+1));
 
348
 
 
349
  share->keynames.type_names[share->keynames.count]= NULL;
 
350
  share->keynames.type_lengths[share->keynames.count]= 0;
 
351
 
 
352
  KEY* keyinfo= share->key_info;
 
353
  for (int keynr= 0; keynr < table.indexes_size(); keynr++, keyinfo++)
 
354
  {
 
355
    message::Table::Index indx= table.indexes(keynr);
 
356
 
 
357
    keyinfo->table= 0;
 
358
    keyinfo->flags= 0;
 
359
 
 
360
    if (indx.is_unique())
 
361
      keyinfo->flags|= HA_NOSAME;
 
362
 
 
363
    if (indx.has_options())
 
364
    {
 
365
      message::Table::Index::IndexOptions indx_options= indx.options();
 
366
      if (indx_options.pack_key())
 
367
        keyinfo->flags|= HA_PACK_KEY;
 
368
 
 
369
      if (indx_options.var_length_key())
 
370
        keyinfo->flags|= HA_VAR_LENGTH_PART;
 
371
 
 
372
      if (indx_options.null_part_key())
 
373
        keyinfo->flags|= HA_NULL_PART_KEY;
 
374
 
 
375
      if (indx_options.binary_pack_key())
 
376
        keyinfo->flags|= HA_BINARY_PACK_KEY;
 
377
 
 
378
      if (indx_options.has_partial_segments())
 
379
        keyinfo->flags|= HA_KEY_HAS_PART_KEY_SEG;
 
380
 
 
381
      if (indx_options.auto_generated_key())
 
382
        keyinfo->flags|= HA_GENERATED_KEY;
 
383
 
 
384
      if (indx_options.has_key_block_size())
 
385
      {
 
386
        keyinfo->flags|= HA_USES_BLOCK_SIZE;
 
387
        keyinfo->block_size= indx_options.key_block_size();
 
388
      }
 
389
      else
 
390
      {
 
391
        keyinfo->block_size= 0;
 
392
      }
 
393
    }
 
394
 
 
395
    switch (indx.type())
 
396
    {
 
397
    case message::Table::Index::UNKNOWN_INDEX:
 
398
      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
 
399
      break;
 
400
    case message::Table::Index::BTREE:
 
401
      keyinfo->algorithm= HA_KEY_ALG_BTREE;
 
402
      break;
 
403
    case message::Table::Index::HASH:
 
404
      keyinfo->algorithm= HA_KEY_ALG_HASH;
 
405
      break;
 
406
 
 
407
    default:
 
408
      /* TODO: suitable warning ? */
 
409
      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
 
410
      break;
 
411
    }
 
412
 
 
413
    keyinfo->key_length= indx.key_length();
 
414
 
 
415
    keyinfo->key_parts= indx.index_part_size();
 
416
 
 
417
    keyinfo->key_part= key_part;
 
418
    keyinfo->rec_per_key= rec_per_key;
 
419
 
 
420
    for (unsigned int partnr= 0;
 
421
         partnr < keyinfo->key_parts;
 
422
         partnr++, key_part++)
 
423
    {
 
424
      message::Table::Index::IndexPart part;
 
425
      part= indx.index_part(partnr);
 
426
 
 
427
      *rec_per_key++= 0;
 
428
 
 
429
      key_part->field= NULL;
 
430
      key_part->fieldnr= part.fieldnr() + 1; // start from 1.
 
431
      key_part->null_bit= 0;
 
432
      /* key_part->null_offset is only set if null_bit (see later) */
 
433
      /* key_part->key_type= */ /* I *THINK* this may be okay.... */
 
434
      /* key_part->type ???? */
 
435
      key_part->key_part_flag= 0;
 
436
      if (part.has_in_reverse_order())
 
437
        key_part->key_part_flag= part.in_reverse_order()? HA_REVERSE_SORT : 0;
 
438
 
 
439
      key_part->length= part.compare_length();
 
440
 
 
441
      key_part->store_length= key_part->length;
 
442
 
 
443
      /* key_part->offset is set later */
 
444
      key_part->key_type= part.key_type();
 
445
    }
 
446
 
 
447
    if (! indx.has_comment())
 
448
    {
 
449
      keyinfo->comment.length= 0;
 
450
      keyinfo->comment.str= NULL;
 
451
    }
 
452
    else
 
453
    {
 
454
      keyinfo->flags|= HA_USES_COMMENT;
 
455
      keyinfo->comment.length= indx.comment().length();
 
456
      keyinfo->comment.str= strmake_root(&share->mem_root,
 
457
                                         indx.comment().c_str(),
 
458
                                         keyinfo->comment.length);
 
459
    }
 
460
 
 
461
    keyinfo->name= strmake_root(&share->mem_root,
 
462
                                indx.name().c_str(),
 
463
                                indx.name().length());
 
464
 
 
465
    share->keynames.type_names[keynr]= keyinfo->name;
 
466
    share->keynames.type_lengths[keynr]= indx.name().length();
 
467
  }
 
468
 
 
469
  share->keys_for_keyread.reset();
 
470
  set_prefix(share->keys_in_use, share->keys);
 
471
 
 
472
  share->fields= table.field_size();
 
473
 
 
474
  share->field= (Field**) alloc_root(&share->mem_root,
 
475
                                     ((share->fields+1) * sizeof(Field*)));
 
476
  share->field[share->fields]= NULL;
 
477
 
 
478
  uint32_t null_fields= 0;
 
479
  share->reclength= 0;
 
480
 
 
481
  uint32_t *field_offsets= (uint32_t*)malloc(share->fields * sizeof(uint32_t));
 
482
  uint32_t *field_pack_length=(uint32_t*)malloc(share->fields*sizeof(uint32_t));
 
483
 
 
484
  assert(field_offsets && field_pack_length); // TODO: fixme
 
485
 
 
486
  uint32_t interval_count= 0;
 
487
  uint32_t interval_parts= 0;
 
488
 
 
489
  uint32_t stored_columns_reclength= 0;
 
490
 
 
491
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
 
492
  {
 
493
    message::Table::Field pfield= table.field(fieldnr);
 
494
    if (pfield.constraints().is_nullable())
 
495
      null_fields++;
 
496
 
 
497
    enum_field_types drizzle_field_type=
 
498
      proto_field_type_to_drizzle_type(pfield.type());
 
499
 
 
500
    field_offsets[fieldnr]= stored_columns_reclength;
 
501
 
 
502
    /* the below switch is very similar to
 
503
       CreateField::create_length_to_internal_length in field.cc
 
504
       (which should one day be replace by just this code)
 
505
    */
 
506
    switch(drizzle_field_type)
 
507
    {
 
508
    case DRIZZLE_TYPE_BLOB:
 
509
    case DRIZZLE_TYPE_VARCHAR:
 
510
      {
 
511
        message::Table::Field::StringFieldOptions field_options= pfield.string_options();
 
512
 
 
513
        const CHARSET_INFO *cs= get_charset(field_options.has_collation_id() ?
 
514
                                            field_options.collation_id() : 0);
 
515
 
 
516
        if (! cs)
 
517
          cs= default_charset_info;
 
518
 
 
519
        field_pack_length[fieldnr]= calc_pack_length(drizzle_field_type,
 
520
                                                     field_options.length() * cs->mbmaxlen);
 
521
      }
 
522
      break;
 
523
    case DRIZZLE_TYPE_ENUM:
 
524
      {
 
525
        message::Table::Field::SetFieldOptions field_options= pfield.set_options();
 
526
 
 
527
        field_pack_length[fieldnr]=
 
528
          get_enum_pack_length(field_options.field_value_size());
 
529
 
 
530
        interval_count++;
 
531
        interval_parts+= field_options.field_value_size();
 
532
      }
 
533
      break;
 
534
    case DRIZZLE_TYPE_DECIMAL:
 
535
      {
 
536
        message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
537
 
 
538
        field_pack_length[fieldnr]= my_decimal_get_binary_size(fo.precision(), fo.scale());
 
539
      }
 
540
      break;
 
541
    default:
 
542
      /* Zero is okay here as length is fixed for other types. */
 
543
      field_pack_length[fieldnr]= calc_pack_length(drizzle_field_type, 0);
 
544
    }
 
545
 
 
546
    share->reclength+= field_pack_length[fieldnr];
 
547
    stored_columns_reclength+= field_pack_length[fieldnr];
 
548
  }
 
549
 
 
550
  /* data_offset added to stored_rec_length later */
 
551
  share->stored_rec_length= stored_columns_reclength;
 
552
 
 
553
  share->null_fields= null_fields;
 
554
 
 
555
  ulong null_bits= null_fields;
 
556
  if (! table_options.pack_record())
 
557
    null_bits++;
 
558
  ulong data_offset= (null_bits + 7)/8;
 
559
 
 
560
 
 
561
  share->reclength+= data_offset;
 
562
  share->stored_rec_length+= data_offset;
 
563
 
 
564
  ulong rec_buff_length;
 
565
 
 
566
  rec_buff_length= ALIGN_SIZE(share->reclength + 1);
 
567
  share->rec_buff_length= rec_buff_length;
 
568
 
 
569
  unsigned char* record= NULL;
 
570
 
 
571
  if (! (record= (unsigned char *) alloc_root(&share->mem_root,
 
572
                                              rec_buff_length)))
 
573
    abort();
 
574
 
 
575
  memset(record, 0, rec_buff_length);
 
576
 
 
577
  int null_count= 0;
 
578
 
 
579
  if (! table_options.pack_record())
 
580
  {
 
581
    null_count++; // one bit for delete mark.
 
582
    *record|= 1;
 
583
  }
 
584
 
 
585
  share->default_values= record;
 
586
 
 
587
  if (interval_count)
 
588
  {
 
589
    share->intervals= (TYPELIB *) alloc_root(&share->mem_root,
 
590
                                           interval_count*sizeof(TYPELIB));
 
591
  }
 
592
  else
 
593
    share->intervals= NULL;
 
594
 
 
595
  share->fieldnames.type_names= (const char **) alloc_root(&share->mem_root,
 
596
                                                          (share->fields + 1) * sizeof(char*));
 
597
 
 
598
  share->fieldnames.type_lengths= (unsigned int *) alloc_root(&share->mem_root,
 
599
                                                             (share->fields + 1) * sizeof(unsigned int));
 
600
 
 
601
  share->fieldnames.type_names[share->fields]= NULL;
 
602
  share->fieldnames.type_lengths[share->fields]= 0;
 
603
  share->fieldnames.count= share->fields;
 
604
 
 
605
 
 
606
  /* Now fix the TYPELIBs for the intervals (enum values)
 
607
     and field names.
 
608
   */
 
609
 
 
610
  uint32_t interval_nr= 0;
 
611
 
 
612
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
 
613
  {
 
614
    message::Table::Field pfield= table.field(fieldnr);
 
615
 
 
616
    /* field names */
 
617
    share->fieldnames.type_names[fieldnr]= strmake_root(&share->mem_root,
 
618
                                                        pfield.name().c_str(),
 
619
                                                        pfield.name().length());
 
620
 
 
621
    share->fieldnames.type_lengths[fieldnr]= pfield.name().length();
 
622
 
 
623
    /* enum typelibs */
 
624
    if (pfield.type() != message::Table::Field::ENUM)
 
625
      continue;
 
626
 
 
627
    message::Table::Field::SetFieldOptions field_options= pfield.set_options();
 
628
 
 
629
    const CHARSET_INFO *charset= get_charset(field_options.has_collation_id() ?
 
630
                                             field_options.collation_id() : 0);
 
631
 
 
632
    if (! charset)
 
633
      charset= default_charset_info;
 
634
 
 
635
    TYPELIB *t= &(share->intervals[interval_nr]);
 
636
 
 
637
    t->type_names= (const char**)alloc_root(&share->mem_root,
 
638
                                            (field_options.field_value_size() + 1) * sizeof(char*));
 
639
 
 
640
    t->type_lengths= (unsigned int*) alloc_root(&share->mem_root,
 
641
                                                (field_options.field_value_size() + 1) * sizeof(unsigned int));
 
642
 
 
643
    t->type_names[field_options.field_value_size()]= NULL;
 
644
    t->type_lengths[field_options.field_value_size()]= 0;
 
645
 
 
646
    t->count= field_options.field_value_size();
 
647
    t->name= NULL;
 
648
 
 
649
    for (int n= 0; n < field_options.field_value_size(); n++)
 
650
    {
 
651
      t->type_names[n]= strmake_root(&share->mem_root,
 
652
                                     field_options.field_value(n).c_str(),
 
653
                                     field_options.field_value(n).length());
 
654
 
 
655
      /* 
 
656
       * Go ask the charset what the length is as for "" length=1
 
657
       * and there's stripping spaces or some other crack going on.
 
658
       */
 
659
      uint32_t lengthsp;
 
660
      lengthsp= charset->cset->lengthsp(charset,
 
661
                                        t->type_names[n],
 
662
                                        field_options.field_value(n).length());
 
663
      t->type_lengths[n]= lengthsp;
 
664
    }
 
665
    interval_nr++;
 
666
  }
 
667
 
 
668
 
 
669
  /* and read the fields */
 
670
  interval_nr= 0;
 
671
 
 
672
  bool use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
 
673
 
 
674
  if (use_hash)
 
675
    use_hash= ! hash_init(&share->name_hash,
 
676
                          system_charset_info,
 
677
                          share->fields,
 
678
                          0,
 
679
                          0,
 
680
                          (hash_get_key) get_field_name,
 
681
                          0,
 
682
                          0);
 
683
 
 
684
  unsigned char* null_pos= record;;
 
685
  int null_bit_pos= (table_options.pack_record()) ? 0 : 1;
 
686
 
 
687
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
 
688
  {
 
689
    message::Table::Field pfield= table.field(fieldnr);
 
690
 
 
691
    enum column_format_type column_format= COLUMN_FORMAT_TYPE_DEFAULT;
 
692
 
 
693
    switch (pfield.format())
 
694
    {
 
695
    case message::Table::Field::DefaultFormat:
 
696
      column_format= COLUMN_FORMAT_TYPE_DEFAULT;
 
697
      break;
 
698
    case message::Table::Field::FixedFormat:
 
699
      column_format= COLUMN_FORMAT_TYPE_FIXED;
 
700
      break;
 
701
    case message::Table::Field::DynamicFormat:
 
702
      column_format= COLUMN_FORMAT_TYPE_DYNAMIC;
 
703
      break;
 
704
    default:
 
705
      assert(1);
 
706
    }
 
707
 
 
708
    Field::utype unireg_type= Field::NONE;
 
709
 
 
710
    if (pfield.has_numeric_options() &&
 
711
        pfield.numeric_options().is_autoincrement())
 
712
    {
 
713
      unireg_type= Field::NEXT_NUMBER;
 
714
    }
 
715
 
 
716
    if (pfield.has_options() &&
 
717
        pfield.options().has_default_value() &&
 
718
        pfield.options().default_value().compare("NOW()") == 0)
 
719
    {
 
720
      if (pfield.options().has_update_value() &&
 
721
          pfield.options().update_value().compare("NOW()") == 0)
 
722
      {
 
723
        unireg_type= Field::TIMESTAMP_DNUN_FIELD;
 
724
      }
 
725
      else if (! pfield.options().has_update_value())
 
726
      {
 
727
        unireg_type= Field::TIMESTAMP_DN_FIELD;
 
728
      }
 
729
      else
 
730
        assert(1); // Invalid update value.
 
731
    }
 
732
    else if (pfield.has_options() &&
 
733
             pfield.options().has_update_value() &&
 
734
             pfield.options().update_value().compare("NOW()") == 0)
 
735
    {
 
736
      unireg_type= Field::TIMESTAMP_UN_FIELD;
 
737
    }
 
738
 
 
739
    LEX_STRING comment;
 
740
    if (!pfield.has_comment())
 
741
    {
 
742
      comment.str= (char*)"";
 
743
      comment.length= 0;
 
744
    }
 
745
    else
 
746
    {
 
747
      size_t len= pfield.comment().length();
 
748
      const char* str= pfield.comment().c_str();
 
749
 
 
750
      comment.str= strmake_root(&share->mem_root, str, len);
 
751
      comment.length= len;
 
752
    }
 
753
 
 
754
    enum_field_types field_type;
 
755
 
 
756
    field_type= proto_field_type_to_drizzle_type(pfield.type());
 
757
 
 
758
    const CHARSET_INFO *charset= &my_charset_bin;
 
759
 
 
760
    if (field_type == DRIZZLE_TYPE_BLOB ||
 
761
        field_type == DRIZZLE_TYPE_VARCHAR)
 
762
    {
 
763
      message::Table::Field::StringFieldOptions field_options= pfield.string_options();
 
764
 
 
765
      charset= get_charset(field_options.has_collation_id() ?
 
766
                           field_options.collation_id() : 0);
 
767
 
 
768
      if (! charset)
 
769
        charset= default_charset_info;
 
770
    }
 
771
 
 
772
    if (field_type == DRIZZLE_TYPE_ENUM)
 
773
    {
 
774
      message::Table::Field::SetFieldOptions field_options= pfield.set_options();
 
775
 
 
776
      charset= get_charset(field_options.has_collation_id()?
 
777
                           field_options.collation_id() : 0);
 
778
 
 
779
      if (! charset)
 
780
              charset= default_charset_info;
 
781
    }
 
782
 
 
783
    uint8_t decimals= 0;
 
784
    if (field_type == DRIZZLE_TYPE_DECIMAL
 
785
        || field_type == DRIZZLE_TYPE_DOUBLE)
 
786
    {
 
787
      message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
788
 
 
789
      if (! pfield.has_numeric_options() || ! fo.has_scale())
 
790
      {
 
791
        /*
 
792
          We don't write the default to table proto so
 
793
          if no decimals specified for DOUBLE, we use the default.
 
794
        */
 
795
        decimals= NOT_FIXED_DEC;
 
796
      }
 
797
      else
 
798
      {
 
799
        if (fo.scale() > DECIMAL_MAX_SCALE)
 
800
        {
 
801
          error= 4;
 
802
          goto err;
 
803
        }
 
804
        decimals= static_cast<uint8_t>(fo.scale());
 
805
      }
 
806
    }
 
807
 
 
808
    Item *default_value= NULL;
 
809
 
 
810
    if (pfield.options().has_default_value() ||
 
811
        pfield.options().has_default_null()  ||
 
812
        pfield.options().has_default_bin_value())
 
813
    {
 
814
      default_value= default_value_item(field_type,
 
815
                                        charset,
 
816
                                        pfield.options().default_null(),
 
817
                                        &pfield.options().default_value(),
 
818
                                        &pfield.options().default_bin_value());
 
819
    }
 
820
 
 
821
 
 
822
    Table temp_table; /* Use this so that BLOB DEFAULT '' works */
 
823
    memset(&temp_table, 0, sizeof(temp_table));
 
824
    temp_table.s= share;
 
825
    temp_table.in_use= &session;
 
826
    temp_table.s->db_low_byte_first= true; //Cursor->low_byte_first();
 
827
    temp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
 
828
 
 
829
    uint32_t field_length= 0; //Assignment is for compiler complaint.
 
830
 
 
831
    switch (field_type)
 
832
    {
 
833
    case DRIZZLE_TYPE_BLOB:
 
834
    case DRIZZLE_TYPE_VARCHAR:
 
835
    {
 
836
      message::Table::Field::StringFieldOptions field_options= pfield.string_options();
 
837
 
 
838
      charset= get_charset(field_options.has_collation_id() ?
 
839
                           field_options.collation_id() : 0);
 
840
 
 
841
      if (! charset)
 
842
        charset= default_charset_info;
 
843
 
 
844
      field_length= field_options.length() * charset->mbmaxlen;
 
845
    }
 
846
      break;
 
847
    case DRIZZLE_TYPE_DOUBLE:
 
848
    {
 
849
      message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
850
      if (!fo.has_precision() && !fo.has_scale())
 
851
      {
 
852
        field_length= DBL_DIG+7;
 
853
      }
 
854
      else
 
855
      {
 
856
        field_length= fo.precision();
 
857
      }
 
858
      if (field_length < decimals &&
 
859
          decimals != NOT_FIXED_DEC)
 
860
      {
 
861
        my_error(ER_M_BIGGER_THAN_D, MYF(0), pfield.name().c_str());
 
862
        error= 1;
 
863
        goto err;
 
864
      }
 
865
      break;
 
866
    }
 
867
    case DRIZZLE_TYPE_DECIMAL:
 
868
    {
 
869
      message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
870
 
 
871
      field_length= my_decimal_precision_to_length(fo.precision(), fo.scale(),
 
872
                                                   false);
 
873
      break;
 
874
    }
 
875
    case DRIZZLE_TYPE_TIMESTAMP:
 
876
    case DRIZZLE_TYPE_DATETIME:
 
877
      field_length= DateTime::MAX_STRING_LENGTH;
 
878
      break;
 
879
    case DRIZZLE_TYPE_DATE:
 
880
      field_length= Date::MAX_STRING_LENGTH;
 
881
      break;
 
882
    case DRIZZLE_TYPE_ENUM:
 
883
    {
 
884
      field_length= 0;
 
885
 
 
886
      message::Table::Field::SetFieldOptions fo= pfield.set_options();
 
887
 
 
888
      for(int valnr= 0; valnr < fo.field_value_size(); valnr++)
 
889
      {
 
890
        if (fo.field_value(valnr).length() > field_length)
 
891
          field_length= charset->cset->numchars(charset,
 
892
                                                fo.field_value(valnr).c_str(),
 
893
                                                fo.field_value(valnr).c_str()
 
894
                                                + fo.field_value(valnr).length())
 
895
            * charset->mbmaxlen;
 
896
      }
 
897
    }
 
898
      break;
 
899
    case DRIZZLE_TYPE_LONG:
 
900
      {
 
901
        uint32_t sign_len= pfield.constraints().is_unsigned() ? 0 : 1;
 
902
          field_length= MAX_INT_WIDTH+sign_len;
 
903
      }
 
904
      break;
 
905
    case DRIZZLE_TYPE_LONGLONG:
 
906
      field_length= MAX_BIGINT_WIDTH;
 
907
      break;
 
908
    case DRIZZLE_TYPE_NULL:
 
909
      abort(); // Programming error
 
910
    }
 
911
 
 
912
    Field* f= make_field(share,
 
913
                         &share->mem_root,
 
914
                         record + field_offsets[fieldnr] + data_offset,
 
915
                         field_length,
 
916
                         pfield.constraints().is_nullable(),
 
917
                         null_pos,
 
918
                         null_bit_pos,
 
919
                         decimals,
 
920
                         field_type,
 
921
                         charset,
 
922
                         (Field::utype) MTYP_TYPENR(unireg_type),
 
923
                         ((field_type == DRIZZLE_TYPE_ENUM) ?
 
924
                          share->intervals + (interval_nr++)
 
925
                          : (TYPELIB*) 0),
 
926
                         share->fieldnames.type_names[fieldnr]);
 
927
 
 
928
    share->field[fieldnr]= f;
 
929
 
 
930
    f->init(&temp_table); /* blob default values need table obj */
 
931
 
 
932
    if (! (f->flags & NOT_NULL_FLAG))
 
933
    {
 
934
      *f->null_ptr|= f->null_bit;
 
935
      if (! (null_bit_pos= (null_bit_pos + 1) & 7)) /* @TODO Ugh. */
 
936
        null_pos++;
 
937
      null_count++;
 
938
    }
 
939
 
 
940
    if (default_value)
 
941
    {
 
942
      enum_check_fields old_count_cuted_fields= session.count_cuted_fields;
 
943
      session.count_cuted_fields= CHECK_FIELD_WARN;
 
944
      int res= default_value->save_in_field(f, 1);
 
945
      session.count_cuted_fields= old_count_cuted_fields;
 
946
      if (res != 0 && res != 3) /* @TODO Huh? */
 
947
      {
 
948
        my_error(ER_INVALID_DEFAULT, MYF(0), f->field_name);
 
949
        error= 1;
 
950
        goto err;
 
951
      }
 
952
    }
 
953
    else if (f->real_type() == DRIZZLE_TYPE_ENUM &&
 
954
             (f->flags & NOT_NULL_FLAG))
 
955
    {
 
956
      f->set_notnull();
 
957
      f->store((int64_t) 1, true);
 
958
    }
 
959
    else
 
960
      f->reset();
 
961
 
 
962
    /* hack to undo f->init() */
 
963
    f->table= NULL;
 
964
    f->orig_table= NULL;
 
965
 
 
966
    f->field_index= fieldnr;
 
967
    f->comment= comment;
 
968
    if (! default_value &&
 
969
        ! (f->unireg_check==Field::NEXT_NUMBER) &&
 
970
        (f->flags & NOT_NULL_FLAG) &&
 
971
        (f->real_type() != DRIZZLE_TYPE_TIMESTAMP))
 
972
    {
 
973
      f->flags|= NO_DEFAULT_VALUE_FLAG;
 
974
    }
 
975
 
 
976
    if (f->unireg_check == Field::NEXT_NUMBER)
 
977
      share->found_next_number_field= &(share->field[fieldnr]);
 
978
 
 
979
    if (share->timestamp_field == f)
 
980
      share->timestamp_field_offset= fieldnr;
 
981
 
 
982
    if (use_hash) /* supposedly this never fails... but comments lie */
 
983
      (void) my_hash_insert(&share->name_hash,
 
984
                            (unsigned char*)&(share->field[fieldnr]));
 
985
 
 
986
  }
 
987
 
 
988
  keyinfo= share->key_info;
 
989
  for (unsigned int keynr= 0; keynr < share->keys; keynr++, keyinfo++)
 
990
  {
 
991
    key_part= keyinfo->key_part;
 
992
 
 
993
    for (unsigned int partnr= 0;
 
994
         partnr < keyinfo->key_parts;
 
995
         partnr++, key_part++)
 
996
    {
 
997
      /* 
 
998
       * Fix up key_part->offset by adding data_offset.
 
999
       * We really should compute offset as well.
 
1000
       * But at least this way we are a little better.
 
1001
       */
 
1002
      key_part->offset= field_offsets[key_part->fieldnr-1] + data_offset;
 
1003
    }
 
1004
  }
 
1005
 
 
1006
  /*
 
1007
    We need to set the unused bits to 1. If the number of bits is a multiple
 
1008
    of 8 there are no unused bits.
 
1009
  */
 
1010
 
 
1011
  if (null_count & 7)
 
1012
    *(record + null_count / 8)|= ~(((unsigned char) 1 << (null_count & 7)) - 1);
 
1013
 
 
1014
  share->null_bytes= (null_pos - (unsigned char*) record + (null_bit_pos + 7) / 8);
 
1015
 
 
1016
  share->last_null_bit_pos= null_bit_pos;
 
1017
 
 
1018
  free(field_offsets);
 
1019
  field_offsets= NULL;
 
1020
  free(field_pack_length);
 
1021
  field_pack_length= NULL;
 
1022
 
 
1023
  /* Fix key stuff */
 
1024
  if (share->key_parts)
 
1025
  {
 
1026
    uint32_t primary_key= (uint32_t) (find_type((char*) "PRIMARY",
 
1027
                                                &share->keynames, 3) - 1); /* @TODO Huh? */
 
1028
 
 
1029
    keyinfo= share->key_info;
 
1030
    key_part= keyinfo->key_part;
 
1031
 
 
1032
    for (uint32_t key= 0; key < share->keys; key++,keyinfo++)
 
1033
    {
 
1034
      uint32_t usable_parts= 0;
 
1035
 
 
1036
      if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
 
1037
      {
 
1038
        /*
 
1039
          If the UNIQUE key doesn't have NULL columns and is not a part key
 
1040
          declare this as a primary key.
 
1041
        */
 
1042
        primary_key=key;
 
1043
        for (uint32_t i= 0; i < keyinfo->key_parts; i++)
 
1044
        {
 
1045
          uint32_t fieldnr= key_part[i].fieldnr;
 
1046
          if (! fieldnr ||
 
1047
              share->field[fieldnr-1]->null_ptr ||
 
1048
              share->field[fieldnr-1]->key_length() != key_part[i].length)
 
1049
          {
 
1050
            primary_key= MAX_KEY; // Can't be used
 
1051
            break;
 
1052
          }
 
1053
        }
 
1054
      }
 
1055
 
 
1056
      for (uint32_t i= 0 ; i < keyinfo->key_parts ; key_part++,i++)
 
1057
      {
 
1058
        Field *field;
 
1059
        if (! key_part->fieldnr)
 
1060
        {
 
1061
          abort(); // goto err;
 
1062
        }
 
1063
        field= key_part->field= share->field[key_part->fieldnr-1];
 
1064
        key_part->type= field->key_type();
 
1065
        if (field->null_ptr)
 
1066
        {
 
1067
          key_part->null_offset=(uint32_t) ((unsigned char*) field->null_ptr -
 
1068
                                        share->default_values);
 
1069
          key_part->null_bit= field->null_bit;
 
1070
          key_part->store_length+=HA_KEY_NULL_LENGTH;
 
1071
          keyinfo->flags|=HA_NULL_PART_KEY;
 
1072
          keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
 
1073
          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
 
1074
        }
 
1075
        if (field->type() == DRIZZLE_TYPE_BLOB ||
 
1076
            field->real_type() == DRIZZLE_TYPE_VARCHAR)
 
1077
        {
 
1078
          if (field->type() == DRIZZLE_TYPE_BLOB)
 
1079
            key_part->key_part_flag|= HA_BLOB_PART;
 
1080
          else
 
1081
            key_part->key_part_flag|= HA_VAR_LENGTH_PART;
 
1082
          keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
 
1083
          key_part->store_length+=HA_KEY_BLOB_LENGTH;
 
1084
          keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
 
1085
        }
 
1086
        if (i == 0 && key != primary_key)
 
1087
          field->flags |= (((keyinfo->flags & HA_NOSAME) &&
 
1088
                           (keyinfo->key_parts == 1)) ?
 
1089
                           UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
 
1090
        if (i == 0)
 
1091
          field->key_start.set(key);
 
1092
        if (field->key_length() == key_part->length &&
 
1093
            !(field->flags & BLOB_FLAG))
 
1094
        {
 
1095
          enum ha_key_alg algo= share->key_info[key].algorithm;
 
1096
          if (share->db_type()->index_flags(algo) & HA_KEYREAD_ONLY)
 
1097
          {
 
1098
            share->keys_for_keyread.set(key);
 
1099
            field->part_of_key.set(key);
 
1100
            field->part_of_key_not_clustered.set(key);
 
1101
          }
 
1102
          if (share->db_type()->index_flags(algo) & HA_READ_ORDER)
 
1103
            field->part_of_sortkey.set(key);
 
1104
        }
 
1105
        if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
 
1106
            usable_parts == i)
 
1107
          usable_parts++;                       // For FILESORT
 
1108
        field->flags|= PART_KEY_FLAG;
 
1109
        if (key == primary_key)
 
1110
        {
 
1111
          field->flags|= PRI_KEY_FLAG;
 
1112
          /*
 
1113
            If this field is part of the primary key and all keys contains
 
1114
            the primary key, then we can use any key to find this column
 
1115
          */
 
1116
          if (share->storage_engine->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX))
 
1117
          {
 
1118
            field->part_of_key= share->keys_in_use;
 
1119
            if (field->part_of_sortkey.test(key))
 
1120
              field->part_of_sortkey= share->keys_in_use;
 
1121
          }
 
1122
        }
 
1123
        if (field->key_length() != key_part->length)
 
1124
        {
 
1125
          key_part->key_part_flag|= HA_PART_KEY_SEG;
 
1126
        }
 
1127
      }
 
1128
      keyinfo->usable_key_parts= usable_parts; // Filesort
 
1129
 
 
1130
      set_if_bigger(share->max_key_length,keyinfo->key_length+
 
1131
                    keyinfo->key_parts);
 
1132
      share->total_key_length+= keyinfo->key_length;
 
1133
 
 
1134
      if (keyinfo->flags & HA_NOSAME)
 
1135
      {
 
1136
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
 
1137
      }
 
1138
    }
 
1139
    if (primary_key < MAX_KEY &&
 
1140
        (share->keys_in_use.test(primary_key)))
 
1141
    {
 
1142
      share->primary_key= primary_key;
 
1143
      /*
 
1144
        If we are using an integer as the primary key then allow the user to
 
1145
        refer to it as '_rowid'
 
1146
      */
 
1147
      if (share->key_info[primary_key].key_parts == 1)
 
1148
      {
 
1149
        Field *field= share->key_info[primary_key].key_part[0].field;
 
1150
        if (field && field->result_type() == INT_RESULT)
 
1151
        {
 
1152
          /* note that fieldnr here (and rowid_field_offset) starts from 1 */
 
1153
          share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
 
1154
                                      fieldnr);
 
1155
        }
 
1156
      }
 
1157
    }
 
1158
    else
 
1159
      share->primary_key = MAX_KEY; // we do not have a primary key
 
1160
  }
 
1161
  else
 
1162
    share->primary_key= MAX_KEY;
 
1163
 
 
1164
  if (share->found_next_number_field)
 
1165
  {
 
1166
    Field *reg_field= *share->found_next_number_field;
 
1167
    if ((int) (share->next_number_index= (uint32_t)
 
1168
               find_ref_key(share->key_info, share->keys,
 
1169
                            share->default_values, reg_field,
 
1170
                            &share->next_number_key_offset,
 
1171
                            &share->next_number_keypart)) < 0)
 
1172
    {
 
1173
      /* Wrong field definition */
 
1174
      error= 4;
 
1175
      goto err;
 
1176
    }
 
1177
    else
 
1178
      reg_field->flags |= AUTO_INCREMENT_FLAG;
 
1179
  }
 
1180
 
 
1181
  if (share->blob_fields)
 
1182
  {
 
1183
    Field **ptr;
 
1184
    uint32_t k, *save;
 
1185
 
 
1186
    /* Store offsets to blob fields to find them fast */
 
1187
    if (!(share->blob_field= save=
 
1188
          (uint*) alloc_root(&share->mem_root,
 
1189
                             (uint32_t) (share->blob_fields* sizeof(uint32_t)))))
 
1190
      goto err;
 
1191
    for (k= 0, ptr= share->field ; *ptr ; ptr++, k++)
 
1192
    {
 
1193
      if ((*ptr)->flags & BLOB_FLAG)
 
1194
        (*save++)= k;
 
1195
    }
 
1196
  }
 
1197
 
 
1198
  share->db_low_byte_first= true; // @todo Question this.
 
1199
  share->column_bitmap_size= bitmap_buffer_size(share->fields);
 
1200
 
 
1201
  my_bitmap_map *bitmaps;
 
1202
 
 
1203
  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
 
1204
                                             share->column_bitmap_size)))
 
1205
    goto err;
 
1206
  share->all_set.init(bitmaps, share->fields);
 
1207
  share->all_set.setAll();
 
1208
 
 
1209
  return (0);
 
1210
 
 
1211
err:
 
1212
  if (field_offsets)
 
1213
    free(field_offsets);
 
1214
  if (field_pack_length)
 
1215
    free(field_pack_length);
 
1216
 
 
1217
  share->error= error;
 
1218
  share->open_errno= errno;
 
1219
  share->errarg= 0;
 
1220
  hash_free(&share->name_hash);
 
1221
  share->open_table_error(error, share->open_errno, 0);
 
1222
 
 
1223
  return error;
 
1224
}
 
1225
 
 
1226
/*
 
1227
  Read table definition from a binary / text based .frm cursor
 
1228
 
 
1229
  SYNOPSIS
 
1230
  open_table_def()
 
1231
  session               Thread Cursor
 
1232
  share         Fill this with table definition
 
1233
 
 
1234
  NOTES
 
1235
    This function is called when the table definition is not cached in
 
1236
    table_def_cache
 
1237
    The data is returned in 'share', which is alloced by
 
1238
    alloc_table_share().. The code assumes that share is initialized.
 
1239
 
 
1240
  RETURN VALUES
 
1241
   0    ok
 
1242
   1    Error (see open_table_error)
 
1243
   2    Error (see open_table_error)
 
1244
   3    Wrong data in .frm cursor
 
1245
   4    Error (see open_table_error)
 
1246
   5    Error (see open_table_error: charset unavailable)
 
1247
   6    Unknown .frm version
 
1248
*/
 
1249
 
 
1250
int open_table_def(Session& session, TableShare *share)
 
1251
{
 
1252
  int error;
 
1253
  bool error_given;
 
1254
 
 
1255
  error= 1;
 
1256
  error_given= 0;
 
1257
 
 
1258
  message::Table table;
 
1259
 
 
1260
  error= plugin::StorageEngine::getTableDefinition(session, share->normalized_path.str,
 
1261
                                                   share->db.str,
 
1262
                                                   share->table_name.str,
 
1263
                                                   false,
 
1264
                                                   &table);
 
1265
 
 
1266
  if (error != EEXIST)
 
1267
  {
 
1268
    if (error > 0)
 
1269
    {
 
1270
      errno= error;
 
1271
      error= 1;
 
1272
    }
 
1273
    else
 
1274
    {
 
1275
      if (not table.IsInitialized())
 
1276
      {
 
1277
        error= 4;
 
1278
      }
 
1279
    }
 
1280
    goto err_not_open;
 
1281
  }
 
1282
 
 
1283
  error= parse_table_proto(session, table, share);
 
1284
 
 
1285
  share->table_category= get_table_category(& share->db);
 
1286
 
 
1287
  if (not error)
 
1288
    session.status_var.opened_shares++;
 
1289
 
 
1290
err_not_open:
 
1291
  if (error && !error_given)
 
1292
  {
 
1293
    share->error= error;
 
1294
    share->open_table_error(error, (share->open_errno= errno), 0);
 
1295
  }
 
1296
 
 
1297
  return(error);
 
1298
}
 
1299
 
 
1300
 
 
1301
/*
 
1302
  Open a table based on a TableShare
 
1303
 
 
1304
  SYNOPSIS
 
1305
    open_table_from_share()
 
1306
    session                     Thread Cursor
 
1307
    share               Table definition
 
1308
    alias               Alias for table
 
1309
    db_stat             open flags (for example HA_OPEN_KEYFILE|
 
1310
                        HA_OPEN_RNDFILE..) can be 0 (example in
 
1311
                        ha_example_table)
 
1312
    ha_open_flags       HA_OPEN_ABORT_IF_LOCKED etc..
 
1313
    outparam            result table
 
1314
 
 
1315
  RETURN VALUES
 
1316
   0    ok
 
1317
   1    Error (see open_table_error)
 
1318
   2    Error (see open_table_error)
 
1319
   3    Wrong data in .frm cursor
 
1320
   4    Error (see open_table_error)
 
1321
   5    Error (see open_table_error: charset unavailable)
 
1322
   7    Table definition has changed in engine
 
1323
*/
 
1324
 
 
1325
int open_table_from_share(Session *session, TableShare *share, const char *alias,
 
1326
                          uint32_t db_stat, uint32_t ha_open_flags,
 
1327
                          Table *outparam)
 
1328
{
 
1329
  int error;
 
1330
  uint32_t records, i, bitmap_size;
 
1331
  bool error_reported= false;
 
1332
  unsigned char *record, *bitmaps;
 
1333
  Field **field_ptr;
 
1334
 
 
1335
  /* Parsing of partitioning information from .frm needs session->lex set up. */
 
1336
  assert(session->lex->is_lex_started);
 
1337
 
 
1338
  error= 1;
 
1339
  outparam->resetTable(session, share, db_stat);
 
1340
 
 
1341
 
 
1342
  if (not (outparam->alias= strdup(alias)))
 
1343
    goto err;
 
1344
 
 
1345
  /* Allocate Cursor */
 
1346
  if (not (outparam->cursor= share->db_type()->getCursor(*share, &outparam->mem_root)))
 
1347
    goto err;
 
1348
 
 
1349
  error= 4;
 
1350
  records= 0;
 
1351
  if ((db_stat & HA_OPEN_KEYFILE))
 
1352
    records=1;
 
1353
 
 
1354
  records++;
 
1355
 
 
1356
  if (!(record= (unsigned char*) alloc_root(&outparam->mem_root,
 
1357
                                   share->rec_buff_length * records)))
 
1358
    goto err;
 
1359
 
 
1360
  if (records == 0)
 
1361
  {
 
1362
    /* We are probably in hard repair, and the buffers should not be used */
 
1363
    outparam->record[0]= outparam->record[1]= share->default_values;
 
1364
  }
 
1365
  else
 
1366
  {
 
1367
    outparam->record[0]= record;
 
1368
    if (records > 1)
 
1369
      outparam->record[1]= record+ share->rec_buff_length;
 
1370
    else
 
1371
      outparam->record[1]= outparam->record[0];   // Safety
 
1372
  }
 
1373
 
 
1374
#ifdef HAVE_purify
 
1375
  /*
 
1376
    We need this because when we read var-length rows, we are not updating
 
1377
    bytes after end of varchar
 
1378
  */
 
1379
  if (records > 1)
 
1380
  {
 
1381
    memcpy(outparam->record[0], share->default_values, share->rec_buff_length);
 
1382
    memcpy(outparam->record[1], share->default_values, share->null_bytes);
 
1383
    if (records > 2)
 
1384
      memcpy(outparam->record[1], share->default_values,
 
1385
             share->rec_buff_length);
 
1386
  }
 
1387
#endif
 
1388
 
 
1389
  if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
 
1390
                                          (uint32_t) ((share->fields+1)*
 
1391
                                                  sizeof(Field*)))))
 
1392
    goto err;
 
1393
 
 
1394
  outparam->field= field_ptr;
 
1395
 
 
1396
  record= (unsigned char*) outparam->record[0]-1;       /* Fieldstart = 1 */
 
1397
 
 
1398
  outparam->null_flags= (unsigned char*) record+1;
 
1399
 
 
1400
  /* Setup copy of fields from share, but use the right alias and record */
 
1401
  for (i= 0 ; i < share->fields; i++, field_ptr++)
 
1402
  {
 
1403
    if (!((*field_ptr)= share->field[i]->clone(&outparam->mem_root, outparam)))
 
1404
      goto err;
 
1405
  }
 
1406
  (*field_ptr)= 0;                              // End marker
 
1407
 
 
1408
  if (share->found_next_number_field)
 
1409
    outparam->found_next_number_field=
 
1410
      outparam->field[(uint32_t) (share->found_next_number_field - share->field)];
 
1411
  if (share->timestamp_field)
 
1412
    outparam->timestamp_field= (Field_timestamp*) outparam->field[share->timestamp_field_offset];
 
1413
 
 
1414
 
 
1415
  /* Fix key->name and key_part->field */
 
1416
  if (share->key_parts)
 
1417
  {
 
1418
    KEY *key_info, *key_info_end;
 
1419
    KEY_PART_INFO *key_part;
 
1420
    uint32_t n_length;
 
1421
    n_length= share->keys*sizeof(KEY) + share->key_parts*sizeof(KEY_PART_INFO);
 
1422
    if (!(key_info= (KEY*) alloc_root(&outparam->mem_root, n_length)))
 
1423
      goto err;
 
1424
    outparam->key_info= key_info;
 
1425
    key_part= (reinterpret_cast<KEY_PART_INFO*> (key_info+share->keys));
 
1426
 
 
1427
    memcpy(key_info, share->key_info, sizeof(*key_info)*share->keys);
 
1428
    memcpy(key_part, share->key_info[0].key_part, (sizeof(*key_part) *
 
1429
                                                   share->key_parts));
 
1430
 
 
1431
    for (key_info_end= key_info + share->keys ;
 
1432
         key_info < key_info_end ;
 
1433
         key_info++)
 
1434
    {
 
1435
      KEY_PART_INFO *key_part_end;
 
1436
 
 
1437
      key_info->table= outparam;
 
1438
      key_info->key_part= key_part;
 
1439
 
 
1440
      for (key_part_end= key_part+ key_info->key_parts ;
 
1441
           key_part < key_part_end ;
 
1442
           key_part++)
 
1443
      {
 
1444
        Field *field= key_part->field= outparam->field[key_part->fieldnr-1];
 
1445
 
 
1446
        if (field->key_length() != key_part->length &&
 
1447
            !(field->flags & BLOB_FLAG))
 
1448
        {
 
1449
          /*
 
1450
            We are using only a prefix of the column as a key:
 
1451
            Create a new field for the key part that matches the index
 
1452
          */
 
1453
          field= key_part->field=field->new_field(&outparam->mem_root,
 
1454
                                                  outparam, 0);
 
1455
          field->field_length= key_part->length;
 
1456
        }
 
1457
      }
 
1458
    }
 
1459
  }
 
1460
 
 
1461
  /* Allocate bitmaps */
 
1462
 
 
1463
  bitmap_size= share->column_bitmap_size;
 
1464
  if (!(bitmaps= (unsigned char*) alloc_root(&outparam->mem_root, bitmap_size*3)))
 
1465
    goto err;
 
1466
  outparam->def_read_set.init((my_bitmap_map*) bitmaps, share->fields);
 
1467
  outparam->def_write_set.init((my_bitmap_map*) (bitmaps+bitmap_size), share->fields);
 
1468
  outparam->tmp_set.init((my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields);
 
1469
  outparam->default_column_bitmaps();
 
1470
 
 
1471
  /* The table struct is now initialized;  Open the table */
 
1472
  error= 2;
 
1473
  if (db_stat)
 
1474
  {
 
1475
    int ha_err;
 
1476
    if ((ha_err= (outparam->cursor->
 
1477
                  ha_open(outparam, share->normalized_path.str,
 
1478
                          (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
 
1479
                          (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
 
1480
                           (db_stat & HA_WAIT_IF_LOCKED) ?  HA_OPEN_WAIT_IF_LOCKED :
 
1481
                           (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
 
1482
                          HA_OPEN_ABORT_IF_LOCKED :
 
1483
                           HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
 
1484
    {
 
1485
      switch (ha_err)
 
1486
      {
 
1487
        case HA_ERR_NO_SUCH_TABLE:
 
1488
          /*
 
1489
            The table did not exists in storage engine, use same error message
 
1490
            as if the .frm cursor didn't exist
 
1491
          */
 
1492
          error= 1;
 
1493
          errno= ENOENT;
 
1494
          break;
 
1495
        case EMFILE:
 
1496
          /*
 
1497
            Too many files opened, use same error message as if the .frm
 
1498
            cursor can't open
 
1499
           */
 
1500
          error= 1;
 
1501
          errno= EMFILE;
 
1502
          break;
 
1503
        default:
 
1504
          outparam->print_error(ha_err, MYF(0));
 
1505
          error_reported= true;
 
1506
          if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
 
1507
            error= 7;
 
1508
          break;
 
1509
      }
 
1510
      goto err;
 
1511
    }
 
1512
  }
 
1513
 
 
1514
#if defined(HAVE_purify)
 
1515
  memset(bitmaps, 0, bitmap_size*3);
 
1516
#endif
 
1517
 
 
1518
  session->status_var.opened_tables++;
 
1519
 
 
1520
  return (0);
 
1521
 
 
1522
 err:
 
1523
  if (!error_reported)
 
1524
    share->open_table_error(error, errno, 0);
 
1525
  delete outparam->cursor;
 
1526
  outparam->cursor= 0;                          // For easier error checking
 
1527
  outparam->db_stat= 0;
 
1528
  free_root(&outparam->mem_root, MYF(0));       // Safe to call on zeroed root
 
1529
  free((char*) outparam->alias);
 
1530
  return (error);
 
1531
}
 
1532
 
 
1533
bool Table::fill_item_list(List<Item> *item_list) const
 
1534
{
 
1535
  /*
 
1536
    All Item_field's created using a direct pointer to a field
 
1537
    are fixed in Item_field constructor.
 
1538
  */
 
1539
  for (Field **ptr= field; *ptr; ptr++)
 
1540
  {
 
1541
    Item_field *item= new Item_field(*ptr);
 
1542
    if (!item || item_list->push_back(item))
 
1543
      return true;
 
1544
  }
 
1545
  return false;
 
1546
}
 
1547
 
 
1548
int Table::closefrm(bool free_share)
79
1549
{
80
1550
  int error= 0;
81
1551
 
82
1552
  if (db_stat)
83
1553
    error= cursor->close();
84
 
  _alias.clear();
85
 
 
 
1554
  free((char*) alias);
 
1555
  alias= NULL;
86
1556
  if (field)
87
1557
  {
88
1558
    for (Field **ptr=field ; *ptr ; ptr++)
89
 
    {
90
1559
      delete *ptr;
91
 
    }
92
1560
    field= 0;
93
1561
  }
94
 
  safe_delete(cursor);
95
 
 
 
1562
  delete cursor;
 
1563
  cursor= 0;                            /* For easier errorchecking */
96
1564
  if (free_share)
97
1565
  {
98
 
    release();
 
1566
    if (s->tmp_table == STANDARD_TABLE)
 
1567
      TableShare::release(s);
 
1568
    else
 
1569
      s->free_table_share();
99
1570
  }
 
1571
  free_root(&mem_root, MYF(0));
100
1572
 
101
1573
  return error;
102
1574
}
103
1575
 
104
 
Table::~Table()
105
 
{
106
 
  mem_root.free_root(MYF(0));
107
 
}
108
 
 
109
1576
 
110
1577
void Table::resetTable(Session *session,
111
1578
                       TableShare *share,
112
1579
                       uint32_t db_stat_arg)
113
1580
{
114
 
  setShare(share);
115
 
  in_use= session;
116
 
 
 
1581
  s= share;
117
1582
  field= NULL;
118
1583
 
119
1584
  cursor= NULL;
126
1591
  tablenr= 0;
127
1592
  db_stat= db_stat_arg;
128
1593
 
 
1594
  in_use= session;
129
1595
  record[0]= (unsigned char *) NULL;
130
1596
  record[1]= (unsigned char *) NULL;
131
1597
 
132
 
  insert_values.clear();
 
1598
  insert_values= NULL;
133
1599
  key_info= NULL;
134
1600
  next_number_field= NULL;
135
1601
  found_next_number_field= NULL;
137
1603
 
138
1604
  pos_in_table_list= NULL;
139
1605
  group= NULL;
140
 
  _alias.clear();
 
1606
  alias= NULL;
141
1607
  null_flags= NULL;
142
1608
 
143
1609
  lock_position= 0;
191
1657
  memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
192
1658
 
193
1659
  memory::init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
1660
  memset(&sort, 0, sizeof(filesort_info_st));
194
1661
}
195
1662
 
196
1663
 
197
1664
 
198
1665
/* Deallocate temporary blob storage */
199
1666
 
200
 
void free_blobs(Table *table)
 
1667
void free_blobs(register Table *table)
201
1668
{
202
1669
  uint32_t *ptr, *end;
203
1670
  for (ptr= table->getBlobField(), end=ptr + table->sizeBlobFields();
204
1671
       ptr != end ;
205
1672
       ptr++)
206
 
  {
207
 
    ((Field_blob*) table->getField(*ptr))->free();
208
 
  }
 
1673
    ((Field_blob*) table->field[*ptr])->free();
209
1674
}
210
1675
 
211
1676
 
 
1677
        /* error message when opening a form cursor */
 
1678
 
 
1679
void TableShare::open_table_error(int pass_error, int db_errno, int pass_errarg)
 
1680
{
 
1681
  int err_no;
 
1682
  char buff[FN_REFLEN];
 
1683
  myf errortype= ME_ERROR+ME_WAITTANG;
 
1684
 
 
1685
  switch (pass_error) {
 
1686
  case 7:
 
1687
  case 1:
 
1688
    if (db_errno == ENOENT)
 
1689
      my_error(ER_NO_SUCH_TABLE, MYF(0), db.str, table_name.str);
 
1690
    else
 
1691
    {
 
1692
      sprintf(buff,"%s",normalized_path.str);
 
1693
      my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
 
1694
               errortype, buff, db_errno);
 
1695
    }
 
1696
    break;
 
1697
  case 2:
 
1698
  {
 
1699
    Cursor *cursor= 0;
 
1700
    const char *datext= "";
 
1701
 
 
1702
    if (db_type() != NULL)
 
1703
    {
 
1704
      if ((cursor= db_type()->getCursor(*this, current_session->mem_root)))
 
1705
      {
 
1706
        if (!(datext= *db_type()->bas_ext()))
 
1707
          datext= "";
 
1708
      }
 
1709
    }
 
1710
    err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
 
1711
      ER_FILE_USED : ER_CANT_OPEN_FILE;
 
1712
    sprintf(buff,"%s%s", normalized_path.str,datext);
 
1713
    my_error(err_no,errortype, buff, db_errno);
 
1714
    delete cursor;
 
1715
    break;
 
1716
  }
 
1717
  case 5:
 
1718
  {
 
1719
    const char *csname= get_charset_name((uint32_t) pass_errarg);
 
1720
    char tmp[10];
 
1721
    if (!csname || csname[0] =='?')
 
1722
    {
 
1723
      snprintf(tmp, sizeof(tmp), "#%d", pass_errarg);
 
1724
      csname= tmp;
 
1725
    }
 
1726
    my_printf_error(ER_UNKNOWN_COLLATION,
 
1727
                    _("Unknown collation '%s' in table '%-.64s' definition"),
 
1728
                    MYF(0), csname, table_name.str);
 
1729
    break;
 
1730
  }
 
1731
  case 6:
 
1732
    sprintf(buff,"%s", normalized_path.str);
 
1733
    my_printf_error(ER_NOT_FORM_FILE,
 
1734
                    _("Table '%-.64s' was created with a different version "
 
1735
                    "of Drizzle and cannot be read"),
 
1736
                    MYF(0), buff);
 
1737
    break;
 
1738
  case 8:
 
1739
    break;
 
1740
  default:                              /* Better wrong error than none */
 
1741
  case 4:
 
1742
    sprintf(buff,"%s", normalized_path.str);
 
1743
    my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
 
1744
    break;
 
1745
  }
 
1746
  return;
 
1747
} /* open_table_error */
 
1748
 
 
1749
 
212
1750
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings)
213
1751
{
214
 
  TYPELIB *result= (TYPELIB*) mem_root->alloc_root(sizeof(TYPELIB));
 
1752
  TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
215
1753
  if (!result)
216
1754
    return 0;
217
1755
  result->count= strings.elements;
218
1756
  result->name= "";
219
1757
  uint32_t nbytes= (sizeof(char*) + sizeof(uint32_t)) * (result->count + 1);
220
1758
  
221
 
  if (!(result->type_names= (const char**) mem_root->alloc_root(nbytes)))
 
1759
  if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
222
1760
    return 0;
223
1761
    
224
1762
  result->type_lengths= (uint*) (result->type_names + result->count + 1);
225
1763
 
226
 
  List<String>::iterator it(strings.begin());
 
1764
  List_iterator<String> it(strings);
227
1765
  String *tmp;
228
1766
  for (uint32_t i= 0; (tmp= it++); i++)
229
1767
  {
239
1777
 
240
1778
        /* Check that the integer is in the internal */
241
1779
 
242
 
int set_zone(int nr, int min_zone, int max_zone)
 
1780
int set_zone(register int nr, int min_zone, int max_zone)
243
1781
{
244
1782
  if (nr<=min_zone)
245
1783
    return (min_zone);
248
1786
  return (nr);
249
1787
} /* set_zone */
250
1788
 
 
1789
        /* Adjust number to next larger disk buffer */
 
1790
 
 
1791
ulong next_io_size(register ulong pos)
 
1792
{
 
1793
  register ulong offset;
 
1794
  if ((offset= pos & (IO_SIZE-1)))
 
1795
    return pos-offset+IO_SIZE;
 
1796
  return pos;
 
1797
} /* next_io_size */
 
1798
 
251
1799
 
252
1800
/*
253
1801
  Store an SQL quoted string.
275
1823
        (mblen= my_ismbchar(default_charset_info, pos, end)))
276
1824
    {
277
1825
      res->append(pos, mblen);
278
 
      pos+= mblen - 1;
 
1826
      pos+= mblen;
279
1827
      if (pos >= end)
280
1828
        break;
281
1829
      continue;
311
1859
}
312
1860
 
313
1861
 
 
1862
/*
 
1863
  Set up column usage bitmaps for a temporary table
 
1864
 
 
1865
  IMPLEMENTATION
 
1866
    For temporary tables, we need one bitmap with all columns set and
 
1867
    a tmp_set bitmap to be used by things like filesort.
 
1868
*/
 
1869
 
 
1870
void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)
 
1871
{
 
1872
  uint32_t field_count= s->fields;
 
1873
 
 
1874
  this->def_read_set.init((my_bitmap_map*) bitmaps, field_count);
 
1875
  this->tmp_set.init((my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);
 
1876
 
 
1877
  /* write_set and all_set are copies of read_set */
 
1878
  def_write_set= def_read_set;
 
1879
  s->all_set= def_read_set;
 
1880
  this->s->all_set.setAll();
 
1881
  default_column_bitmaps();
 
1882
}
 
1883
 
 
1884
 
 
1885
 
 
1886
void Table::updateCreateInfo(message::Table *table_proto)
 
1887
{
 
1888
  message::Table::TableOptions *table_options= table_proto->mutable_options();
 
1889
  table_options->set_block_size(s->block_size);
 
1890
  table_options->set_comment(s->getComment());
 
1891
}
 
1892
 
314
1893
int rename_file_ext(const char * from,const char * to,const char * ext)
315
1894
{
316
1895
  string from_s, to_s;
323
1902
}
324
1903
 
325
1904
/*
 
1905
  DESCRIPTION
 
1906
    given a buffer with a key value, and a map of keyparts
 
1907
    that are present in this value, returns the length of the value
 
1908
*/
 
1909
uint32_t calculate_key_len(Table *table, uint32_t key,
 
1910
                       const unsigned char *,
 
1911
                       key_part_map keypart_map)
 
1912
{
 
1913
  /* works only with key prefixes */
 
1914
  assert(((keypart_map + 1) & keypart_map) == 0);
 
1915
 
 
1916
  KEY *key_info= table->s->key_info+key;
 
1917
  KEY_PART_INFO *key_part= key_info->key_part;
 
1918
  KEY_PART_INFO *end_key_part= key_part + key_info->key_parts;
 
1919
  uint32_t length= 0;
 
1920
 
 
1921
  while (key_part < end_key_part && keypart_map)
 
1922
  {
 
1923
    length+= key_part->store_length;
 
1924
    keypart_map >>= 1;
 
1925
    key_part++;
 
1926
  }
 
1927
  return length;
 
1928
}
 
1929
 
 
1930
/*
 
1931
  Check if database name is valid
 
1932
 
 
1933
  SYNPOSIS
 
1934
    check_db_name()
 
1935
    org_name            Name of database and length
 
1936
 
 
1937
  RETURN
 
1938
    0   ok
 
1939
    1   error
 
1940
*/
 
1941
 
 
1942
bool check_db_name(LEX_STRING *org_name)
 
1943
{
 
1944
  char *name= org_name->str;
 
1945
  uint32_t name_length= org_name->length;
 
1946
 
 
1947
  if (not plugin::Authorization::isAuthorized(current_session->getSecurityContext(),
 
1948
                                              string(name, name_length)))
 
1949
  {
 
1950
    return 1;
 
1951
  }
 
1952
 
 
1953
  if (!name_length || name_length > NAME_LEN || name[name_length - 1] == ' ')
 
1954
    return 1;
 
1955
 
 
1956
  my_casedn_str(files_charset_info, name);
 
1957
 
 
1958
  return check_identifier_name(org_name);
 
1959
}
 
1960
 
 
1961
/*
326
1962
  Allow anything as a table name, as long as it doesn't contain an
327
1963
  ' ' at the end
328
1964
  returns 1 on error
392
2028
    bitmap_clear_all(&table->def_read_set);
393
2029
    bitmap_clear_all(&table->def_write_set);
394
2030
  */
395
 
  def_read_set.reset();
396
 
  def_write_set.reset();
397
 
  column_bitmaps_set(def_read_set, def_write_set);
 
2031
  def_read_set.clearAll();
 
2032
  def_write_set.clearAll();
 
2033
  column_bitmaps_set(&def_read_set, &def_write_set);
398
2034
}
399
2035
 
400
2036
 
411
2047
{
412
2048
 
413
2049
  if ((cursor->getEngine()->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX)) &&
414
 
      getShare()->hasPrimaryKey())
 
2050
      s->primary_key < MAX_KEY)
415
2051
  {
416
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
2052
    mark_columns_used_by_index_no_reset(s->primary_key);
417
2053
  }
418
2054
  return;
419
2055
}
431
2067
 
432
2068
void Table::mark_columns_used_by_index(uint32_t index)
433
2069
{
434
 
  boost::dynamic_bitset<> *bitmap= &tmp_set;
 
2070
  MyBitmap *bitmap= &tmp_set;
435
2071
 
436
2072
  (void) cursor->extra(HA_EXTRA_KEYREAD);
437
 
  bitmap->reset();
438
 
  mark_columns_used_by_index_no_reset(index, *bitmap);
439
 
  column_bitmaps_set(*bitmap, *bitmap);
 
2073
  bitmap->clearAll();
 
2074
  mark_columns_used_by_index_no_reset(index, bitmap);
 
2075
  column_bitmaps_set(bitmap, bitmap);
440
2076
  return;
441
2077
}
442
2078
 
468
2104
 
469
2105
void Table::mark_columns_used_by_index_no_reset(uint32_t index)
470
2106
{
471
 
    mark_columns_used_by_index_no_reset(index, *read_set);
 
2107
    mark_columns_used_by_index_no_reset(index, read_set);
472
2108
}
473
2109
 
474
 
 
475
2110
void Table::mark_columns_used_by_index_no_reset(uint32_t index,
476
 
                                                boost::dynamic_bitset<>& bitmap)
 
2111
                                                MyBitmap *bitmap)
477
2112
{
478
 
  KeyPartInfo *key_part= key_info[index].key_part;
479
 
  KeyPartInfo *key_part_end= (key_part + key_info[index].key_parts);
480
 
  for (; key_part != key_part_end; key_part++)
481
 
  {
482
 
    if (! bitmap.empty())
483
 
      bitmap.set(key_part->fieldnr-1);
484
 
  }
 
2113
  KEY_PART_INFO *key_part= key_info[index].key_part;
 
2114
  KEY_PART_INFO *key_part_end= (key_part +
 
2115
                                key_info[index].key_parts);
 
2116
  for (;key_part != key_part_end; key_part++)
 
2117
    bitmap->setBit(key_part->fieldnr-1);
485
2118
}
486
2119
 
487
2120
 
500
2133
    We must set bit in read set as update_auto_increment() is using the
501
2134
    store() to check overflow of auto_increment values
502
2135
  */
503
 
  setReadSet(found_next_number_field->position());
504
 
  setWriteSet(found_next_number_field->position());
505
 
  if (getShare()->next_number_keypart)
506
 
    mark_columns_used_by_index_no_reset(getShare()->next_number_index);
 
2136
  setReadSet(found_next_number_field->field_index);
 
2137
  setWriteSet(found_next_number_field->field_index);
 
2138
  if (s->next_number_keypart)
 
2139
    mark_columns_used_by_index_no_reset(s->next_number_index);
507
2140
}
508
2141
 
509
2142
 
534
2167
    be able to do an delete
535
2168
 
536
2169
  */
537
 
  if (not getShare()->hasPrimaryKey())
 
2170
  if (s->primary_key == MAX_KEY)
538
2171
  {
539
2172
    /* fallback to use all columns in the table to identify row */
540
2173
    use_all_columns();
541
2174
    return;
542
2175
  }
543
2176
  else
544
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
2177
    mark_columns_used_by_index_no_reset(s->primary_key);
545
2178
 
546
2179
  /* If we the engine wants all predicates we mark all keys */
547
2180
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
550
2183
    for (reg_field= field ; *reg_field ; reg_field++)
551
2184
    {
552
2185
      if ((*reg_field)->flags & PART_KEY_FLAG)
553
 
        setReadSet((*reg_field)->position());
 
2186
        setReadSet((*reg_field)->field_index);
554
2187
    }
555
2188
  }
556
2189
}
582
2215
    the primary key, the hidden primary key or all columns to be
583
2216
    able to do an update
584
2217
  */
585
 
  if (not getShare()->hasPrimaryKey())
 
2218
  if (s->primary_key == MAX_KEY)
586
2219
  {
587
2220
    /* fallback to use all columns in the table to identify row */
588
2221
    use_all_columns();
589
2222
    return;
590
2223
  }
591
2224
  else
592
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
2225
    mark_columns_used_by_index_no_reset(s->primary_key);
593
2226
 
594
2227
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
595
2228
  {
599
2232
    {
600
2233
      /* Merge keys is all keys that had a column refered to in the query */
601
2234
      if (is_overlapping(merge_keys, (*reg_field)->part_of_key))
602
 
        setReadSet((*reg_field)->position());
 
2235
        setReadSet((*reg_field)->field_index);
603
2236
    }
604
2237
  }
605
2238
 
631
2264
  {
632
2265
    Field_blob* const blob= (Field_blob*) field[*ptr];
633
2266
    length+= blob->get_length((const unsigned char*)
634
 
                              (data + blob->offset(getInsertRecord()))) +
 
2267
                              (data + blob->offset(record[0]))) +
635
2268
      HA_KEY_BLOB_LENGTH;
636
2269
  }
637
2270
  return length;
638
2271
}
639
2272
 
640
 
void Table::setVariableWidth(void)
641
 
{
642
 
  assert(in_use);
643
 
  if (in_use && in_use->getLex()->sql_command == SQLCOM_CREATE_TABLE)
644
 
  {
645
 
    getMutableShare()->setVariableWidth();
646
 
    return;
647
 
  }
648
 
 
649
 
  assert(0); // Programming error, you can't set this on a plain old Table.
650
 
}
651
 
 
652
2273
/****************************************************************************
653
2274
 Functions for creating temporary tables.
654
2275
****************************************************************************/
 
2276
 
 
2277
 
 
2278
/* Prototypes */
 
2279
void free_tmp_table(Session *session, Table *entry);
 
2280
 
655
2281
/**
656
2282
  Create field for temporary table from given field.
657
2283
 
686
2312
  */
687
2313
  if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&
688
2314
      (org_field->flags & BLOB_FLAG))
689
 
  {
690
 
    table->setVariableWidth();
691
2315
    new_field= new Field_varstring(convert_blob_length,
692
2316
                                   org_field->maybe_null(),
693
 
                                   org_field->field_name,
 
2317
                                   org_field->field_name, table->s,
694
2318
                                   org_field->charset());
695
 
  }
696
2319
  else
697
 
  {
698
2320
    new_field= org_field->new_field(session->mem_root, table,
699
 
                                    table == org_field->getTable());
700
 
  }
 
2321
                                    table == org_field->table);
701
2322
  if (new_field)
702
2323
  {
703
2324
    new_field->init(table);
710
2331
    if (org_field->maybe_null() || (item && item->maybe_null))
711
2332
      new_field->flags&= ~NOT_NULL_FLAG;        // Because of outer join
712
2333
    if (org_field->type() == DRIZZLE_TYPE_VARCHAR)
713
 
      table->getMutableShare()->db_create_options|= HA_OPTION_PACK_RECORD;
 
2334
      table->s->db_create_options|= HA_OPTION_PACK_RECORD;
714
2335
    else if (org_field->type() == DRIZZLE_TYPE_DOUBLE)
715
2336
      ((Field_double *) new_field)->not_fixed= true;
716
2337
  }
748
2369
#define AVG_STRING_LENGTH_TO_PACK_ROWS   64
749
2370
#define RATIO_TO_PACK_ROWS             2
750
2371
 
 
2372
static void make_internal_temporary_table_path(Session *session, char *path)
 
2373
{
 
2374
  snprintf(path, FN_REFLEN, "%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,
 
2375
           session->thread_id, session->tmp_table++);
 
2376
 
 
2377
  internal::fn_format(path, path, drizzle_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);
 
2378
}
 
2379
 
751
2380
Table *
752
2381
create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,
753
 
                 Order *group, bool distinct, bool save_sum_fields,
 
2382
                 order_st *group, bool distinct, bool save_sum_fields,
754
2383
                 uint64_t select_options, ha_rows rows_limit,
755
2384
                 const char *table_alias)
756
2385
{
757
 
  memory::Root *mem_root_save;
 
2386
  memory::Root *mem_root_save, own_root;
 
2387
  Table *table;
 
2388
  TableShare *share;
758
2389
  uint  i,field_count,null_count,null_pack_length;
759
2390
  uint32_t  copy_func_count= param->func_count;
760
2391
  uint32_t  hidden_null_count, hidden_null_pack_length, hidden_field_count;
764
2395
  bool  using_unique_constraint= false;
765
2396
  bool  use_packed_rows= true;
766
2397
  bool  not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);
767
 
  unsigned char *pos, *group_buff;
 
2398
  char  *tmpname;
 
2399
  char  path[FN_REFLEN];
 
2400
  unsigned char *pos, *group_buff, *bitmaps;
768
2401
  unsigned char *null_flags;
769
2402
  Field **reg_field, **from_field, **default_field;
 
2403
  uint32_t *blob_field;
770
2404
  CopyField *copy= 0;
771
 
  KeyInfo *keyinfo;
772
 
  KeyPartInfo *key_part_info;
 
2405
  KEY *keyinfo;
 
2406
  KEY_PART_INFO *key_part_info;
773
2407
  Item **copy_func;
774
2408
  MI_COLUMNDEF *recinfo;
775
2409
  uint32_t total_uneven_bit_length= 0;
776
2410
  bool force_copy_fields= param->force_copy_fields;
777
2411
  uint64_t max_rows= 0;
778
2412
 
779
 
  session->status_var.created_tmp_tables++;
 
2413
  status_var_increment(session->status_var.created_tmp_tables);
 
2414
 
 
2415
  make_internal_temporary_table_path(session, path);
780
2416
 
781
2417
  if (group)
782
2418
  {
783
2419
    if (! param->quick_group)
784
 
    {
785
2420
      group= 0;                                 // Can't use group key
786
 
    }
787
 
    else for (Order *tmp=group ; tmp ; tmp=tmp->next)
 
2421
    else for (order_st *tmp=group ; tmp ; tmp=tmp->next)
788
2422
    {
789
2423
      /*
790
2424
        marker == 4 means two things:
813
2447
    these items are stored in the temporary table.
814
2448
  */
815
2449
  if (param->precomputed_group_by)
816
 
  {
817
2450
    copy_func_count+= param->sum_func_count;
818
 
  }
819
 
 
820
 
  table::Singular *table;
821
 
  table= session->getInstanceTable(); // This will not go into the tableshare cache, so no key is used.
822
 
 
823
 
  if (not table->getMemRoot()->multi_alloc_root(0,
824
 
                                                &default_field, sizeof(Field*) * (field_count),
825
 
                                                &from_field, sizeof(Field*)*field_count,
826
 
                                                &copy_func, sizeof(*copy_func)*(copy_func_count+1),
827
 
                                                &param->keyinfo, sizeof(*param->keyinfo),
828
 
                                                &key_part_info, sizeof(*key_part_info)*(param->group_parts+1),
829
 
                                                &param->start_recinfo, sizeof(*param->recinfo)*(field_count*2+4),
830
 
                                                &group_buff, (group && ! using_unique_constraint ?
831
 
                                                              param->group_length : 0),
832
 
                                                NULL))
 
2451
 
 
2452
  memory::init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
2453
 
 
2454
  if (!multi_alloc_root(&own_root,
 
2455
                        &table, sizeof(*table),
 
2456
                        &share, sizeof(*share),
 
2457
                        &reg_field, sizeof(Field*) * (field_count+1),
 
2458
                        &default_field, sizeof(Field*) * (field_count),
 
2459
                        &blob_field, sizeof(uint32_t)*(field_count+1),
 
2460
                        &from_field, sizeof(Field*)*field_count,
 
2461
                        &copy_func, sizeof(*copy_func)*(copy_func_count+1),
 
2462
                        &param->keyinfo, sizeof(*param->keyinfo),
 
2463
                        &key_part_info,
 
2464
                        sizeof(*key_part_info)*(param->group_parts+1),
 
2465
                        &param->start_recinfo,
 
2466
                        sizeof(*param->recinfo)*(field_count*2+4),
 
2467
                        &tmpname, (uint32_t) strlen(path)+1,
 
2468
                        &group_buff, (group && ! using_unique_constraint ?
 
2469
                                      param->group_length : 0),
 
2470
                        &bitmaps, bitmap_buffer_size(field_count)*2,
 
2471
                        NULL))
833
2472
  {
834
2473
    return NULL;
835
2474
  }
836
2475
  /* CopyField belongs to Tmp_Table_Param, allocate it in Session mem_root */
837
2476
  if (!(param->copy_field= copy= new (session->mem_root) CopyField[field_count]))
838
2477
  {
 
2478
    free_root(&own_root, MYF(0));
839
2479
    return NULL;
840
2480
  }
841
2481
  param->items_to_copy= copy_func;
 
2482
  strcpy(tmpname,path);
842
2483
  /* make table according to fields */
843
2484
 
 
2485
  memset(table, 0, sizeof(*table));
 
2486
  memset(reg_field, 0, sizeof(Field*)*(field_count+1));
844
2487
  memset(default_field, 0, sizeof(Field*) * (field_count));
845
2488
  memset(from_field, 0, sizeof(Field*)*field_count);
846
2489
 
 
2490
  table->mem_root= own_root;
847
2491
  mem_root_save= session->mem_root;
848
 
  session->mem_root= table->getMemRoot();
 
2492
  session->mem_root= &table->mem_root;
849
2493
 
850
 
  table->getMutableShare()->setFields(field_count+1);
851
 
  table->setFields(table->getMutableShare()->getFields(true));
852
 
  reg_field= table->getMutableShare()->getFields(true);
853
 
  table->setAlias(table_alias);
 
2494
  table->field=reg_field;
 
2495
  table->alias= table_alias;
854
2496
  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */
855
2497
  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
856
2498
  table->map=1;
857
2499
  table->copy_blobs= 1;
858
 
  assert(session);
859
2500
  table->in_use= session;
860
2501
  table->quick_keys.reset();
861
2502
  table->covering_keys.reset();
862
2503
  table->keys_in_use_for_query.reset();
863
2504
 
864
 
  table->getMutableShare()->blob_field.resize(field_count+1);
865
 
  uint32_t *blob_field= &table->getMutableShare()->blob_field[0];
866
 
  table->getMutableShare()->db_low_byte_first=1;                // True for HEAP and MyISAM
867
 
  table->getMutableShare()->table_charset= param->table_charset;
868
 
  table->getMutableShare()->keys_for_keyread.reset();
869
 
  table->getMutableShare()->keys_in_use.reset();
 
2505
  table->setShare(share);
 
2506
  share->init(tmpname, tmpname);
 
2507
  share->blob_field= blob_field;
 
2508
  share->blob_ptr_size= portable_sizeof_char_ptr;
 
2509
  share->db_low_byte_first=1;                // True for HEAP and MyISAM
 
2510
  share->table_charset= param->table_charset;
 
2511
  share->primary_key= MAX_KEY;               // Indicate no primary key
 
2512
  share->keys_for_keyread.reset();
 
2513
  share->keys_in_use.reset();
870
2514
 
871
2515
  /* Calculate which type of fields we will store in the temporary table */
872
2516
 
874
2518
  blob_count= string_count= null_count= hidden_null_count= group_null_items= 0;
875
2519
  param->using_indirect_summary_function= 0;
876
2520
 
877
 
  List<Item>::iterator li(fields.begin());
 
2521
  List_iterator_fast<Item> li(fields);
878
2522
  Item *item;
879
2523
  Field **tmp_from_field=from_field;
880
2524
  while ((item=li++))
933
2577
          }
934
2578
          session->mem_root= mem_root_save;
935
2579
          session->change_item_tree(argp, new Item_field(new_field));
936
 
          session->mem_root= table->getMemRoot();
 
2580
          session->mem_root= &table->mem_root;
937
2581
          if (!(new_field->flags & NOT_NULL_FLAG))
938
2582
          {
939
2583
            null_count++;
943
2587
            */
944
2588
            (*argp)->maybe_null=1;
945
2589
          }
946
 
          new_field->setPosition(fieldnr++);
 
2590
          new_field->field_index= fieldnr++;
947
2591
        }
948
2592
      }
949
2593
    }
990
2634
        group_null_items++;
991
2635
        new_field->flags|= GROUP_FLAG;
992
2636
      }
993
 
      new_field->setPosition(fieldnr++);
 
2637
      new_field->field_index= fieldnr++;
994
2638
      *(reg_field++)= new_field;
995
2639
    }
996
2640
    if (!--hidden_field_count)
1008
2652
      null_count= 0;
1009
2653
    }
1010
2654
  }
1011
 
  assert(fieldnr == (uint32_t) (reg_field - table->getFields()));
1012
 
  assert(field_count >= (uint32_t) (reg_field - table->getFields()));
 
2655
  assert(fieldnr == (uint32_t) (reg_field - table->field));
 
2656
  assert(field_count >= (uint32_t) (reg_field - table->field));
1013
2657
  field_count= fieldnr;
1014
2658
  *reg_field= 0;
1015
2659
  *blob_field= 0;                               // End marker
1016
 
  table->getMutableShare()->setFieldSize(field_count);
 
2660
  share->fields= field_count;
1017
2661
 
1018
2662
  /* If result table is small; use a heap */
1019
2663
  /* future: storage engine selection can be made dynamic? */
1020
 
  if (blob_count || using_unique_constraint || 
1021
 
      (session->getLex()->select_lex.options & SELECT_BIG_RESULT) ||
1022
 
      (session->getLex()->current_select->olap == ROLLUP_TYPE) ||
 
2664
  if (blob_count || using_unique_constraint ||
1023
2665
      (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) == OPTION_BIG_TABLES)
1024
2666
  {
1025
 
    table->getMutableShare()->storage_engine= myisam_engine;
1026
 
    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
 
2667
    share->storage_engine= myisam_engine;
 
2668
    table->cursor= share->db_type()->getCursor(*share, &table->mem_root);
1027
2669
    if (group &&
1028
2670
        (param->group_parts > table->cursor->getEngine()->max_key_parts() ||
1029
2671
         param->group_length > table->cursor->getEngine()->max_key_length()))
1030
 
    {
1031
2672
      using_unique_constraint= true;
1032
 
    }
1033
2673
  }
1034
2674
  else
1035
2675
  {
1036
 
    table->getMutableShare()->storage_engine= heap_engine;
1037
 
    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
 
2676
    share->storage_engine= heap_engine;
 
2677
    table->cursor= share->db_type()->getCursor(*share, &table->mem_root);
1038
2678
  }
1039
2679
  if (! table->cursor)
1040
2680
    goto err;
1043
2683
  if (! using_unique_constraint)
1044
2684
    reclength+= group_null_items;       // null flag is stored separately
1045
2685
 
1046
 
  table->getMutableShare()->blob_fields= blob_count;
 
2686
  share->blob_fields= blob_count;
1047
2687
  if (blob_count == 0)
1048
2688
  {
1049
2689
    /* We need to ensure that first byte is not 0 for the delete link */
1062
2702
  if (blob_count || ((string_total_length >= STRING_TOTAL_LENGTH_TO_PACK_ROWS) && (reclength / string_total_length <= RATIO_TO_PACK_ROWS || (string_total_length / string_count) >= AVG_STRING_LENGTH_TO_PACK_ROWS)))
1063
2703
    use_packed_rows= 1;
1064
2704
 
1065
 
  table->getMutableShare()->setRecordLength(reclength);
 
2705
  share->reclength= reclength;
1066
2706
  {
1067
2707
    uint32_t alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1);
1068
 
    table->getMutableShare()->rec_buff_length= alloc_length;
1069
 
    if (!(table->record[0]= (unsigned char*) table->alloc_root(alloc_length*2)))
1070
 
    {
 
2708
    share->rec_buff_length= alloc_length;
 
2709
    if (!(table->record[0]= (unsigned char*)
 
2710
                            alloc_root(&table->mem_root, alloc_length*3)))
1071
2711
      goto err;
1072
 
    }
1073
 
    table->record[1]= table->getInsertRecord()+alloc_length;
1074
 
    table->getMutableShare()->resizeDefaultValues(alloc_length);
 
2712
    table->record[1]= table->record[0]+alloc_length;
 
2713
    share->default_values= table->record[1]+alloc_length;
1075
2714
  }
1076
2715
  copy_func[0]= 0;                              // End marker
1077
2716
  param->func_count= copy_func - param->items_to_copy;
1078
2717
 
1079
 
  table->setup_tmp_table_column_bitmaps();
 
2718
  table->setup_tmp_table_column_bitmaps(bitmaps);
1080
2719
 
1081
2720
  recinfo=param->start_recinfo;
1082
 
  null_flags=(unsigned char*) table->getInsertRecord();
1083
 
  pos=table->getInsertRecord()+ null_pack_length;
 
2721
  null_flags=(unsigned char*) table->record[0];
 
2722
  pos=table->record[0]+ null_pack_length;
1084
2723
  if (null_pack_length)
1085
2724
  {
1086
2725
    memset(recinfo, 0, sizeof(*recinfo));
1089
2728
    recinfo++;
1090
2729
    memset(null_flags, 255, null_pack_length);  // Set null fields
1091
2730
 
1092
 
    table->null_flags= (unsigned char*) table->getInsertRecord();
1093
 
    table->getMutableShare()->null_fields= null_count+ hidden_null_count;
1094
 
    table->getMutableShare()->null_bytes= null_pack_length;
 
2731
    table->null_flags= (unsigned char*) table->record[0];
 
2732
    share->null_fields= null_count+ hidden_null_count;
 
2733
    share->null_bytes= null_pack_length;
1095
2734
  }
1096
2735
  null_count= (blob_count == 0) ? 1 : 0;
1097
2736
  hidden_field_count=param->hidden_field_count;
1098
 
  for (i= 0,reg_field= table->getFields(); i < field_count; i++,reg_field++,recinfo++)
 
2737
  for (i= 0,reg_field=table->field; i < field_count; i++,reg_field++,recinfo++)
1099
2738
  {
1100
2739
    Field *field= *reg_field;
1101
2740
    uint32_t length;
1142
2781
      ptrdiff_t diff;
1143
2782
      Field *orig_field= default_field[i];
1144
2783
      /* Get the value from default_values */
1145
 
      diff= (ptrdiff_t) (orig_field->getTable()->getDefaultValues() - orig_field->getTable()->getInsertRecord());
 
2784
      diff= (ptrdiff_t) (orig_field->table->s->default_values-
 
2785
                            orig_field->table->record[0]);
1146
2786
      orig_field->move_field_offset(diff);      // Points now at default_values
1147
2787
      if (orig_field->is_real_null())
1148
2788
        field->set_null();
1151
2791
        field->set_notnull();
1152
2792
        memcpy(field->ptr, orig_field->ptr, field->pack_length());
1153
2793
      }
1154
 
      orig_field->move_field_offset(-diff);     // Back to getInsertRecord()
 
2794
      orig_field->move_field_offset(-diff);     // Back to record[0]
1155
2795
    }
1156
2796
 
1157
2797
    if (from_field[i])
1170
2810
      recinfo->type=FIELD_NORMAL;
1171
2811
    if (!--hidden_field_count)
1172
2812
      null_count=(null_count+7) & ~7;           // move to next byte
 
2813
 
 
2814
    // fix table name in field entry
 
2815
    field->table_name= &table->alias;
1173
2816
  }
1174
2817
 
1175
2818
  param->copy_field_end=copy;
1177
2820
  table->storeRecordAsDefault();        // Make empty default record
1178
2821
 
1179
2822
  if (session->variables.tmp_table_size == ~ (uint64_t) 0)              // No limit
1180
 
  {
1181
2823
    max_rows= ~(uint64_t) 0;
1182
 
  }
1183
2824
  else
1184
 
  {
1185
 
    max_rows= (uint64_t) (((table->getMutableShare()->db_type() == heap_engine) ?
1186
 
                           min(session->variables.tmp_table_size,
1187
 
                               session->variables.max_heap_table_size) :
1188
 
                           session->variables.tmp_table_size) /
1189
 
                          table->getMutableShare()->getRecordLength());
1190
 
  }
 
2825
    max_rows= (uint64_t) (((share->db_type() == heap_engine) ?
 
2826
                          min(session->variables.tmp_table_size,
 
2827
                              session->variables.max_heap_table_size) :
 
2828
                          session->variables.tmp_table_size) /
 
2829
                         share->reclength);
1191
2830
 
1192
2831
  set_if_bigger(max_rows, (uint64_t)1); // For dummy start options
1193
2832
  /*
1196
2835
  */
1197
2836
  set_if_smaller(max_rows, rows_limit);
1198
2837
 
1199
 
  table->getMutableShare()->setMaxRows(max_rows);
 
2838
  share->setMaxRows(max_rows);
1200
2839
 
1201
2840
  param->end_write_records= rows_limit;
1202
2841
 
1206
2845
  {
1207
2846
    table->group=group;                         /* Table is grouped by key */
1208
2847
    param->group_buff=group_buff;
1209
 
    table->getMutableShare()->keys=1;
1210
 
    table->getMutableShare()->uniques= test(using_unique_constraint);
 
2848
    share->keys=1;
 
2849
    share->uniques= test(using_unique_constraint);
1211
2850
    table->key_info=keyinfo;
1212
2851
    keyinfo->key_part=key_part_info;
1213
2852
    keyinfo->flags=HA_NOSAME;
1216
2855
    keyinfo->rec_per_key= 0;
1217
2856
    keyinfo->algorithm= HA_KEY_ALG_UNDEF;
1218
2857
    keyinfo->name= (char*) "group_key";
1219
 
    Order *cur_group= group;
 
2858
    order_st *cur_group= group;
1220
2859
    for (; cur_group ; cur_group= cur_group->next, key_part_info++)
1221
2860
    {
1222
2861
      Field *field=(*cur_group->item)->get_tmp_table_field();
1223
2862
      bool maybe_null=(*cur_group->item)->maybe_null;
1224
2863
      key_part_info->null_bit= 0;
1225
2864
      key_part_info->field=  field;
1226
 
      key_part_info->offset= field->offset(table->getInsertRecord());
 
2865
      key_part_info->offset= field->offset(table->record[0]);
1227
2866
      key_part_info->length= (uint16_t) field->key_length();
1228
2867
      key_part_info->type=   (uint8_t) field->key_type();
1229
2868
      key_part_info->key_type= 
1251
2890
          keyinfo->flags|= HA_NULL_ARE_EQUAL;   // def. that NULL == NULL
1252
2891
          key_part_info->null_bit=field->null_bit;
1253
2892
          key_part_info->null_offset= (uint32_t) (field->null_ptr -
1254
 
                                              (unsigned char*) table->getInsertRecord());
 
2893
                                              (unsigned char*) table->record[0]);
1255
2894
          cur_group->buff++;                        // Pointer to field data
1256
2895
          group_buff++;                         // Skipp null flag
1257
2896
        }
1278
2917
        indexes on blobs with arbitrary length. Such indexes cannot be
1279
2918
        used for lookups.
1280
2919
      */
1281
 
      table->getMutableShare()->uniques= 1;
 
2920
      share->uniques= 1;
1282
2921
    }
1283
2922
    null_pack_length-=hidden_null_pack_length;
1284
2923
    keyinfo->key_parts= ((field_count-param->hidden_field_count)+
1285
 
                         (table->getMutableShare()->uniques ? test(null_pack_length) : 0));
 
2924
                         (share->uniques ? test(null_pack_length) : 0));
1286
2925
    table->distinct= 1;
1287
 
    table->getMutableShare()->keys= 1;
1288
 
    if (!(key_part_info= (KeyPartInfo*)
1289
 
         table->alloc_root(keyinfo->key_parts * sizeof(KeyPartInfo))))
 
2926
    share->keys= 1;
 
2927
    if (!(key_part_info= (KEY_PART_INFO*)
 
2928
          alloc_root(&table->mem_root,
 
2929
                     keyinfo->key_parts * sizeof(KEY_PART_INFO))))
1290
2930
      goto err;
1291
 
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KeyPartInfo));
 
2931
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KEY_PART_INFO));
1292
2932
    table->key_info=keyinfo;
1293
2933
    keyinfo->key_part=key_part_info;
1294
2934
    keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;
1302
2942
      blobs can distinguish NULL from 0. This extra field is not needed
1303
2943
      when we do not use UNIQUE indexes for blobs.
1304
2944
    */
1305
 
    if (null_pack_length && table->getMutableShare()->uniques)
 
2945
    if (null_pack_length && share->uniques)
1306
2946
    {
1307
2947
      key_part_info->null_bit= 0;
1308
2948
      key_part_info->offset=hidden_null_pack_length;
1309
2949
      key_part_info->length=null_pack_length;
1310
 
      table->setVariableWidth();
1311
 
      key_part_info->field= new Field_varstring(table->getInsertRecord(),
 
2950
      key_part_info->field= new Field_varstring(table->record[0],
1312
2951
                                                (uint32_t) key_part_info->length,
1313
2952
                                                0,
1314
2953
                                                (unsigned char*) 0,
1315
2954
                                                (uint32_t) 0,
1316
2955
                                                NULL,
 
2956
                                                table->s,
1317
2957
                                                &my_charset_bin);
1318
2958
      if (!key_part_info->field)
1319
2959
        goto err;
1323
2963
      key_part_info++;
1324
2964
    }
1325
2965
    /* Create a distinct key over the columns we are going to return */
1326
 
    for (i=param->hidden_field_count, reg_field=table->getFields() + i ;
 
2966
    for (i=param->hidden_field_count, reg_field=table->field + i ;
1327
2967
         i < field_count;
1328
2968
         i++, reg_field++, key_part_info++)
1329
2969
    {
1330
2970
      key_part_info->null_bit= 0;
1331
2971
      key_part_info->field=    *reg_field;
1332
 
      key_part_info->offset=   (*reg_field)->offset(table->getInsertRecord());
 
2972
      key_part_info->offset=   (*reg_field)->offset(table->record[0]);
1333
2973
      key_part_info->length=   (uint16_t) (*reg_field)->pack_length();
1334
 
      /* @todo The below method of computing the key format length of the
 
2974
      /* TODO:
 
2975
        The below method of computing the key format length of the
1335
2976
        key part is a copy/paste from optimizer/range.cc, and table.cc.
1336
2977
        This should be factored out, e.g. as a method of Field.
1337
2978
        In addition it is not clear if any of the Field::*_length
1357
2998
 
1358
2999
  if (session->is_fatal_error)                          // If end of memory
1359
3000
    goto err;
1360
 
  table->getMutableShare()->db_record_offset= 1;
1361
 
  if (table->getShare()->db_type() == myisam_engine)
 
3001
  share->db_record_offset= 1;
 
3002
  if (share->db_type() == myisam_engine)
1362
3003
  {
1363
3004
    if (table->create_myisam_tmp_table(param->keyinfo, param->start_recinfo,
1364
3005
                                       &param->recinfo, select_options))
1365
3006
      goto err;
1366
3007
  }
1367
 
  assert(table->in_use);
1368
3008
  if (table->open_tmp_table())
1369
3009
    goto err;
1370
3010
 
1374
3014
 
1375
3015
err:
1376
3016
  session->mem_root= mem_root_save;
1377
 
  table= NULL;
1378
 
 
 
3017
  table->free_tmp_table(session);
1379
3018
  return NULL;
1380
3019
}
1381
3020
 
1382
3021
/****************************************************************************/
1383
3022
 
1384
 
void Table::column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,
1385
 
                               boost::dynamic_bitset<>& write_set_arg)
1386
 
{
1387
 
  read_set= &read_set_arg;
1388
 
  write_set= &write_set_arg;
1389
 
}
1390
 
 
1391
 
 
1392
 
const boost::dynamic_bitset<> Table::use_all_columns(boost::dynamic_bitset<>& in_map)
1393
 
{
1394
 
  const boost::dynamic_bitset<> old= in_map;
1395
 
  in_map= getShare()->all_set;
 
3023
/**
 
3024
  Create a reduced Table object with properly set up Field list from a
 
3025
  list of field definitions.
 
3026
 
 
3027
    The created table doesn't have a table Cursor associated with
 
3028
    it, has no keys, no group/distinct, no copy_funcs array.
 
3029
    The sole purpose of this Table object is to use the power of Field
 
3030
    class to read/write data to/from table->record[0]. Then one can store
 
3031
    the record in any container (RB tree, hash, etc).
 
3032
    The table is created in Session mem_root, so are the table's fields.
 
3033
    Consequently, if you don't BLOB fields, you don't need to free it.
 
3034
 
 
3035
  @param session         connection handle
 
3036
  @param field_list  list of column definitions
 
3037
 
 
3038
  @return
 
3039
    0 if out of memory, Table object in case of success
 
3040
*/
 
3041
 
 
3042
Table *create_virtual_tmp_table(Session *session, List<CreateField> &field_list)
 
3043
{
 
3044
  uint32_t field_count= field_list.elements;
 
3045
  uint32_t blob_count= 0;
 
3046
  Field **field;
 
3047
  CreateField *cdef;                           /* column definition */
 
3048
  uint32_t record_length= 0;
 
3049
  uint32_t null_count= 0;                 /* number of columns which may be null */
 
3050
  uint32_t null_pack_length;              /* NULL representation array length */
 
3051
  uint32_t *blob_field;
 
3052
  unsigned char *bitmaps;
 
3053
  Table *table;
 
3054
  TableShare *share;
 
3055
 
 
3056
  if (!multi_alloc_root(session->mem_root,
 
3057
                        &table, sizeof(*table),
 
3058
                        &share, sizeof(*share),
 
3059
                        &field, (field_count + 1) * sizeof(Field*),
 
3060
                        &blob_field, (field_count+1) *sizeof(uint32_t),
 
3061
                        &bitmaps, bitmap_buffer_size(field_count)*2,
 
3062
                        NULL))
 
3063
    return NULL;
 
3064
 
 
3065
  memset(table, 0, sizeof(*table));
 
3066
  memset(share, 0, sizeof(*share));
 
3067
  table->field= field;
 
3068
  table->s= share;
 
3069
  share->blob_field= blob_field;
 
3070
  share->fields= field_count;
 
3071
  share->blob_ptr_size= portable_sizeof_char_ptr;
 
3072
  table->setup_tmp_table_column_bitmaps(bitmaps);
 
3073
 
 
3074
  /* Create all fields and calculate the total length of record */
 
3075
  List_iterator_fast<CreateField> it(field_list);
 
3076
  while ((cdef= it++))
 
3077
  {
 
3078
    *field= make_field(share,
 
3079
                       NULL,
 
3080
                       0,
 
3081
                       cdef->length,
 
3082
                       (cdef->flags & NOT_NULL_FLAG) ? false : true,
 
3083
                       (unsigned char *) ((cdef->flags & NOT_NULL_FLAG) ? 0 : ""),
 
3084
                       (cdef->flags & NOT_NULL_FLAG) ? 0 : 1,
 
3085
                       cdef->decimals,
 
3086
                       cdef->sql_type,
 
3087
                       cdef->charset,
 
3088
                       cdef->unireg_check,
 
3089
                       cdef->interval,
 
3090
                       cdef->field_name);
 
3091
    if (!*field)
 
3092
      goto error;
 
3093
    (*field)->init(table);
 
3094
    record_length+= (*field)->pack_length();
 
3095
    if (! ((*field)->flags & NOT_NULL_FLAG))
 
3096
      null_count++;
 
3097
 
 
3098
    if ((*field)->flags & BLOB_FLAG)
 
3099
      share->blob_field[blob_count++]= (uint32_t) (field - table->field);
 
3100
 
 
3101
    field++;
 
3102
  }
 
3103
  *field= NULL;                             /* mark the end of the list */
 
3104
  share->blob_field[blob_count]= 0;            /* mark the end of the list */
 
3105
  share->blob_fields= blob_count;
 
3106
 
 
3107
  null_pack_length= (null_count + 7)/8;
 
3108
  share->reclength= record_length + null_pack_length;
 
3109
  share->rec_buff_length= ALIGN_SIZE(share->reclength + 1);
 
3110
  table->record[0]= (unsigned char*) session->alloc(share->rec_buff_length);
 
3111
  if (!table->record[0])
 
3112
    goto error;
 
3113
 
 
3114
  if (null_pack_length)
 
3115
  {
 
3116
    table->null_flags= (unsigned char*) table->record[0];
 
3117
    share->null_fields= null_count;
 
3118
    share->null_bytes= null_pack_length;
 
3119
  }
 
3120
 
 
3121
  table->in_use= session;           /* field->reset() may access table->in_use */
 
3122
  {
 
3123
    /* Set up field pointers */
 
3124
    unsigned char *null_pos= table->record[0];
 
3125
    unsigned char *field_pos= null_pos + share->null_bytes;
 
3126
    uint32_t null_bit= 1;
 
3127
 
 
3128
    for (field= table->field; *field; ++field)
 
3129
    {
 
3130
      Field *cur_field= *field;
 
3131
      if ((cur_field->flags & NOT_NULL_FLAG))
 
3132
        cur_field->move_field(field_pos);
 
3133
      else
 
3134
      {
 
3135
        cur_field->move_field(field_pos, (unsigned char*) null_pos, null_bit);
 
3136
        null_bit<<= 1;
 
3137
        if (null_bit == (1 << 8))
 
3138
        {
 
3139
          ++null_pos;
 
3140
          null_bit= 1;
 
3141
        }
 
3142
      }
 
3143
      cur_field->reset();
 
3144
 
 
3145
      field_pos+= cur_field->pack_length();
 
3146
    }
 
3147
  }
 
3148
  return table;
 
3149
error:
 
3150
  for (field= table->field; *field; ++field)
 
3151
    delete *field;                         /* just invokes field destructor */
 
3152
  return 0;
 
3153
}
 
3154
 
 
3155
bool Table::open_tmp_table()
 
3156
{
 
3157
  int error;
 
3158
  if ((error=cursor->ha_open(this, s->table_name.str,O_RDWR,
 
3159
                                  HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))
 
3160
  {
 
3161
    print_error(error, MYF(0));
 
3162
    db_stat= 0;
 
3163
    return true;
 
3164
  }
 
3165
  (void) cursor->extra(HA_EXTRA_QUICK);         /* Faster */
 
3166
  return false;
 
3167
}
 
3168
 
 
3169
 
 
3170
/*
 
3171
  Create MyISAM temporary table
 
3172
 
 
3173
  SYNOPSIS
 
3174
    create_myisam_tmp_table()
 
3175
      keyinfo         Description of the index (there is always one index)
 
3176
      start_recinfo   MyISAM's column descriptions
 
3177
      recinfo INOUT   End of MyISAM's column descriptions
 
3178
      options         Option bits
 
3179
 
 
3180
  DESCRIPTION
 
3181
    Create a MyISAM temporary table according to passed description. The is
 
3182
    assumed to have one unique index or constraint.
 
3183
 
 
3184
    The passed array or MI_COLUMNDEF structures must have this form:
 
3185
 
 
3186
      1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte
 
3187
         when there are many nullable columns)
 
3188
      2. Table columns
 
3189
      3. One free MI_COLUMNDEF element (*recinfo points here)
 
3190
 
 
3191
    This function may use the free element to create hash column for unique
 
3192
    constraint.
 
3193
 
 
3194
   RETURN
 
3195
     false - OK
 
3196
     true  - Error
 
3197
*/
 
3198
 
 
3199
bool Table::create_myisam_tmp_table(KEY *keyinfo,
 
3200
                                    MI_COLUMNDEF *start_recinfo,
 
3201
                                    MI_COLUMNDEF **recinfo,
 
3202
                                    uint64_t options)
 
3203
{
 
3204
  int error;
 
3205
  MI_KEYDEF keydef;
 
3206
  MI_UNIQUEDEF uniquedef;
 
3207
  TableShare *share= s;
 
3208
 
 
3209
  if (share->keys)
 
3210
  {                                             // Get keys for ni_create
 
3211
    bool using_unique_constraint= false;
 
3212
    HA_KEYSEG *seg= (HA_KEYSEG*) alloc_root(&this->mem_root,
 
3213
                                            sizeof(*seg) * keyinfo->key_parts);
 
3214
    if (!seg)
 
3215
      goto err;
 
3216
 
 
3217
    memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
 
3218
    if (keyinfo->key_length >= cursor->getEngine()->max_key_length() ||
 
3219
        keyinfo->key_parts > cursor->getEngine()->max_key_parts() ||
 
3220
        share->uniques)
 
3221
    {
 
3222
      /* Can't create a key; Make a unique constraint instead of a key */
 
3223
      share->keys=    0;
 
3224
      share->uniques= 1;
 
3225
      using_unique_constraint= true;
 
3226
      memset(&uniquedef, 0, sizeof(uniquedef));
 
3227
      uniquedef.keysegs=keyinfo->key_parts;
 
3228
      uniquedef.seg=seg;
 
3229
      uniquedef.null_are_equal=1;
 
3230
 
 
3231
      /* Create extra column for hash value */
 
3232
      memset(*recinfo, 0, sizeof(**recinfo));
 
3233
      (*recinfo)->type= FIELD_CHECK;
 
3234
      (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
 
3235
      (*recinfo)++;
 
3236
      share->reclength+=MI_UNIQUE_HASH_LENGTH;
 
3237
    }
 
3238
    else
 
3239
    {
 
3240
      /* Create an unique key */
 
3241
      memset(&keydef, 0, sizeof(keydef));
 
3242
      keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
 
3243
      keydef.keysegs=  keyinfo->key_parts;
 
3244
      keydef.seg= seg;
 
3245
    }
 
3246
    for (uint32_t i= 0; i < keyinfo->key_parts ; i++,seg++)
 
3247
    {
 
3248
      Field *key_field=keyinfo->key_part[i].field;
 
3249
      seg->flag=     0;
 
3250
      seg->language= key_field->charset()->number;
 
3251
      seg->length=   keyinfo->key_part[i].length;
 
3252
      seg->start=    keyinfo->key_part[i].offset;
 
3253
      if (key_field->flags & BLOB_FLAG)
 
3254
      {
 
3255
        seg->type= ((keyinfo->key_part[i].key_type & 1 /* binary */) ?
 
3256
         HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);
 
3257
        seg->bit_start= (uint8_t)(key_field->pack_length()
 
3258
                                  - share->blob_ptr_size);
 
3259
        seg->flag= HA_BLOB_PART;
 
3260
        seg->length= 0;                 // Whole blob in unique constraint
 
3261
      }
 
3262
      else
 
3263
      {
 
3264
        seg->type= keyinfo->key_part[i].type;
 
3265
      }
 
3266
      if (!(key_field->flags & NOT_NULL_FLAG))
 
3267
      {
 
3268
        seg->null_bit= key_field->null_bit;
 
3269
        seg->null_pos= (uint32_t) (key_field->null_ptr - (unsigned char*) record[0]);
 
3270
        /*
 
3271
          We are using a GROUP BY on something that contains NULL
 
3272
          In this case we have to tell MyISAM that two NULL should
 
3273
          on INSERT be regarded at the same value
 
3274
        */
 
3275
        if (! using_unique_constraint)
 
3276
          keydef.flag|= HA_NULL_ARE_EQUAL;
 
3277
      }
 
3278
    }
 
3279
  }
 
3280
  MI_CREATE_INFO create_info;
 
3281
  memset(&create_info, 0, sizeof(create_info));
 
3282
 
 
3283
  if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
 
3284
      OPTION_BIG_TABLES)
 
3285
    create_info.data_file_length= ~(uint64_t) 0;
 
3286
 
 
3287
  if ((error=mi_create(share->table_name.str, share->keys, &keydef,
 
3288
                       (uint32_t) (*recinfo-start_recinfo),
 
3289
                       start_recinfo,
 
3290
                       share->uniques, &uniquedef,
 
3291
                       &create_info,
 
3292
                       HA_CREATE_TMP_TABLE)))
 
3293
  {
 
3294
    print_error(error, MYF(0));
 
3295
    db_stat= 0;
 
3296
    goto err;
 
3297
  }
 
3298
  status_var_increment(in_use->status_var.created_tmp_disk_tables);
 
3299
  share->db_record_offset= 1;
 
3300
  return false;
 
3301
 err:
 
3302
  return true;
 
3303
}
 
3304
 
 
3305
 
 
3306
void Table::free_tmp_table(Session *session)
 
3307
{
 
3308
  memory::Root own_root= mem_root;
 
3309
  const char *save_proc_info;
 
3310
 
 
3311
  save_proc_info=session->get_proc_info();
 
3312
  session->set_proc_info("removing tmp table");
 
3313
 
 
3314
  // Release latches since this can take a long time
 
3315
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
 
3316
 
 
3317
  if (cursor)
 
3318
  {
 
3319
    if (db_stat)
 
3320
      cursor->closeMarkForDelete(s->table_name.str);
 
3321
 
 
3322
    s->db_type()->doDropTable(*session, s->table_name.str);
 
3323
 
 
3324
    delete cursor;
 
3325
  }
 
3326
 
 
3327
  /* free blobs */
 
3328
  for (Field **ptr= field ; *ptr ; ptr++)
 
3329
    (*ptr)->free();
 
3330
  free_io_cache();
 
3331
 
 
3332
  free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
 
3333
  session->set_proc_info(save_proc_info);
 
3334
}
 
3335
 
 
3336
/**
 
3337
  If a HEAP table gets full, create a MyISAM table and copy all rows
 
3338
  to this.
 
3339
*/
 
3340
 
 
3341
bool create_myisam_from_heap(Session *session, Table *table,
 
3342
                             MI_COLUMNDEF *start_recinfo,
 
3343
                             MI_COLUMNDEF **recinfo,
 
3344
                             int error, bool ignore_last_dupp_key_error)
 
3345
{
 
3346
  Table new_table;
 
3347
  TableShare share;
 
3348
  const char *save_proc_info;
 
3349
  int write_err;
 
3350
 
 
3351
  if (table->s->db_type() != heap_engine ||
 
3352
      error != HA_ERR_RECORD_FILE_FULL)
 
3353
  {
 
3354
    table->print_error(error, MYF(0));
 
3355
    return true;
 
3356
  }
 
3357
 
 
3358
  // Release latches since this can take a long time
 
3359
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
 
3360
 
 
3361
  new_table= *table;
 
3362
  share= *table->s;
 
3363
  new_table.s= &share;
 
3364
  new_table.s->storage_engine= myisam_engine;
 
3365
  if (not (new_table.cursor= new_table.s->db_type()->getCursor(share, &new_table.mem_root)))
 
3366
    return true;                                // End of memory
 
3367
 
 
3368
  save_proc_info=session->get_proc_info();
 
3369
  session->set_proc_info("converting HEAP to MyISAM");
 
3370
 
 
3371
  if (new_table.create_myisam_tmp_table(table->key_info, start_recinfo,
 
3372
                                        recinfo, session->lex->select_lex.options |
 
3373
                                        session->options))
 
3374
    goto err2;
 
3375
  if (new_table.open_tmp_table())
 
3376
    goto err1;
 
3377
  if (table->cursor->indexes_are_disabled())
 
3378
    new_table.cursor->ha_disable_indexes(HA_KEY_SWITCH_ALL);
 
3379
  table->cursor->ha_index_or_rnd_end();
 
3380
  table->cursor->ha_rnd_init(1);
 
3381
  if (table->no_rows)
 
3382
  {
 
3383
    new_table.cursor->extra(HA_EXTRA_NO_ROWS);
 
3384
    new_table.no_rows=1;
 
3385
  }
 
3386
 
 
3387
  /* HA_EXTRA_WRITE_CACHE can stay until close, no need to disable it */
 
3388
  new_table.cursor->extra(HA_EXTRA_WRITE_CACHE);
 
3389
 
 
3390
  /*
 
3391
    copy all old rows from heap table to MyISAM table
 
3392
    This is the only code that uses record[1] to read/write but this
 
3393
    is safe as this is a temporary MyISAM table without timestamp/autoincrement.
 
3394
  */
 
3395
  while (!table->cursor->rnd_next(new_table.record[1]))
 
3396
  {
 
3397
    write_err= new_table.cursor->ha_write_row(new_table.record[1]);
 
3398
    if (write_err)
 
3399
      goto err;
 
3400
  }
 
3401
  /* copy row that filled HEAP table */
 
3402
  if ((write_err=new_table.cursor->ha_write_row(table->record[0])))
 
3403
  {
 
3404
    if (new_table.cursor->is_fatal_error(write_err, HA_CHECK_DUP) ||
 
3405
        !ignore_last_dupp_key_error)
 
3406
      goto err;
 
3407
  }
 
3408
 
 
3409
  /* remove heap table and change to use myisam table */
 
3410
  (void) table->cursor->ha_rnd_end();
 
3411
  (void) table->cursor->close();                  // This deletes the table !
 
3412
  delete table->cursor;
 
3413
  table->cursor= NULL;
 
3414
  new_table.s= table->s;                       // Keep old share
 
3415
  *table= new_table;
 
3416
  *table->s= share;
 
3417
 
 
3418
  table->cursor->change_table_ptr(table, table->s);
 
3419
  table->use_all_columns();
 
3420
  if (save_proc_info)
 
3421
  {
 
3422
    const char *new_proc_info=
 
3423
      (!strcmp(save_proc_info,"Copying to tmp table") ?
 
3424
      "Copying to tmp table on disk" : save_proc_info);
 
3425
    session->set_proc_info(new_proc_info);
 
3426
  }
 
3427
  return false;
 
3428
 
 
3429
 err:
 
3430
  table->print_error(write_err, MYF(0));
 
3431
  (void) table->cursor->ha_rnd_end();
 
3432
  (void) new_table.cursor->close();
 
3433
 err1:
 
3434
  new_table.s->db_type()->doDropTable(*session, new_table.s->table_name.str);
 
3435
 err2:
 
3436
  delete new_table.cursor;
 
3437
  session->set_proc_info(save_proc_info);
 
3438
  table->mem_root= new_table.mem_root;
 
3439
  return true;
 
3440
}
 
3441
 
 
3442
my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)
 
3443
{
 
3444
  my_bitmap_map *old= bitmap->getBitmap();
 
3445
  bitmap->setBitmap(s->all_set.getBitmap());
1396
3446
  return old;
1397
3447
}
1398
3448
 
1399
 
void Table::restore_column_map(const boost::dynamic_bitset<>& old)
 
3449
void Table::restore_column_map(my_bitmap_map *old)
1400
3450
{
1401
 
  for (boost::dynamic_bitset<>::size_type i= 0; i < old.size(); i++)
1402
 
  {
1403
 
    if (old.test(i))
1404
 
    {
1405
 
      read_set->set(i);
1406
 
    }
1407
 
    else
1408
 
    {
1409
 
      read_set->reset(i);
1410
 
    }
1411
 
  }
 
3451
  read_set->setBitmap(old);
1412
3452
}
1413
3453
 
1414
3454
uint32_t Table::find_shortest_key(const key_map *usable_keys)
1417
3457
  uint32_t best= MAX_KEY;
1418
3458
  if (usable_keys->any())
1419
3459
  {
1420
 
    for (uint32_t nr= 0; nr < getShare()->sizeKeys() ; nr++)
 
3460
    for (uint32_t nr= 0; nr < s->keys ; nr++)
1421
3461
    {
1422
3462
      if (usable_keys->test(nr))
1423
3463
      {
1444
3484
{
1445
3485
  for (; *ptr ; ptr++)
1446
3486
  {
1447
 
    if ((*ptr)->cmp_offset(getShare()->rec_buff_length))
 
3487
    if ((*ptr)->cmp_offset(s->rec_buff_length))
1448
3488
      return true;
1449
3489
  }
1450
3490
  return false;
1451
3491
}
1452
3492
 
1453
 
/**
1454
 
   True if the table's input and output record buffers are comparable using
1455
 
   compare_records(TABLE*).
1456
 
 */
1457
 
bool Table::records_are_comparable()
1458
 
{
1459
 
  return ((getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) == 0) ||
1460
 
          write_set->is_subset_of(*read_set));
1461
 
}
1462
 
 
1463
 
/**
1464
 
   Compares the input and outbut record buffers of the table to see if a row
1465
 
   has changed. The algorithm iterates over updated columns and if they are
1466
 
   nullable compares NULL bits in the buffer before comparing actual
1467
 
   data. Special care must be taken to compare only the relevant NULL bits and
1468
 
   mask out all others as they may be undefined. The storage engine will not
1469
 
   and should not touch them.
1470
 
 
1471
 
   @param table The table to evaluate.
1472
 
 
1473
 
   @return true if row has changed.
1474
 
   @return false otherwise.
1475
 
*/
1476
 
bool Table::compare_records()
1477
 
{
1478
 
  if (getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) != 0)
1479
 
  {
1480
 
    /*
1481
 
      Storage engine may not have read all columns of the record.  Fields
1482
 
      (including NULL bits) not in the write_set may not have been read and
1483
 
      can therefore not be compared.
1484
 
    */
1485
 
    for (Field **ptr= this->field ; *ptr != NULL; ptr++)
1486
 
    {
1487
 
      Field *f= *ptr;
1488
 
      if (write_set->test(f->position()))
1489
 
      {
1490
 
        if (f->real_maybe_null())
1491
 
        {
1492
 
          unsigned char null_byte_index= f->null_ptr - record[0];
1493
 
 
1494
 
          if (((record[0][null_byte_index]) & f->null_bit) !=
1495
 
              ((record[1][null_byte_index]) & f->null_bit))
1496
 
            return true;
1497
 
        }
1498
 
        if (f->cmp_binary_offset(getShare()->rec_buff_length))
1499
 
          return true;
1500
 
      }
1501
 
    }
1502
 
    return false;
1503
 
  }
1504
 
 
1505
 
  /*
1506
 
    The storage engine has read all columns, so it's safe to compare all bits
1507
 
    including those not in the write_set. This is cheaper than the
1508
 
    field-by-field comparison done above.
1509
 
  */
1510
 
  if (not getShare()->blob_fields + getShare()->hasVariableWidth())
1511
 
    // Fixed-size record: do bitwise comparison of the records
1512
 
    return memcmp(this->getInsertRecord(), this->getUpdateRecord(), (size_t) getShare()->getRecordLength());
1513
 
 
 
3493
/* Return false if row hasn't changed */
 
3494
 
 
3495
bool Table::compare_record()
 
3496
{
 
3497
  if (s->blob_fields + s->varchar_fields == 0)
 
3498
    return memcmp(this->record[0], this->record[1], (size_t) s->reclength);
 
3499
  
1514
3500
  /* Compare null bits */
1515
 
  if (memcmp(null_flags, null_flags + getShare()->rec_buff_length, getShare()->null_bytes))
 
3501
  if (memcmp(null_flags, null_flags + s->rec_buff_length, s->null_bytes))
1516
3502
    return true; /* Diff in NULL value */
1517
3503
 
1518
3504
  /* Compare updated fields */
1519
3505
  for (Field **ptr= field ; *ptr ; ptr++)
1520
3506
  {
1521
 
    if (isWriteSet((*ptr)->position()) &&
1522
 
        (*ptr)->cmp_binary_offset(getShare()->rec_buff_length))
 
3507
    if (isWriteSet((*ptr)->field_index) &&
 
3508
        (*ptr)->cmp_binary_offset(s->rec_buff_length))
1523
3509
      return true;
1524
3510
  }
1525
3511
  return false;
1531
3517
 */
1532
3518
void Table::storeRecord()
1533
3519
{
1534
 
  memcpy(getUpdateRecord(), getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3520
  memcpy(record[1], record[0], (size_t) s->reclength);
1535
3521
}
1536
3522
 
1537
3523
/*
1540
3526
 */
1541
3527
void Table::storeRecordAsInsert()
1542
3528
{
1543
 
  assert(insert_values.size() >= getShare()->getRecordLength());
1544
 
  memcpy(&insert_values[0], getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3529
  memcpy(insert_values, record[0], (size_t) s->reclength);
1545
3530
}
1546
3531
 
1547
3532
/*
1550
3535
 */
1551
3536
void Table::storeRecordAsDefault()
1552
3537
{
1553
 
  memcpy(getMutableShare()->getDefaultValues(), getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3538
  memcpy(s->default_values, record[0], (size_t) s->reclength);
1554
3539
}
1555
3540
 
1556
3541
/*
1559
3544
 */
1560
3545
void Table::restoreRecord()
1561
3546
{
1562
 
  memcpy(getInsertRecord(), getUpdateRecord(), (size_t) getShare()->getRecordLength());
 
3547
  memcpy(record[0], record[1], (size_t) s->reclength);
1563
3548
}
1564
3549
 
1565
3550
/*
1568
3553
 */
1569
3554
void Table::restoreRecordAsDefault()
1570
3555
{
1571
 
  memcpy(getInsertRecord(), getMutableShare()->getDefaultValues(), (size_t) getShare()->getRecordLength());
 
3556
  memcpy(record[0], s->default_values, (size_t) s->reclength);
1572
3557
}
1573
3558
 
1574
3559
/*
1578
3563
void Table::emptyRecord()
1579
3564
{
1580
3565
  restoreRecordAsDefault();
1581
 
  memset(null_flags, 255, getShare()->null_bytes);
 
3566
  memset(null_flags, 255, s->null_bytes);
1582
3567
}
1583
3568
 
1584
 
Table::Table() : 
1585
 
  field(NULL),
1586
 
  cursor(NULL),
1587
 
  next(NULL),
1588
 
  prev(NULL),
1589
 
  read_set(NULL),
1590
 
  write_set(NULL),
1591
 
  tablenr(0),
1592
 
  db_stat(0),
1593
 
  def_read_set(),
1594
 
  def_write_set(),
1595
 
  tmp_set(),
1596
 
  in_use(NULL),
1597
 
  key_info(NULL),
1598
 
  next_number_field(NULL),
1599
 
  found_next_number_field(NULL),
1600
 
  timestamp_field(NULL),
1601
 
  pos_in_table_list(NULL),
1602
 
  group(NULL),
1603
 
  null_flags(NULL),
1604
 
  lock_position(0),
1605
 
  lock_data_start(0),
1606
 
  lock_count(0),
1607
 
  used_fields(0),
1608
 
  status(0),
1609
 
  derived_select_number(0),
1610
 
  current_lock(F_UNLCK),
1611
 
  copy_blobs(false),
1612
 
  maybe_null(false),
1613
 
  null_row(false),
1614
 
  force_index(false),
1615
 
  distinct(false),
1616
 
  const_table(false),
1617
 
  no_rows(false),
1618
 
  key_read(false),
1619
 
  no_keyread(false),
1620
 
  open_placeholder(false),
1621
 
  locked_by_name(false),
1622
 
  no_cache(false),
1623
 
  auto_increment_field_not_null(false),
1624
 
  alias_name_used(false),
1625
 
  query_id(0),
1626
 
  quick_condition_rows(0),
1627
 
  timestamp_field_type(TIMESTAMP_NO_AUTO_SET),
1628
 
  map(0),
1629
 
  quick_rows(),
1630
 
  const_key_parts(),
1631
 
  quick_key_parts(),
1632
 
  quick_n_ranges()
 
3569
Table::Table()
 
3570
  : s(NULL),
 
3571
    field(NULL),
 
3572
    cursor(NULL),
 
3573
    next(NULL),
 
3574
    prev(NULL),
 
3575
    read_set(NULL),
 
3576
    write_set(NULL),
 
3577
    tablenr(0),
 
3578
    db_stat(0),
 
3579
    in_use(NULL),
 
3580
    insert_values(NULL),
 
3581
    key_info(NULL),
 
3582
    next_number_field(NULL),
 
3583
    found_next_number_field(NULL),
 
3584
    timestamp_field(NULL),
 
3585
    pos_in_table_list(NULL),
 
3586
    group(NULL),
 
3587
    alias(NULL),
 
3588
    null_flags(NULL),
 
3589
    lock_position(0),
 
3590
    lock_data_start(0),
 
3591
    lock_count(0),
 
3592
    used_fields(0),
 
3593
    status(0),
 
3594
    derived_select_number(0),
 
3595
    current_lock(F_UNLCK),
 
3596
    copy_blobs(false),
 
3597
    maybe_null(false),
 
3598
    null_row(false),
 
3599
    force_index(false),
 
3600
    distinct(false),
 
3601
    const_table(false),
 
3602
    no_rows(false),
 
3603
    key_read(false),
 
3604
    no_keyread(false),
 
3605
    open_placeholder(false),
 
3606
    locked_by_name(false),
 
3607
    no_cache(false),
 
3608
    auto_increment_field_not_null(false),
 
3609
    alias_name_used(false),
 
3610
    query_id(0),
 
3611
    quick_condition_rows(0),
 
3612
    timestamp_field_type(TIMESTAMP_NO_AUTO_SET),
 
3613
    map(0)
1633
3614
{
1634
3615
  record[0]= (unsigned char *) 0;
1635
3616
  record[1]= (unsigned char *) 0;
 
3617
 
 
3618
  covering_keys.reset();
 
3619
 
 
3620
  quick_keys.reset();
 
3621
  merge_keys.reset();
 
3622
 
 
3623
  keys_in_use_for_query.reset();
 
3624
  keys_in_use_for_group_by.reset();
 
3625
  keys_in_use_for_order_by.reset();
 
3626
 
 
3627
  memset(quick_rows, 0, sizeof(ha_rows) * MAX_KEY);
 
3628
  memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
 
3629
 
 
3630
  memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
 
3631
  memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
 
3632
 
 
3633
  memory::init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
3634
  memset(&sort, 0, sizeof(filesort_info_st));
1636
3635
}
1637
3636
 
1638
3637
/*****************************************************************************
1654
3653
    print them to the .err log
1655
3654
  */
1656
3655
  if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT)
1657
 
    errmsg_printf(error::ERROR, _("Got error %d when reading table '%s'"),
1658
 
                  error, getShare()->getPath());
 
3656
    errmsg_printf(ERRMSG_LVL_ERROR, _("Got error %d when reading table '%s'"),
 
3657
                    error, s->path.str);
1659
3658
  print_error(error, MYF(0));
1660
3659
 
1661
3660
  return 1;
1669
3668
  null_row= 0;
1670
3669
  status= STATUS_NO_RECORD;
1671
3670
  maybe_null= table_list->outer_join;
1672
 
  TableList *embedding= table_list->getEmbedding();
 
3671
  TableList *embedding= table_list->embedding;
1673
3672
  while (!maybe_null && embedding)
1674
3673
  {
1675
3674
    maybe_null= embedding->outer_join;
1676
 
    embedding= embedding->getEmbedding();
 
3675
    embedding= embedding->embedding;
1677
3676
  }
1678
3677
  tablenr= table_number;
1679
3678
  map= (table_map) 1 << table_number;
1680
3679
  force_index= table_list->force_index;
1681
 
  covering_keys= getShare()->keys_for_keyread;
 
3680
  covering_keys= s->keys_for_keyread;
1682
3681
  merge_keys.reset();
1683
3682
}
1684
3683
 
1685
3684
 
1686
 
bool Table::fill_item_list(List<Item> *item_list) const
1687
 
{
1688
 
  /*
1689
 
    All Item_field's created using a direct pointer to a field
1690
 
    are fixed in Item_field constructor.
1691
 
  */
1692
 
  for (Field **ptr= field; *ptr; ptr++)
1693
 
  {
1694
 
    Item_field *item= new Item_field(*ptr);
1695
 
    if (!item || item_list->push_back(item))
1696
 
      return true;
1697
 
  }
1698
 
  return false;
1699
 
}
1700
 
 
1701
 
 
1702
 
void Table::filesort_free_buffers(bool full)
1703
 
{
1704
 
  if (sort.record_pointers)
1705
 
  {
1706
 
    free((unsigned char*) sort.record_pointers);
1707
 
    sort.record_pointers=0;
1708
 
  }
1709
 
  if (full)
1710
 
  {
1711
 
    if (sort.sort_keys )
1712
 
    {
1713
 
      if ((unsigned char*) sort.sort_keys)
1714
 
        free((unsigned char*) sort.sort_keys);
1715
 
      sort.sort_keys= 0;
1716
 
    }
1717
 
    if (sort.buffpek)
1718
 
    {
1719
 
      if ((unsigned char*) sort.buffpek)
1720
 
        free((unsigned char*) sort.buffpek);
1721
 
      sort.buffpek= 0;
1722
 
      sort.buffpek_len= 0;
1723
 
    }
1724
 
  }
1725
 
 
1726
 
  if (sort.addon_buf)
1727
 
  {
1728
 
    free((char *) sort.addon_buf);
1729
 
    free((char *) sort.addon_field);
1730
 
    sort.addon_buf=0;
1731
 
    sort.addon_field=0;
1732
 
  }
1733
 
}
1734
 
 
1735
3685
/*
1736
 
  Is this instance of the table should be reopen or represents a name-lock?
 
3686
  Used by ALTER Table when the table is a temporary one. It changes something
 
3687
  only if the ALTER contained a RENAME clause (otherwise, table_name is the old
 
3688
  name).
 
3689
  Prepares a table cache key, which is the concatenation of db, table_name and
 
3690
  session->slave_proxy_id, separated by '\0'.
1737
3691
*/
1738
 
bool Table::needs_reopen_or_name_lock() const
1739
 
{ 
1740
 
  return getShare()->getVersion() != refresh_version;
1741
 
}
1742
 
 
1743
 
uint32_t Table::index_flags(uint32_t idx) const
1744
 
{
1745
 
  return getShare()->getEngine()->index_flags(getShare()->getKeyInfo(idx).algorithm);
1746
 
}
1747
 
 
1748
 
void Table::print_error(int error, myf errflag) const
1749
 
{
1750
 
  getShare()->getEngine()->print_error(error, errflag, *this);
 
3692
 
 
3693
bool Table::rename_temporary_table(const char *db, const char *table_name)
 
3694
{
 
3695
  char *key;
 
3696
  uint32_t key_length;
 
3697
  TableShare *share= s;
 
3698
 
 
3699
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
 
3700
    return true;
 
3701
 
 
3702
  key_length= TableShare::createKey(key, db, table_name);
 
3703
  share->set_table_cache_key(key, key_length);
 
3704
 
 
3705
  return false;
1751
3706
}
1752
3707
 
1753
3708
} /* namespace drizzled */