ft_update.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:9k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* Written by Sergei A. Golubchik, who has a shared copyright to this code */
  14. /* functions to work with full-text indices */
  15. #include "ftdefs.h"
  16. #include <math.h>
  17. void _mi_ft_segiterator_init(MI_INFO *info, uint keynr, const byte *record,
  18.      FT_SEG_ITERATOR *ftsi)
  19. {
  20.   DBUG_ENTER("_mi_ft_segiterator_init");
  21.   ftsi->num=info->s->keyinfo[keynr].keysegs;
  22.   ftsi->seg=info->s->keyinfo[keynr].seg;
  23.   ftsi->rec=record;
  24.   DBUG_VOID_RETURN;
  25. }
  26. void _mi_ft_segiterator_dummy_init(const byte *record, uint len,
  27.    FT_SEG_ITERATOR *ftsi)
  28. {
  29.   DBUG_ENTER("_mi_ft_segiterator_dummy_init");
  30.   ftsi->num=1;
  31.   ftsi->seg=0;
  32.   ftsi->pos=record;
  33.   ftsi->len=len;
  34.   DBUG_VOID_RETURN;
  35. }
  36. /*
  37.   This function breaks convention "return 0 in success"
  38.   but it's easier to use like this
  39.      while(_mi_ft_segiterator())
  40.   so "1" means "OK", "0" means "EOF"
  41. */
  42. uint _mi_ft_segiterator(register FT_SEG_ITERATOR *ftsi)
  43. {
  44.   DBUG_ENTER("_mi_ft_segiterator");
  45.   if (!ftsi->num)
  46.   {
  47.     DBUG_RETURN(0);
  48.   }
  49.   else
  50.     ftsi->num--;
  51.   if (!ftsi->seg)
  52.   {
  53.     DBUG_RETURN(1);
  54.   }
  55.   else
  56.     ftsi->seg--;
  57.   if (ftsi->seg->null_bit &&
  58.       (ftsi->rec[ftsi->seg->null_pos] & ftsi->seg->null_bit))
  59.   {
  60.       ftsi->pos=0;
  61.       DBUG_RETURN(1);
  62.   }
  63.   ftsi->pos= ftsi->rec+ftsi->seg->start;
  64.   if (ftsi->seg->flag & HA_VAR_LENGTH)
  65.   {
  66.     ftsi->len=uint2korr(ftsi->pos);
  67.     ftsi->pos+=2;  /* Skip VARCHAR length */
  68.     DBUG_RETURN(1);
  69.   }
  70.   if (ftsi->seg->flag & HA_BLOB_PART)
  71.   {
  72.     ftsi->len=_mi_calc_blob_length(ftsi->seg->bit_start,ftsi->pos);
  73.     memcpy_fixed((char*) &ftsi->pos, ftsi->pos+ftsi->seg->bit_start,
  74.  sizeof(char*));
  75.     DBUG_RETURN(1);
  76.   }
  77.   ftsi->len=ftsi->seg->length;
  78.   DBUG_RETURN(1);
  79. }
  80. /* parses a document i.e. calls ft_parse for every keyseg */
  81. uint _mi_ft_parse(TREE *parsed, MI_INFO *info, uint keynr,
  82.                   const byte *record, my_bool with_alloc)
  83. {
  84.   FT_SEG_ITERATOR ftsi;
  85.   DBUG_ENTER("_mi_ft_parse");
  86.   _mi_ft_segiterator_init(info, keynr, record, &ftsi);
  87.   ft_parse_init(parsed, info->s->keyinfo[keynr].seg->charset);
  88.   while (_mi_ft_segiterator(&ftsi))
  89.   {
  90.     if (ftsi.pos)
  91.       if (ft_parse(parsed, (byte *)ftsi.pos, ftsi.len, with_alloc))
  92.         DBUG_RETURN(1);
  93.   }
  94.   DBUG_RETURN(0);
  95. }
  96. FT_WORD * _mi_ft_parserecord(MI_INFO *info, uint keynr, const byte *record)
  97. {
  98.   TREE ptree;
  99.   DBUG_ENTER("_mi_ft_parserecord");
  100.   bzero((char*) &ptree, sizeof(ptree));
  101.   if (_mi_ft_parse(&ptree, info, keynr, record,0))
  102.     DBUG_RETURN(NULL);
  103.   DBUG_RETURN(ft_linearize(&ptree));
  104. }
  105. static int _mi_ft_store(MI_INFO *info, uint keynr, byte *keybuf,
  106. FT_WORD *wlist, my_off_t filepos)
  107. {
  108.   uint key_length;
  109.   DBUG_ENTER("_mi_ft_store");
  110.   for (; wlist->pos; wlist++)
  111.   {
  112.     key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
  113.     if (_mi_ck_write(info,keynr,(uchar*) keybuf,key_length))
  114.       DBUG_RETURN(1);
  115.    }
  116.    DBUG_RETURN(0);
  117. }
  118. static int _mi_ft_erase(MI_INFO *info, uint keynr, byte *keybuf,
  119. FT_WORD *wlist, my_off_t filepos)
  120. {
  121.   uint key_length, err=0;
  122.   DBUG_ENTER("_mi_ft_erase");
  123.   for (; wlist->pos; wlist++)
  124.   {
  125.     key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
  126.     if (_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length))
  127.       err=1;
  128.    }
  129.    DBUG_RETURN(err);
  130. }
  131. /*
  132.   Compares an appropriate parts of two WORD_KEY keys directly out of records
  133.   returns 1 if they are different
  134. */
  135. #define THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT 1
  136. #define GEE_THEY_ARE_ABSOLUTELY_IDENTICAL  0
  137. int _mi_ft_cmp(MI_INFO *info, uint keynr, const byte *rec1, const byte *rec2)
  138. {
  139.   FT_SEG_ITERATOR ftsi1, ftsi2;
  140.   CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
  141.   DBUG_ENTER("_mi_ft_cmp");
  142.   _mi_ft_segiterator_init(info, keynr, rec1, &ftsi1);
  143.   _mi_ft_segiterator_init(info, keynr, rec2, &ftsi2);
  144.   while (_mi_ft_segiterator(&ftsi1) && _mi_ft_segiterator(&ftsi2))
  145.   {
  146.     if ((ftsi1.pos != ftsi2.pos) &&
  147.         (!ftsi1.pos || !ftsi2.pos ||
  148.          mi_compare_text(cs, (uchar*) ftsi1.pos,ftsi1.len,
  149.                          (uchar*) ftsi2.pos,ftsi2.len,0,0)))
  150.       DBUG_RETURN(THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT);
  151.   }
  152.   DBUG_RETURN(GEE_THEY_ARE_ABSOLUTELY_IDENTICAL);
  153. }
  154. /* update a document entry */
  155. int _mi_ft_update(MI_INFO *info, uint keynr, byte *keybuf,
  156.                   const byte *oldrec, const byte *newrec, my_off_t pos)
  157. {
  158.   int error= -1;
  159.   FT_WORD *oldlist,*newlist, *old_word, *new_word;
  160.   CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
  161.   uint key_length;
  162.   int cmp, cmp2;
  163.   DBUG_ENTER("_mi_ft_update");
  164.   if (!(old_word=oldlist=_mi_ft_parserecord(info, keynr, oldrec)))
  165.     goto err0;
  166.   if (!(new_word=newlist=_mi_ft_parserecord(info, keynr, newrec)))
  167.     goto err1;
  168.   error=0;
  169.   while(old_word->pos && new_word->pos)
  170.   {
  171.     cmp= mi_compare_text(cs, (uchar*) old_word->pos,old_word->len,
  172.                              (uchar*) new_word->pos,new_word->len,0,0);
  173.     cmp2= cmp ? 0 : (fabs(old_word->weight - new_word->weight) > 1.e-5);
  174.     if (cmp < 0 || cmp2)
  175.     {
  176.       key_length=_ft_make_key(info,keynr,keybuf,old_word,pos);
  177.       if ((error=_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length)))
  178.         goto err2;
  179.     }
  180.     if (cmp > 0 || cmp2)
  181.     {
  182.       key_length=_ft_make_key(info,keynr,keybuf,new_word,pos);
  183.       if ((error=_mi_ck_write(info,keynr,(uchar*) keybuf,key_length)))
  184.         goto err2;
  185.     }
  186.     if (cmp<=0) old_word++;
  187.     if (cmp>=0) new_word++;
  188.  }
  189.  if (old_word->pos)
  190.    error=_mi_ft_erase(info,keynr,keybuf,old_word,pos);
  191.  else if (new_word->pos)
  192.    error=_mi_ft_store(info,keynr,keybuf,new_word,pos);
  193. err2:
  194.     my_free((char*) newlist,MYF(0));
  195. err1:
  196.     my_free((char*) oldlist,MYF(0));
  197. err0:
  198.   DBUG_RETURN(error);
  199. }
  200. /* adds a document to the collection */
  201. int _mi_ft_add(MI_INFO *info, uint keynr, byte *keybuf, const byte *record,
  202.        my_off_t pos)
  203. {
  204.   int error= -1;
  205.   FT_WORD *wlist;
  206.   DBUG_ENTER("_mi_ft_add");
  207.   if ((wlist=_mi_ft_parserecord(info, keynr, record)))
  208.   {
  209.     error=_mi_ft_store(info,keynr,keybuf,wlist,pos);
  210.     my_free((char*) wlist,MYF(0));
  211.   }
  212.   DBUG_RETURN(error);
  213. }
  214. /* removes a document from the collection */
  215. int _mi_ft_del(MI_INFO *info, uint keynr, byte *keybuf, const byte *record,
  216.        my_off_t pos)
  217. {
  218.   int error= -1;
  219.   FT_WORD *wlist;
  220.   DBUG_ENTER("_mi_ft_del");
  221.   DBUG_PRINT("enter",("keynr: %d",keynr));
  222.   if ((wlist=_mi_ft_parserecord(info, keynr, record)))
  223.   {
  224.     error=_mi_ft_erase(info,keynr,keybuf,wlist,pos);
  225.     my_free((char*) wlist,MYF(0));
  226.   }
  227.   DBUG_PRINT("exit",("Return: %d",error));
  228.   DBUG_RETURN(error);
  229. }
  230. uint _ft_make_key(MI_INFO *info, uint keynr, byte *keybuf, FT_WORD *wptr,
  231.   my_off_t filepos)
  232. {
  233.   byte buf[HA_FT_MAXBYTELEN+16];
  234.   DBUG_ENTER("_ft_make_key");
  235. #if HA_FT_WTYPE == HA_KEYTYPE_FLOAT
  236.   {
  237.     float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
  238.     mi_float4store(buf,weight);
  239.   }
  240. #else
  241. #error
  242. #endif
  243.   int2store(buf+HA_FT_WLEN,wptr->len);
  244.   memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
  245.   DBUG_RETURN(_mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos));
  246. }
  247. /*
  248.   convert key value to ft2
  249. */
  250. uint _mi_ft_convert_to_ft2(MI_INFO *info, uint keynr, uchar *key)
  251. {
  252.   my_off_t root;
  253.   DYNAMIC_ARRAY *da=info->ft1_to_ft2;
  254.   MI_KEYDEF *keyinfo=&info->s->ft2_keyinfo;
  255.   uchar *key_ptr= (uchar*) dynamic_array_ptr(da, 0), *end;
  256.   uint length, key_length;
  257.   DBUG_ENTER("_mi_ft_convert_to_ft2");
  258.   /* we'll generate one pageful at once, and insert the rest one-by-one */
  259.   /* calculating the length of this page ...*/
  260.   length=(keyinfo->block_length-2) / keyinfo->keylength;
  261.   set_if_smaller(length, da->elements);
  262.   length=length * keyinfo->keylength;
  263.   get_key_full_length_rdonly(key_length, key);
  264.   while (_mi_ck_delete(info, keynr, key, key_length) == 0)
  265.     /* nothing to do here.
  266.        _mi_ck_delete() will populate info->ft1_to_ft2 with deleted keys
  267.      */;
  268.   /* creating pageful of keys */
  269.   mi_putint(info->buff,length+2,0);
  270.   memcpy(info->buff+2, key_ptr, length);
  271.   info->buff_used=info->page_changed=1;           /* info->buff is used */
  272.   if ((root= _mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR ||
  273.       _mi_write_keypage(info,keyinfo,root,DFLT_INIT_HITS,info->buff))
  274.     DBUG_RETURN(-1);
  275.   /* inserting the rest of key values */
  276.   end= (uchar*) dynamic_array_ptr(da, da->elements);
  277.   for (key_ptr+=length; key_ptr < end; key_ptr+=keyinfo->keylength)
  278.     if(_mi_ck_real_write_btree(info, keyinfo, key_ptr, 0, &root, SEARCH_SAME))
  279.       DBUG_RETURN(-1);
  280.   /* now, writing the word key entry */
  281.   ft_intXstore(key+key_length, - (int) da->elements);
  282.   _mi_dpointer(info, key+key_length+HA_FT_WLEN, root);
  283.   DBUG_RETURN(_mi_ck_real_write_btree(info,
  284.                                      info->s->keyinfo+keynr,
  285.                                      key, 0,
  286.                                      &info->s->state.key_root[keynr],
  287.                                      SEARCH_SAME));
  288. }