求mysql 关于blob的接口

oken

BLOB是一个二进制大对象，可以容纳可变数量的数据。有4种BLOB类型：TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB。它们只是可容纳值的最大长度不同。
   mysql有些存储引擎是支持blob类型的，有些不支持。例如，MYISAM和falcon都是支持blob的。
   我现在的问题是，mysql是如何调用函数来处理blob这种特殊类型的。例如，在一个含有blob字段的表里面执行update,insert,delete这些操作的时候，函数是如何调用的。
   由于MYISAM是大多数表的默认存储引擎，所以我就研究了一下MYISAM。
我看了十多天MYISAM的源代码，始终没有搞明白里面的函数调用关系。因为结构太复杂了！在mysql-6.0.3/storage/myisam/目录下有个Mi_update.c文件，代码如下：
/* Update an old row in a MyISAM table */

#include "fulltext.h"
#include "rt_index.h"

int mi_update(register MI_INFO *info, const uchar *oldrec, uchar *newrec)
{//MI_INFO在myisamdef.h定义
   int flag,key_changed,save_errno;
   reg3 my_off_t pos;
   uint i;
   uchar old_key[MI_MAX_KEY_BUFF],*new_key;//#define MI_MAX_KEY_BUFF  (MI_MAX_KEY_LENGTH+MI_MAX_KEY_SEG*6+8+8)
   bool auto_key_changed=0;
   ulonglong changed;
   MYISAM_SHARE *share=info->s;
   ha_checksum old_checksum;
   DBUG_ENTER("mi_update");
   LINT_INIT(new_key);
   LINT_INIT(changed);
   LINT_INIT(old_checksum);

   DBUG_EXECUTE_IF("myisam_pretend_crashed_table_on_usage",
                   mi_print_error(info->s, HA_ERR_CRASHED);
                   DBUG_RETURN(my_errno= HA_ERR_CRASHED););
   if (!(info->update & HA_STATE_AKTIV))
   {
     DBUG_RETURN(my_errno=HA_ERR_KEY_NOT_FOUND);
   }
   if (share->options & HA_OPTION_READ_ONLY_DATA)
   {
     DBUG_RETURN(my_errno=EACCES);
   }
   if (info->state->key_file_length >= share->base.margin_key_file_length)
   {
     DBUG_RETURN(my_errno=HA_ERR_INDEX_FILE_FULL);
   }
   pos=info->lastpos;
   if (_mi_readinfo(info,F_WRLCK,1))
     DBUG_RETURN(my_errno);

   if (share->calc_checksum)
     old_checksum=info->checksum=(*share->calc_checksum)(info,oldrec);
   if ((*share->compare_record)(info,oldrec))
   {
     save_errno=my_errno;
     goto err_end;   /* Record has changed */
   }


   /* Calculate and check all unique constraints */
   key_changed=0;
   for (i=0 ; i < share->state.header.uniques ; i++)
   {
     MI_UNIQUEDEF *def=share->uniqueinfo+i;
     if (mi_unique_comp(def, newrec, oldrec,1) &&
  mi_check_unique(info, def, newrec, mi_unique_hash(def, newrec),
    info->lastpos))
     {
       save_errno=my_errno;
       goto err_end;
     }
   }
   if (_mi_mark_file_changed(info))
   {
     save_errno=my_errno;
     goto err_end;
   }

   /* Check which keys changed from the original row */

   new_key=info->lastkey2;
   changed=0;
   for (i=0 ; i < share->base.keys ; i++)
   {
     if (mi_is_key_active(share->state.key_map, i))
     {
       if (share->keyinfo.flag & HA_FULLTEXT )//128
       {
  if (_mi_ft_cmp(info,i,oldrec, newrec))//ft_update.c
  {
    if ((int) i == info->lastinx)
    {
    /*
      We are changeing the index we are reading on.  Mark that
      the index data has changed and we need to do a full search
      when doing read-next
    */
      key_changed|=HA_STATE_WRITTEN;//4//4
    }
    changed|=((ulonglong) 1 << i);
    if (_mi_ft_update(info,i, old_key,oldrec,newrec,pos))
      goto err;
  }
       }
       else
       {
  uint new_length=_mi_make_key(info,i,new_key,newrec,pos);//Mi_key.c
  uint old_length=_mi_make_key(info,i,old_key,oldrec,pos);

         /* The above changed info->lastkey2. Inform mi_rnext_same(). */
         info->update&= ~HA_STATE_RNEXT_SAME; //4096

  if (new_length != old_length ||
      memcmp((uchar*) old_key,(uchar*) new_key,new_length))
  {
    if ((int) i == info->lastinx)
      key_changed|=HA_STATE_WRITTEN; /* Mark that keyfile changed */
    changed|=((ulonglong) 1 << i);
    share->keyinfo.version++;
    if (share->keyinfo.ck_delete(info,i,old_key,old_length)) goto err;
    if (share->keyinfo.ck_insert(info,i,new_key,new_length)) goto err;
    if (share->base.auto_key == i+1)
      auto_key_changed=1;
  }
       }
     }
   }
   /*
     If we are running with external locking, we must update the index file
     that something has changed.
   */
   if (changed || !my_disable_locking)
     key_changed|= HA_STATE_CHANGED;// 1 database has changed

   if (share->calc_checksum)
   {
     info->checksum=(*share->calc_checksum)(info,newrec);
     /* Store new checksum in index file header */
     key_changed|= HA_STATE_CHANGED;
   }
   {
     /*
       Don't update index file if data file is not extended and no status
       information changed
     */
     MI_STATUS_INFO state; // st_mi_status_info Myisamdef.h
     ha_rows org_split;
     my_off_t org_delete_link;

     memcpy((char*) &state, (char*) info->state, sizeof(state));
     org_split=      share->state.split;
     org_delete_link= share->state.dellink;
     if ((*share->update_record)(info,pos,newrec))
       goto err;
     if (!key_changed &&
  (memcmp((char*) &state, (char*) info->state, sizeof(state)) ||
   org_split != share->state.split ||
   org_delete_link != share->state.dellink))
       key_changed|= HA_STATE_CHANGED;  /* Must update index file */
   }
   if (auto_key_changed)
     set_if_bigger(info->s->state.auto_increment,
                   retrieve_auto_increment(info, newrec));
   if (share->calc_checksum)
     info->state->checksum+=(info->checksum - old_checksum);

   info->update= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED | HA_STATE_AKTIV |
    key_changed);
   myisam_log_record(MI_LOG_UPDATE,info,newrec,info->lastpos,0);
   /*
     Every myisam function that updates myisam table must end with
     call to _mi_writeinfo(). If operation (second param of
     _mi_writeinfo()) is not 0 it sets share->changed to 1, that is
     flags that data has changed. If operation is 0, this function
     equals to no-op in this case.

     mi_update() must always pass !0 value as operation, since even if
     there is no index change there could be data change.
   */
   VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
   allow_break();    /* Allow SIGHUP & SIGINT */
   if (info->invalidator != 0)
   {
     DBUG_PRINT("info", ("invalidator... '%s' (update)", info->filename));
     (*info->invalidator)(info->filename);
     info->invalidator=0;
   }
   DBUG_RETURN(0);

