home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / ha_heap.cpp < prev    next >
C/C++ Source or Header  |  2000-09-26  |  7KB  |  277 lines

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17.  
  18. #ifdef __GNUC__
  19. #pragma implementation                // gcc: Class implementation
  20. #endif
  21.  
  22. #include "mysql_priv.h"
  23. #include <myisampack.h>
  24. #include "ha_heap.h"
  25.  
  26. /*****************************************************************************
  27. ** HEAP tables
  28. *****************************************************************************/
  29.  
  30. const char **ha_heap::bas_ext() const
  31. { static const char *ext[1]= { NullS }; return ext; }
  32.  
  33.  
  34. int ha_heap::open(const char *name, int mode, uint test_if_locked)
  35. {
  36.   uint key,part,parts;
  37.   HP_KEYDEF *keydef;
  38.   HP_KEYSEG *seg;
  39.  
  40.   for (key=parts=0 ; key < table->keys ; key++)
  41.     parts+=table->key_info[key].key_parts;
  42.  
  43.   if (!(keydef=(HP_KEYDEF*) my_malloc(table->keys*sizeof(HP_KEYDEF)+
  44.                       parts*sizeof(HP_KEYSEG),MYF(MY_WME))))
  45.     return my_errno;
  46.   seg=my_reinterpret_cast(HP_KEYSEG*) (keydef+table->keys);
  47.   for (key=0 ; key < table->keys ; key++)
  48.   {
  49.     KEY *pos=table->key_info+key;
  50.  
  51.     keydef[key].keysegs=(uint) pos->key_parts;
  52.     keydef[key].flag = (pos->flags & HA_NOSAME);
  53.     keydef[key].seg=seg;
  54.     
  55.     for (part=0 ; part < pos->key_parts ; part++)
  56.     {
  57.       uint flag=pos->key_part[part].key_type;
  58.       if (!f_is_packed(flag) &&
  59.       f_packtype(flag) == (int) FIELD_TYPE_DECIMAL &&
  60.       !(flag & FIELDFLAG_BINARY))
  61.     seg->type= (int) HA_KEYTYPE_TEXT;
  62.       else
  63.     seg->type= (int) HA_KEYTYPE_BINARY;
  64.       seg->start=(uint) pos->key_part[part].offset;
  65.       seg->length=(uint) pos->key_part[part].length;
  66.       seg++;
  67.     }
  68.   }
  69.   file=heap_open(table->path,mode,
  70.          table->keys,keydef,
  71.          table->reclength,table->max_rows,
  72.          table->min_rows);
  73.   my_free((gptr) keydef,MYF(0));
  74.   info(HA_STATUS_NO_LOCK | HA_STATUS_CONST | HA_STATUS_VARIABLE);
  75.   ref_length=sizeof(HEAP_PTR);
  76.   return (!file ? errno : 0);
  77. }
  78.  
  79. int ha_heap::close(void)
  80. {
  81.   return heap_close(file);
  82. }
  83.  
  84. int ha_heap::write_row(byte * buf)
  85. {
  86.   statistic_increment(ha_write_count,&LOCK_status);
  87.   if (table->time_stamp)
  88.     update_timestamp(buf+table->time_stamp-1);
  89.   return heap_write(file,buf);
  90. }
  91.  
  92. int ha_heap::update_row(const byte * old_data, byte * new_data)
  93. {
  94.   statistic_increment(ha_update_count,&LOCK_status);
  95.   if (table->time_stamp)
  96.     update_timestamp(new_data+table->time_stamp-1);
  97.   return heap_update(file,old_data,new_data);
  98. }
  99.  
  100. int ha_heap::delete_row(const byte * buf)
  101. {
  102.   statistic_increment(ha_delete_count,&LOCK_status);
  103.   return heap_delete(file,buf);
  104. }
  105.  
  106. int ha_heap::index_read(byte * buf, const byte * key,
  107.             uint key_len __attribute__((unused)),
  108.             enum ha_rkey_function find_flag
  109.             __attribute__((unused)))
  110. {
  111.   statistic_increment(ha_read_key_count,&LOCK_status);
  112.   int error=heap_rkey(file,buf,active_index, key);
  113.   table->status=error ? STATUS_NOT_FOUND: 0;
  114.   return error;
  115. }
  116.  
  117. int ha_heap::index_read_idx(byte * buf, uint index, const byte * key,
  118.                 uint key_len __attribute__((unused)),
  119.                 enum ha_rkey_function find_flag
  120.                 __attribute__((unused)))
  121. {
  122.   statistic_increment(ha_read_key_count,&LOCK_status);
  123.   int error=heap_rkey(file, buf, index, key);
  124.   table->status=error ? STATUS_NOT_FOUND: 0;
  125.   return error;
  126. }
  127.  
  128.  
  129. int ha_heap::index_next(byte * buf)
  130. {
  131.   statistic_increment(ha_read_next_count,&LOCK_status);
  132.   int error=heap_rnext(file,buf);
  133.   table->status=error ? STATUS_NOT_FOUND: 0;
  134.   return error;
  135. }
  136.  
  137. int ha_heap::index_prev(byte * buf)
  138. {
  139.   statistic_increment(ha_read_prev_count,&LOCK_status);
  140.   int error=heap_rprev(file,buf);
  141.   table->status=error ? STATUS_NOT_FOUND: 0;
  142.   return error;
  143. }
  144.   
  145. int ha_heap::index_first(byte * buf)
  146. {
  147.   statistic_increment(ha_read_first_count,&LOCK_status);
  148.   int error=heap_rfirst(file, buf);
  149.   table->status=error ? STATUS_NOT_FOUND: 0;
  150.   return error;
  151. }
  152.  
  153. int ha_heap::index_last(byte * buf)
  154. {
  155.   statistic_increment(ha_read_last_count,&LOCK_status);
  156.   int error=heap_rlast(file, buf);
  157.   table->status=error ? STATUS_NOT_FOUND: 0;
  158.   return error;
  159. }
  160.  
  161. int ha_heap::rnd_init(bool scan)
  162. {
  163.   return scan ? heap_scan_init(file) : 0;
  164. }
  165.  
  166. int ha_heap::rnd_next(byte *buf)
  167. {
  168.   statistic_increment(ha_read_rnd_next_count,&LOCK_status);
  169.   int error=heap_scan(file, buf);
  170.   table->status=error ? STATUS_NOT_FOUND: 0;
  171.   return error;
  172. }
  173.  
  174. int ha_heap::rnd_pos(byte * buf, byte *pos)
  175. {
  176.   int error;
  177.   HEAP_PTR position;
  178.   statistic_increment(ha_read_rnd_count,&LOCK_status);
  179.   memcpy_fixed((char*) &position,pos,sizeof(HEAP_PTR));
  180.   error=heap_rrnd(file, buf, position);
  181.   table->status=error ? STATUS_NOT_FOUND: 0;
  182.   return error;
  183. }
  184.  
  185. void ha_heap::position(const byte *record)
  186. {
  187.   *(HEAP_PTR*) ref= heap_position(file);    // Ref is aligned
  188. }
  189.  
  190. void ha_heap::info(uint flag)
  191. {
  192.   HEAPINFO info;
  193.   (void) heap_info(file,&info,flag);
  194.  
  195.   records = info.records;
  196.   deleted = info.deleted;
  197.   errkey  = info.errkey;
  198.   mean_rec_length=info.reclength;
  199.   data_file_length=info.data_length;
  200.   index_file_length=info.index_length;
  201.   max_data_file_length= info.max_records* info.reclength;
  202.   delete_length= info.deleted * info.reclength;
  203. }
  204.  
  205. int ha_heap::extra(enum ha_extra_function operation)
  206. {
  207.   return heap_extra(file,operation);
  208. }
  209.  
  210. int ha_heap::reset(void)
  211. {
  212.   return heap_extra(file,HA_EXTRA_RESET);
  213. }
  214.  
  215. int ha_heap::delete_all_rows()
  216. {
  217.   heap_clear(file);
  218.   return 0;
  219. }
  220.  
  221. int ha_heap::external_lock(THD *thd, int lock_type)
  222. {
  223.   return 0;                    // No external locking
  224. }  
  225.  
  226. THR_LOCK_DATA **ha_heap::store_lock(THD *thd,
  227.                     THR_LOCK_DATA **to,
  228.                     enum thr_lock_type lock_type)
  229. {
  230.   if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
  231.     file->lock.type=lock_type;
  232.   *to++= &file->lock;
  233.   return to;
  234. }
  235.  
  236.  
  237. /*
  238.   We have to ignore ENOENT entries as the HEAP table is created on open and
  239.   not when doing a CREATE on the table.
  240. */
  241.  
  242. int ha_heap::delete_table(const char *name)
  243. {
  244.   int error=heap_delete_all(name);
  245.   return error == ENOENT ? 0 : error;
  246. }
  247.  
  248. int ha_heap::rename_table(const char * from, const char * to)
  249. {
  250.   return heap_rename(from,to);
  251. }
  252.  
  253.  
  254. ha_rows ha_heap::records_in_range(int inx,
  255.                   const byte *start_key,uint start_key_len,
  256.                   enum ha_rkey_function start_search_flag,
  257.                   const byte *end_key,uint end_key_len,
  258.                   enum ha_rkey_function end_search_flag)
  259. {
  260.   KEY *pos=table->key_info+inx;
  261.   if (start_key_len != end_key_len ||
  262.       start_key_len != pos->key_length ||
  263.       start_search_flag != HA_READ_KEY_EXACT ||
  264.       end_search_flag != HA_READ_AFTER_KEY)
  265.     return HA_POS_ERROR;            // Can't only use exact keys
  266.   return 10;                    // Good guess
  267. }
  268.  
  269. /* We can just delete the heap on creation */
  270.  
  271. int ha_heap::create(const char *name, TABLE *form, HA_CREATE_INFO *create_info)
  272.  
  273. {
  274.   char buff[FN_REFLEN];
  275.   return heap_create(fn_format(buff,name,"","",2));
  276. }
  277.