← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

Rename of handler to Cursor.  You would not believe how long I have wanted
to do that.

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
  Cursor *handler_file= NULL;
 
281
 
 
282
  share->setTableProto(new(nothrow) message::Table(table));
 
283
 
 
284
  share->storage_engine= plugin::StorageEngine::findByName(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; //Cursor->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= share->db_type()->getCursor(share, session->mem_root)))
 
966
    abort(); // FIXME
 
967
 
 
968
  /* Fix key stuff */
 
969
  if (share->key_parts)
 
970
  {
 
971
    uint32_t primary_key= (uint32_t) (find_type((char*) "PRIMARY",
 
972
                                                &share->keynames, 3) - 1); /* @TODO Huh? */
 
973
 
 
974
    int64_t ha_option= handler_file->ha_table_flags();
 
975
 
 
976
    keyinfo= share->key_info;
 
977
    key_part= keyinfo->key_part;
 
978
 
 
979
    for (uint32_t key= 0; key < share->keys; key++,keyinfo++)
 
980
    {
 
981
      uint32_t usable_parts= 0;
 
982
 
 
983
      if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
 
984
      {
 
985
        /*
 
986
          If the UNIQUE key doesn't have NULL columns and is not a part key
 
987
          declare this as a primary key.
 
988
        */
 
989
        primary_key=key;
 
990
        for (uint32_t i= 0; i < keyinfo->key_parts; i++)
 
991
        {
 
992
          uint32_t fieldnr= key_part[i].fieldnr;
 
993
          if (! fieldnr ||
 
994
              share->field[fieldnr-1]->null_ptr ||
 
995
              share->field[fieldnr-1]->key_length() != key_part[i].length)
 
996
          {
 
997
            primary_key= MAX_KEY; // Can't be used
 
998
            break;
 
999
          }
 
1000
        }
 
1001
      }
 
1002
 
 
1003
      for (uint32_t i= 0 ; i < keyinfo->key_parts ; key_part++,i++)
 
1004
      {
 
1005
        Field *field;
 
1006
        if (! key_part->fieldnr)
 
1007
        {
 
1008
          abort(); // goto err;
 
1009
        }
 
1010
        field= key_part->field= share->field[key_part->fieldnr-1];
 
1011
        key_part->type= field->key_type();
 
1012
        if (field->null_ptr)
 
1013
        {
 
1014
          key_part->null_offset=(uint32_t) ((unsigned char*) field->null_ptr -
 
1015
                                        share->default_values);
 
1016
          key_part->null_bit= field->null_bit;
 
1017
          key_part->store_length+=HA_KEY_NULL_LENGTH;
 
1018
          keyinfo->flags|=HA_NULL_PART_KEY;
 
1019
          keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
 
1020
          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
 
1021
        }
 
1022
        if (field->type() == DRIZZLE_TYPE_BLOB ||
 
1023
            field->real_type() == DRIZZLE_TYPE_VARCHAR)
 
1024
        {
 
1025
          if (field->type() == DRIZZLE_TYPE_BLOB)
 
1026
            key_part->key_part_flag|= HA_BLOB_PART;
 
1027
          else
 
1028
            key_part->key_part_flag|= HA_VAR_LENGTH_PART;
 
1029
          keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
 
1030
          key_part->store_length+=HA_KEY_BLOB_LENGTH;
 
1031
          keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
 
1032
        }
 
1033
        if (i == 0 && key != primary_key)
 
1034
          field->flags |= (((keyinfo->flags & HA_NOSAME) &&
 
1035
                           (keyinfo->key_parts == 1)) ?
 
1036
                           UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
 
1037
        if (i == 0)
 
1038
          field->key_start.set(key);
 
1039
        if (field->key_length() == key_part->length &&
 
1040
            !(field->flags & BLOB_FLAG))
 
1041
        {
 
1042
          if (handler_file->index_flags(key, i, 0) & HA_KEYREAD_ONLY)
 
1043
          {
 
1044
            share->keys_for_keyread.set(key);
 
1045
            field->part_of_key.set(key);
 
1046
            field->part_of_key_not_clustered.set(key);
 
1047
          }
 
1048
          if (handler_file->index_flags(key, i, 1) & HA_READ_ORDER)
 
1049
            field->part_of_sortkey.set(key);
 
1050
        }
 
1051
        if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
 
1052
            usable_parts == i)
 
1053
          usable_parts++;                       // For FILESORT
 
1054
        field->flags|= PART_KEY_FLAG;
 
1055
        if (key == primary_key)
 
1056
        {
 
1057
          field->flags|= PRI_KEY_FLAG;
 
1058
          /*
 
1059
            If this field is part of the primary key and all keys contains
 
1060
            the primary key, then we can use any key to find this column
 
1061
          */
 
1062
          if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
 
1063
          {
 
1064
            field->part_of_key= share->keys_in_use;
 
1065
            if (field->part_of_sortkey.test(key))
 
1066
              field->part_of_sortkey= share->keys_in_use;
 
1067
          }
 
1068
        }
 
1069
        if (field->key_length() != key_part->length)
 
1070
        {
 
1071
          key_part->key_part_flag|= HA_PART_KEY_SEG;
 
1072
        }
 
1073
      }
 
1074
      keyinfo->usable_key_parts= usable_parts; // Filesort
 
1075
 
 
1076
      set_if_bigger(share->max_key_length,keyinfo->key_length+
 
1077
                    keyinfo->key_parts);
 
1078
      share->total_key_length+= keyinfo->key_length;
 
1079
      /*
 
1080
        MERGE tables do not have unique indexes. But every key could be
 
1081
        an unique index on the underlying MyISAM table. (Bug #10400)
 
1082
      */
 
1083
      if ((keyinfo->flags & HA_NOSAME) ||
 
1084
          (ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
 
1085
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
 
1086
    }
 
1087
    if (primary_key < MAX_KEY &&
 
1088
        (share->keys_in_use.test(primary_key)))
 
1089
    {
 
1090
      share->primary_key= primary_key;
 
1091
      /*
 
1092
        If we are using an integer as the primary key then allow the user to
 
1093
        refer to it as '_rowid'
 
1094
      */
 
1095
      if (share->key_info[primary_key].key_parts == 1)
 
1096
      {
 
1097
        Field *field= share->key_info[primary_key].key_part[0].field;
 
1098
        if (field && field->result_type() == INT_RESULT)
 
1099
        {
 
1100
          /* note that fieldnr here (and rowid_field_offset) starts from 1 */
 
1101
          share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
 
1102
                                      fieldnr);
 
1103
        }
 
1104
      }
 
1105
    }
 
1106
    else
 
1107
      share->primary_key = MAX_KEY; // we do not have a primary key
 
1108
  }
 
1109
  else
 
1110
    share->primary_key= MAX_KEY;
 
1111
 
 
1112
  if (share->found_next_number_field)
 
1113
  {
 
1114
    Field *reg_field= *share->found_next_number_field;
 
1115
    if ((int) (share->next_number_index= (uint32_t)
 
1116
               find_ref_key(share->key_info, share->keys,
 
1117
                            share->default_values, reg_field,
 
1118
                            &share->next_number_key_offset,
 
1119
                            &share->next_number_keypart)) < 0)
 
1120
    {
 
1121
      /* Wrong field definition */
 
1122
      error= 4;
 
1123
      goto err;
 
1124
    }
 
1125
    else
 
1126
      reg_field->flags |= AUTO_INCREMENT_FLAG;
 
1127
  }
 
1128
 
 
1129
  if (share->blob_fields)
 
1130
  {
 
1131
    Field **ptr;
 
1132
    uint32_t k, *save;
 
1133
 
 
1134
    /* Store offsets to blob fields to find them fast */
 
1135
    if (!(share->blob_field= save=
 
1136
          (uint*) alloc_root(&share->mem_root,
 
1137
                             (uint32_t) (share->blob_fields* sizeof(uint32_t)))))
 
1138
      goto err;
 
1139
    for (k= 0, ptr= share->field ; *ptr ; ptr++, k++)
 
1140
    {
 
1141
      if ((*ptr)->flags & BLOB_FLAG)
 
1142
        (*save++)= k;
 
1143
    }
 
1144
  }
 
1145
 
 
1146
  share->db_low_byte_first= handler_file->low_byte_first();
 
1147
  share->column_bitmap_size= bitmap_buffer_size(share->fields);
 
1148
 
 
1149
  my_bitmap_map *bitmaps;
 
1150
 
 
1151
  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
 
1152
                                             share->column_bitmap_size)))
 
1153
    goto err;
 
1154
  share->all_set.init(bitmaps, share->fields);
 
1155
  share->all_set.setAll();
 
1156
 
 
1157
  if (handler_file)
 
1158
    delete handler_file;
 
1159
  return (0);
 
1160
 
 
1161
err:
 
1162
  share->error= error;
 
1163
  share->open_errno= my_errno;
 
1164
  share->errarg= 0;
 
1165
  hash_free(&share->name_hash);
 
1166
  if (handler_file)
 
1167
    delete handler_file;
 
1168
  share->open_table_error(error, share->open_errno, 0);
 
1169
 
 
1170
  return error;
 
1171
}
 
1172
 
 
1173
/*
 
1174
  Read table definition from a binary / text based .frm file
 
1175
 
 
1176
  SYNOPSIS
 
1177
  open_table_def()
 
1178
  session               Thread Cursor
 
1179
  share         Fill this with table definition
 
1180
 
 
1181
  NOTES
 
1182
    This function is called when the table definition is not cached in
 
1183
    table_def_cache
 
1184
    The data is returned in 'share', which is alloced by
 
1185
    alloc_table_share().. The code assumes that share is initialized.
 
1186
 
 
1187
  RETURN VALUES
 
1188
   0    ok
 
1189
   1    Error (see open_table_error)
 
1190
   2    Error (see open_table_error)
 
1191
   3    Wrong data in .frm file
 
1192
   4    Error (see open_table_error)
 
1193
   5    Error (see open_table_error: charset unavailable)
 
1194
   6    Unknown .frm version
 
1195
*/
 
1196
 
 
1197
int open_table_def(Session *session, TableShare *share)
 
1198
{
 
1199
  int error;
 
1200
  bool error_given;
 
1201
 
 
1202
  error= 1;
 
1203
  error_given= 0;
 
1204
 
 
1205
  message::Table table;
 
1206
 
 
1207
  error= plugin::StorageEngine::getTableProto(share->normalized_path.str,
 
1208
                                              &table);
 
1209
 
 
1210
  if (error != EEXIST)
 
1211
  {
 
1212
    if (error>0)
 
1213
    {
 
1214
      my_errno= error;
 
1215
      error= 1;
 
1216
    }
 
1217
    else
 
1218
    {
 
1219
      if (!table.IsInitialized())
 
1220
      {
 
1221
        error= 4;
 
1222
      }
 
1223
    }
 
1224
    goto err_not_open;
 
1225
  }
 
1226
 
 
1227
  error= parse_table_proto(session, table, share);
 
1228
 
 
1229
  share->table_category= get_table_category(& share->db);
 
1230
 
 
1231
  if (!error)
 
1232
    session->status_var.opened_shares++;
 
1233
 
 
1234
err_not_open:
 
1235
  if (error && !error_given)
 
1236
  {
 
1237
    share->error= error;
 
1238
    share->open_table_error(error, (share->open_errno= my_errno), 0);
 
1239
  }
 
1240
 
 
1241
  return(error);
 
1242
}
 
