home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / myisam / ft_update.c < prev    next >
C/C++ Source or Header  |  2000-10-11  |  6KB  |  205 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. /* Written by Sergei A. Golubchik, who has a shared copyright to this code */
  18.  
  19. /* functions to work with full-text indices */
  20.  
  21. #include "ftdefs.h"
  22.  
  23. /**************************************************************
  24.    This is to make ft-code to ignore keyseg.length at all     *
  25.    and to index the whole VARCHAR/BLOB instead...             */
  26. #undef set_if_smaller
  27. #define set_if_smaller(A,B)                          /* no op */
  28. /**************************************************************/
  29.  
  30.  
  31. /* parses a document i.e. calls _mi_ft_parse for every keyseg */
  32. static FT_WORD * _mi_ft_parserecord(MI_INFO *info, uint keynr, byte *keybuf,
  33.                     const byte *record)
  34. {
  35.   TREE *parsed=NULL;
  36.   MI_KEYSEG *keyseg;
  37.   byte *pos;
  38.   uint i;
  39.  
  40.   keyseg=info->s->keyinfo[keynr].seg;
  41.   for (i=info->s->keyinfo[keynr].keysegs-FT_SEGS ; i-- ; )
  42.   {
  43.     uint len;
  44.  
  45.     keyseg--;
  46.     if (keyseg->null_bit && (record[keyseg->null_pos] & keyseg->null_bit))
  47.     continue; /* NULL field */
  48.     pos= (byte *)record+keyseg->start;
  49.     if (keyseg->flag & HA_VAR_LENGTH)
  50.     {
  51.       len=uint2korr(pos);
  52.       pos+=2;                     /* Skip VARCHAR length */
  53.       set_if_smaller(len,keyseg->length);
  54.     }
  55.     else if (keyseg->flag & HA_BLOB_PART)
  56.     {
  57.       len=_mi_calc_blob_length(keyseg->bit_start,pos);
  58.       memcpy_fixed(&pos,pos+keyseg->bit_start,sizeof(char*));
  59.       set_if_smaller(len,keyseg->length);
  60.     }
  61.     else
  62.       len=keyseg->length;
  63.     if (!(parsed=ft_parse(parsed, pos, len)))
  64.       return NULL;
  65.   }
  66.   /* Handle the case where all columns are NULL */
  67.   if (!parsed && !(parsed=ft_parse(0, (byte*) "", 0)))
  68.     return NULL;
  69.   return ft_linearize(info, keynr, keybuf, parsed);
  70. }
  71.  
  72. static int _mi_ft_store(MI_INFO *info, uint keynr, byte *keybuf,
  73.             FT_WORD *wlist, my_off_t filepos)
  74. {
  75.   uint key_length;
  76.  
  77.   while(wlist->pos)
  78.   {
  79.     key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
  80.     if (_mi_ck_write(info,keynr,(uchar*) keybuf,key_length))
  81.       return 1;
  82.     wlist++;
  83.    }
  84.    return 0;
  85. }
  86.  
  87. static int _mi_ft_erase(MI_INFO *info, uint keynr, byte *keybuf, FT_WORD *wlist, my_off_t filepos)
  88. {
  89.   uint key_length, err=0;
  90.  
  91.   while(wlist->pos)
  92.   {
  93.     key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
  94.     if (_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length))
  95.       err=1;
  96.     wlist++;
  97.    }
  98.    return err;
  99. }
  100.  
  101. /* compares an appropriate parts of two WORD_KEY keys directly out of records */
  102. /* returns 1 if they are different */
  103.  
  104. #define THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT 1
  105. #define GEE_THEY_ARE_ABSOLUTELY_IDENTICAL     0
  106.  
  107. int _mi_ft_cmp(MI_INFO *info, uint keynr, const byte *rec1, const byte *rec2)
  108. {
  109.   MI_KEYSEG *keyseg;
  110.   byte *pos1, *pos2;
  111.   uint i;
  112.  
  113.   i=info->s->keyinfo[keynr].keysegs-FT_SEGS;
  114.   keyseg=info->s->keyinfo[keynr].seg;
  115.   while(i--)
  116.   {
  117.     uint len1, len2;
  118.     LINT_INIT(len1); LINT_INIT(len2);
  119.     keyseg--;
  120.     if (keyseg->null_bit)
  121.     {
  122.       if ( (rec1[keyseg->null_pos] ^ rec2[keyseg->null_pos])
  123.        & keyseg->null_bit )
  124.     return THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT;
  125.       if (rec1[keyseg->null_pos] & keyseg->null_bit )
  126.     continue; /* NULL field */
  127.     }
  128.     pos1= (byte *)rec1+keyseg->start;
  129.     pos2= (byte *)rec2+keyseg->start;
  130.     if (keyseg->flag & HA_VAR_LENGTH)
  131.     {
  132.       len1=uint2korr(pos1);
  133.       pos1+=2;                     /* Skip VARCHAR length */
  134.       set_if_smaller(len1,keyseg->length);
  135.       len2=uint2korr(pos2);
  136.       pos2+=2;                     /* Skip VARCHAR length */
  137.       set_if_smaller(len2,keyseg->length);
  138.     }
  139.     else if (keyseg->flag & HA_BLOB_PART)
  140.     {
  141.       len1=_mi_calc_blob_length(keyseg->bit_start,pos1);
  142.       memcpy_fixed(&pos1,pos1+keyseg->bit_start,sizeof(char*));
  143.       set_if_smaller(len1,keyseg->length);
  144.       len2=_mi_calc_blob_length(keyseg->bit_start,pos2);
  145.       memcpy_fixed(&pos2,pos2+keyseg->bit_start,sizeof(char*));
  146.       set_if_smaller(len2,keyseg->length);
  147.     }
  148.     if ((len1 != len2) || memcmp(pos1, pos2, len1))
  149.       return THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT;
  150.   }
  151.   return GEE_THEY_ARE_ABSOLUTELY_IDENTICAL;
  152. }
  153.  
  154. /* adds a document to the collection */
  155. int _mi_ft_add(MI_INFO *info, uint keynr, byte *keybuf, const byte *record,
  156.            my_off_t pos)
  157. {
  158.   int error= -1;
  159.   FT_WORD *wlist;
  160.  
  161.   if ((wlist=_mi_ft_parserecord(info, keynr, keybuf, record)))
  162.   {
  163.     error=_mi_ft_store(info,keynr,keybuf,wlist,pos);
  164.     my_free((char*) wlist,MYF(0));
  165.   }
  166.   return error;
  167. }
  168.  
  169. /* removes a document from the collection */
  170. int _mi_ft_del(MI_INFO *info, uint keynr, byte *keybuf, const byte *record,
  171.            my_off_t pos)
  172. {
  173.   int error= -1;
  174.   FT_WORD *wlist;
  175.   if ((wlist=_mi_ft_parserecord(info, keynr, keybuf, record)))
  176.   {
  177.     error=_mi_ft_erase(info,keynr,keybuf,wlist,pos);
  178.     my_free((char*) wlist,MYF(0));
  179.   }
  180.   return error;
  181. }
  182.  
  183. uint _ft_make_key(MI_INFO *info, uint keynr, byte *keybuf, FT_WORD *wptr,
  184.           my_off_t filepos)
  185. {
  186.   byte buf[HA_FT_MAXLEN+16];
  187.  
  188. #if HA_FT_WTYPE == HA_KEYTYPE_FLOAT
  189.   float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
  190.   mi_float4store(buf,weight);
  191. #else
  192. #error
  193. #endif
  194.  
  195. #ifdef EVAL_RUN
  196.   *(buf+HA_FT_WLEN)=wptr->cnt;
  197.   int2store(buf+HA_FT_WLEN+1,wptr->len);
  198.   memcpy(buf+HA_FT_WLEN+3,wptr->pos,wptr->len);
  199. #else /* EVAL_RUN */
  200.   int2store(buf+HA_FT_WLEN,wptr->len);
  201.   memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
  202. #endif /* EVAL_RUN */
  203.   return _mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos);
  204. }
  205.