• unknown's avatar
    Fixes after review of guilhem of block record patch · eb7d9500
    unknown authored
    Short overview:
    Changed a lot of variable, functions, defines and struct elements to use more readable names
    More comments (mostly function and structure slot comments)
    
    Other things:
    Changed 'USE_WHOLE_KEY' to a big number to not interfer with long keys
    Ensure that tail block are at least of size 'MIN_TAIL_SIZE'
    Allow longer keys and key parts than before (don't limit Maria interface by HA_MAX_KEY_LENGTH)
    Use ma_chsize() to write initial bitmap page
    Added checking if using file with wrong block_size
    Added issing types to type_names[] (for maria_chk -d)
    Added maria_max_key_length()
    
    
    include/maria.h:
      Changed maria_portable_size_char_ptr to portable_size_char_ptr and moved it to my_handler.h
      Removed not used variable maria_delay_rec_write.
      More comments
    include/my_handler.h:
      Added portable_sizeof_char_ptr
    include/myisam.h:
      Changed mi_portable_size_char_ptr to portable_size_char_ptr and moved it to my_handler.h
    mysql-test/r/maria.result:
      Fix results when we now have a longer key length
    mysql-test/t/maria.test:
      More tests
    mysys/my_pread.c:
      Code cleanup
    sql/net_serv.cc:
      Changed warning to note (as in main 5.1 tree) to avoid not critical failing tests
    sql/sql_select.cc:
      Use portable_sizeof_char_ptr
    storage/maria/ha_maria.cc:
      Added max_supported_key_length(), as this is not a trival function anymore
    storage/maria/ha_maria.h:
      Moved max_supported_key_length(), as this is not a trival function anymore
    storage/maria/ma_bitmap.c:
      Lots of new comments
      Added maria_bitmap_marker[] to mark 2 last bytes of each bitmap (for corruption detection)
      Trivial code changes (based on review comments)
    storage/maria/ma_blockrec.c:
      More code comments
      Renamed _block_row() functions to _block_record()
      Trivial code changes, based on review comments
      Moved Code from maria_close() to _ma_end_block_record()
      Some function renames to make things more understandable
      DIR_ENTRY_OFFSET -> DIR_COUNT_OFFSET
      keybuff_used -> keyread_buff_used
      ma_recordpos_to_offset -> ma_recordpos_to_dir_entry
      Changed some 'rec' named variables to 'column'.
      Ensure that tail block are at least of size 'MIN_TAIL_SIZE'
    storage/maria/ma_blockrec.h:
      More comments
      DIRCOUNT_SIZE -> DIR_COUNT_SIZE
      Added define for maira_bitmap_marker[]
      ma_recordpos_to_offset -> ma_recordpos_to_dir_entry
      xxx_block_row() -> xxx_block_record()
      Made _ma_read_bitmap_page() static
    storage/maria/ma_check.c:
      More comments
      ma_recordpos_to_offset() -> ma_recordpos_to_dir_entry()
      DIR_ENTRY_OFFSET -> DIR_COUNT_OFFSET
      rec variables -> column variables
      recdef -> columndef
    storage/maria/ma_checksum.c:
      rec -> column
      Avoid an 'if' in _ma_checksum() for the common case
    storage/maria/ma_close.c:
      Moved resetting of info->dfile to ma_end_once_block_record()
    storage/maria/ma_create.c:
      Some variable changes to make things more readable:
      recinfo -> columndef
      rec -> column
      rec_end -> end_column
      record_type -> datafile_type
      ma_recinfo_write() -> ma_columndef_write()
      Fixed wrong setting of 'data_file_length'; Now max_rows should be calculated correctly
      New check if too long key.
      Use ma_chsize() to write bitmap page.
    storage/maria/ma_delete.c:
      keybuff_used -> keyread_buff_used
    storage/maria/ma_dynrec.c:
      rec -> columndef
      rec_length -> column_length
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
      Better comment for _ma_read_rnd_dynamic_record()
    storage/maria/ma_ft_eval.c:
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/maria/ma_ft_test1.c:
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/maria/ma_ft_update.c:
      keybuff_used -> keyread_buff_used
    storage/maria/ma_info.c:
      More comments
    storage/maria/ma_open.c:
      Added checking if using file with wrong block_size
      New checking of max_key_length
      rec -> columndef
      _ma_recinfo_write -> _ma_columndef_write
      Don't change block_size (as this is checked in ma_create())
      More comments
    storage/maria/ma_packrec.c:
      Trivial code changes
      rec -> columndef
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/maria/ma_page.c:
      keybuff_used -> keyread_buff_used
    storage/maria/ma_rkey.c:
      Removed not needded empty line
    storage/maria/ma_rrnd.c:
      Removed not used variable
    storage/maria/ma_rt_index.c:
      keybuff_used -> keyread_buff_used
    storage/maria/ma_search.c:
      keybuff_used -> keyread_buff_used
      Trivial code changes
    storage/maria/ma_sp_test.c:
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/maria/ma_test1.c:
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/maria/ma_test2.c:
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/maria/ma_update.c:
      Updated comment
    storage/maria/ma_write.c:
      keybuff_used -> keyread_buff_used
    storage/maria/maria_chk.c:
      Added missing types to type_names[]
      Removed not used variable
      rec -> columndef
      Replaced some numbers with define flags
    storage/maria/maria_def.h:
      More comments
      Added 'MARIA_INDEX_MIN_OVERHEAD_SIZE'
      rec -> columndef
      keybuff_used -> keyread_buff_used
      _ma_recinfo_write -> _ma_culumndef_write
      _ma_recinfo_read -> _ma_columndef_read
      Changed 'USE_WHOLE_KEY' to a big number to not interfer with long keys
      Added maria_max_key_length()
    storage/maria/maria_pack.c:
      Updated message strings
      rec -> columndef
      maria_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
      More comments
    storage/myisam/ft_eval.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/ft_test1.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/mi_checksum.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/mi_create.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/mi_dynrec.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/mi_open.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/mi_packrec.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/mi_rkey.c:
      Unlock mutex also in case of error
    storage/myisam/mi_test1.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/mi_test2.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/myisampack.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    storage/myisam/sp_test.c:
      mi_portable_sizeof_char_ptr -> portable_sizeof_char_ptr
    support-files/magic:
      Fixed typo
    eb7d9500
ma_ft_update.c 10.1 KB
/* Copyright (C) 2006 MySQL AB & MySQL Finland AB & TCX DataKonsult 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 "ma_ftdefs.h"
#include <math.h>

void _ma_ft_segiterator_init(MARIA_HA *info, uint keynr, const byte *record,
			     FT_SEG_ITERATOR *ftsi)
{
  DBUG_ENTER("_ma_ft_segiterator_init");

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

void _ma_ft_segiterator_dummy_init(const byte *record, uint len,
				   FT_SEG_ITERATOR *ftsi)
{
  DBUG_ENTER("_ma_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(_ma_ft_segiterator())

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

uint _ma_ft_segiterator(register FT_SEG_ITERATOR *ftsi)
{
  DBUG_ENTER("_ma_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= _ma_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 maria_ft_parse for every keyseg */

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

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

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

FT_WORD * _ma_ft_parserecord(MARIA_HA *info, uint keynr, const byte *record,
                             MEM_ROOT *mem_root)
{
  TREE ptree;
  MYSQL_FTPARSER_PARAM *param;
  DBUG_ENTER("_ma_ft_parserecord");
  if (! (param= maria_ftparser_call_initializer(info, keynr, 0)))
    DBUG_RETURN(NULL);
  bzero((char*) &ptree, sizeof(ptree));
  param->flags= 0;
  if (_ma_ft_parse(&ptree, info, keynr, record, param, mem_root))
    DBUG_RETURN(NULL);

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

static int _ma_ft_store(MARIA_HA *info, uint keynr, byte *keybuf,
			FT_WORD *wlist, my_off_t filepos)
{
  uint key_length;
  DBUG_ENTER("_ma_ft_store");

  for (; wlist->pos; wlist++)
  {
    key_length= _ma_ft_make_key(info,keynr,keybuf,wlist,filepos);
    if (_ma_ck_write(info, keynr, keybuf, key_length))
      DBUG_RETURN(1);
   }
   DBUG_RETURN(0);
}

static int _ma_ft_erase(MARIA_HA *info, uint keynr, byte *keybuf,
			FT_WORD *wlist, my_off_t filepos)
{
  uint key_length, err=0;
  DBUG_ENTER("_ma_ft_erase");

  for (; wlist->pos; wlist++)
  {
    key_length= _ma_ft_make_key(info,keynr,keybuf,wlist,filepos);
    if (_ma_ck_delete(info, keynr, 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 _ma_ft_cmp(MARIA_HA *info, uint keynr, const byte *rec1, const byte *rec2)
{
  FT_SEG_ITERATOR ftsi1, ftsi2;
  CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
  DBUG_ENTER("_ma_ft_cmp");

  _ma_ft_segiterator_init(info, keynr, rec1, &ftsi1);
  _ma_ft_segiterator_init(info, keynr, rec2, &ftsi2);

  while (_ma_ft_segiterator(&ftsi1) && _ma_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 _ma_ft_update(MARIA_HA *info, uint keynr, byte *keybuf,
                  const byte *oldrec, const byte *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("_ma_ft_update");

  if (!(old_word=oldlist=_ma_ft_parserecord(info, keynr, oldrec,
                                            &info->ft_memroot)) ||
      !(new_word=newlist=_ma_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= _ma_ft_make_key(info,keynr,keybuf,old_word,pos);
      if ((error= _ma_ck_delete(info,keynr, keybuf,key_length)))
        goto err;
    }
    if (cmp > 0 || cmp2)
    {
      key_length= _ma_ft_make_key(info, keynr, keybuf, new_word,pos);
      if ((error= _ma_ck_write(info, keynr, keybuf,key_length)))
        goto err;
    }
    if (cmp<=0) old_word++;
    if (cmp>=0) new_word++;
 }
 if (old_word->pos)
   error= _ma_ft_erase(info,keynr,keybuf,old_word,pos);
 else if (new_word->pos)
   error= _ma_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 _ma_ft_add(MARIA_HA *info, uint keynr, byte *keybuf, const byte *record,
	       my_off_t pos)
{
  int error= -1;
  FT_WORD *wlist;
  DBUG_ENTER("_ma_ft_add");
  DBUG_PRINT("enter",("keynr: %d",keynr));

  if ((wlist= _ma_ft_parserecord(info, keynr, record, &info->ft_memroot)))
    error= _ma_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 _ma_ft_del(MARIA_HA *info, uint keynr, byte *keybuf, const byte *record,
	       my_off_t pos)
{
  int error= -1;
  FT_WORD *wlist;
  DBUG_ENTER("_ma_ft_del");
  DBUG_PRINT("enter",("keynr: %d",keynr));

  if ((wlist= _ma_ft_parserecord(info, keynr, record, &info->ft_memroot)))
    error= _ma_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 _ma_ft_make_key(MARIA_HA *info, uint keynr, byte *keybuf, FT_WORD *wptr,
                     my_off_t filepos)
{
  byte buf[HA_FT_MAXBYTELEN+16];
  DBUG_ENTER("_ma_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(_ma_make_key(info, keynr, keybuf, buf, filepos));
}


/*
  convert key value to ft2
*/

uint _ma_ft_convert_to_ft2(MARIA_HA *info, uint keynr, byte *key)
{
  my_off_t root;
  DYNAMIC_ARRAY *da=info->ft1_to_ft2;
  MARIA_KEYDEF *keyinfo=&info->s->ft2_keyinfo;
  byte *key_ptr= (byte*) dynamic_array_ptr(da, 0), *end;
  uint length, key_length;
  DBUG_ENTER("_ma_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 (_ma_ck_delete(info, keynr, key, key_length) == 0)
  {
    /*
      nothing to do here.
      _ma_ck_delete() will populate info->ft1_to_ft2 with deleted keys
     */
  }

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

  /* inserting the rest of key values */
  end= (byte*) dynamic_array_ptr(da, da->elements);
  for (key_ptr+=length; key_ptr < end; key_ptr+=keyinfo->keylength)
    if(_ma_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);
  _ma_dpointer(info, key+key_length+HA_FT_WLEN, root);

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