← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

Merge Stewarts cleanup for proto on tinyint

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"
20
 
 
21
 
#include <float.h>
22
 
#include <fcntl.h>
23
 
 
24
 
#include <string>
25
 
#include <vector>
26
 
#include <algorithm>
27
 
 
 
19
#include <drizzled/server_includes.h>
28
20
#include <drizzled/error.h>
29
21
#include <drizzled/gettext.h>
30
22
 
31
 
#include "drizzled/plugin/transactional_storage_engine.h"
32
 
#include "drizzled/plugin/authorization.h"
33
23
#include <drizzled/nested_join.h>
34
24
#include <drizzled/sql_parse.h>
35
25
#include <drizzled/item/sum.h>
42
32
#include <drizzled/field/double.h>
43
33
#include <drizzled/unireg.h>
44
34
#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"
50
35
 
51
36
#include <drizzled/item/string.h>
52
37
#include <drizzled/item/int.h>
53
38
#include <drizzled/item/decimal.h>
54
39
#include <drizzled/item/float.h>
55
40
#include <drizzled/item/null.h>
56
 
#include <drizzled/temporal.h>
57
 
 
58
 
#include <drizzled/refresh_version.h>
59
 
 
60
 
#include "drizzled/table/singular.h"
61
 
 
62
 
#include "drizzled/table_proto.h"
63
 
 
 
41
 
 
42
#include <drizzled/table_proto.h>
 
43
 
 
44
#include <string>
 
45
#include <vector>
 
46
#include <algorithm>
 
47
 
 
48
using namespace drizzled;
64
49
using namespace std;
65
 
 
66
 
namespace drizzled
67
 
