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_myisammrg.cpp < prev    next >
C/C++ Source or Header  |  2000-09-26  |  7KB  |  240 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. #include "ha_myisammrg.h"
  25. #ifndef MASTER
  26. #include "../srclib/myisammrg/mymrgdef.h"
  27. #else
  28. #include "../myisammrg/mymrgdef.h"
  29. #endif
  30.  
  31. /*****************************************************************************
  32. ** MyISAM MERGE tables
  33. *****************************************************************************/
  34.  
  35. const char **ha_myisammrg::bas_ext() const
  36. { static const char *ext[]= { ".MRG", NullS }; return ext; }
  37.  
  38. int ha_myisammrg::open(const char *name, int mode, uint test_if_locked)
  39. {
  40.   char name_buff[FN_REFLEN];
  41.   if (!(file=myrg_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.     myrg_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.     myrg_extra(file,HA_EXTRA_WAIT_LOCK);
  51.   if (table->reclength != mean_rec_length && mean_rec_length)
  52.   {
  53.     DBUG_PRINT("error",("reclength: %d  mean_rec_length: %d",
  54.             table->reclength, mean_rec_length));
  55.     myrg_close(file);
  56.     file=0;
  57.     return my_errno=HA_ERR_WRONG_TABLE_DEF;
  58.   }
  59.   return (0);
  60. }
  61.  
  62. int ha_myisammrg::close(void)
  63. {
  64.   return myrg_close(file);
  65. }
  66.  
  67. int ha_myisammrg::write_row(byte * buf)
  68. {
  69.   return (my_errno=HA_ERR_WRONG_COMMAND);
  70. }
  71.  
  72. int ha_myisammrg::update_row(const byte * old_data, byte * new_data)
  73. {
  74.   statistic_increment(ha_update_count,&LOCK_status);
  75.   if (table->time_stamp)
  76.     update_timestamp(new_data+table->time_stamp-1);
  77.   return myrg_update(file,old_data,new_data);
  78. }
  79.  
  80. int ha_myisammrg::delete_row(const byte * buf)
  81. {
  82.   statistic_increment(ha_delete_count,&LOCK_status);
  83.   return myrg_delete(file,buf);
  84. }
  85.  
  86. int ha_myisammrg::index_read(byte * buf, const byte * key,
  87.               uint key_len, enum ha_rkey_function find_flag)
  88. {
  89. //  return (my_errno=HA_ERR_WRONG_COMMAND);
  90.   statistic_increment(ha_read_key_count,&LOCK_status);
  91.   int error=myrg_rkey(file,buf,active_index, key, key_len, find_flag);
  92.   table->status=error ? STATUS_NOT_FOUND: 0;
  93.   return error;
  94. }
  95.  
  96. int ha_myisammrg::index_read_idx(byte * buf, uint index, const byte * key,
  97.                  uint key_len, enum ha_rkey_function find_flag)
  98. {
  99. //  return (my_errno=HA_ERR_WRONG_COMMAND);
  100.   statistic_increment(ha_read_key_count,&LOCK_status);
  101.   int error=myrg_rkey(file,buf,index, key, key_len, find_flag);
  102.   table->status=error ? STATUS_NOT_FOUND: 0;
  103.   return error;
  104. }
  105.  
  106. int ha_myisammrg::index_next(byte * buf)
  107. {
  108. //  return (my_errno=HA_ERR_WRONG_COMMAND);
  109.   statistic_increment(ha_read_next_count,&LOCK_status);
  110.   int error=myrg_rnext(file,buf,active_index);
  111.   table->status=error ? STATUS_NOT_FOUND: 0;
  112.   return error;
  113. }
  114.  
  115. int ha_myisammrg::index_prev(byte * buf)
  116. {
  117. // return (my_errno=HA_ERR_WRONG_COMMAND);
  118.   statistic_increment(ha_read_prev_count,&LOCK_status);
  119.   int error=myrg_rprev(file,buf, active_index);
  120.   table->status=error ? STATUS_NOT_FOUND: 0;
  121.   return error;
  122. }
  123.  
  124. int ha_myisammrg::index_first(byte * buf)
  125. {
  126. //  return (my_errno=HA_ERR_WRONG_COMMAND);
  127.   statistic_increment(ha_read_first_count,&LOCK_status);
  128.   int error=myrg_rfirst(file, buf, active_index);
  129.   table->status=error ? STATUS_NOT_FOUND: 0;
  130.   return error;
  131. }
  132.  
  133. int ha_myisammrg::index_last(byte * buf)
  134. {
  135. //  return (my_errno=HA_ERR_WRONG_COMMAND);
  136.   statistic_increment(ha_read_last_count,&LOCK_status);
  137.   int error=myrg_rlast(file, buf, active_index);
  138.   table->status=error ? STATUS_NOT_FOUND: 0;
  139.   return error;
  140. }
  141.  
  142. int ha_myisammrg::rnd_init(bool scan)
  143. {
  144.   return myrg_extra(file,HA_EXTRA_RESET);
  145. }
  146.  
  147. int ha_myisammrg::rnd_next(byte *buf)
  148. {
  149.   statistic_increment(ha_read_rnd_next_count,&LOCK_status);
  150.   int error=myrg_rrnd(file, buf, HA_OFFSET_ERROR);
  151.   table->status=error ? STATUS_NOT_FOUND: 0;
  152.   return error;
  153. }
  154.  
  155. int ha_myisammrg::rnd_pos(byte * buf, byte *pos)
  156. {
  157.   statistic_increment(ha_read_rnd_count,&LOCK_status);
  158.   int error=myrg_rrnd(file, buf, ha_get_ptr(pos,ref_length));
  159.   table->status=error ? STATUS_NOT_FOUND: 0;
  160.   return error;
  161. }
  162.  
  163. void ha_myisammrg::position(const byte *record)
  164. {
  165.   ulonglong position= myrg_position(file);
  166.   ha_store_ptr(ref, ref_length, (my_off_t) position);
  167. }
  168.  
  169.  
  170. void ha_myisammrg::info(uint flag)
  171. {
  172.   MYMERGE_INFO info;
  173.   (void) myrg_status(file,&info,flag);
  174.   records = (ha_rows) info.records;
  175.   deleted = (ha_rows) info.deleted;
  176.   data_file_length=info.data_file_length;
  177.   errkey  = info.errkey;
  178.   table->keys_in_use=(((key_map) 1) << table->keys)- (key_map) 1;
  179.   table->db_options_in_use    = info.options;
  180.   mean_rec_length=info.reclength;
  181.   block_size=0;
  182.   update_time=0;
  183.   ref_length=6;                    // Should be big enough
  184. }
  185.  
  186.  
  187. int ha_myisammrg::extra(enum ha_extra_function operation)
  188. {
  189.   return myrg_extra(file,operation);
  190. }
  191.  
  192. int ha_myisammrg::reset(void)
  193. {
  194.   return myrg_extra(file,HA_EXTRA_RESET);
  195. }
  196.  
  197. int ha_myisammrg::external_lock(THD *thd, int lock_type)
  198. {
  199.   return myrg_lock_database(file,lock_type);
  200. }
  201.  
  202. uint ha_myisammrg::lock_count(void) const
  203. {
  204.   return file->tables;
  205. }
  206.  
  207.  
  208. THR_LOCK_DATA **ha_myisammrg::store_lock(THD *thd,
  209.                      THR_LOCK_DATA **to,
  210.                      enum thr_lock_type lock_type)
  211. {
  212.   MYRG_TABLE *table;
  213.  
  214.   for (table=file->open_tables ; table != file->end_table ; table++)
  215.   {
  216.     *(to++)= &table->table->lock;
  217.     if (lock_type != TL_IGNORE && table->table->lock.type == TL_UNLOCK)
  218.       table->table->lock.type=lock_type;
  219.   }
  220.   return to;
  221. }
  222.  
  223.  
  224. int ha_myisammrg::create(const char *name, register TABLE *form,
  225.              HA_CREATE_INFO *create_info)
  226. {
  227.   char buff[FN_REFLEN],**table_names,**pos;
  228.   TABLE_LIST *tables= (TABLE_LIST*) create_info->merge_list.first;
  229.   DBUG_ENTER("ha_myisammrg::create");
  230.  
  231.   if (!(table_names= (char**) sql_alloc((create_info->merge_list.elements+1)*
  232.                     sizeof(char*))))
  233.     DBUG_RETURN(1);
  234.   for (pos=table_names ; tables ; tables=tables->next)
  235.     *pos++= tables->real_name;
  236.   *pos=0;
  237.   DBUG_RETURN(myrg_create(fn_format(buff,name,"","",2+4+16),
  238.               (const char **) table_names, (my_bool) 0));
  239. }
  240.