ha_heap.cc 19 KB
Newer Older
1
/* Copyright (C) 2000,2004 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


18
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
19 20 21 22 23 24 25
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include <myisampack.h>
#include "ha_heap.h"

26

unknown's avatar
unknown committed
27
static handler *heap_create_handler(TABLE_SHARE *table);
28

29
handlerton heap_hton= {
unknown's avatar
unknown committed
30
  MYSQL_HANDLERTON_INTERFACE_VERSION,
31
  "MEMORY",
32 33 34 35
  SHOW_OPTION_YES,
  "Hash based, stored in memory, useful for temporary tables", 
  DB_TYPE_HEAP,
  NULL,
36 37
  0,       /* slot */
  0,       /* savepoint size. */
38 39 40 41 42 43 44 45 46 47 48 49 50
  NULL,    /* close_connection */
  NULL,    /* savepoint */
  NULL,    /* rollback to savepoint */
  NULL,    /* release savepoint */
  NULL,    /* commit */
  NULL,    /* rollback */
  NULL,    /* prepare */
  NULL,    /* recover */
  NULL,    /* commit_by_xid */
  NULL,    /* rollback_by_xid */
  NULL,    /* create_cursor_read_view */
  NULL,    /* set_cursor_read_view */
  NULL,    /* close_cursor_read_view */
51 52 53 54 55 56
  heap_create_handler,    /* Create a new handler */
  NULL,    /* Drop a database */
  heap_panic,    /* Panic call */
  NULL,    /* Start Consistent Snapshot */
  NULL,    /* Flush logs */
  NULL,    /* Show status */
unknown's avatar
unknown committed
57 58
  NULL,    /* Partition flags */
  NULL,    /* Alter table flags */
unknown's avatar
unknown committed
59
  NULL,    /* Alter Tablespace */
60
  NULL,    /* Fill Files Table */
61
  HTON_CAN_RECREATE
62 63
};

unknown's avatar
unknown committed
64
static handler *heap_create_handler(TABLE_SHARE *table)
65 66 67 68 69
{
  return new ha_heap(table);
}


unknown's avatar
unknown committed
70 71 72
/*****************************************************************************
** HEAP tables
*****************************************************************************/
73

unknown's avatar
unknown committed
74
ha_heap::ha_heap(TABLE_SHARE *table_arg)
75
  :handler(&heap_hton, table_arg), file(0), records_changed(0),
unknown's avatar
unknown committed
76
  key_stat_version(0)
77 78 79
{}


unknown's avatar
unknown committed
80 81 82
static const char *ha_heap_exts[] = {
  NullS
};
unknown's avatar
unknown committed
83 84

const char **ha_heap::bas_ext() const
unknown's avatar
unknown committed
85 86 87
{
  return ha_heap_exts;
}
unknown's avatar
unknown committed
88

89 90
/*
  Hash index statistics is updated (copied from HP_KEYDEF::hash_buckets to 
91 92 93 94 95 96 97 98
  rec_per_key) after 1/HEAP_STATS_UPDATE_THRESHOLD fraction of table records 
  have been inserted/updated/deleted. delete_all_rows() and table flush cause 
  immediate update.

  NOTE
   hash index statistics must be updated when number of table records changes
   from 0 to non-zero value and vice versa. Otherwise records_in_range may 
   erroneously return 0 and 'range' may miss records.
99 100
*/
#define HEAP_STATS_UPDATE_THRESHOLD 10
unknown's avatar
unknown committed
101