{
68
 
 
69
 
extern plugin::StorageEngine *heap_engine;
70
 
extern plugin::StorageEngine *myisam_engine;
71
 
 
72
 
/* Functions defined in this cursor */
 
50
using namespace drizzled;
 
51
 
 
52
/* Functions defined in this file */
 
53
 
 
54
void open_table_error(TableShare *share, int error, int db_errno,
 
55
                      myf errortype, int errarg);
73
56
 
74
57
/*************************************************************************/
75
58
 
76
 
// @note this should all be the destructor
77
 
int Table::delete_table(bool free_share)
 
59
/* Get column name from column hash */
 
60
 
 
61
static unsigned char *get_field_name(Field **buff, size_t *length, bool)
 
62
{
 
63
  *length= (uint32_t) strlen((*buff)->field_name);
 
64
  return (unsigned char*) (*buff)->field_name;
 
65
}
 
66
 
 
67
 
 
68
/*
 
69
  Returns pointer to '.frm' extension of the file name.
 
70
 
 
71
  SYNOPSIS
 
72
    fn_rext()
 
73
    name       file name
 
74
 
 
75
  DESCRIPTION
 
76
    Checks file name part starting with the rightmost '.' character,
 
77
    and returns it if it is equal to '.dfe'.
 
78
 
 
79
  TODO
 
80
    It is a good idea to get rid of this function modifying the code
 
81
    to garantee that the functions presently calling fn_rext() always
 
82
    get arguments in the same format: either with '.frm' or without '.frm'.
 
83
 
 
84
  RETURN VALUES
 
85
    Pointer to the '.frm' extension. If there is no extension,
 
86
    or extension is not '.frm', pointer at the end of file name.
 
87
*/
 
88
 
 
89
char *fn_rext(char *name)
 
90
{
 
91
  char *res= strrchr(name, '.');
 
92
  if (res && !strcmp(res, ".dfe"))
 
93
    return res;
 
94
  return name + strlen(name);
 
95
}
 
96
 
 
97
static TABLE_CATEGORY get_table_category(const LEX_STRING *db)
 
98
{
 
99
  assert(db != NULL);
 
100
 
 
101
  if ((db->length == INFORMATION_SCHEMA_NAME.length()) &&
 
102
      (my_strcasecmp(system_charset_info,
 
103
                    INFORMATION_SCHEMA_NAME.c_str(),
 
104
                    db->str) == 0))
 
105
  {
 
106
    return TABLE_CATEGORY_INFORMATION;
 
107
  }
 
108
 
 
109
  return TABLE_CATEGORY_USER;
 
110
}
 
111
 
 
112
 
 
113
/*
 
114
  Allocate a setup TableShare structure
 
115
 
 
116
  SYNOPSIS
 
117
    alloc_table_share()
 
118
    TableList           Take database and table name from there
 
119
    key                 Table cache key (db \0 table_name \0...)
 
120
    key_length          Length of key
 
121
 
 
122
  RETURN
 
123
    0  Error (out of memory)
 
124
    #  Share
 
125
*/
 
126
 
 
127
TableShare *alloc_table_share(TableList *table_list, char *key,
 
128
                               uint32_t key_length)
 
129
{
 
130
  MEM_ROOT mem_root;
 
131
  TableShare *share;
 
132
  char *key_buff, *path_buff;
 
133
  char path[FN_REFLEN];
 
134
  uint32_t path_length;
 
135
 
 
136
  path_length= build_table_filename(path, sizeof(path) - 1,
 
137
                                    table_list->db,
 
138
                                    table_list->table_name, false);
 
139
  init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
140
  if (multi_alloc_root(&mem_root,
 
141
                       &share, sizeof(*share),
 
142
                       &key_buff, key_length,
 
143
                       &path_buff, path_length + 1,
 
144
                       NULL))
 
145
  {
 
146
    memset(share, 0, sizeof(*share));
 
147
 
 
148
    share->set_table_cache_key(key_buff, key, key_length);
 
149
 
 
150
    share->path.str= path_buff;
 
151
    share->path.length= path_length;
 
152
    strcpy(share->path.str, path);
 
153
    share->normalized_path.str=    share->path.str;
 
154
    share->normalized_path.length= path_length;
 
155
 
 
156
    share->version=       refresh_version;
 
157
 
 
158
    memcpy(&share->mem_root, &mem_root, sizeof(mem_root));
 
159
    pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
 
160
    pthread_cond_init(&share->cond, NULL);
 
161
  }
 
162
  return(share);
 
163
}
 
164
 
 
165
 
 
166
static enum_field_types proto_field_type_to_drizzle_type(uint32_t proto_field_type)
 
167
{
 
168
  enum_field_types field_type;
 
169
 
 
170
  switch(proto_field_type)
 
171
  {
 
172
  case message::Table::Field::INTEGER:
 
173
    field_type= DRIZZLE_TYPE_LONG;
 
174
    break;
 
175
  case message::Table::Field::DOUBLE:
 
176
    field_type= DRIZZLE_TYPE_DOUBLE;
 
177
    break;
 
178
  case message::Table::Field::TIMESTAMP:
 
179
    field_type= DRIZZLE_TYPE_TIMESTAMP;
 
180
    break;
 
181
  case message::Table::Field::BIGINT:
 
182
    field_type= DRIZZLE_TYPE_LONGLONG;
 
183
    break;
 
184
  case message::Table::Field::DATETIME:
 
185
    field_type= DRIZZLE_TYPE_DATETIME;
 
186
    break;
 
187
  case message::Table::Field::DATE:
 
188
    field_type= DRIZZLE_TYPE_DATE;
 
189
    break;
 
190
  case message::Table::Field::VARCHAR:
 
191
    field_type= DRIZZLE_TYPE_VARCHAR;
 
192
    break;
 
193
  case message::Table::Field::DECIMAL:
 
194
    field_type= DRIZZLE_TYPE_NEWDECIMAL;
 
195
    break;
 
196
  case message::Table::Field::ENUM:
 
197
    field_type= DRIZZLE_TYPE_ENUM;
 
198
    break;
 
199
  case message::Table::Field::BLOB:
 
200
    field_type= DRIZZLE_TYPE_BLOB;
 
201
    break;
 
202
  default:
 
203
    field_type= DRIZZLE_TYPE_TINY; /* Set value to kill GCC warning */
 
204
    assert(1);
 
205
  }
 
206
 
 
207
  return field_type;
 
208
}
 
209
 
 
210
static Item *default_value_item(enum_field_types field_type,
 
211
                                const CHARSET_INFO *charset,
 
212
                                bool default_null, const string *default_value,
 
213
                                const string *default_bin_value)
 
214
{
 
215
  Item *default_item= NULL;
 
216
  int error= 0;
 
217
 
 
218
  if (default_null)
 
219
  {
 
220
    return new Item_null();
 
221
  }
 
222
 
 
223
  switch(field_type)
 
224
  {
 
225
  case DRIZZLE_TYPE_TINY:
 
226
  case DRIZZLE_TYPE_LONG:
 
227
  case DRIZZLE_TYPE_LONGLONG:
 
228
    default_item= new Item_int(default_value->c_str(),
 
229
                               (int64_t) my_strtoll10(default_value->c_str(),
 
230
                                                      NULL,
 
231
                                                      &error),
 
232
                               default_value->length());
 
233
    break;
 
234
  case DRIZZLE_TYPE_DOUBLE:
 
235
    default_item= new Item_float(default_value->c_str(),
 
236
                                 default_value->length());
 
237
    break;
 
238
  case DRIZZLE_TYPE_NULL:
 
239
    assert(false);
 
240
  case DRIZZLE_TYPE_TIMESTAMP:
 
241
  case DRIZZLE_TYPE_DATETIME:
 
242
  case DRIZZLE_TYPE_DATE:
 
243
    if (default_value->compare("NOW()") == 0)
 
244
      break;
 
245
  case DRIZZLE_TYPE_ENUM:
 
246
    default_item= new Item_string(default_value->c_str(),
 
247
                                  default_value->length(),
 
248
                                  system_charset_info);
 
249
    break;
 
250
  case DRIZZLE_TYPE_VARCHAR:
 
251
  case DRIZZLE_TYPE_BLOB: /* Blob is here due to TINYTEXT. Feel the hate. */
 
252
    if (charset==&my_charset_bin)
 
253
    {
 
254
      default_item= new Item_string(default_bin_value->c_str(),
 
255
                                    default_bin_value->length(),
 
256
                                    &my_charset_bin);
 
257
    }
 
258
    else
 
259
    {
 
260
      default_item= new Item_string(default_value->c_str(),
 
261
                                    default_value->length(),
 
262
                                    system_charset_info);
 
263
    }
 
264
    break;
 
265
  case DRIZZLE_TYPE_NEWDECIMAL:
 
266
    default_item= new Item_decimal(default_value->c_str(),
 
267
                                   default_value->length(),
 
268
                                   system_charset_info);
 
269
    break;
 
270
  }
 
271
 
 
272
  return default_item;
 
273
}
 
274
 
 
275
int parse_table_proto(Session *session,
 
276
                      message::Table &table,
 
277
                      TableShare *share)
 
278
{
 
279
  int error= 0;
 
280
  handler *handler_file= NULL;
 
281
 
 
282
  share->setTableProto(new(nothrow) message::Table(table));
 
283
 
 
284
  share->storage_engine= ha_resolve_by_name(session, table.engine().name());
 
285
 
 
286
  message::Table::TableOptions table_options;
 
287
 
 
288
  if (table.has_options())
 
289
    table_options= table.options();
 
290
 
 
291
  uint32_t db_create_options= 0;
 
292
 
 
293
  if (table_options.has_pack_keys())
 
294
  {
 
295
    if (table_options.pack_keys())
 
296
      db_create_options|= HA_OPTION_PACK_KEYS;
 
297
    else
 
298
      db_create_options|= HA_OPTION_NO_PACK_KEYS;
 
299
  }
 
300
 
 
301
  if (table_options.pack_record())
 
302
    db_create_options|= HA_OPTION_PACK_RECORD;
 
303
 
 
304
  /* db_create_options was stored as 2 bytes in FRM
 
305
     Any HA_OPTION_ that doesn't fit into 2 bytes was silently truncated away.
 
306
   */
 
307
  share->db_create_options= (db_create_options & 0x0000FFFF);
 
308
  share->db_options_in_use= share->db_create_options;
 
309
 
 
310
  share->row_type= table_options.has_row_type() ?
 
311
    (enum row_type) table_options.row_type() : ROW_TYPE_DEFAULT;
 
312
 
 
313
  share->block_size= table_options.has_block_size() ?
 
314
    table_options.block_size() : 0;
 
315
 
 
316
  share->table_charset= get_charset(table_options.has_collation_id()?
 
317
                                    table_options.collation_id() : 0);
 
318
 
 
319
  if (!share->table_charset)
 
320
  {
 
321
    /* unknown charset in head[38] or pre-3.23 frm */
 
322
    if (use_mb(default_charset_info))
 
323
    {
 
324
      /* Warn that we may be changing the size of character columns */
 
325
      errmsg_printf(ERRMSG_LVL_WARN,
 
326
                    _("'%s' had no or invalid character set, "
 
327
                      "and default character set is multi-byte, "
 
328
                      "so character column sizes may have changed"),
 
329
                    share->path.str);
 
330
    }
 
331
    share->table_charset= default_charset_info;
 
332
  }
 
333
 
 
334
  share->db_record_offset= 1;
 
335
 
 
336
  share->blob_ptr_size= portable_sizeof_char_ptr; // more bonghits.
 
337
 
 
338
  share->db_low_byte_first= true;
 
339
 
 
340
  share->keys= table.indexes_size();
 
341
 
 
342
  share->key_parts= 0;
 
343
  for (int indx= 0; indx < table.indexes_size(); indx++)
 
344
    share->key_parts+= table.indexes(indx).index_part_size();
 
345
 
 
346
  share->key_info= (KEY*) alloc_root(&share->mem_root,
 
347
                                     table.indexes_size() * sizeof(KEY)
 
348
                                     +share->key_parts*sizeof(KEY_PART_INFO));
 
349
 
 
350
  KEY_PART_INFO *key_part;
 
351
 
 
352
  key_part= reinterpret_cast<KEY_PART_INFO*>
 
353
    (share->key_info+table.indexes_size());
 
354
 
 
355
 
 
356
  ulong *rec_per_key= (ulong*) alloc_root(&share->mem_root,
 
357
                                            sizeof(ulong*)*share->key_parts);
 
358
 
 
359
  share->keynames.count= table.indexes_size();
 
360
  share->keynames.name= NULL;
 
361
  share->keynames.type_names= (const char**)
 
362
    alloc_root(&share->mem_root, sizeof(char*) * (table.indexes_size()+1));
 
363
 
 
364
  share->keynames.type_lengths= (unsigned int*)
 
365
    alloc_root(&share->mem_root,
 
366
               sizeof(unsigned int) * (table.indexes_size()+1));
 
367
 
 
368
  share->keynames.type_names[share->keynames.count]= NULL;
 
369
  share->keynames.type_lengths[share->keynames.count]= 0;
 
370
 
 
371
  KEY* keyinfo= share->key_info;
 
372
  for (int keynr= 0; keynr < table.indexes_size(); keynr++, keyinfo++)
 
373
  {
 
374
    message::Table::Index indx= table.indexes(keynr);
 
375
 
 
376
    keyinfo->table= 0;
 
377
    keyinfo->flags= 0;
 
378
 
 
379
    if (indx.is_unique())
 
380
      keyinfo->flags|= HA_NOSAME;
 
381
 
 
382
    if (indx.has_options())
 
383
    {
 
384
      message::Table::Index::IndexOptions indx_options= indx.options();
 
385
      if (indx_options.pack_key())
 
386
        keyinfo->flags|= HA_PACK_KEY;
 
387
 
 
388
      if (indx_options.var_length_key())
 
389
        keyinfo->flags|= HA_VAR_LENGTH_PART;
 
390
 
 
391
      if (indx_options.null_part_key())
 
392
        keyinfo->flags|= HA_NULL_PART_KEY;
 
393
 
 
394
      if (indx_options.binary_pack_key())
 
395
        keyinfo->flags|= HA_BINARY_PACK_KEY;
 
396
 
 
397
      if (indx_options.has_partial_segments())
 
398
        keyinfo->flags|= HA_KEY_HAS_PART_KEY_SEG;
 
399
 
 
400
      if (indx_options.auto_generated_key())
 
401
        keyinfo->flags|= HA_GENERATED_KEY;
 
402
 
 
403
      if (indx_options.has_key_block_size())
 
404
      {
 
405
        keyinfo->flags|= HA_USES_BLOCK_SIZE;
 
406
        keyinfo->block_size= indx_options.key_block_size();
 
407
      }
 
408
      else
 
409
      {
 
410
        keyinfo->block_size= 0;
 
411
      }
 
412
    }
 
413
 
 
414
    switch (indx.type())
 
415
    {
 
416
    case message::Table::Index::UNKNOWN_INDEX:
 
417
      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
 
418
      break;
 
419
    case message::Table::Index::BTREE:
 
420
      keyinfo->algorithm= HA_KEY_ALG_BTREE;
 
421
      break;
 
422
    case message::Table::Index::RTREE:
 
423
      keyinfo->algorithm= HA_KEY_ALG_RTREE;
 
424
      break;
 
425
    case message::Table::Index::HASH:
 
426
      keyinfo->algorithm= HA_KEY_ALG_HASH;
 
427
      break;
 
428
    case message::Table::Index::FULLTEXT:
 
429
      keyinfo->algorithm= HA_KEY_ALG_FULLTEXT;
 
430
 
 
431
    default:
 
432
      /* TODO: suitable warning ? */
 
433
      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
 
434
      break;
 
435
    }
 
436
 
 
437
    keyinfo->key_length= indx.key_length();
 
438
 
 
439
    keyinfo->key_parts= indx.index_part_size();
 
440
 
 
441
    keyinfo->key_part= key_part;
 
442
    keyinfo->rec_per_key= rec_per_key;
 
443
 
 
444
    for (unsigned int partnr= 0;
 
445
         partnr < keyinfo->key_parts;
 
446
         partnr++, key_part++)
 
447
    {
 
448
      message::Table::Index::IndexPart part;
 
449
      part= indx.index_part(partnr);
 
450
 
 
451
      *rec_per_key++= 0;
 
452
 
 
453
      key_part->field= NULL;
 
454
      key_part->fieldnr= part.fieldnr() + 1; // start from 1.
 
455
      key_part->null_bit= 0;
 
456
      /* key_part->null_offset is only set if null_bit (see later) */
 
457
      /* key_part->key_type= */ /* I *THINK* this may be okay.... */
 
458
      /* key_part->type ???? */
 
459
      key_part->key_part_flag= 0;
 
460
      if (part.has_in_reverse_order())
 
461
        key_part->key_part_flag= part.in_reverse_order()? HA_REVERSE_SORT : 0;
 
462
 
 
463
      key_part->length= part.compare_length();
 
464
 
 
465
      key_part->store_length= key_part->length;
 
466
 
 
467
      /* key_part->offset is set later */
 
468
      key_part->key_type= part.key_type();
 
469
    }
 
470
 
 
471
    if (! indx.has_comment())
 
472
    {
 
473
      keyinfo->comment.length= 0;
 
474
      keyinfo->comment.str= NULL;
 
475
    }
 
476
    else
 
477
    {
 
478
      keyinfo->flags|= HA_USES_COMMENT;
 
479
      keyinfo->comment.length= indx.comment().length();
 
480
      keyinfo->comment.str= strmake_root(&share->mem_root,
 
481
                                         indx.comment().c_str(),
 
482
                                         keyinfo->comment.length);
 
483
    }
 
484
 
 
485
    keyinfo->name= strmake_root(&share->mem_root,
 
486
                                indx.name().c_str(),
 
487
                                indx.name().length());
 
488
 
 
489
    share->keynames.type_names[keynr]= keyinfo->name;
 
490
    share->keynames.type_lengths[keynr]= indx.name().length();
 
491
  }
 
492
 
 
493
  share->keys_for_keyread.reset();
 
494
  set_prefix(share->keys_in_use, share->keys);
 
495
 
 
496
  share->key_block_size= table_options.has_key_block_size() ?
 
497
    table_options.key_block_size() : 0;
 
498
 
 
499
  share->fields= table.field_size();
 
500
 
 
501
  share->field= (Field**) alloc_root(&share->mem_root,
 
502
                                     ((share->fields+1) * sizeof(Field*)));
 
503
  share->field[share->fields]= NULL;
 
504
 
 
505
  uint32_t null_fields= 0;
 
506
  share->reclength= 0;
 
507
 
 
508
  uint32_t *field_offsets= (uint32_t*)malloc(share->fields * sizeof(uint32_t));
 
509
  uint32_t *field_pack_length=(uint32_t*)malloc(share->fields*sizeof(uint32_t));
 
510
 
 
511
  assert(field_offsets && field_pack_length); // TODO: fixme
 
512
 
 
513
  uint32_t interval_count= 0;
 
514
  uint32_t interval_parts= 0;
 
515
 
 
516
  uint32_t stored_columns_reclength= 0;
 
517
 
 
518
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
 
519
  {
 
520
    message::Table::Field pfield= table.field(fieldnr);
 
521
    if (pfield.has_constraints() && pfield.constraints().is_nullable())
 
522
      null_fields++;
 
523
 
 
524
    enum_field_types drizzle_field_type=
 
525
      proto_field_type_to_drizzle_type(pfield.type());
 
526
 
 
527
    field_offsets[fieldnr]= stored_columns_reclength;
 
528
 
 
529
    /* the below switch is very similar to
 
530
       CreateField::create_length_to_internal_length in field.cc
 
531
       (which should one day be replace by just this code)
 
532
    */
 
533
    switch(drizzle_field_type)
 
534
    {
 
535
    case DRIZZLE_TYPE_BLOB:
 
536
    case DRIZZLE_TYPE_VARCHAR:
 
537
      {
 
538
        message::Table::Field::StringFieldOptions field_options= pfield.string_options();
 
539
 
 
540
        const CHARSET_INFO *cs= get_charset(field_options.has_collation_id() ?
 
541
                                            field_options.collation_id() : 0);
 
542
 
 
543
        if (! cs)
 
544
          cs= default_charset_info;
 
545
 
 
546
        field_pack_length[fieldnr]= calc_pack_length(drizzle_field_type,
 
547
                                                     field_options.length() * cs->mbmaxlen);
 
548
      }
 
549
      break;
 
550
    case DRIZZLE_TYPE_ENUM:
 
551
      {
 
552
        message::Table::Field::SetFieldOptions field_options= pfield.set_options();
 
553
 
 
554
        field_pack_length[fieldnr]=
 
555
          get_enum_pack_length(field_options.field_value_size());
 
556
 
 
557
        interval_count++;
 
558
        interval_parts+= field_options.field_value_size();
 
559
      }
 
560
      break;
 
561
    case DRIZZLE_TYPE_NEWDECIMAL:
 
562
      {
 
563
        message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
564
 
 
565
        field_pack_length[fieldnr]= my_decimal_get_binary_size(fo.precision(), fo.scale());
 
566
      }
 
567
      break;
 
568
    default:
 
569
      /* Zero is okay here as length is fixed for other types. */
 
570
      field_pack_length[fieldnr]= calc_pack_length(drizzle_field_type, 0);
 
571
    }
 
572
 
 
573
    share->reclength+= field_pack_length[fieldnr];
 
574
    stored_columns_reclength+= field_pack_length[fieldnr];
 
575
  }
 
576
 
 
577
  /* data_offset added to stored_rec_length later */
 
578
  share->stored_rec_length= stored_columns_reclength;
 
579
 
 
580
  share->null_fields= null_fields;
 
581
 
 
582
  ulong null_bits= null_fields;
 
583
  if (! table_options.pack_record())
 
584
    null_bits++;
 
585
  ulong data_offset= (null_bits + 7)/8;
 
586
 
 
587
 
 
588
  share->reclength+= data_offset;
 
589
  share->stored_rec_length+= data_offset;
 
590
 
 
591
  ulong rec_buff_length;
 
592
 
 
593
  rec_buff_length= ALIGN_SIZE(share->reclength + 1);
 
594
  share->rec_buff_length= rec_buff_length;
 
595
 
 
596
  unsigned char* record= NULL;
 
597
 
 
598
  if (! (record= (unsigned char *) alloc_root(&share->mem_root,
 
599
                                              rec_buff_length)))
 
600
    abort();
 
601
 
 
602
  memset(record, 0, rec_buff_length);
 
603
 
 
604
  int null_count= 0;
 
605
 
 
606
  if (! table_options.pack_record())
 
607
  {
 
608
    null_count++; // one bit for delete mark.
 
609
    *record|= 1;
 
610
  }
 
611
 
 
612
  share->default_values= record;
 
613
 
 
614
  if (interval_count)
 
615
  {
 
616
    share->intervals= (TYPELIB *) alloc_root(&share->mem_root,
 
617
                                           interval_count*sizeof(TYPELIB));
 
618
  }
 
619
  else
 
620
    share->intervals= NULL;
 
621
 
 
622
  share->fieldnames.type_names= (const char **) alloc_root(&share->mem_root,
 
623
                                                          (share->fields + 1) * sizeof(char*));
 
624
 
 
625
  share->fieldnames.type_lengths= (unsigned int *) alloc_root(&share->mem_root,
 
626
                                                             (share->fields + 1) * sizeof(unsigned int));
 
627
 
 
628
  share->fieldnames.type_names[share->fields]= NULL;
 
629
  share->fieldnames.type_lengths[share->fields]= 0;
 
630
  share->fieldnames.count= share->fields;
 
631
 
 
632
 
 
633
  /* Now fix the TYPELIBs for the intervals (enum values)
 
634
     and field names.
 
635
   */
 
636
 
 
637
  uint32_t interval_nr= 0;
 
638
 
 
639
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
 
640
  {
 
641
    message::Table::Field pfield= table.field(fieldnr);
 
642
 
 
643
    /* field names */
 
644
    share->fieldnames.type_names[fieldnr]= strmake_root(&share->mem_root,
 
645
                                                        pfield.name().c_str(),
 
646
                                                        pfield.name().length());
 
647
 
 
648
    share->fieldnames.type_lengths[fieldnr]= pfield.name().length();
 
649
 
 
650
    /* enum typelibs */
 
651
    if (pfield.type() != message::Table::Field::ENUM)
 
652
      continue;
 
653
 
 
654
    message::Table::Field::SetFieldOptions field_options= pfield.set_options();
 
655
 
 
656
    const CHARSET_INFO *charset= get_charset(field_options.has_collation_id() ?
 
657
                                             field_options.collation_id() : 0);
 
658
 
 
659
    if (! charset)
 
660
      charset= default_charset_info;
 
661
 
 
662
    TYPELIB *t= &(share->intervals[interval_nr]);
 
663
 
 
664
    t->type_names= (const char**)alloc_root(&share->mem_root,
 
665
                                            (field_options.field_value_size() + 1) * sizeof(char*));
 
666
 
 
667
    t->type_lengths= (unsigned int*) alloc_root(&share->mem_root,
 
668
                                                (field_options.field_value_size() + 1) * sizeof(unsigned int));
 
669
 
 
670
    t->type_names[field_options.field_value_size()]= NULL;
 
671
    t->type_lengths[field_options.field_value_size()]= 0;
 
672
 
 
673
    t->count= field_options.field_value_size();
 
674
    t->name= NULL;
 
675
 
 
676
    for (int n= 0; n < field_options.field_value_size(); n++)
 
677
    {
 
678
      t->type_names[n]= strmake_root(&share->mem_root,
 
679
                                     field_options.field_value(n).c_str(),
 
680
                                     field_options.field_value(n).length());
 
681
 
 
682
      /* 
 
683
       * Go ask the charset what the length is as for "" length=1
 
684
       * and there's stripping spaces or some other crack going on.
 
685
       */
 
686
      uint32_t lengthsp;
 
687
      lengthsp= charset->cset->lengthsp(charset,
 
688
                                        t->type_names[n],
 
689
                                        field_options.field_value(n).length());
 
690
      t->type_lengths[n]= lengthsp;
 
691
    }
 
692
    interval_nr++;
 
693
  }
 
694
 
 
695
 
 
696
  /* and read the fields */
 
697
  interval_nr= 0;
 
698
 
 
699
  bool use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
 
700
 
 
701
  if (use_hash)
 
702
    use_hash= ! hash_init(&share->name_hash,
 
703
                          system_charset_info,
 
704
                          share->fields,
 
705
                          0,
 
706
                          0,
 
707
                          (hash_get_key) get_field_name,
 
708
                          0,
 
709
                          0);
 
710
 
 
711
  unsigned char* null_pos= record;;
 
712
  int null_bit_pos= (table_options.pack_record()) ? 0 : 1;
 
713
 
 
714
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
 
715
  {
 
716
    message::Table::Field pfield= table.field(fieldnr);
 
717
 
 
718
    enum column_format_type column_format= COLUMN_FORMAT_TYPE_DEFAULT;
 
719
 
 
720
    switch (pfield.format())
 
721
    {
 
722
    case message::Table::Field::DefaultFormat:
 
723
      column_format= COLUMN_FORMAT_TYPE_DEFAULT;
 
724
      break;
 
725
    case message::Table::Field::FixedFormat:
 
726
      column_format= COLUMN_FORMAT_TYPE_FIXED;
 
727
      break;
 
728
    case message::Table::Field::DynamicFormat:
 
729
      column_format= COLUMN_FORMAT_TYPE_DYNAMIC;
 
730
      break;
 
731
    default:
 
732
      assert(1);
 
733
    }
 
734
 
 
735
    Field::utype unireg_type= Field::NONE;
 
736
 
 
737
    if (pfield.has_numeric_options() &&
 
738
        pfield.numeric_options().is_autoincrement())
 
739
    {
 
740
      unireg_type= Field::NEXT_NUMBER;
 
741
    }
 
742
 
 
743
    if (pfield.has_options() &&
 
744
        pfield.options().has_default_value() &&
 
745
        pfield.options().default_value().compare("NOW()") == 0)
 
746
    {
 
747
      if (pfield.options().has_update_value() &&
 
748
          pfield.options().update_value().compare("NOW()") == 0)
 
749
      {
 
750
        unireg_type= Field::TIMESTAMP_DNUN_FIELD;
 
751
      }
 
752
      else if (! pfield.options().has_update_value())
 
753
      {
 
754
        unireg_type= Field::TIMESTAMP_DN_FIELD;
 
755
      }
 
756
      else
 
757
        assert(1); // Invalid update value.
 
758
    }
 
759
    else if (pfield.has_options() &&
 
760
             pfield.options().has_update_value() &&
 
761
             pfield.options().update_value().compare("NOW()") == 0)
 
762
    {
 
763
      unireg_type= Field::TIMESTAMP_UN_FIELD;
 
764
    }
 
765
 
 
766
    LEX_STRING comment;
 
767
    if (!pfield.has_comment())
 
768
    {
 
769
      comment.str= (char*)"";
 
770
      comment.length= 0;
 
771
    }
 
772
    else
 
773
    {
 
774
      size_t len= pfield.comment().length();
 
775
      const char* str= pfield.comment().c_str();
 
776
 
 
777
      comment.str= strmake_root(&share->mem_root, str, len);
 
778
      comment.length= len;
 
779
    }
 
780
 
 
781
    enum_field_types field_type;
 
782
 
 
783
    field_type= proto_field_type_to_drizzle_type(pfield.type());
 
784
 
 
785
    const CHARSET_INFO *charset= &my_charset_bin;
 
786
 
 
787
    if (field_type == DRIZZLE_TYPE_BLOB ||
 
788
        field_type == DRIZZLE_TYPE_VARCHAR)
 
789
    {
 
790
      message::Table::Field::StringFieldOptions field_options= pfield.string_options();
 
791
 
 
792
      charset= get_charset(field_options.has_collation_id() ?
 
793
                           field_options.collation_id() : 0);
 
794
 
 
795
      if (! charset)
 
796
        charset= default_charset_info;
 
797
    }
 
798
 
 
799
    if (field_type == DRIZZLE_TYPE_ENUM)
 
800
    {
 
801
      message::Table::Field::SetFieldOptions field_options= pfield.set_options();
 
802
 
 
803
      charset= get_charset(field_options.has_collation_id()?
 
804
                           field_options.collation_id() : 0);
 
805
 
 
806
      if (! charset)
 
807
              charset= default_charset_info;
 
808
    }
 
809
 
 
810
    uint8_t decimals= 0;
 
811
    if (field_type == DRIZZLE_TYPE_NEWDECIMAL
 
812
        || field_type == DRIZZLE_TYPE_DOUBLE)
 
813
    {
 
814
      message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
815
 
 
816
      if (! pfield.has_numeric_options() || ! fo.has_scale())
 
817
      {
 
818
        /*
 
819
          We don't write the default to table proto so
 
820
          if no decimals specified for DOUBLE, we use the default.
 
821
        */
 
822
        decimals= NOT_FIXED_DEC;
 
823
      }
 
824
      else
 
825
      {
 
826
        if (fo.scale() > DECIMAL_MAX_SCALE)
 
827
        {
 
828
          error= 4;
 
829
          goto err;
 
830
        }
 
831
        decimals= static_cast<uint8_t>(fo.scale());
 
832
      }
 
833
    }
 
834
 
 
835
    Item *default_value= NULL;
 
836
 
 
837
    if (pfield.options().has_default_value() ||
 
838
        pfield.options().has_default_null()  ||
 
839
        pfield.options().has_default_bin_value())
 
840
    {
 
841
      default_value= default_value_item(field_type,
 
842
                                        charset,
 
843
                                        pfield.options().default_null(),
 
844
                                        &pfield.options().default_value(),
 
845
                                        &pfield.options().default_bin_value());
 
846
    }
 
847
 
 
848
 
 
849
    Table temp_table; /* Use this so that BLOB DEFAULT '' works */
 
850
    memset(&temp_table, 0, sizeof(temp_table));
 
851
    temp_table.s= share;
 
852
    temp_table.in_use= session;
 
853
    temp_table.s->db_low_byte_first= 1; //handler->low_byte_first();
 
854
    temp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
 
855
 
 
856
    Field* f= make_field(share,
 
857
                         &share->mem_root,
 
858
                         record + field_offsets[fieldnr] + data_offset,
 
859
                         pfield.options().length(),
 
860
                         pfield.has_constraints() && pfield.constraints().is_nullable() ? true : false,
 
861
                         null_pos,
 
862
                         null_bit_pos,
 
863
                         decimals,
 
864
                         field_type,
 
865
                         charset,
 
866
                         (Field::utype) MTYP_TYPENR(unireg_type),
 
867
                         ((field_type == DRIZZLE_TYPE_ENUM) ?
 
868
                          share->intervals + (interval_nr++)
 
869
                          : (TYPELIB*) 0),
 
870
                         share->fieldnames.type_names[fieldnr]);
 
871
 
 
872
    share->field[fieldnr]= f;
 
873
 
 
874
    f->init(&temp_table); /* blob default values need table obj */
 
875
 
 
876
    if (! (f->flags & NOT_NULL_FLAG))
 
877
    {
 
878
      *f->null_ptr|= f->null_bit;
 
879
      if (! (null_bit_pos= (null_bit_pos + 1) & 7)) /* @TODO Ugh. */
 
880
        null_pos++;
 
881
      null_count++;
 
882
    }
 
883
 
 
884
    if (default_value)
 
885
    {
 
886
      enum_check_fields old_count_cuted_fields= session->count_cuted_fields;
 
887
      session->count_cuted_fields= CHECK_FIELD_WARN;
 
888
      int res= default_value->save_in_field(f, 1);
 
889
      session->count_cuted_fields= old_count_cuted_fields;
 
890
      if (res != 0 && res != 3) /* @TODO Huh? */
 
891
      {
 
892
        my_error(ER_INVALID_DEFAULT, MYF(0), f->field_name);
 
893
        error= 1;
 
894
        goto err;
 
895
      }
 
896
    }
 
897
    else if (f->real_type() == DRIZZLE_TYPE_ENUM &&
 
898
             (f->flags & NOT_NULL_FLAG))
 
899
    {
 
900
      f->set_notnull();
 
901
      f->store((int64_t) 1, true);
 
902
    }
 
903
    else
 
904
      f->reset();
 
905
 
 
906
    /* hack to undo f->init() */
 
907
    f->table= NULL;
 
908
    f->orig_table= NULL;
 
909
 
 
910
    f->field_index= fieldnr;
 
911
    f->comment= comment;
 
912
    if (! default_value &&
 
913
        ! (f->unireg_check==Field::NEXT_NUMBER) &&
 
914
        (f->flags & NOT_NULL_FLAG) &&
 
915
        (f->real_type() != DRIZZLE_TYPE_TIMESTAMP))
 
916
    {
 
917
      f->flags|= NO_DEFAULT_VALUE_FLAG;
 
918
    }
 
919
 
 
920
    if (f->unireg_check == Field::NEXT_NUMBER)
 
921
      share->found_next_number_field= &(share->field[fieldnr]);
 
922
 
 
923
    if (share->timestamp_field == f)
 
924
      share->timestamp_field_offset= fieldnr;
 
925
 
 
926
    if (use_hash) /* supposedly this never fails... but comments lie */
 
927
      (void) my_hash_insert(&share->name_hash,
 
928
                            (unsigned char*)&(share->field[fieldnr]));
 
929
 
 
930
  }
 
931
 
 
932
  keyinfo= share->key_info;
 
933
  for (unsigned int keynr= 0; keynr < share->keys; keynr++, keyinfo++)
 
934
  {
 
935
    key_part= keyinfo->key_part;
 
936
 
 
937
    for (unsigned int partnr= 0;
 
938
         partnr < keyinfo->key_parts;
 
939
         partnr++, key_part++)
 
940
    {
 
941
      /* 
 
942
       * Fix up key_part->offset by adding data_offset.
 
943
       * We really should compute offset as well.
 
944
       * But at least this way we are a little better.
 
945
       */
 
946
      key_part->offset= field_offsets[key_part->fieldnr-1] + data_offset;
 
947
    }
 
948
  }
 
949
 
 
950
  /*
 
951
    We need to set the unused bits to 1. If the number of bits is a multiple
 
952
    of 8 there are no unused bits.
 
953
  */
 
954
 
 
955
  if (null_count & 7)
 
956
    *(record + null_count / 8)|= ~(((unsigned char) 1 << (null_count & 7)) - 1);
 
957
 
 
958
  share->null_bytes= (null_pos - (unsigned char*) record + (null_bit_pos + 7) / 8);
 
959
 
 
960
  share->last_null_bit_pos= null_bit_pos;
 
961
 
 
962
  free(field_offsets);
 
963
  free(field_pack_length);
 
964
 
 
965
  if (! (handler_file= get_new_handler(share,
 
966
                                       session->mem_root,
 
967
                                       share->db_type())))
 
968
    abort(); // FIXME
 
969
 
 
970
  /* Fix key stuff */
 
971
  if (share->key_parts)
 
972
  {
 
973
    uint32_t primary_key= (uint32_t) (find_type((char*) "PRIMARY",
 
974
                                                &share->keynames, 3) - 1); /* @TODO Huh? */
 
975
 
 
976
    int64_t ha_option= handler_file->ha_table_flags();
 
977
 
 
978
    keyinfo= share->key_info;
 
979
    key_part= keyinfo->key_part;
 
980
 
 
981
    for (uint32_t key= 0; key < share->keys; key++,keyinfo++)
 
982
    {
 
983
      uint32_t usable_parts= 0;
 
984
 
 
985
      if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
 
986
      {
 
987
        /*
 
988
          If the UNIQUE key doesn't have NULL columns and is not a part key
 
989
          declare this as a primary key.
 
990
        */
 
991
        primary_key=key;
 
992
        for (uint32_t i= 0; i < keyinfo->key_parts; i++)
 
993
        {
 
994
          uint32_t fieldnr= key_part[i].fieldnr;
 
995
          if (! fieldnr ||
 
996
              share->field[fieldnr-1]->null_ptr ||
 
997
              share->field[fieldnr-1]->key_length() != key_part[i].length)
 
998
          {
 
999
            primary_key= MAX_KEY; // Can't be used
 
1000
            break;
 
1001
          }
 
1002
        }
 
1003
      }
 
1004
 
 
1005
      for (uint32_t i= 0 ; i < keyinfo->key_parts ; key_part++,i++)
 
1006
      {
 
1007
        Field *field;
 
1008
        if (! key_part->fieldnr)
 
1009
        {
 
1010
          abort(); // goto err;
 
1011
        }
 
1012
        field= key_part->field= share->field[key_part->fieldnr-1];
 
1013
        key_part->type= field->key_type();
 
1014
        if (field->null_ptr)
 
1015
        {
 
1016
          key_part->null_offset=(uint32_t) ((unsigned char*) field->null_ptr -
 
1017
                                        share->default_values);
 
1018
          key_part->null_bit= field->null_bit;
 
1019
          key_part->store_length+=HA_KEY_NULL_LENGTH;
 
1020
          keyinfo->flags|=HA_NULL_PART_KEY;
 
1021
          keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
 
1022
          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
 
1023
        }
 
1024
        if (field->type() == DRIZZLE_TYPE_BLOB ||
 
1025
            field->real_type() == DRIZZLE_TYPE_VARCHAR)
 
1026
        {
 
1027
          if (field->type() == DRIZZLE_TYPE_BLOB)
 
1028
            key_part->key_part_flag|= HA_BLOB_PART;
 
1029
          else
 
1030
            key_part->key_part_flag|= HA_VAR_LENGTH_PART;
 
1031
          keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
 
1032
          key_part->store_length+=HA_KEY_BLOB_LENGTH;
 
1033
          keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
 
1034
        }
 
1035
        if (i == 0 && key != primary_key)
 
1036
          field->flags |= (((keyinfo->flags & HA_NOSAME) &&
 
1037
                           (keyinfo->key_parts == 1)) ?
 
1038
                           UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
 
1039
        if (i == 0)
 
1040
          field->key_start.set(key);
 
1041
        if (field->key_length() == key_part->length &&
 
1042
            !(field->flags & BLOB_FLAG))
 
1043
        {
 
1044
          if (handler_file->index_flags(key, i, 0) & HA_KEYREAD_ONLY)
 
1045
          {
 
1046
            share->keys_for_keyread.set(key);
 
1047
            field->part_of_key.set(key);
 
1048
            field->part_of_key_not_clustered.set(key);
 
1049
          }
 
1050
          if (handler_file->index_flags(key, i, 1) & HA_READ_ORDER)
 
1051
            field->part_of_sortkey.set(key);
 
1052
        }
 
1053
        if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
 
1054
            usable_parts == i)
 
1055
          usable_parts++;                       // For FILESORT
 
1056
        field->flags|= PART_KEY_FLAG;
 
1057
        if (key == primary_key)
 
1058
        {
 
1059
          field->flags|= PRI_KEY_FLAG;
 
1060
          /*
 
1061
            If this field is part of the primary key and all keys contains
 
1062
            the primary key, then we can use any key to find this column
 
1063
          */
 
1064
          if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
 
1065
          {
 
1066
            field->part_of_key= share->keys_in_use;
 
1067
            if (field->part_of_sortkey.test(key))
 
1068
              field->part_of_sortkey= share->keys_in_use;
 
1069
          }
 
1070
        }
 
1071
        if (field->key_length() != key_part->length)
 
1072
        {
 
1073
          key_part->key_part_flag|= HA_PART_KEY_SEG;
 
1074
        }
 
1075
      }
 
1076
      keyinfo->usable_key_parts= usable_parts; // Filesort
 
1077
 
 
1078
      set_if_bigger(share->max_key_length,keyinfo->key_length+
 
1079
                    keyinfo->key_parts);
 
1080
      share->total_key_length+= keyinfo->key_length;
 
1081
      /*
 
1082
        MERGE tables do not have unique indexes. But every key could be
 
1083
        an unique index on the underlying MyISAM table. (Bug #10400)
 
1084
      */
 
1085
      if ((keyinfo->flags & HA_NOSAME) ||
 
1086
          (ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
 
1087
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
 
1088
    }
 
1089
    if (primary_key < MAX_KEY &&
 
1090
        (share->keys_in_use.test(primary_key)))
 
1091
    {
 
1092
      share->primary_key= primary_key;
 
1093
      /*
 
1094
        If we are using an integer as the primary key then allow the user to
 
1095
        refer to it as '_rowid'
 
1096
      */
 
1097
      if (share->key_info[primary_key].key_parts == 1)
 
1098
      {
 
1099
        Field *field= share->key_info[primary_key].key_part[0].field;
 
1100
        if (field && field->result_type() == INT_RESULT)
 
1101
        {
 
1102
          /* note that fieldnr here (and rowid_field_offset) starts from 1 */
 
1103
          share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
 
1104
                                      fieldnr);
 
1105
        }
 
1106
      }
 
1107
    }
 
1108
    else
 
1109
      share->primary_key = MAX_KEY; // we do not have a primary key
 
1110
  }
 
1111
  else
 
1112
    share->primary_key= MAX_KEY;
 
1113
 
 
1114
  if (share->found_next_number_field)
 
1115
  {
 
1116
    Field *reg_field= *share->found_next_number_field;
 
1117
    if ((int) (share->next_number_index= (uint32_t)
 
1118
               find_ref_key(share->key_info, share->keys,
 
1119
                            share->default_values, reg_field,
 
1120
                            &share->next_number_key_offset,
 
1121
                            &share->next_number_keypart)) < 0)
 
1122
    {
 
1123
      /* Wrong field definition */
 
1124
      error= 4;
 
1125
      goto err;
 
1126
    }
 
1127
    else
 
1128
      reg_field->flags |= AUTO_INCREMENT_FLAG;
 
1129
  }
 
1130
 
 
1131
  if (share->blob_fields)
 
1132
  {
 
1133
    Field **ptr;
 
1134
    uint32_t k, *save;
 
1135
 
 
1136
    /* Store offsets to blob fields to find them fast */
 
1137
    if (!(share->blob_field= save=
 
1138
          (uint*) alloc_root(&share->mem_root,
 
1139
                             (uint32_t) (share->blob_fields* sizeof(uint32_t)))))
 
1140
      goto err;
 
1141
    for (k= 0, ptr= share->field ; *ptr ; ptr++, k++)
 
1142
    {
 
1143
      if ((*ptr)->flags & BLOB_FLAG)
 
1144
        (*save++)= k;
 
1145
    }
 
1146
  }
 
1147
 
 
1148
  share->db_low_byte_first= handler_file->low_byte_first();
 
1149
  share->column_bitmap_size= bitmap_buffer_size(share->fields);
 
1150
 
 
1151
  my_bitmap_map *bitmaps;
 
1152
 
 
1153
  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
 
1154
                                             share->column_bitmap_size)))
 
