~drizzle-trunk/drizzle/development

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

 

#include "ha_heap.h"

#include "heapdef.h"

 

                                    TABLE_SHARE *table, 

                                    MEM_ROOT *mem_root);

 

{

}

 

 

 

  heap_hton= (handlerton *)p;

  heap_hton->state=      SHOW_OPTION_YES;

  heap_hton->create=     heap_create_handler;

  heap_hton->flags=      HTON_CAN_RECREATE;

 

  return 0;

 

 

static const char *ha_heap_exts[] = {

};

 

const char **ha_heap::bas_ext() const

*/

#define HEAP_STATS_UPDATE_THRESHOLD 10

 

{

  if ((test_if_locked & HA_OPEN_INTERNAL_TABLE) || (!(file= heap_open(name, mode)) && my_errno == ENOENT))

  {

    HA_CREATE_INFO create_info;

    internal_table= test(test_if_locked & HA_OPEN_INTERNAL_TABLE);

    file= 0;

    if (!create(name, table, &create_info))

    {

void ha_heap::set_keys_for_scanning(void)

{

  btree_keys.clear_all();

  {

    if (table->key_info[i].algorithm == HA_KEY_ALG_BTREE)

      btree_keys.set_bit(i);

 

void ha_heap::update_key_stats()

{

  {

    KEY *key=table->key_info+i;

    if (!key->rec_per_key)

      else

      {

        ha_rows hash_buckets= file->s->keydef[i].hash_buckets;

        if (no_records < 2)

          no_records= 2;

        key->rec_per_key[key->key_parts-1]= no_records;

}

 

 

{

  int res;

  ha_statistic_increment(&SSV::ha_write_count);

  return res;

}

 

{

  int res;

  ha_statistic_increment(&SSV::ha_update_count);

  return res;

}

 

{

  int res;

  ha_statistic_increment(&SSV::ha_delete_count);

  return res;

}

 

                            key_part_map keypart_map,

                            enum ha_rkey_function find_flag)

{

  ha_statistic_increment(&SSV::ha_read_key_count);

  int error = heap_rkey(file,buf,active_index, key, keypart_map, find_flag);

  table->status = error ? STATUS_NOT_FOUND : 0;

  return error;

}

 

                                 key_part_map keypart_map)

{

  ha_statistic_increment(&SSV::ha_read_key_count);

  int error= heap_rkey(file, buf, active_index, key, keypart_map,

                       HA_READ_PREFIX_LAST);

  return error;

}

 

                                key_part_map keypart_map,

                                enum ha_rkey_function find_flag)

{

  return error;

}

 

{

  ha_statistic_increment(&SSV::ha_read_next_count);

  int error=heap_rnext(file,buf);

  table->status=error ? STATUS_NOT_FOUND: 0;

  return error;

}

 

{

  ha_statistic_increment(&SSV::ha_read_prev_count);

  int error=heap_rprev(file,buf);

  table->status=error ? STATUS_NOT_FOUND: 0;

  return error;

}

 

{

  ha_statistic_increment(&SSV::ha_read_first_count);

  int error=heap_rfirst(file, buf, active_index);

  table->status=error ? STATUS_NOT_FOUND: 0;

  return error;

}

 

{

  ha_statistic_increment(&SSV::ha_read_last_count);

  int error=heap_rlast(file, buf, active_index);

  table->status=error ? STATUS_NOT_FOUND: 0;

  return scan ? heap_scan_init(file) : 0;

}

 

{

  ha_statistic_increment(&SSV::ha_read_rnd_next_count);

  int error=heap_scan(file, buf);

  return error;

}

 

{

  int error;

  HEAP_PTR heap_position;

  ha_statistic_increment(&SSV::ha_read_rnd_count);

  error=heap_rrnd(file, buf, heap_position);

  table->status=error ? STATUS_NOT_FOUND: 0;

  return error;

}

 

{

  *(HEAP_PTR*) ref= heap_position(file);        // Ref is aligned

}

 

{

  HEAPINFO hp_info;

  (void) heap_info(file,&hp_info,flag);

}

 

 

int ha_heap::extra(enum ha_extra_function operation)

{

  return heap_extra(file,operation);

  return 0;

}

 

{

  return 0;                                     // No external locking

}

    HA_ERR_WRONG_COMMAND  mode not implemented.

*/

 

{

  int error;

 

    HA_ERR_WRONG_COMMAND  mode not implemented.

*/

 

{

  int error;

 

  return heap_indexes_are_disabled(file);

}

 

{

  if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)

    file->lock.type=lock_type;

}

 

 

{

  file->s->delete_on_close= 1;

  close();

}

 

 

                                  key_range *max_key)

{

  KEY *key=table->key_info+inx;

    return stats.records;

 

  /* Assert that info() did run. We need current statistics here. */

  return key->rec_per_key[key->key_parts-1];

}

 

 

                    HA_CREATE_INFO *create_info)

{

  HP_KEYDEF *keydef;

  HA_KEYSEG *seg;

  int error;

  TABLE_SHARE *share= table_arg->s;

  bool found_real_auto_increment= 0;

 

  for (key= parts= 0; key < keys; key++)

    parts+= table_arg->key_info[key].key_parts;

 

  if (!(keydef= (HP_KEYDEF*) my_malloc(keys * sizeof(HP_KEYDEF) +

                                       parts * sizeof(HA_KEYSEG),

                                       MYF(MY_WME))))

    return my_errno;

  for (key= 0; key < keys; key++)

  {

    KEY *pos= table_arg->key_info+key;

    case HA_KEY_ALG_UNDEF:

    case HA_KEY_ALG_HASH:

      keydef[key].algorithm= HA_KEY_ALG_HASH;

      break;

    case HA_KEY_ALG_BTREE:

      keydef[key].algorithm= HA_KEY_ALG_BTREE;

      break;

    default:

    }

 

    for (; key_part != key_part_end; key_part++, seg++)

      seg->length=  (uint) key_part->length;

      seg->flag=    key_part->key_part_flag;

 

      if (field->flags & (ENUM_FLAG | SET_FLAG))

        seg->charset= &my_charset_bin;

      else

      if (field->null_ptr)

      {

        seg->null_bit= field->null_bit;

      }

      else

      {

        auto_key= key+ 1;

        auto_key_type= field->key_type();

      }

    }

  }

  if (table_arg->found_next_number_field)

  {

    keydef[share->next_number_index].flag|= HA_AUTO_KEY;

  hp_create_info.max_table_size=current_thd->variables.max_heap_table_size;

  hp_create_info.with_auto_increment= found_real_auto_increment;

  hp_create_info.internal_table= internal_table;

  return (error);

}

 

  table->file->info(HA_STATUS_AUTO);

  if (!(create_info->used_fields & HA_CREATE_USED_AUTO))

    create_info->auto_increment_value= stats.auto_increment_value;

}

 

                                 uint64_t *first_value,

                                 uint64_t *nb_reserved_values)

{

  ha_heap::info(HA_STATUS_AUTO);

  *first_value= stats.auto_increment_value;

  /* such table has only table-level locking so reserves up to +inf */

}