102
int ha_heap::open(const char *name, int mode, uint test_if_locked)
unknown's avatar
unknown committed
103
{
unknown's avatar
unknown committed
104
  if (!(file= heap_open(name, mode)) && my_errno == ENOENT)
unknown's avatar
unknown committed
105
  {
unknown's avatar
unknown committed
106 107 108
    HA_CREATE_INFO create_info;
    bzero(&create_info, sizeof(create_info));
    if (!create(name, table, &create_info))
unknown's avatar
unknown committed
109
    {
unknown's avatar
unknown committed
110
      file= heap_open(name, mode);
unknown's avatar
unknown committed
111 112
      implicit_emptied= 1;
    }
unknown's avatar
unknown committed
113
  }
unknown's avatar
unknown committed
114
  ref_length= sizeof(HEAP_PTR);
115 116 117
  if (file)
  {
    /* Initialize variables for the opened table */
118
    set_keys_for_scanning();
119 120 121 122 123 124 125 126
    /*
      We cannot run update_key_stats() here because we do not have a
      lock on the table. The 'records' count might just be changed
      temporarily at this moment and we might get wrong statistics (Bug
      #10178). Instead we request for update. This will be done in
      ha_heap::info(), which is always called before key statistics are
      used.
    */
127
    key_stat_version= file->s->key_stat_version-1;
128
  }
unknown's avatar
unknown committed
129
  return (file ? 0 : 1);
unknown's avatar
unknown committed
130 131 132 133 134 135 136
}

int ha_heap::close(void)
{
  return heap_close(file);
}

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

/*
  Compute which keys to use for scanning

  SYNOPSIS
    set_keys_for_scanning()
    no parameter

  DESCRIPTION
    Set the bitmap btree_keys, which is used when the upper layers ask
    which keys to use for scanning. For each btree index the
    corresponding bit is set.

  RETURN
    void
*/

void ha_heap::set_keys_for_scanning(void)
{
  btree_keys.clear_all();
157
  for (uint i= 0 ; i < table->s->keys ; i++)
158 159 160 161 162 163
  {
    if (table->key_info[i].algorithm == HA_KEY_ALG_BTREE)
      btree_keys.set_bit(i);
  }
}

164

165 166
void ha_heap::update_key_stats()
{
167
  for (uint i= 0; i < table->s->keys; i++)
168 169
  {
    KEY *key=table->key_info+i;
170 171
    if (!key->rec_per_key)
      continue;
172 173
    if (key->algorithm != HA_KEY_ALG_BTREE)
    {
174 175 176 177 178 179 180 181 182 183
      if (key->flags & HA_NOSAME)
        key->rec_per_key[key->key_parts-1]= 1;
      else
      {
        ha_rows hash_buckets= file->s->keydef[i].hash_buckets;
        uint no_records= hash_buckets ? file->s->records/hash_buckets : 2;
        if (no_records < 2)
          no_records= 2;
        key->rec_per_key[key->key_parts-1]= no_records;
      }
184 185 186
    }
  }
  records_changed= 0;
187
  /* At the end of update_key_stats() we can proudly claim they are OK. */
188
  key_stat_version= file->s->key_stat_version;
189 190
}

191

unknown's avatar
unknown committed
192 193
int ha_heap::write_row(byte * buf)
{
194
  int res;
195
  statistic_increment(table->in_use->status_var.ha_write_count,&LOCK_status);
196 197
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
    table->timestamp_field->set_time();
unknown's avatar
unknown committed
198 199
  if (table->next_number_field && buf == table->record[0])
    update_auto_increment();
200
  res= heap_write(file,buf);
unknown's avatar
unknown committed
201 202
  if (!res && (++records_changed*HEAP_STATS_UPDATE_THRESHOLD > 
               file->s->records))
203 204 205 206 207
  {
    /*
       We can perform this safely since only one writer at the time is
       allowed on the table.
    */
208
    file->s->key_stat_version++;
209
  }
210
  return res;
unknown's avatar
unknown committed
211 212 213 214
}

int ha_heap::update_row(const byte * old_data, byte * new_data)
{
215
  int res;
unknown's avatar
unknown committed
216
  statistic_increment(table->in_use->status_var.ha_update_count,&LOCK_status);
217 218
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
    table->timestamp_field->set_time();
219
  res= heap_update(file,old_data,new_data);
220 221
  if (!res && ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > 
              file->s->records)
222 223 224 225 226
  {
    /*
       We can perform this safely since only one writer at the time is
       allowed on the table.
    */
227
    file->s->key_stat_version++;
228
  }
229
  return res;
unknown's avatar
unknown committed
230 231 232 233
}