1155
    goto err;
 
1156
  share->all_set.init(bitmaps, share->fields);
 
1157
  share->all_set.setAll();
 
1158
 
 
1159
  if (handler_file)
 
1160
    delete handler_file;
 
1161
  return (0);
 
1162
 
 
1163
err:
 
1164
  share->error= error;
 
1165
  share->open_errno= my_errno;
 
1166
  share->errarg= 0;
 
1167
  hash_free(&share->name_hash);
 
1168
  if (handler_file)
 
1169
    delete handler_file;
 
1170
  share->open_table_error(error, share->open_errno, 0);
 
1171
 
 
1172
  return error;
 
1173
}
 
1174
 
 
1175
/*
 
1176
  Read table definition from a binary / text based .frm file
 
1177
 
 
1178
  SYNOPSIS
 
1179
  open_table_def()
 
1180
  session               Thread handler
 
1181
  share         Fill this with table definition
 
1182
 
 
1183
  NOTES
 
1184
    This function is called when the table definition is not cached in
 
1185
    table_def_cache
 
1186
    The data is returned in 'share', which is alloced by
 
1187
    alloc_table_share().. The code assumes that share is initialized.
 
1188
 
 
1189
  RETURN VALUES
 
1190
   0    ok
 
1191
   1    Error (see open_table_error)
 
1192
   2    Error (see open_table_error)
 
1193
   3    Wrong data in .frm file
 
1194
   4    Error (see open_table_error)
 
1195
   5    Error (see open_table_error: charset unavailable)
 
1196
   6    Unknown .frm version
 
1197
*/
 
1198
 
 
1199
int open_table_def(Session *session, TableShare *share)
 
1200
{
 
1201
  int error;
 
1202
  bool error_given;
 
1203
 
 
1204
  error= 1;
 
1205
  error_given= 0;
 
1206
 
 
1207
  message::Table table;
 
1208
 
 
1209
  error= StorageEngine::getTableProto(share->normalized_path.str, &table);
 
1210
 
 
1211
  if (error != EEXIST)
 
1212
  {
 
1213
    if (error>0)
 
1214
    {
 
1215
      my_errno= error;
 
1216
      error= 1;
 
1217
    }
 
1218
    else
 
1219
    {
 
1220
      if (!table.IsInitialized())
 
1221
      {
 
1222
        error= 4;
 
1223
      }
 
1224
    }
 
1225
    goto err_not_open;
 
1226
  }
 
1227
 
 
1228
  error= parse_table_proto(session, table, share);
 
1229
 
 
1230
  share->table_category= get_table_category(& share->db);
 
1231
 
 
1232
  if (!error)
 
1233
    session->status_var.opened_shares++;
 
1234
 
 
1235
err_not_open:
 
1236
  if (error && !error_given)
 
1237
  {
 
1238
    share->error= error;
 
1239
    share->open_table_error(error, (share->open_errno= my_errno), 0);
 
1240
  }
 
1241
 
 
1242
  return(error);
 
1243
}
 
1244
 
 
1245
 
 
1246
/*
 
1247
  Open a table based on a TableShare
 
1248
 
 
1249
  SYNOPSIS
 
1250
    open_table_from_share()
 
1251
    session                     Thread handler
 
1252
    share               Table definition
 
1253
    alias               Alias for table
 
1254
    db_stat             open flags (for example HA_OPEN_KEYFILE|
 
1255
                        HA_OPEN_RNDFILE..) can be 0 (example in
 
1256
                        ha_example_table)
 
1257
    prgflag             READ_ALL etc..
 
1258
    ha_open_flags       HA_OPEN_ABORT_IF_LOCKED etc..
 
1259
    outparam            result table
 
1260
    open_mode           One of OTM_OPEN|OTM_CREATE|OTM_ALTER
 
1261
                        if OTM_CREATE some errors are ignore
 
1262
                        if OTM_ALTER HA_OPEN is not called
 
1263
 
 
1264
  RETURN VALUES
 
1265
   0    ok
 
1266
   1    Error (see open_table_error)
 
1267
   2    Error (see open_table_error)
 
1268
   3    Wrong data in .frm file
 
1269
   4    Error (see open_table_error)
 
1270
   5    Error (see open_table_error: charset unavailable)
 
1271
   7    Table definition has changed in engine
 
1272
*/
 
1273
 
 
1274
int open_table_from_share(Session *session, TableShare *share, const char *alias,
 
1275
                          uint32_t db_stat, uint32_t prgflag, uint32_t ha_open_flags,
 
1276
                          Table *outparam, open_table_mode open_mode)
 
1277
{
 
1278
  int error;
 
1279
  uint32_t records, i, bitmap_size;
 
1280
  bool error_reported= false;
 
1281
  unsigned char *record, *bitmaps;
 
1282
  Field **field_ptr;
 
1283
 
 
1284
  /* Parsing of partitioning information from .frm needs session->lex set up. */
 
1285
  assert(session->lex->is_lex_started);
 
1286
 
 
1287
  error= 1;
 
1288
  outparam->resetTable(session, share, db_stat);
 
1289
 
 
1290
 
 
1291
  if (!(outparam->alias= strdup(alias)))
 
1292
    goto err;
 
1293
 
 
1294
  /* Allocate handler */
 
1295
  if (!(prgflag & OPEN_FRM_FILE_ONLY))
 
1296
  {
 
1297
    if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
 
1298
                                          share->db_type())))
 
1299
      goto err;
 
1300
  }
 
1301
  else
 
1302
  {
 
1303
    assert(!db_stat);
 
1304
  }
 
1305
 
 
1306
  error= 4;
 
1307
  records= 0;
 
1308
  if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN))
 
1309
    records=1;
 
1310
  if (prgflag & (READ_ALL+EXTRA_RECORD))
 
1311
    records++;
 
1312
 
 
1313
  if (!(record= (unsigned char*) alloc_root(&outparam->mem_root,
 
1314
                                   share->rec_buff_length * records)))
 
1315
    goto err;
 
1316
 
 
1317
  if (records == 0)
 
1318
  {
 
1319
    /* We are probably in hard repair, and the buffers should not be used */
 
1320
    outparam->record[0]= outparam->record[1]= share->default_values;
 
1321
  }
 
1322
  else
 
1323
  {
 
1324
    outparam->record[0]= record;
 
1325
    if (records > 1)
 
1326
      outparam->record[1]= record+ share->rec_buff_length;
 
1327
    else
 
1328
      outparam->record[1]= outparam->record[0];   // Safety
 
1329
  }
 
1330
 
 
1331
#ifdef HAVE_purify
 
1332
  /*
 
1333
    We need this because when we read var-length rows, we are not updating
 
1334
    bytes after end of varchar
 
1335
  */
 
1336
  if (records > 1)
 
1337
  {
 
1338
    memcpy(outparam->record[0], share->default_values, share->rec_buff_length);
 
1339
    memcpy(outparam->record[1], share->default_values, share->null_bytes);
 
1340
    if (records > 2)
 
1341
      memcpy(outparam->record[1], share->default_values,
 
1342
             share->rec_buff_length);
 
1343
  }
 
1344
#endif
 
1345
 
 
1346
  if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
 
1347
                                          (uint32_t) ((share->fields+1)*
 
1348
                                                  sizeof(Field*)))))
 
1349
    goto err;
 
1350
 
 
1351
  outparam->field= field_ptr;
 
1352
 
 
1353
  record= (unsigned char*) outparam->record[0]-1;       /* Fieldstart = 1 */
 
1354
 
 
1355
  outparam->null_flags= (unsigned char*) record+1;
 
1356
 
 
1357
  /* Setup copy of fields from share, but use the right alias and record */
 
1358
  for (i= 0 ; i < share->fields; i++, field_ptr++)
 
1359
  {
 
1360
    if (!((*field_ptr)= share->field[i]->clone(&outparam->mem_root, outparam)))
 
1361
      goto err;
 
1362
  }
 
1363
  (*field_ptr)= 0;                              // End marker
 
1364
 
 
1365
  if (share->found_next_number_field)
 
1366
    outparam->found_next_number_field=
 
1367
      outparam->field[(uint32_t) (share->found_next_number_field - share->field)];
 
1368
  if (share->timestamp_field)
 
