~drizzle-trunk/drizzle/development : contents of storage/myisam/ft

~drizzle-trunk/drizzle/development : (revision 33)

/* Copyright (C) 2000-2004, 2006 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Written by Sergei A. Golubchik, who has a shared copyright to this code */

/* functions to work with full-text indices */

#include "ftdefs.h"
#include <math.h>

void _mi_ft_segiterator_init(MI_INFO *info, uint keynr, const uchar *record,
			     FT_SEG_ITERATOR *ftsi)
{
  DBUG_ENTER("_mi_ft_segiterator_init");

  ftsi->num=info->s->keyinfo[keynr].keysegs;
  ftsi->seg=info->s->keyinfo[keynr].seg;
  ftsi->rec=record;
  DBUG_VOID_RETURN;
}

void _mi_ft_segiterator_dummy_init(const uchar *record, uint len,
				   FT_SEG_ITERATOR *ftsi)
{
  DBUG_ENTER("_mi_ft_segiterator_dummy_init");

  ftsi->num=1;
  ftsi->seg=0;
  ftsi->pos=record;
  ftsi->len=len;
  DBUG_VOID_RETURN;
}

/*
  This function breaks convention "return 0 in success"
  but it's easier to use like this

     while(_mi_ft_segiterator())

  so "1" means "OK", "0" means "EOF"
*/

uint _mi_ft_segiterator(register FT_SEG_ITERATOR *ftsi)
{
  DBUG_ENTER("_mi_ft_segiterator");

  if (!ftsi->num)
    DBUG_RETURN(0);

  ftsi->num--;
  if (!ftsi->seg)
    DBUG_RETURN(1);

  ftsi->seg--;

  if (ftsi->seg->null_bit &&
      (ftsi->rec[ftsi->seg->null_pos] & ftsi->seg->null_bit))
  {
    ftsi->pos=0;
    DBUG_RETURN(1);
  }
  ftsi->pos= ftsi->rec+ftsi->seg->start;
  if (ftsi->seg->flag & HA_VAR_LENGTH_PART)
  {
    uint pack_length= (ftsi->seg->bit_start);
    ftsi->len= (pack_length == 1 ? (uint) *(uchar*) ftsi->pos :
                uint2korr(ftsi->pos));
    ftsi->pos+= pack_length;			 /* Skip VARCHAR length */
    DBUG_RETURN(1);
  }
  if (ftsi->seg->flag & HA_BLOB_PART)
  {
    ftsi->len=_mi_calc_blob_length(ftsi->seg->bit_start,ftsi->pos);
    memcpy_fixed((char*) &ftsi->pos, ftsi->pos+ftsi->seg->bit_start,
		 sizeof(char*));
    DBUG_RETURN(1);
  }
  ftsi->len=ftsi->seg->length;
  DBUG_RETURN(1);
}


/* parses a document i.e. calls ft_parse for every keyseg */

uint _mi_ft_parse(TREE *parsed, MI_INFO *info, uint keynr, const uchar *record,
                  MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
  FT_SEG_ITERATOR ftsi;
  struct st_mysql_ftparser *parser;
  DBUG_ENTER("_mi_ft_parse");

  _mi_ft_segiterator_init(info, keynr, record, &ftsi);

  ft_parse_init(parsed, info->s->keyinfo[keynr].seg->charset);
  parser= info->s->keyinfo[keynr].parser;
  while (_mi_ft_segiterator(&ftsi))
  {
    if (ftsi.pos)
      if (ft_parse(parsed, (uchar *)ftsi.pos, ftsi.len, parser, param, mem_root))
        DBUG_RETURN(1);
  }
  DBUG_RETURN(0);
}

FT_WORD *_mi_ft_parserecord(MI_INFO *info, uint keynr, const uchar *record,
                             MEM_ROOT *mem_root)
{
  TREE ptree;
  MYSQL_FTPARSER_PARAM *param;
  DBUG_ENTER("_mi_ft_parserecord");
  if (! (param= ftparser_call_initializer(info, keynr, 0)))
    DBUG_RETURN(NULL);
  bzero((char*) &ptree, sizeof(ptree));
  param->flags= 0;
  if (_mi_ft_parse(&ptree, info, keynr, record, param, mem_root))
    DBUG_RETURN(NULL);

  DBUG_RETURN(ft_linearize(&ptree, mem_root));
}