1243
 
 
1244
 
 
1245
/*
 
1246
  Open a table based on a TableShare
 
1247
 
 
1248
  SYNOPSIS
 
1249
    open_table_from_share()
 
1250
    session                     Thread Cursor
 
1251
    share               Table definition
 
1252
    alias               Alias for table
 
1253
    db_stat             open flags (for example HA_OPEN_KEYFILE|
 
1254
                        HA_OPEN_RNDFILE..) can be 0 (example in
 
1255
                        ha_example_table)
 
1256
    prgflag             READ_ALL etc..
 
1257
    ha_open_flags       HA_OPEN_ABORT_IF_LOCKED etc..
 
1258
    outparam            result table
 
1259
    open_mode           One of OTM_OPEN|OTM_CREATE|OTM_ALTER
 
1260
                        if OTM_CREATE some errors are ignore
 
1261
                        if OTM_ALTER HA_OPEN is not called
 
1262
 
 
1263
  RETURN VALUES
 
1264
   0    ok
 
1265
   1    Error (see open_table_error)
 
1266
   2    Error (see open_table_error)
 
1267
   3    Wrong data in .frm file
 
1268
   4    Error (see open_table_error)
 
1269
   5    Error (see open_table_error: charset unavailable)
 
1270
   7    Table definition has changed in engine
 
1271
*/
 
1272
 
 
1273
int open_table_from_share(Session *session, TableShare *share, const char *alias,
 
1274
                          uint32_t db_stat, uint32_t prgflag, uint32_t ha_open_flags,
 
1275
                          Table *outparam, open_table_mode open_mode)
 
1276
{
 
1277
  int error;
 
1278
  uint32_t records, i, bitmap_size;
 
1279
  bool error_reported= false;
 
1280
  unsigned char *record, *bitmaps;
 
1281
  Field **field_ptr;
 
1282
 
 
1283
  /* Parsing of partitioning information from .frm needs session->lex set up. */
 
1284
  assert(session->lex->is_lex_started);
 
1285
 
 
1286
  error= 1;
 
1287
  outparam->resetTable(session, share, db_stat);
 
1288
 
 
1289
 
 
1290
  if (!(outparam->alias= strdup(alias)))
 
1291
    goto err;
 
1292
 
 
1293
  /* Allocate Cursor */
 
1294
  if (!(prgflag & OPEN_FRM_FILE_ONLY))
 
1295
  {
 
1296
    if (!(outparam->file= share->db_type()->getCursor(share, &outparam->mem_root)))
 
1297
      goto err;
 
1298
  }
 
1299
  else
 
1300
  {
 
1301
    assert(!db_stat);
 
1302
  }
 
1303
 
 
1304
  error= 4;
 
1305
  records= 0;
 
1306
  if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN))
 
1307
    records=1;
 
1308
  if (prgflag & (READ_ALL+EXTRA_RECORD))
 
1309
    records++;
 
1310
 
 
1311
  if (!(record= (unsigned char*) alloc_root(&outparam->mem_root,
 
1312
                                   share->rec_buff_length * records)))
 
1313
    goto err;
 
1314
 
 
1315
  if (records == 0)
 
1316
  {
 
1317
    /* We are probably in hard repair, and the buffers should not be used */
 
1318
    outparam->record[0]= outparam->record[1]= share->default_values;
 
1319
  }
 
1320
  else
 
1321
  {
 
1322
    outparam->record[0]= record;
 
1323
    if (records > 1)
 
1324
      outparam->record[1]= record+ share->rec_buff_length;
 
1325
    else
 
1326
      outparam->record[1]= outparam->record[0];   // Safety
 
1327
  }
 
1328
 
 
1329
#ifdef HAVE_purify
 
1330
  /*
 
1331
    We need this because when we read var-length rows, we are not updating
 
1332
    bytes after end of varchar
 
1333
  */
 
1334
  if (records > 1)
 
1335
  {
 
1336
    memcpy(outparam->record[0], share->default_values, share->rec_buff_length);
 
1337
    memcpy(outparam->record[1], share->default_values, share->null_bytes);
 
1338
    if (records > 2)
 
1339
      memcpy(outparam->record[1], share->default_values,
 
1340
             share->rec_buff_length);
 
1341
  }
 
1342
#endif
 
1343
 
 
1344
  if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
 
1345
                                          (uint32_t) ((share->fields+1)*
 
1346
                                                  sizeof(Field*)))))
 
1347
    goto err;
 
1348
 
 
1349
  outparam->field= field_ptr;
 
1350
 
 
1351
  record= (unsigned char*) outparam->record[0]-1;       /* Fieldstart = 1 */
 
1352
 
 
1353
  outparam->null_flags= (unsigned char*) record+1;
 
1354
 
 
1355
  /* Setup copy of fields from share, but use the right alias and record */
 
1356
  for (i= 0 ; i < share->fields; i++, field_ptr++)
 
1357
  {
 
1358
    if (!((*field_ptr)= share->field[i]->clone(&outparam->mem_root, outparam)))
 
1359
      goto err;
 
1360
  }
 
1361
  (*field_ptr)= 0;                              // End marker
 
1362
 
 
1363
  if (share->found_next_number_field)
 
1364
    outparam->found_next_number_field=
 
1365
      outparam->field[(uint32_t) (share->found_next_number_field - share->field)];
 
1366
  if (share->timestamp_field)
 
1367
    outparam->timestamp_field= (Field_timestamp*) outparam->field[share->timestamp_field_offset];
 
1368
 
 
1369
 
 
1370
  /* Fix key->name and key_part->field */
 
1371
  if (share->key_parts)
 
1372
  {
 
1373
    KEY *key_info, *key_info_end;
 
1374
    KEY_PART_INFO *key_part;
 
1375
    uint32_t n_length;
 
1376
    n_length= share->keys*sizeof(KEY) + share->key_parts*sizeof(KEY_PART_INFO);
 
1377
    if (!(key_info= (KEY*) alloc_root(&outparam->mem_root, n_length)))
 
1378
      goto err;
 
1379
    outparam->key_info= key_info;
 
1380
    key_part= (reinterpret_cast<KEY_PART_INFO*> (key_info+share->keys));
 
1381
 
 
1382
    memcpy(key_info, share->key_info, sizeof(*key_info)*share->keys);
 
1383
    memcpy(key_part, share->key_info[0].key_part, (sizeof(*key_part) *
 
1384
                                                   share->key_parts));
 
1385
 
 
1386
    for (key_info_end= key_info + share->keys ;
 
1387
         key_info < key_info_end ;
 
1388
         key_info++)
 
1389
    {
 
1390
      KEY_PART_INFO *key_part_end;
 
1391
 
 
1392
      key_info->table= outparam;
 
1393
      key_info->key_part= key_part;
 
1394
 
 
1395
      for (key_part_end= key_part+ key_info->key_parts ;
 
1396
           key_part < key_part_end ;
 
1397
           key_part++)
 
1398
      {
 
1399
        Field *field= key_part->field= outparam->field[key_part->fieldnr-1];
 
1400
 
 
1401
        if (field->key_length() != key_part->length &&
 
1402
            !(field->flags & BLOB_FLAG))
 
1403
        {
 
1404
          /*
 
1405
            We are using only a prefix of the column as a key:
 
1406
            Create a new field for the key part that matches the index
 
1407
          */
 
1408
          field= key_part->field=field->new_field(&outparam->mem_root,
 
1409
                                                  outparam, 0);
 
1410
          field->field_length= key_part->length;
 
1411
        }
 
1412
      }
 
1413
    }
 
1414
  }
 
1415
 
 
1416
  /* Allocate bitmaps */
 
1417
 
 
1418
  bitmap_size= share->column_bitmap_size;
 
1419
  if (!(bitmaps= (unsigned char*) alloc_root(&outparam->mem_root, bitmap_size*3)))
 
1420
    goto err;
 
1421
  outparam->def_read_set.init((my_bitmap_map*) bitmaps, share->fields);
 
1422
  outparam->def_write_set.init((my_bitmap_map*) (bitmaps+bitmap_size), share->fields);
 