1369
    outparam->timestamp_field= (Field_timestamp*) outparam->field[share->timestamp_field_offset];
 
1370
 
 
1371
 
 
1372
  /* Fix key->name and key_part->field */
 
1373
  if (share->key_parts)
 
1374
  {
 
1375
    KEY *key_info, *key_info_end;
 
1376
    KEY_PART_INFO *key_part;
 
1377
    uint32_t n_length;
 
1378
    n_length= share->keys*sizeof(KEY) + share->key_parts*sizeof(KEY_PART_INFO);
 
1379
    if (!(key_info= (KEY*) alloc_root(&outparam->mem_root, n_length)))
 
1380
      goto err;
 
1381
    outparam->key_info= key_info;
 
1382
    key_part= (reinterpret_cast<KEY_PART_INFO*> (key_info+share->keys));
 
1383
 
 
1384
    memcpy(key_info, share->key_info, sizeof(*key_info)*share->keys);
 
1385
    memcpy(key_part, share->key_info[0].key_part, (sizeof(*key_part) *
 
1386
                                                   share->key_parts));
 
1387
 
 
1388
    for (key_info_end= key_info + share->keys ;
 
1389
         key_info < key_info_end ;
 
1390
         key_info++)
 
1391
    {
 
1392
      KEY_PART_INFO *key_part_end;
 
1393
 
 
1394
      key_info->table= outparam;
 
1395
      key_info->key_part= key_part;
 
1396
 
 
1397
      for (key_part_end= key_part+ key_info->key_parts ;
 
1398
           key_part < key_part_end ;
 
1399
           key_part++)
 
1400
      {
 
1401
        Field *field= key_part->field= outparam->field[key_part->fieldnr-1];
 
1402
 
 
1403
        if (field->key_length() != key_part->length &&
 
1404
            !(field->flags & BLOB_FLAG))
 
1405
        {
 
1406
          /*
 
1407
            We are using only a prefix of the column as a key:
 
1408
            Create a new field for the key part that matches the index
 
1409
          */
 
1410
          field= key_part->field=field->new_field(&outparam->mem_root,
 
1411
                                                  outparam, 0);
 
1412
          field->field_length= key_part->length;
 
1413
        }
 
1414
      }
 
1415
    }
 
1416
  }
 
1417
 
 
1418
  /* Allocate bitmaps */
 
1419
 
 
1420
  bitmap_size= share->column_bitmap_size;
 
1421
  if (!(bitmaps= (unsigned char*) alloc_root(&outparam->mem_root, bitmap_size*3)))
 
1422
    goto err;
 
1423
  outparam->def_read_set.init((my_bitmap_map*) bitmaps, share->fields);
 
1424
  outparam->def_write_set.init((my_bitmap_map*) (bitmaps+bitmap_size), share->fields);
 