err:
   DBUG_PRINT("error",("key: %d  errno: %d",i,my_errno));
   save_errno=my_errno;
   if (changed)
     key_changed|= HA_STATE_CHANGED;
   if (my_errno == HA_ERR_FOUND_DUPP_KEY || my_errno == HA_ERR_OUT_OF_MEM ||
       my_errno == HA_ERR_RECORD_FILE_FULL)
   {
     info->errkey= (int) i;
     flag=0;
     do
     {
       if (((ulonglong) 1 << i) & changed)
       {
  if (share->keyinfo.flag & HA_FULLTEXT)
  {
    if ((flag++ && _mi_ft_del(info,i, new_key,newrec,pos)) ||
        _mi_ft_add(info,i, old_key,oldrec,pos))
      break;
  }
  else
  {
    uint new_length=_mi_make_key(info,i,new_key,newrec,pos);
    uint old_length= _mi_make_key(info,i,old_key,oldrec,pos);
    if ((flag++ && _mi_ck_delete(info,i,new_key,new_length)) ||
        _mi_ck_write(info,i,old_key,old_length))
      break;
  }
       }
     } while (i-- != 0);
   }
   else
   {
     mi_print_error(info->s, HA_ERR_CRASHED);
     mi_mark_crashed(info);
   }
   info->update= (HA_STATE_CHANGED | HA_STATE_AKTIV | HA_STATE_ROW_CHANGED |
    key_changed);

  err_end:
   myisam_log_record(MI_LOG_UPDATE,info,newrec,info->lastpos,my_errno);
   VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
   allow_break();    /* Allow SIGHUP & SIGINT */
   if (save_errno == HA_ERR_KEY_NOT_FOUND)
   {
     mi_print_error(info->s, HA_ERR_CRASHED);
     save_errno=HA_ERR_CRASHED;
   }
   DBUG_RETURN(my_errno=save_errno);
} /* mi_update */

看代码没有blob这个单词，而是通过调用了一些其他函数，例如：_mi_ft_update：

/* 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= mi_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);
}
还有很多其他代码！
我们项目小组想写一个支持blob操作的存储引擎，不过我是个菜鸟。希望各位大侠出手相助！
这些函数究竟是怎样调用的呢？可以说一下某种引擎（如myisam）的某个操作（如update,write_row,delete)。当然讲得越多越详细越好！
  谢谢！

[ 本帖最后由 oken 于 2008-8-15 18:38 编辑 ]