1423
  outparam->tmp_set.init((my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields);
 
1424
  outparam->default_column_bitmaps();
 
1425
 
 
1426
  /* The table struct is now initialized;  Open the table */
 
1427
  error= 2;
 
1428
  if (db_stat && open_mode != OTM_ALTER)
 
1429
  {
 
1430
    int ha_err;
 
1431
    if ((ha_err= (outparam->file->
 
1432
                  ha_open(outparam, share->normalized_path.str,
 
1433
                          (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
 
1434
                          (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
 
1435
                           (db_stat & HA_WAIT_IF_LOCKED) ?  HA_OPEN_WAIT_IF_LOCKED :
 
1436
                           (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
 
1437
                          HA_OPEN_ABORT_IF_LOCKED :
 
1438
                           HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
 
1439
    {
 
1440
      /* Set a flag if the table is crashed and it can be auto. repaired */
 
1441
      share->crashed= ((ha_err == HA_ERR_CRASHED_ON_USAGE) &&
 
1442
                       outparam->file->auto_repair() &&
 
1443
                       !(ha_open_flags & HA_OPEN_FOR_REPAIR));
 
1444
 
 
1445
      switch (ha_err)
 
1446
      {
 
1447
        case HA_ERR_NO_SUCH_TABLE:
 
1448
          /*
 
1449
            The table did not exists in storage engine, use same error message
 
1450
            as if the .frm file didn't exist
 
1451
          */
 
1452
          error= 1;
 
1453
          my_errno= ENOENT;
 
1454
          break;
 
1455
        case EMFILE:
 
1456
          /*
 
1457
            Too many files opened, use same error message as if the .frm
 
1458
            file can't open
 
1459
           */
 
1460
          error= 1;
 
1461
          my_errno= EMFILE;
 
1462
          break;
 
1463
        default:
 
1464
          outparam->file->print_error(ha_err, MYF(0));
 
1465
          error_reported= true;
 
1466
          if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
 
1467
            error= 7;
 
1468
          break;
 
1469
      }
 
1470
      goto err;
 
1471
    }
 
1472
  }
 
1473
 
 
1474
#if defined(HAVE_purify)
 
1475
  memset(bitmaps, 0, bitmap_size*3);
 
1476
#endif
 
1477
 
 
1478
  session->status_var.opened_tables++;
 
1479
 
 
1480
  return (0);
 
1481
 
 
1482
 err:
 
1483
  if (!error_reported && !(prgflag & DONT_GIVE_ERROR))
 
1484
    share->open_table_error(error, my_errno, 0);
 
1485
  delete outparam->file;
 
1486
  outparam->file= 0;                            // For easier error checking
 
1487
  outparam->db_stat= 0;
 
1488
  free_root(&outparam->mem_root, MYF(0));       // Safe to call on zeroed root
 
1489
  free((char*) outparam->alias);
 
1490
  return (error);
 
1491
}
 
1492
 
 
1493
/*
 
1494
  Free information allocated by openfrm
 
1495
 
 
1496
  SYNOPSIS
 
1497
    closefrm()
 
1498
    table               Table object to free
 
1499
    free_share          Is 1 if we also want to free table_share
 
1500
*/
 
1501
 
 
1502
int Table::closefrm(bool free_share)
78
1503
{
79
1504
  int error= 0;
80
1505
 
81
1506
  if (db_stat)
82
 
    error= cursor->close();
83
 
  _alias.clear();
84
 
 
 
1507
    error= file->close();
 
1508
  free((char*) alias);
 
1509
  alias= NULL;
85
1510
  if (field)
86
1511
  {
87
1512
    for (Field **ptr=field ; *ptr ; ptr++)
88
 
    {
89
1513
      delete *ptr;
90
 
    }
91
1514
    field= 0;
92
1515
  }
93
 
  delete cursor;
94
 
  cursor= 0;                            /* For easier errorchecking */
95
 
 
 
1516
  delete file;
 
1517
  file= 0;                              /* For easier errorchecking */
96
1518
  if (free_share)
97
1519
  {
98
 
    release();
 
1520
    if (s->tmp_table == NO_TMP_TABLE)
 
1521
      TableShare::release(s);
 
1522
    else
 
1523
      s->free_table_share();
99
1524
  }
 
1525
  free_root(&mem_root, MYF(0));
100
1526
 
101
1527
  return error;
102
1528
}
103
1529
 
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
1530
 
198
1531
/* Deallocate temporary blob storage */
199
1532
 
203
1536
  for (ptr= table->getBlobField(), end=ptr + table->sizeBlobFields();
204
1537
       ptr != end ;
205
1538
       ptr++)
206
 
  {
207
 
    ((Field_blob*) table->getField(*ptr))->free();
208
 
  }
 
1539
    ((Field_blob*) table->field[*ptr])->free();
209
1540
}
210
1541
 
211
1542
 
212
 
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings)
213
 
{
214
 
  TYPELIB *result= (TYPELIB*) mem_root->alloc_root(sizeof(TYPELIB));
 
1543
        /* error message when opening a form file */
 
1544
 
 
1545
void TableShare::open_table_error(int pass_error, int db_errno, int pass_errarg)
 
1546
{
 
1547
  int err_no;
 
1548
  char buff[FN_REFLEN];
 
1549
  myf errortype= ME_ERROR+ME_WAITTANG;
 
1550
 
 
1551
  switch (pass_error) {
 
1552
  case 7:
 
1553
  case 1:
 
1554
    if (db_errno == ENOENT)
 
1555
      my_error(ER_NO_SUCH_TABLE, MYF(0), db.str, table_name.str);
 
1556
    else
 
1557
    {
 
1558
      sprintf(buff,"%s",normalized_path.str);
 
1559
      my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
 
1560
               errortype, buff, db_errno);
 
1561
    }
 
1562
    break;
 
1563
  case 2:
 
1564
  {
 
1565
    Cursor *file= 0;
 
1566
    const char *datext= "";
 
1567
 
 
1568
    if (db_type() != NULL)
 
1569
    {
 
1570
      if ((file= db_type()->getCursor(this, current_session->mem_root)))
 
1571
      {
 
1572
        if (!(datext= *db_type()->bas_ext()))
 
1573
          datext= "";
 
1574
      }
 
1575
    }
 
1576
    err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
 
1577
      ER_FILE_USED : ER_CANT_OPEN_FILE;
 
1578
    sprintf(buff,"%s%s", normalized_path.str,datext);
 
1579
    my_error(err_no,errortype, buff, db_errno);
 
1580
    delete file;
 
1581
    break;
 
1582
  }
 
1583
  case 5:
 
1584
  {
 
1585
    const char *csname= get_charset_name((uint32_t) pass_errarg);
 
1586
    char tmp[10];
 
1587
    if (!csname || csname[0] =='?')
 
1588
    {
 
1589
      snprintf(tmp, sizeof(tmp), "#%d", pass_errarg);
 
1590
      csname= tmp;
 
1591
    }
 
1592
    my_printf_error(ER_UNKNOWN_COLLATION,
 
1593
                    _("Unknown collation '%s' in table '%-.64s' definition"),
 
1594
                    MYF(0), csname, table_name.str);
 
1595
    break;
 
1596
  }
 
1597
  case 6:
 
1598
    sprintf(buff,"%s", normalized_path.str);
 
1599
    my_printf_error(ER_NOT_FORM_FILE,
 
1600
                    _("Table '%-.64s' was created with a different version "
 
1601
                    "of Drizzle and cannot be read"),
 
1602
                    MYF(0), buff);
 
1603
    break;
 
1604
  case 8:
 
1605
    break;
 
1606
  default:                              /* Better wrong error than none */
 
1607
  case 4:
 
1608
    sprintf(buff,"%s", normalized_path.str);
 
1609
    my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
 
1610
    break;
 
1611
  }
 
1612
  return;
 
1613
} /* open_table_error */
 
1614
 
 
1615
 
 
1616
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings)
 
1617
{
 
1618
  TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
215
1619
  if (!result)
216
1620
    return 0;
217
1621
  result->count= strings.elements;
218
1622
  result->name= "";
219
1623
  uint32_t nbytes= (sizeof(char*) + sizeof(uint32_t)) * (result->count + 1);
220
1624
  
221
 
  if (!(result->type_names= (const char**) mem_root->alloc_root(nbytes)))
 
1625
  if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
222
1626
    return 0;
223
1627
    
224
1628
  result->type_lengths= (uint*) (result->type_names + result->count + 1);
248
1652
  return (nr);
249
1653
} /* set_zone */
250
1654
 
 
1655
        /* Adjust number to next larger disk buffer */
 
1656
 
 
1657
ulong next_io_size(register ulong pos)
 
1658
{
 
1659
  register ulong offset;
 
1660
  if ((offset= pos & (IO_SIZE-1)))
 
1661
    return pos-offset+IO_SIZE;
 
1662
  return pos;
 
1663
} /* next_io_size */
 
1664
 
251
1665
 
252
1666
/*
253
1667
  Store an SQL quoted string.
275
1689
        (mblen= my_ismbchar(default_charset_info, pos, end)))
276
1690
    {
277
1691
      res->append(pos, mblen);
278
 
      pos+= mblen - 1;
 
1692
      pos+= mblen;
279
1693
      if (pos >= end)
280
1694
        break;
281
1695
      continue;
311
1725
}
312
1726
 
313
1727
 
 
1728
/*
 
1729
  Set up column usage bitmaps for a temporary table
 
1730
 
 
1731
  IMPLEMENTATION
 
1732
    For temporary tables, we need one bitmap with all columns set and
 
1733
    a tmp_set bitmap to be used by things like filesort.
 
1734
*/
 
1735
 
 
1736
void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)
 
1737
{
 
1738
  uint32_t field_count= s->fields;
 
1739
 
 
1740
  this->def_read_set.init((my_bitmap_map*) bitmaps, field_count);
 
1741
  this->tmp_set.init((my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);
 
1742
 
 
1743
  /* write_set and all_set are copies of read_set */
 
1744
  def_write_set= def_read_set;
 
1745
  s->all_set= def_read_set;
 
1746
  this->s->all_set.setAll();
 
1747
  default_column_bitmaps();
 
1748
}
 
1749
 
 
1750
 
 
1751
 
 
1752
void Table::updateCreateInfo(HA_CREATE_INFO *create_info,
 
1753
                             message::Table *table_proto)
 
1754
{
 
1755
  message::Table::TableOptions *table_options= table_proto->mutable_options();
 
1756
  create_info->table_options= s->db_create_options;
 
1757
  table_options->set_block_size(s->block_size);
 
1758
  create_info->row_type= s->row_type;
 
1759
  create_info->default_table_charset= s->table_charset;
 
1760
  create_info->table_charset= 0;
 
1761
  table_options->set_comment(s->getComment());
 
1762
}
 
1763
 
314
1764
int rename_file_ext(const char * from,const char * to,const char * ext)
315
1765
{
316
1766
  string from_s, to_s;
319
1769
  from_s.append(ext);
320
1770
  to_s.append(to);
321
1771
  to_s.append(ext);
322
 
  return (internal::my_rename(from_s.c_str(),to_s.c_str(),MYF(MY_WME)));
 
1772
  return (my_rename(from_s.c_str(),to_s.c_str(),MYF(MY_WME)));
 
1773
}
 
1774
 
 
1775
/*
 
1776
  DESCRIPTION
 
1777
    given a buffer with a key value, and a map of keyparts
 
1778
    that are present in this value, returns the length of the value
 
1779
*/
 
1780
uint32_t calculate_key_len(Table *table, uint32_t key,
 
1781
                       const unsigned char *,
 
1782
                       key_part_map keypart_map)
 
1783
{
 
1784
  /* works only with key prefixes */
 
1785
  assert(((keypart_map + 1) & keypart_map) == 0);
 
1786
 
 
1787
  KEY *key_info= table->s->key_info+key;
 
1788
  KEY_PART_INFO *key_part= key_info->key_part;
 
1789
  KEY_PART_INFO *end_key_part= key_part + key_info->key_parts;
 
1790
  uint32_t length= 0;
 
1791
 
 
1792
  while (key_part < end_key_part && keypart_map)
 
1793
  {
 
1794
    length+= key_part->store_length;
 
1795
    keypart_map >>= 1;
 
1796
    key_part++;
 
1797
  }
 
1798
  return length;
323
1799
}
324
1800
 
325
1801
/*
330
1806
    org_name            Name of database and length
331
1807
 
332
1808
  RETURN
333
 
    false error
334
 
    true ok
 
1809
    0   ok
 
1810
    1   error
335
1811
*/
336
1812
 
337
 
bool check_db_name(Session *session, identifier::Schema &schema_identifier)
 
1813
bool check_db_name(LEX_STRING *org_name)
338
1814
{
339
 
  if (not plugin::Authorization::isAuthorized(session->user(), schema_identifier))
340
 
  {
341
 
    return false;
342
 
  }
343
 
 
344
 
  return schema_identifier.isValid();
 
1815
  char *name= org_name->str;
 
1816
  uint32_t name_length= org_name->length;
 
1817
 
 
1818
  if (!name_length || name_length > NAME_LEN || name[name_length - 1] == ' ')
 
1819
    return 1;
 
1820
 
 
1821
  if (name != any_db)
 
1822
    my_casedn_str(files_charset_info, name);
 
1823
 
 
1824
  return check_identifier_name(org_name);
345
1825
}
346
1826
 
 
1827
 
347
1828
/*
348
1829
  Allow anything as a table name, as long as it doesn't contain an
349
1830
  ' ' at the end
414
1895
    bitmap_clear_all(&table->def_read_set);
415
1896
    bitmap_clear_all(&table->def_write_set);
416
1897
  */
417
 
  def_read_set.reset();
418
 
  def_write_set.reset();
419
 
  column_bitmaps_set(def_read_set, def_write_set);
 
1898
  def_read_set.clearAll();
 
1899
  def_write_set.clearAll();
 
1900
  column_bitmaps_set(&def_read_set, &def_write_set);
420
1901
}
421
1902
 
422
1903
 
432
1913
void Table::prepare_for_position()
433
1914
{
434
1915
 
435
 
  if ((cursor->getEngine()->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX)) &&
436
 
      getShare()->hasPrimaryKey())
 
1916
  if ((file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
 
1917
      s->primary_key < MAX_KEY)
437
1918
  {
438
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
1919
    mark_columns_used_by_index_no_reset(s->primary_key);
439
1920
  }
440
1921
  return;
441
1922
}
453
1934
 
454
1935
void Table::mark_columns_used_by_index(uint32_t index)
455
1936
{
456
 
  boost::dynamic_bitset<> *bitmap= &tmp_set;
 
1937
  MyBitmap *bitmap= &tmp_set;
457
1938
 
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);
 
1939
  (void) file->extra(HA_EXTRA_KEYREAD);
 
1940
  bitmap->clearAll();
 
1941
  mark_columns_used_by_index_no_reset(index, bitmap);
 
1942
  column_bitmaps_set(bitmap, bitmap);
462
1943
  return;
463
1944
}
464
1945
 
478
1959
{
479
1960
 
480
1961
  key_read= 0;
481
 
  (void) cursor->extra(HA_EXTRA_NO_KEYREAD);
 
1962
  (void) file->extra(HA_EXTRA_NO_KEYREAD);
482
1963
  default_column_bitmaps();
483
1964
  return;
484
1965
}
490
1971
 
491
1972
void Table::mark_columns_used_by_index_no_reset(uint32_t index)
492
1973
{
493
 
    mark_columns_used_by_index_no_reset(index, *read_set);
 
1974
    mark_columns_used_by_index_no_reset(index, read_set);
494
1975
}
495
1976
 
496
 
 
497
1977
void Table::mark_columns_used_by_index_no_reset(uint32_t index,
498
 
                                                boost::dynamic_bitset<>& bitmap)
 
1978
                                                MyBitmap *bitmap)
499
1979
{
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
 
  }
 
1980
  KEY_PART_INFO *key_part= key_info[index].key_part;
 
1981
  KEY_PART_INFO *key_part_end= (key_part +
 
1982
                                key_info[index].key_parts);
 
1983
  for (;key_part != key_part_end; key_part++)
 
1984
    bitmap->setBit(key_part->fieldnr-1);
507
1985
}
508
1986
 