int ha_heap::delete_row(const byte * buf)
{
234
  int res;
235
  statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status);
236
  res= heap_delete(file,buf);
237
  if (!res && table->s->tmp_table == NO_TMP_TABLE && 
238
      ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > file->s->records)
239 240 241 242 243
  {
    /*
       We can perform this safely since only one writer at the time is
       allowed on the table.
    */
244
    file->s->key_stat_version++;
245
  }
246
  return res;
unknown's avatar
unknown committed
247 248
}

249 250
int ha_heap::index_read(byte * buf, const byte * key, uint key_len,
			enum ha_rkey_function find_flag)
unknown's avatar
unknown committed
251
{
unknown's avatar
unknown committed
252
  DBUG_ASSERT(inited==INDEX);
253 254
  statistic_increment(table->in_use->status_var.ha_read_key_count,
		      &LOCK_status);
255 256
  int error = heap_rkey(file,buf,active_index, key, key_len, find_flag);
  table->status = error ? STATUS_NOT_FOUND : 0;
unknown's avatar
unknown committed
257 258 259
  return error;
}

260 261
int ha_heap::index_read_last(byte *buf, const byte *key, uint key_len)
{
unknown's avatar
unknown committed
262
  DBUG_ASSERT(inited==INDEX);
263 264
  statistic_increment(table->in_use->status_var.ha_read_key_count,
		      &LOCK_status);
265 266 267 268 269 270
  int error= heap_rkey(file, buf, active_index, key, key_len,
		       HA_READ_PREFIX_LAST);
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}

unknown's avatar
unknown committed
271
int ha_heap::index_read_idx(byte * buf, uint index, const byte * key,
272
			    uint key_len, enum ha_rkey_function find_flag)
unknown's avatar
unknown committed
273
{
274 275
  statistic_increment(table->in_use->status_var.ha_read_key_count,
		      &LOCK_status);
276 277
  int error = heap_rkey(file, buf, index, key, key_len, find_flag);
  table->status = error ? STATUS_NOT_FOUND : 0;
unknown's avatar
unknown committed
278 279 280 281 282
  return error;
}

int ha_heap::index_next(byte * buf)
{
unknown's avatar
unknown committed
283
  DBUG_ASSERT(inited==INDEX);
284 285
  statistic_increment(table->in_use->status_var.ha_read_next_count,
		      &LOCK_status);
unknown's avatar
unknown committed
286 287 288 289 290 291 292
  int error=heap_rnext(file,buf);
  table->status=error ? STATUS_NOT_FOUND: 0;
  return error;
}

int ha_heap::index_prev(byte * buf)
{
unknown's avatar
unknown committed
293
  DBUG_ASSERT(inited==INDEX);
294 295
  statistic_increment(table->in_use->status_var.ha_read_prev_count,
		      &LOCK_status);
unknown's avatar
unknown committed
296 297 298 299
  int error=heap_rprev(file,buf);
  table->status=error ? STATUS_NOT_FOUND: 0;
  return error;
}
unknown's avatar
unknown committed
300

unknown's avatar
unknown committed
301 302
int ha_heap::index_first(byte * buf)
{
unknown's avatar
unknown committed
303
  DBUG_ASSERT(inited==INDEX);
304
  statistic_increment(table->in_use->status_var.ha_read_first_count,
305
		      &LOCK_status);
unknown's avatar
unknown committed
306
  int error=heap_rfirst(file, buf, active_index);
unknown's avatar
unknown committed
307 308 309 310 311 312
  table->status=error ? STATUS_NOT_FOUND: 0;
  return error;
}