static int _mi_ft_store(MI_INFO *info, uint keynr, uchar *keybuf,
			FT_WORD *wlist, my_off_t filepos)
{
  uint key_length;
  DBUG_ENTER("_mi_ft_store");

  for (; wlist->pos; wlist++)
  {
    key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
    if (_mi_ck_write(info,keynr,(uchar*) keybuf,key_length))
      DBUG_RETURN(1);
   }
   DBUG_RETURN(0);
}

static int _mi_ft_erase(MI_INFO *info, uint keynr, uchar *keybuf,
			FT_WORD *wlist, my_off_t filepos)
{
  uint key_length, err=0;
  DBUG_ENTER("_mi_ft_erase");

  for (; wlist->pos; wlist++)
  {
    key_length=_ft_make_key(info,keynr,keybuf,wlist,filepos);
    if (_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length))
      err=1;
   }
   DBUG_RETURN(err);
}

/*
  Compares an appropriate parts of two WORD_KEY keys directly out of records
  returns 1 if they are different
*/

#define THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT 1
#define GEE_THEY_ARE_ABSOLUTELY_IDENTICAL	 0

int _mi_ft_cmp(MI_INFO *info, uint keynr, const uchar *rec1, const uchar *rec2)
{
  FT_SEG_ITERATOR ftsi1, ftsi2;
  CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
  DBUG_ENTER("_mi_ft_cmp");
  _mi_ft_segiterator_init(info, keynr, rec1, &ftsi1);
  _mi_ft_segiterator_init(info, keynr, rec2, &ftsi2);

  while (_mi_ft_segiterator(&ftsi1) && _mi_ft_segiterator(&ftsi2))
  {
    if ((ftsi1.pos != ftsi2.pos) &&
        (!ftsi1.pos || !ftsi2.pos ||
         ha_compare_text(cs, (uchar*) ftsi1.pos,ftsi1.len,
                         (uchar*) ftsi2.pos,ftsi2.len,0,0)))
      DBUG_RETURN(THOSE_TWO_DAMN_KEYS_ARE_REALLY_DIFFERENT);
  }
  DBUG_RETURN(GEE_THEY_ARE_ABSOLUTELY_IDENTICAL);
}


/* update a document entry */

int _mi_ft_update(MI_INFO *info, uint keynr, uchar *keybuf,
                  const uchar *oldrec, const uchar *newrec, my_off_t pos)
{
  int error= -1;
  FT_WORD *oldlist,*newlist, *old_word, *new_word;
  CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
  uint key_length;
  int cmp, cmp2;
  DBUG_ENTER("_mi_ft_update");

  if (!(old_word=oldlist=_mi_ft_parserecord(info, keynr, oldrec,
                                            &info->ft_memroot)) ||
      !(new_word=newlist=_mi_ft_parserecord(info, keynr, newrec,
                                            &info->ft_memroot)))
    goto err;

  error=0;
  while(old_word->pos && new_word->pos)
  {
    cmp= ha_compare_text(cs, (uchar*) old_word->pos,old_word->len,
                             (uchar*) new_word->pos,new_word->len,0,0);
    cmp2= cmp ? 0 : (fabs(old_word->weight - new_word->weight) > 1.e-5);

    if (cmp < 0 || cmp2)
    {
      key_length=_ft_make_key(info,keynr,keybuf,old_word,pos);
      if ((error=_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length)))
        goto err;
    }
    if (cmp > 0 || cmp2)
    {
      key_length=_ft_make_key(info,keynr,keybuf,new_word,pos);
      if ((error=_mi_ck_write(info,keynr,(uchar*) keybuf,key_length)))
        goto err;
    }
    if (cmp<=0) old_word++;
    if (cmp>=0) new_word++;
 }
 if (old_word->pos)
   error=_mi_ft_erase(info,keynr,keybuf,old_word,pos);
 else if (new_word->pos)
   error=_mi_ft_store(info,keynr,keybuf,new_word,pos);