1425
  outparam->tmp_set.init((my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields);
 
1426
  outparam->default_column_bitmaps();
 
1427
 
 
1428
  /* The table struct is now initialized;  Open the table */
 
1429
  error= 2;
 
1430
  if (db_stat && open_mode != OTM_ALTER)
 
1431
  {
 
1432
    int ha_err;
 
1433
    if ((ha_err= (outparam->file->
 
1434
                  ha_open(outparam, share->normalized_path.str,
 
1435
                          (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
 
1436
                          (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
 
1437
                           (db_stat & HA_WAIT_IF_LOCKED) ?  HA_OPEN_WAIT_IF_LOCKED :
 
1438
                           (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
 
1439
                          HA_OPEN_ABORT_IF_LOCKED :
 
1440
                           HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
 
1441
    {
 
1442
      /* Set a flag if the table is crashed and it can be auto. repaired */
 
1443
      share->crashed= ((ha_err == HA_ERR_CRASHED_ON_USAGE) &&
 
1444
                       outparam->file->auto_repair() &&
 
1445
                       !(ha_open_flags & HA_OPEN_FOR_REPAIR));
 
1446
 
 
1447
      switch (ha_err)
 
1448
      {
 
1449
        case HA_ERR_NO_SUCH_TABLE:
 
1450
          /*
 
1451
            The table did not exists in storage engine, use same error message
 
1452
            as if the .frm file didn't exist
 
1453
          */
 
1454
          error= 1;
 
1455
          my_errno= ENOENT;
 
1456
          break;
 
1457
        case EMFILE:
 
1458
          /*
 
1459
            Too many files opened, use same error message as if the .frm
 
1460
            file can't open
 
1461
           */
 
1462
          error= 1;
 
1463
          my_errno= EMFILE;
 
1464
          break;
 
1465
        default:
 
1466
          outparam->file->print_error(ha_err, MYF(0));
 
1467
          error_reported= true;
 
1468
          if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
 
1469
            error= 7;
 
1470
          break;
 
1471
      }
 
1472
      goto err;
 
1473
    }
 
1474
  }
 
1475
 
 
1476
#if defined(HAVE_purify)
 
1477
  memset(bitmaps, 0, bitmap_size*3);
 
1478
#endif
 
1479
 
 
1480
  session->status_var.opened_tables++;
 
1481
 
 
1482
  return (0);
 
1483
 
 
1484
 err:
 
1485
  if (!error_reported && !(prgflag & DONT_GIVE_ERROR))
 
1486
    share->open_table_error(error, my_errno, 0);
 
1487
  delete outparam->file;
 
1488
  outparam->file= 0;                            // For easier error checking
 
1489
  outparam->db_stat= 0;
 
1490
  free_root(&outparam->mem_root, MYF(0));       // Safe to call on zeroed root
 
1491
  free((char*) outparam->alias);
 
1492
  return (error);
 
1493
}
 
1494
 
 
1495
/*
 
1496
  Free information allocated by openfrm
 
1497
 
 
1498
  SYNOPSIS
 
1499
    closefrm()
 
1500
    table               Table object to free
 
1501
    free_share          Is 1 if we also want to free table_share
 
1502
*/
 
1503
 
 
1504
int Table::closefrm(bool free_share)
78
1505
{
79
1506
  int error= 0;
80
1507
 
81
1508
  if (db_stat)
82
 
    error= cursor->close();
83
 
  _alias.clear();
84
 
 
 
1509
    error= file->close();
 
1510
  free((char*) alias);
 
1511
  alias= NULL;
85
1512
  if (field)
86
1513
  {
87
1514
    for (Field **ptr=field ; *ptr ; ptr++)
88
 
    {
89
1515
      delete *ptr;
90
 
    }
91
1516
    field= 0;
92
1517
  }
93
 
  delete cursor;
94
 
  cursor= 0;                            /* For easier errorchecking */
95
 
 
 
1518
  delete file;
 
1519
  file= 0;                              /* For easier errorchecking */
96
1520
  if (free_share)
97
1521
  {
98
 
    release();
 
1522
    if (s->tmp_table == NO_TMP_TABLE)
 
1523
      TableShare::release(s);
 
1524
    else
 
1525
      s->free_table_share();
99
1526
  }
 
1527
  free_root(&mem_root, MYF(0));
100
1528
 
101
1529
  return error;
102
1530
}
103
1531
 
104
 
Table::~Table()
105
 
{
106
 
  mem_root.free_root(MYF(0));
107
 
}
108
 
 
109
 
 
110
 
void Table::resetTable(Session *session,
111
 
                       TableShare *share,
112
 
                       uint32_t db_stat_arg)
113
 
{
114
 
  setShare(share);
115
 
  in_use= session;
116
 
 
117
 
  field= NULL;
118
 
 
119
 
  cursor= NULL;
120
 
  next= NULL;
121
 
  prev= NULL;
122
 
 
123
 
  read_set= NULL;
124
 
  write_set= NULL;
125
 
 
126
 
  tablenr= 0;
127
 
  db_stat= db_stat_arg;
128
 
 
129
 
  record[0]= (unsigned char *) NULL;
130
 
  record[1]= (unsigned char *) NULL;
131
 
 
132
 
  insert_values.clear();
133
 
  key_info= NULL;
134
 
  next_number_field= NULL;
135
 
  found_next_number_field= NULL;
136
 
  timestamp_field= NULL;
137
 
 
138
 
  pos_in_table_list= NULL;
139
 
  group= NULL;
140
 
  _alias.clear();
141
 
  null_flags= NULL;
142
 
 
143
 
  lock_position= 0;
144
 
  lock_data_start= 0;
145
 
  lock_count= 0;
146
 
  used_fields= 0;
147
 
  status= 0;
148
 
  derived_select_number= 0;
149
 
  current_lock= F_UNLCK;
150
 
  copy_blobs= false;
151
 
 
152
 
  maybe_null= false;
153
 
 
154
 
  null_row= false;
155
 
 
156
 
  force_index= false;
157
 
  distinct= false;
158
 
  const_table= false;
159
 
  no_rows= false;
160
 
  key_read= false;
161
 
  no_keyread= false;
162
 
 
163
 
  open_placeholder= false;
164
 
  locked_by_name= false;
165
 
  no_cache= false;
166
 
 
167
 
  auto_increment_field_not_null= false;
168
 
  alias_name_used= false;
169
 
 
170
 
  query_id= 0;
171
 
  quick_condition_rows= 0;
172
 
 
173
 
  timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
174
 
  map= 0;
175
 
 
176
 
  reginfo.reset();
177
 
 
178
 
  covering_keys.reset();
179
 
 
180
 
  quick_keys.reset();
181
 
  merge_keys.reset();
182
 
 
183
 
  keys_in_use_for_query.reset();
184
 
  keys_in_use_for_group_by.reset();
185
 
  keys_in_use_for_order_by.reset();
186
 
 
187
 
  memset(quick_rows, 0, sizeof(ha_rows) * MAX_KEY);
188
 
  memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
189
 
 
190
 
  memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
191
 
  memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
192
 
 
193
 
  memory::init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
194
 
}
195
 
 
196
 
 
197
1532
 
198
1533
/* Deallocate temporary blob storage */
199
1534
 
203
1538
  for (ptr= table->getBlobField(), end=ptr + table->sizeBlobFields();
204
1539
       ptr != end ;
205
1540
       ptr++)
206
 
  {
207
 
    ((Field_blob*) table->getField(*ptr))->free();
208
 
  }
 
1541
    ((Field_blob*) table->field[*ptr])->free();
209
1542
}
210
1543
 
211
1544
 
212
 
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings)
213
 
{
214
 
  TYPELIB *result= (TYPELIB*) mem_root->alloc_root(sizeof(TYPELIB));
 
1545
        /* error message when opening a form file */
 
1546
 
 
1547
void TableShare::open_table_error(int pass_error, int db_errno, int pass_errarg)
 
1548
{
 
1549
  int err_no;
 
1550
  char buff[FN_REFLEN];
 
1551
  myf errortype= ME_ERROR+ME_WAITTANG;
 
1552
 
 
1553
  switch (pass_error) {
 
1554
  case 7:
 
1555
  case 1:
 
1556
    if (db_errno == ENOENT)
 
1557
      my_error(ER_NO_SUCH_TABLE, MYF(0), db.str, table_name.str);
 
1558
    else
 
1559
    {
 
1560
      sprintf(buff,"%s",normalized_path.str);
 
1561
      my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
 
1562
               errortype, buff, db_errno);
 
1563
    }
 
1564
    break;
 
1565
  case 2:
 
1566
  {
 
1567
    handler *file= 0;
 
1568
    const char *datext= "";
 
1569
 
 
1570
    if (db_type() != NULL)
 
1571
    {
 
1572
      if ((file= get_new_handler(this, current_session->mem_root,
 
1573
                                 db_type())))
 
1574
      {
 
1575
        if (!(datext= *db_type()->bas_ext()))
 
1576
          datext= "";
 
1577
      }
 
1578
    }
 
1579
    err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
 
1580
      ER_FILE_USED : ER_CANT_OPEN_FILE;
 
1581
    sprintf(buff,"%s%s", normalized_path.str,datext);
 
1582
    my_error(err_no,errortype, buff, db_errno);
 
1583
    delete file;
 
1584
    break;
 
1585
  }
 
1586
  case 5:
 
1587
  {
 
1588
    const char *csname= get_charset_name((uint32_t) pass_errarg);
 
1589
    char tmp[10];
 
1590
    if (!csname || csname[0] =='?')
 
1591
    {
 
1592
      snprintf(tmp, sizeof(tmp), "#%d", pass_errarg);
 
1593
      csname= tmp;
 
1594
    }
 
1595
    my_printf_error(ER_UNKNOWN_COLLATION,
 
1596
                    _("Unknown collation '%s' in table '%-.64s' definition"),
 
1597
                    MYF(0), csname, table_name.str);
 
1598
    break;
 
1599
  }
 
1600
  case 6:
 
1601
    sprintf(buff,"%s", normalized_path.str);
 
1602
    my_printf_error(ER_NOT_FORM_FILE,
 
1603
                    _("Table '%-.64s' was created with a different version "
 
1604
                    "of Drizzle and cannot be read"),
 
1605
                    MYF(0), buff);
 
1606
    break;
 
1607
  case 8:
 
1608
    break;
 
1609
  default:                              /* Better wrong error than none */
 
1610
  case 4:
 
1611
    sprintf(buff,"%s", normalized_path.str);
 
1612
    my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
 
1613
    break;
 
1614
  }
 
1615
  return;
 
1616
} /* open_table_error */
 
1617
 
 
1618
 
 
1619
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings)
 
1620
{
 
1621
  TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
215
1622
  if (!result)
216
1623
    return 0;
217
1624
  result->count= strings.elements;
218
1625
  result->name= "";
219
1626
  uint32_t nbytes= (sizeof(char*) + sizeof(uint32_t)) * (result->count + 1);
220
1627
  
221
 
  if (!(result->type_names= (const char**) mem_root->alloc_root(nbytes)))
 
1628
  if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
222
1629
    return 0;
223
1630
    
224
1631
  result->type_lengths= (uint*) (result->type_names + result->count + 1);
248
1655
  return (nr);
249
1656
} /* set_zone */
250
1657
 
 
1658
        /* Adjust number to next larger disk buffer */
 
1659
 
 
1660
ulong next_io_size(register ulong pos)
 
1661
{
 
1662
  register ulong offset;
 
1663
  if ((offset= pos & (IO_SIZE-1)))
 
1664
    return pos-offset+IO_SIZE;
 
1665
  return pos;
 
1666
} /* next_io_size */
 
1667
 
251
1668
 
252
1669
/*
253
1670
  Store an SQL quoted string.
275
1692
        (mblen= my_ismbchar(default_charset_info, pos, end)))
276
1693
    {
277
1694
      res->append(pos, mblen);
278
 
      pos+= mblen - 1;
 
1695
      pos+= mblen;
279
1696
      if (pos >= end)
280
1697
        break;
281
1698
      continue;
311
1728
}
312
1729
 
313
1730
 
 
1731
/*
 
1732
  Set up column usage bitmaps for a temporary table
 
1733
 
 
1734
  IMPLEMENTATION
 
1735
    For temporary tables, we need one bitmap with all columns set and
 
1736
    a tmp_set bitmap to be used by things like filesort.
 
1737
*/
 
1738
 
 
1739
void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)
 
1740
{
 
1741
  uint32_t field_count= s->fields;
 
1742
 
 
1743
  this->def_read_set.init((my_bitmap_map*) bitmaps, field_count);
 
1744
  this->tmp_set.init((my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);
 
1745
 
 
1746
  /* write_set and all_set are copies of read_set */
 
1747
  def_write_set= def_read_set;
 
1748
  s->all_set= def_read_set;
 
1749
  this->s->all_set.setAll();
 
1750
  default_column_bitmaps();
 
1751
}
 
1752
 
 
1753
 
 
1754
 
 
1755
void Table::updateCreateInfo(HA_CREATE_INFO *create_info,
 
1756
                             message::Table *table_proto)
 
1757
{
 
1758
  message::Table::TableOptions *table_options= table_proto->mutable_options();
 
1759
  create_info->table_options= s->db_create_options;
 
1760
  table_options->set_block_size(s->block_size);
 
1761
  create_info->row_type= s->row_type;
 
1762
  create_info->default_table_charset= s->table_charset;
 
1763
  create_info->table_charset= 0;
 
1764
  table_options->set_comment(s->getComment());
 
1765
}
 
1766
 
314
1767
int rename_file_ext(const char * from,const char * to,const char * ext)
315
1768
{
316
1769
  string from_s, to_s;
319
1772
  from_s.append(ext);
320
1773
  to_s.append(to);
321
1774
  to_s.append(ext);
322
 
  return (internal::my_rename(from_s.c_str(),to_s.c_str(),MYF(MY_WME)));
 
1775
  return (my_rename(from_s.c_str(),to_s.c_str(),MYF(MY_WME)));
 
1776
}
 
1777
 
 
1778
/*
 
1779
  DESCRIPTION
 
1780
    given a buffer with a key value, and a map of keyparts
 
1781
    that are present in this value, returns the length of the value
 
1782
*/
 
1783
uint32_t calculate_key_len(Table *table, uint32_t key,
 
1784
                       const unsigned char *,
 
1785
                       key_part_map keypart_map)
 
1786
{
 
1787
  /* works only with key prefixes */
 
1788
  assert(((keypart_map + 1) & keypart_map) == 0);
 
1789
 
 
1790
  KEY *key_info= table->s->key_info+key;
 
1791
  KEY_PART_INFO *key_part= key_info->key_part;
 
1792
  KEY_PART_INFO *end_key_part= key_part + key_info->key_parts;
 
1793
  uint32_t length= 0;
 
1794
 
 
1795
  while (key_part < end_key_part && keypart_map)
 
1796
  {
 
1797
    length+= key_part->store_length;
 
1798
    keypart_map >>= 1;
 
1799
    key_part++;
 
1800
  }
 
1801
  return length;
323
1802
}
324
1803
 
325
1804
/*
330
1809
    org_name            Name of database and length
331
1810
 
332
1811
  RETURN
333
 
    false error
334
 
    true ok
 
1812
    0   ok
 
1813
    1   error
335
1814
*/
336
1815
 
337
 
bool check_db_name(Session *session, identifier::Schema &schema_identifier)
 
1816
bool check_db_name(LEX_STRING *org_name)
338
1817
{
339
 
  if (not plugin::Authorization::isAuthorized(session->user(), schema_identifier))
340
 
  {
341
 
    return false;
342
 
  }
343
 
 
344
 
  return schema_identifier.isValid();
 
1818
  char *name= org_name->str;
 
1819
  uint32_t name_length= org_name->length;
 
1820
 
 
1821
  if (!name_length || name_length > NAME_LEN || name[name_length - 1] == ' ')
 
1822
    return 1;
 
1823
 
 
1824
  if (name != any_db)
 
1825
    my_casedn_str(files_charset_info, name);
 
1826
 
 
1827
  return check_identifier_name(org_name);
345
1828
}
346
1829
 
 
1830
 
347
1831
/*
348
1832
  Allow anything as a table name, as long as it doesn't contain an
349
1833
  ' ' at the end
414
1898
    bitmap_clear_all(&table->def_read_set);
415
1899
    bitmap_clear_all(&table->def_write_set);
416
1900
  */
417
 
  def_read_set.reset();
418
 
  def_write_set.reset();
419
 
  column_bitmaps_set(def_read_set, def_write_set);
 
1901
  def_read_set.clearAll();
 
1902
  def_write_set.clearAll();
 
1903
  column_bitmaps_set(&def_read_set, &def_write_set);
420
1904
}
421
1905
 
422
1906
 
423
1907
/*
424
 
  Tell Cursor we are going to call position() and rnd_pos() later.
 
1908
  Tell handler we are going to call position() and rnd_pos() later.
425
1909
 
426
1910
  NOTES:
427
1911
  This is needed for handlers that uses the primary key to find the
432
1916
void Table::prepare_for_position()
433
1917
{
434
1918
 
435
 
  if ((cursor->getEngine()->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX)) &&
436
 
      getShare()->hasPrimaryKey())
 
1919
  if ((file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
 
1920
      s->primary_key < MAX_KEY)
437
1921
  {
438
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
1922
    mark_columns_used_by_index_no_reset(s->primary_key);
439
1923
  }
440
1924
  return;
441
1925
}
453
1937
 
454
1938
void Table::mark_columns_used_by_index(uint32_t index)
455
1939
{
456
 
  boost::dynamic_bitset<> *bitmap= &tmp_set;
 
1940
  MyBitmap *bitmap= &tmp_set;
457
1941
 
458
 
  (void) cursor->extra(HA_EXTRA_KEYREAD);
459
 
  bitmap->reset();
460
 
  mark_columns_used_by_index_no_reset(index, *bitmap);
461
 
  column_bitmaps_set(*bitmap, *bitmap);
 
1942
  (void) file->extra(HA_EXTRA_KEYREAD);
 
1943
  bitmap->clearAll();
 
1944
  mark_columns_used_by_index_no_reset(index, bitmap);
 
1945
  column_bitmaps_set(bitmap, bitmap);
462
1946
  return;
463
1947
}
464
1948
 
478
1962
{
479
1963
 
480
1964
  key_read= 0;
481
 
  (void) cursor->extra(HA_EXTRA_NO_KEYREAD);
 
1965
  (void) file->extra(HA_EXTRA_NO_KEYREAD);
482
1966
  default_column_bitmaps();
483
1967
  return;
484
1968
}
490
1974
 
491
1975
void Table::mark_columns_used_by_index_no_reset(uint32_t index)
492
1976
{
493
 
    mark_columns_used_by_index_no_reset(index, *read_set);
 
1977
    mark_columns_used_by_index_no_reset(index, read_set);
494
1978
}
495
1979
 
496
 
 
497
1980
void Table::mark_columns_used_by_index_no_reset(uint32_t index,
498
 
                                                boost::dynamic_bitset<>& bitmap)
 
1981
                                                MyBitmap *bitmap)
499
1982
{
500
 
  KeyPartInfo *key_part= key_info[index].key_part;
501
 
  KeyPartInfo *key_part_end= (key_part + key_info[index].key_parts);
502
 
  for (; key_part != key_part_end; key_part++)
503
 
  {
504
 
    if (! bitmap.empty())
505
 
      bitmap.set(key_part->fieldnr-1);
506
 
  }
 
1983
  KEY_PART_INFO *key_part= key_info[index].key_part;
 
1984
  KEY_PART_INFO *key_part_end= (key_part +
 
1985
                                key_info[index].key_parts);
 
1986
  for (;key_part != key_part_end; key_part++)
 
1987
    bitmap->setBit(key_part->fieldnr-1);
507
1988
}
508
1989
 
509
1990
 
522
2003
    We must set bit in read set as update_auto_increment() is using the
523
2004
    store() to check overflow of auto_increment values
524
2005
  */
525
 
  setReadSet(found_next_number_field->position());
526
 
  setWriteSet(found_next_number_field->position());
527
 
  if (getShare()->next_number_keypart)
528
 
    mark_columns_used_by_index_no_reset(getShare()->next_number_index);
 
2006
  setReadSet(found_next_number_field->field_index);
 
2007
  setWriteSet(found_next_number_field->field_index);
 
2008
  if (s->next_number_keypart)
 
2009
    mark_columns_used_by_index_no_reset(s->next_number_index);
529
2010
}
530
2011
 
531
2012
 
550
2031
void Table::mark_columns_needed_for_delete()
551
2032
{
552
2033
  /*
553
 
    If the Cursor has no cursor capabilites, or we have row-based
 
2034
    If the handler has no cursor capabilites, or we have row-based
554
2035
    replication active for the current statement, we have to read
555
2036
    either the primary key, the hidden primary key or all columns to
556
2037
    be able to do an delete
557
2038
 
558
2039
  */
559
 
  if (not getShare()->hasPrimaryKey())
 
2040
  if (s->primary_key == MAX_KEY)
560
2041
  {
561
2042
    /* fallback to use all columns in the table to identify row */
562
2043
    use_all_columns();
563
2044
    return;
564
2045
  }
565
2046
  else
566
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
2047
    mark_columns_used_by_index_no_reset(s->primary_key);
567
2048
 
568
2049
  /* If we the engine wants all predicates we mark all keys */
569
 
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
 
2050
  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
570
2051
  {
571
2052
    Field **reg_field;
572
2053
    for (reg_field= field ; *reg_field ; reg_field++)
573
2054
    {
574
2055
      if ((*reg_field)->flags & PART_KEY_FLAG)
575
 
        setReadSet((*reg_field)->position());
 
2056
        setReadSet((*reg_field)->field_index);
576
2057
    }
577
2058
  }
578
2059
}
590
2071
    if neeed, either the primary key column or all columns to be read.
591
2072
    (see mark_columns_needed_for_delete() for details)
592
2073
 
593
 
    If the engine has HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
 
2074
    If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
594
2075
    mark all USED key columns as 'to-be-read'. This allows the engine to
595
2076
    loop over the given record to find all changed keys and doesn't have to
596
2077
    retrieve the row again.
599
2080
void Table::mark_columns_needed_for_update()
600
2081
{
601
2082
  /*
602
 
    If the Cursor has no cursor capabilites, or we have row-based
 
2083
    If the handler has no cursor capabilites, or we have row-based
603
2084
    logging active for the current statement, we have to read either
604
2085
    the primary key, the hidden primary key or all columns to be
605
2086
    able to do an update
606
2087
  */
607
 
  if (not getShare()->hasPrimaryKey())
 
2088
  if (s->primary_key == MAX_KEY)
608
2089
  {
609
2090
    /* fallback to use all columns in the table to identify row */
610
2091
    use_all_columns();
611
2092
    return;
612
2093
  }
613
2094
  else
614
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
2095
    mark_columns_used_by_index_no_reset(s->primary_key);
615
2096
 
616
 
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
 
2097
  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
617
2098
  {
618
2099
    /* Mark all used key columns for read */
619
2100
    Field **reg_field;
621
2102
    {
622
2103
      /* Merge keys is all keys that had a column refered to in the query */
623
2104
      if (is_overlapping(merge_keys, (*reg_field)->part_of_key))
624
 
        setReadSet((*reg_field)->position());
 
2105
        setReadSet((*reg_field)->field_index);
625
2106
    }
626
2107
  }
627
2108
 
629
2110
 
630
2111
 
631
2112
/*
632
 
  Mark columns the Cursor needs for doing an insert
 
2113
  Mark columns the handler needs for doing an insert
633
2114
 
634
2115
  For now, this is used to mark fields used by the trigger
635
2116
  as changed.
653
2134
  {
654
2135
    Field_blob* const blob= (Field_blob*) field[*ptr];
655
2136
    length+= blob->get_length((const unsigned char*)
656
 
                              (data + blob->offset(getInsertRecord()))) +
 
2137
                              (data + blob->offset(record[0]))) +
657
2138
      HA_KEY_BLOB_LENGTH;
658
2139
  }
659
2140
  return length;
660
2141
}
661
2142
 
662
 
void Table::setVariableWidth(void)
663
 
{
664
 
  assert(in_use);
665
 
  if (in_use && in_use->lex->sql_command == SQLCOM_CREATE_TABLE)
666
 
  {
667
 
    getMutableShare()->setVariableWidth();
668
 
    return;
669
 
  }
670
 
 
671
 
  assert(0); // Programming error, you can't set this on a plain old Table.
672
 
}
673
 
 
674
2143
/****************************************************************************
675
2144
 Functions for creating temporary tables.
676
2145
****************************************************************************/
 
2146
 
 
2147
 
 
2148
/* Prototypes */
 
2149
void free_tmp_table(Session *session, Table *entry);
 
2150
 
677
2151
/**
678
2152
  Create field for temporary table from given field.
679
2153
 
680
 
  @param session               Thread Cursor
 
2154
  @param session               Thread handler
681
2155
  @param org_field    field from which new field will be created
682
2156
  @param name         New field name
683
2157
  @param table         Temporary table
708
2182
  */
709
2183
  if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&
710
2184
      (org_field->flags & BLOB_FLAG))
711
 
  {
712
 
    table->setVariableWidth();
713
2185
    new_field= new Field_varstring(convert_blob_length,
714
2186
                                   org_field->maybe_null(),
715
 
                                   org_field->field_name,
 
2187
                                   org_field->field_name, table->s,
716
2188
                                   org_field->charset());
717
 
  }
718
2189
  else
719
 
  {
720
2190
    new_field= org_field->new_field(session->mem_root, table,
721
 
                                    table == org_field->getTable());
722
 
  }
 
2191
                                    table == org_field->table);
723
2192
  if (new_field)
724
2193
  {
725
2194
    new_field->init(table);
732
2201
    if (org_field->maybe_null() || (item && item->maybe_null))
733
2202
      new_field->flags&= ~NOT_NULL_FLAG;        // Because of outer join
734
2203
    if (org_field->type() == DRIZZLE_TYPE_VARCHAR)
735
 
      table->getMutableShare()->db_create_options|= HA_OPTION_PACK_RECORD;
 
2204
      table->s->db_create_options|= HA_OPTION_PACK_RECORD;
736
2205
    else if (org_field->type() == DRIZZLE_TYPE_DOUBLE)
737
2206
      ((Field_double *) new_field)->not_fixed= true;
738
2207
  }
741
2210
 
742
2211
 
743
2212
/**
 
2213
  Create field for information schema table.
 
2214
 
 
2215
  @param session                Thread handler
 
2216
  @param table          Temporary table
 
2217
  @param item           Item to create a field for
 
2218
 
 
2219
  @retval
 
2220
    0                   on error
 
2221
  @retval
 
2222
    new_created field
 
2223
*/
 
2224
 
 
2225
static Field *create_tmp_field_for_schema(Item *item, Table *table)
 
2226
{
 
2227
  if (item->field_type() == DRIZZLE_TYPE_VARCHAR)
 
2228
  {
 
2229
    Field *field;
 
2230
    if (item->max_length > MAX_FIELD_VARCHARLENGTH)
 
2231
      field= new Field_blob(item->max_length, item->maybe_null,
 
2232
                            item->name, item->collation.collation);
 
2233
    else
 
2234
      field= new Field_varstring(item->max_length, item->maybe_null,
 
2235
                                 item->name,
 
2236
                                 table->s, item->collation.collation);
 
2237
    if (field)
 
2238
      field->init(table);
 
2239
    return field;
 
2240
  }
 
2241
  return item->tmp_table_field_from_field_type(table, 0);
 
2242
}
 
2243
 
 
2244
 
 
2245
/**
744
2246
  Create a temp table according to a field list.
745
2247
 
746
2248
  Given field pointers are changed to point at tmp_table for
772
2274
 
773
2275
Table *
774
2276
create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,
775
 
                 Order *group, bool distinct, bool save_sum_fields,
 
2277
                 order_st *group, bool distinct, bool save_sum_fields,
776
2278
                 uint64_t select_options, ha_rows rows_limit,
777
2279
                 const char *table_alias)
778
2280
{
779
 
  memory::Root *mem_root_save;
 
2281
  MEM_ROOT *mem_root_save, own_root;
 
2282
  Table *table;
 
2283
  TableShare *share;
780
2284
  uint  i,field_count,null_count,null_pack_length;
781
2285
  uint32_t  copy_func_count= param->func_count;
782
2286
  uint32_t  hidden_null_count, hidden_null_pack_length, hidden_field_count;
783
2287
  uint32_t  blob_count,group_null_items, string_count;
784
2288
  uint32_t fieldnr= 0;
785
2289
  ulong reclength, string_total_length;
786
 
  bool  using_unique_constraint= false;
787
 
  bool  use_packed_rows= true;
 
2290
  bool  using_unique_constraint= 0;
 
2291
  bool  use_packed_rows= 0;
788
2292
  bool  not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);
789
 
  unsigned char *pos, *group_buff;
 
2293
  char  *tmpname,path[FN_REFLEN];
 
2294
  unsigned char *pos, *group_buff, *bitmaps;
790
2295
  unsigned char *null_flags;
791
2296
  Field **reg_field, **from_field, **default_field;
 
2297
  uint32_t *blob_field;
792
2298
  CopyField *copy= 0;
793
 
  KeyInfo *keyinfo;
794
 
  KeyPartInfo *key_part_info;
 
2299
  KEY *keyinfo;
 
2300
  KEY_PART_INFO *key_part_info;
795
2301
  Item **copy_func;
796
2302
  MI_COLUMNDEF *recinfo;
797
2303
  uint32_t total_uneven_bit_length= 0;
798
2304
  bool force_copy_fields= param->force_copy_fields;
799
2305
  uint64_t max_rows= 0;
800
2306
 
801
 
  session->status_var.created_tmp_tables++;
 
2307
  status_var_increment(session->status_var.created_tmp_tables);
 
2308
 
 
2309
  /* if we run out of slots or we are not using tempool */
 
2310
  sprintf(path,"%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,
 
2311
          session->thread_id, session->tmp_table++);
 
2312
 
 
2313
  /*
 
2314
    No need to change table name to lower case as we are only creating
 
2315
    MyISAM or HEAP tables here
 
2316
  */
 
2317
  fn_format(path, path, drizzle_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);
 
2318
 
802
2319
 
803
2320
  if (group)
804
2321
  {
805
 
    if (! param->quick_group)
806
 
    {
 
2322
    if (!param->quick_group)
807
2323
      group= 0;                                 // Can't use group key
808
 
    }
809
 
    else for (Order *tmp=group ; tmp ; tmp=tmp->next)
 
2324
    else for (order_st *tmp=group ; tmp ; tmp=tmp->next)
810
2325
    {
811
2326
      /*
812
2327
        marker == 4 means two things:
816
2331
      */
817
2332
      (*tmp->item)->marker= 4;
818
2333
      if ((*tmp->item)->max_length >= CONVERT_IF_BIGGER_TO_BLOB)
819
 
        using_unique_constraint= true;
 
2334
        using_unique_constraint=1;
820
2335
    }
821
2336
    if (param->group_length >= MAX_BLOB_WIDTH)
822
 
      using_unique_constraint= true;
 
2337
      using_unique_constraint=1;
823
2338
    if (group)
824
2339
      distinct= 0;                              // Can't use distinct
825
2340
  }
835
2350
    these items are stored in the temporary table.
836
2351
  */
837
2352
  if (param->precomputed_group_by)
838
 
  {
839
2353
    copy_func_count+= param->sum_func_count;
840
 
  }
841
 
 
842
 
  table::Singular *table;
843
 
  table= session->getInstanceTable(); // This will not go into the tableshare cache, so no key is used.
844
 
 
845
 
  if (not table->getMemRoot()->multi_alloc_root(0,
846
 
                                                &default_field, sizeof(Field*) * (field_count),
847
 
                                                &from_field, sizeof(Field*)*field_count,
848
 
                                                &copy_func, sizeof(*copy_func)*(copy_func_count+1),
849
 
                                                &param->keyinfo, sizeof(*param->keyinfo),
850
 
                                                &key_part_info, sizeof(*key_part_info)*(param->group_parts+1),
851
 
                                                &param->start_recinfo, sizeof(*param->recinfo)*(field_count*2+4),
852
 
                                                &group_buff, (group && ! using_unique_constraint ?
853
 
                                                              param->group_length : 0),
854
 
                                                NULL))
 
2354
 
 
2355
  init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
2356
 
 
2357
  if (!multi_alloc_root(&own_root,
 
2358
                        &table, sizeof(*table),
 
2359
                        &share, sizeof(*share),
 
2360
                        &reg_field, sizeof(Field*) * (field_count+1),
 
2361
                        &default_field, sizeof(Field*) * (field_count),
 
2362
                        &blob_field, sizeof(uint32_t)*(field_count+1),
 
2363
                        &from_field, sizeof(Field*)*field_count,
 
2364
                        &copy_func, sizeof(*copy_func)*(copy_func_count+1),
 
2365
                        &param->keyinfo, sizeof(*param->keyinfo),
 
2366
                        &key_part_info,
 
2367
                        sizeof(*key_part_info)*(param->group_parts+1),
 
2368
                        &param->start_recinfo,
 
2369
                        sizeof(*param->recinfo)*(field_count*2+4),
 
2370
                        &tmpname, (uint32_t) strlen(path)+1,
 
2371
                        &group_buff, (group && ! using_unique_constraint ?
 
2372
                                      param->group_length : 0),
 
2373
                        &bitmaps, bitmap_buffer_size(field_count)*2,
 
2374
                        NULL))
855
2375
  {
856
2376
    return NULL;
857
2377
  }
858
2378
  /* CopyField belongs to Tmp_Table_Param, allocate it in Session mem_root */
859
2379
  if (!(param->copy_field= copy= new (session->mem_root) CopyField[field_count]))
860
2380
  {
 
2381
    free_root(&own_root, MYF(0));
861
2382
    return NULL;
862
2383
  }
863
2384
  param->items_to_copy= copy_func;
 
2385
  strcpy(tmpname,path);
864
2386
  /* make table according to fields */
865
2387
 
 
2388
  memset(table, 0, sizeof(*table));
 
2389
  memset(reg_field, 0, sizeof(Field*)*(field_count+1));
866
2390
  memset(default_field, 0, sizeof(Field*) * (field_count));
867
2391
  memset(from_field, 0, sizeof(Field*)*field_count);
868
2392
 
 
2393
  table->mem_root= own_root;
869
2394
  mem_root_save= session->mem_root;
870
 
  session->mem_root= table->getMemRoot();
 
2395
  session->mem_root= &table->mem_root;
871
2396
 
872
 
  table->getMutableShare()->setFields(field_count+1);
873
 
  table->setFields(table->getMutableShare()->getFields(true));
874
 
  reg_field= table->getMutableShare()->getFields(true);
875
 
  table->setAlias(table_alias);
 
2397
  table->field=reg_field;
 
2398
  table->alias= table_alias;
876
2399
  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */
877
2400
  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
878
2401
  table->map=1;
879
2402
  table->copy_blobs= 1;
880
 
  assert(session);
881
2403
  table->in_use= session;
882
2404
  table->quick_keys.reset();
883
2405
  table->covering_keys.reset();
884
2406
  table->keys_in_use_for_query.reset();
885
2407
 
886
 
  table->getMutableShare()->blob_field.resize(field_count+1);
887
 
  uint32_t *blob_field= &table->getMutableShare()->blob_field[0];
888
 
  table->getMutableShare()->db_low_byte_first=1;                // True for HEAP and MyISAM
889
 
  table->getMutableShare()->table_charset= param->table_charset;
890
 
  table->getMutableShare()->keys_for_keyread.reset();
891
 
  table->getMutableShare()->keys_in_use.reset();
 
2408
  table->setShare(share);
 
2409
  share->init(tmpname, tmpname);
 
2410
  share->blob_field= blob_field;
 
2411
  share->blob_ptr_size= portable_sizeof_char_ptr;
 
2412
  share->db_low_byte_first=1;                // True for HEAP and MyISAM
 
2413
  share->table_charset= param->table_charset;
 
2414
  share->primary_key= MAX_KEY;               // Indicate no primary key
 
2415
  share->keys_for_keyread.reset();
 
2416
  share->keys_in_use.reset();
892
2417
 
893
2418
  /* Calculate which type of fields we will store in the temporary table */
894
2419
 
936
2461
            create_tmp_field(session, table, arg, arg->type(), &copy_func,
937
2462
                             tmp_from_field, &default_field[fieldnr],
938
2463
                             group != 0,not_all_columns,
939
 
                             false,
 
2464
                             distinct, 0,
940
2465
                             param->convert_blob_length);
941
2466
          if (!new_field)
942
2467
            goto err;                                   // Should be OOM
955
2480
          }
