home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / myisam / myisamdef.h < prev    next >
C/C++ Source or Header  |  2000-11-16  |  26KB  |  646 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  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.
  12.    
  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 */
  16.  
  17. /* This file is included by all internal myisam files */
  18.  
  19. #define ISAM_LIBRARY
  20. #include "myisam.h"            /* Structs & some defines */
  21. #include "myisampack.h"            /* packing of keys */
  22. #ifdef THREAD
  23. #include <my_pthread.h>
  24. #include <thr_lock.h>
  25. #else
  26. #include <my_no_pthread.h>
  27. #endif
  28.  
  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
  32.  
  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;  
  42.  
  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 not_used[2];            /* To align to 8 */
  59.   } header;
  60.  
  61.   MI_STATUS_INFO state;
  62.   ha_rows split;            /* number of split blocks */
  63.   my_off_t dellink;            /* Link to next removed block */
  64.   ulonglong auto_increment;
  65.   ulong process;            /* process that updated table last */
  66.   ulong unique;                /* Unique number for this process */
  67.   ulong update_count;            /* Updated for each write lock */
  68.   ulong status;
  69.   my_off_t *key_root;            /* Start of key trees */
  70.   my_off_t *key_del;            /* delete links for trees */
  71.  
  72.   ulong sec_index_changed;        /* Updated when new sec_index */
  73.   ulong sec_index_used;            /* which extra index are in use */
  74.   ulonglong key_map;            /* Which keys are in use */
  75.   ha_checksum checksum;
  76.   ulong version;            /* timestamp of create */
  77.   time_t create_time;            /* Time when created database */
  78.   time_t recover_time;            /* Time for last recover */
  79.   time_t check_time;            /* Time for last check */
  80.   uint    sortkey;            /* sorted by this key  (not used) */
  81.   uint open_count;
  82.   uint8 changed;            /* Changed since myisamchk */
  83.   my_off_t rec_per_key_rows;        /* Rows when calculating rec_per_key */
  84.   ulong *rec_per_key_part;
  85.  
  86.   /* the following isn't saved on disk */
  87.   uint state_diff_length;        /* Should be 0 */
  88.   uint    state_length;            /* Length of state header in file */
  89.   ulong *key_info;
  90. } MI_STATE_INFO;
  91.  
  92. #define MI_STATE_INFO_SIZE    (24+14*8+7*4+2*2+8)
  93. #define MI_STATE_KEY_SIZE     8
  94. #define MI_STATE_KEYBLOCK_SIZE  8
  95. #define MI_STATE_KEYSEG_SIZE    4
  96. #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)
  97. #define MI_KEYDEF_SIZE        (2+ 5*2)
  98. #define MI_UNIQUEDEF_SIZE    (2+1+1)
  99. #define MI_KEYSEG_SIZE        (6+ 2*2 + 4*2)
  100. #define MI_COLUMNDEF_SIZE    (2*3+1)
  101. #define MI_BASE_INFO_SIZE    (5*8 + 8*4 + 4 + 4*2 + 16)
  102. #define MI_INDEX_BLOCK_MARGIN    16    /* Safety margin for .MYI tables */
  103.  
  104. typedef struct st_mi_base_info
  105. {
  106.   my_off_t keystart;            /* Start of keys */
  107.   my_off_t max_data_file_length;
  108.   my_off_t max_key_file_length;
  109.   my_off_t margin_key_file_length;
  110.   ha_rows records,reloc;        /* Create information */
  111.   ulong mean_row_length;        /* Create information */
  112.   ulong reclength;            /* length of unpacked record */
  113.   ulong pack_reclength;            /* Length of full packed rec. */
  114.   ulong min_pack_length;
  115.   ulong max_pack_length;        /* Max possibly length of packed rec.*/
  116.   ulong min_block_length;
  117.   ulong fields,                /* fields in table */
  118.        pack_fields;            /* packed fields in table */
  119.   uint rec_reflength;            /* = 2-8 */
  120.   uint key_reflength;            /* = 2-8 */
  121.   uint keys;                /* same as in state.header */
  122.   uint auto_key;            /* Which key-1 is a auto key */
  123.   uint blobs;                /* Number of blobs */
  124.   uint pack_bits;            /* Length of packed bits */
  125.   uint max_key_block_length;        /* Max block length */
  126.   uint max_key_length;            /* Max key length */
  127.   /* Extra allocation when using dynamic record format */
  128.   uint extra_alloc_bytes;
  129.   uint extra_alloc_procent;
  130.   /* Info about raid */
  131.   uint raid_type,raid_chunks;
  132.   ulong raid_chunksize;
  133.   /* The following are from the header */
  134.   uint key_parts,all_key_parts;
  135. } MI_BASE_INFO;
  136.  
  137.  
  138.     /* Structs used intern in database */
  139.  
  140. typedef struct st_mi_blob        /* Info of record */
  141. {
  142.   ulong offset;                /* Offset to blob in record */
  143.   uint pack_length;            /* Type of packed length */
  144.   ulong length;                /* Calc:ed for each record */
  145. } MI_BLOB;
  146.  
  147.  
  148. typedef struct st_mi_isam_pack {
  149.   ulong header_length;
  150.   uint ref_length;
  151. } MI_PACK;
  152.  
  153.  
  154. typedef struct st_mi_isam_share {    /* Shared between opens */
  155.   MI_STATE_INFO state;
  156.   MI_BASE_INFO base;
  157.   MI_KEYDEF  *keyinfo;            /* Key definitions */
  158.   MI_UNIQUEDEF *uniqueinfo;        /* unique definitions */
  159.   MI_KEYSEG *keyparts;            /* key part info */
  160.   MI_COLUMNDEF *rec;            /* Pointer to field information */
  161.   MI_PACK    pack;            /* Data about packed records */
  162.   MI_BLOB    *blobs;            /* Pointer to blobs */
  163.   char    *filename;            /* Name of indexfile */
  164.   byte *file_map;            /* mem-map of file if possible */
  165.   ulong this_process;            /* processid */
  166.   ulong last_process;            /* For table-change-check */
  167.   ulong last_version;            /* Version on start */
  168.   ulong options;            /* Options used */
  169.   uint    rec_reflength;            /* rec_reflength in use now */
  170.   int    kfile;                /* Shared keyfile */
  171.   int    data_file;            /* Shared data file */
  172.   int    mode;                /* mode of file on open */
  173.   uint    reopen;                /* How many times reopened */
  174.   uint    w_locks,r_locks;        /* Number of read/write locks */
  175.   uint    blocksize;            /* blocksize of keyfile */
  176.   ulong min_pack_length;        /* Theese are used by packed data */
  177.   ulong max_pack_length;
  178.   ulong state_diff_length;
  179.   my_bool  changed,            /* If changed since lock */
  180.     global_changed,            /* If changed since open */
  181.     not_flushed,
  182.     temporary,delay_key_write,
  183.     concurrent_insert,
  184.     fulltext_index;
  185.   myf write_flag;
  186.   int    rnd;                /* rnd-counter */
  187.   MI_DECODE_TREE *decode_trees;
  188.   uint16 *decode_tables;
  189.   enum data_file_type data_file_type;
  190.   int (*read_record)(struct st_myisam_info*, my_off_t, byte*);
  191.   int (*write_record)(struct st_myisam_info*, const byte*);
  192.   int (*update_record)(struct st_myisam_info*, my_off_t, const byte*);
  193.   int (*delete_record)(struct st_myisam_info*);
  194.   int (*read_rnd)(struct st_myisam_info*, byte*, my_off_t, my_bool);
  195.   int (*compare_record)(struct st_myisam_info*, const byte *);
  196.   ha_checksum (*calc_checksum)(struct st_myisam_info*, const byte *);
  197.   int (*compare_unique)(struct st_myisam_info*, MI_UNIQUEDEF *,
  198.             const byte *record, my_off_t pos);
  199. #ifdef THREAD
  200.   THR_LOCK lock;
  201.   pthread_mutex_t intern_lock;        /* Locking for use with _locking */
  202.   rw_lock_t *key_root_lock;
  203. #endif
  204. } MYISAM_SHARE;
  205.  
  206.  
  207. typedef uint mi_bit_type;
  208.  
  209. typedef struct st_mi_bit_buff {        /* Used for packing of record */
  210.   mi_bit_type current_byte;
  211.   uint bits;
  212.   uchar *pos,*end,*blob_pos;
  213.   uint error;
  214. } MI_BIT_BUFF;
  215.  
  216.  
  217. struct st_myisam_info {
  218.   MYISAM_SHARE *s;            /* Shared between open:s */
  219.   MI_STATUS_INFO *state,save_state;
  220.   MI_BLOB     *blobs;            /* Pointer to blobs */
  221.   int dfile;                /* The datafile */
  222.   MI_BIT_BUFF   bit_buff;
  223.   uint    opt_flag;            /* Optim. for space/speed */
  224.   uint update;                /* If file changed since open */
  225.   char *filename;            /* parameter to open filename */
  226.   ulong this_unique;            /* uniq filenumber or thread */
  227.   ulong last_unique;            /* last unique number */
  228.   ulong this_loop;            /* counter for this open */
  229.   ulong last_loop;            /* last used counter */
  230.   my_off_t lastpos,            /* Last record position */
  231.     nextpos;            /* Position to next record */
  232.   my_off_t save_lastpos;
  233.   my_off_t pos;                /* Intern variable */
  234.   ha_checksum checksum;
  235.   ulong packed_length,blob_length;    /* Length of found, packed record */
  236.   uint    alloced_rec_buff_length;    /* Max recordlength malloced */
  237.   uchar *buff,                /* Temp area for key */
  238.     *lastkey,*lastkey2;        /* Last used search key */
  239.   byte    *rec_buff,            /* Tempbuff for recordpack */
  240.     *rec_alloc;            /* Malloced area for record */
  241.   uchar *int_keypos,            /* Save position for next/previous */
  242.     *int_maxpos;            /*  -""-  */
  243.   uint32 int_keytree_version;        /*  -""-  */
  244.   uint   int_nod_flag;            /*  -""-  */
  245.   my_off_t last_keypage;        /* Last key page read */
  246.   my_off_t last_search_keypage;        /* Last keypage when searching */
  247.   my_off_t dupp_key_pos;
  248.   int    lastinx;            /* Last used index */
  249.   uint    lastkey_length;            /* Length of key in lastkey */
  250.   uint    last_rkey_length;        /* Last length in mi_rkey() */
  251.   uint  save_lastkey_length;
  252.   int    errkey;                /* Got last error on this key */
  253.   int   lock_type;            /* How database was locked */
  254.   int   tmp_lock_type;            /* When locked by readinfo */
  255.   uint    data_changed;            /* Somebody has changed data */
  256.   uint    save_update;            /* When using KEY_READ */
  257.   int    save_lastinx;
  258.   my_bool was_locked;            /* Was locked in panic */
  259.   my_bool quick_mode;
  260.   my_bool page_changed;        /* If info->buff can't be used for rnext */
  261.   my_bool buff_used;        /* If info->buff has to be reread for rnext */
  262.   myf lock_wait;            /* is 0 or MY_DONT_WAIT */
  263.   int (*read_record)(struct st_myisam_info*, my_off_t, byte*);
  264.   LIST    open_list;
  265.   IO_CACHE rec_cache;            /* When cacheing records */
  266. #ifdef THREAD
  267.   THR_LOCK_DATA lock;
  268. #endif
  269. };
  270.  
  271.  
  272.     /* Some defines used by isam-funktions */
  273.  
  274. #define USE_WHOLE_KEY    MI_MAX_KEY_BUFF*2 /* Use whole key in _mi_search() */
  275. #define F_EXTRA_LCK    -1
  276.  
  277.     /* bits in opt_flag */
  278. #define MEMMAP_USED    32
  279. #define REMEMBER_OLD_POS 64
  280.  
  281. #define WRITEINFO_UPDATE_KEYFILE    1
  282. #define WRITEINFO_NO_UNLOCK        2
  283.  
  284.     /* bits in state.changed */
  285.  
  286. #define STATE_CHANGED        1
  287. #define STATE_CRASHED        2
  288. #define STATE_CRASHED_ON_REPAIR 4 
  289. #define STATE_NOT_ANALYZED    8
  290. #define STATE_NOT_OPTIMIZED_KEYS 16
  291. #define STATE_NOT_SORTED_PAGES    32
  292.  
  293.  
  294. #define mi_getint(x)    ((uint) mi_uint2korr(x) & 32767)
  295. #define mi_putint(x,y,nod) { uint16 boh=(nod ? (uint16) 32768 : 0) + (uint16) (y);\
  296.               mi_int2store(x,boh); }
  297. #define mi_test_if_nod(x) (x[0] & 128 ? info->s->base.key_reflength : 0)
  298. #define mi_mark_crashed(x) (x)->s->state.changed|=STATE_CRASHED
  299. #define mi_mark_crashed_on_repair(x) { (x)->s->state.changed|=STATE_CRASHED|STATE_CRASHED_ON_REPAIR ; (x)->update|= HA_STATE_CHANGED; }
  300. #define mi_is_crashed(x) ((x)->s->state.changed & STATE_CRASHED)
  301. #define mi_is_crashed_on_repair(x) ((x)->s->state.changed & STATE_CRASHED_ON_REPAIR)
  302.  
  303. /* Functions to store length of space packed keys, VARCHAR or BLOB keys */
  304.  
  305. #define store_key_length_inc(key,length) \
  306. { if ((length) < 255) \
  307.   { *(key)++=(length); } \
  308.   else \
  309.   { *(key)=255; mi_int2store((key)+1,(length)); (key)+=3; } \
  310. }
  311.  
  312. #define store_key_length(key,length) \
  313. { if ((length) < 255) \
  314.   { *(key)=(length); } \
  315.   else \
  316.   { *(key)=255; mi_int2store((key)+1,(length)); } \
  317. }
  318.  
  319. #define get_key_length(length,key) \
  320. { if ((uchar) *(key) != 255) \
  321.     length= (uint) (uchar) *((key)++); \
  322.   else \
  323.   { length=mi_uint2korr((key)+1); (key)+=3; } \
  324. }
  325.  
  326. #define get_key_full_length(length,key) \
  327. { if ((uchar) *(key) != 255) \
  328.     length= ((uint) (uchar) *((key)++))+1; \
  329.   else \
  330.   { length=mi_uint2korr((key)+1)+3; (key)+=3; } \
  331. }
  332.  
  333. #define get_key_pack_length(length,length_pack,key) \
  334. { if ((uchar) *(key) != 255) \
  335.   { length= (uint) (uchar) *((key)++); length_pack=1; }\
  336.   else \
  337.   { length=mi_uint2korr((key)+1); (key)+=3; length_pack=3; } \
  338. }
  339.  
  340. #define get_pack_length(length) ((length) >= 255 ? 3 : 1)
  341.  
  342. #define MI_MIN_BLOCK_LENGTH    20    /* Because of delete-link */
  343. #define MI_EXTEND_BLOCK_LENGTH    20    /* Don't use to small record-blocks */
  344. #define MI_SPLIT_LENGTH    ((MI_EXTEND_BLOCK_LENGTH+4)*2)
  345. #define MI_MAX_DYN_BLOCK_HEADER    20    /* Max prefix of record-block */
  346. #define MI_BLOCK_INFO_HEADER_LENGTH 20
  347. #define MI_DYN_DELETE_BLOCK_HEADER 20    /* length of delete-block-header */
  348. #define MI_DYN_MAX_BLOCK_LENGTH    ((1L << 24)-4L)
  349. #define MI_DYN_MAX_ROW_LENGTH    (MI_DYN_MAX_BLOCK_LENGTH - MI_SPLIT_LENGTH)
  350. #define MI_DYN_ALIGN_SIZE    4    /* Align blocks on this */
  351. #define MI_MAX_DYN_HEADER_BYTE    12    /* max header byte for dynamic rows */
  352.  
  353. #define MEMMAP_EXTRA_MARGIN    7    /* Write this as a suffix for file */
  354.  
  355. #define PACK_TYPE_SELECTED    1    /* Bits in field->pack_type */
  356. #define PACK_TYPE_SPACE_FIELDS    2
  357. #define PACK_TYPE_ZERO_FILL    4
  358. #define MI_FOUND_WRONG_KEY 32738    /* Impossible value from _mi_key_cmp */
  359.  
  360. #define MI_KEY_BLOCK_LENGTH    1024    /* Min key block length */
  361. #define MI_MAX_KEY_BLOCK_LENGTH    8192
  362. #define MI_MAX_KEY_BLOCK_SIZE    (MI_MAX_KEY_BLOCK_LENGTH/MI_KEY_BLOCK_LENGTH)
  363. #define MI_BLOCK_SIZE(key_length,data_pointer,key_pointer) ((((key_length+data_pointer+key_pointer)*4+key_pointer+2)/MI_KEY_BLOCK_LENGTH+1)*MI_KEY_BLOCK_LENGTH)
  364. #define MI_MAX_KEYPTR_SIZE    5    /* For calculating block lengths */
  365. #define MI_MIN_KEYBLOCK_LENGTH    50    /* When to split delete blocks */
  366.  
  367. /* The UNIQUE check is done with a hashed long key */
  368.  
  369. #define MI_UNIQUE_HASH_TYPE    HA_KEYTYPE_ULONG_INT
  370. #define mi_unique_store(A,B)    mi_int4store((A),(B))
  371.  
  372. #ifdef THREAD
  373. extern pthread_mutex_t THR_LOCK_myisam;
  374. #endif
  375. #if !defined(THREAD) || defined(DONT_USE_RW_LOCKS)
  376. #define rw_wrlock(A) {}
  377. #define rw_rdlock(A) {}
  378. #define rw_unlock(A) {}
  379. #endif
  380.  
  381.     /* Some extern variables */
  382.  
  383. extern LIST *myisam_open_list;
  384. extern uchar NEAR myisam_file_magic[],NEAR myisam_pack_file_magic[];
  385. extern uint NEAR myisam_read_vec[],NEAR myisam_readnext_vec[];
  386. extern uint myisam_quick_table_bits;
  387. extern File myisam_log_file;
  388. extern ulong myisam_pid;
  389.  
  390.     /* This is used by _mi_calc_xxx_key_length och _mi_store_key */
  391.  
  392. typedef struct st_mi_s_param
  393. {
  394.   uint    ref_length,key_length,
  395.     n_ref_length,
  396.     n_length,
  397.     totlength,
  398.     part_of_prev_key,prev_length,pack_marker;
  399.   uchar *key, *prev_key,*next_key_pos;
  400.   bool    store_not_null;
  401. } MI_KEY_PARAM;
  402.  
  403.     /* Prototypes for intern functions */
  404.  
  405. extern int _mi_read_dynamic_record(MI_INFO *info,my_off_t filepos,byte *buf);
  406. extern int _mi_write_dynamic_record(MI_INFO*, const byte*);
  407. extern int _mi_update_dynamic_record(MI_INFO*, my_off_t, const byte*);
  408. extern int _mi_delete_dynamic_record(MI_INFO *info);
  409. extern int _mi_cmp_dynamic_record(MI_INFO *info,const byte *record);
  410. extern int _mi_read_rnd_dynamic_record(MI_INFO *, byte *,my_off_t, my_bool);
  411. extern int _mi_write_blob_record(MI_INFO*, const byte*);
  412. extern int _mi_update_blob_record(MI_INFO*, my_off_t, const byte*);
  413. extern int _mi_read_static_record(MI_INFO *info, my_off_t filepos,byte *buf);
  414. extern int _mi_write_static_record(MI_INFO*, const byte*);
  415. extern int _mi_update_static_record(MI_INFO*, my_off_t, const byte*);
  416. extern int _mi_delete_static_record(MI_INFO *info);
  417. extern int _mi_cmp_static_record(MI_INFO *info,const byte *record);
  418. extern int _mi_read_rnd_static_record(MI_INFO*, byte *,my_off_t, my_bool);
  419. extern int _mi_ck_write(MI_INFO *info,uint keynr,uchar *key,uint length);
  420. extern int _mi_enlarge_root(MI_INFO *info,uint keynr,uchar *key);
  421. extern int _mi_insert(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  422.               uchar *anc_buff,uchar *key_pos,uchar *key_buff,
  423.               uchar *father_buff, uchar *father_keypos,
  424.               my_off_t father_page, my_bool insert_last);
  425. extern int _mi_split_page(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  426.               uchar *buff,uchar *key_buff, my_bool insert_last);
  427. extern uchar *_mi_find_half_pos(uint nod_flag,MI_KEYDEF *keyinfo,uchar *page,
  428.                 uchar *key,uint *return_key_length,
  429.                 uchar **after_key);
  430. extern int _mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  431.                       uchar *key_pos, uchar *org_key,
  432.                       uchar *key_buff,
  433.                       uchar *key, MI_KEY_PARAM *s_temp);
  434. extern int _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  435.                    uchar *key_pos, uchar *org_key,
  436.                    uchar *key_buff,
  437.                    uchar *key, MI_KEY_PARAM *s_temp);
  438. extern int _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  439.                     uchar *key_pos, uchar *org_key,
  440.                     uchar *prev_key,
  441.                     uchar *key, MI_KEY_PARAM *s_temp);
  442. extern int _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  443.                     uchar *key_pos,uchar *org_key,
  444.                     uchar *prev_key,
  445.                     uchar *key, MI_KEY_PARAM *s_temp);
  446. void _mi_store_static_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  447.                MI_KEY_PARAM *s_temp);
  448. void _mi_store_var_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  449.                  MI_KEY_PARAM *s_temp);
  450. #ifdef NOT_USED
  451. void _mi_store_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  452.              MI_KEY_PARAM *s_temp);
  453. #endif
  454. void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
  455.                 MI_KEY_PARAM *s_temp);
  456.  
  457. extern int _mi_ck_delete(MI_INFO *info,uint keynr,uchar *key,uint key_length);
  458. extern int _mi_readinfo(MI_INFO *info,int lock_flag,int check_keybuffer);
  459. extern int _mi_writeinfo(MI_INFO *info,uint options);
  460. extern int _mi_test_if_changed(MI_INFO *info);
  461. extern int _mi_mark_file_changed(MI_INFO *info);
  462. extern int _mi_decrement_open_count(MI_INFO *info);
  463. extern int _mi_check_index(MI_INFO *info,int inx);
  464. extern int _mi_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,uint key_len,
  465.               uint nextflag,my_off_t pos);
  466. extern int _mi_bin_search(struct st_myisam_info *info,MI_KEYDEF *keyinfo,
  467.               uchar *page,uchar *key,uint key_len,uint comp_flag,
  468.               uchar * *ret_pos,uchar *buff, my_bool *was_last_key);
  469. extern int _mi_seq_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *page,
  470.               uchar *key,uint key_len,uint comp_flag,
  471.               uchar **ret_pos,uchar *buff, my_bool *was_last_key);
  472. extern int _mi_compare_text(CHARSET_INFO *, uchar *, uint, uchar *, uint ,
  473.                 my_bool);
  474. extern my_off_t _mi_kpos(uint nod_flag,uchar *after_key);
  475. extern void _mi_kpointer(MI_INFO *info,uchar *buff,my_off_t pos);
  476. extern my_off_t _mi_dpos(MI_INFO *info, uint nod_flag,uchar *after_key);
  477. extern my_off_t _mi_rec_pos(MYISAM_SHARE *info, uchar *ptr);
  478. extern void _mi_dpointer(MI_INFO *info, uchar *buff,my_off_t pos);
  479. extern int _mi_key_cmp(MI_KEYSEG *keyseg, uchar *a,uchar *b,
  480.                uint key_length,uint nextflag,uint *diff_length);
  481. extern uint _mi_get_static_key(MI_KEYDEF *keyinfo,uint nod_flag,uchar * *page,
  482.                    uchar *key);
  483. extern uint _mi_get_pack_key(MI_KEYDEF *keyinfo,uint nod_flag,uchar * *page,
  484.                  uchar *key);
  485. extern uint _mi_get_binary_pack_key(MI_KEYDEF *keyinfo, uint nod_flag,
  486.                     uchar **page_pos, uchar *key);
  487. extern uchar *_mi_get_last_key(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *keypos,
  488.                    uchar *lastkey,uchar *endpos,
  489.                    uint *return_key_length);
  490. extern uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
  491.               uchar *key, uchar *keypos, uint *return_key_length);
  492. extern uint _mi_keylength(MI_KEYDEF *keyinfo,uchar *key);
  493. extern uchar *_mi_move_key(MI_KEYDEF *keyinfo,uchar *to,uchar *from);
  494. extern int _mi_search_next(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  495.                uint key_length,uint nextflag,my_off_t pos);
  496. extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
  497. extern int _mi_search_last(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
  498. extern uchar *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
  499.                 uchar *buff,int return_buffer);
  500. extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
  501.                  uchar *buff);
  502. extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
  503. extern my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo);
  504. extern uint _mi_make_key(MI_INFO *info,uint keynr,uchar *key,
  505.              const byte *record,my_off_t filepos);
  506. extern uint _mi_pack_key(MI_INFO *info,uint keynr,uchar *key,uchar *old,
  507.              uint key_length);
  508. extern int _mi_read_key_record(MI_INFO *info,my_off_t filepos,byte *buf);
  509. extern int _mi_read_cache(IO_CACHE *info,byte *buff,my_off_t pos,
  510.               uint length,int re_read_if_possibly);
  511. extern void update_auto_increment(MI_INFO *info,const byte *record);
  512. extern byte *mi_fix_rec_buff_for_blob(MI_INFO *info,ulong blob_length);
  513. extern ulong _mi_rec_unpack(MI_INFO *info,byte *to,byte *from,
  514.                 ulong reclength);
  515. extern my_bool _mi_rec_check(MI_INFO *info,const char *from);
  516. extern int _mi_write_part_record(MI_INFO *info,my_off_t filepos,ulong length,
  517.                  my_off_t next_filepos,byte **record,
  518.                  ulong *reclength,int *flag);
  519. extern void _mi_print_key(FILE *stream,MI_KEYSEG *keyseg,const uchar *key,
  520.               uint length);
  521. extern my_bool _mi_read_pack_info(MI_INFO *info,pbool fix_keys);
  522. extern int _mi_read_pack_record(MI_INFO *info,my_off_t filepos,byte *buf);
  523. extern int _mi_read_rnd_pack_record(MI_INFO*, byte *,my_off_t, my_bool);
  524. extern int _mi_pack_rec_unpack(MI_INFO *info,byte *to,byte *from,
  525.                    ulong reclength);
  526. extern ulonglong mi_safe_mul(ulonglong a,ulonglong b);
  527.  
  528. struct st_sort_info;
  529.  
  530.  
  531. typedef struct st_mi_block_info {    /* Parameter to _mi_get_block_info */
  532.   uchar header[MI_BLOCK_INFO_HEADER_LENGTH];
  533.   ulong rec_len;
  534.   ulong data_len;
  535.   ulong block_len;
  536.   ulong blob_len;
  537.   my_off_t filepos;
  538.   my_off_t next_filepos;
  539.   my_off_t prev_filepos;
  540.   uint second_read;
  541.   uint offset;
  542. } MI_BLOCK_INFO;
  543.  
  544.     /* bits in return from _mi_get_block_info */
  545.  
  546. #define BLOCK_FIRST    1
  547. #define BLOCK_LAST    2
  548. #define BLOCK_DELETED    4
  549. #define BLOCK_ERROR    8    /* Wrong data */
  550. #define BLOCK_SYNC_ERROR 16    /* Right data at wrong place */
  551. #define BLOCK_FATAL_ERROR 32    /* hardware-error */
  552.  
  553. #define NEAD_MEM    ((uint) 10*4*(IO_SIZE+32)+32) /* Nead for recursion */
  554. #define MAXERR            20
  555. #define BUFFERS_WHEN_SORTING    16        /* Alloc for sort-key-tree */
  556. #define WRITE_COUNT        MY_HOW_OFTEN_TO_WRITE
  557. #define INDEX_TMP_EXT        ".TMM"
  558. #define DATA_TMP_EXT        ".TMD"
  559.  
  560. #define UPDATE_TIME        1
  561. #define UPDATE_STAT        2
  562. #define UPDATE_SORT        4
  563. #define UPDATE_AUTO_INC        8
  564. #define UPDATE_OPEN_COUNT    16
  565.  
  566. #define USE_BUFFER_INIT        (((1024L*512L-MALLOC_OVERHEAD)/IO_SIZE)*IO_SIZE)
  567. #define READ_BUFFER_INIT    (1024L*256L-MALLOC_OVERHEAD)
  568. #define SORT_BUFFER_INIT    (2048L*1024L-MALLOC_OVERHEAD)
  569. #define MIN_SORT_BUFFER        (4096-MALLOC_OVERHEAD)
  570.  
  571. enum myisam_log_commands {
  572.   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
  573. };
  574.  
  575. #define myisam_log(a,b,c,d) if (myisam_log_file >= 0) _myisam_log(a,b,c,d)
  576. #define myisam_log_command(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_command(a,b,c,d,e)
  577. #define myisam_log_record(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_record(a,b,c,d,e)
  578.  
  579. #ifdef    __cplusplus
  580. extern "C" {
  581. #endif
  582.  
  583. extern uint _mi_get_block_info(MI_BLOCK_INFO *,File, my_off_t);
  584. extern uint _mi_rec_pack(MI_INFO *info,byte *to,const byte *from);
  585. extern uint _mi_pack_get_block_info(MI_INFO *mysql, MI_BLOCK_INFO *, File,
  586.                     my_off_t, char *rec_buf);
  587. extern void _my_store_blob_length(byte *pos,uint pack_length,uint length);
  588. extern void _myisam_log(enum myisam_log_commands command,MI_INFO *info,
  589.                const byte *buffert,uint length);
  590. extern void _myisam_log_command(enum myisam_log_commands command,
  591.                    MI_INFO *info, const byte *buffert,
  592.                    uint length, int result);
  593. extern void _myisam_log_record(enum myisam_log_commands command,MI_INFO *info,
  594.                   const byte *record,my_off_t filepos,
  595.                   int result);
  596. extern my_bool _mi_memmap_file(MI_INFO *info);
  597. extern void _mi_unmap_file(MI_INFO *info);
  598. extern uint save_pack_length(byte *block_buff,ulong length);
  599.  
  600. uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite);
  601. char *mi_state_info_read(char *ptr, MI_STATE_INFO *state);
  602. uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead);
  603. uint mi_base_info_write(File file, MI_BASE_INFO *base);
  604. char *my_n_base_info_read(char *ptr, MI_BASE_INFO *base);
  605. int mi_keyseg_write(File file, const MI_KEYSEG *keyseg);
  606. char *mi_keyseg_read(char *ptr, MI_KEYSEG *keyseg);
  607. uint mi_keydef_write(File file, MI_KEYDEF *keydef);
  608. char *mi_keydef_read(char *ptr, MI_KEYDEF *keydef);
  609. uint mi_uniquedef_write(File file, MI_UNIQUEDEF *keydef);
  610. char *mi_uniquedef_read(char *ptr, MI_UNIQUEDEF *keydef);
  611. uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo);
  612. char *mi_recinfo_read(char *ptr, MI_COLUMNDEF *recinfo);
  613. ulong _my_calc_total_blob_length(MI_INFO *info, const byte *record);
  614. ha_checksum mi_checksum(MI_INFO *info, const byte *buf);
  615. ha_checksum mi_static_checksum(MI_INFO *info, const byte *buf);
  616. my_bool mi_check_unique(MI_INFO *info, MI_UNIQUEDEF *def, byte *record,
  617.              ha_checksum unique_hash, my_off_t pos);
  618. ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const byte *buf);
  619. int _mi_cmp_static_unique(MI_INFO *info, MI_UNIQUEDEF *def,
  620.                const byte *record, my_off_t pos);
  621. int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
  622.                const byte *record, my_off_t pos);
  623. int mi_unique_comp(MI_UNIQUEDEF *def, const byte *a, const byte *b,
  624.            my_bool null_are_equal);
  625. void mi_get_status(void* param);
  626. void mi_update_status(void* param);
  627. void mi_copy_status(void* to,void *from);
  628. my_bool mi_check_status(void* param);
  629. void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows);
  630. int _mi_rkey(MI_INFO *info, byte *buf, int inx, const byte *key, uint key_len,
  631.          enum ha_rkey_function search_flag, bool raw_key);
  632.  
  633. my_bool check_table_is_closed(const char *name, const char *where);
  634. int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share);
  635. int mi_open_keyfile(MYISAM_SHARE *share);
  636.  
  637. /* Functions needed by mi_check */
  638. void mi_check_print_error _VARARGS((MI_CHECK *param, const char *fmt,...));
  639. void mi_check_print_warning _VARARGS((MI_CHECK *param, const char *fmt,...));
  640. void mi_check_print_info _VARARGS((MI_CHECK *param, const char *fmt,...));
  641.  
  642. #ifdef __cplusplus
  643. }
  644. #endif
  645.  
  646.