err:
  free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
  DBUG_RETURN(error);
}


/* adds a document to the collection */

int _mi_ft_add(MI_INFO *info, uint keynr, uchar *keybuf, const uchar *record,
	       my_off_t pos)
{
  int error= -1;
  FT_WORD *wlist;
  DBUG_ENTER("_mi_ft_add");
  DBUG_PRINT("enter",("keynr: %d",keynr));

  if ((wlist=_mi_ft_parserecord(info, keynr, record, &info->ft_memroot)))
    error=_mi_ft_store(info,keynr,keybuf,wlist,pos);

  free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
  DBUG_PRINT("exit",("Return: %d",error));
  DBUG_RETURN(error);
}


/* removes a document from the collection */

int _mi_ft_del(MI_INFO *info, uint keynr, uchar *keybuf, const uchar *record,
	       my_off_t pos)
{
  int error= -1;
  FT_WORD *wlist;
  DBUG_ENTER("_mi_ft_del");
  DBUG_PRINT("enter",("keynr: %d",keynr));

  if ((wlist=_mi_ft_parserecord(info, keynr, record, &info->ft_memroot)))
    error=_mi_ft_erase(info,keynr,keybuf,wlist,pos);

  free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
  DBUG_PRINT("exit",("Return: %d",error));
  DBUG_RETURN(error);
}

uint _ft_make_key(MI_INFO *info, uint keynr, uchar *keybuf, FT_WORD *wptr,
		  my_off_t filepos)
{
  uchar buf[HA_FT_MAXBYTELEN+16];
  DBUG_ENTER("_ft_make_key");

#if HA_FT_WTYPE == HA_KEYTYPE_FLOAT
  {
    float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
    mi_float4store(buf,weight);
  }
#else
#error
#endif

  int2store(buf+HA_FT_WLEN,wptr->len);
  memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
  DBUG_RETURN(_mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos));
}


/*
  convert key value to ft2
*/

uint _mi_ft_convert_to_ft2(MI_INFO *info, uint keynr, uchar *key)
{
  my_off_t root;
  DYNAMIC_ARRAY *da=info->ft1_to_ft2;
  MI_KEYDEF *keyinfo=&info->s->ft2_keyinfo;
  uchar *key_ptr= (uchar*) dynamic_array_ptr(da, 0), *end;
  uint length, key_length;
  DBUG_ENTER("_mi_ft_convert_to_ft2");

  /* we'll generate one pageful at once, and insert the rest one-by-one */
  /* calculating the length of this page ...*/
  length=(keyinfo->block_length-2) / keyinfo->keylength;
  set_if_smaller(length, da->elements);
  length=length * keyinfo->keylength;

  get_key_full_length_rdonly(key_length, key);
  while (_mi_ck_delete(info, keynr, key, key_length) == 0)
  {
    /*
      nothing to do here.
      _mi_ck_delete() will populate info->ft1_to_ft2 with deleted keys
     */
  }

  /* creating pageful of keys */
  mi_putint(info->buff,length+2,0);
  memcpy(info->buff+2, key_ptr, length);
  info->buff_used=info->page_changed=1;           /* info->buff is used */
  if ((root= _mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR ||
      _mi_write_keypage(info,keyinfo,root,DFLT_INIT_HITS,info->buff))
    DBUG_RETURN(-1);

  /* inserting the rest of key values */
  end= (uchar*) dynamic_array_ptr(da, da->elements);
  for (key_ptr+=length; key_ptr < end; key_ptr+=keyinfo->keylength)
    if(_mi_ck_real_write_btree(info, keyinfo, key_ptr, 0, &root, SEARCH_SAME))
      DBUG_RETURN(-1);

  /* now, writing the word key entry */
  ft_intXstore(key+key_length, - (int) da->elements);
  _mi_dpointer(info, key+key_length+HA_FT_WLEN, root);

  DBUG_RETURN(_mi_ck_real_write_btree(info,
                                     info->s->keyinfo+keynr,
                                     key, 0,
                                     &info->s->state.key_root[keynr],
                                     SEARCH_SAME));
}


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