← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/heap/ha_heap.cc

  • Committer: Monty Taylor
  • Date: 2008-11-16 23:47:43 UTC
  • mto: (584.1.10 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116234743-c38gmv0pa2kdefaj
Broke out cached_item.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/heap/ha_heap.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include "heap_priv.h"
 
16
#define DRIZZLE_SERVER 1
 
17
#include <drizzled/server_includes.h>
 
18
#include "ha_heap.h"
 
19
#include "heapdef.h"
17
20
#include <drizzled/error.h>
18
 
#include <drizzled/table.h>
19
 
#include <drizzled/session.h>
20
 
#include <drizzled/current_session.h>
21
 
#include <drizzled/field/timestamp.h>
22
 
#include <drizzled/field/varstring.h>
23
 
#include "drizzled/plugin/daemon.h"
24
 
 
25
 
#include "heap.h"
26
 
#include "ha_heap.h"
27
 
 
28
 
#include <string>
29
 
 
30
 
 
31
 
using namespace drizzled;
32
 
using namespace std;
33
 
 
34
 
static const string engine_name("MEMORY");
35
 
 
36
 
pthread_mutex_t THR_LOCK_heap= PTHREAD_MUTEX_INITIALIZER;
37
 
 
38
 
static const char *ha_heap_exts[] = {
39
 
  NULL
40
 
};
41
 
 
42
 
class HeapEngine : public plugin::StorageEngine
43
 
{
44
 
public:
45
 
  explicit HeapEngine(string name_arg) :
46
 
    plugin::StorageEngine(name_arg,
47
 
                          HTON_STATS_RECORDS_IS_EXACT |
48
 
                          HTON_NULL_IN_KEY |
49
 
                          HTON_FAST_KEY_READ |
50
 
                          HTON_NO_BLOBS |
51
 
                          HTON_HAS_RECORDS |
52
 
                          HTON_SKIP_STORE_LOCK |
53
 
                          HTON_TEMPORARY_ONLY)
54
 
  {
55
 
    pthread_mutex_init(&THR_LOCK_heap, MY_MUTEX_INIT_FAST);
56
 
  }
57
 
 
58
 
  virtual ~HeapEngine()
59
 
  {
60
 
    hp_panic(HA_PANIC_CLOSE);
61
 
 
62
 
    pthread_mutex_destroy(&THR_LOCK_heap);
63
 
  }
64
 
 
65
 
  virtual Cursor *create(TableShare &table,
66
 
                          memory::Root *mem_root)
67
 
  {
68
 
    return new (mem_root) ha_heap(*this, table);
69
 
  }
70
 
 
71
 
  const char **bas_ext() const {
72
 
    return ha_heap_exts;
73
 
  }
74
 
 
75
 
  int doCreateTable(Session &session,
76
 
                    Table &table_arg,
77
 
                    drizzled::TableIdentifier &identifier,
78
 
                    message::Table &create_proto);
79
 
 
80
 
  /* For whatever reason, internal tables can be created by Cursor::open()
81
 
     for MEMORY.
82
 
     Instead of diving down a rat hole, let's just cry ourselves to sleep
83
 
     at night with this odd hackish workaround.
84
 
   */
85
 
  int heap_create_table(Session *session, const char *table_name,
86
 
                        Table *table_arg,
87
 
                        bool internal_table,
88
 
                        message::Table &create_proto,
89
 
                        HP_SHARE **internal_share);
90
 
 
91
 
  int doRenameTable(Session&, TableIdentifier &from, TableIdentifier &to);
92
 
 
93
 
  int doDropTable(Session&, TableIdentifier &identifier);
94
 
 
95
 
  int doGetTableDefinition(Session& session,
96
 
                           TableIdentifier &identifier,
97
 
                           message::Table &table_message);
98
 
 
99
 
  /* Temp only engine, so do not return values. */
100
 
  void doGetTableNames(CachedDirectory &, SchemaIdentifier& , set<string>&) { };
101
 
 
102
 
  uint32_t max_supported_keys()          const { return MAX_KEY; }
103
 
  uint32_t max_supported_key_part_length() const { return MAX_KEY_LENGTH; }
104
 
 
105
 
  uint32_t index_flags(enum  ha_key_alg algorithm) const
106
 
  {
107
 
    return ((algorithm == HA_KEY_ALG_BTREE) ?
108
 
            HA_READ_NEXT |
109
 
            HA_READ_PREV |
110
 
            HA_READ_ORDER |
111
 
            HA_READ_RANGE :
112
 
            HA_ONLY_WHOLE_INDEX |
113
 
            HA_KEY_SCAN_NOT_ROR);
114
 
  }
115
 
 
116
 
  bool doDoesTableExist(Session& session, TableIdentifier &identifier);
117
 
  void doGetTableIdentifiers(drizzled::CachedDirectory &directory,
118
 
                             drizzled::SchemaIdentifier &schema_identifier,
119
 
                             drizzled::TableIdentifiers &set_of_identifiers);
120
 
};
121
 
 
122
 
void HeapEngine::doGetTableIdentifiers(drizzled::CachedDirectory&,
123
 
                                       drizzled::SchemaIdentifier&,
124
 
                                       drizzled::TableIdentifiers&)
125
 
{
126
 
}
127
 
 
128
 
bool HeapEngine::doDoesTableExist(Session& session, TableIdentifier &identifier)
129
 
{
130
 
  return session.doesTableMessageExist(identifier);
131
 
}
132
 
 
133
 
int HeapEngine::doGetTableDefinition(Session &session,
134
 
                                     TableIdentifier &identifier,
135
 
                                     message::Table &table_proto)
136
 
{
137
 
  if (session.getTableMessage(identifier, table_proto))
138
 
    return EEXIST;
139
 
 
140
 
  return ENOENT;
141
 
}
142
 
/*
143
 
  We have to ignore ENOENT entries as the MEMORY table is created on open and
144
 
  not when doing a CREATE on the table.
145
 
*/
146
 
int HeapEngine::doDropTable(Session &session, TableIdentifier &identifier)
147
 
{
148
 
  session.removeTableMessage(identifier);
149
 
 
150
 
  int error= heap_delete_table(identifier.getPath().c_str());
151
 
 
152
 
  if (error == ENOENT)
153
 
    error= 0;
154
 
 
155
 
  return error;
156
 
}
157
 
 
158
 
static HeapEngine *heap_storage_engine= NULL;
159
 
 
160
 
static int heap_init(plugin::Context &context)
161
 
{
162
 
  heap_storage_engine= new HeapEngine(engine_name);
163
 
  context.add(heap_storage_engine);
 
21
 
 
22
static handler *heap_create_handler(handlerton *hton,
 
23
                                    TABLE_SHARE *table, 
 
24
                                    MEM_ROOT *mem_root);
 
25
 
 
26
int heap_deinit(void *p __attribute__((unused)))
 
27
            
 
28
{
 
29
  return hp_panic(HA_PANIC_CLOSE);
 
30
}
 
31
 
 
32
 
 
33
int heap_init(void *p)
 
34
{
 
35
  handlerton *heap_hton;
 
36
 
 
37
  heap_hton= (handlerton *)p;
 
38
  heap_hton->state=      SHOW_OPTION_YES;
 
39
  heap_hton->create=     heap_create_handler;
 
40
  heap_hton->flags=      HTON_CAN_RECREATE;
 
41
 
164
42
  return 0;
165
43
}
166
44
 
 
45
static handler *heap_create_handler(handlerton *hton,
 
46
                                    TABLE_SHARE *table, 
 
47
                                    MEM_ROOT *mem_root)
 
48
{
 
49
  return new (mem_root) ha_heap(hton, table);
 
50
}
 
51
 
167
52
 
168
53
/*****************************************************************************
169
 
** MEMORY tables
 
54
** HEAP tables
170
55
*****************************************************************************/
171
56
 
172
 
ha_heap::ha_heap(plugin::StorageEngine &engine_arg,
173
 
                 TableShare &table_arg)
174
 
  :Cursor(engine_arg, table_arg), file(0), records_changed(0), key_stat_version(0),
 
57
ha_heap::ha_heap(handlerton *hton, TABLE_SHARE *table_arg)
 
58
  :handler(hton, table_arg), file(0), records_changed(0), key_stat_version(0), 
175
59
  internal_table(0)
176
60
{}
177
61
 
 
62
 
 
63
static const char *ha_heap_exts[] = {
 
64
  NULL
 
65
};
 
66
 
 
67
const char **ha_heap::bas_ext() const
 
68
{
 
69
  return ha_heap_exts;
 
70
}
 
71
 
178
72
/*
179
 
  Hash index statistics is updated (copied from HP_KEYDEF::hash_buckets to
180
 
  rec_per_key) after 1/MEMORY_STATS_UPDATE_THRESHOLD fraction of table records
181
 
  have been inserted/updated/deleted. delete_all_rows() and table flush cause
 
73
  Hash index statistics is updated (copied from HP_KEYDEF::hash_buckets to 
 
74
  rec_per_key) after 1/HEAP_STATS_UPDATE_THRESHOLD fraction of table records 
 
75
  have been inserted/updated/deleted. delete_all_rows() and table flush cause 
182
76
  immediate update.
183
77
 
184
78
  NOTE
185
79
   hash index statistics must be updated when number of table records changes
186
 
   from 0 to non-zero value and vice versa. Otherwise records_in_range may
 
80
   from 0 to non-zero value and vice versa. Otherwise records_in_range may 
187
81
   erroneously return 0 and 'range' may miss records.
188
82
*/
189
 
#define MEMORY_STATS_UPDATE_THRESHOLD 10
 
83
#define HEAP_STATS_UPDATE_THRESHOLD 10
190
84
 
191
85
int ha_heap::open(const char *name, int mode, uint32_t test_if_locked)
192
86
{
193
 
  if ((test_if_locked & HA_OPEN_INTERNAL_TABLE) || (!(file= heap_open(name, mode)) && errno == ENOENT))
 
87
  if ((test_if_locked & HA_OPEN_INTERNAL_TABLE) || (!(file= heap_open(name, mode)) && my_errno == ENOENT))
194
88
  {
195
89
    HA_CREATE_INFO create_info;
196
90
    internal_table= test(test_if_locked & HA_OPEN_INTERNAL_TABLE);
197
91
    memset(&create_info, 0, sizeof(create_info));
198
92
    file= 0;
199
 
    HP_SHARE *internal_share= NULL;
200
 
    message::Table create_proto;
201
 
 
202
 
    if (!heap_storage_engine->heap_create_table(ha_session(), name, table,
203
 
                                                internal_table,
204
 
                                                create_proto,
205
 
                                                &internal_share))
 
93
    if (!create(name, table, &create_info))
206
94
    {
207
95
        file= internal_table ?
208
96
          heap_open_from_share(internal_share, mode) :
245
133
  Create a copy of this table
246
134
 
247
135
  DESCRIPTION
248
 
    Do same as default implementation but use file->s->name instead of
 
136
    Do same as default implementation but use file->s->name instead of 
249
137
    table->s->path. This is needed by Windows where the clone() call sees
250
 
    '/'-delimited path in table->s->path, while ha_peap::open() was called
 
138
    '/'-delimited path in table->s->path, while ha_peap::open() was called 
251
139
    with '\'-delimited path.
252
140
*/
253
141
 
254
 
Cursor *ha_heap::clone(memory::Root *mem_root)
 
142
handler *ha_heap::clone(MEM_ROOT *mem_root)
255
143
{
256
 
  Cursor *new_handler= table->s->db_type()->getCursor(*table->s, mem_root);
257
 
 
 
144
  handler *new_handler= get_new_handler(table->s, mem_root, table->s->db_type());
258
145
  if (new_handler && !new_handler->ha_open(table, file->s->name, table->db_stat,
259
146
                                           HA_OPEN_IGNORE_IF_LOCKED))
260
147
    return new_handler;
261
 
  return NULL;
262
 
}
263
 
 
264
 
 
265
 
const char *ha_heap::index_type(uint32_t inx)
266
 
{
267
 
  return ((table_share->key_info[inx].algorithm == HA_KEY_ALG_BTREE) ?
268
 
          "BTREE" : "HASH");
 
148
  return NULL;  /* purecov: inspected */
269
149
}
270
150
 
271
151
 
287
167
 
288
168
void ha_heap::set_keys_for_scanning(void)
289
169
{
290
 
  btree_keys.reset();
 
170
  btree_keys.clear_all();
291
171
  for (uint32_t i= 0 ; i < table->s->keys ; i++)
292
172
  {
293
173
    if (table->key_info[i].algorithm == HA_KEY_ALG_BTREE)
294
 
      btree_keys.set(i);
 
174
      btree_keys.set_bit(i);
295
175
  }
296
176
}
297
177
 
326
206
int ha_heap::write_row(unsigned char * buf)
327
207
{
328
208
  int res;
329
 
  ha_statistic_increment(&system_status_var::ha_write_count);
 
209
  ha_statistic_increment(&SSV::ha_write_count);
 
210
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
 
211
    table->timestamp_field->set_time();
330
212
  if (table->next_number_field && buf == table->record[0])
331
213
  {
332
214
    if ((res= update_auto_increment()))
333
215
      return res;
334
216
  }
335
217
  res= heap_write(file,buf);
336
 
  if (!res && (++records_changed*MEMORY_STATS_UPDATE_THRESHOLD >
 
218
  if (!res && (++records_changed*HEAP_STATS_UPDATE_THRESHOLD > 
337
219
               file->s->records))
338
220
  {
339
221
    /*
348
230
int ha_heap::update_row(const unsigned char * old_data, unsigned char * new_data)
349
231
{
350
232
  int res;
351
 
  ha_statistic_increment(&system_status_var::ha_update_count);
 
233
  ha_statistic_increment(&SSV::ha_update_count);
352
234
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
353
235
    table->timestamp_field->set_time();
354
236
  res= heap_update(file,old_data,new_data);
355
 
  if (!res && ++records_changed*MEMORY_STATS_UPDATE_THRESHOLD >
 
237
  if (!res && ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > 
356
238
              file->s->records)
357
239
  {
358
240
    /*
367
249
int ha_heap::delete_row(const unsigned char * buf)
368
250
{
369
251
  int res;
370
 
  ha_statistic_increment(&system_status_var::ha_delete_count);
 
252
  ha_statistic_increment(&SSV::ha_delete_count);
371
253
  res= heap_delete(file,buf);
372
 
  if (!res && table->s->tmp_table == message::Table::STANDARD &&
373
 
      ++records_changed*MEMORY_STATS_UPDATE_THRESHOLD > file->s->records)
 
254
  if (!res && table->s->tmp_table == NO_TMP_TABLE && 
 
255
      ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > file->s->records)
374
256
  {
375
257
    /*
376
258
       We can perform this safely since only one writer at the time is
386
268
                            enum ha_rkey_function find_flag)
387
269
{
388
270
  assert(inited==INDEX);
389
 
  ha_statistic_increment(&system_status_var::ha_read_key_count);
 
271
  ha_statistic_increment(&SSV::ha_read_key_count);
390
272
  int error = heap_rkey(file,buf,active_index, key, keypart_map, find_flag);
391
273
  table->status = error ? STATUS_NOT_FOUND : 0;
392
274
  return error;
396
278
                                 key_part_map keypart_map)
397
279
{
398
280
  assert(inited==INDEX);
399
 
  ha_statistic_increment(&system_status_var::ha_read_key_count);
 
281
  ha_statistic_increment(&SSV::ha_read_key_count);
400
282
  int error= heap_rkey(file, buf, active_index, key, keypart_map,
401
283
                       HA_READ_PREFIX_LAST);
402
284
  table->status= error ? STATUS_NOT_FOUND : 0;
407
289
                                key_part_map keypart_map,
408
290
                                enum ha_rkey_function find_flag)
409
291
{
410
 
  ha_statistic_increment(&system_status_var::ha_read_key_count);
 
292
  ha_statistic_increment(&SSV::ha_read_key_count);
411
293
  int error = heap_rkey(file, buf, index, key, keypart_map, find_flag);
412
294
  table->status = error ? STATUS_NOT_FOUND : 0;
413
295
  return error;
416
298
int ha_heap::index_next(unsigned char * buf)
417
299
{
418
300
  assert(inited==INDEX);
419
 
  ha_statistic_increment(&system_status_var::ha_read_next_count);
 
301
  ha_statistic_increment(&SSV::ha_read_next_count);
420
302
  int error=heap_rnext(file,buf);
421
303
  table->status=error ? STATUS_NOT_FOUND: 0;
422
304
  return error;
425
307
int ha_heap::index_prev(unsigned char * buf)
426
308
{
427
309
  assert(inited==INDEX);
428
 
  ha_statistic_increment(&system_status_var::ha_read_prev_count);
 
310
  ha_statistic_increment(&SSV::ha_read_prev_count);
429
311
  int error=heap_rprev(file,buf);
430
312
  table->status=error ? STATUS_NOT_FOUND: 0;
431
313
  return error;
434
316
int ha_heap::index_first(unsigned char * buf)
435
317
{
436
318
  assert(inited==INDEX);
437
 
  ha_statistic_increment(&system_status_var::ha_read_first_count);
 
319
  ha_statistic_increment(&SSV::ha_read_first_count);
438
320
  int error=heap_rfirst(file, buf, active_index);
439
321
  table->status=error ? STATUS_NOT_FOUND: 0;
440
322
  return error;
443
325
int ha_heap::index_last(unsigned char * buf)
444
326
{
445
327
  assert(inited==INDEX);
446
 
  ha_statistic_increment(&system_status_var::ha_read_last_count);
 
328
  ha_statistic_increment(&SSV::ha_read_last_count);
447
329
  int error=heap_rlast(file, buf, active_index);
448
330
  table->status=error ? STATUS_NOT_FOUND: 0;
449
331
  return error;
456
338
 
457
339
int ha_heap::rnd_next(unsigned char *buf)
458
340
{
459
 
  ha_statistic_increment(&system_status_var::ha_read_rnd_next_count);
 
341
  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
460
342
  int error=heap_scan(file, buf);
461
343
  table->status=error ? STATUS_NOT_FOUND: 0;
462
344
  return error;
466
348
{
467
349
  int error;
468
350
  HEAP_PTR heap_position;
469
 
  ha_statistic_increment(&system_status_var::ha_read_rnd_count);
 
351
  ha_statistic_increment(&SSV::ha_read_rnd_count);
470
352
  memcpy(&heap_position, pos, sizeof(HEAP_PTR));
471
353
  error=heap_rrnd(file, buf, heap_position);
472
354
  table->status=error ? STATUS_NOT_FOUND: 0;
473
355
  return error;
474
356
}
475
357
 
476
 
void ha_heap::position(const unsigned char *)
 
358
void ha_heap::position(const unsigned char *record __attribute__((unused)))
477
359
{
478
360
  *(HEAP_PTR*) ref= heap_position(file);        // Ref is aligned
479
361
}
527
409
int ha_heap::delete_all_rows()
528
410
{
529
411
  heap_clear(file);
530
 
  if (table->s->tmp_table == message::Table::STANDARD)
 
412
  if (table->s->tmp_table == NO_TMP_TABLE)
531
413
  {
532
414
    /*
533
415
       We can perform this safely since only one writer at the time is
538
420
  return 0;
539
421
}
540
422
 
 
423
int ha_heap::external_lock(Session *session __attribute__((unused)),
 
424
                           int lock_type __attribute__((unused)))
 
425
{
 
426
  return 0;                                     // No external locking
 
427
}
 
428
 
 
429
 
541
430
/*
542
431
  Disable indexes.
543
432
 
596
485
    The indexes might have been disabled by disable_index() before.
597
486
    The function works only if both data and indexes are empty,
598
487
    since the heap storage engine cannot repair the indexes.
599
 
    To be sure, call Cursor::delete_all_rows() before.
 
488
    To be sure, call handler::delete_all_rows() before.
600
489
 
601
490
  IMPLEMENTATION
602
491
    HA_KEY_SWITCH_NONUNIQ       is not implemented.
645
534
  return heap_indexes_are_disabled(file);
646
535
}
647
536
 
648
 
void ha_heap::drop_table(const char *)
 
537
THR_LOCK_DATA **ha_heap::store_lock(Session *session __attribute__((unused)),
 
538
                                    THR_LOCK_DATA **to,
 
539
                                    enum thr_lock_type lock_type)
 
540
{
 
541
  if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
 
542
    file->lock.type=lock_type;
 
543
  *to++= &file->lock;
 
544
  return to;
 
545
}
 
546
 
 
547
/*
 
548
  We have to ignore ENOENT entries as the HEAP table is created on open and
 
549
  not when doing a CREATE on the table.
 
550
*/
 
551
 
 
552
int ha_heap::delete_table(const char *name)
 
553
{
 
554
  int error= heap_delete_table(name);
 
555
  return error == ENOENT ? 0 : error;
 
556
}
 
557
 
 
558
 
 
559
void ha_heap::drop_table(const char *name __attribute__((unused)))
649
560
{
650
561
  file->s->delete_on_close= 1;
651
562
  close();
652
563
}
653
564
 
654
565
 
655
 
int HeapEngine::doRenameTable(Session &session, TableIdentifier &from, TableIdentifier &to)
 
566
int ha_heap::rename_table(const char * from, const char * to)
656
567
{
657
 
  session.renameTableMessage(from, to);
658
 
  return heap_rename(from.getPath().c_str(), to.getPath().c_str());
 
568
  return heap_rename(from,to);
659
569
}
660
570
 
661
571
 
681
591
  return key->rec_per_key[key->key_parts-1];
682
592
}
683
593
 
684
 
int HeapEngine::doCreateTable(Session &session,
685
 
                              Table &table_arg,
686
 
                              drizzled::TableIdentifier &identifier,
687
 
                              message::Table& create_proto)
688
 
{
689
 
  int error;
690
 
  HP_SHARE *internal_share;
691
 
  const char *table_name= identifier.getPath().c_str();
692
 
 
693
 
  error= heap_create_table(&session, table_name, &table_arg,
694
 
                           false, 
695
 
                           create_proto,
696
 
                           &internal_share);
697
 
 
698
 
  if (error == 0)
699
 
  {
700
 
    session.storeTableMessage(identifier, create_proto);
701
 
  }
702
 
 
703
 
  return error;
704
 
}
705
 
 
706
 
 
707
 
int HeapEngine::heap_create_table(Session *session, const char *table_name,
708
 
                                  Table *table_arg,
709
 
                                  bool internal_table, 
710
 
                                  message::Table &create_proto,
711
 
                                  HP_SHARE **internal_share)
 
594
 
 
595
int ha_heap::create(const char *name, Table *table_arg,
 
596
                    HA_CREATE_INFO *create_info)
712
597
{
713
598
  uint32_t key, parts, mem_per_row_keys= 0, keys= table_arg->s->keys;
714
599
  uint32_t auto_key= 0, auto_key_type= 0;
719
604
  HA_KEYSEG *seg;
720
605
  char buff[FN_REFLEN];
721
606
  int error;
722
 
  TableShare *share= table_arg->s;
 
607
  TABLE_SHARE *share= table_arg->s;
723
608
  bool found_real_auto_increment= 0;
724
609
 
725
 
  /* 
726
 
   * We cannot create tables with more rows than UINT32_MAX.  This is a
727
 
   * limitation of the HEAP engine.  Here, since TableShare::getMaxRows()
728
 
   * can return a number more than that, we trap it here instead of casting
729
 
   * to a truncated integer.
730
 
   */
731
 
  uint64_t num_rows= share->getMaxRows();
732
 
  if (num_rows > UINT32_MAX)
733
 
    return -1;
734
 
 
735
 
  if (!(columndef= (HP_COLUMNDEF*) malloc(column_count * sizeof(HP_COLUMNDEF))))
736
 
    return errno;
 
610
  if (!(columndef= (HP_COLUMNDEF*) my_malloc(column_count * sizeof(HP_COLUMNDEF), MYF(MY_WME))))
 
611
    return my_errno;
737
612
 
738
613
  for (column_idx= 0; column_idx < column_count; column_idx++)
739
614
  {
767
642
  for (key= parts= 0; key < keys; key++)
768
643
    parts+= table_arg->key_info[key].key_parts;
769
644
 
770
 
  if (!(keydef= (HP_KEYDEF*) malloc(keys * sizeof(HP_KEYDEF) +
771
 
                                    parts * sizeof(HA_KEYSEG))))
 
645
  if (!(keydef= (HP_KEYDEF*) my_malloc(keys * sizeof(HP_KEYDEF) +
 
646
                                       parts * sizeof(HA_KEYSEG),
 
647
                                       MYF(MY_WME))))
772
648
  {
773
649
    free((void *) columndef);
774
 
    return errno;
 
650
    return my_errno;
775
651
  }
776
652
 
777
653
  seg= reinterpret_cast<HA_KEYSEG*> (keydef + keys);
828
704
        key_part_size= next_field_pos;
829
705
      }
830
706
 
831
 
      if (field->flags & ENUM_FLAG)
 
707
      if (field->flags & (ENUM_FLAG | SET_FLAG))
832
708
        seg->charset= &my_charset_bin;
833
709
      else
834
710
        seg->charset= field->charset();
860
736
      }
861
737
    }
862
738
  }
863
 
 
 
739
  
864
740
  if (key_part_size < share->null_bytes + ((share->last_null_bit_pos+7) >> 3))
865
741
  {
866
742
    /* Make sure to include null fields regardless of the presense of keys */
867
743
    key_part_size = share->null_bytes + ((share->last_null_bit_pos+7) >> 3);
868
744
  }
869
745
 
870
 
 
871
 
 
 
746
  
 
747
  
872
748
  if (table_arg->found_next_number_field)
873
749
  {
874
750
    keydef[share->next_number_index].flag|= HA_AUTO_KEY;
877
753
  HP_CREATE_INFO hp_create_info;
878
754
  hp_create_info.auto_key= auto_key;
879
755
  hp_create_info.auto_key_type= auto_key_type;
880
 
  hp_create_info.auto_increment= (create_proto.options().has_auto_increment_value() ?
881
 
                                  create_proto.options().auto_increment_value() - 1 : 0);
882
 
  hp_create_info.max_table_size=session->variables.max_heap_table_size;
 
756
  hp_create_info.auto_increment= (create_info->auto_increment_value ?
 
757
                                  create_info->auto_increment_value - 1 : 0);
 
758
  hp_create_info.max_table_size=current_session->variables.max_heap_table_size;
883
759
  hp_create_info.with_auto_increment= found_real_auto_increment;
884
760
  hp_create_info.internal_table= internal_table;
885
761
  hp_create_info.max_chunk_size= share->block_size;
886
762
  hp_create_info.is_dynamic= (share->row_type == ROW_TYPE_DYNAMIC);
887
 
 
888
 
  error= heap_create(internal::fn_format(buff,table_name,"","",
889
 
                              MY_REPLACE_EXT|MY_UNPACK_FILENAME),
890
 
                    keys, keydef,
891
 
                    column_count, columndef,
892
 
                    max_key_fieldnr, key_part_size,
893
 
                    share->reclength, mem_per_row_keys,
894
 
                    static_cast<uint32_t>(num_rows), /* We check for overflow above, so cast is fine here. */
895
 
                    0, // Factor out MIN
896
 
                    &hp_create_info, internal_share);
897
 
 
 
763
  error= heap_create(fn_format(buff,name,"","",
 
764
                               MY_REPLACE_EXT|MY_UNPACK_FILENAME),
 
765
                   keys, keydef,
 
766
         column_count, columndef,
 
767
         max_key_fieldnr, key_part_size,
 
768
         share->reclength, mem_per_row_keys,
 
769
         (uint32_t) share->max_rows, (uint32_t) share->min_rows,
 
770
         &hp_create_info, &internal_share);
 
771
  
898
772
  free((unsigned char*) keydef);
899
773
  free((void *) columndef);
900
 
 
 
774
  assert(file == 0);
901
775
  return (error);
902
776
}
903
777
 
904
778
 
905
 
void ha_heap::get_auto_increment(uint64_t, uint64_t, uint64_t,
 
779
void ha_heap::update_create_info(HA_CREATE_INFO *create_info)
 
780
{
 
781
  table->file->info(HA_STATUS_AUTO);
 
782
  if (!(create_info->used_fields & HA_CREATE_USED_AUTO))
 
783
    create_info->auto_increment_value= stats.auto_increment_value;
 
784
  if (!(create_info->used_fields & HA_CREATE_USED_BLOCK_SIZE))
 
785
  {
 
786
    if (file->s->recordspace.is_variable_size)
 
787
      create_info->block_size= file->s->recordspace.chunk_length;
 
788
    else
 
789
      create_info->block_size= 0;
 
790
  }
 
791
}
 
792
 
 
793
void ha_heap::get_auto_increment(uint64_t offset __attribute__((unused)),
 
794
                                 uint64_t increment __attribute__((unused)),
 
795
                                 uint64_t nb_desired_values __attribute__((unused)),
906
796
                                 uint64_t *first_value,
907
797
                                 uint64_t *nb_reserved_values)
908
798
{
913
803
}
914
804
 
915
805
 
916
 
int ha_heap::cmp_ref(const unsigned char *ref1, const unsigned char *ref2)
 
806
bool ha_heap::check_if_incompatible_data(HA_CREATE_INFO *info,
 
807
                                         uint32_t table_changes)
917
808
{
918
 
  return memcmp(ref1, ref2, sizeof(HEAP_PTR));
 
809
  /* Check that auto_increment value was not changed */
 
810
  if ((info->used_fields & HA_CREATE_USED_AUTO &&
 
811
       info->auto_increment_value != 0) ||
 
812
      table_changes == IS_EQUAL_NO ||
 
813
      table_changes & IS_EQUAL_PACK_LENGTH) // Not implemented yet
 
814
    return COMPATIBLE_DATA_NO;
 
815
  return COMPATIBLE_DATA_YES;
919
816
}
920
817
 
921
 
 
922
 
DRIZZLE_DECLARE_PLUGIN
 
818
mysql_declare_plugin(heap)
923
819
{
924
 
  DRIZZLE_VERSION_ID,
 
820
  DRIZZLE_STORAGE_ENGINE_PLUGIN,
925
821
  "MEMORY",
926
822
  "1.0",
927
823
  "MySQL AB",
928
824
  "Hash based, stored in memory, useful for temporary tables",
929
825
  PLUGIN_LICENSE_GPL,
930
826
  heap_init,
 
827
  heap_deinit,
 
828
  NULL,                       /* status variables                */
931
829
  NULL,                       /* system variables                */
932
830
  NULL                        /* config options                  */
933
831
}
934
 
DRIZZLE_DECLARE_PLUGIN_END;
 
832
mysql_declare_plugin_end;