509
1987
 
522
2000
    We must set bit in read set as update_auto_increment() is using the
523
2001
    store() to check overflow of auto_increment values
524
2002
  */
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);
 
2003
  setReadSet(found_next_number_field->field_index);
 
2004
  setWriteSet(found_next_number_field->field_index);
 
2005
  if (s->next_number_keypart)
 
2006
    mark_columns_used_by_index_no_reset(s->next_number_index);
529
2007
}
530
2008
 
531
2009
 
556
2034
    be able to do an delete
557
2035
 
558
2036
  */
559
 
  if (not getShare()->hasPrimaryKey())
 
2037
  if (s->primary_key == MAX_KEY)
560
2038
  {
561
2039
    /* fallback to use all columns in the table to identify row */
562
2040
    use_all_columns();
563
2041
    return;
564
2042
  }
565
2043
  else
566
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
2044
    mark_columns_used_by_index_no_reset(s->primary_key);
567
2045
 
568
2046
  /* If we the engine wants all predicates we mark all keys */
569
 
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
 
2047
  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
570
2048
  {
571
2049
    Field **reg_field;
572
2050
    for (reg_field= field ; *reg_field ; reg_field++)
573
2051
    {
574
2052
      if ((*reg_field)->flags & PART_KEY_FLAG)
575
 
        setReadSet((*reg_field)->position());
 
2053
        setReadSet((*reg_field)->field_index);
576
2054
    }
577
2055
  }
578
2056
}
590
2068
    if neeed, either the primary key column or all columns to be read.
591
2069
    (see mark_columns_needed_for_delete() for details)
592
2070
 
593
 
    If the engine has HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
 
2071
    If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
594
2072
    mark all USED key columns as 'to-be-read'. This allows the engine to
595
2073
    loop over the given record to find all changed keys and doesn't have to
596
2074
    retrieve the row again.
604
2082
    the primary key, the hidden primary key or all columns to be
605
2083
    able to do an update
606
2084
  */
607
 
  if (not getShare()->hasPrimaryKey())
 
2085
  if (s->primary_key == MAX_KEY)
608
2086
  {
609
2087
    /* fallback to use all columns in the table to identify row */
610
2088
    use_all_columns();
611
2089
    return;
612
2090
  }
613
2091
  else
614
 
    mark_columns_used_by_index_no_reset(getShare()->getPrimaryKey());
 
2092
    mark_columns_used_by_index_no_reset(s->primary_key);
615
2093
 
616
 
  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))
 
2094
  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
617
2095
  {
618
2096
    /* Mark all used key columns for read */
619
2097
    Field **reg_field;
621
2099
    {
622
2100
      /* Merge keys is all keys that had a column refered to in the query */
623
2101
      if (is_overlapping(merge_keys, (*reg_field)->part_of_key))
624
 
        setReadSet((*reg_field)->position());
 
2102
        setReadSet((*reg_field)->field_index);
625
2103
    }
626
2104
  }
627
2105
 
653
2131
  {
654
2132
    Field_blob* const blob= (Field_blob*) field[*ptr];
655
2133
    length+= blob->get_length((const unsigned char*)
656
 
                              (data + blob->offset(getInsertRecord()))) +
 
2134
                              (data + blob->offset(record[0]))) +
657
2135
      HA_KEY_BLOB_LENGTH;
658
2136
  }
659
2137
  return length;
660
2138
}
661
2139
 
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
2140
/****************************************************************************
675
2141
 Functions for creating temporary tables.
676
2142
****************************************************************************/
 
2143
 
 
2144
 
 
2145
/* Prototypes */
 
2146
void free_tmp_table(Session *session, Table *entry);
 
2147
 
677
2148
/**
678
2149
  Create field for temporary table from given field.
679
2150
 
708
2179
  */
709
2180
  if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&
710
2181
      (org_field->flags & BLOB_FLAG))
711
 
  {
712
 
    table->setVariableWidth();
713
2182
    new_field= new Field_varstring(convert_blob_length,
714
2183
                                   org_field->maybe_null(),
715
 
                                   org_field->field_name,
 
2184
                                   org_field->field_name, table->s,
716
2185
                                   org_field->charset());
717
 
  }
718
2186
  else
719
 
  {
720
2187
    new_field= org_field->new_field(session->mem_root, table,
721
 
                                    table == org_field->getTable());
722
 
  }
 
2188
                                    table == org_field->table);
723
2189
  if (new_field)
724
2190
  {
725
2191
    new_field->init(table);
732
2198
    if (org_field->maybe_null() || (item && item->maybe_null))
733
2199
      new_field->flags&= ~NOT_NULL_FLAG;        // Because of outer join
734
2200
    if (org_field->type() == DRIZZLE_TYPE_VARCHAR)
735
 
      table->getMutableShare()->db_create_options|= HA_OPTION_PACK_RECORD;
 
2201
      table->s->db_create_options|= HA_OPTION_PACK_RECORD;
736
2202
    else if (org_field->type() == DRIZZLE_TYPE_DOUBLE)
737
2203
      ((Field_double *) new_field)->not_fixed= true;
738
2204
  }
741
2207
 
742
2208
 
743
2209
/**
 
2210
  Create field for information schema table.
 
2211
 
 
2212
  @param session                Thread Cursor
 
2213
  @param table          Temporary table
 
2214
  @param item           Item to create a field for
 
2215
 
 
2216
  @retval
 
2217
    0                   on error
 
2218
  @retval
 
2219
    new_created field
 
2220
*/
 
2221
 
 
2222
static Field *create_tmp_field_for_schema(Item *item, Table *table)
 
2223
{
 
2224
  if (item->field_type() == DRIZZLE_TYPE_VARCHAR)
 
2225
  {
 
2226
    Field *field;
 
2227
    if (item->max_length > MAX_FIELD_VARCHARLENGTH)
 
2228
      field= new Field_blob(item->max_length, item->maybe_null,
 
2229
                            item->name, item->collation.collation);
 
2230
    else
 
2231
      field= new Field_varstring(item->max_length, item->maybe_null,
 
2232
                                 item->name,
 
2233
                                 table->s, item->collation.collation);
 
2234
    if (field)
 
2235
      field->init(table);
 
2236
    return field;
 
2237
  }
 
2238
  return item->tmp_table_field_from_field_type(table, 0);
 
2239
}
 
2240
 
 
2241
 
 
2242
/**
744
2243
  Create a temp table according to a field list.
745
2244
 
746
2245
  Given field pointers are changed to point at tmp_table for
772
2271
 
773
2272
Table *
774
2273
create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,
775
 
                 Order *group, bool distinct, bool save_sum_fields,
 
2274
                 order_st *group, bool distinct, bool save_sum_fields,
776
2275
                 uint64_t select_options, ha_rows rows_limit,
777
2276
                 const char *table_alias)
778
2277
{
779
 
  memory::Root *mem_root_save;
 
2278
  MEM_ROOT *mem_root_save, own_root;
 
2279
  Table *table;
 
2280
  TableShare *share;
780
2281
  uint  i,field_count,null_count,null_pack_length;
781
2282
  uint32_t  copy_func_count= param->func_count;
782
2283
  uint32_t  hidden_null_count, hidden_null_pack_length, hidden_field_count;
783
2284
  uint32_t  blob_count,group_null_items, string_count;
784
2285
  uint32_t fieldnr= 0;
785
2286
  ulong reclength, string_total_length;
786
 
  bool  using_unique_constraint= false;
787
 
  bool  use_packed_rows= true;
 
2287
  bool  using_unique_constraint= 0;
 
2288
  bool  use_packed_rows= 0;
788
2289
  bool  not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);
789
 
  unsigned char *pos, *group_buff;
 
2290
  char  *tmpname,path[FN_REFLEN];
 
2291
  unsigned char *pos, *group_buff, *bitmaps;
790
2292
  unsigned char *null_flags;
791
2293
  Field **reg_field, **from_field, **default_field;
 
2294
  uint32_t *blob_field;
792
2295
  CopyField *copy= 0;
793
 
  KeyInfo *keyinfo;
794
 
  KeyPartInfo *key_part_info;
 
2296
  KEY *keyinfo;
 
2297
  KEY_PART_INFO *key_part_info;
795
2298
  Item **copy_func;
796
2299
  MI_COLUMNDEF *recinfo;
797
2300
  uint32_t total_uneven_bit_length= 0;
798
2301
  bool force_copy_fields= param->force_copy_fields;
799
2302
  uint64_t max_rows= 0;
800
2303
 
801
 
  session->status_var.created_tmp_tables++;
 
2304
  status_var_increment(session->status_var.created_tmp_tables);
 
2305
 
 
2306
  /* if we run out of slots or we are not using tempool */
 
2307
  sprintf(path,"%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,
 
2308
          session->thread_id, session->tmp_table++);
 
2309
 
 
2310
  /*
 
2311
    No need to change table name to lower case as we are only creating
 
2312
    MyISAM or HEAP tables here
 
2313
  */
 
2314
  fn_format(path, path, drizzle_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);
 
2315
 
802
2316
 
803
2317
  if (group)
804
2318
  {
805
 
    if (! param->quick_group)
806
 
    {
 
2319
    if (!param->quick_group)
807
2320
      group= 0;                                 // Can't use group key
808
 
    }
809
 
    else for (Order *tmp=group ; tmp ; tmp=tmp->next)
 
2321
    else for (order_st *tmp=group ; tmp ; tmp=tmp->next)
810
2322
    {
811
2323
      /*
812
2324
        marker == 4 means two things:
816
2328
      */
817
2329
      (*tmp->item)->marker= 4;
818
2330
      if ((*tmp->item)->max_length >= CONVERT_IF_BIGGER_TO_BLOB)
819
 
        using_unique_constraint= true;
 
2331
        using_unique_constraint=1;
820
2332
    }
821
2333
    if (param->group_length >= MAX_BLOB_WIDTH)
822
 
      using_unique_constraint= true;
 
2334
      using_unique_constraint=1;
823
2335
    if (group)
824
2336
      distinct= 0;                              // Can't use distinct
825
2337
  }
835
2347
    these items are stored in the temporary table.
836
2348
  */
837
2349
  if (param->precomputed_group_by)