956
2481
          session->mem_root= mem_root_save;
957
2482
          session->change_item_tree(argp, new Item_field(new_field));
958
 
          session->mem_root= table->getMemRoot();
 
2483
          session->mem_root= &table->mem_root;
959
2484
          if (!(new_field->flags & NOT_NULL_FLAG))
960
2485
          {
961
2486
            null_count++;
965
2490
            */
966
2491
            (*argp)->maybe_null=1;
967
2492
          }
968
 
          new_field->setPosition(fieldnr++);
 
2493
          new_field->field_index= fieldnr++;
969
2494
        }
970
2495
      }
971
2496
    }
981
2506
        We here distinguish between UNION and multi-table-updates by the fact
982
2507
        that in the later case group is set to the row pointer.
983
2508
      */
984
 
      Field *new_field=
 
2509
      Field *new_field= (param->schema_table) ?
 
2510
        create_tmp_field_for_schema(item, table) :
985
2511
        create_tmp_field(session, table, item, type, &copy_func,
986
2512
                         tmp_from_field, &default_field[fieldnr],
987
2513
                         group != 0,
988
2514
                         !force_copy_fields &&
989
2515
                           (not_all_columns || group != 0),
 
2516
                         /*
 
2517
                           If item->marker == 4 then we force create_tmp_field
 
2518
                           to create a 64-bit longs for BIT fields because HEAP
 
2519
                           tables can't index BIT fields directly. We do the same
 
2520
                           for distinct, as we want the distinct index to be
 
2521
                           usable in this case too.
 
2522
                         */
 
2523
                         item->marker == 4 || param->bit_fields_as_long,
990
2524
                         force_copy_fields,
991
2525
                         param->convert_blob_length);
992
2526
 
1012
2546
        group_null_items++;
1013
2547
        new_field->flags|= GROUP_FLAG;
1014
2548
      }
1015
 
      new_field->setPosition(fieldnr++);
 
2549
      new_field->field_index= fieldnr++;
1016
2550
      *(reg_field++)= new_field;
1017
2551
    }
1018
2552
    if (!--hidden_field_count)
1030
2564
      null_count= 0;
1031
2565
    }
1032
2566
  }
1033
 
  assert(fieldnr == (uint32_t) (reg_field - table->getFields()));
1034
 
  assert(field_count >= (uint32_t) (reg_field - table->getFields()));
 
2567
  assert(fieldnr == (uint32_t) (reg_field - table->field));
 
2568
  assert(field_count >= (uint32_t) (reg_field - table->field));
1035
2569
  field_count= fieldnr;
1036
2570
  *reg_field= 0;
1037
2571
  *blob_field= 0;                               // End marker
1038
 
  table->getMutableShare()->setFieldSize(field_count);
 
2572
  share->fields= field_count;
1039
2573
 
1040
2574
  /* If result table is small; use a heap */
1041
2575
  /* future: storage engine selection can be made dynamic? */
1042
 
  if (blob_count || using_unique_constraint || 
1043
 
      (session->lex->select_lex.options & SELECT_BIG_RESULT) ||
1044
 
      (session->lex->current_select->olap == ROLLUP_TYPE) ||
1045
 
      (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) == OPTION_BIG_TABLES)
 
2576
  if (blob_count || using_unique_constraint ||
 
2577
      (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
 
2578
      OPTION_BIG_TABLES || (select_options & TMP_TABLE_FORCE_MYISAM))
1046
2579
  {
1047
 
    table->getMutableShare()->storage_engine= myisam_engine;
1048
 
    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
 
2580
    share->storage_engine= myisam_engine;
 
2581
    table->file= get_new_handler(share, &table->mem_root,
 
2582
                                 share->db_type());
1049
2583
    if (group &&
1050
 
        (param->group_parts > table->cursor->getEngine()->max_key_parts() ||
1051
 
         param->group_length > table->cursor->getEngine()->max_key_length()))
1052
 
    {
1053
 
      using_unique_constraint= true;
1054
 
    }
 
2584
        (param->group_parts > table->file->max_key_parts() ||
 
2585
         param->group_length > table->file->max_key_length()))
 
2586
      using_unique_constraint=1;
1055
2587
  }
1056
2588
  else
1057
2589
  {
1058
 
    table->getMutableShare()->storage_engine= heap_engine;
1059
 
    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
 
2590
    share->storage_engine= heap_engine;
 
2591
    table->file= get_new_handler(share, &table->mem_root,
 
2592
                                 share->db_type());
1060
2593
  }
1061
 
  if (! table->cursor)
 
2594
  if (!table->file)
1062
2595
    goto err;
1063
2596
 
1064
2597
 
1065
 
  if (! using_unique_constraint)
 
2598
  if (!using_unique_constraint)
1066
2599
    reclength+= group_null_items;       // null flag is stored separately
1067
2600
 
1068
 
  table->getMutableShare()->blob_fields= blob_count;
 
2601
  share->blob_fields= blob_count;
1069
2602
  if (blob_count == 0)
1070
2603
  {
1071
2604
    /* We need to ensure that first byte is not 0 for the delete link */
1084
2617
  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)))
1085
2618
    use_packed_rows= 1;
1086
2619
 
1087
 
  table->getMutableShare()->setRecordLength(reclength);
 
2620
  share->reclength= reclength;
1088
2621
  {
1089
2622
    uint32_t alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1);
1090
 
    table->getMutableShare()->rec_buff_length= alloc_length;
1091
 
    if (!(table->record[0]= (unsigned char*) table->alloc_root(alloc_length*2)))
1092
 
    {
 
2623
    share->rec_buff_length= alloc_length;
 
2624
    if (!(table->record[0]= (unsigned char*)
 
2625
                            alloc_root(&table->mem_root, alloc_length*3)))
1093
2626
      goto err;
1094
 
    }
1095
 
    table->record[1]= table->getInsertRecord()+alloc_length;
1096
 
    table->getMutableShare()->resizeDefaultValues(alloc_length);
 
2627
    table->record[1]= table->record[0]+alloc_length;
 
2628
    share->default_values= table->record[1]+alloc_length;
1097
2629
  }
1098
2630
  copy_func[0]= 0;                              // End marker
1099
2631
  param->func_count= copy_func - param->items_to_copy;
1100
2632
 
1101
 
  table->setup_tmp_table_column_bitmaps();
 
2633
  table->setup_tmp_table_column_bitmaps(bitmaps);
1102
2634
 
1103
2635
  recinfo=param->start_recinfo;
1104
 
  null_flags=(unsigned char*) table->getInsertRecord();
1105
 
  pos=table->getInsertRecord()+ null_pack_length;
 
2636
  null_flags=(unsigned char*) table->record[0];
 
2637
  pos=table->record[0]+ null_pack_length;
1106
2638
  if (null_pack_length)
1107
2639
  {
1108
2640
    memset(recinfo, 0, sizeof(*recinfo));
1111
2643
    recinfo++;
1112
2644
    memset(null_flags, 255, null_pack_length);  // Set null fields
1113
2645
 
1114
 
    table->null_flags= (unsigned char*) table->getInsertRecord();
1115
 
    table->getMutableShare()->null_fields= null_count+ hidden_null_count;
1116
 
    table->getMutableShare()->null_bytes= null_pack_length;
 
2646
    table->null_flags= (unsigned char*) table->record[0];
 
2647
    share->null_fields= null_count+ hidden_null_count;
 
2648
    share->null_bytes= null_pack_length;
1117
2649
  }
1118
2650
  null_count= (blob_count == 0) ? 1 : 0;
1119
2651
  hidden_field_count=param->hidden_field_count;
1120
 
  for (i= 0,reg_field= table->getFields(); i < field_count; i++,reg_field++,recinfo++)
 
2652
  for (i= 0,reg_field=table->field; i < field_count; i++,reg_field++,recinfo++)
1121
2653
  {
1122
2654
    Field *field= *reg_field;
1123
2655
    uint32_t length;
1161
2693
         inherit the default value that is defined for the field referred
1162
2694
         by the Item_field object from which 'field' has been created.
1163
2695
      */
1164
 
      ptrdiff_t diff;
 
2696
      my_ptrdiff_t diff;
1165
2697
      Field *orig_field= default_field[i];
1166
2698
      /* Get the value from default_values */
1167
 
      diff= (ptrdiff_t) (orig_field->getTable()->getDefaultValues() - orig_field->getTable()->getInsertRecord());
 
2699
      diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
 
2700
                            orig_field->table->record[0]);
1168
2701
      orig_field->move_field_offset(diff);      // Points now at default_values
1169
2702
      if (orig_field->is_real_null())
1170
2703
        field->set_null();
1173
2706
        field->set_notnull();
1174
2707
        memcpy(field->ptr, orig_field->ptr, field->pack_length());
1175
2708
      }
1176
 
      orig_field->move_field_offset(-diff);     // Back to getInsertRecord()
 
2709
      orig_field->move_field_offset(-diff);     // Back to record[0]
1177
2710
    }
1178
2711
 
1179
2712
    if (from_field[i])
1192
2725
      recinfo->type=FIELD_NORMAL;
1193
2726
    if (!--hidden_field_count)
1194
2727
      null_count=(null_count+7) & ~7;           // move to next byte
 
2728
 
 
2729
    // fix table name in field entry
 
2730
    field->table_name= &table->alias;
1195
2731
  }
1196
2732
 
1197
2733
  param->copy_field_end=copy;
1199
2735
  table->storeRecordAsDefault();        // Make empty default record
1200
2736
 
1201
2737
  if (session->variables.tmp_table_size == ~ (uint64_t) 0)              // No limit
1202
 
  {
1203
2738
    max_rows= ~(uint64_t) 0;
1204
 
  }
1205
2739
  else
1206
 
  {
1207
 
    max_rows= (uint64_t) (((table->getMutableShare()->db_type() == heap_engine) ?
1208
 
                           min(session->variables.tmp_table_size,
1209
 
                               session->variables.max_heap_table_size) :
1210
 
                           session->variables.tmp_table_size) /
1211
 
                          table->getMutableShare()->getRecordLength());
1212
 
  }
 
2740
    max_rows= (uint64_t) (((share->db_type() == heap_engine) ?
 
2741
                          min(session->variables.tmp_table_size,
 
2742
                              session->variables.max_heap_table_size) :
 
2743
                          session->variables.tmp_table_size) /
 
2744
                         share->reclength);
1213
2745
 
1214
2746
  set_if_bigger(max_rows, (uint64_t)1); // For dummy start options
1215
2747
  /*
1218
2750
  */
1219
2751
  set_if_smaller(max_rows, rows_limit);
1220
2752
 
1221
 
  table->getMutableShare()->setMaxRows(max_rows);
 
2753
  share->setMaxRows(max_rows);
1222
2754
 
1223
2755
  param->end_write_records= rows_limit;
1224
2756
 
1228
2760
  {
1229
2761
    table->group=group;                         /* Table is grouped by key */
1230
2762
    param->group_buff=group_buff;
1231
 
    table->getMutableShare()->keys=1;
1232
 
    table->getMutableShare()->uniques= test(using_unique_constraint);
 
2763
    share->keys=1;
 
2764
    share->uniques= test(using_unique_constraint);
1233
2765
    table->key_info=keyinfo;
1234
2766
    keyinfo->key_part=key_part_info;
1235
2767
    keyinfo->flags=HA_NOSAME;
1238
2770
    keyinfo->rec_per_key= 0;
1239
2771
    keyinfo->algorithm= HA_KEY_ALG_UNDEF;
1240
2772
    keyinfo->name= (char*) "group_key";
1241
 
    Order *cur_group= group;
 
2773
    order_st *cur_group= group;
1242
2774
    for (; cur_group ; cur_group= cur_group->next, key_part_info++)
1243
2775
    {
1244
2776
      Field *field=(*cur_group->item)->get_tmp_table_field();
1245
2777
      bool maybe_null=(*cur_group->item)->maybe_null;
1246
2778
      key_part_info->null_bit= 0;
1247
2779
      key_part_info->field=  field;
1248
 
      key_part_info->offset= field->offset(table->getInsertRecord());
 
2780
      key_part_info->offset= field->offset(table->record[0]);
1249
2781
      key_part_info->length= (uint16_t) field->key_length();
1250
2782
      key_part_info->type=   (uint8_t) field->key_type();
1251
2783
      key_part_info->key_type= 
1273
2805
          keyinfo->flags|= HA_NULL_ARE_EQUAL;   // def. that NULL == NULL
1274
2806
          key_part_info->null_bit=field->null_bit;
1275
2807
          key_part_info->null_offset= (uint32_t) (field->null_ptr -
1276
 
                                              (unsigned char*) table->getInsertRecord());
 
2808
                                              (unsigned char*) table->record[0]);
1277
2809
          cur_group->buff++;                        // Pointer to field data
1278
2810
          group_buff++;                         // Skipp null flag
1279
2811
        }
1300
2832
        indexes on blobs with arbitrary length. Such indexes cannot be
1301
2833
        used for lookups.
1302
2834
      */
1303
 
      table->getMutableShare()->uniques= 1;
 
2835
      share->uniques= 1;
1304
2836
    }
1305
2837
    null_pack_length-=hidden_null_pack_length;
1306
2838
    keyinfo->key_parts= ((field_count-param->hidden_field_count)+
1307
 
                         (table->getMutableShare()->uniques ? test(null_pack_length) : 0));
 
2839
                         (share->uniques ? test(null_pack_length) : 0));
1308
2840
    table->distinct= 1;
1309
 
    table->getMutableShare()->keys= 1;
1310
 
    if (!(key_part_info= (KeyPartInfo*)
1311
 
         table->alloc_root(keyinfo->key_parts * sizeof(KeyPartInfo))))
 
2841
    share->keys= 1;
 
2842
    if (!(key_part_info= (KEY_PART_INFO*)
 
2843
          alloc_root(&table->mem_root,
 
2844
                     keyinfo->key_parts * sizeof(KEY_PART_INFO))))
1312
2845
      goto err;
1313
 
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KeyPartInfo));
 
2846
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KEY_PART_INFO));
1314
2847
    table->key_info=keyinfo;
1315
2848
    keyinfo->key_part=key_part_info;
1316
2849
    keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;
1324
2857
      blobs can distinguish NULL from 0. This extra field is not needed
1325
2858
      when we do not use UNIQUE indexes for blobs.
1326
2859
    */
1327
 
    if (null_pack_length && table->getMutableShare()->uniques)
 
2860
    if (null_pack_length && share->uniques)