int ha_heap::index_last(byte * buf)
{
unknown's avatar
unknown committed
313
  DBUG_ASSERT(inited==INDEX);
314 315
  statistic_increment(table->in_use->status_var.ha_read_last_count,
		      &LOCK_status);
unknown's avatar
unknown committed
316
  int error=heap_rlast(file, buf, active_index);
unknown's avatar
unknown committed
317 318 319 320 321 322 323 324 325 326 327
  table->status=error ? STATUS_NOT_FOUND: 0;
  return error;
}

int ha_heap::rnd_init(bool scan)
{
  return scan ? heap_scan_init(file) : 0;
}

int ha_heap::rnd_next(byte *buf)
{
328
  statistic_increment(table->in_use->status_var.ha_read_rnd_next_count,
329
		      &LOCK_status);
unknown's avatar
unknown committed
330 331 332 333 334 335 336 337 338
  int error=heap_scan(file, buf);
  table->status=error ? STATUS_NOT_FOUND: 0;
  return error;
}

int ha_heap::rnd_pos(byte * buf, byte *pos)
{
  int error;
  HEAP_PTR position;
339 340
  statistic_increment(table->in_use->status_var.ha_read_rnd_count,
		      &LOCK_status);
unknown's avatar
unknown committed
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
  memcpy_fixed((char*) &position,pos,sizeof(HEAP_PTR));
  error=heap_rrnd(file, buf, position);
  table->status=error ? STATUS_NOT_FOUND: 0;
  return error;
}

void ha_heap::position(const byte *record)
{
  *(HEAP_PTR*) ref= heap_position(file);	// Ref is aligned
}

void ha_heap::info(uint flag)
{
  HEAPINFO info;
  (void) heap_info(file,&info,flag);

  records = info.records;
  deleted = info.deleted;
  errkey  = info.errkey;
  mean_rec_length=info.reclength;
  data_file_length=info.data_length;
  index_file_length=info.index_length;
  max_data_file_length= info.max_records* info.reclength;
  delete_length= info.deleted * info.reclength;
unknown's avatar
unknown committed
365 366
  if (flag & HA_STATUS_AUTO)
    auto_increment_value= info.auto_increment;
367 368 369 370 371
  /*
    If info() is called for the first time after open(), we will still
    have to update the key statistics. Hoping that a table lock is now
    in place.
  */
372
  if (key_stat_version != file->s->key_stat_version)
373
    update_key_stats();
unknown's avatar
unknown committed
374 375 376 377 378 379 380 381 382 383
}

int ha_heap::extra(enum ha_extra_function operation)
{
  return heap_extra(file,operation);
}

int ha_heap::delete_all_rows()
{
  heap_clear(file);
384
  if (table->s->tmp_table == NO_TMP_TABLE)
385 386 387 388 389
  {
    /*
       We can perform this safely since only one writer at the time is
       allowed on the table.
    */
390
    file->s->key_stat_version++;
391
  }
unknown's avatar
unknown committed
392 393 394 395 396 397
  return 0;
}

int ha_heap::external_lock(THD *thd, int lock_type)
{
  return 0;					// No external locking
unknown's avatar
unknown committed
398
}
unknown's avatar
unknown committed
399

400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507

/*
  Disable indexes.

  SYNOPSIS
    disable_indexes()
    mode        mode of operation:
                HA_KEY_SWITCH_NONUNIQ      disable all non-unique keys
                HA_KEY_SWITCH_ALL          disable all keys
                HA_KEY_SWITCH_NONUNIQ_SAVE dis. non-uni. and make persistent
                HA_KEY_SWITCH_ALL_SAVE     dis. all keys and make persistent

  DESCRIPTION
    Disable indexes and clear keys to use for scanning.

  IMPLEMENTATION
    HA_KEY_SWITCH_NONUNIQ       is not implemented.
    HA_KEY_SWITCH_NONUNIQ_SAVE  is not implemented with HEAP.
    HA_KEY_SWITCH_ALL_SAVE      is not implemented with HEAP.

  RETURN
    0  ok
    HA_ERR_WRONG_COMMAND  mode not implemented.
*/