838
 
  {
839
2350
    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))
 
2351
 
 
2352
  init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);
 
2353
 
 
2354
  if (!multi_alloc_root(&own_root,
 
2355
                        &table, sizeof(*table),
 
2356
                        &share, sizeof(*share),
 
2357
                        &reg_field, sizeof(Field*) * (field_count+1),
 
2358
                        &default_field, sizeof(Field*) * (field_count),
 
2359
                        &blob_field, sizeof(uint32_t)*(field_count+1),
 
2360
                        &from_field, sizeof(Field*)*field_count,
 
2361
                        &copy_func, sizeof(*copy_func)*(copy_func_count+1),
 
2362
                        &param->keyinfo, sizeof(*param->keyinfo),
 
2363
                        &key_part_info,
 
2364
                        sizeof(*key_part_info)*(param->group_parts+1),
 
2365
                        &param->start_recinfo,
 
2366
                        sizeof(*param->recinfo)*(field_count*2+4),
 
2367
                        &tmpname, (uint32_t) strlen(path)+1,
 
2368
                        &group_buff, (group && ! using_unique_constraint ?
 
2369
                                      param->group_length : 0),
 
2370
                        &bitmaps, bitmap_buffer_size(field_count)*2,
 
2371
                        NULL))
855
2372
  {
856
2373
    return NULL;
857
2374
  }
858
2375
  /* CopyField belongs to Tmp_Table_Param, allocate it in Session mem_root */
859
2376
  if (!(param->copy_field= copy= new (session->mem_root) CopyField[field_count]))
860
2377
  {
 
2378
    free_root(&own_root, MYF(0));
861
2379
    return NULL;
862
2380
  }
863
2381
  param->items_to_copy= copy_func;
 
2382
  strcpy(tmpname,path);
864
2383
  /* make table according to fields */
865
2384
 
 
2385
  memset(table, 0, sizeof(*table));
 
2386
  memset(reg_field, 0, sizeof(Field*)*(field_count+1));
866
2387
  memset(default_field, 0, sizeof(Field*) * (field_count));
867
2388
  memset(from_field, 0, sizeof(Field*)*field_count);
868
2389
 
 
2390
  table->mem_root= own_root;
869
2391
  mem_root_save= session->mem_root;
870
 
  session->mem_root= table->getMemRoot();
 
2392
  session->mem_root= &table->mem_root;
871
2393
 
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);
 
2394
  table->field=reg_field;
 
2395
  table->alias= table_alias;
876
2396
  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */
877
2397
  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
878
2398
  table->map=1;
879
2399
  table->copy_blobs= 1;
880
 
  assert(session);
881
2400
  table->in_use= session;
882
2401
  table->quick_keys.reset();
883
2402
  table->covering_keys.reset();
884
2403
  table->keys_in_use_for_query.reset();
885
2404
 
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();
 
2405
  table->setShare(share);
 
2406
  share->init(tmpname, tmpname);
 
2407
  share->blob_field= blob_field;
 
2408
  share->blob_ptr_size= portable_sizeof_char_ptr;
 
2409
  share->db_low_byte_first=1;                // True for HEAP and MyISAM
 
2410
  share->table_charset= param->table_charset;
 
2411
  share->primary_key= MAX_KEY;               // Indicate no primary key
 
2412
  share->keys_for_keyread.reset();
 
2413
  share->keys_in_use.reset();
892
2414
 
893
2415
  /* Calculate which type of fields we will store in the temporary table */
894
2416
 
936
2458
            create_tmp_field(session, table, arg, arg->type(), &copy_func,
937
2459
                             tmp_from_field, &default_field[fieldnr],
938
2460
                             group != 0,not_all_columns,
939
 
                             false,
 
2461
                             distinct, 0,
940
2462
                             param->convert_blob_length);
941
2463
          if (!new_field)
942
2464
            goto err;                                   // Should be OOM
955
2477
          }
956
2478
          session->mem_root= mem_root_save;
957
2479
          session->change_item_tree(argp, new Item_field(new_field));
958
 
          session->mem_root= table->getMemRoot();
 
2480
          session->mem_root= &table->mem_root;
959
2481
          if (!(new_field->flags & NOT_NULL_FLAG))
960
2482
          {
961
2483
            null_count++;
965
2487
            */
966
2488
            (*argp)->maybe_null=1;
967
2489
          }
968
 
          new_field->setPosition(fieldnr++);
 
2490
          new_field->field_index= fieldnr++;
969
2491
        }
970
2492
      }
971
2493
    }
981
2503
        We here distinguish between UNION and multi-table-updates by the fact
982
2504
        that in the later case group is set to the row pointer.
983
2505
      */
984
 
      Field *new_field=
 
2506
      Field *new_field= (param->schema_table) ?
 
2507
        create_tmp_field_for_schema(item, table) :
985
2508
        create_tmp_field(session, table, item, type, &copy_func,
986
2509
                         tmp_from_field, &default_field[fieldnr],
987
2510
                         group != 0,
988
2511
                         !force_copy_fields &&
989
2512
                           (not_all_columns || group != 0),
 
2513
                         /*
 
2514
                           If item->marker == 4 then we force create_tmp_field
 
2515
                           to create a 64-bit longs for BIT fields because HEAP
 
2516
                           tables can't index BIT fields directly. We do the same
 
2517
                           for distinct, as we want the distinct index to be
 
2518
                           usable in this case too.
 
2519
                         */
 
2520
                         item->marker == 4 || param->bit_fields_as_long,
990
2521
                         force_copy_fields,
991
2522
                         param->convert_blob_length);
992
2523
 
1012
2543
        group_null_items++;
1013
2544
        new_field->flags|= GROUP_FLAG;
1014
2545
      }
1015
 
      new_field->setPosition(fieldnr++);
 
2546
      new_field->field_index= fieldnr++;
1016
2547
      *(reg_field++)= new_field;
1017
2548
    }
1018
2549
    if (!--hidden_field_count)
1030
2561
      null_count= 0;
1031
2562
    }
1032
2563
  }
1033
 
  assert(fieldnr == (uint32_t) (reg_field - table->getFields()));
1034
 
  assert(field_count >= (uint32_t) (reg_field - table->getFields()));
 
2564
  assert(fieldnr == (uint32_t) (reg_field - table->field));
 
2565
  assert(field_count >= (uint32_t) (reg_field - table->field));
1035
2566
  field_count= fieldnr;
1036
2567
  *reg_field= 0;
1037
2568
  *blob_field= 0;                               // End marker
1038
 
  table->getMutableShare()->setFieldSize(field_count);
 
2569
  share->fields= field_count;
1039
2570
 
1040
2571
  /* If result table is small; use a heap */
1041
2572
  /* 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)
 
2573
  if (blob_count || using_unique_constraint ||
 
2574
      (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
 
2575
      OPTION_BIG_TABLES || (select_options & TMP_TABLE_FORCE_MYISAM))
1046
2576
  {
1047
 
    table->getMutableShare()->storage_engine= myisam_engine;
1048
 
    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
 
2577
    share->storage_engine= myisam_engine;
 
2578
    table->file= share->db_type()->getCursor(share, &table->mem_root);
1049
2579
    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
 
    }
 
2580
        (param->group_parts > table->file->max_key_parts() ||
 
2581
         param->group_length > table->file->max_key_length()))
 
2582
      using_unique_constraint=1;
1055
2583
  }
1056
2584
  else
1057
2585
  {
1058
 
    table->getMutableShare()->storage_engine= heap_engine;
1059
 
    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
 
2586
    share->storage_engine= heap_engine;
 
2587
    table->file= share->db_type()->getCursor(share, &table->mem_root);
1060
2588
  }
1061
 
  if (! table->cursor)
 
2589
  if (!table->file)
1062
2590
    goto err;
1063
2591
 
1064
2592
 
1065
 
  if (! using_unique_constraint)
 
2593
  if (!using_unique_constraint)
1066
2594
    reclength+= group_null_items;       // null flag is stored separately
1067
2595
 
1068
 
  table->getMutableShare()->blob_fields= blob_count;
 
2596
  share->blob_fields= blob_count;
1069
2597
  if (blob_count == 0)
1070
2598
  {
1071
2599
    /* We need to ensure that first byte is not 0 for the delete link */
1084
2612
  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
2613
    use_packed_rows= 1;
1086
2614
 
1087
 
  table->getMutableShare()->setRecordLength(reclength);
 
2615
  share->reclength= reclength;
1088
2616
  {
1089
2617
    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
 
    {
 
2618
    share->rec_buff_length= alloc_length;
 
2619
    if (!(table->record[0]= (unsigned char*)
 
2620
                            alloc_root(&table->mem_root, alloc_length*3)))
1093
2621
      goto err;
1094
 
    }
1095
 
    table->record[1]= table->getInsertRecord()+alloc_length;
1096
 
    table->getMutableShare()->resizeDefaultValues(alloc_length);
 
2622
    table->record[1]= table->record[0]+alloc_length;
 
2623
    share->default_values= table->record[1]+alloc_length;
1097
2624
  }
1098
2625
  copy_func[0]= 0;                              // End marker
1099
2626
  param->func_count= copy_func - param->items_to_copy;
1100
2627
 
1101
 
  table->setup_tmp_table_column_bitmaps();
 
2628
  table->setup_tmp_table_column_bitmaps(bitmaps);
1102
2629
 
1103
2630
  recinfo=param->start_recinfo;
1104
 
  null_flags=(unsigned char*) table->getInsertRecord();
1105
 
  pos=table->getInsertRecord()+ null_pack_length;
 
2631
  null_flags=(unsigned char*) table->record[0];
 
2632
  pos=table->record[0]+ null_pack_length;
1106
2633
  if (null_pack_length)
1107
2634
  {
1108
2635
    memset(recinfo, 0, sizeof(*recinfo));
1111
2638
    recinfo++;
1112
2639
    memset(null_flags, 255, null_pack_length);  // Set null fields
1113
2640
 
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;
 
2641
    table->null_flags= (unsigned char*) table->record[0];
 
2642
    share->null_fields= null_count+ hidden_null_count;
 
2643
    share->null_bytes= null_pack_length;
1117
2644
  }
1118
2645
  null_count= (blob_count == 0) ? 1 : 0;
1119
2646
  hidden_field_count=param->hidden_field_count;
1120
 
  for (i= 0,reg_field= table->getFields(); i < field_count; i++,reg_field++,recinfo++)
 
2647
  for (i= 0,reg_field=table->field; i < field_count; i++,reg_field++,recinfo++)
1121
2648
  {
1122
2649
    Field *field= *reg_field;
1123
2650
    uint32_t length;
1161
2688
         inherit the default value that is defined for the field referred
1162
2689
         by the Item_field object from which 'field' has been created.
1163
2690
      */
1164
 
      ptrdiff_t diff;
 
2691
      my_ptrdiff_t diff;
1165
2692
      Field *orig_field= default_field[i];
1166
2693
      /* Get the value from default_values */
1167
 
      diff= (ptrdiff_t) (orig_field->getTable()->getDefaultValues() - orig_field->getTable()->getInsertRecord());
 
2694
      diff= (my_ptrdiff_t) (orig_field->table->s->default_values-
 
2695
                            orig_field->table->record[0]);
1168
2696
      orig_field->move_field_offset(diff);      // Points now at default_values
1169
2697
      if (orig_field->is_real_null())
1170
2698
        field->set_null();
1173
2701
        field->set_notnull();
1174
2702
        memcpy(field->ptr, orig_field->ptr, field->pack_length());
1175
2703
      }
