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_isam.cpp < prev    next >
C/C++ Source or Header  |  2000-09-26  |  12KB  |  391 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 <myisampack.h>
  25. #include "ha_isam.h"
  26. #ifndef MASTER
  27. #include "../srclib/isam/isamdef.h"
  28. #else
  29. #include "../isam/isamdef.h"
  30. #endif
  31.  
  32. /*****************************************************************************
  33. ** isam tables
  34. *****************************************************************************/
  35.  
  36. const char **ha_isam::bas_ext() const
  37. { static const char *ext[]= { ".ISD",".ISM", NullS }; return ext; }
  38.  
  39.  
  40. int ha_isam::open(const char *name, int mode, uint test_if_locked)
  41. {
  42.   char name_buff[FN_REFLEN];
  43.   if (!(file=nisam_open(fn_format(name_buff,name,"","",2 | 4), mode,
  44.              test_if_locked)))
  45.     return (my_errno ? my_errno : -1);
  46.  
  47.   if (!(test_if_locked == HA_OPEN_WAIT_IF_LOCKED ||
  48.     test_if_locked == HA_OPEN_ABORT_IF_LOCKED))
  49.     (void) nisam_extra(file,HA_EXTRA_NO_WAIT_LOCK);
  50.   info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
  51.   if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
  52.     (void) nisam_extra(file,HA_EXTRA_WAIT_LOCK);
  53.   if (!table->db_record_offset)
  54.     int_option_flag|=HA_REC_NOT_IN_SEQ;
  55.   return (0);
  56. }
  57.  
  58. int ha_isam::close(void)
  59. {
  60.   return !nisam_close(file) ? 0 : my_errno ? my_errno : -1;
  61. }
  62.  
  63. uint ha_isam::min_record_length(uint options) const
  64. {
  65.   return (options & HA_OPTION_PACK_RECORD) ? 1 : 5;
  66. }
  67.  
  68.  
  69. int ha_isam::write_row(byte * buf)
  70. {
  71.   statistic_increment(ha_write_count,&LOCK_status);
  72.   if (table->time_stamp)
  73.     update_timestamp(buf+table->time_stamp-1);
  74.   if (table->next_number_field && buf == table->record[0])
  75.     update_auto_increment();
  76.   return !nisam_write(file,buf) ? 0 : my_errno ? my_errno : -1;
  77. }
  78.  
  79. int ha_isam::update_row(const byte * old_data, byte * new_data)
  80. {
  81.   statistic_increment(ha_update_count,&LOCK_status);
  82.   if (table->time_stamp)
  83.     update_timestamp(new_data+table->time_stamp-1);
  84.   return !nisam_update(file,old_data,new_data) ? 0 : my_errno ? my_errno : -1;
  85. }
  86.  
  87. int ha_isam::delete_row(const byte * buf)
  88. {
  89.   statistic_increment(ha_delete_count,&LOCK_status);
  90.   return !nisam_delete(file,buf) ? 0 : my_errno ? my_errno : -1;
  91. }
  92.  
  93. int ha_isam::index_read(byte * buf, const byte * key,
  94.             uint key_len, enum ha_rkey_function find_flag)
  95. {
  96.   statistic_increment(ha_read_key_count,&LOCK_status);
  97.   int error=nisam_rkey(file, buf, active_index, key, key_len, find_flag);
  98.   table->status=error ? STATUS_NOT_FOUND: 0;
  99.   return !error ? 0 : my_errno ? my_errno : -1;
  100. }
  101.  
  102. int ha_isam::index_read_idx(byte * buf, uint index, const byte * key,
  103.                 uint key_len, enum ha_rkey_function find_flag)
  104. {
  105.   statistic_increment(ha_read_key_count,&LOCK_status);
  106.   int error=nisam_rkey(file, buf, index, key, key_len, find_flag);
  107.   table->status=error ? STATUS_NOT_FOUND: 0;
  108.   return !error ? 0 : my_errno ? my_errno : -1;
  109. }
  110.  
  111. int ha_isam::index_next(byte * buf)
  112. {
  113.   statistic_increment(ha_read_next_count,&LOCK_status);
  114.   int error=nisam_rnext(file,buf,active_index);
  115.   table->status=error ? STATUS_NOT_FOUND: 0;
  116.   return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
  117. }
  118.  
  119. int ha_isam::index_prev(byte * buf)
  120. {
  121.   statistic_increment(ha_read_prev_count,&LOCK_status);
  122.   int error=nisam_rprev(file,buf, active_index);
  123.   table->status=error ? STATUS_NOT_FOUND: 0;
  124.   return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
  125. }
  126.   
  127. int ha_isam::index_first(byte * buf)
  128. {
  129.   statistic_increment(ha_read_first_count,&LOCK_status);
  130.   int error=nisam_rfirst(file, buf, active_index);
  131.   table->status=error ? STATUS_NOT_FOUND: 0;
  132.   return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
  133. }
  134.  
  135. int ha_isam::index_last(byte * buf)
  136. {
  137.   statistic_increment(ha_read_last_count,&LOCK_status);
  138.   int error=nisam_rlast(file, buf, active_index);
  139.   table->status=error ? STATUS_NOT_FOUND: 0;
  140.   return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
  141. }
  142.  
  143. int ha_isam::rnd_init(bool scan)
  144. {
  145.   return nisam_extra(file,HA_EXTRA_RESET) ? 0 : my_errno ? my_errno : -1;;
  146. }
  147.  
  148. int ha_isam::rnd_next(byte *buf)
  149. {
  150.   statistic_increment(ha_read_rnd_next_count,&LOCK_status);
  151.   int error=nisam_rrnd(file, buf, NI_POS_ERROR);
  152.   table->status=error ? STATUS_NOT_FOUND: 0;
  153.   return !error ? 0 : my_errno ? my_errno : -1;
  154. }
  155.  
  156. int ha_isam::rnd_pos(byte * buf, byte *pos)
  157. {
  158.   statistic_increment(ha_read_rnd_count,&LOCK_status);
  159.   int error=nisam_rrnd(file, buf, (ulong) ha_get_ptr(pos,ref_length));
  160.   table->status=error ? STATUS_NOT_FOUND: 0;
  161.   return !error ? 0 : my_errno ? my_errno : -1;
  162. }
  163.  
  164. void ha_isam::position(const byte *record)
  165. {
  166.   my_off_t position=nisam_position(file);
  167.   if (position == (my_off_t) ~ (ulong) 0)
  168.     position=HA_OFFSET_ERROR;
  169.   ha_store_ptr(ref, ref_length, position);
  170. }
  171.  
  172. void ha_isam::info(uint flag)
  173. {
  174.   N_ISAMINFO info;
  175.   (void) nisam_info(file,&info,flag);
  176.   if (flag & HA_STATUS_VARIABLE)
  177.   {
  178.     records = info.records;
  179.     deleted = info.deleted;
  180.     data_file_length=info.data_file_length;
  181.     index_file_length=info.index_file_length;
  182.     delete_length = info.delete_length;
  183.     check_time  = info.isamchk_time;
  184.     mean_rec_length=info.mean_reclength;
  185.   }
  186.   if (flag & HA_STATUS_CONST)
  187.   {
  188.     max_data_file_length=info.max_data_file_length;
  189.     max_index_file_length=info.max_index_file_length;
  190.     create_time = info.create_time;
  191.     sortkey = info.sortkey;
  192.     block_size=nisam_block_size;
  193.     table->keys       = min(table->keys,info.keys);
  194.     table->keys_in_use= (((key_map) 1) << table->keys)- (key_map) 1;
  195.     table->db_options_in_use= info.options;
  196.     table->db_record_offset=
  197.       (table->db_options_in_use &
  198.        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? 0 :
  199.       table->reclength;
  200.     if (!table->tmp_table)
  201.     {
  202.       ulong *rec_per_key=info.rec_per_key;
  203.       for (uint i=0 ; i < table->keys ; i++)
  204.       {
  205.     table->key_info[i].rec_per_key[table->key_info[i].key_parts-1]=
  206.       *(rec_per_key++);
  207.       }
  208.     }
  209.     ref_length=4;
  210.   }
  211.   if (flag & HA_STATUS_ERRKEY)
  212.   {
  213.     errkey  = info.errkey;
  214.     ha_store_ptr(dupp_ref, ref_length, info.dupp_key_pos);
  215.   }
  216.   if (flag & HA_STATUS_TIME)
  217.     update_time = info.update_time;
  218. }
  219.  
  220.  
  221. int ha_isam::extra(enum ha_extra_function operation)
  222. {
  223.   if ((specialflag & SPECIAL_SAFE_MODE || test_flags & TEST_NO_EXTRA) &&
  224.       (operation == HA_EXTRA_WRITE_CACHE ||
  225.        operation == HA_EXTRA_KEYREAD))
  226.     return 0;
  227.   return nisam_extra(file,operation);
  228. }
  229.  
  230. int ha_isam::reset(void)
  231. {
  232.   return nisam_extra(file,HA_EXTRA_RESET);
  233. }
  234.  
  235. int ha_isam::external_lock(THD *thd, int lock_type)
  236. {
  237.   return nisam_lock_database(file,lock_type);
  238. }  
  239.  
  240.  
  241. THR_LOCK_DATA **ha_isam::store_lock(THD *thd,
  242.                     THR_LOCK_DATA **to,
  243.                     enum thr_lock_type lock_type)
  244. {
  245.   if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
  246.     file->lock.type=lock_type;
  247.   *to++= &file->lock;
  248.   return to;
  249. }
  250.  
  251.  
  252. int ha_isam::create(const char *name, register TABLE *form,
  253.             HA_CREATE_INFO *create_info)
  254.  
  255. {
  256.   uint options=form->db_options_in_use;
  257.   int error;
  258.   uint i,j,recpos,minpos,fieldpos,temp_length,length;
  259.   enum ha_base_keytype type;
  260.   char buff[FN_REFLEN];
  261.   KEY *pos;
  262.   N_KEYDEF keydef[MAX_KEY];
  263.   N_RECINFO *recinfo,*recinfo_pos;
  264.   DBUG_ENTER("ha_isam::create");
  265.  
  266.   type=HA_KEYTYPE_BINARY;                // Keep compiler happy
  267.   if (!(recinfo= (N_RECINFO*) my_malloc((form->fields*2+2)*sizeof(N_RECINFO),
  268.                     MYF(MY_WME))))
  269.     DBUG_RETURN(1);
  270.  
  271.   pos=form->key_info;
  272.   for (i=0; i < form->keys ; i++, pos++)
  273.   {
  274.     keydef[i].base.flag= (pos->flags & HA_NOSAME);
  275.     for (j=0 ; (int7) j < pos->key_parts ; j++)
  276.     {
  277.       keydef[i].seg[j].base.flag=pos->key_part[j].key_part_flag;
  278.       Field *field=pos->key_part[j].field;
  279.       type=field->key_type();
  280.  
  281.       if ((options & HA_OPTION_PACK_KEYS ||
  282.        (pos->flags & (HA_PACK_KEY | HA_BINARY_PACK_KEY |
  283.               HA_SPACE_PACK_USED))) &&
  284.       pos->key_part[j].length > 8 &&
  285.       (type == HA_KEYTYPE_TEXT ||
  286.        type == HA_KEYTYPE_NUM ||
  287.        (type == HA_KEYTYPE_BINARY && !field->zero_pack())))
  288.       {
  289.     if (j == 0)
  290.       keydef[i].base.flag|=HA_PACK_KEY;
  291.     if (!(field->flags & ZEROFILL_FLAG) &&
  292.         (field->type() == FIELD_TYPE_STRING ||
  293.          field->type() == FIELD_TYPE_VAR_STRING ||
  294.          ((int) (pos->key_part[j].length - field->decimals()))
  295.          >= 4))
  296.       keydef[i].seg[j].base.flag|=HA_SPACE_PACK;
  297.       }
  298.       keydef[i].seg[j].base.type=(int) type;
  299.       keydef[i].seg[j].base.start=  pos->key_part[j].offset;
  300.       keydef[i].seg[j].base.length= pos->key_part[j].length;
  301.     }
  302.     keydef[i].seg[j].base.type=(int) HA_KEYTYPE_END;    /* End of key-parts */
  303.   }
  304.  
  305.   recpos=0; recinfo_pos=recinfo;
  306.   while (recpos < (uint) form->reclength)
  307.   {
  308.     Field **field,*found=0;
  309.     minpos=form->reclength; length=0;
  310.  
  311.     for (field=form->field ; *field ; field++)
  312.     {
  313.       if ((fieldpos=(*field)->offset()) >= recpos &&
  314.       fieldpos <= minpos)
  315.       {
  316.     /* skip null fields */
  317.     if (!(temp_length= (*field)->pack_length()))
  318.       continue;                /* Skipp null-fields */
  319.     if (! found || fieldpos < minpos ||
  320.         (fieldpos == minpos && temp_length < length))
  321.     {
  322.       minpos=fieldpos; found= *field; length=temp_length;
  323.     }
  324.       }
  325.     }
  326.     DBUG_PRINT("loop",("found: %lx  recpos: %d  minpos: %d  length: %d",
  327.                found,recpos,minpos,length));
  328.     if (recpos != minpos)
  329.     {                        // Reserved space (Null bits?)
  330.       recinfo_pos->base.type=(int) FIELD_NORMAL;
  331.       recinfo_pos++->base.length= (uint16) (minpos-recpos);
  332.     }
  333.     if (! found)
  334.       break;
  335.  
  336.     if (found->flags & BLOB_FLAG)
  337.     {
  338.       /* ISAM can only handle blob pointers of sizeof(char(*)) */
  339.       recinfo_pos->base.type= (int) FIELD_BLOB;
  340.       if (options & HA_OPTION_LONG_BLOB_PTR)
  341.     length= length-portable_sizeof_char_ptr+sizeof(char*);
  342.     }
  343.     else if (!(options & HA_OPTION_PACK_RECORD))
  344.       recinfo_pos->base.type= (int) FIELD_NORMAL;
  345.     else if (found->zero_pack())
  346.       recinfo_pos->base.type= (int) FIELD_SKIPP_ZERO;
  347.     else
  348.       recinfo_pos->base.type= (int) ((length <= 3 ||
  349.                       (found->flags & ZEROFILL_FLAG)) ?
  350.                      FIELD_NORMAL :
  351.                      found->type() == FIELD_TYPE_STRING ||
  352.                      found->type() == FIELD_TYPE_VAR_STRING ?
  353.                      FIELD_SKIPP_ENDSPACE :
  354.                      FIELD_SKIPP_PRESPACE);
  355.     recinfo_pos++ ->base.length=(uint16) length;
  356.     recpos=minpos+length;
  357.     DBUG_PRINT("loop",("length: %d  type: %d",
  358.                recinfo_pos[-1].base.length,recinfo_pos[-1].base.type));
  359.  
  360.     if ((found->flags & BLOB_FLAG) && (options & HA_OPTION_LONG_BLOB_PTR) &&
  361.     sizeof(char*) != portable_sizeof_char_ptr)
  362.     {                        // Not used space
  363.       recinfo_pos->base.type=(int) FIELD_ZERO;
  364.       recinfo_pos++->base.length=
  365.     (uint16) (portable_sizeof_char_ptr-sizeof(char*));
  366.       recpos+= (portable_sizeof_char_ptr-sizeof(char*));
  367.     }
  368.   }
  369.   recinfo_pos->base.type= (int) FIELD_LAST;    /* End of fieldinfo */
  370.   error=nisam_create(fn_format(buff,name,"","",2+4+16),form->keys,keydef,
  371.           recinfo,form->max_rows,form->min_rows,0,0,0L);
  372.   my_free((gptr) recinfo,MYF(0));
  373.   DBUG_RETURN(error);
  374.  
  375. }
  376.  
  377.  
  378. ha_rows ha_isam::records_in_range(int inx,
  379.                   const byte *start_key,uint start_key_len,
  380.                   enum ha_rkey_function start_search_flag,
  381.                   const byte *end_key,uint end_key_len,
  382.                   enum ha_rkey_function end_search_flag)
  383. {
  384.   return (ha_rows) nisam_records_in_range(file,
  385.                        inx,
  386.                        start_key,start_key_len,
  387.                        start_search_flag,
  388.                        end_key,end_key_len,
  389.                        end_search_flag);
  390. }
  391.