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_isammrg.cpp < prev    next >
C/C++ Source or Header  |  2000-09-26  |  6KB  |  211 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 <m_ctype.h>
  24. #ifndef MASTER
  25. #include "../srclib/merge/mrgdef.h"
  26. #else
  27. #include "../merge/mrgdef.h"
  28. #endif
  29. #include "ha_isammrg.h"
  30.  
  31. /*****************************************************************************
  32. ** ISAM MERGE tables
  33. *****************************************************************************/
  34.  
  35. const char **ha_isammrg::bas_ext() const
  36. { static const char *ext[]= { ".MRG", NullS }; return ext; }
  37.  
  38. int ha_isammrg::open(const char *name, int mode, uint test_if_locked)
  39. {
  40.   char name_buff[FN_REFLEN];
  41.   if (!(file=mrg_open(fn_format(name_buff,name,"","",2 | 4), mode,
  42.                test_if_locked)))
  43.     return (my_errno ? my_errno : -1);
  44.  
  45.   if (!(test_if_locked == HA_OPEN_WAIT_IF_LOCKED ||
  46.     test_if_locked == HA_OPEN_ABORT_IF_LOCKED))
  47.     mrg_extra(file,HA_EXTRA_NO_WAIT_LOCK);
  48.   info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
  49.   if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
  50.     mrg_extra(file,HA_EXTRA_WAIT_LOCK);
  51.   if (table->reclength != mean_rec_length)
  52.   {
  53.     DBUG_PRINT("error",("reclength: %d  mean_rec_length: %d",
  54.             table->reclength, mean_rec_length));
  55.     mrg_close(file);
  56.     file=0;
  57.     return ER_WRONG_MRG_TABLE;
  58.   }
  59.   return (0);
  60. }
  61.  
  62. int ha_isammrg::close(void)
  63. {
  64.   return !mrg_close(file) ? 0 : my_errno ? my_errno : -1;
  65. }
  66.  
  67. uint ha_isammrg::min_record_length(uint options) const
  68. {
  69.   return (options & HA_OPTION_PACK_RECORD) ? 1 : 5;
  70. }
  71.  
  72. int ha_isammrg::write_row(byte * buf)
  73. {
  74.   return (my_errno=HA_ERR_WRONG_COMMAND);
  75. }
  76.  
  77. int ha_isammrg::update_row(const byte * old_data, byte * new_data)
  78. {
  79.   statistic_increment(ha_update_count,&LOCK_status);
  80.   if (table->time_stamp)
  81.     update_timestamp(new_data+table->time_stamp-1);
  82.   return !mrg_update(file,old_data,new_data) ? 0 : my_errno ? my_errno : -1;
  83. }
  84.  
  85. int ha_isammrg::delete_row(const byte * buf)
  86. {
  87.   statistic_increment(ha_delete_count,&LOCK_status);
  88.   return !mrg_delete(file,buf) ? 0 : my_errno ? my_errno : -1;
  89. }
  90.  
  91. int ha_isammrg::index_read(byte * buf, const byte * key,
  92.                uint key_len, enum ha_rkey_function find_flag)
  93. {
  94.   return (my_errno=HA_ERR_WRONG_COMMAND);
  95. }
  96.  
  97. int ha_isammrg::index_read_idx(byte * buf, uint index, const byte * key,
  98.                    uint key_len, enum ha_rkey_function find_flag)
  99. {
  100.   return (my_errno=HA_ERR_WRONG_COMMAND);
  101. }
  102.  
  103. int ha_isammrg::index_next(byte * buf)
  104. {
  105.   return (my_errno=HA_ERR_WRONG_COMMAND);
  106. }
  107.  
  108. int ha_isammrg::index_prev(byte * buf)
  109. {
  110.   return (my_errno=HA_ERR_WRONG_COMMAND);
  111. }
  112.   
  113. int ha_isammrg::index_first(byte * buf)
  114. {
  115.   return (my_errno=HA_ERR_WRONG_COMMAND);
  116. }
  117.  
  118. int ha_isammrg::index_last(byte * buf)
  119. {
  120.   return (my_errno=HA_ERR_WRONG_COMMAND);
  121. }
  122.  
  123. int ha_isammrg::rnd_init(bool scan)
  124. {
  125.   return !mrg_extra(file,HA_EXTRA_RESET) ? 0 : my_errno ? my_errno : -1;
  126. }
  127.  
  128. int ha_isammrg::rnd_next(byte *buf)
  129. {
  130.   statistic_increment(ha_read_rnd_next_count,&LOCK_status);
  131.   int error=mrg_rrnd(file, buf, ~(mrg_off_t) 0);
  132.   table->status=error ? STATUS_NOT_FOUND: 0;
  133.   return !error ? 0 : my_errno ? my_errno : -1;
  134. }
  135.  
  136. int ha_isammrg::rnd_pos(byte * buf, byte *pos)
  137. {
  138.   statistic_increment(ha_read_rnd_count,&LOCK_status);
  139.   int error=mrg_rrnd(file, buf, (ulong) ha_get_ptr(pos,ref_length));
  140.   table->status=error ? STATUS_NOT_FOUND: 0;
  141.   return !error ? 0 : my_errno ? my_errno : -1;
  142. }
  143.  
  144. void ha_isammrg::position(const byte *record)
  145. {
  146.   ulong position= mrg_position(file);
  147.   ha_store_ptr(ref, ref_length, (my_off_t) position);
  148. }
  149.  
  150.  
  151. void ha_isammrg::info(uint flag)
  152. {
  153.   MERGE_INFO info;
  154.   (void) mrg_info(file,&info,flag);
  155.   records = (ha_rows) info.records;
  156.   deleted = (ha_rows) info.deleted;
  157.   data_file_length=info.data_file_length;
  158.   errkey  = info.errkey;
  159.   table->keys_in_use=0;                // No keys yet
  160.   table->db_options_in_use    = info.options;
  161.   mean_rec_length=info.reclength;
  162.   block_size=0;
  163.   update_time=0;
  164.   ref_length=4;                    // Should be big enough
  165. }
  166.  
  167.  
  168. int ha_isammrg::extra(enum ha_extra_function operation)
  169. {
  170.   return !mrg_extra(file,operation) ? 0 : my_errno ? my_errno : -1;
  171. }
  172.  
  173. int ha_isammrg::reset(void)
  174. {
  175.   return !mrg_extra(file,HA_EXTRA_RESET) ? 0 : my_errno ? my_errno : -1;
  176. }
  177.  
  178. int ha_isammrg::external_lock(THD *thd, int lock_type)
  179. {
  180.   return !mrg_lock_database(file,lock_type) ? 0 : my_errno ? my_errno : -1;
  181. }  
  182.  
  183. uint ha_isammrg::lock_count(void) const
  184. {
  185.   return file->tables;
  186. }
  187.  
  188. THR_LOCK_DATA **ha_isammrg::store_lock(THD *thd,
  189.                        THR_LOCK_DATA **to,
  190.                        enum thr_lock_type lock_type)
  191. {
  192.   MRG_TABLE *table;
  193.  
  194.   for (table=file->open_tables ; table != file->end_table ; table++)
  195.   {
  196.     *(to++)= &table->table->lock;
  197.     if (lock_type != TL_IGNORE && table->table->lock.type == TL_UNLOCK)
  198.       table->table->lock.type=lock_type;
  199.   }
  200.   return to;
  201. }
  202.  
  203.  
  204. int ha_isammrg::create(const char *name, register TABLE *form,
  205.                HA_CREATE_INFO *create_info)
  206.  
  207. {
  208.   char buff[FN_REFLEN];
  209.   return mrg_create(fn_format(buff,name,"","",2+4+16),0);
  210. }
  211.