1176
 
      orig_field->move_field_offset(-diff);     // Back to getInsertRecord()
 
2704
      orig_field->move_field_offset(-diff);     // Back to record[0]
1177
2705
    }
1178
2706
 
1179
2707
    if (from_field[i])
1192
2720
      recinfo->type=FIELD_NORMAL;
1193
2721
    if (!--hidden_field_count)
1194
2722
      null_count=(null_count+7) & ~7;           // move to next byte
 
2723
 
 
2724
    // fix table name in field entry
 
2725
    field->table_name= &table->alias;
1195
2726
  }
1196
2727
 
1197
2728
  param->copy_field_end=copy;
1199
2730
  table->storeRecordAsDefault();        // Make empty default record
1200
2731
 
1201
2732
  if (session->variables.tmp_table_size == ~ (uint64_t) 0)              // No limit
1202
 
  {
1203
2733
    max_rows= ~(uint64_t) 0;
1204
 
  }
1205
2734
  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
 
  }
 
2735
    max_rows= (uint64_t) (((share->db_type() == heap_engine) ?
 
2736
                          min(session->variables.tmp_table_size,
 
2737
                              session->variables.max_heap_table_size) :
 
2738
                          session->variables.tmp_table_size) /
 
2739
                         share->reclength);
1213
2740
 
1214
2741
  set_if_bigger(max_rows, (uint64_t)1); // For dummy start options
1215
2742
  /*
1218
2745
  */
1219
2746
  set_if_smaller(max_rows, rows_limit);
1220
2747
 
1221
 
  table->getMutableShare()->setMaxRows(max_rows);
 
2748
  share->setMaxRows(max_rows);
1222
2749
 
1223
2750
  param->end_write_records= rows_limit;
1224
2751
 
1228
2755
  {
1229
2756
    table->group=group;                         /* Table is grouped by key */
1230
2757
    param->group_buff=group_buff;
1231
 
    table->getMutableShare()->keys=1;
1232
 
    table->getMutableShare()->uniques= test(using_unique_constraint);
 
2758
    share->keys=1;
 
2759
    share->uniques= test(using_unique_constraint);
1233
2760
    table->key_info=keyinfo;
1234
2761
    keyinfo->key_part=key_part_info;
1235
2762
    keyinfo->flags=HA_NOSAME;
1238
2765
    keyinfo->rec_per_key= 0;
1239
2766
    keyinfo->algorithm= HA_KEY_ALG_UNDEF;
1240
2767
    keyinfo->name= (char*) "group_key";
1241
 
    Order *cur_group= group;
 
2768
    order_st *cur_group= group;
1242
2769
    for (; cur_group ; cur_group= cur_group->next, key_part_info++)
1243
2770
    {
1244
2771
      Field *field=(*cur_group->item)->get_tmp_table_field();
1245
2772
      bool maybe_null=(*cur_group->item)->maybe_null;
1246
2773
      key_part_info->null_bit= 0;
1247
2774
      key_part_info->field=  field;
1248
 
      key_part_info->offset= field->offset(table->getInsertRecord());
 
2775
      key_part_info->offset= field->offset(table->record[0]);
1249
2776
      key_part_info->length= (uint16_t) field->key_length();
1250
2777
      key_part_info->type=   (uint8_t) field->key_type();
1251
2778
      key_part_info->key_type= 
1273
2800
          keyinfo->flags|= HA_NULL_ARE_EQUAL;   // def. that NULL == NULL
1274
2801
          key_part_info->null_bit=field->null_bit;
1275
2802
          key_part_info->null_offset= (uint32_t) (field->null_ptr -
1276
 
                                              (unsigned char*) table->getInsertRecord());
 
2803
                                              (unsigned char*) table->record[0]);
1277
2804
          cur_group->buff++;                        // Pointer to field data
1278
2805
          group_buff++;                         // Skipp null flag
1279
2806
        }
1300
2827
        indexes on blobs with arbitrary length. Such indexes cannot be
1301
2828
        used for lookups.
1302
2829
      */
1303
 
      table->getMutableShare()->uniques= 1;
 
2830
      share->uniques= 1;
1304
2831
    }
1305
2832
    null_pack_length-=hidden_null_pack_length;
1306
2833
    keyinfo->key_parts= ((field_count-param->hidden_field_count)+
1307
 
                         (table->getMutableShare()->uniques ? test(null_pack_length) : 0));
 
2834
                         (share->uniques ? test(null_pack_length) : 0));
1308
2835
    table->distinct= 1;
1309
 
    table->getMutableShare()->keys= 1;
1310
 
    if (!(key_part_info= (KeyPartInfo*)
1311
 
         table->alloc_root(keyinfo->key_parts * sizeof(KeyPartInfo))))
 
2836
    share->keys= 1;
 
2837
    if (!(key_part_info= (KEY_PART_INFO*)
 
2838
          alloc_root(&table->mem_root,
 
2839
                     keyinfo->key_parts * sizeof(KEY_PART_INFO))))
1312
2840
      goto err;
1313
 
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KeyPartInfo));
 
2841
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KEY_PART_INFO));
1314
2842
    table->key_info=keyinfo;
1315
2843
    keyinfo->key_part=key_part_info;
1316
2844
    keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;
1324
2852
      blobs can distinguish NULL from 0. This extra field is not needed
1325
2853
      when we do not use UNIQUE indexes for blobs.
1326
2854
    */
1327
 
    if (null_pack_length && table->getMutableShare()->uniques)
 
2855
    if (null_pack_length && share->uniques)
