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

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

MySQL数据库

开发平台：

Visual C++

myisamdef.h：源码内容
  1. /* Copyright (C) 2000,2004 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. /* This file is included by all internal myisam files */
  19. #include "myisam.h" /* Structs & some defines */
  20. #include "myisampack.h" /* packing of keys */
  21. #include <my_tree.h>
  22. #ifdef THREAD
  23. #include <my_pthread.h>
  24. #include <thr_lock.h>
  25. #else
  26. #include <my_no_pthread.h>
  27. #endif
  29. #if defined(my_write) && !defined(MAP_TO_USE_RAID)
  30. #undef my_write /* undef map from my_nosys; We need test-if-disk full */
  31. #endif
  33. typedef struct st_mi_status_info
  34. {
  35.   ha_rows records; /* Rows in table */
  36.   ha_rows del; /* Removed rows */
  37.   my_off_t empty; /* lost space in datafile */
  38.   my_off_t key_empty; /* lost space in indexfile */
  39.   my_off_t key_file_length;
  40.   my_off_t data_file_length;
  41. } MI_STATUS_INFO;
  43. typedef struct st_mi_state_info
  44. {
  45.   struct { /* Fileheader */
  46.     uchar file_version[4];
  47.     uchar options[2];
  48.     uchar header_length[2];
  49.     uchar state_info_length[2];
  50.     uchar base_info_length[2];
  51.     uchar base_pos[2];
  52.     uchar key_parts[2]; /* Key parts */
  53.     uchar unique_key_parts[2]; /* Key parts + unique parts */
  54.     uchar keys; /* number of keys in file */
  55.     uchar uniques; /* number of UNIQUE definitions */
  56.     uchar language; /* Language for indexes */
  57.     uchar max_block_size; /* max keyblock size */
  58.     uchar fulltext_keys;
  59.     uchar not_used;                     /* To align to 8 */
  60.   } header;
  62.   MI_STATUS_INFO state;
  63.   ha_rows split; /* number of split blocks */
  64.   my_off_t dellink; /* Link to next removed block */
  65.   ulonglong auto_increment;
  66.   ulong process; /* process that updated table last */
  67.   ulong unique; /* Unique number for this process */
  68.   ulong update_count; /* Updated for each write lock */
  69.   ulong status;
  70.   ulong *rec_per_key_part;
  71.   my_off_t *key_root; /* Start of key trees */
  72.   my_off_t *key_del; /* delete links for trees */
  73.   my_off_t rec_per_key_rows; /* Rows when calculating rec_per_key */
  75.   ulong sec_index_changed; /* Updated when new sec_index */
  76.   ulong sec_index_used; /* which extra index are in use */
  77.   ulonglong key_map; /* Which keys are in use */
  78.   ha_checksum checksum;
  79.   ulong version; /* timestamp of create */
  80.   time_t create_time; /* Time when created database */
  81.   time_t recover_time; /* Time for last recover */
  82.   time_t check_time; /* Time for last check */
  83.   uint sortkey; /* sorted by this key  (not used) */
  84.   uint open_count;
  85.   uint8 changed; /* Changed since myisamchk */
  87.   /* the following isn't saved on disk */
  88.   uint state_diff_length; /* Should be 0 */
  89.   uint state_length; /* Length of state header in file */
  90.   ulong *key_info;
  91. } MI_STATE_INFO;
  93. #define MI_STATE_INFO_SIZE (24+14*8+7*4+2*2+8)
  94. #define MI_STATE_KEY_SIZE 8
  95. #define MI_STATE_KEYBLOCK_SIZE  8
  96. #define MI_STATE_KEYSEG_SIZE 4
  97. #define MI_STATE_EXTRA_SIZE ((MI_MAX_KEY+MI_MAX_KEY_BLOCK_SIZE)*MI_STATE_KEY_SIZE + MI_MAX_KEY*MI_MAX_KEY_SEG*MI_STATE_KEYSEG_SIZE)
  98. #define MI_KEYDEF_SIZE (2+ 5*2)
  99. #define MI_UNIQUEDEF_SIZE (2+1+1)
  100. #define HA_KEYSEG_SIZE (6+ 2*2 + 4*2)
  101. #define MI_COLUMNDEF_SIZE (2*3+1)
  102. #define MI_BASE_INFO_SIZE (5*8 + 8*4 + 4 + 4*2 + 16)
  103. #define MI_INDEX_BLOCK_MARGIN 16 /* Safety margin for .MYI tables */
  105. typedef struct st_mi_base_info
  106. {
  107.   my_off_t keystart; /* Start of keys */
  108.   my_off_t max_data_file_length;
  109.   my_off_t max_key_file_length;
  110.   my_off_t margin_key_file_length;
  111.   ha_rows records,reloc; /* Create information */
  112.   ulong mean_row_length; /* Create information */
  113.   ulong reclength; /* length of unpacked record */
  114.   ulong pack_reclength; /* Length of full packed rec. */
  115.   ulong min_pack_length;
  116.   ulong max_pack_length; /* Max possibly length of packed rec.*/
  117.   ulong min_block_length;
  118.   ulong fields, /* fields in table */
  119.        pack_fields; /* packed fields in table */
  120.   uint rec_reflength; /* = 2-8 */
  121.   uint key_reflength; /* = 2-8 */
  122.   uint keys; /* same as in state.header */
  123.   uint auto_key; /* Which key-1 is a auto key */
  124.   uint blobs; /* Number of blobs */
  125.   uint pack_bits; /* Length of packed bits */
  126.   uint max_key_block_length; /* Max block length */
  127.   uint max_key_length; /* Max key length */
  128.   /* Extra allocation when using dynamic record format */
  129.   uint extra_alloc_bytes;
  130.   uint extra_alloc_procent;
  131.   /* Info about raid */
  132.   uint raid_type,raid_chunks;
  133.   ulong raid_chunksize;
  134.   /* The following are from the header */
  135.   uint key_parts,all_key_parts;
  136. } MI_BASE_INFO;
  139. /* Structs used intern in database */
  141. typedef struct st_mi_blob /* Info of record */
  142. {
  143.   ulong offset; /* Offset to blob in record */
  144.   uint pack_length; /* Type of packed length */
  145.   ulong length; /* Calc:ed for each record */
  146. } MI_BLOB;
  149. typedef struct st_mi_isam_pack {
  150.   ulong header_length;
  151.   uint ref_length;
  152.   uchar version;
  153. } MI_PACK;
  156. typedef struct st_mi_isam_share { /* Shared between opens */
  157.   MI_STATE_INFO state;
  158.   MI_BASE_INFO base;
  159.   MI_KEYDEF  ft2_keyinfo; /* Second-level ft-key definition */
  160.   MI_KEYDEF  *keyinfo; /* Key definitions */
  161.   MI_UNIQUEDEF *uniqueinfo; /* unique definitions */
  162.   HA_KEYSEG *keyparts; /* key part info */
  163.   MI_COLUMNDEF *rec; /* Pointer to field information */
  164.   MI_PACK    pack; /* Data about packed records */
  165.   MI_BLOB    *blobs; /* Pointer to blobs */
  166.   char  *unique_file_name; /* realpath() of index file */
  167.   char  *data_file_name, /* Resolved path names from symlinks */
  168.         *index_file_name;
  169.   byte *file_map; /* mem-map of file if possible */
  170.   KEY_CACHE *key_cache; /* ref to the current key cache */
  171.   MI_DECODE_TREE *decode_trees;
  172.   uint16 *decode_tables;
  173.   int (*read_record)(struct st_myisam_info*, my_off_t, byte*);
  174.   int (*write_record)(struct st_myisam_info*, const byte*);
  175.   int (*update_record)(struct st_myisam_info*, my_off_t, const byte*);
  176.   int (*delete_record)(struct st_myisam_info*);
  177.   int (*read_rnd)(struct st_myisam_info*, byte*, my_off_t, my_bool);
  178.   int (*compare_record)(struct st_myisam_info*, const byte *);
  179.   ha_checksum (*calc_checksum)(struct st_myisam_info*, const byte *);
  180.   int (*compare_unique)(struct st_myisam_info*, MI_UNIQUEDEF *,
  181. const byte *record, my_off_t pos);
  182.   invalidator_by_filename invalidator;  /* query cache invalidator */
  183.   ulong this_process; /* processid */
  184.   ulong last_process; /* For table-change-check */
  185.   ulong last_version; /* Version on start */
  186.   ulong options; /* Options used */
  187.   ulong min_pack_length; /* Theese are used by packed data */
  188.   ulong max_pack_length;
  189.   ulong state_diff_length;
  190.   uint rec_reflength; /* rec_reflength in use now */
  191.   uint  unique_name_length;
  192.   File kfile; /* Shared keyfile */
  193.   File data_file; /* Shared data file */
  194.   int mode; /* mode of file on open */
  195.   uint reopen; /* How many times reopened */
  196.   uint w_locks,r_locks,tot_locks; /* Number of read/write locks */
  197.   uint blocksize; /* blocksize of keyfile */
  198.   myf write_flag;
  199.   enum data_file_type data_file_type;
  200.   my_bool  changed, /* If changed since lock */
  201.     global_changed, /* If changed since open */
  202.     not_flushed,
  203.     temporary,delay_key_write,
  204.     concurrent_insert;
  205. #ifdef THREAD
  206.   THR_LOCK lock;
  207.   pthread_mutex_t intern_lock; /* Locking for use with _locking */
  208.   rw_lock_t *key_root_lock;
  209. #endif
  210. } MYISAM_SHARE;
  213. typedef uint mi_bit_type;
  215. typedef struct st_mi_bit_buff { /* Used for packing of record */
  216.   mi_bit_type current_byte;
  217.   uint bits;
  218.   uchar *pos,*end,*blob_pos,*blob_end;
  219.   uint error;
  220. } MI_BIT_BUFF;
  222. struct st_myisam_info {
  223.   MYISAM_SHARE *s; /* Shared between open:s */
  224.   MI_STATUS_INFO *state,save_state;
  225.   MI_BLOB     *blobs; /* Pointer to blobs */
  226.   MI_BIT_BUFF  bit_buff;
  227.   /* accumulate indexfile changes between write's */
  228.   TREE         *bulk_insert;
  229.   DYNAMIC_ARRAY *ft1_to_ft2;            /* used only in ft1->ft2 conversion */
  230.   char *filename; /* parameter to open filename */
  231.   uchar *buff, /* Temp area for key */
  232. *lastkey,*lastkey2; /* Last used search key */
  233.   uchar *first_mbr_key; /* Searhed spatial key */ 
  234.   byte *rec_buff; /* Tempbuff for recordpack */
  235.   uchar *int_keypos, /* Save position for next/previous */
  236.         *int_maxpos; /*  -""-  */
  237.   uint  int_nod_flag; /*  -""-  */
  238.   uint32 int_keytree_version; /*  -""-  */
  239.   int (*read_record)(struct st_myisam_info*, my_off_t, byte*);
  240.   invalidator_by_filename invalidator;  /* query cache invalidator */
  241.   ulong this_unique; /* uniq filenumber or thread */
  242.   ulong last_unique; /* last unique number */
  243.   ulong this_loop; /* counter for this open */
  244.   ulong last_loop; /* last used counter */
  245.   my_off_t lastpos, /* Last record position */
  246. nextpos; /* Position to next record */
  247.   my_off_t save_lastpos;
  248.   my_off_t pos; /* Intern variable */
  249.   my_off_t last_keypage; /* Last key page read */
  250.   my_off_t last_search_keypage; /* Last keypage when searching */
  251.   my_off_t dupp_key_pos;
  252.   ha_checksum checksum;
  253.   /* QQ: the folloing two xxx_length fields should be removed,
  254.      as they are not compatible with parallel repair */
  255.   ulong packed_length,blob_length; /* Length of found, packed record */
  256.   int  dfile; /* The datafile */
  257.   uint opt_flag; /* Optim. for space/speed */
  258.   uint update; /* If file changed since open */
  259.   int lastinx; /* Last used index */
  260.   uint lastkey_length; /* Length of key in lastkey */
  261.   uint last_rkey_length; /* Last length in mi_rkey() */
  262.   enum ha_rkey_function last_key_func;  /* CONTAIN, OVERLAP, etc */
  263.   uint  save_lastkey_length;
  264.   uint  pack_key_length;                /* For MYISAMMRG */
  265.   int errkey; /* Got last error on this key */
  266.   int   lock_type; /* How database was locked */
  267.   int   tmp_lock_type; /* When locked by readinfo */
  268.   uint data_changed; /* Somebody has changed data */
  269.   uint save_update; /* When using KEY_READ */
  270.   int save_lastinx;
  271.   LIST open_list;
  272.   IO_CACHE rec_cache; /* When cacheing records */
  273.   uint  preload_buff_size;              /* When preloading indexes */
  274.   myf lock_wait; /* is 0 or MY_DONT_WAIT */
  275.   my_bool was_locked; /* Was locked in panic */
  276.   my_bool quick_mode;
  277.   my_bool page_changed; /* If info->buff can't be used for rnext */
  278.   my_bool buff_used; /* If info->buff has to be reread for rnext */
  279.   my_bool once_flags;           /* For MYISAMMRG */
  280. #ifdef THREAD
  281.   THR_LOCK_DATA lock;
  282. #endif
  283.   uchar  *rtree_recursion_state; /* For RTREE */
  284.   int     rtree_recursion_depth;
  285. };
  287. typedef struct st_buffpek {
  288.   my_off_t file_pos;                    /* Where we are in the sort file */
  289.   uchar *base,*key;                     /* Key pointers */
  290.   ha_rows count;                        /* Number of rows in table */
  291.   ulong mem_count;                      /* numbers of keys in memory */
  292.   ulong max_keys;                       /* Max keys in buffert */
  293. } BUFFPEK;
  295. typedef struct st_mi_sort_param
  296. {
  297.   pthread_t  thr;
  298.   IO_CACHE read_cache, tempfile, tempfile_for_exceptions;
  299.   DYNAMIC_ARRAY buffpek;
  300.   
  301.   /* 
  302.     The next two are used to collect statistics, see update_key_parts for
  303.     description.
  304.   */
  305.   ulonglong unique[MI_MAX_KEY_SEG+1];
  306.   ulonglong notnull[MI_MAX_KEY_SEG+1];
  308.   my_off_t pos,max_pos,filepos,start_recpos;
  309.   uint key, key_length,real_key_length,sortbuff_size;
  310.   uint maxbuffers, keys, find_length, sort_keys_length;
  311.   my_bool fix_datafile, master;
  312.   MI_KEYDEF *keyinfo;
  313.   HA_KEYSEG *seg;
  314.   SORT_INFO *sort_info;
  315.   uchar **sort_keys;
  316.   byte *rec_buff;
  317.   void *wordlist, *wordptr;
  318.   char *record;
  319.   MY_TMPDIR *tmpdir;
  320.   int (*key_cmp)(struct st_mi_sort_param *, const void *, const void *);
  321.   int (*key_read)(struct st_mi_sort_param *,void *);
  322.   int (*key_write)(struct st_mi_sort_param *, const void *);
  323.   void (*lock_in_memory)(MI_CHECK *);
  324.   NEAR int (*write_keys)(struct st_mi_sort_param *, register uchar **,
  325.                      uint , struct st_buffpek *, IO_CACHE *);
  326.   NEAR uint (*read_to_buffer)(IO_CACHE *,struct st_buffpek *, uint);
  327.   NEAR int (*write_key)(struct st_mi_sort_param *, IO_CACHE *,char *,
  328.                        uint, uint);
  329. } MI_SORT_PARAM;
  330. /* Some defines used by isam-funktions */
  332. #define USE_WHOLE_KEY MI_MAX_KEY_BUFF*2 /* Use whole key in _mi_search() */
  333. #define F_EXTRA_LCK -1
  335. /* bits in opt_flag */
  336. #define MEMMAP_USED 32
  337. #define REMEMBER_OLD_POS 64
  339. #define WRITEINFO_UPDATE_KEYFILE 1
  340. #define WRITEINFO_NO_UNLOCK 2
  342.         /* once_flags */
  343. #define USE_PACKED_KEYS         1
  344. #define RRND_PRESERVE_LASTINX   2
  346. /* bits in state.changed */
  348. #define STATE_CHANGED 1
  349. #define STATE_CRASHED 2
  350. #define STATE_CRASHED_ON_REPAIR 4
  351. #define STATE_NOT_ANALYZED 8
  352. #define STATE_NOT_OPTIMIZED_KEYS 16
  353. #define STATE_NOT_SORTED_PAGES 32
  355. /* options to mi_read_cache */
  357. #define READING_NEXT 1
  358. #define READING_HEADER 2
  360. #define mi_getint(x) ((uint) mi_uint2korr(x) & 32767)
  361. #define mi_putint(x,y,nod) { uint16 boh=(nod ? (uint16) 32768 : 0) + (uint16) (y);
  362.   mi_int2store(x,boh); }
  363. #define mi_test_if_nod(x) (x[0] & 128 ? info->s->base.key_reflength : 0)
  364. #define mi_mark_crashed(x) (x)->s->state.changed|=STATE_CRASHED
  365. #define mi_mark_crashed_on_repair(x) { (x)->s->state.changed|=STATE_CRASHED|STATE_CRASHED_ON_REPAIR ; (x)->update|= HA_STATE_CHANGED; }
  366. #define mi_is_crashed(x) ((x)->s->state.changed & STATE_CRASHED)
  367. #define mi_is_crashed_on_repair(x) ((x)->s->state.changed & STATE_CRASHED_ON_REPAIR)
  369. /* Functions to store length of space packed keys, VARCHAR or BLOB keys */
  371. #define store_key_length_inc(key,length) 
  372. { if ((length) < 255) 
  373.   { *(key)++=(length); } 
  374.   else 
  375.   { *(key)=255; mi_int2store((key)+1,(length)); (key)+=3; } 
  376. }
  378. #define store_key_length(key,length) 
  379. { if ((length) < 255) 
  380.   { *(key)=(length); } 
  381.   else 
  382.   { *(key)=255; mi_int2store((key)+1,(length)); } 
  383. }
  385. #define get_key_full_length(length,key) 
  386. { if ((uchar) *(key) != 255) 
  387.     length= ((uint) (uchar) *((key)++))+1; 
  388.   else 
  389.   { length=mi_uint2korr((key)+1)+3; (key)+=3; } 
  390. }
  392. #define get_key_full_length_rdonly(length,key) 
  393. { if ((uchar) *(key) != 255) 
  394.     length= ((uint) (uchar) *((key)))+1; 
  395.   else 
  396.   { length=mi_uint2korr((key)+1)+3; } 
  397. }
  399. #define get_pack_length(length) ((length) >= 255 ? 3 : 1)
  401. #define MI_MIN_BLOCK_LENGTH 20 /* Because of delete-link */
  402. #define MI_EXTEND_BLOCK_LENGTH 20 /* Don't use to small record-blocks */
  403. #define MI_SPLIT_LENGTH ((MI_EXTEND_BLOCK_LENGTH+4)*2)
  404. #define MI_MAX_DYN_BLOCK_HEADER 20 /* Max prefix of record-block */
  405. #define MI_BLOCK_INFO_HEADER_LENGTH 20
  406. #define MI_DYN_DELETE_BLOCK_HEADER 20 /* length of delete-block-header */
  407. #define MI_DYN_MAX_BLOCK_LENGTH ((1L << 24)-4L)
  408. #define MI_DYN_MAX_ROW_LENGTH (MI_DYN_MAX_BLOCK_LENGTH - MI_SPLIT_LENGTH)
  409. #define MI_DYN_ALIGN_SIZE 4 /* Align blocks on this */
  410. #define MI_MAX_DYN_HEADER_BYTE 13 /* max header byte for dynamic rows */
  411. #define MI_MAX_BLOCK_LENGTH ((((ulong) 1 << 24)-1) & (~ (ulong) (MI_DYN_ALIGN_SIZE-1)))
  412. #define MI_REC_BUFF_OFFSET      ALIGN_SIZE(MI_DYN_DELETE_BLOCK_HEADER+sizeof(uint32))
  414. #define MEMMAP_EXTRA_MARGIN 7 /* Write this as a suffix for file */
  416. #define PACK_TYPE_SELECTED 1 /* Bits in field->pack_type */
  417. #define PACK_TYPE_SPACE_FIELDS 2
  418. #define PACK_TYPE_ZERO_FILL 4
  419. #define MI_FOUND_WRONG_KEY 32738 /* Impossible value from ha_key_cmp */
  421. #define MI_MAX_KEY_BLOCK_SIZE (MI_MAX_KEY_BLOCK_LENGTH/MI_MIN_KEY_BLOCK_LENGTH)
  422. #define MI_BLOCK_SIZE(key_length,data_pointer,key_pointer) (((((key_length)+(data_pointer)+(key_pointer))*4+(key_pointer)+2)/myisam_block_size+1)*myisam_block_size)
  423. #define MI_MAX_KEYPTR_SIZE 5        /* For calculating block lengths */
  424. #define MI_MIN_KEYBLOCK_LENGTH 50         /* When to split delete blocks */
  426. #define MI_MIN_SIZE_BULK_INSERT_TREE 16384             /* this is per key */
  427. #define MI_MIN_ROWS_TO_USE_BULK_INSERT 100
  428. #define MI_MIN_ROWS_TO_DISABLE_INDEXES 100
  429. #define MI_MIN_ROWS_TO_USE_WRITE_CACHE 10
  431. /* The UNIQUE check is done with a hashed long key */
  433. #define MI_UNIQUE_HASH_TYPE HA_KEYTYPE_ULONG_INT
  434. #define mi_unique_store(A,B)    mi_int4store((A),(B))
  436. #ifdef THREAD
  437. extern pthread_mutex_t THR_LOCK_myisam;
  438. #endif
  439. #if !defined(THREAD) || defined(DONT_USE_RW_LOCKS)
  440. #define rw_wrlock(A) {}
  441. #define rw_rdlock(A) {}
  442. #define rw_unlock(A) {}
  443. #endif
  445. /* Some extern variables */
  447. extern LIST *myisam_open_list;
  448. extern uchar NEAR myisam_file_magic[],NEAR myisam_pack_file_magic[];
  449. extern uint NEAR myisam_read_vec[],NEAR myisam_readnext_vec[];
  450. extern uint myisam_quick_table_bits;
  451. extern File myisam_log_file;
  452. extern ulong myisam_pid;
  454. /* This is used by _mi_calc_xxx_key_length och _mi_store_key */
  456. typedef struct st_mi_s_param
  457. {
  458.   uint ref_length,key_length,
  459. n_ref_length,
  460. n_length,
  461. totlength,
  462. part_of_prev_key,prev_length,pack_marker;
  463.   uchar *key, *prev_key,*next_key_pos;
  464.   bool store_not_null;
  465. } MI_KEY_PARAM;
  467. /* Prototypes for intern functions */
  469. extern int _mi_read_dynamic_record(MI_INFO *info,my_off_t filepos,byte *buf);
  470. extern int _mi_write_dynamic_record(MI_INFO*, const byte*);
  471. extern int _mi_update_dynamic_record(MI_INFO*, my_off_t, const byte*);
  472. extern int _mi_delete_dynamic_record(MI_INFO *info);
  473. extern int _mi_cmp_dynamic_record(MI_INFO *info,const byte *record);
  474. extern int _mi_read_rnd_dynamic_record(MI_INFO *, byte *,my_off_t, my_bool);
  475. extern int _mi_write_blob_record(MI_INFO*, const byte*);
  476. extern int _mi_update_blob_record(MI_INFO*, my_off_t, const byte*);
  477. extern int _mi_read_static_record(MI_INFO *info, my_off_t filepos,byte *buf);
  478. extern int _mi_write_static_record(MI_INFO*, const byte*);
  479. extern int _mi_update_static_record(MI_INFO*, my_off_t, const byte*);
  480. extern int _mi_delete_static_record(MI_INFO *info);
  481. extern int _mi_cmp_static_record(MI_INFO *info,const byte *record);
  482. extern int _mi_read_rnd_static_record(MI_INFO*, byte *,my_off_t, my_bool);
  483. extern int _mi_ck_write(MI_INFO *info,uint keynr,uchar *key,uint length);
  484. extern int _mi_ck_real_write_btree(MI_INFO *info, MI_KEYDEF *keyinfo,
  485.                                    uchar *key, uint key_length,
  486.                                    my_off_t *root, uint comp_flag);
  487. extern int _mi_enlarge_root(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key, my_off_t *root);
  488. extern int _mi_insert(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  489.       uchar *anc_buff,uchar *key_pos,uchar *key_buff,
  490.       uchar *father_buff, uchar *father_keypos,
  491.       my_off_t father_page, my_bool insert_last);
  492. extern int _mi_split_page(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  493.   uchar *buff,uchar *key_buff, my_bool insert_last);
  494. extern uchar *_mi_find_half_pos(uint nod_flag,MI_KEYDEF *keyinfo,uchar *page,
  495. uchar *key,uint *return_key_length,
  496. uchar **after_key);
  497. extern int _mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  498.       uchar *key_pos, uchar *org_key,
  499.       uchar *key_buff,
  500.       uchar *key, MI_KEY_PARAM *s_temp);
  501. extern int _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  502.    uchar *key_pos, uchar *org_key,
  503.    uchar *key_buff,
  504.    uchar *key, MI_KEY_PARAM *s_temp);
  505. extern int _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  506. uchar *key_pos, uchar *org_key,
  507. uchar *prev_key,
  508. uchar *key, MI_KEY_PARAM *s_temp);
  509. extern int _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  510. uchar *key_pos,uchar *org_key,
  511. uchar *prev_key,
  512. uchar *key, MI_KEY_PARAM *s_temp);
  513. void _mi_store_static_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  514.    MI_KEY_PARAM *s_temp);
  515. void _mi_store_var_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  516.      MI_KEY_PARAM *s_temp);
  517. #ifdef NOT_USED
  518. void _mi_store_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  519.  MI_KEY_PARAM *s_temp);
  520. #endif
  521. void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  522.     MI_KEY_PARAM *s_temp);
  524. extern int _mi_ck_delete(MI_INFO *info,uint keynr,uchar *key,uint key_length);
  525. extern int _mi_readinfo(MI_INFO *info,int lock_flag,int check_keybuffer);
  526. extern int _mi_writeinfo(MI_INFO *info,uint options);
  527. extern int _mi_test_if_changed(MI_INFO *info);
  528. extern int _mi_mark_file_changed(MI_INFO *info);
  529. extern int _mi_decrement_open_count(MI_INFO *info);
  530. extern int _mi_check_index(MI_INFO *info,int inx);
  531. extern int _mi_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,uint key_len,
  532.       uint nextflag,my_off_t pos);
  533. extern int _mi_bin_search(struct st_myisam_info *info,MI_KEYDEF *keyinfo,
  534.   uchar *page,uchar *key,uint key_len,uint comp_flag,
  535.   uchar * *ret_pos,uchar *buff, my_bool *was_last_key);
  536. extern int _mi_seq_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *page,
  537.   uchar *key,uint key_len,uint comp_flag,
  538.   uchar **ret_pos,uchar *buff, my_bool *was_last_key);
  539. extern int _mi_prefix_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *page,
  540.   uchar *key,uint key_len,uint comp_flag,
  541.   uchar **ret_pos,uchar *buff, my_bool *was_last_key);
  542. extern my_off_t _mi_kpos(uint nod_flag,uchar *after_key);
  543. extern void _mi_kpointer(MI_INFO *info,uchar *buff,my_off_t pos);
  544. extern my_off_t _mi_dpos(MI_INFO *info, uint nod_flag,uchar *after_key);
  545. extern my_off_t _mi_rec_pos(MYISAM_SHARE *info, uchar *ptr);
  546. extern void _mi_dpointer(MI_INFO *info, uchar *buff,my_off_t pos);
  547. extern int ha_key_cmp(HA_KEYSEG *keyseg, uchar *a,uchar *b,
  548.        uint key_length,uint nextflag,uint *diff_length);
  549. extern uint _mi_get_static_key(MI_KEYDEF *keyinfo,uint nod_flag,uchar * *page,
  550.        uchar *key);
  551. extern uint _mi_get_pack_key(MI_KEYDEF *keyinfo,uint nod_flag,uchar * *page,
  552.      uchar *key);
  553. extern uint _mi_get_binary_pack_key(MI_KEYDEF *keyinfo, uint nod_flag,
  554.     uchar **page_pos, uchar *key);
  555. extern uchar *_mi_get_last_key(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *keypos,
  556.        uchar *lastkey,uchar *endpos,
  557.        uint *return_key_length);
  558. extern uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
  559.   uchar *key, uchar *keypos, uint *return_key_length);
  560. extern uint _mi_keylength(MI_KEYDEF *keyinfo,uchar *key);
  561. extern uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
  562.        HA_KEYSEG *end);
  563. extern uchar *_mi_move_key(MI_KEYDEF *keyinfo,uchar *to,uchar *from);
  564. extern int _mi_search_next(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  565.    uint key_length,uint nextflag,my_off_t pos);
  566. extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
  567. extern int _mi_search_last(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
  568. extern uchar *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
  569. int level,uchar *buff,int return_buffer);
  570. extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
  571.      int level, uchar *buff);
  572. extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos,
  573.                       int level);
  574. extern my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo,int level);
  575. extern uint _mi_make_key(MI_INFO *info,uint keynr,uchar *key,
  576.  const byte *record,my_off_t filepos);
  577. extern uint _mi_pack_key(MI_INFO *info,uint keynr,uchar *key,uchar *old,
  578.  uint key_length, HA_KEYSEG **last_used_keyseg);
  579. extern int _mi_read_key_record(MI_INFO *info,my_off_t filepos,byte *buf);
  580. extern int _mi_read_cache(IO_CACHE *info,byte *buff,my_off_t pos,
  581.   uint length,int re_read_if_possibly);
  582. extern void update_auto_increment(MI_INFO *info,const byte *record);
  584. extern byte *mi_alloc_rec_buff(MI_INFO *,ulong, byte**);
  585. #define mi_get_rec_buff_ptr(info,buf)                              
  586.         ((((info)->s->options & HA_OPTION_PACK_RECORD) && (buf)) ? 
  587.         (buf) - MI_REC_BUFF_OFFSET : (buf))
  588. #define mi_get_rec_buff_len(info,buf)                              
  589.         (*((uint32 *)(mi_get_rec_buff_ptr(info,buf))))
  591. extern ulong _mi_rec_unpack(MI_INFO *info,byte *to,byte *from,
  592.     ulong reclength);
  593. extern my_bool _mi_rec_check(MI_INFO *info,const char *record, byte *packpos,
  594.                              ulong packed_length, my_bool with_checkum);
  595. extern int _mi_write_part_record(MI_INFO *info,my_off_t filepos,ulong length,
  596.  my_off_t next_filepos,byte **record,
  597.  ulong *reclength,int *flag);
  598. extern void _mi_print_key(FILE *stream,HA_KEYSEG *keyseg,const uchar *key,
  599.   uint length);
  600. extern my_bool _mi_read_pack_info(MI_INFO *info,pbool fix_keys);
  601. extern int _mi_read_pack_record(MI_INFO *info,my_off_t filepos,byte *buf);
  602. extern int _mi_read_rnd_pack_record(MI_INFO*, byte *,my_off_t, my_bool);
  603. extern int _mi_pack_rec_unpack(MI_INFO *info,byte *to,byte *from,
  604.        ulong reclength);
  605. extern ulonglong mi_safe_mul(ulonglong a,ulonglong b);
  606. extern int _mi_ft_update(MI_INFO *info, uint keynr, byte *keybuf,
  607.  const byte *oldrec, const byte *newrec, my_off_t pos);
  609. struct st_sort_info;
  612. typedef struct st_mi_block_info { /* Parameter to _mi_get_block_info */
  613.   uchar header[MI_BLOCK_INFO_HEADER_LENGTH];
  614.   ulong rec_len;
  615.   ulong data_len;
  616.   ulong block_len;
  617.   ulong blob_len;
  618.   my_off_t filepos;
  619.   my_off_t next_filepos;
  620.   my_off_t prev_filepos;
  621.   uint second_read;
  622.   uint offset;
  623. } MI_BLOCK_INFO;
  625. /* bits in return from _mi_get_block_info */
  627. #define BLOCK_FIRST 1
  628. #define BLOCK_LAST 2
  629. #define BLOCK_DELETED 4
  630. #define BLOCK_ERROR 8 /* Wrong data */
  631. #define BLOCK_SYNC_ERROR 16 /* Right data at wrong place */
  632. #define BLOCK_FATAL_ERROR 32 /* hardware-error */
  634. #define NEED_MEM ((uint) 10*4*(IO_SIZE+32)+32) /* Nead for recursion */
  635. #define MAXERR 20
  636. #define BUFFERS_WHEN_SORTING 16 /* Alloc for sort-key-tree */
  637. #define WRITE_COUNT MY_HOW_OFTEN_TO_WRITE
  638. #define INDEX_TMP_EXT ".TMM"
  639. #define DATA_TMP_EXT ".TMD"
  641. #define UPDATE_TIME 1
  642. #define UPDATE_STAT 2
  643. #define UPDATE_SORT 4
  644. #define UPDATE_AUTO_INC 8
  645. #define UPDATE_OPEN_COUNT 16
  647. #define USE_BUFFER_INIT (((1024L*512L-MALLOC_OVERHEAD)/IO_SIZE)*IO_SIZE)
  648. #define READ_BUFFER_INIT (1024L*256L-MALLOC_OVERHEAD)
  649. #define SORT_BUFFER_INIT (2048L*1024L-MALLOC_OVERHEAD)
  650. #define MIN_SORT_BUFFER (4096-MALLOC_OVERHEAD)
  652. enum myisam_log_commands {
  653.   MI_LOG_OPEN,MI_LOG_WRITE,MI_LOG_UPDATE,MI_LOG_DELETE,MI_LOG_CLOSE,MI_LOG_EXTRA,MI_LOG_LOCK,MI_LOG_DELETE_ALL
  654. };
  656. #define myisam_log(a,b,c,d) if (myisam_log_file >= 0) _myisam_log(a,b,c,d)
  657. #define myisam_log_command(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_command(a,b,c,d,e)
  658. #define myisam_log_record(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_record(a,b,c,d,e)
  660. #define fast_mi_writeinfo(INFO) if (!(INFO)->s->tot_locks) (void) _mi_writeinfo((INFO),0)
  661. #define fast_mi_readinfo(INFO) ((INFO)->lock_type == F_UNLCK) && _mi_readinfo((INFO),F_RDLCK,1)
  663. #ifdef __cplusplus
  664. extern "C" {
  665. #endif
  667. extern uint _mi_get_block_info(MI_BLOCK_INFO *,File, my_off_t);
  668. extern uint _mi_rec_pack(MI_INFO *info,byte *to,const byte *from);
  669. extern uint _mi_pack_get_block_info(MI_INFO *, MI_BLOCK_INFO *, File, my_off_t);
  670. extern void _my_store_blob_length(byte *pos,uint pack_length,uint length);
  671. extern void _myisam_log(enum myisam_log_commands command,MI_INFO *info,
  672.        const byte *buffert,uint length);
  673. extern void _myisam_log_command(enum myisam_log_commands command,
  674.        MI_INFO *info, const byte *buffert,
  675.        uint length, int result);
  676. extern void _myisam_log_record(enum myisam_log_commands command,MI_INFO *info,
  677.       const byte *record,my_off_t filepos,
  678.       int result);
  679. extern my_bool _mi_memmap_file(MI_INFO *info);
  680. extern void _mi_unmap_file(MI_INFO *info);
  681. extern uint save_pack_length(uint version, byte *block_buff, ulong length);
  682. extern uint read_pack_length(uint version, const uchar *buf, ulong *length);
  683. extern uint calc_pack_length(uint version, ulong length);
  685. uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite);
  686. char *mi_state_info_read(char *ptr, MI_STATE_INFO *state);
  687. uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead);
  688. uint mi_base_info_write(File file, MI_BASE_INFO *base);
  689. char *my_n_base_info_read(char *ptr, MI_BASE_INFO *base);
  690. int mi_keyseg_write(File file, const HA_KEYSEG *keyseg);
  691. char *mi_keyseg_read(char *ptr, HA_KEYSEG *keyseg);
  692. uint mi_keydef_write(File file, MI_KEYDEF *keydef);
  693. char *mi_keydef_read(char *ptr, MI_KEYDEF *keydef);
  694. uint mi_uniquedef_write(File file, MI_UNIQUEDEF *keydef);
  695. char *mi_uniquedef_read(char *ptr, MI_UNIQUEDEF *keydef);
  696. uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo);
  697. char *mi_recinfo_read(char *ptr, MI_COLUMNDEF *recinfo);
  698. extern int mi_disable_indexes(MI_INFO *info);
  699. extern int mi_enable_indexes(MI_INFO *info);
  700. extern int mi_indexes_are_disabled(MI_INFO *info);
  701. ulong _my_calc_total_blob_length(MI_INFO *info, const byte *record);
  702. ha_checksum mi_checksum(MI_INFO *info, const byte *buf);
  703. ha_checksum mi_static_checksum(MI_INFO *info, const byte *buf);
  704. my_bool mi_check_unique(MI_INFO *info, MI_UNIQUEDEF *def, byte *record,
  705.      ha_checksum unique_hash, my_off_t pos);
  706. ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const byte *buf);
  707. int _mi_cmp_static_unique(MI_INFO *info, MI_UNIQUEDEF *def,
  708.    const byte *record, my_off_t pos);
  709. int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
  710.    const byte *record, my_off_t pos);
  711. int mi_unique_comp(MI_UNIQUEDEF *def, const byte *a, const byte *b,
  712.    my_bool null_are_equal);
  713. void mi_get_status(void* param);
  714. void mi_update_status(void* param);
  715. void mi_copy_status(void* to,void *from);
  716. my_bool mi_check_status(void* param);
  717. void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows);
  719. extern MI_INFO *test_if_reopen(char *filename);
  720. my_bool check_table_is_closed(const char *name, const char *where);
  721. int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup);
  722. int mi_open_keyfile(MYISAM_SHARE *share);
  723. void mi_setup_functions(register MYISAM_SHARE *share);
  725.     /* Functions needed by mi_check */
  726. volatile my_bool *killed_ptr(MI_CHECK *param);
  727. void mi_check_print_error _VARARGS((MI_CHECK *param, const char *fmt,...));
  728. void mi_check_print_warning _VARARGS((MI_CHECK *param, const char *fmt,...));
  729. void mi_check_print_info _VARARGS((MI_CHECK *param, const char *fmt,...));
  730. int flush_pending_blocks(MI_SORT_PARAM *param);
  731. int sort_ft_buf_flush(MI_SORT_PARAM *sort_param);
  732. int thr_write_keys(MI_SORT_PARAM *sort_param);
  733. #ifdef THREAD
  734. pthread_handler_decl(thr_find_all_keys,arg);
  735. #endif
  736. int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, File file);
  738. int sort_write_record(MI_SORT_PARAM *sort_param);
  739. int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages, ulong);
  741. #ifdef __cplusplus
  742. }
  743. #endif