int ha_heap::disable_indexes(uint mode)
{
  int error;

  if (mode == HA_KEY_SWITCH_ALL)
  {
    if (!(error= heap_disable_indexes(file)))
      set_keys_for_scanning();
  }
  else
  {
    /* mode not implemented */
    error= HA_ERR_WRONG_COMMAND;
  }
  return error;
}


/*
  Enable indexes.

  SYNOPSIS
    enable_indexes()
    mode        mode of operation:
                HA_KEY_SWITCH_NONUNIQ      enable all non-unique keys
                HA_KEY_SWITCH_ALL          enable all keys
                HA_KEY_SWITCH_NONUNIQ_SAVE en. non-uni. and make persistent
                HA_KEY_SWITCH_ALL_SAVE     en. all keys and make persistent

  DESCRIPTION
    Enable indexes and set keys to use for scanning.
    The indexes might have been disabled by disable_index() before.
    The function works only if both data and indexes are empty,
    since the heap storage engine cannot repair the indexes.
    To be sure, call handler::delete_all_rows() before.

  IMPLEMENTATION
    HA_KEY_SWITCH_NONUNIQ       is not implemented.
    HA_KEY_SWITCH_NONUNIQ_SAVE  is not implemented with HEAP.
    HA_KEY_SWITCH_ALL_SAVE      is not implemented with HEAP.

  RETURN
    0  ok
    HA_ERR_CRASHED  data or index is non-empty. Delete all rows and retry.
    HA_ERR_WRONG_COMMAND  mode not implemented.
*/

int ha_heap::enable_indexes(uint mode)
{
  int error;

  if (mode == HA_KEY_SWITCH_ALL)
  {
    if (!(error= heap_enable_indexes(file)))
      set_keys_for_scanning();
  }
  else
  {
    /* mode not implemented */
    error= HA_ERR_WRONG_COMMAND;
  }
  return error;
}


/*
  Test if indexes are disabled.

  SYNOPSIS
    indexes_are_disabled()
    no parameters

  RETURN
    0  indexes are not disabled
    1  all indexes are disabled
   [2  non-unique indexes are disabled - NOT YET IMPLEMENTED]
*/

int ha_heap::indexes_are_disabled(void)
{
  return heap_indexes_are_disabled(file);
}

unknown's avatar
unknown committed
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
THR_LOCK_DATA **ha_heap::store_lock(THD *thd,
				    THR_LOCK_DATA **to,
				    enum thr_lock_type lock_type)
{
  if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
    file->lock.type=lock_type;
  *to++= &file->lock;
  return to;
}

/*
  We have to ignore ENOENT entries as the HEAP table is created on open and
  not when doing a CREATE on the table.
*/

int ha_heap::delete_table(const char *name)
{
525
  char buff[FN_REFLEN];
unknown's avatar
unknown committed
526
  int error= heap_delete_table(name);
unknown's avatar
unknown committed
527 528 529
  return error == ENOENT ? 0 : error;
}

unknown's avatar
unknown committed
530 531 532 533 534 535 536 537

void ha_heap::drop_table(const char *name)
{
  heap_drop_table(file);
  close();
}


unknown's avatar
unknown committed
538 539 540 541 542
int ha_heap::rename_table(const char * from, const char * to)
{
  return heap_rename(from,to);
}

unknown's avatar
unknown committed
543 544 545

ha_rows ha_heap::records_in_range(uint inx, key_range *min_key,
                                  key_range *max_key)
unknown's avatar
unknown committed
546
{
unknown's avatar
unknown committed
547 548 549 550
  KEY *key=table->key_info+inx;
  if (key->algorithm == HA_KEY_ALG_BTREE)
    return hp_rb_records_in_range(file, inx, min_key, max_key);

551 552
  if (!min_key || !max_key ||
      min_key->length != max_key->length ||
unknown's avatar
unknown committed
553 554 555
      min_key->length != key->key_length ||
      min_key->flag != HA_READ_KEY_EXACT ||
      max_key->flag != HA_READ_AFTER_KEY)
unknown's avatar
unknown committed
556
    return HA_POS_ERROR;			// Can only use exact keys
557

558 559 560
  if (records <= 1)
    return records;

561
  /* Assert that info() did run. We need current statistics here. */
unknown's avatar
unknown committed
562
  DBUG_ASSERT(key_stat_version);
563
  return key->rec_per_key[key->key_parts-1];
unknown's avatar
unknown committed
564 565
}