1328
2856
    {
1329
2857
      key_part_info->null_bit= 0;
1330
2858
      key_part_info->offset=hidden_null_pack_length;
1331
2859
      key_part_info->length=null_pack_length;
1332
 
      table->setVariableWidth();
1333
 
      key_part_info->field= new Field_varstring(table->getInsertRecord(),
 
2860
      key_part_info->field= new Field_varstring(table->record[0],
1334
2861
                                                (uint32_t) key_part_info->length,
1335
2862
                                                0,
1336
2863
                                                (unsigned char*) 0,
1337
2864
                                                (uint32_t) 0,
1338
2865
                                                NULL,
 
2866
                                                table->s,
1339
2867
                                                &my_charset_bin);
1340
2868
      if (!key_part_info->field)
1341
2869
        goto err;
1345
2873
      key_part_info++;
1346
2874
    }
1347
2875
    /* Create a distinct key over the columns we are going to return */
1348
 
    for (i=param->hidden_field_count, reg_field=table->getFields() + i ;
 
2876
    for (i=param->hidden_field_count, reg_field=table->field + i ;
1349
2877
         i < field_count;
1350
2878
         i++, reg_field++, key_part_info++)
1351
2879
    {
1352
2880
      key_part_info->null_bit= 0;
1353
2881
      key_part_info->field=    *reg_field;
1354
 
      key_part_info->offset=   (*reg_field)->offset(table->getInsertRecord());
 
2882
      key_part_info->offset=   (*reg_field)->offset(table->record[0]);
1355
2883
      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.
 
2884
      /* TODO:
 
2885
        The below method of computing the key format length of the
 
2886
        key part is a copy/paste from opt_range.cc, and table.cc.
1358
2887
        This should be factored out, e.g. as a method of Field.
1359
2888
        In addition it is not clear if any of the Field::*_length
1360
2889
        methods is supposed to compute the same length. If so, it
1379
2908
 
1380
2909
  if (session->is_fatal_error)                          // If end of memory
1381
2910
    goto err;
1382
 
  table->getMutableShare()->db_record_offset= 1;
1383
 
  if (table->getShare()->db_type() == myisam_engine)
 
2911
  share->db_record_offset= 1;
 
2912
  if (share->db_type() == myisam_engine)
1384
2913
  {
1385
2914
    if (table->create_myisam_tmp_table(param->keyinfo, param->start_recinfo,
1386
2915
                                       &param->recinfo, select_options))
1387
2916
      goto err;
1388
2917
  }
1389
 
  assert(table->in_use);
1390
2918
  if (table->open_tmp_table())
1391
2919
    goto err;
1392
2920
 
1396
2924
 
1397
2925
err:
1398
2926
  session->mem_root= mem_root_save;
1399
 
  table= NULL;
1400
 
 
 
2927
  table->free_tmp_table(session);
1401
2928
  return NULL;
1402
2929
}
1403
2930
 
1404
2931
/****************************************************************************/
1405
2932
 
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;
 
2933
/**
 
2934
  Create a reduced Table object with properly set up Field list from a
 
2935
  list of field definitions.
 
2936
 
 
2937
    The created table doesn't have a table Cursor associated with
 
2938
    it, has no keys, no group/distinct, no copy_funcs array.
 
2939
    The sole purpose of this Table object is to use the power of Field
 
2940
    class to read/write data to/from table->record[0]. Then one can store
 
2941
    the record in any container (RB tree, hash, etc).
 
2942
    The table is created in Session mem_root, so are the table's fields.
 
2943
    Consequently, if you don't BLOB fields, you don't need to free it.
 
2944
 
 
2945
  @param session         connection handle
 
2946
  @param field_list  list of column definitions
 
2947
 
 
2948
  @return
 
2949
    0 if out of memory, Table object in case of success
 
2950
*/
 
2951
 
 
2952
Table *create_virtual_tmp_table(Session *session, List<CreateField> &field_list)
 
2953
{
 
2954
  uint32_t field_count= field_list.elements;
 
2955
  uint32_t blob_count= 0;
 
2956
  Field **field;
 
2957
  CreateField *cdef;                           /* column definition */
 
2958
  uint32_t record_length= 0;
 
2959
  uint32_t null_count= 0;                 /* number of columns which may be null */
 
2960
  uint32_t null_pack_length;              /* NULL representation array length */
 
2961
  uint32_t *blob_field;
 
2962
  unsigned char *bitmaps;
 
2963
  Table *table;
 
2964
  TableShare *share;
 
2965
 
 
2966
  if (!multi_alloc_root(session->mem_root,
 
2967
                        &table, sizeof(*table),
 
2968
                        &share, sizeof(*share),
 
2969
                        &field, (field_count + 1) * sizeof(Field*),
 
2970
                        &blob_field, (field_count+1) *sizeof(uint32_t),
 
2971
                        &bitmaps, bitmap_buffer_size(field_count)*2,
 
2972
                        NULL))
 
2973
    return NULL;
 
2974
 
 
2975
  memset(table, 0, sizeof(*table));
 
2976
  memset(share, 0, sizeof(*share));
 
2977
  table->field= field;
 
2978
  table->s= share;
 
2979
  share->blob_field= blob_field;
 
2980
  share->fields= field_count;
 
2981
  share->blob_ptr_size= portable_sizeof_char_ptr;
 
2982
  table->setup_tmp_table_column_bitmaps(bitmaps);
 
2983
 
 
2984
  /* Create all fields and calculate the total length of record */
 
2985
  List_iterator_fast<CreateField> it(field_list);
 
2986
  while ((cdef= it++))
 
2987
  {
 
2988
    *field= make_field(share,
 
2989
                       NULL,
 
2990
                       0,
 
2991
                       cdef->length,
 
2992
                       (cdef->flags & NOT_NULL_FLAG) ? false : true,
 
2993
                       (unsigned char *) ((cdef->flags & NOT_NULL_FLAG) ? 0 : ""),
 
2994
                       (cdef->flags & NOT_NULL_FLAG) ? 0 : 1,
 
2995
                       cdef->decimals,
 
2996
                       cdef->sql_type,
 
2997
                       cdef->charset,
 
2998
                       cdef->unireg_check,
 
2999
                       cdef->interval,
 
3000
                       cdef->field_name);
 
3001
    if (!*field)
 
3002
      goto error;
 
3003
    (*field)->init(table);
 
3004
    record_length+= (*field)->pack_length();
 
3005
    if (! ((*field)->flags & NOT_NULL_FLAG))
 
3006
      null_count++;
 
3007
 
 
3008
    if ((*field)->flags & BLOB_FLAG)
 
3009
      share->blob_field[blob_count++]= (uint32_t) (field - table->field);
 
3010
 
 
3011
    field++;
 
3012
  }
 
3013
  *field= NULL;                             /* mark the end of the list */
 
3014
  share->blob_field[blob_count]= 0;            /* mark the end of the list */
 
3015
  share->blob_fields= blob_count;
 
3016
 
 
3017
  null_pack_length= (null_count + 7)/8;
 
3018
  share->reclength= record_length + null_pack_length;
 
3019
  share->rec_buff_length= ALIGN_SIZE(share->reclength + 1);
 
3020
  table->record[0]= (unsigned char*) session->alloc(share->rec_buff_length);
 
3021
  if (!table->record[0])
 
3022
    goto error;
 
3023
 
 
3024
  if (null_pack_length)
 
3025
  {
 
3026
    table->null_flags= (unsigned char*) table->record[0];
 
3027
    share->null_fields= null_count;
 
3028
    share->null_bytes= null_pack_length;
 
3029
  }
 
3030
 
 
3031
  table->in_use= session;           /* field->reset() may access table->in_use */
 
3032
  {
 
3033
    /* Set up field pointers */
 
3034
    unsigned char *null_pos= table->record[0];
 
3035
    unsigned char *field_pos= null_pos + share->null_bytes;
 
3036
    uint32_t null_bit= 1;
 
3037
 
 
3038
    for (field= table->field; *field; ++field)
 
3039
    {
 
3040
      Field *cur_field= *field;
 
3041
      if ((cur_field->flags & NOT_NULL_FLAG))
 
3042
        cur_field->move_field(field_pos);
 
3043
      else
 
3044
      {
 
3045
        cur_field->move_field(field_pos, (unsigned char*) null_pos, null_bit);
 
3046
        null_bit<<= 1;
 
3047
        if (null_bit == (1 << 8))
 
3048
        {
 
3049
          ++null_pos;
 
3050
          null_bit= 1;
 
3051
        }
 
3052
      }
 
3053
      cur_field->reset();
 
3054
 
 
3055
      field_pos+= cur_field->pack_length();
 
3056
    }
 
3057
  }
 
3058
  return table;
 
3059
error:
 
3060
  for (field= table->field; *field; ++field)
 
3061
    delete *field;                         /* just invokes field destructor */
 
3062
  return 0;
 
3063
}
 
3064
 
 
3065
bool Table::open_tmp_table()
 
3066
{
 
3067
  int error;
 
3068
  if ((error=file->ha_open(this, s->table_name.str,O_RDWR,
 
3069
                                  HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))
 
3070
  {
 
3071
    file->print_error(error,MYF(0));
 
3072
    db_stat= 0;
 
3073
    return true;
 
3074
  }
 
3075
  (void) file->extra(HA_EXTRA_QUICK);           /* Faster */
 
3076
  return false;
 
3077
}
 
3078
 
 
3079
 
 
3080
/*
 
3081
  Create MyISAM temporary table
 
3082
 
 
3083
  SYNOPSIS
 
3084
    create_myisam_tmp_table()
 
3085
      keyinfo         Description of the index (there is always one index)
 
3086
      start_recinfo   MyISAM's column descriptions
 
3087
      recinfo INOUT   End of MyISAM's column descriptions
 
3088
      options         Option bits
 
3089
 
 
3090
  DESCRIPTION
 
3091
    Create a MyISAM temporary table according to passed description. The is
 
3092
    assumed to have one unique index or constraint.
 
3093
 
 
3094
    The passed array or MI_COLUMNDEF structures must have this form:
 
3095
 
 
3096
      1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte
 
3097
         when there are many nullable columns)
 
3098
      2. Table columns
 
3099
      3. One free MI_COLUMNDEF element (*recinfo points here)
 
3100
 
 
3101
    This function may use the free element to create hash column for unique
 
3102
    constraint.
 
3103
 
 
3104
   RETURN
 
3105
     false - OK
 
3106
     true  - Error
 
3107
*/
 
3108
 
 
3109
bool Table::create_myisam_tmp_table(KEY *keyinfo,
 
3110
                                    MI_COLUMNDEF *start_recinfo,
 
3111
                                    MI_COLUMNDEF **recinfo,
 
3112
                                    uint64_t options)
 
3113
{
 
3114
  int error;
 
3115
  MI_KEYDEF keydef;
 
3116
  MI_UNIQUEDEF uniquedef;
 
3117
  TableShare *share= s;
 
3118
 
 
3119
  if (share->keys)
 
3120
  {                                             // Get keys for ni_create
 
3121
    bool using_unique_constraint= 0;
 
3122
    HA_KEYSEG *seg= (HA_KEYSEG*) alloc_root(&this->mem_root,
 
3123
                                            sizeof(*seg) * keyinfo->key_parts);
 
3124
    if (!seg)
 
3125
      goto err;
 
3126
 
 
3127
    memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
 
3128
    if (keyinfo->key_length >= file->max_key_length() ||
 
3129
        keyinfo->key_parts > file->max_key_parts() ||
 
3130
        share->uniques)
 
3131
    {
 
3132
      /* Can't create a key; Make a unique constraint instead of a key */
 
3133
      share->keys=    0;
 
3134
      share->uniques= 1;
 
3135
      using_unique_constraint=1;
 
3136
      memset(&uniquedef, 0, sizeof(uniquedef));
 
3137
      uniquedef.keysegs=keyinfo->key_parts;
 
3138
      uniquedef.seg=seg;
 
3139
      uniquedef.null_are_equal=1;
 
3140
 
 
3141
      /* Create extra column for hash value */
 
3142
      memset(*recinfo, 0, sizeof(**recinfo));
 
3143
      (*recinfo)->type= FIELD_CHECK;
 
3144
      (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
 
3145
      (*recinfo)++;
 
3146
      share->reclength+=MI_UNIQUE_HASH_LENGTH;
 
3147
    }
 
3148
    else
 
3149
    {
 
3150
      /* Create an unique key */
 
3151
      memset(&keydef, 0, sizeof(keydef));
 
3152
      keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
 
3153
      keydef.keysegs=  keyinfo->key_parts;
 
3154
      keydef.seg= seg;
 
3155
    }
 
3156
    for (uint32_t i= 0; i < keyinfo->key_parts ; i++,seg++)
 
3157
    {
 
3158
      Field *key_field=keyinfo->key_part[i].field;
 
3159
      seg->flag=     0;
 
3160
      seg->language= key_field->charset()->number;
 
3161
      seg->length=   keyinfo->key_part[i].length;
 
3162
      seg->start=    keyinfo->key_part[i].offset;
 
3163
      if (key_field->flags & BLOB_FLAG)
 
3164
      {
 
3165
        seg->type= ((keyinfo->key_part[i].key_type & 1 /* binary */) ?
 
3166
         HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);
 
3167
        seg->bit_start= (uint8_t)(key_field->pack_length()
 
3168
                                  - share->blob_ptr_size);
 
3169
        seg->flag= HA_BLOB_PART;
 
3170
        seg->length= 0;                 // Whole blob in unique constraint
 
3171
      }
 
3172
      else
 
3173
      {
 
3174
        seg->type= keyinfo->key_part[i].type;
 
3175
      }
 
3176
      if (!(key_field->flags & NOT_NULL_FLAG))
 
3177
      {
 
3178
        seg->null_bit= key_field->null_bit;
 
3179
        seg->null_pos= (uint32_t) (key_field->null_ptr - (unsigned char*) record[0]);
 
3180
        /*
 
3181
          We are using a GROUP BY on something that contains NULL
 
3182
          In this case we have to tell MyISAM that two NULL should
 
3183
          on INSERT be regarded at the same value
 
3184
        */
 
3185
        if (!using_unique_constraint)
 
3186
          keydef.flag|= HA_NULL_ARE_EQUAL;
 
3187
      }
 
3188
    }
 
3189
  }
 
3190
  MI_CREATE_INFO create_info;
 
3191
  memset(&create_info, 0, sizeof(create_info));
 
3192
 
 
3193
  if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
 
3194
      OPTION_BIG_TABLES)
 
3195
    create_info.data_file_length= ~(uint64_t) 0;
 
3196
 
 
3197
  if ((error=mi_create(share->table_name.str, share->keys, &keydef,
 
3198
                       (uint32_t) (*recinfo-start_recinfo),
 
3199
                       start_recinfo,
 
3200
                       share->uniques, &uniquedef,
 
3201
                       &create_info,
 
3202
                       HA_CREATE_TMP_TABLE)))
 
3203
  {
 
3204
    file->print_error(error,MYF(0));
 
3205
    db_stat= 0;
 
3206
    goto err;
 
3207
  }
 
3208
  status_var_increment(in_use->status_var.created_tmp_disk_tables);
 
3209
  share->db_record_offset= 1;
 
3210
  return false;
 
3211
 err:
 
3212
  return true;
 
3213
}
 
3214
 
 
3215
 
 
3216
void Table::free_tmp_table(Session *session)
 
3217
{
 
3218
  MEM_ROOT own_root= mem_root;
 
3219
  const char *save_proc_info;
 
3220
 
 
3221
  save_proc_info=session->get_proc_info();
 
3222
  session->set_proc_info("removing tmp table");
 
3223
 
 
3224
  // Release latches since this can take a long time
 
3225
  plugin::StorageEngine::releaseTemporaryLatches(session);
 
3226
 
 
3227
  if (file)
 
3228
  {
 
3229
    if (db_stat)
 
3230
      file->closeMarkForDelete(s->table_name.str);
 
3231
 
 
3232
    s->db_type()->doDeleteTable(session, s->table_name.str);
 
3233
 
 
3234
    delete file;
 
3235
  }
 
3236
 
 
3237
  /* free blobs */
 
3238
  for (Field **ptr= field ; *ptr ; ptr++)
 
3239
    (*ptr)->free();
 
3240
  free_io_cache();
 
3241
 
 
3242
  free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
 
3243
  session->set_proc_info(save_proc_info);
 
3244
}
 
3245
 
 
3246
/**
 
3247
  If a HEAP table gets full, create a MyISAM table and copy all rows
 
3248
  to this.
 
3249
*/
 
3250
 
 
3251
bool create_myisam_from_heap(Session *session, Table *table,
 
3252
                             MI_COLUMNDEF *start_recinfo,
 
3253
                             MI_COLUMNDEF **recinfo,
 
3254
                             int error, bool ignore_last_dupp_key_error)
 
3255
{
 
3256
  Table new_table;
 
3257
  TableShare share;
 
3258
  const char *save_proc_info;
 
3259
  int write_err;
 
3260
 
 
3261
  if (table->s->db_type() != heap_engine ||
 
3262
      error != HA_ERR_RECORD_FILE_FULL)
 
3263
  {
 
3264
    table->file->print_error(error,MYF(0));
 
3265
    return true;
 
3266
  }
 
3267
 
 
3268
  // Release latches since this can take a long time
 
3269
  plugin::StorageEngine::releaseTemporaryLatches(session);
 
3270
 
 
3271
  new_table= *table;
 
3272
  share= *table->s;
 
3273
  new_table.s= &share;
 
3274
  new_table.s->storage_engine= myisam_engine;
 
3275
  if (!(new_table.file= new_table.s->db_type()->getCursor(&share, &new_table.mem_root)))
 
3276
    return true;                                // End of memory
 
3277
 
 
3278
  save_proc_info=session->get_proc_info();
 
3279
  session->set_proc_info("converting HEAP to MyISAM");
 
3280
 
 
3281
  if (new_table.create_myisam_tmp_table(table->key_info, start_recinfo,
 
3282
                                        recinfo, session->lex->select_lex.options |
 
3283
                                        session->options))
 
3284
    goto err2;
 
3285
  if (new_table.open_tmp_table())
 
3286
    goto err1;
 
3287
  if (table->file->indexes_are_disabled())
 
3288
    new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);
 
3289
  table->file->ha_index_or_rnd_end();
 
3290
  table->file->ha_rnd_init(1);
 
3291
  if (table->no_rows)
 
3292
  {
 
3293
    new_table.file->extra(HA_EXTRA_NO_ROWS);
 
3294
    new_table.no_rows=1;
 
3295
  }
 
3296
 
 
3297
  /* HA_EXTRA_WRITE_CACHE can stay until close, no need to disable it */
 
3298
  new_table.file->extra(HA_EXTRA_WRITE_CACHE);
 
3299
 
 
3300
  /*
 
3301
    copy all old rows from heap table to MyISAM table
 
3302
    This is the only code that uses record[1] to read/write but this
 
3303
    is safe as this is a temporary MyISAM table without timestamp/autoincrement.
 
3304
  */
 
3305
  while (!table->file->rnd_next(new_table.record[1]))
 
3306
  {
 
3307
    write_err= new_table.file->ha_write_row(new_table.record[1]);
 
3308
    if (write_err)
 
3309
      goto err;
 
3310
  }
 
3311
  /* copy row that filled HEAP table */
 
3312
  if ((write_err=new_table.file->ha_write_row(table->record[0])))
 
3313
  {
 
3314
    if (new_table.file->is_fatal_error(write_err, HA_CHECK_DUP) ||
 
3315
        !ignore_last_dupp_key_error)
 
3316
      goto err;
 
3317
  }
 
3318
 
 
3319
  /* remove heap table and change to use myisam table */
 
3320
  (void) table->file->ha_rnd_end();
 
3321
  (void) table->file->close();                  // This deletes the table !
 
3322
  delete table->file;
 
3323
  table->file= NULL;
 
3324
  new_table.s= table->s;                       // Keep old share
 
3325
  *table= new_table;
 
3326
  *table->s= share;
 
3327
 
 
3328
  table->file->change_table_ptr(table, table->s);
 
3329
  table->use_all_columns();
 
3330
  if (save_proc_info)
 
3331
  {
 
3332
    const char *new_proc_info=
 
3333
      (!strcmp(save_proc_info,"Copying to tmp table") ?
 
3334
      "Copying to tmp table on disk" : save_proc_info);
 
3335
    session->set_proc_info(new_proc_info);
 
3336
  }
 
3337
  return false;
 
3338
 
 
3339
 err:
 
3340
  table->file->print_error(write_err, MYF(0));
 
3341
  (void) table->file->ha_rnd_end();
 
3342
  (void) new_table.file->close();
 
3343
 err1:
 
3344
  new_table.s->db_type()->doDeleteTable(session, new_table.s->table_name.str);
 
3345
 err2:
 
3346
  delete new_table.file;
 
3347
  session->set_proc_info(save_proc_info);
 
3348
  table->mem_root= new_table.mem_root;
 
3349
  return true;
 
3350
}
 
3351
 
 
3352
my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)
 
3353
{
 
3354
  my_bitmap_map *old= bitmap->getBitmap();
 
3355
  bitmap->setBitmap(s->all_set.getBitmap());
1418
3356
  return old;
1419
3357
}
1420
3358
 
1421
 
void Table::restore_column_map(const boost::dynamic_bitset<>& old)
 
3359
void Table::restore_column_map(my_bitmap_map *old)
1422
3360
{
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
 
  }
 
3361
  read_set->setBitmap(old);
1434
3362
}
1435
3363
 
1436
3364
uint32_t Table::find_shortest_key(const key_map *usable_keys)
1439
3367
  uint32_t best= MAX_KEY;
1440
3368
  if (usable_keys->any())
1441
3369
  {
1442
 
    for (uint32_t nr= 0; nr < getShare()->sizeKeys() ; nr++)
 
3370
    for (uint32_t nr= 0; nr < s->keys ; nr++)
1443
3371
    {
1444
3372
      if (usable_keys->test(nr))
1445
3373
      {
1466
3394
{
1467
3395
  for (; *ptr ; ptr++)
1468
3396
  {
1469
 
    if ((*ptr)->cmp_offset(getShare()->rec_buff_length))
 
3397
    if ((*ptr)->cmp_offset(s->rec_buff_length))
1470
3398
      return true;
1471
3399
  }
1472
3400
  return false;
1473
3401
}
1474
3402
 
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
 
 
 
3403
/* Return false if row hasn't changed */
 
3404
 
 
3405
bool Table::compare_record()
 
3406
{
 
3407
  if (s->blob_fields + s->varchar_fields == 0)
 
3408
    return memcmp(this->record[0], this->record[1], (size_t) s->reclength);
1536
3409
  /* 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
 
 
 
3410
  if (memcmp(null_flags,
 
3411
             null_flags + s->rec_buff_length,
 
3412
             s->null_bytes))
 
3413
    return true;                                // Diff in NULL value
1540
3414
  /* Compare updated fields */
1541
3415
  for (Field **ptr= field ; *ptr ; ptr++)
1542
3416
  {
1543
 
    if (isWriteSet((*ptr)->position()) &&
1544
 
        (*ptr)->cmp_binary_offset(getShare()->rec_buff_length))
 
3417
    if (isWriteSet((*ptr)->field_index) &&
 
3418
        (*ptr)->cmp_binary_offset(s->rec_buff_length))
1545
3419
      return true;
1546
3420
  }
1547
3421
  return false;
1553
3427
 */
1554
3428
void Table::storeRecord()
1555
3429
{
1556
 
  memcpy(getUpdateRecord(), getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3430
  memcpy(record[1], record[0], (size_t) s->reclength);
1557
3431
}
1558
3432
 
1559
3433
/*
1562
3436
 */
1563
3437
void Table::storeRecordAsInsert()
1564
3438
{
1565
 
  assert(insert_values.size() >= getShare()->getRecordLength());
1566
 
  memcpy(&insert_values[0], getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3439
  memcpy(insert_values, record[0], (size_t) s->reclength);
1567
3440
}
1568
3441
 
1569
3442
/*
1572
3445
 */
1573
3446
void Table::storeRecordAsDefault()
1574
3447
{
1575
 
  memcpy(getMutableShare()->getDefaultValues(), getInsertRecord(), (size_t) getShare()->getRecordLength());
 
3448
  memcpy(s->default_values, record[0], (size_t) s->reclength);
1576
3449
}
1577
3450
 
1578
3451
/*
1581
3454
 */
1582
3455
void Table::restoreRecord()
1583
3456
{
1584
 
  memcpy(getInsertRecord(), getUpdateRecord(), (size_t) getShare()->getRecordLength());
 
3457
  memcpy(record[0], record[1], (size_t) s->reclength);
1585
3458
}
1586
3459
 
1587
3460
/*
1590
3463
 */
1591
3464
void Table::restoreRecordAsDefault()
1592
3465
{
1593
 
  memcpy(getInsertRecord(), getMutableShare()->getDefaultValues(), (size_t) getShare()->getRecordLength());
 
3466
  memcpy(record[0], s->default_values, (size_t) s->reclength);
1594
3467
}
1595
3468
 
1596
3469
/*
1600
3473
void Table::emptyRecord()
1601
3474
{
1602
3475
  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;
 
3476
  memset(null_flags, 255, s->null_bytes);
1658
3477
}
1659
3478
 
1660
3479
/*****************************************************************************
1676
3495
    print them to the .err log
1677
3496
  */
1678
3497
  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));
 
3498
    errmsg_printf(ERRMSG_LVL_ERROR, _("Got error %d when reading table '%s'"),
 
3499
                    error, s->path.str);
 
3500
  file->print_error(error,MYF(0));
1682
3501
 
1683
3502
  return 1;
1684
3503
}
1691
3510
  null_row= 0;
1692
3511
  status= STATUS_NO_RECORD;
1693
3512
  maybe_null= table_list->outer_join;
1694
 
  TableList *embedding= table_list->getEmbedding();
 
3513
  TableList *embedding= table_list->embedding;
1695
3514
  while (!maybe_null && embedding)
1696
3515
  {
1697
3516
    maybe_null= embedding->outer_join;
1698
 
    embedding= embedding->getEmbedding();
 
3517
    embedding= embedding->embedding;
1699
3518
  }
1700
3519
  tablenr= table_number;
1701
3520
  map= (table_map) 1 << table_number;
1702
3521
  force_index= table_list->force_index;
1703
 
  covering_keys= getShare()->keys_for_keyread;
 
3522
  covering_keys= s->keys_for_keyread;
1704
3523
  merge_keys.reset();
1705
3524
}
1706
3525
 
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
 
}
 
3526
Field *Table::find_field_in_table_sef(const char *name)
 
3527
{
 
3528
  Field **field_ptr;
 
3529
  if (s->name_hash.records)
 
3530
  {
 
3531
    field_ptr= (Field**)hash_search(&s->name_hash,(unsigned char*) name,
 
3532
                                    strlen(name));
 
3533
    if (field_ptr)
 
3534
    {
 
3535
      /*
 
3536
        field_ptr points to field in TableShare. Convert it to the matching
 
3537
        field in table
 
3538
      */
 
3539
      field_ptr= (field + (field_ptr - s->field));
 
3540
    }
 
3541
  }
 
3542
  else
 
3543
  {
 
3544
    if (!(field_ptr= field))
 
3545
      return (Field *)0;
 
3546
    for (; *field_ptr; ++field_ptr)
 
3547
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
 
3548
        break;
 
3549
  }
 
3550
  if (field_ptr)
 
3551
    return *field_ptr;
 
3552
  else
 
3553
    return (Field *)0;
 
3554
}
 
3555
 
1756
3556
 
1757
3557
/*
1758
 
  Is this instance of the table should be reopen or represents a name-lock?
 
3558
  Used by ALTER Table when the table is a temporary one. It changes something
 
3559
  only if the ALTER contained a RENAME clause (otherwise, table_name is the old
 
3560
  name).
 
3561
  Prepares a table cache key, which is the concatenation of db, table_name and
 
3562
  session->slave_proxy_id, separated by '\0'.
1759
3563
*/
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 */
 
3564
 
 
3565
bool Table::rename_temporary_table(const char *db, const char *table_name)
 
3566
{
 
3567
  char *key;
 
3568
  uint32_t key_length;
 
3569
  TableShare *share= s;
 
3570
 
 
3571
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
 
3572
    return true;
 
3573
 
 
3574
  key_length= TableShare::createKey(key, db, table_name);
 
3575
  share->set_table_cache_key(key, key_length);
 
3576
 
 
3577
  return false;
 
3578
}
 
3579
 
 
3580
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
3581
template class List<String>;
 
3582
template class List_iterator<String>;
 
3583
#endif