1328
2861
    {
1329
2862
      key_part_info->null_bit= 0;
1330
2863
      key_part_info->offset=hidden_null_pack_length;
1331
2864
      key_part_info->length=null_pack_length;
1332
 
      table->setVariableWidth();
1333
 
      key_part_info->field= new Field_varstring(table->getInsertRecord(),
 
2865
      key_part_info->field= new Field_varstring(table->record[0],
1334
2866
                                                (uint32_t) key_part_info->length,
1335
2867
                                                0,
1336
2868
                                                (unsigned char*) 0,
1337
2869
                                                (uint32_t) 0,
1338
2870
                                                NULL,
 
2871
                                                table->s,
1339
2872
                                                &my_charset_bin);
1340
2873
      if (!key_part_info->field)
1341
2874
        goto err;
1345
2878
      key_part_info++;
1346
2879
    }
1347
2880
    /* Create a distinct key over the columns we are going to return */
1348
 
    for (i=param->hidden_field_count, reg_field=table->getFields() + i ;
 
2881
    for (i=param->hidden_field_count, reg_field=table->field + i ;
1349
2882
         i < field_count;
1350
2883
         i++, reg_field++, key_part_info++)
1351
2884
    {
1352
2885
      key_part_info->null_bit= 0;
1353
2886
      key_part_info->field=    *reg_field;
1354
 
      key_part_info->offset=   (*reg_field)->offset(table->getInsertRecord());
 
2887
      key_part_info->offset=   (*reg_field)->offset(table->record[0]);
1355
2888
      key_part_info->length=   (uint16_t) (*reg_field)->pack_length();
1356
 
      /* @todo The below method of computing the key format length of the
1357
 
        key part is a copy/paste from optimizer/range.cc, and table.cc.
 
2889
      /* TODO:
 
2890
        The below method of computing the key format length of the
 
2891
        key part is a copy/paste from opt_range.cc, and table.cc.
1358
2892
        This should be factored out, e.g. as a method of Field.
1359
2893
        In addition it is not clear if any of the Field::*_length
1360
2894
        methods is supposed to compute the same length. If so, it
1379
2913
 
1380
2914
  if (session->is_fatal_error)                          // If end of memory
1381
2915
    goto err;
1382
 
  table->getMutableShare()->db_record_offset= 1;
1383
 
  if (table->getShare()->db_type() == myisam_engine)
 
2916
  share->db_record_offset= 1;
 
2917
  if (share->db_type() == myisam_engine)
1384
2918
  {
1385
2919
    if (table->create_myisam_tmp_table(param->keyinfo, param->start_recinfo,
1386
2920
                                       &param->recinfo, select_options))
1387
2921
      goto err;
1388
2922
  }
1389
 
  assert(table->in_use);
1390
2923
  if (table->open_tmp_table())
1391
2924
    goto err;
1392
2925
 
1396
2929
 
1397
2930
err:
1398
2931
  session->mem_root= mem_root_save;
1399
 
  table= NULL;
1400
 
 
 
2932
  table->free_tmp_table(session);
1401
2933
  return NULL;
1402
2934
}
1403
2935
 
1404
2936
/****************************************************************************/
1405
2937
 
1406
 
void Table::column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,
1407
 
                               boost::dynamic_bitset<>& write_set_arg)
1408
 
{
1409
 
  read_set= &read_set_arg;
1410
 
  write_set= &write_set_arg;
1411
 
}
1412
 
 
1413
 
 
1414
 
const boost::dynamic_bitset<> Table::use_all_columns(boost::dynamic_bitset<>& in_map)
1415
 
{
1416
 
  const boost::dynamic_bitset<> old= in_map;
1417
 
  in_map= getShare()->all_set;
 
2938
/**
 
2939
  Create a reduced Table object with properly set up Field list from a
 
2940
  list of field definitions.
 
2941
 
 
2942
    The created table doesn't have a table handler associated with
 
2943
    it, has no keys, no group/distinct, no copy_funcs array.
 
2944
    The sole purpose of this Table object is to use the power of Field
 
2945
    class to read/write data to/from table->record[0]. Then one can store
 
2946
    the record in any container (RB tree, hash, etc).
 
2947
    The table is created in Session mem_root, so are the table's fields.
 
2948
    Consequently, if you don't BLOB fields, you don't need to free it.
 
2949
 
 
2950
  @param session         connection handle
 
2951
  @param field_list  list of column definitions
 
2952
 
 
2953
  @return
 
2954
    0 if out of memory, Table object in case of success
 
2955
*/
 
2956
 
 
2957
Table *create_virtual_tmp_table(Session *session, List<CreateField> &field_list)
 
2958
{
 
2959
  uint32_t field_count= field_list.elements;
 
2960
  uint32_t blob_count= 0;
 
2961
  Field **field;
 
2962
  CreateField *cdef;                           /* column definition */
 
2963
  uint32_t record_length= 0;
 
2964
  uint32_t null_count= 0;                 /* number of columns which may be null */
 
2965
  uint32_t null_pack_length;              /* NULL representation array length */
 
2966
  uint32_t *blob_field;
 
2967
  unsigned char *bitmaps;
 
2968
  Table *table;
 
2969
  TableShare *share;
 
2970
 
 
2971
  if (!multi_alloc_root(session->mem_root,
 
2972
                        &table, sizeof(*table),
 
2973
                        &share, sizeof(*share),
 
2974
                        &field, (field_count + 1) * sizeof(Field*),
 
2975
                        &blob_field, (field_count+1) *sizeof(uint32_t),
 
2976
                        &bitmaps, bitmap_buffer_size(field_count)*2,
 
2977
                        NULL))
 
2978
    return NULL;
 
2979
 
 
2980
  memset(table, 0, sizeof(*table));
 
2981
  memset(share, 0, sizeof(*share));
 
2982
  table->field= field;
 
2983
  table->s= share;
 
2984
  share->blob_field= blob_field;
 
2985
  share->fields= field_count;
 
2986
  share->blob_ptr_size= portable_sizeof_char_ptr;
 
2987
  table->setup_tmp_table_column_bitmaps(bitmaps);
 
2988
 
 
2989
  /* Create all fields and calculate the total length of record */
 
2990
  List_iterator_fast<CreateField> it(field_list);
 
2991
  while ((cdef= it++))
 
2992
  {
 
2993
    *field= make_field(share,
 
2994
                       NULL,
 
2995
                       0,
 
2996
                       cdef->length,
 
2997
                       (cdef->flags & NOT_NULL_FLAG) ? false : true,
 
2998
                       (unsigned char *) ((cdef->flags & NOT_NULL_FLAG) ? 0 : ""),
 
2999
                       (cdef->flags & NOT_NULL_FLAG) ? 0 : 1,
 
3000
                       cdef->decimals,
 
3001
                       cdef->sql_type,
 
3002
                       cdef->charset,
 
3003
                       cdef->unireg_check,
 
3004
                       cdef->interval,
 
3005
                       cdef->field_name);
 
3006
    if (!*field)
 
3007
      goto error;
 
3008
    (*field)->init(table);
 
3009
    record_length+= (*field)->pack_length();
 
3010
    if (! ((*field)->flags & NOT_NULL_FLAG))
 
3011
      null_count++;
 
3012
 
 
3013
    if ((*field)->flags & BLOB_FLAG)
 
3014
      share->blob_field[blob_count++]= (uint32_t) (field - table->field);
 
3015
 
 
3016
    field++;
 
3017
  }
 
3018
  *field= NULL;                             /* mark the end of the list */
 
3019
  share->blob_field[blob_count]= 0;            /* mark the end of the list */
 
3020
  share->blob_fields= blob_count;
 
3021
 
 
3022
  null_pack_length= (null_count + 7)/8;
 
3023
  share->reclength= record_length + null_pack_length;
 
3024
  share->rec_buff_length= ALIGN_SIZE(share->reclength + 1);
 
3025
  table->record[0]= (unsigned char*) session->alloc(share->rec_buff_length);
 
3026
  if (!table->record[0])
 
3027
    goto error;
 
3028
 
 
3029
  if (null_pack_length)
 
3030
  {
 
3031
    table->null_flags= (unsigned char*) table->record[0];
 
3032
    share->null_fields= null_count;
 
3033
    share->null_bytes= null_pack_length;
 
3034
  }
 
3035
 
 
3036
  table->in_use= session;           /* field->reset() may access table->in_use */
 
3037
  {
 
3038
    /* Set up field pointers */
 
3039
    unsigned char *null_pos= table->record[0];
 
3040
    unsigned char *field_pos= null_pos + share->null_bytes;
 
3041
    uint32_t null_bit= 1;
 
3042
 
 
3043
    for (field= table->field; *field; ++field)
 
3044
    {
 
3045
      Field *cur_field= *field;
 
3046
      if ((cur_field->flags & NOT_NULL_FLAG))
 
3047
        cur_field->move_field(field_pos);
 
3048
      else
 
3049
      {
 
3050
        cur_field->move_field(field_pos, (unsigned char*) null_pos, null_bit);
 
3051
        null_bit<<= 1;
 
3052
        if (null_bit == (1 << 8))
 
3053
        {
 
3054
          ++null_pos;
 
3055
          null_bit= 1;
 
3056
        }
 
3057
      }
 
3058
      cur_field->reset();
 
3059
 
 
3060
      field_pos+= cur_field->pack_length();
 
3061
    }
 
3062
  }
 
3063
  return table;
 
3064
error:
 
3065
  for (field= table->field; *field; ++field)
 
3066
    delete *field;                         /* just invokes field destructor */
 
3067
  return 0;
 
3068
}
 
3069
 
 
3070
bool Table::open_tmp_table()
 
3071
{
 
3072
  int error;
 
3073
  if ((error=file->ha_open(this, s->table_name.str,O_RDWR,
 
3074
                                  HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))
 
3075
  {
 
3076
    file->print_error(error,MYF(0));
 
3077
    db_stat= 0;
 
3078
    return true;
 
3079
  }
 
3080
  (void) file->extra(HA_EXTRA_QUICK);           /* Faster */
 
3081
  return false;
 
3082
}
 
3083
 
 
3084
 
 
3085
/*
 
3086
  Create MyISAM temporary table
 
3087
 
 
3088
  SYNOPSIS
 
3089
    create_myisam_tmp_table()
 
3090
      keyinfo         Description of the index (there is always one index)
 
3091
      start_recinfo   MyISAM's column descriptions
 
3092
      recinfo INOUT   End of MyISAM's column descriptions
 
3093
      options         Option bits
 
3094
 
 
3095
  DESCRIPTION
 
3096
    Create a MyISAM temporary table according to passed description. The is
 
3097
    assumed to have one unique index or constraint.
 
3098
 
 
3099
    The passed array or MI_COLUMNDEF structures must have this form:
 
3100
 
 
3101
      1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte
 
3102
         when there are many nullable columns)
 
3103
      2. Table columns
 
3104
      3. One free MI_COLUMNDEF element (*recinfo points here)
 
3105
 
 
3106
    This function may use the free element to create hash column for unique
 
3107
    constraint.
 
3108
 
 
3109
   RETURN
 
3110
     false - OK
 
3111
     true  - Error
 
3112
*/
 
3113
 
 
3114
bool Table::create_myisam_tmp_table(KEY *keyinfo,
 
3115
                                    MI_COLUMNDEF *start_recinfo,
 
3116
                                    MI_COLUMNDEF **recinfo,
 
3117
                                    uint64_t options)
 
3118
{
 
3119
  int error;
 
3120
  MI_KEYDEF keydef;
 
3121
  MI_UNIQUEDEF uniquedef;
 
3122
  TableShare *share= s;
 
3123
 
 
3124
  if (share->keys)
 
3125
  {                                             // Get keys for ni_create
 
3126
    bool using_unique_constraint= 0;
 
3127
    HA_KEYSEG *seg= (HA_KEYSEG*) alloc_root(&this->mem_root,
 
3128
                                            sizeof(*seg) * keyinfo->key_parts);
 
3129
    if (!seg)
 
3130
      goto err;
 
3131
 
 
3132
    memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
 
3133
    if (keyinfo->key_length >= file->max_key_length() ||
 
3134
        keyinfo->key_parts > file->max_key_parts() ||
 
3135
        share->uniques)
 
3136
    {
 
3137
      /* Can't create a key; Make a unique constraint instead of a key */
 
3138
      share->keys=    0;
 
3139
      share->uniques= 1;
 
3140
      using_unique_constraint=1;
 
3141
      memset(&uniquedef, 0, sizeof(uniquedef));
 
3142
      uniquedef.keysegs=keyinfo->key_parts;
 
3143
      uniquedef.seg=seg;
 
3144
      uniquedef.null_are_equal=1;
 
3145
 
 
3146
      /* Create extra column for hash value */
 
3147
      memset(*recinfo, 0, sizeof(**recinfo));
 
3148
      (*recinfo)->type= FIELD_CHECK;
 
3149
      (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
 
3150
      (*recinfo)++;
 
3151
      share->reclength+=MI_UNIQUE_HASH_LENGTH;
 
3152
    }
 
3153
    else
 
3154
    {
 
3155
      /* Create an unique key */
 
3156
      memset(&keydef, 0, sizeof(keydef));
 
3157
      keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
 
3158
      keydef.keysegs=  keyinfo->key_parts;
 
3159
      keydef.seg= seg;
 
3160
    }
 
3161
    for (uint32_t i= 0; i < keyinfo->key_parts ; i++,seg++)
 
3162
    {
 
3163
      Field *key_field=keyinfo->key_part[i].field;
 
3164
      seg->flag=     0;
 
3165
      seg->language= key_field->charset()->number;
 
3166
      seg->length=   keyinfo->key_part[i].length;
 
3167
      seg->start=    keyinfo->key_part[i].offset;
 
3168
      if (key_field->flags & BLOB_FLAG)
 
3169
      {
 
3170
        seg->type= ((keyinfo->key_part[i].key_type & 1 /* binary */) ?
 
3171
         HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);
 
3172
        seg->bit_start= (uint8_t)(key_field->pack_length()
 
3173
                                  - share->blob_ptr_size);
 
3174
        seg->flag= HA_BLOB_PART;
 
3175
        seg->length= 0;                 // Whole blob in unique constraint
 
3176
      }
 
3177
      else
 
3178
      {
 
3179
        seg->type= keyinfo->key_part[i].type;
 
3180
      }
 
3181
      if (!(key_field->flags & NOT_NULL_FLAG))
 
3182
      {
 
3183
        seg->null_bit= key_field->null_bit;
 
3184
        seg->null_pos= (uint32_t) (key_field->null_ptr - (unsigned char*) record[0]);
 
3185
        /*
 
3186
          We are using a GROUP BY on something that contains NULL
 
3187
          In this case we have to tell MyISAM that two NULL should
 
3188
          on INSERT be regarded at the same value
 
3189
        */
 
3190
        if (!using_unique_constraint)
 
3191
          keydef.flag|= HA_NULL_ARE_EQUAL;
 
3192
      }
 
3193
    }
 
3194
  }
 
3195
  MI_CREATE_INFO create_info;
 
3196
  memset(&create_info, 0, sizeof(create_info));
 
3197
 
 
3198
  if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
 
3199
      OPTION_BIG_TABLES)
 
3200
    create_info.data_file_length= ~(uint64_t) 0;
 
3201
 
 
3202
  if ((error=mi_create(share->table_name.str, share->keys, &keydef,
 
3203
                       (uint32_t) (*recinfo-start_recinfo),
 
3204
                       start_recinfo,
 
3205
                       share->uniques, &uniquedef,
 
3206
                       &create_info,
 
3207
                       HA_CREATE_TMP_TABLE)))
 
3208
  {
 
3209
    file->print_error(error,MYF(0));
 
3210
    db_stat= 0;
 
3211
    goto err;
 
3212
  }
 
3213
  status_var_increment(in_use->status_var.created_tmp_disk_tables);
 
3214
  share->db_record_offset= 1;
 
3215
  return false;
 
3216
 err:
 
3217
  return true;
 
3218
}
 
3219
 
 
3220
 
 
3221
void Table::free_tmp_table(Session *session)
 
3222
{
 
3223
  MEM_ROOT own_root= mem_root;
 
3224
  const char *save_proc_info;
 
3225
 
 
3226
  save_proc_info=session->get_proc_info();
 
3227
  session->set_proc_info("removing tmp table");
 
3228
 
 
3229
  // Release latches since this can take a long time
 
3230
  ha_release_temporary_latches(session);
 
3231
 
 
3232
  if (file)
 
3233
  {
 
3234
    if (db_stat)
 
3235
      file->ha_drop_table(s->table_name.str);
 
3236
    else
 
3237
      s->db_type()->deleteTable(session, s->table_name.str);
 
3238
    delete file;
 
3239
  }
 
3240
 
 
3241
  /* free blobs */
 
3242
  for (Field **ptr= field ; *ptr ; ptr++)
 
3243
    (*ptr)->free();
 
3244
  free_io_cache();
 
3245
 
 
3246
  free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
 
3247
  session->set_proc_info(save_proc_info);
 
3248
}
 
3249
 
 
3250
/**
 
3251
  If a HEAP table gets full, create a MyISAM table and copy all rows
 
3252
  to this.
 
3253
*/
 
3254
 
 
3255
bool create_myisam_from_heap(Session *session, Table *table,
 
3256
                             MI_COLUMNDEF *start_recinfo,
 
3257
                             MI_COLUMNDEF **recinfo,
 
3258
                             int error, bool ignore_last_dupp_key_error)
 
3259
{
 
3260
  Table new_table;
 
3261
  TableShare share;
 
3262
  const char *save_proc_info;
 
3263
  int write_err;
 
3264
 
 
3265
  if (table->s->db_type() != heap_engine ||
 
3266
      error != HA_ERR_RECORD_FILE_FULL)
 
3267
  {
 
3268
    table->file->print_error(error,MYF(0));
 
3269
    return true;
 
3270
  }
 
3271
 
 
3272
  // Release latches since this can take a long time
 
3273
  ha_release_temporary_latches(session);
 
3274
 
 
3275
  new_table= *table;
 
3276
  share= *table->s;
 
3277
  new_table.s= &share;
 
3278
  new_table.s->storage_engine= myisam_engine;
 
3279
  if (!(new_table.file= get_new_handler(&share, &new_table.mem_root,
 
3280
                                        new_table.s->db_type())))
 
3281
    return true;                                // End of memory
 
3282
 
 
3283
  save_proc_info=session->get_proc_info();
 
3284
  session->set_proc_info("converting HEAP to MyISAM");
 
3285
 
 
3286
  if (new_table.create_myisam_tmp_table(table->key_info, start_recinfo,
 
3287
                                        recinfo, session->lex->select_lex.options |
 
3288
                                        session->options))
 
3289
    goto err2;
 
3290
  if (new_table.open_tmp_table())
 
3291
    goto err1;
 
3292
  if (table->file->indexes_are_disabled())
 
3293
    new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);
 
3294
  table->file->ha_index_or_rnd_end();
 
3295
  table->file->ha_rnd_init(1);
 
3296
  if (table->no_rows)
 
3297
  {
 
3298
    new_table.file->extra(HA_EXTRA_NO_ROWS);
 
3299
    new_table.no_rows=1;
 
3300
  }
 
3301
 
 
3302
  /* HA_EXTRA_WRITE_CACHE can stay until close, no need to disable it */
 
3303
  new_table.file->extra(HA_EXTRA_WRITE_CACHE);
 
3304
 
 
3305
  /*
 
3306
    copy all old rows from heap table to MyISAM table
 
3307
    This is the only code that uses record[1] to read/write but this
 
3308
    is safe as this is a temporary MyISAM table without timestamp/autoincrement.
 
3309
  */
 
3310
  while (!table->file->rnd_next(new_table.record[1]))
 
3311
  {
 
3312
    write_err= new_table.file->ha_write_row(new_table.record[1]);
 
3313
    if (write_err)
 
3314
      goto err;
 
3315
  }
 
3316
  /* copy row that filled HEAP table */
 
3317
  if ((write_err=new_table.file->ha_write_row(table->record[0])))
 
3318
  {
 
3319
    if (new_table.file->is_fatal_error(write_err, HA_CHECK_DUP) ||
 
3320
        !ignore_last_dupp_key_error)
 
3321
      goto err;
 
3322
  }
 
3323
 
 
3324
  /* remove heap table and change to use myisam table */
 
3325
  (void) table->file->ha_rnd_end();
 
3326
  (void) table->file->close();                  // This deletes the table !
 
3327
  delete table->file;
 
3328
  table->file= NULL;
 
3329
  new_table.s= table->s;                       // Keep old share
 
3330
  *table= new_table;
 
3331
  *table->s= share;
 
3332
 
 
3333
  table->file->change_table_ptr(table, table->s);
 
3334
  table->use_all_columns();
 
3335
  if (save_proc_info)
 
3336
  {
 
3337
    const char *new_proc_info=
 
3338
      (!strcmp(save_proc_info,"Copying to tmp table") ?
 
3339
      "Copying to tmp table on disk" : save_proc_info);
 
3340
    session->set_proc_info(new_proc_info);
 
3341
  }
 
3342
  return false;
 
3343
 
 
3344
 err:
 
3345
  table->file->print_error(write_err, MYF(0));
 
3346
  (void) table->file->ha_rnd_end();
 
3347
  (void) new_table.file->close();
 
3348
 err1:
 
3349
  new_table.s->db_type()->deleteTable(session, new_table.s->table_name.str);
 
3350
 err2:
 
3351
  delete new_table.file;
 
3352
  session->set_proc_info(save_proc_info);
 
3353
  table->mem_root= new_table.mem_root;
 
3354
  return true;
 
3355
}
 
3356
 
 
3357
my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)
 
3358
{
 
3359
  my_bitmap_map *old= bitmap->getBitmap();
 
3360
  bitmap->setBitmap(s->all_set.getBitmap());
1418
3361
  return old;
1419
3362
}
1420
3363
 
1421
 
void Table::restore_column_map(const boost::dynamic_bitset<>& old)
 
3364
void Table::restore_column_map(my_bitmap_map *old)
1422
3365
{
1423
 
  for (boost::dynamic_bitset<>::size_type i= 0; i < old.size(); i++)
1424
 
  {
1425
 
    if (old.test(i))
1426
 
    {
1427
 
      read_set->set(i);
1428
 
    }
1429
 
    else
1430
 
    {
1431
 
      read_set->reset(i);
1432
 
    }
1433
 
  }
 
3366
  read_set->setBitmap(old);
1434
3367
}
1435
3368
 
1436
3369
uint32_t Table::find_shortest_key(const key_map *usable_keys)
1439
3372
  uint32_t best= MAX_KEY;
1440
3373
  if (usable_keys->any())
1441
3374
  {
1442
 
    for (uint32_t nr= 0; nr < getShare()->sizeKeys() ; nr++)
 
3375
    for (uint32_t nr= 0; nr < s->keys ; nr++)
1443
3376
    {
1444
3377
      if (usable_keys->test(nr))
1445
3378
      {
1466
3399
{
1467
3400
  for (; *ptr ; ptr++)
1468
3401
  {
1469
 
    if ((*ptr)->cmp_offset(getShare()->rec_buff_length))
 
3402
    if ((*ptr)->cmp_offset(s->rec_buff_length))
1470
3403
      return true;
1471
3404
  }
1472
3405
  return false;
1473
3406
}
1474
3407
 
1475
 
/**
1476
 
   True if the table's input and output record buffers are comparable using
1477
 
   compare_records(TABLE*).
1478
 
 */
1479
 
bool Table::records_are_comparable()
1480
 
{
1481
 
  return ((getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) == 0) ||
1482
 
          write_set->is_subset_of(*read_set));
1483
 
}
1484
 
 
1485
 
/**
1486
 
   Compares the input and outbut record buffers of the table to see if a row
1487
 
   has changed. The algorithm iterates over updated columns and if they are
1488
 
   nullable compares NULL bits in the buffer before comparing actual
1489
 
   data. Special care must be taken to compare only the relevant NULL bits and
1490
 
   mask out all others as they may be undefined. The storage engine will not
1491
 
   and should not touch them.
1492
 
 
1493
 
   @param table The table to evaluate.
1494
 
 
1495
 
   @return true if row has changed.
1496
 
   @return false otherwise.
1497
 
*/
1498
 
bool Table::compare_records()
1499
 
{
1500
 
  if (getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) != 0)
1501
 
  {
1502
 
    /*
1503
 
      Storage engine may not have read all columns of the record.  Fields
1504
 
      (including NULL bits) not in the write_set may not have been read and
1505
 
      can therefore not be compared.
1506
 
    */
1507
 
    for (Field **ptr= this->field ; *ptr != NULL; ptr++)
1508
 
    {
1509
 
      Field *f= *ptr;
1510
 
      if (write_set->test(f->position()))
1511
 
      {
1512
 
        if (f->real_maybe_null())
1513
 
        {
1514
 
          unsigned char null_byte_index= f->null_ptr - record[0];
1515
 
 
1516
 
          if (((record[0][null_byte_index]) & f->null_bit) !=
1517
 
              ((record[1][null_byte_index]) & f->null_bit))
1518
 
            return true;
1519
 
        }
1520
 
        if (f->cmp_binary_offset(getShare()->rec_buff_length))
1521
 
          return true;
1522
 
      }
1523
 
    }
1524
 
    return false;
1525
 
  }
1526
 
 
1527
 
  /*
1528
 
    The storage engine has read all columns, so it's safe to compare all bits
1529
 
    including those not in the write_set. This is cheaper than the
1530
 
    field-by-field comparison done above.
1531
 
  */
1532
 
  if (not getShare()->blob_fields + getShare()->hasVariableWidth())
1533
 
    // Fixed-size record: do bitwise comparison of the records
1534
 
    return memcmp(this->getInsertRecord(), this->getUpdateRecord(), (size_t) getShare()->getRecordLength());
1535
 
 
 
3408
/* Return false if row hasn't changed */
 
3409
 
 
3410
bool Table::compare_record()
 
3411
{
 
3412
  if (s->blob_fields + s->varchar_fields == 0)
 
3413
    return memcmp(this->record[0], this->record[1], (size_t) s->reclength);
1536
3414
  /* Compare null bits */
1537
 
  if (memcmp(null_flags, null_flags + getShare()->rec_buff_length, getShare()->null_bytes))
1538
 
    return true; /* Diff in NULL value */
1539
 
 
 
3415
  if (memcmp(null_flags,
 
3416
             null_flags + s->rec_buff_length,
 
3417
             s->null_bytes))
 
3418
    return true;                                // Diff in NULL value
1540
3419
  /* Compare updated fields */
1541
3420
  for (Field **ptr= field ; *ptr ; ptr++)
1542
3421
  {
1543
 
    if (isWriteSet((*ptr)->position()) &&
1544
 
        (*ptr)->cmp_binary_offset(getShare()->rec_buff_length))
 
3422
    if (isWriteSet((*ptr)->field_index) &&
 
3423
        (*ptr)->cmp_binary_offset(s->rec_buff_length))
1545
3424
      return true;
1546
3425
  }
1547
3426
  return false;
1553
3432
 */
1554
3433
void Table::storeRecord()
1555
3434
{
1556
 
  memcpy(getUpdateRecord(), getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3435
  memcpy(record[1], record[0], (size_t) s->reclength);
1557
3436
}
1558
3437
 
1559
3438
/*
1562
3441
 */
1563
3442
void Table::storeRecordAsInsert()
1564
3443
{
1565
 
  assert(insert_values.size() >= getShare()->getRecordLength());
1566
 
  memcpy(&insert_values[0], getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3444
  memcpy(insert_values, record[0], (size_t) s->reclength);
1567
3445
}
1568
3446
 
1569
3447
/*
1572
3450
 */
1573
3451
void Table::storeRecordAsDefault()
1574
3452
{
1575
 
  memcpy(getMutableShare()->getDefaultValues(), getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3453
  memcpy(s->default_values, record[0], (size_t) s->reclength);
1576
3454
}
1577
3455
 
1578
3456
/*
1581
3459
 */
1582
3460
void Table::restoreRecord()
1583
3461
{
1584
 
  memcpy(getInsertRecord(), getUpdateRecord(), (size_t) getShare()->getRecordLength());
 
3462
  memcpy(record[0], record[1], (size_t) s->reclength);
1585
3463
}
1586
3464
 
1587
3465
/*
1590
3468
 */
1591
3469
void Table::restoreRecordAsDefault()
1592
3470
{
1593
 
  memcpy(getInsertRecord(), getMutableShare()->getDefaultValues(), (size_t) getShare()->getRecordLength());
 
3471
  memcpy(record[0], s->default_values, (size_t) s->reclength);
1594
3472
}
1595
3473
 
1596
3474
/*
1600
3478
void Table::emptyRecord()
1601
3479
{
1602
3480
  restoreRecordAsDefault();
1603
 
  memset(null_flags, 255, getShare()->null_bytes);
1604
 
}
1605
 
 
1606
 
Table::Table() : 
1607
 
  field(NULL),
1608
 
  cursor(NULL),
1609
 
  next(NULL),
1610
 
  prev(NULL),
1611
 
  read_set(NULL),
1612
 
  write_set(NULL),
1613
 
  tablenr(0),
1614
 
  db_stat(0),
1615
 
  def_read_set(),
1616
 
  def_write_set(),
1617
 
  tmp_set(),
1618
 
  in_use(NULL),
1619
 
  key_info(NULL),
1620
 
  next_number_field(NULL),
1621
 
  found_next_number_field(NULL),
1622
 
  timestamp_field(NULL),
1623
 
  pos_in_table_list(NULL),
1624
 
  group(NULL),
1625
 
  null_flags(NULL),
1626
 
  lock_position(0),
1627
 
  lock_data_start(0),
1628
 
  lock_count(0),
1629
 
  used_fields(0),
1630
 
  status(0),
1631
 
  derived_select_number(0),
1632
 
  current_lock(F_UNLCK),
1633
 
  copy_blobs(false),
1634
 
  maybe_null(false),
1635
 
  null_row(false),
1636
 
  force_index(false),
1637
 
  distinct(false),
1638
 
  const_table(false),
1639
 
  no_rows(false),
1640
 
  key_read(false),
1641
 
  no_keyread(false),
1642
 
  open_placeholder(false),
1643
 
  locked_by_name(false),
1644
 
  no_cache(false),
1645
 
  auto_increment_field_not_null(false),
1646
 
  alias_name_used(false),
1647
 
  query_id(0),
1648
 
  quick_condition_rows(0),
1649
 
  timestamp_field_type(TIMESTAMP_NO_AUTO_SET),
1650
 
  map(0),
1651
 
  quick_rows(),
1652
 
  const_key_parts(),
1653
 
  quick_key_parts(),
1654
 
  quick_n_ranges()
1655
 
{
1656
 
  record[0]= (unsigned char *) 0;
1657
 
  record[1]= (unsigned char *) 0;
 
3481
  memset(null_flags, 255, s->null_bytes);
1658
3482
}
1659
3483
 
1660
3484
/*****************************************************************************
1662
3486
  Returns -1 if row was not found, 0 if row was found and 1 on errors
1663
3487
*****************************************************************************/
1664
3488
 
1665
 
/** Help function when we get some an error from the table Cursor. */
 
3489
/** Help function when we get some an error from the table handler. */
1666
3490
 
1667
3491
int Table::report_error(int error)
1668
3492
{
1676
3500
    print them to the .err log
1677
3501
  */
1678
3502
  if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT)
1679
 
    errmsg_printf(error::ERROR, _("Got error %d when reading table '%s'"),
1680
 
                  error, getShare()->getPath());
1681
 
  print_error(error, MYF(0));
 
3503
    errmsg_printf(ERRMSG_LVL_ERROR, _("Got error %d when reading table '%s'"),
 
3504
                    error, s->path.str);
 
3505
  file->print_error(error,MYF(0));
1682
3506
 
1683
3507
  return 1;
1684
3508
}
1691
3515
  null_row= 0;
1692
3516
  status= STATUS_NO_RECORD;
1693
3517
  maybe_null= table_list->outer_join;
1694
 
  TableList *embedding= table_list->getEmbedding();
 
3518
  TableList *embedding= table_list->embedding;
1695
3519
  while (!maybe_null && embedding)
1696
3520
  {
1697
3521
    maybe_null= embedding->outer_join;
1698
 
    embedding= embedding->getEmbedding();
 
3522
    embedding= embedding->embedding;
1699
3523
  }
1700
3524
  tablenr= table_number;
1701
3525
  map= (table_map) 1 << table_number;
1702
3526
  force_index= table_list->force_index;
1703
 
  covering_keys= getShare()->keys_for_keyread;
 
3527
  covering_keys= s->keys_for_keyread;
1704
3528
  merge_keys.reset();
1705
3529
}
1706
3530
 
1707
 
 
1708
 
bool Table::fill_item_list(List<Item> *item_list) const
1709
 
{
1710
 
  /*
1711
 
    All Item_field's created using a direct pointer to a field
1712
 
    are fixed in Item_field constructor.
1713
 
  */
1714
 
  for (Field **ptr= field; *ptr; ptr++)
1715
 
  {
1716
 
    Item_field *item= new Item_field(*ptr);
1717
 
    if (!item || item_list->push_back(item))
1718
 
      return true;
1719
 
  }
1720
 
  return false;
1721
 
}
1722
 
 
1723
 
 
1724
 
void Table::filesort_free_buffers(bool full)
1725
 
{
1726
 
  if (sort.record_pointers)
1727
 
  {
1728
 
    free((unsigned char*) sort.record_pointers);
1729
 
    sort.record_pointers=0;
1730
 
  }
1731
 
  if (full)
1732
 
  {
1733
 
    if (sort.sort_keys )
1734
 
    {
1735
 
      if ((unsigned char*) sort.sort_keys)
1736
 
        free((unsigned char*) sort.sort_keys);
1737
 
      sort.sort_keys= 0;
1738
 
    }
1739
 
    if (sort.buffpek)
1740
 
    {
1741
 
      if ((unsigned char*) sort.buffpek)
1742
 
        free((unsigned char*) sort.buffpek);
1743
 
      sort.buffpek= 0;
1744
 
      sort.buffpek_len= 0;
1745
 
    }
1746
 
  }
1747
 
 
1748
 
  if (sort.addon_buf)
1749
 
  {
1750
 
    free((char *) sort.addon_buf);
1751
 
    free((char *) sort.addon_field);
1752
 
    sort.addon_buf=0;
1753
 
    sort.addon_field=0;
1754
 
  }
1755
 
}
 
3531
Field *Table::find_field_in_table_sef(const char *name)
 
3532
{
 
3533
  Field **field_ptr;
 
3534
  if (s->name_hash.records)
 
3535
  {
 
3536
    field_ptr= (Field**)hash_search(&s->name_hash,(unsigned char*) name,
 
3537
                                    strlen(name));
 
3538
    if (field_ptr)
 
3539
    {
 
3540
      /*
 
3541
        field_ptr points to field in TableShare. Convert it to the matching
 
3542
        field in table
 
3543
      */
 
3544
      field_ptr= (field + (field_ptr - s->field));
 
3545
    }
 
3546
  }
 
3547
  else
 
3548
  {
 
3549
    if (!(field_ptr= field))
 
3550
      return (Field *)0;
 
3551
    for (; *field_ptr; ++field_ptr)
 
3552
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
 
3553
        break;
 
3554
  }
 
3555
  if (field_ptr)
 
3556
    return *field_ptr;
 
3557
  else
 
3558
    return (Field *)0;
 
3559
}
 
3560
 
1756
3561
 
1757
3562
/*
1758
 
  Is this instance of the table should be reopen or represents a name-lock?
 
3563
  Used by ALTER Table when the table is a temporary one. It changes something
 
3564
  only if the ALTER contained a RENAME clause (otherwise, table_name is the old
 
3565
  name).
 
3566
  Prepares a table cache key, which is the concatenation of db, table_name and
 
3567
  session->slave_proxy_id, separated by '\0'.
1759
3568
*/
1760
 
bool Table::needs_reopen_or_name_lock() const
1761
 
{ 
1762
 
  return getShare()->getVersion() != refresh_version;
1763
 
}
1764
 
 
1765
 
uint32_t Table::index_flags(uint32_t idx) const
1766
 
{
1767
 
  return getShare()->getEngine()->index_flags(getShare()->getKeyInfo(idx).algorithm);
1768
 
}
1769
 
 
1770
 
void Table::print_error(int error, myf errflag) const
1771
 
{
1772
 
  getShare()->getEngine()->print_error(error, errflag, *this);
1773
 
}
1774
 
 
1775
 
} /* namespace drizzled */
 
3569
 
 
3570
bool Table::rename_temporary_table(const char *db, const char *table_name)
 
3571
{
 
3572
  char *key;
 
3573
  uint32_t key_length;
 
3574
  TableShare *share= s;
 
3575
 
 
3576
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
 
3577
    return true;
 
3578
 
 
3579
  key_length= TableShare::createKey(key, db, table_name);
 
3580
  share->set_table_cache_key(key, key_length);
 
3581
 
 
3582
  return false;
 
3583
}
 
3584
 
 
3585
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
3586
template class List<String>;
 
3587
template class List_iterator<String>;
 
3588
#endif