566 567

int ha_heap::create(const char *name, TABLE *table_arg,
unknown's avatar
unknown committed
568
		    HA_CREATE_INFO *create_info)
unknown's avatar
unknown committed
569
{
570
  uint key, parts, mem_per_row= 0, keys= table_arg->s->keys;
unknown's avatar
unknown committed
571
  uint auto_key= 0, auto_key_type= 0;
unknown's avatar
unknown committed
572
  ha_rows max_rows;
unknown's avatar
unknown committed
573 574 575
  HP_KEYDEF *keydef;
  HA_KEYSEG *seg;
  int error;
576
  TABLE_SHARE *share= table_arg->s;
577
  bool found_real_auto_increment= 0;
unknown's avatar
unknown committed
578

579
  for (key= parts= 0; key < keys; key++)
580
    parts+= table_arg->key_info[key].key_parts;
unknown's avatar
unknown committed
581

582
  if (!(keydef= (HP_KEYDEF*) my_malloc(keys * sizeof(HP_KEYDEF) +
unknown's avatar
unknown committed
583 584
				       parts * sizeof(HA_KEYSEG),
				       MYF(MY_WME))))
unknown's avatar
unknown committed
585
    return my_errno;
586 587
  seg= my_reinterpret_cast(HA_KEYSEG*) (keydef + keys);
  for (key= 0; key < keys; key++)
unknown's avatar
unknown committed
588
  {
589
    KEY *pos= table_arg->key_info+key;
unknown's avatar
unknown committed
590 591 592 593 594 595
    KEY_PART_INFO *key_part=     pos->key_part;
    KEY_PART_INFO *key_part_end= key_part + pos->key_parts;

    keydef[key].keysegs=   (uint) pos->key_parts;
    keydef[key].flag=      (pos->flags & (HA_NOSAME | HA_NULL_ARE_EQUAL));
    keydef[key].seg=       seg;
596 597 598 599 600 601 602 603 604 605 606 607 608 609

    switch (pos->algorithm) {
    case HA_KEY_ALG_UNDEF:
    case HA_KEY_ALG_HASH:
      keydef[key].algorithm= HA_KEY_ALG_HASH;
      mem_per_row+= sizeof(char*) * 2; // = sizeof(HASH_INFO)
      break;
    case HA_KEY_ALG_BTREE:
      keydef[key].algorithm= HA_KEY_ALG_BTREE;
      mem_per_row+=sizeof(TREE_ELEMENT)+pos->key_length+sizeof(char*);
      break;
    default:
      DBUG_ASSERT(0); // cannot happen
    }
unknown's avatar
unknown committed
610 611 612 613

    for (; key_part != key_part_end; key_part++, seg++)
    {
      Field *field= key_part->field;
614

unknown's avatar
unknown committed
615 616 617 618
      if (pos->algorithm == HA_KEY_ALG_BTREE)
	seg->type= field->key_type();
      else
      {
619
        if ((seg->type = field->key_type()) != (int) HA_KEYTYPE_TEXT &&
620 621 622 623
            seg->type != HA_KEYTYPE_VARTEXT1 &&
            seg->type != HA_KEYTYPE_VARTEXT2 &&
            seg->type != HA_KEYTYPE_VARBINARY1 &&
            seg->type != HA_KEYTYPE_VARBINARY2)
624
          seg->type= HA_KEYTYPE_BINARY;
unknown's avatar
unknown committed
625 626 627
      }
      seg->start=   (uint) key_part->offset;
      seg->length=  (uint) key_part->length;
628 629
      seg->flag=    key_part->key_part_flag;

unknown's avatar
unknown committed
630
      seg->charset= field->charset();
unknown's avatar
unknown committed
631 632 633
      if (field->null_ptr)
      {
	seg->null_bit= field->null_bit;
634
	seg->null_pos= (uint) (field->null_ptr - (uchar*) table_arg->record[0]);
unknown's avatar
unknown committed
635 636 637 638 639 640
      }
      else
      {
	seg->null_bit= 0;
	seg->null_pos= 0;
      }
641 642
      if (field->flags & AUTO_INCREMENT_FLAG &&
          table_arg->found_next_number_field &&
unknown's avatar
unknown committed
643
          key == share->next_number_index)
644 645 646 647 648 649
      {
        /*
          Store key number and type for found auto_increment key
          We have to store type as seg->type can differ from it
        */
        auto_key= key+ 1;
unknown's avatar
unknown committed
650
	auto_key_type= field->key_type();
651
      }
unknown's avatar
unknown committed
652 653
    }
  }
654
  mem_per_row+= MY_ALIGN(share->reclength + 1, sizeof(char*));
unknown's avatar
unknown committed
655
  max_rows = (ha_rows) (table_arg->in_use->variables.max_heap_table_size /
unknown's avatar
unknown committed
656
			mem_per_row);
657 658
  if (table_arg->found_next_number_field)
  {
unknown's avatar
unknown committed
659 660
    keydef[share->next_number_index].flag|= HA_AUTO_KEY;
    found_real_auto_increment= share->next_number_key_offset == 0;
661
  }
unknown's avatar
unknown committed
662
  HP_CREATE_INFO hp_create_info;
663
  hp_create_info.auto_key= auto_key;
unknown's avatar
unknown committed
664 665 666
  hp_create_info.auto_key_type= auto_key_type;
  hp_create_info.auto_increment= (create_info->auto_increment_value ?
				  create_info->auto_increment_value - 1 : 0);
667
  hp_create_info.max_table_size=current_thd->variables.max_heap_table_size;
668
  hp_create_info.with_auto_increment= found_real_auto_increment;
669
  max_rows = (ha_rows) (hp_create_info.max_table_size / mem_per_row);
unknown's avatar
unknown committed
670
  error= heap_create(name,
unknown's avatar
unknown committed
671
		     keys, keydef, share->reclength,
672 673 674 675
		     (ulong) ((share->max_rows < max_rows &&
			       share->max_rows) ? 
			      share->max_rows : max_rows),
		     (ulong) share->min_rows, &hp_create_info);
unknown's avatar
unknown committed
676 677 678 679
  my_free((gptr) keydef, MYF(0));
  if (file)
    info(HA_STATUS_NO_LOCK | HA_STATUS_CONST | HA_STATUS_VARIABLE);
  return (error);
unknown's avatar
unknown committed
680
}
unknown's avatar
unknown committed
681

682

unknown's avatar
unknown committed
683 684 685 686 687 688 689
void ha_heap::update_create_info(HA_CREATE_INFO *create_info)
{
  table->file->info(HA_STATUS_AUTO);
  if (!(create_info->used_fields & HA_CREATE_USED_AUTO))
    create_info->auto_increment_value= auto_increment_value;
}

690
ulonglong ha_heap::get_auto_increment()
unknown's avatar
unknown committed
691 692 693 694
{
  ha_heap::info(HA_STATUS_AUTO);
  return auto_increment_value;
}
unknown's avatar
unknown committed
695 696 697 698 699 700 701 702 703 704 705 706


bool ha_heap::check_if_incompatible_data(HA_CREATE_INFO *info,
					 uint table_changes)
{
  /* Check that auto_increment value was not changed */
  if ((table_changes != IS_EQUAL_YES &&
       info->used_fields & HA_CREATE_USED_AUTO) &&
      info->auto_increment_value != 0)
    return COMPATIBLE_DATA_NO;
  return COMPATIBLE_DATA_YES;
}