开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_extra.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：12k
源码类别：

MySQL数据库

开发平台：

Visual C++

mi_extra.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  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.
  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.
  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 */
  17. #include "myisamdef.h"
  18. #ifdef HAVE_MMAP
  19. #include <sys/mman.h>
  20. #endif
  22. static void mi_extra_keyflag(MI_INFO *info, enum ha_extra_function function);
  25. /*
  26.   Set options and buffers to optimize table handling
  28.   SYNOPSIS
  29.     mi_extra()
  30.     info open table
  31.     function operation
  32.     extra_arg Pointer to extra argument (normally pointer to ulong)
  33.      Used when function is one of:
  34. HA_EXTRA_WRITE_CACHE
  35. HA_EXTRA_CACHE
  36.   RETURN VALUES
  37.     0  ok
  38.     #  error
  39. */
  41. int mi_extra(MI_INFO *info, enum ha_extra_function function, void *extra_arg)
  42. {
  43.   int error=0;
  44.   ulong cache_size;
  45.   MYISAM_SHARE *share=info->s;
  46.   DBUG_ENTER("mi_extra");
  47.   DBUG_PRINT("enter",("function: %d",(int) function));
  49.   switch (function) {
  50.   case HA_EXTRA_RESET:
  51.     /*
  52.       Free buffers and reset the following flags:
  53.       EXTRA_CACHE, EXTRA_WRITE_CACHE, EXTRA_KEYREAD, EXTRA_QUICK
  55.       If the row buffer cache is large (for dynamic tables), reduce it
  56.       to save memory.
  57.     */
  58.     if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
  59.     {
  60.       info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  61.       error=end_io_cache(&info->rec_cache);
  62.     }
  63.     if (share->base.blobs)
  64.       mi_alloc_rec_buff(info, -1, &info->rec_buff);
  65. #if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
  66.     if (info->opt_flag & MEMMAP_USED)
  67.       madvise(share->file_map,share->state.state.data_file_length,MADV_RANDOM);
  68. #endif
  69.     info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
  70.     info->quick_mode=0;
  71.     /* Fall through */
  73.   case HA_EXTRA_RESET_STATE: /* Reset state (don't free buffers) */
  74.     info->lastinx= 0; /* Use first index as def */
  75.     info->last_search_keypage=info->lastpos= HA_OFFSET_ERROR;
  76.     info->page_changed=1;
  77. /* Next/prev gives first/last */
  78.     if (info->opt_flag & READ_CACHE_USED)
  79.     {
  80.       reinit_io_cache(&info->rec_cache,READ_CACHE,0,
  81.       (pbool) (info->lock_type != F_UNLCK),
  82.       (pbool) test(info->update & HA_STATE_ROW_CHANGED)
  83.       );
  84.     }
  85.     info->update= ((info->update & HA_STATE_CHANGED) | HA_STATE_NEXT_FOUND |
  86.    HA_STATE_PREV_FOUND);
  87.     break;
  88.   case HA_EXTRA_CACHE:
  89.     if (info->lock_type == F_UNLCK &&
  90. (share->options & HA_OPTION_PACK_RECORD))
  91.     {
  92.       error=1; /* Not possibly if not locked */
  93.       my_errno=EACCES;
  94.       break;
  95.     }
  96. #if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
  97.     if ((share->options & HA_OPTION_COMPRESS_RECORD))
  98.     {
  99.       pthread_mutex_lock(&share->intern_lock);
  100.       if (_mi_memmap_file(info))
  101.       {
  102. /* We don't nead MADV_SEQUENTIAL if small file */
  103. madvise(share->file_map,share->state.state.data_file_length,
  104. share->state.state.data_file_length <= RECORD_CACHE_SIZE*16 ?
  105. MADV_RANDOM : MADV_SEQUENTIAL);
  106. pthread_mutex_unlock(&share->intern_lock);
  107. break;
  108.       }
  109.       pthread_mutex_unlock(&share->intern_lock);
  110.     }
  111. #endif
  112.     if (info->opt_flag & WRITE_CACHE_USED)
  113.     {
  114.       info->opt_flag&= ~WRITE_CACHE_USED;
  115.       if ((error=end_io_cache(&info->rec_cache)))
  116. break;
  117.     }
  118.     if (!(info->opt_flag &
  119.   (READ_CACHE_USED | WRITE_CACHE_USED | MEMMAP_USED)))
  120.     {
  121.       cache_size= (extra_arg ? *(ulong*) extra_arg :
  122.    my_default_record_cache_size);
  123.       if (!(init_io_cache(&info->rec_cache,info->dfile,
  124.  (uint) min(info->state->data_file_length+1,
  125.     cache_size),
  126.   READ_CACHE,0L,(pbool) (info->lock_type != F_UNLCK),
  127.   MYF(share->write_flag & MY_WAIT_IF_FULL))))
  128.       {
  129. info->opt_flag|=READ_CACHE_USED;
  130. info->update&= ~HA_STATE_ROW_CHANGED;
  131.       }
  132.       if (share->concurrent_insert)
  133. info->rec_cache.end_of_file=info->state->data_file_length;
  134.     }
  135.     break;
  136.   case HA_EXTRA_REINIT_CACHE:
  137.     if (info->opt_flag & READ_CACHE_USED)
  138.     {
  139.       reinit_io_cache(&info->rec_cache,READ_CACHE,info->nextpos,
  140.       (pbool) (info->lock_type != F_UNLCK),
  141.       (pbool) test(info->update & HA_STATE_ROW_CHANGED));
  142.       info->update&= ~HA_STATE_ROW_CHANGED;
  143.       if (share->concurrent_insert)
  144. info->rec_cache.end_of_file=info->state->data_file_length;
  145.     }
  146.     break;
  147.   case HA_EXTRA_WRITE_CACHE:
  148.     if (info->lock_type == F_UNLCK)
  149.     {
  150.       error=1; /* Not possibly if not locked */
  151.       break;
  152.     }
  153.     cache_size= (extra_arg ? *(ulong*) extra_arg :
  154.  my_default_record_cache_size);
  155.     if (!(info->opt_flag &
  156.   (READ_CACHE_USED | WRITE_CACHE_USED | OPT_NO_ROWS)) &&
  157. !share->state.header.uniques)
  158.       if (!(init_io_cache(&info->rec_cache,info->dfile, cache_size,
  159.  WRITE_CACHE,info->state->data_file_length,
  160.   (pbool) (info->lock_type != F_UNLCK),
  161.   MYF(share->write_flag & MY_WAIT_IF_FULL))))
  162.       {
  163. info->opt_flag|=WRITE_CACHE_USED;
  164. info->update&= ~(HA_STATE_ROW_CHANGED |
  165.  HA_STATE_WRITE_AT_END |
  166.  HA_STATE_EXTEND_BLOCK);
  167.       }
  168.     break;
  169.   case HA_EXTRA_PREPARE_FOR_UPDATE:
  170.     if (info->s->data_file_type != DYNAMIC_RECORD)
  171.       break;
  172.     /* Remove read/write cache if dynamic rows */
  173.   case HA_EXTRA_NO_CACHE:
  174.     if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
  175.     {
  176.       info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  177.       error=end_io_cache(&info->rec_cache);
  178.       /* Sergei will insert full text index caching here */
  179.     }
  180. #if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
  181.     if (info->opt_flag & MEMMAP_USED)
  182.       madvise(share->file_map,share->state.state.data_file_length,MADV_RANDOM);
  183. #endif
  184.     break;
  185.   case HA_EXTRA_FLUSH_CACHE:
  186.     if (info->opt_flag & WRITE_CACHE_USED)
  187.     {
  188.       if ((error=flush_io_cache(&info->rec_cache)))
  189. mi_mark_crashed(info); /* Fatal error found */
  190.     }
  191.     break;
  192.   case HA_EXTRA_NO_READCHECK:
  193.     info->opt_flag&= ~READ_CHECK_USED; /* No readcheck */
  194.     break;
  195.   case HA_EXTRA_READCHECK:
  196.     info->opt_flag|= READ_CHECK_USED;
  197.     break;
  198.   case HA_EXTRA_KEYREAD: /* Read only keys to record */
  199.   case HA_EXTRA_REMEMBER_POS:
  200.     info->opt_flag |= REMEMBER_OLD_POS;
  201.     bmove((byte*) info->lastkey+share->base.max_key_length*2,
  202.   (byte*) info->lastkey,info->lastkey_length);
  203.     info->save_update= info->update;
  204.     info->save_lastinx= info->lastinx;
  205.     info->save_lastpos= info->lastpos;
  206.     info->save_lastkey_length=info->lastkey_length;
  207.     if (function == HA_EXTRA_REMEMBER_POS)
  208.       break;
  209.     /* fall through */
  210.   case HA_EXTRA_KEYREAD_CHANGE_POS:
  211.     info->opt_flag |= KEY_READ_USED;
  212.     info->read_record=_mi_read_key_record;
  213.     break;
  214.   case HA_EXTRA_NO_KEYREAD:
  215.   case HA_EXTRA_RESTORE_POS:
  216.     if (info->opt_flag & REMEMBER_OLD_POS)
  217.     {
  218.       bmove((byte*) info->lastkey,
  219.     (byte*) info->lastkey+share->base.max_key_length*2,
  220.     info->save_lastkey_length);
  221.       info->update= info->save_update | HA_STATE_WRITTEN;
  222.       info->lastinx= info->save_lastinx;
  223.       info->lastpos= info->save_lastpos;
  224.       info->lastkey_length=info->save_lastkey_length;
  225.     }
  226.     info->read_record= share->read_record;
  227.     info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
  228.     break;
  229.   case HA_EXTRA_NO_USER_CHANGE: /* Database is somehow locked agains changes */
  230.     info->lock_type= F_EXTRA_LCK; /* Simulate as locked */
  231.     break;
  232.   case HA_EXTRA_WAIT_LOCK:
  233.     info->lock_wait=0;
  234.     break;
  235.   case HA_EXTRA_NO_WAIT_LOCK:
  236.     info->lock_wait=MY_DONT_WAIT;
  237.     break;
  238.   case HA_EXTRA_NO_KEYS:
  239.     if (info->lock_type == F_UNLCK)
  240.     {
  241.       error=1; /* Not possibly if not lock */
  242.       break;
  243.     }
  244.     if (share->state.key_map)
  245.     {
  246.       MI_KEYDEF *key=share->keyinfo;
  247.       uint i;
  248.       for (i=0 ; i < share->base.keys ; i++,key++)
  249.       {
  250.         if (!(key->flag & HA_NOSAME) && info->s->base.auto_key != i+1)
  251.         {
  252.           share->state.key_map&= ~ ((ulonglong) 1 << i);
  253.           info->update|= HA_STATE_CHANGED;
  254.         }
  255.       }
  257.       if (!share->changed)
  258.       {
  259. share->state.changed|= STATE_CHANGED | STATE_NOT_ANALYZED;
  260. share->changed=1; /* Update on close */
  261. if (!share->global_changed)
  262. {
  263.   share->global_changed=1;
  264.   share->state.open_count++;
  265. }
  266.       }
  267.       share->state.state= *info->state;
  268.       error=mi_state_info_write(share->kfile,&share->state,1 | 2);
  269.     }
  270.     break;
  271.   case HA_EXTRA_FORCE_REOPEN:
  272.     pthread_mutex_lock(&THR_LOCK_myisam);
  273.     share->last_version= 0L; /* Impossible version */
  274.     pthread_mutex_unlock(&THR_LOCK_myisam);
  275.     break;
  276.   case HA_EXTRA_PREPARE_FOR_DELETE:
  277.     pthread_mutex_lock(&THR_LOCK_myisam);
  278.     share->last_version= 0L; /* Impossible version */
  279. #ifdef __WIN__
  280.     /* Close the isam and data files as Win32 can't drop an open table */
  281.     pthread_mutex_lock(&share->intern_lock);
  282.     if (flush_key_blocks(share->key_cache, share->kfile,
  283.  (function == HA_EXTRA_FORCE_REOPEN ?
  284.   FLUSH_RELEASE : FLUSH_IGNORE_CHANGED)))
  285.     {
  286.       error=my_errno;
  287.       share->changed=1;
  288.       mi_mark_crashed(info); /* Fatal error found */
  289.     }
  290.     if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
  291.     {
  292.       info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  293.       error=end_io_cache(&info->rec_cache);
  294.     }
  295.     if (info->lock_type != F_UNLCK && ! info->was_locked)
  296.     {
  297.       info->was_locked=info->lock_type;
  298.       if (mi_lock_database(info,F_UNLCK))
  299. error=my_errno;
  300.       info->lock_type = F_UNLCK;
  301.     }
  302.     if (share->kfile >= 0)
  303.       _mi_decrement_open_count(info);
  304.     if (share->kfile >= 0 && my_close(share->kfile,MYF(0)))
  305.       error=my_errno;
  306.     {
  307.       LIST *list_element ;
  308.       for (list_element=myisam_open_list ;
  309.    list_element ;
  310.    list_element=list_element->next)
  311.       {
  312. MI_INFO *tmpinfo=(MI_INFO*) list_element->data;
  313. if (tmpinfo->s == info->s)
  314. {
  315.   if (tmpinfo->dfile >= 0 && my_close(tmpinfo->dfile,MYF(0)))
  316.     error = my_errno;
  317.   tmpinfo->dfile= -1;
  318. }
  319.       }
  320.     }
  321.     share->kfile= -1; /* Files aren't open anymore */
  322.     pthread_mutex_unlock(&share->intern_lock);
  323. #endif
  324.     pthread_mutex_unlock(&THR_LOCK_myisam);
  325.     break;
  326.   case HA_EXTRA_FLUSH:
  327.     if (!share->temporary)
  328.       flush_key_blocks(share->key_cache, share->kfile, FLUSH_KEEP);
  329. #ifdef HAVE_PWRITE
  330.     _mi_decrement_open_count(info);
  331. #endif
  332.     if (share->not_flushed)
  333.     {
  334.       share->not_flushed=0;
  335.       if (my_sync(share->kfile, MYF(0)))
  336. error= my_errno;
  337.       if (my_sync(info->dfile, MYF(0)))
  338. error= my_errno;
  339.       if (error)
  340.       {
  341. share->changed=1;
  342. mi_mark_crashed(info); /* Fatal error found */
  343.       }
  344.     }
  345.     if (share->base.blobs)
  346.       mi_alloc_rec_buff(info, -1, &info->rec_buff);
  347.     break;
  348.   case HA_EXTRA_NORMAL: /* Theese isn't in use */
  349.     info->quick_mode=0;
  350.     break;
  351.   case HA_EXTRA_QUICK:
  352.     info->quick_mode=1;
  353.     break;
  354.   case HA_EXTRA_NO_ROWS:
  355.     if (!share->state.header.uniques)
  356.       info->opt_flag|= OPT_NO_ROWS;
  357.     break;
  358.   case HA_EXTRA_PRELOAD_BUFFER_SIZE:
  359.     info->preload_buff_size= *((ulong *) extra_arg); 
  360.     break;
  361.   case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
  362.   case HA_EXTRA_CHANGE_KEY_TO_DUP:
  363.     mi_extra_keyflag(info, function);
  364.     break;
  365.   case HA_EXTRA_KEY_CACHE:
  366.   case HA_EXTRA_NO_KEY_CACHE:
  367.   default:
  368.     break;
  369.   }
  370.   {
  371.     char tmp[1];
  372.     tmp[0]=function;
  373.     myisam_log_command(MI_LOG_EXTRA,info,(byte*) tmp,1,error);
  374.   }
  375.   DBUG_RETURN(error);
  376. } /* mi_extra */
  379. /*
  380.     Start/Stop Inserting Duplicates Into a Table, WL#1648.
  381.  */
  382. static void mi_extra_keyflag(MI_INFO *info, enum ha_extra_function function)
  383. {
  384.   uint  idx;
  386.   for (idx= 0; idx< info->s->base.keys; idx++)
  387.   {
  388.     switch (function) {
  389.     case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
  390.       info->s->keyinfo[idx].flag|= HA_NOSAME;
  391.       break;
  392.     case HA_EXTRA_CHANGE_KEY_TO_DUP:
  393.       info->s->keyinfo[idx].flag&= ~(HA_NOSAME);
  394.       break;
  395.     default:
  396.       break;
  397.     }
  398.   }
  399. }