1 /* Copyright (C) 2006 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; version 2 of the License.
6
7 This program is distributed in the hope that it will be useful,
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 GNU General Public License for more details.
11
12 You should have received a copy of the GNU General Public License
13 along with this program; if not, write to the Free Software
14 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
15
16 /* This file is included by all internal maria files */
17
18 #include <my_global.h>
19 #include "maria.h" /* Structs & some defines */
20 #include "ma_pagecache.h"
21 #include <myisampack.h> /* packing of keys */
22 #include <my_tree.h>
23 #include <my_bitmap.h>
24 #include <my_pthread.h>
25 #include <thr_lock.h>
26 #include <hash.h>
27 #include "ma_loghandler.h"
28 #include "ma_control_file.h"
29 #include "ma_state.h"
30 #include <waiting_threads.h>
31 #include <mysql/psi/mysql_file.h>
32
33 /* For testing recovery */
34 #ifdef TO_BE_REMOVED
35 #define IDENTICAL_PAGES_AFTER_RECOVERY 1
36 #endif
37 /* Do extra sanity checking */
38 #define SANITY_CHECKS 1
39 #ifdef EXTRA_DEBUG
40 #define EXTRA_DEBUG_KEY_CHANGES
41 #define EXTRA_STORE_FULL_PAGE_IN_KEY_CHANGES
42 #endif
43
44 #define MAX_NONMAPPED_INSERTS 1000
45 #define MARIA_MAX_TREE_LEVELS 32
46 #define MARIA_MAX_RECORD_ON_STACK 16384
47
48 /* maria_open() flag, specific for maria_pack */
49 #define HA_OPEN_IGNORE_MOVED_STATE (1U << 30)
50
51 extern PAGECACHE maria_pagecache_var, *maria_pagecache;
52 int maria_assign_to_pagecache(MARIA_HA *info, ulonglong key_map,
53 PAGECACHE *key_cache);
54 void maria_change_pagecache(PAGECACHE *old_key_cache,
55 PAGECACHE *new_key_cache);
56
57 typedef struct st_maria_sort_info
58 {
59 /* sync things */
60 mysql_mutex_t mutex;
61 mysql_cond_t cond;
62 MARIA_HA *info, *new_info;
63 HA_CHECK *param;
64 char *buff;
65 SORT_KEY_BLOCKS *key_block, *key_block_end;
66 SORT_FT_BUF *ft_buf;
67 my_off_t filelength, dupp, buff_length;
68 pgcache_page_no_t page;
69 ha_rows max_records;
70 uint current_key, total_keys;
71 volatile uint got_error;
72 uint threads_running;
73 myf myf_rw;
74 enum data_file_type new_data_file_type, org_data_file_type;
75 } MARIA_SORT_INFO;
76
77 typedef struct st_maria_sort_param
78 {
79 pthread_t thr;
80 IO_CACHE read_cache, tempfile, tempfile_for_exceptions;
81 DYNAMIC_ARRAY buffpek;
82 MARIA_BIT_BUFF bit_buff; /* For parallel repair of packrec. */
83
84 MARIA_KEYDEF *keyinfo;
85 MARIA_SORT_INFO *sort_info;
86 HA_KEYSEG *seg;
87 uchar **sort_keys;
88 uchar *rec_buff;
89 void *wordlist, *wordptr;
90 MEM_ROOT wordroot;
91 uchar *record;
92 MY_TMPDIR *tmpdir;
93
94 /*
95 The next two are used to collect statistics, see maria_update_key_parts for
96 description.
97 */
98 ulonglong unique[HA_MAX_KEY_SEG+1];
99 ulonglong notnull[HA_MAX_KEY_SEG+1];
100 ulonglong sortbuff_size;
101
102 MARIA_RECORD_POS pos,max_pos,filepos,start_recpos, current_filepos;
103 uint key, key_length,real_key_length;
104 uint maxbuffers, keys, find_length, sort_keys_length;
105 my_bool fix_datafile, master;
106 my_bool calc_checksum; /* calculate table checksum */
107 size_t rec_buff_size;
108
109 int (*key_cmp)(struct st_maria_sort_param *, const void *, const void *);
110 int (*key_read)(struct st_maria_sort_param *, uchar *);
111 int (*key_write)(struct st_maria_sort_param *, const uchar *);
112 void (*lock_in_memory)(HA_CHECK *);
113 int (*write_keys)(struct st_maria_sort_param *, uchar **,
114 ulonglong , struct st_buffpek *, IO_CACHE *);
115 my_off_t (*read_to_buffer)(IO_CACHE *,struct st_buffpek *, uint);
116 int (*write_key)(struct st_maria_sort_param *, IO_CACHE *,uchar *,
117 uint, ulonglong);
118 } MARIA_SORT_PARAM;
119
120 int maria_write_data_suffix(MARIA_SORT_INFO *sort_info, my_bool fix_datafile);
121
122 struct st_transaction;
123
124 /* undef map from my_nosys; We need test-if-disk full */
125 #undef my_write
126
127 #define CRC_SIZE 4
128
129 typedef struct st_maria_state_info
130 {
131 struct
132 { /* Fileheader (24 bytes) */
133 uchar file_version[4];
134 uchar options[2];
135 uchar header_length[2];
136 uchar state_info_length[2];
137 uchar base_info_length[2];
138 uchar base_pos[2];
139 uchar key_parts[2]; /* Key parts */
140 uchar unique_key_parts[2]; /* Key parts + unique parts */
141 uchar keys; /* number of keys in file */
142 uchar uniques; /* number of UNIQUE definitions */
143 uchar not_used; /* Language for indexes */
144 uchar fulltext_keys;
145 uchar data_file_type;
146 /* Used by mariapack to store the original data_file_type */
147 uchar org_data_file_type;
148 } header;
149
150 MARIA_STATUS_INFO state;
151 /* maria_ha->state points here for crash-safe but not versioned tables */
152 MARIA_STATUS_INFO common;
153 /* State for a versioned table that is temporary non versioned */
154 MARIA_STATUS_INFO no_logging;
155 ha_rows split; /* number of split blocks */
156 my_off_t dellink; /* Link to next removed block */
157 pgcache_page_no_t first_bitmap_with_space;
158 ulonglong auto_increment;
159 TrID create_trid; /* Minum trid for file */
160 TrID last_change_trn; /* selfdescriptive */
161 ulong update_count; /* Updated for each write lock */
162 ulong status;
163 double *rec_per_key_part;
164 ulong *nulls_per_key_part;
165 ha_checksum checksum; /* Table checksum */
166 my_off_t *key_root; /* Start of key trees */
167 my_off_t key_del; /* delete links for index pages */
168 my_off_t records_at_analyze; /* Rows when calculating rec_per_key */
169
170 ulong sec_index_changed; /* Updated when new sec_index */
171 ulong sec_index_used; /* which extra index are in use */
172 ulonglong key_map; /* Which keys are in use */
173 ulong version; /* timestamp of create */
174 time_t create_time; /* Time when created database */
175 time_t recover_time; /* Time for last recover */
176 time_t check_time; /* Time for last check */
177 uint sortkey; /* sorted by this key (not used) */
178 uint open_count;
179 uint changed; /* Changed since maria_chk */
180 uint org_changed; /* Changed since open */
181 /**
182 Birthday of the table: no record in the log before this LSN should ever
183 be applied to the table. Updated when created, renamed, explicitly
184 repaired (REPAIR|OPTIMIZE TABLE, ALTER TABLE ENABLE KEYS, maria_chk).
185 */
186 LSN create_rename_lsn;
187 /** @brief Log horizon when state was last updated on disk */
188 TRANSLOG_ADDRESS is_of_horizon;
189 /**
190 REDO phase should ignore any record before this LSN. UNDO phase
191 shouldn't, this is the difference with create_rename_lsn.
192 skip_redo_lsn >= create_rename_lsn.
193 The distinction is for these cases:
194 - after a repair at end of bulk insert (enabling indices), REDO phase
195 should skip the table but UNDO phase should not, so only skip_redo_lsn is
196 increased, not create_rename_lsn
197 - if one table is corrupted and so recovery fails, user may repair the
198 table with maria_chk and let recovery restart: that recovery should then
199 skip the repaired table even in the UNDO phase, so create_rename_lsn is
200 increased.
201 */
202 LSN skip_redo_lsn;
203 /* LSN when we wrote file id to the log */
204 LSN logrec_file_id;
205
206 uint8 dupp_key; /* Lastly processed index with */
207 /* violated uniqueness constraint */
208
209 /* the following isn't saved on disk */
210 uint state_diff_length; /* Should be 0 */
211 uint state_length; /* Length of state header in file */
212 ulong *key_info;
213 } MARIA_STATE_INFO;
214
215
216 /* Number of bytes written be _ma_state_info_write_sub() */
217 #define MARIA_STATE_INFO_SIZE \
218 (24 + 2 + LSN_STORE_SIZE*3 + 4 + 11*8 + 4*4 + 8 + 3*4 + 5*8)
219 #define MARIA_FILE_OPEN_COUNT_OFFSET 0
220 #define MARIA_FILE_CHANGED_OFFSET 2
221 #define MARIA_FILE_CREATE_RENAME_LSN_OFFSET 4
222 #define MARIA_FILE_CREATE_TRID_OFFSET (4 + LSN_STORE_SIZE*3 + 11*8)
223
224 #define MARIA_STATE_KEY_SIZE (8 + 4)
225 #define MARIA_STATE_KEYBLOCK_SIZE 8
226 #define MARIA_STATE_KEYSEG_SIZE 12
227 #define MARIA_STATE_EXTRA_SIZE (MARIA_MAX_KEY*MARIA_STATE_KEY_SIZE + MARIA_MAX_KEY*HA_MAX_KEY_SEG*MARIA_STATE_KEYSEG_SIZE)
228 #define MARIA_KEYDEF_SIZE (2+ 5*2)
229 #define MARIA_UNIQUEDEF_SIZE (2+1+1)
230 #define HA_KEYSEG_SIZE (6+ 2*2 + 4*2)
231 #define MARIA_MAX_KEY_BUFF (HA_MAX_KEY_BUFF + MARIA_MAX_PACK_TRANSID_SIZE)
232 #define MARIA_COLUMNDEF_SIZE (2*7+1+1+4)
233 #define MARIA_BASE_INFO_SIZE (MY_UUID_SIZE + 5*8 + 6*4 + 11*2 + 6 + 5*2 + 1 + 16)
234 #define MARIA_INDEX_BLOCK_MARGIN 16 /* Safety margin for .MYI tables */
235 #define MARIA_MAX_POINTER_LENGTH 7 /* Node pointer */
236 /* Internal management bytes needed to store 2 transid/key on an index page */
237 #define MARIA_MAX_PACK_TRANSID_SIZE (TRANSID_SIZE+1)
238 #define MARIA_TRANSID_PACK_OFFSET (256- TRANSID_SIZE - 1)
239 #define MARIA_MIN_TRANSID_PACK_OFFSET (MARIA_TRANSID_PACK_OFFSET-TRANSID_SIZE)
240 #define MARIA_INDEX_OVERHEAD_SIZE (MARIA_MAX_PACK_TRANSID_SIZE * 2 + \
241 MARIA_MAX_POINTER_LENGTH)
242 #define MARIA_DELETE_KEY_NR 255 /* keynr for deleted blocks */
243
244 /* extra options */
245 #define MA_EXTRA_OPTIONS_ENCRYPTED (1 << 0)
246 #define MA_EXTRA_OPTIONS_INSERT_ORDER (1 << 1)
247
248 /*
249 Basic information of the Maria table. This is stored on disk
250 and not changed (unless we do DLL changes).
251 */
252
253 typedef struct st_ma_base_info
254 {
255 my_off_t keystart; /* Start of keys */
256 my_off_t max_data_file_length;
257 my_off_t max_key_file_length;
258 my_off_t margin_key_file_length;
259 ha_rows records, reloc; /* Create information */
260 ulong mean_row_length; /* Create information */
261 ulong reclength; /* length of unpacked record */
262 ulong pack_reclength; /* Length of full packed rec */
263 ulong min_pack_length;
264 ulong max_pack_length; /* Max possibly length of packed rec */
265 ulong min_block_length;
266 uint fields; /* fields in table */
267 uint fixed_not_null_fields;
268 uint fixed_not_null_fields_length;
269 uint max_field_lengths;
270 uint pack_fields; /* packed fields in table */
271 uint varlength_fields; /* char/varchar/blobs */
272 /* Number of bytes in the index used to refer to a row (2-8) */
273 uint rec_reflength;
274 /* Number of bytes in the index used to refer to another index page (2-8) */
275 uint key_reflength; /* = 2-8 */
276 uint keys; /* same as in state.header */
277 uint auto_key; /* Which key-1 is a auto key */
278 uint blobs; /* Number of blobs */
279 /* Length of packed bits (when table was created first time) */
280 uint pack_bytes;
281 /* Length of null bits (when table was created first time) */
282 uint original_null_bytes;
283 uint null_bytes; /* Null bytes in record */
284 uint field_offsets; /* Number of field offsets */
285 uint max_key_block_length; /* Max block length */
286 uint max_key_length; /* Max key length */
287 /* Extra allocation when using dynamic record format */
288 uint extra_alloc_bytes;
289 uint extra_alloc_procent;
290 uint is_nulls_extended; /* 1 if new null bytes */
291 uint default_row_flag; /* 0 or ROW_FLAG_NULLS_EXTENDED */
292 uint block_size;
293 /* Size of initial record buffer */
294 uint default_rec_buff_size;
295 /* Extra number of bytes the row format require in the record buffer */
296 uint extra_rec_buff_size;
297 /* Tuning flags that can be ignored by older Maria versions */
298 uint extra_options;
299 /* default language, not really used but displayed by maria_chk */
300 uint language;
301
302 /* The following are from the header */
303 uint key_parts, all_key_parts;
304 uchar uuid[MY_UUID_SIZE];
305 /**
306 @brief If false, we disable logging, versioning, transaction etc. Observe
307 difference with MARIA_SHARE::now_transactional
308 */
309 my_bool born_transactional;
310 } MARIA_BASE_INFO;
311
312
313 /* Structs used intern in database */
314
315 typedef struct st_maria_blob /* Info of record */
316 {
317 ulong offset; /* Offset to blob in record */
318 uint pack_length; /* Type of packed length */
319 ulong length; /* Calc:ed for each record */
320 } MARIA_BLOB;
321
322
323 typedef struct st_maria_pack
324 {
325 ulong header_length;
326 uint ref_length;
327 uchar version;
328 } MARIA_PACK;
329
330 typedef struct st_maria_file_bitmap
331 {
332 struct st_maria_share *share;
333 uchar *map;
334 pgcache_page_no_t page; /* Page number for current bitmap */
335 pgcache_page_no_t last_bitmap_page; /* Last possible bitmap page */
336 my_bool changed; /* 1 if page needs to be written */
337 my_bool changed_not_flushed; /* 1 if some bitmap is not flushed */
338 my_bool return_first_match; /* Shortcut find_head() */
339 uint used_size; /* Size of bitmap head that is not 0 */
340 uint full_head_size; /* Where to start search for head */
341 uint full_tail_size; /* Where to start search for tail */
342 uint flush_all_requested; /**< If _ma_bitmap_flush_all waiting */
343 uint waiting_for_flush_all_requested; /* If someone is waiting for above */
344 uint non_flushable; /**< 0 if bitmap and log are in sync */
345 uint waiting_for_non_flushable; /* If someone is waiting for above */
346 PAGECACHE_FILE file; /* datafile where bitmap is stored */
347
348 mysql_mutex_t bitmap_lock;
349 mysql_cond_t bitmap_cond; /**< When bitmap becomes flushable */
350 /* Constants, allocated when initiating bitmaps */
351 uint sizes[8]; /* Size per bit combination */
352 uint total_size; /* Total usable size of bitmap page */
353 uint max_total_size; /* Max value for total_size */
354 uint last_total_size; /* Size of bitmap on last_bitmap_page */
355 uint block_size; /* Block size of file */
356 ulong pages_covered; /* Pages covered by bitmap + 1 */
357 DYNAMIC_ARRAY pinned_pages; /**< not-yet-flushable bitmap pages */
358 } MARIA_FILE_BITMAP;
359
360 #define MARIA_CHECKPOINT_LOOKS_AT_ME 1
361 #define MARIA_CHECKPOINT_SHOULD_FREE_ME 2
362 #define MARIA_CHECKPOINT_SEEN_IN_LOOP 4
363
364 typedef struct st_maria_crypt_data MARIA_CRYPT_DATA;
365
366 typedef struct st_maria_share
367 { /* Shared between opens */
368 MARIA_STATE_INFO state;
369 MARIA_STATE_INFO checkpoint_state; /* Copy of saved state by checkpoint */
370 MARIA_BASE_INFO base;
371 MARIA_STATE_HISTORY *state_history;
372 MARIA_KEYDEF ft2_keyinfo; /* Second-level ft-key definition */
373 MARIA_KEYDEF *keyinfo; /* Key definitions */
374 MARIA_UNIQUEDEF *uniqueinfo; /* unique definitions */
375 HA_KEYSEG *keyparts; /* key part info */
376 MARIA_COLUMNDEF *columndef; /* Pointer to column information */
377 MARIA_PACK pack; /* Data about packed records */
378 MARIA_BLOB *blobs; /* Pointer to blobs */
379 uint16 *column_nr; /* Original column order */
380 LEX_STRING unique_file_name; /* realpath() of index file */
381 LEX_STRING data_file_name; /* Resolved path names from symlinks */
382 LEX_STRING index_file_name;
383 LEX_STRING open_file_name; /* parameter to open filename */
384 uchar *file_map; /* mem-map of file if possible */
385 LIST *open_list; /* Tables open with this share */
386 PAGECACHE *pagecache; /* ref to the current key cache */
387 MARIA_DECODE_TREE *decode_trees;
388 /*
389 Previous auto-increment value. Used to verify if we can restore the
390 auto-increment counter if we have to abort an insert (duplicate key).
391 */
392 ulonglong last_auto_increment;
393 uint16 *decode_tables;
394 uint16 id; /**< 2-byte id by which log records refer to the table */
395 /* Called the first time the table instance is opened */
396 my_bool (*once_init)(struct st_maria_share *, File);
397 /* Called when the last instance of the table is closed */
398 my_bool (*once_end)(struct st_maria_share *);
399 /* Is called for every open of the table */
400 my_bool (*init)(MARIA_HA *);
401 /* Is called for every close of the table */
402 void (*end)(MARIA_HA *);
403 /* Called when we want to read a record from a specific position */
404 int (*read_record)(MARIA_HA *, uchar *, MARIA_RECORD_POS);
405 /* Initialize a scan */
406 my_bool (*scan_init)(MARIA_HA *);
407 /* Read next record while scanning */
408 int (*scan)(MARIA_HA *, uchar *, MARIA_RECORD_POS, my_bool);
409 /* End scan */
410 void (*scan_end)(MARIA_HA *);
411 int (*scan_remember_pos)(MARIA_HA *, MARIA_RECORD_POS*);
412 int (*scan_restore_pos)(MARIA_HA *, MARIA_RECORD_POS);
413 /* Pre-write of row (some handlers may do the actual write here) */
414 MARIA_RECORD_POS (*write_record_init)(MARIA_HA *, const uchar *);
415 /* Write record (or accept write_record_init) */
416 my_bool (*write_record)(MARIA_HA *, const uchar *);
417 /* Called when write failed */
418 my_bool (*write_record_abort)(MARIA_HA *);
419 my_bool (*update_record)(MARIA_HA *, MARIA_RECORD_POS,
420 const uchar *, const uchar *);
421 my_bool (*delete_record)(MARIA_HA *, const uchar *record);
422 my_bool (*compare_record)(MARIA_HA *, const uchar *);
423 /* calculate checksum for a row */
424 ha_checksum(*calc_checksum)(MARIA_HA *, const uchar *);
425 /*
426 Calculate checksum for a row during write. May be 0 if we calculate
427 the checksum in write_record_init()
428 */
429 ha_checksum(*calc_write_checksum)(MARIA_HA *, const uchar *);
430 /* calculate checksum for a row during check table */
431 ha_checksum(*calc_check_checksum)(MARIA_HA *, const uchar *);
432 /* Compare a row in memory with a row on disk */
433 my_bool (*compare_unique)(MARIA_HA *, MARIA_UNIQUEDEF *,
434 const uchar *record, MARIA_RECORD_POS pos);
435 my_off_t (*keypos_to_recpos)(struct st_maria_share *share, my_off_t pos);
436 my_off_t (*recpos_to_keypos)(struct st_maria_share *share, my_off_t pos);
437 my_bool (*row_is_visible)(MARIA_HA *);
438
439 /* Mapings to read/write the data file */
440 size_t (*file_read)(MARIA_HA *, uchar *, size_t, my_off_t, myf);
441 size_t (*file_write)(MARIA_HA *, const uchar *, size_t, my_off_t, myf);
442 /* query cache invalidator for merged tables */
443 invalidator_by_filename invalidator;
444 /* query cache invalidator for changing state */
445 invalidator_by_filename chst_invalidator;
446 my_off_t key_del_current; /* delete links for index pages */
447 ulong this_process; /* processid */
448 ulong last_process; /* For table-change-check */
449 ulong last_version; /* Version on start */
450 ulong options; /* Options used */
451 ulong min_pack_length; /* These are used by packed data */
452 ulong max_pack_length;
453 ulong state_diff_length;
454 uint rec_reflength; /* rec_reflength in use now */
455 uint keypage_header;
456 uint32 ftkeys; /* Number of distinct full-text keys
457 + 1 */
458 PAGECACHE_FILE kfile; /* Shared keyfile */
459 File data_file; /* Shared data file */
460 int mode; /* mode of file on open */
461 uint reopen; /* How many times opened */
462 uint in_trans; /* Number of references by trn */
463 uint w_locks, r_locks, tot_locks; /* Number of read/write locks */
464 uint block_size; /* block_size of keyfile & data file*/
465 uint max_index_block_size; /* block_size - end_of_page_info */
466 /* Fixed length part of a packed row in BLOCK_RECORD format */
467 uint base_length;
468 myf write_flag;
469 enum data_file_type data_file_type;
470 enum pagecache_page_type page_type; /* value depending transactional */
471 /**
472 if Checkpoint looking at table; protected by close_lock or THR_LOCK_maria
473 */
474 uint8 in_checkpoint;
475 my_bool temporary;
476 /* Below flag is needed to make log tables work with concurrent insert */
477 my_bool is_log_table;
478 my_bool has_null_fields;
479 my_bool has_varchar_fields; /* If table has varchar fields */
480 /*
481 Set to 1 if open_count was wrong at open. Set to avoid asserts for
482 wrong open count on close.
483 */
484 my_bool open_count_not_zero_on_open;
485
486 my_bool changed, /* If changed since lock */
487 global_changed, /* If changed since open */
488 not_flushed;
489 my_bool internal_table; /* Internal tmp table */
490 my_bool lock_key_trees; /* If we have to lock trees on read */
491 my_bool non_transactional_concurrent_insert;
492 my_bool delay_key_write;
493 my_bool have_rtree;
494 /**
495 @brief if the table is transactional right now. It may have been created
496 transactional (base.born_transactional==TRUE) but with transactionality
497 (logging) temporarily disabled (now_transactional==FALSE). The opposite
498 (FALSE, TRUE) is impossible.
499 */
500 my_bool now_transactional;
501 my_bool have_versioning;
502 my_bool key_del_used; /* != 0 if key_del is locked */
503 my_bool deleting; /* we are going to delete this table */
504 my_bool redo_error_given; /* Used during recovery */
505 my_bool silence_encryption_errors; /* Used during recovery */
506 THR_LOCK lock;
507 void (*lock_restore_status)(void *);
508 /**
509 Protects kfile, dfile, most members of the state, state disk writes,
510 versioning information (like in_trans, state_history).
511 @todo find the exhaustive list.
512 */
513 mysql_mutex_t intern_lock;
514 mysql_mutex_t key_del_lock;
515 mysql_cond_t key_del_cond;
516 /**
517 _Always_ held while closing table; prevents checkpoint from looking at
518 structures freed during closure (like bitmap). If you need close_lock and
519 intern_lock, lock them in this order.
520 */
521 mysql_mutex_t close_lock;
522 my_off_t mmaped_length;
523 uint nonmmaped_inserts; /* counter of writing in
524 non-mmaped area */
525 MARIA_FILE_BITMAP bitmap;
526 mysql_rwlock_t mmap_lock;
527 LSN lsn_of_file_id; /**< LSN of its last LOGREC_FILE_ID */
528
529 /**
530 Crypt data
531 */
532 uint crypt_page_header_space;
533 MARIA_CRYPT_DATA *crypt_data;
534
535 /**
536 Keep of track of last insert page, used to implement insert order
537 */
538 uint last_insert_page;
539 pgcache_page_no_t last_insert_bitmap;
540 } MARIA_SHARE;
541
542
543 typedef uchar MARIA_BITMAP_BUFFER;
544
545 typedef struct st_maria_bitmap_block
546 {
547 pgcache_page_no_t page; /* Page number */
548 /* Number of continuous pages. TAIL_BIT is set if this is a tail page */
549 uint page_count;
550 uint empty_space; /* Set for head and tail pages */
551 /*
552 Number of BLOCKS for block-region (holds all non-blob-fields or one blob)
553 */
554 uint sub_blocks;
555 /* set to <> 0 in write_record() if this block was actually used */
556 uint8 used;
557 uint8 org_bitmap_value;
558 } MARIA_BITMAP_BLOCK;
559
560
561 typedef struct st_maria_bitmap_blocks
562 {
563 MARIA_BITMAP_BLOCK *block;
564 uint count;
565 my_bool tail_page_skipped; /* If some tail pages was not used */
566 my_bool page_skipped; /* If some full pages was not used */
567 } MARIA_BITMAP_BLOCKS;
568
569
570 /* Data about the currently read row */
571 typedef struct st_maria_row
572 {
573 MARIA_BITMAP_BLOCKS insert_blocks;
574 MARIA_BITMAP_BUFFER *extents;
575 MARIA_RECORD_POS lastpos, nextpos;
576 MARIA_RECORD_POS *tail_positions;
577 ha_checksum checksum;
578 LSN orig_undo_lsn; /* Lsn at start of row insert */
579 TrID trid; /* Transaction id for current row */
580 uchar *empty_bits, *field_lengths;
581 uint *null_field_lengths; /* All null field lengths */
582 ulong *blob_lengths; /* Length for each blob */
583 ulong min_length, normal_length, char_length, varchar_length;
584 ulong blob_length, total_length;
585 size_t extents_buffer_length; /* Size of 'extents' buffer */
586 uint head_length, header_length;
587 uint field_lengths_length; /* Length of data in field_lengths */
588 uint extents_count; /* number of extents in 'extents' */
589 uint full_page_count, tail_count; /* For maria_chk */
590 uint space_on_head_page;
591 } MARIA_ROW;
592
593 /* Data to scan row in blocked format */
594 typedef struct st_maria_block_scan
595 {
596 uchar *bitmap_buff, *bitmap_pos, *bitmap_end, *page_buff;
597 uchar *dir, *dir_end;
598 pgcache_page_no_t bitmap_page, max_page;
599 ulonglong bits;
600 uint number_of_rows, bit_pos;
601 MARIA_RECORD_POS row_base_page;
602 ulonglong row_changes;
603 } MARIA_BLOCK_SCAN;
604
605
606 struct st_maria_handler
607 {
608 MARIA_SHARE *s; /* Shared between open:s */
609 struct st_ma_transaction *trn; /* Pointer to active transaction */
610 struct st_maria_handler *trn_next,**trn_prev;
611 MARIA_STATUS_INFO *state, state_save;
612 MARIA_STATUS_INFO *state_start; /* State at start of transaction */
613 MARIA_USED_TABLES *used_tables;
614 MARIA_ROW cur_row; /* The active row that we just read */
615 MARIA_ROW new_row; /* Storage for a row during update */
616 MARIA_KEY last_key; /* Last found key */
617 MARIA_BLOCK_SCAN scan, *scan_save;
618 MARIA_BLOB *blobs; /* Pointer to blobs */
619 MARIA_BIT_BUFF bit_buff;
620 DYNAMIC_ARRAY bitmap_blocks;
621 DYNAMIC_ARRAY pinned_pages;
622 /* accumulate indexfile changes between write's */
623 TREE *bulk_insert;
624 LEX_CUSTRING *log_row_parts; /* For logging */
625 DYNAMIC_ARRAY *ft1_to_ft2; /* used only in ft1->ft2 conversion */
626 MEM_ROOT ft_memroot; /* used by the parser */
627 MYSQL_FTPARSER_PARAM *ftparser_param; /* share info between init/deinit */
628 void *external_ref; /* For MariaDB TABLE */
629 uchar *buff; /* page buffer */
630 uchar *keyread_buff; /* Buffer for last key read */
631 uchar *lastkey_buff; /* Last used search key */
632 uchar *lastkey_buff2;
633 uchar *first_mbr_key; /* Searhed spatial key */
634 uchar *rec_buff; /* Temp buffer for recordpack */
635 uchar *blob_buff; /* Temp buffer for blobs */
636 uchar *int_keypos; /* Save position for next/previous */
637 uchar *int_maxpos; /* -""- */
638 uint keypos_offset; /* Tmp storage for offset int_keypos */
639 uint maxpos_offset; /* Tmp storage for offset int_maxpos */
640 uchar *update_field_data; /* Used by update in rows-in-block */
641 uint int_nod_flag; /* -""- */
642 uint32 int_keytree_version; /* -""- */
643 int (*read_record)(MARIA_HA *, uchar*, MARIA_RECORD_POS);
644 invalidator_by_filename invalidator; /* query cache invalidator */
645 ulonglong last_auto_increment; /* auto value at start of statement */
646 ulonglong row_changes; /* Incremented for each change */
647 ulonglong start_row_changes; /* Row changes since start trans */
648 ulong this_unique; /* uniq filenumber or thread */
649 ulong last_unique; /* last unique number */
650 ulong this_loop; /* counter for this open */
651 ulong last_loop; /* last used counter */
652 MARIA_RECORD_POS save_lastpos;
653 MARIA_RECORD_POS dup_key_pos;
654 TrID dup_key_trid;
655 my_off_t pos; /* Intern variable */
656 my_off_t last_keypage; /* Last key page read */
657 my_off_t last_search_keypage; /* Last keypage when searching */
658
659 /*
660 QQ: the folloing two xxx_length fields should be removed,
661 as they are not compatible with parallel repair
662 */
663 ulong packed_length, blob_length; /* Length of found, packed record */
664 size_t rec_buff_size, blob_buff_size;
665 PAGECACHE_FILE dfile; /* The datafile */
666 IO_CACHE rec_cache; /* When cacheing records */
667 LIST open_list;
668 LIST share_list;
669 MY_BITMAP changed_fields;
670 ulong row_base_length; /* Length of row header */
671 uint row_flag; /* Flag to store in row header */
672 uint opt_flag; /* Optim. for space/speed */
673 uint open_flags; /* Flags used in open() */
674 uint update; /* If file changed since open */
675 int lastinx; /* Last used index */
676 uint last_rkey_length; /* Last length in maria_rkey() */
677 uint *last_rtree_keypos; /* Last key positions for rtrees */
678 uint bulk_insert_ref_length; /* Lenght of row ref during bi */
679 uint non_flushable_state;
680 enum ha_rkey_function last_key_func; /* CONTAIN, OVERLAP, etc */
681 uint save_lastkey_data_length;
682 uint save_lastkey_ref_length;
683 uint pack_key_length; /* For MARIA_MRG */
684 myf lock_wait; /* is 0 or MY_SHORT_WAIT */
685 int errkey; /* Got last error on this key */
686 int lock_type; /* How database was locked */
687 int tmp_lock_type; /* When locked by readinfo */
688 uint data_changed; /* Somebody has changed data */
689 uint save_update; /* When using KEY_READ */
690 int save_lastinx;
691 uint preload_buff_size; /* When preloading indexes */
692 uint16 last_used_keyseg; /* For MARIAMRG */
693 uint8 key_del_used; /* != 0 if key_del is used */
694 my_bool was_locked; /* Was locked in panic */
695 my_bool intern_lock_locked; /* locked in ma_extra() */
696 my_bool append_insert_at_end; /* Set if concurrent insert */
697 my_bool quick_mode;
698 my_bool in_check_table; /* We are running check tables */
699 /* Marker if key_del_changed */
700 /* If info->keyread_buff can't be used for rnext */
701 my_bool page_changed;
702 /* If info->keyread_buff has to be re-read for rnext */
703 my_bool keyread_buff_used;
704 my_bool once_flags; /* For MARIA_MRG */
705 /* For bulk insert enable/disable transactions control */
706 my_bool switched_transactional;
707 #ifdef _WIN32
708 my_bool owned_by_merge; /* This Maria table is part of a merge union */
709 #endif
710 THR_LOCK_DATA lock;
711 uchar *maria_rtree_recursion_state; /* For RTREE */
712 uchar length_buff[5]; /* temp buff to store blob lengths */
713 int maria_rtree_recursion_depth;
714
715 my_bool create_unique_index_by_sort;
716 index_cond_func_t index_cond_func; /* Index condition function */
717 void *index_cond_func_arg; /* parameter for the func */
718 };
719
720 /* Some defines used by maria-functions */
721
722 #define USE_WHOLE_KEY 65535 /* Use whole key in _search() */
723 #define F_EXTRA_LCK -1
724
725 /* bits in opt_flag */
726 #define MEMMAP_USED 32U
727 #define REMEMBER_OLD_POS 64U
728
729 #define WRITEINFO_UPDATE_KEYFILE 1U
730 #define WRITEINFO_NO_UNLOCK 2U
731
732 /* once_flags */
733 #define USE_PACKED_KEYS 1U
734 #define RRND_PRESERVE_LASTINX 2U
735
736 /* bits in state.changed */
737
738 #define STATE_CHANGED 1U
739 #define STATE_CRASHED 2U
740 #define STATE_CRASHED_ON_REPAIR 4U
741 #define STATE_NOT_ANALYZED 8U
742 #define STATE_NOT_OPTIMIZED_KEYS 16U
743 #define STATE_NOT_SORTED_PAGES 32U
744 #define STATE_NOT_OPTIMIZED_ROWS 64U
745 #define STATE_NOT_ZEROFILLED 128U
746 #define STATE_NOT_MOVABLE 256U
747 #define STATE_MOVED 512U /* set if base->uuid != maria_uuid */
748 #define STATE_IN_REPAIR 1024U /* We are running repair on table */
749 #define STATE_CRASHED_PRINTED 2048U
750 #define STATE_DATA_FILE_FULL 4096U
751
752 #define STATE_CRASHED_FLAGS (STATE_CRASHED | STATE_CRASHED_ON_REPAIR | STATE_CRASHED_PRINTED)
753
754 /* options to maria_read_cache */
755
756 #define READING_NEXT 1U
757 #define READING_HEADER 2U
758
759 /* Number of bytes on key pages to indicate used size */
760 #define KEYPAGE_USED_SIZE 2U
761 #define KEYPAGE_KEYID_SIZE 1U
762 #define KEYPAGE_FLAG_SIZE 1U
763 #define KEYPAGE_KEY_VERSION_SIZE 4U /* encryption */
764 #define KEYPAGE_CHECKSUM_SIZE 4U
765 #define MAX_KEYPAGE_HEADER_SIZE (LSN_STORE_SIZE + KEYPAGE_USED_SIZE + \
766 KEYPAGE_KEYID_SIZE + KEYPAGE_FLAG_SIZE + \
767 TRANSID_SIZE + KEYPAGE_KEY_VERSION_SIZE)
768 #define KEYPAGE_FLAG_ISNOD 1U
769 #define KEYPAGE_FLAG_HAS_TRANSID 2U
770
771 #define _ma_get_page_used(share,x) \
772 ((uint) mi_uint2korr((x) + (share)->keypage_header - KEYPAGE_USED_SIZE))
773 #define _ma_store_page_used(share,x,y) \
774 mi_int2store((x) + (share)->keypage_header - KEYPAGE_USED_SIZE, (y))
775 #define _ma_get_keypage_flag(share,x) x[(share)->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]
776 #define _ma_test_if_nod(share,x) \
777 ((_ma_get_keypage_flag(share,x) & KEYPAGE_FLAG_ISNOD) ? (share)->base.key_reflength : 0)
778
779 #define _ma_store_keynr(share, x, nr) x[(share)->keypage_header - KEYPAGE_KEYID_SIZE - KEYPAGE_FLAG_SIZE - KEYPAGE_USED_SIZE]= (nr)
780 #define _ma_get_keynr(share, x) ((uchar) x[(share)->keypage_header - KEYPAGE_KEYID_SIZE - KEYPAGE_FLAG_SIZE - KEYPAGE_USED_SIZE])
781 #define _ma_store_transid(buff, transid) \
782 transid_store((buff) + LSN_STORE_SIZE, (transid))
783 #define _ma_korr_transid(buff) \
784 transid_korr((buff) + LSN_STORE_SIZE)
785 #define _ma_store_keypage_flag(share,x,flag) x[(share)->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]= (flag)
786 #define _ma_mark_page_with_transid(share, page) \
787 do { (page)->flag|= KEYPAGE_FLAG_HAS_TRANSID; \
788 (page)->buff[(share)->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]= (page)->flag; } while (0)
789
790 #define KEYPAGE_KEY_VERSION(share, x) ((x) + \
791 (share)->keypage_header - \
792 (KEYPAGE_USED_SIZE + \
793 KEYPAGE_FLAG_SIZE + \
794 KEYPAGE_KEYID_SIZE + \
795 KEYPAGE_KEY_VERSION_SIZE))
796
797 #define _ma_get_key_version(share,x) \
798 ((uint) uint4korr(KEYPAGE_KEY_VERSION((share), (x))))
799
800 #define _ma_store_key_version(share,x,kv) \
801 int4store(KEYPAGE_KEY_VERSION((share), (x)), (kv))
802
803 /*
804 TODO: write int4store_aligned as *((uint32 *) (T))= (uint32) (A) for
805 architectures where it is possible
806 */
807 #define int4store_aligned(A,B) int4store((A),(B))
808
809 #define maria_mark_crashed(x) do{(x)->s->state.changed|= STATE_CRASHED; \
810 DBUG_PRINT("error", ("Marked table crashed")); \
811 }while(0)
812 #define maria_mark_crashed_share(x) \
813 do{(x)->state.changed|= STATE_CRASHED; \
814 DBUG_PRINT("error", ("Marked table crashed")); \
815 }while(0)
816 #define maria_mark_crashed_on_repair(x) do{(x)->s->state.changed|= \
817 STATE_CRASHED|STATE_CRASHED_ON_REPAIR; \
818 (x)->update|= HA_STATE_CHANGED; \
819 DBUG_PRINT("error", ("Marked table crashed on repair")); \
820 }while(0)
821 #define maria_mark_in_repair(x) do{(x)->s->state.changed|= \
822 STATE_CRASHED | STATE_IN_REPAIR; \
823 (x)->update|= HA_STATE_CHANGED; \
824 DBUG_PRINT("error", ("Marked table crashed for repair")); \
825 }while(0)
826 #define maria_is_crashed(x) ((x)->s->state.changed & STATE_CRASHED)
827 #define maria_is_crashed_on_repair(x) ((x)->s->state.changed & STATE_CRASHED_ON_REPAIR)
828 #define maria_in_repair(x) ((x)->s->state.changed & STATE_IN_REPAIR)
829
830 #ifdef EXTRA_DEBUG
831 /**
832 Brings additional information in certain debug builds and in standalone
833 (non-ha_maria) programs. To help debugging. Not in ha_maria, to not spam the
834 user (some messages can be produced many times per statement, or even
835 wrongly during some repair operations).
836 */
837 #define maria_print_error(SHARE, ERRNO) \
838 do{ if (!maria_in_ha_maria) \
839 _ma_report_error((ERRNO), &(SHARE)->index_file_name); } \
840 while(0)
841 #else
842 #define maria_print_error(SHARE, ERRNO) while (0)
843 #endif
844 #define DBUG_DUMP_KEY(name, key) DBUG_DUMP(name, (key)->data, (key)->data_length + (key)->ref_length)
845
846 /* Functions to store length of space packed keys, VARCHAR or BLOB keys */
847
848 #define store_key_length(key,length) \
849 { if ((length) < 255) \
850 { *(key)=(length); } \
851 else \
852 { *(key)=255; mi_int2store((key)+1,(length)); } \
853 }
854
855 #define get_key_full_length(length,key) \
856 { if (*(const uchar*) (key) != 255) \
857 length= ((uint) *(const uchar*) ((key)++))+1; \
858 else \
859 { length=mi_uint2korr((key)+1)+3; (key)+=3; } \
860 }
861
862 #define get_key_full_length_rdonly(length,key) \
863 { if (*(const uchar*) (key) != 255) \
864 length= ((uint) *(const uchar*) ((key)))+1; \
865 else \
866 { length=mi_uint2korr((key)+1)+3; } \
867 }
868
869 #define _ma_max_key_length() ((maria_block_size - MAX_KEYPAGE_HEADER_SIZE)/3 - MARIA_INDEX_OVERHEAD_SIZE)
870 #define get_pack_length(length) ((length) >= 255 ? 3 : 1)
871 #define _ma_have_versioning(info) ((info)->row_flag & ROW_FLAG_TRANSID)
872
873 #define MARIA_MIN_BLOCK_LENGTH 20 /* Because of delete-link */
874 /* Don't use to small record-blocks */
875 #define MARIA_EXTEND_BLOCK_LENGTH 20
876 #define MARIA_SPLIT_LENGTH ((MARIA_EXTEND_BLOCK_LENGTH+4)*2)
877 /* Max prefix of record-block */
878 #define MARIA_MAX_DYN_BLOCK_HEADER 20
879 #define MARIA_BLOCK_INFO_HEADER_LENGTH 20
880 #define MARIA_DYN_DELETE_BLOCK_HEADER 20 /* length of delete-block-header */
881 #define MARIA_DYN_MAX_BLOCK_LENGTH ((1L << 24)-4L)
882 #define MARIA_DYN_MAX_ROW_LENGTH (MARIA_DYN_MAX_BLOCK_LENGTH - MARIA_SPLIT_LENGTH)
883 #define MARIA_DYN_ALIGN_SIZE 4 /* Align blocks on this */
884 #define MARIA_MAX_DYN_HEADER_BYTE 13 /* max header uchar for dynamic rows */
885 #define MARIA_MAX_BLOCK_LENGTH ((((ulong) 1 << 24)-1) & (~ (ulong) (MARIA_DYN_ALIGN_SIZE-1)))
886 #define MARIA_REC_BUFF_OFFSET ALIGN_SIZE(MARIA_DYN_DELETE_BLOCK_HEADER+sizeof(uint32))
887
888 #define MEMMAP_EXTRA_MARGIN 7 /* Write this as a suffix for file */
889
890 #define PACK_TYPE_SELECTED 1U /* Bits in field->pack_type */
891 #define PACK_TYPE_SPACE_FIELDS 2U
892 #define PACK_TYPE_ZERO_FILL 4U
893 #define MARIA_FOUND_WRONG_KEY 32768U /* Impossible value from ha_key_cmp */
894
895 #define MARIA_BLOCK_SIZE(key_length,data_pointer,key_pointer,block_size) (((((key_length)+(data_pointer)+(key_pointer))*4+(key_pointer)+2)/(block_size)+1)*(block_size))
896 #define MARIA_MAX_KEYPTR_SIZE 5 /* For calculating block lengths */
897
898 /* Marker for impossible delete link */
899 #define IMPOSSIBLE_PAGE_NO 0xFFFFFFFFFFLL
900
901 /* The UNIQUE check is done with a hashed long key */
902
903 #define MARIA_UNIQUE_HASH_TYPE HA_KEYTYPE_ULONG_INT
904 #define maria_unique_store(A,B) mi_int4store((A),(B))
905
906 extern mysql_mutex_t THR_LOCK_maria;
907 #ifdef DONT_USE_RW_LOCKS
908 #define mysql_rwlock_wrlock(A) {}
909 #define mysql_rwlock_rdlock(A) {}
910 #define mysql_rwlock_unlock(A) {}
911 #endif
912
913 /* Some tuning parameters */
914 #define MARIA_MIN_KEYBLOCK_LENGTH 50 /* When to split delete blocks */
915 #define MARIA_MIN_SIZE_BULK_INSERT_TREE 16384U /* this is per key */
916 #define MARIA_MIN_ROWS_TO_USE_BULK_INSERT 100
917 #define MARIA_MIN_ROWS_TO_DISABLE_INDEXES 100
918 #define MARIA_MIN_ROWS_TO_USE_WRITE_CACHE 10
919 /* Keep a small buffer for tables only using small blobs */
920 #define MARIA_SMALL_BLOB_BUFFER 1024U
921 #define MARIA_MAX_CONTROL_FILE_LOCK_RETRY 30 /* Retry this many times */
922
923 /* Some extern variables */
924 extern LIST *maria_open_list;
925 extern uchar maria_file_magic[], maria_pack_file_magic[];
926 extern uchar maria_uuid[MY_UUID_SIZE];
927 extern uint32 maria_read_vec[], maria_readnext_vec[];
928 extern uint maria_quick_table_bits;
929 extern char *maria_data_root;
930 extern uchar maria_zero_string[];
931 extern my_bool maria_inited, maria_in_ha_maria, maria_recovery_changed_data;
932 extern my_bool maria_recovery_verbose, maria_checkpoint_disabled;
933 extern my_bool maria_assert_if_crashed_table;
934 extern ulong maria_checkpoint_min_log_activity;
935 extern HASH maria_stored_state;
936 extern int (*maria_create_trn_hook)(MARIA_HA *);
937 extern my_bool (*ma_killed)(MARIA_HA *);
938
939 #ifdef HAVE_PSI_INTERFACE
940 extern PSI_mutex_key key_SHARE_BITMAP_lock, key_SORT_INFO_mutex,
941 key_THR_LOCK_maria, key_TRANSLOG_BUFFER_mutex,
942 key_LOCK_soft_sync,
943 key_TRANSLOG_DESCRIPTOR_dirty_buffer_mask_lock,
944 key_TRANSLOG_DESCRIPTOR_sent_to_disk_lock,
945 key_TRANSLOG_DESCRIPTOR_log_flush_lock,
946 key_TRANSLOG_DESCRIPTOR_file_header_lock,
947 key_TRANSLOG_DESCRIPTOR_unfinished_files_lock,
948 key_TRANSLOG_DESCRIPTOR_purger_lock,
949 key_SHARE_intern_lock, key_SHARE_key_del_lock,
950 key_SHARE_close_lock,
951 key_SERVICE_THREAD_CONTROL_lock,
952 key_PAGECACHE_cache_lock;
953
954 extern PSI_mutex_key key_CRYPT_DATA_lock;
955
956 extern PSI_cond_key key_SHARE_key_del_cond, key_SERVICE_THREAD_CONTROL_cond,
957 key_SORT_INFO_cond, key_SHARE_BITMAP_cond,
958 key_COND_soft_sync, key_TRANSLOG_BUFFER_waiting_filling_buffer,
959 key_TRANSLOG_BUFFER_prev_sent_to_disk_cond,
960 key_TRANSLOG_DESCRIPTOR_log_flush_cond,
961 key_TRANSLOG_DESCRIPTOR_new_goal_cond;
962
963 extern PSI_rwlock_key key_KEYINFO_root_lock, key_SHARE_mmap_lock,
964 key_TRANSLOG_DESCRIPTOR_open_files_lock;
965
966 extern PSI_thread_key key_thread_checkpoint, key_thread_find_all_keys,
967 key_thread_soft_sync;
968
969 extern PSI_file_key key_file_translog, key_file_kfile, key_file_dfile,
970 key_file_control, key_file_tmp;
971
972 #endif
973
974 /* Note that PSI_stage_info globals must always be declared. */
975 extern PSI_stage_info stage_waiting_for_a_resource;
976
977 /* This is used by _ma_calc_xxx_key_length och _ma_store_key */
978 typedef struct st_maria_s_param
979 {
980 const uchar *key;
981 uchar *prev_key, *next_key_pos;
982 uchar *key_pos; /* For balance page */
983 uint ref_length, key_length, n_ref_length;
984 uint n_length, totlength, part_of_prev_key, prev_length, pack_marker;
985 uint changed_length;
986 int move_length; /* For balance_page */
987 my_bool store_not_null;
988 } MARIA_KEY_PARAM;
989
990
991 /* Used to store reference to pinned page */
992 typedef struct st_pinned_page
993 {
994 PAGECACHE_BLOCK_LINK *link;
995 enum pagecache_page_lock unlock, write_lock;
996 my_bool changed;
997 } MARIA_PINNED_PAGE;
998
999
1000 /* Keeps all information about a page and related to a page */
1001 typedef struct st_maria_page
1002 {
1003 MARIA_HA *info;
1004 const MARIA_KEYDEF *keyinfo;
1005 uchar *buff; /* Data for page */
1006 my_off_t pos; /* Disk address to page */
1007 uint size; /* Size of data on page */
1008 uint org_size; /* Size of page at read or after log */
1009 uint node; /* 0 or share->base.key_reflength */
1010 uint flag; /* Page flag */
1011 uint link_offset;
1012 } MARIA_PAGE;
1013
1014
1015 /* Prototypes for intern functions */
1016 extern int _ma_read_dynamic_record(MARIA_HA *, uchar *, MARIA_RECORD_POS);
1017 extern int _ma_read_rnd_dynamic_record(MARIA_HA *, uchar *, MARIA_RECORD_POS,
1018 my_bool);
1019 extern my_bool _ma_write_dynamic_record(MARIA_HA *, const uchar *);
1020 extern my_bool _ma_update_dynamic_record(MARIA_HA *, MARIA_RECORD_POS,
1021 const uchar *, const uchar *);
1022 extern my_bool _ma_delete_dynamic_record(MARIA_HA *info, const uchar *record);
1023 extern my_bool _ma_cmp_dynamic_record(MARIA_HA *info, const uchar *record);
1024 extern my_bool _ma_write_blob_record(MARIA_HA *, const uchar *);
1025 extern my_bool _ma_update_blob_record(MARIA_HA *, MARIA_RECORD_POS,
1026 const uchar *, const uchar *);
1027 extern int _ma_read_static_record(MARIA_HA *info, uchar *, MARIA_RECORD_POS);
1028 extern int _ma_read_rnd_static_record(MARIA_HA *, uchar *, MARIA_RECORD_POS,
1029 my_bool);
1030 extern my_bool _ma_write_static_record(MARIA_HA *, const uchar *);
1031 extern my_bool _ma_update_static_record(MARIA_HA *, MARIA_RECORD_POS,
1032 const uchar *, const uchar *);
1033 extern my_bool _ma_delete_static_record(MARIA_HA *info, const uchar *record);
1034 extern my_bool _ma_cmp_static_record(MARIA_HA *info, const uchar *record);
1035
1036 extern my_bool _ma_write_no_record(MARIA_HA *info, const uchar *record);
1037 extern my_bool _ma_update_no_record(MARIA_HA *info, MARIA_RECORD_POS pos,
1038 const uchar *oldrec, const uchar *record);
1039 extern my_bool _ma_delete_no_record(MARIA_HA *info, const uchar *record);
1040 extern int _ma_read_no_record(MARIA_HA *info, uchar *record,
1041 MARIA_RECORD_POS pos);
1042 extern int _ma_read_rnd_no_record(MARIA_HA *info, uchar *buf,
1043 MARIA_RECORD_POS filepos,
1044 my_bool skip_deleted_blocks);
1045 my_off_t _ma_no_keypos_to_recpos(MARIA_SHARE *share, my_off_t pos);
1046
1047 extern my_bool _ma_ck_write(MARIA_HA *info, MARIA_KEY *key);
1048 extern my_bool _ma_enlarge_root(MARIA_HA *info, MARIA_KEY *key,
1049 MARIA_RECORD_POS *root);
1050 int _ma_insert(MARIA_HA *info, MARIA_KEY *key,
1051 MARIA_PAGE *anc_page, uchar *key_pos, uchar *key_buff,
1052 MARIA_PAGE *father_page, uchar *father_key_pos,
1053 my_bool insert_last);
1054 extern my_bool _ma_ck_real_write_btree(MARIA_HA *info, MARIA_KEY *key,
1055 MARIA_RECORD_POS *root, uint32 comp_flag);
1056 extern int _ma_split_page(MARIA_HA *info, MARIA_KEY *key,
1057 MARIA_PAGE *split_page,
1058 uint org_split_length,
1059 uchar *inserted_key_pos, uint changed_length,
1060 int move_length,
1061 uchar *key_buff, my_bool insert_last_key);
1062 extern uchar *_ma_find_half_pos(MARIA_KEY *key, MARIA_PAGE *page,
1063 uchar ** after_key);
1064 extern int _ma_calc_static_key_length(const MARIA_KEY *key, uint nod_flag,
1065 uchar *key_pos, uchar *org_key,
1066 uchar *key_buff,
1067 MARIA_KEY_PARAM *s_temp);
1068 extern int _ma_calc_var_key_length(const MARIA_KEY *key, uint nod_flag,
1069 uchar *key_pos, uchar *org_key,
1070 uchar *key_buff,
1071 MARIA_KEY_PARAM *s_temp);
1072 extern int _ma_calc_var_pack_key_length(const MARIA_KEY *key,
1073 uint nod_flag, uchar *next_key,
1074 uchar *org_key, uchar *prev_key,
1075 MARIA_KEY_PARAM *s_temp);
1076 extern int _ma_calc_bin_pack_key_length(const MARIA_KEY *key,
1077 uint nod_flag, uchar *next_key,
1078 uchar *org_key, uchar *prev_key,
1079 MARIA_KEY_PARAM *s_temp);
1080 extern void _ma_store_static_key(MARIA_KEYDEF *keyinfo, uchar *key_pos,
1081 MARIA_KEY_PARAM *s_temp);
1082 extern void _ma_store_var_pack_key(MARIA_KEYDEF *keyinfo, uchar *key_pos,
1083 MARIA_KEY_PARAM *s_temp);
1084 #ifdef NOT_USED
1085 extern void _ma_store_pack_key(MARIA_KEYDEF *keyinfo, uchar *key_pos,
1086 MARIA_KEY_PARAM *s_temp);
1087 #endif
1088 extern void _ma_store_bin_pack_key(MARIA_KEYDEF *keyinfo, uchar *key_pos,
1089 MARIA_KEY_PARAM *s_temp);
1090
1091 extern my_bool _ma_ck_delete(MARIA_HA *info, MARIA_KEY *key);
1092 extern my_bool _ma_ck_real_delete(MARIA_HA *info, MARIA_KEY *key,
1093 my_off_t *root);
1094 extern int _ma_readinfo(MARIA_HA *info, int lock_flag, int check_keybuffer);
1095 extern int _ma_writeinfo(MARIA_HA *info, uint options);
1096 extern int _ma_test_if_changed(MARIA_HA *info);
1097 extern int _ma_mark_file_changed(MARIA_SHARE *info);
1098 extern int _ma_mark_file_changed_now(MARIA_SHARE *info);
1099 extern void _ma_mark_file_crashed(MARIA_SHARE *share);
1100 void _ma_set_fatal_error(MARIA_SHARE *share, int error);
1101 extern my_bool _ma_set_uuid(MARIA_SHARE *info, my_bool reset_uuid);
1102 extern my_bool _ma_check_if_zero(uchar *pos, size_t size);
1103 extern int _ma_decrement_open_count(MARIA_HA *info, my_bool lock_table);
1104 extern int _ma_check_index(MARIA_HA *info, int inx);
1105 extern int _ma_search(MARIA_HA *info, MARIA_KEY *key, uint32 nextflag,
1106 my_off_t pos);
1107 extern int _ma_bin_search(const MARIA_KEY *key, const MARIA_PAGE *page,
1108 uint32 comp_flag, uchar **ret_pos, uchar *buff,
1109 my_bool *was_last_key);
1110 extern int _ma_seq_search(const MARIA_KEY *key, const MARIA_PAGE *page,
1111 uint comp_flag, uchar ** ret_pos, uchar *buff,
1112 my_bool *was_last_key);
1113 extern int _ma_prefix_search(const MARIA_KEY *key, const MARIA_PAGE *page,
1114 uint32 comp_flag, uchar ** ret_pos, uchar *buff,
1115 my_bool *was_last_key);
1116 extern my_off_t _ma_kpos(uint nod_flag, const uchar *after_key);
1117 extern void _ma_kpointer(MARIA_HA *info, uchar *buff, my_off_t pos);
1118 MARIA_RECORD_POS _ma_row_pos_from_key(const MARIA_KEY *key);
1119 TrID _ma_trid_from_key(const MARIA_KEY *key);
1120 extern MARIA_RECORD_POS _ma_rec_pos(MARIA_SHARE *share, uchar *ptr);
1121 extern void _ma_dpointer(MARIA_SHARE *share, uchar *buff,
1122 MARIA_RECORD_POS pos);
1123 extern uint _ma_get_static_key(MARIA_KEY *key, uint page_flag, uint nod_flag,
1124 uchar **page);
1125 extern uchar *_ma_skip_static_key(MARIA_KEY *key, uint page_flag,
1126 uint nod_flag, uchar *page);
1127 extern uint _ma_get_pack_key(MARIA_KEY *key, uint page_flag, uint nod_flag,
1128 uchar **page);
1129 extern uchar *_ma_skip_pack_key(MARIA_KEY *key, uint page_flag,
1130 uint nod_flag, uchar *page);
1131 extern uint _ma_get_binary_pack_key(MARIA_KEY *key, uint page_flag,
1132 uint nod_flag, uchar **page_pos);
1133 uchar *_ma_skip_binary_pack_key(MARIA_KEY *key, uint page_flag,
1134 uint nod_flag, uchar *page);
1135 extern uchar *_ma_get_last_key(MARIA_KEY *key, MARIA_PAGE *page,
1136 uchar *endpos);
1137 extern uchar *_ma_get_key(MARIA_KEY *key, MARIA_PAGE *page, uchar *keypos);
1138 extern uint _ma_keylength(MARIA_KEYDEF *keyinfo, const uchar *key);
1139 extern uint _ma_keylength_part(MARIA_KEYDEF *keyinfo, const uchar *key,
1140 HA_KEYSEG *end);
1141 extern int _ma_search_next(MARIA_HA *info, MARIA_KEY *key,
1142 uint32 nextflag, my_off_t pos);
1143 extern int _ma_search_first(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
1144 my_off_t pos);
1145 extern int _ma_search_last(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
1146 my_off_t pos);
1147 extern my_off_t _ma_static_keypos_to_recpos(MARIA_SHARE *share, my_off_t pos);
1148 extern my_off_t _ma_static_recpos_to_keypos(MARIA_SHARE *share, my_off_t pos);
1149 extern my_off_t _ma_transparent_recpos(MARIA_SHARE *share, my_off_t pos);
1150 extern my_off_t _ma_transaction_keypos_to_recpos(MARIA_SHARE *, my_off_t pos);
1151 extern my_off_t _ma_transaction_recpos_to_keypos(MARIA_SHARE *, my_off_t pos);
1152
1153 extern void _ma_page_setup(MARIA_PAGE *page, MARIA_HA *info,
1154 const MARIA_KEYDEF *keyinfo, my_off_t pos,
1155 uchar *buff);
1156 extern my_bool _ma_fetch_keypage(MARIA_PAGE *page, MARIA_HA *info,
1157 const MARIA_KEYDEF *keyinfo,
1158 my_off_t pos, enum pagecache_page_lock lock,
1159 int level, uchar *buff,
1160 my_bool return_buffer);
1161 extern my_bool _ma_write_keypage(MARIA_PAGE *page,
1162 enum pagecache_page_lock lock, int level);
1163 extern int _ma_dispose(MARIA_HA *info, my_off_t pos, my_bool page_not_read);
1164 extern my_off_t _ma_new(MARIA_HA *info, int level,
1165 MARIA_PINNED_PAGE **page_link);
1166 extern my_bool _ma_compact_keypage(MARIA_PAGE *page, TrID min_read_from);
1167 extern uint transid_store_packed(MARIA_HA *info, uchar *to, ulonglong trid);
1168 extern ulonglong transid_get_packed(MARIA_SHARE *share, const uchar *from);
1169 #define transid_packed_length(data) \
1170 ((data)[0] < MARIA_MIN_TRANSID_PACK_OFFSET ? 1 : \
1171 (uint) ((uchar) (data)[0]) - (MARIA_TRANSID_PACK_OFFSET - 1))
1172 #define key_has_transid(key) (*(key) & 1)
1173
1174 #define page_mark_changed(info, page) \
1175 dynamic_element(&(info)->pinned_pages, (page)->link_offset, \
1176 MARIA_PINNED_PAGE*)->changed= 1;
1177 #define page_store_size(share, page) \
1178 _ma_store_page_used((share), (page)->buff, (page)->size);
1179 #define page_store_info(share, page) \
1180 _ma_store_keypage_flag((share), (page)->buff, (page)->flag); \
1181 _ma_store_page_used((share), (page)->buff, (page)->size);
1182 #ifdef IDENTICAL_PAGES_AFTER_RECOVERY
1183 void page_cleanup(MARIA_SHARE *share, MARIA_PAGE *page)
1184 #else
1185 #define page_cleanup(A,B) do { } while (0)
1186 #endif
1187
1188 extern MARIA_KEY *_ma_make_key(MARIA_HA *info, MARIA_KEY *int_key, uint keynr,
1189 uchar *key, const uchar *record,
1190 MARIA_RECORD_POS filepos, ulonglong trid);
1191 extern MARIA_KEY *_ma_pack_key(MARIA_HA *info, MARIA_KEY *int_key,
1192 uint keynr, uchar *key,
1193 const uchar *old, key_part_map keypart_map,
1194 HA_KEYSEG ** last_used_keyseg);
1195 extern void _ma_copy_key(MARIA_KEY *to, const MARIA_KEY *from);
1196 extern int _ma_read_key_record(MARIA_HA *info, uchar *buf, MARIA_RECORD_POS);
1197 extern my_bool _ma_read_cache(MARIA_HA *, IO_CACHE *info, uchar *buff,
1198 MARIA_RECORD_POS pos, size_t length,
1199 uint re_read_if_possibly);
1200 extern ulonglong ma_retrieve_auto_increment(const uchar *key, uint8 key_type);
1201 extern my_bool _ma_alloc_buffer(uchar **old_addr, size_t *old_size,
1202 size_t new_size, myf flag);
1203 extern size_t _ma_rec_unpack(MARIA_HA *info, uchar *to, uchar *from,
1204 size_t reclength);
1205 extern my_bool _ma_rec_check(MARIA_HA *info, const uchar *record,
1206 uchar *packpos, ulong packed_length,
1207 my_bool with_checkum, ha_checksum checksum);
1208 extern int _ma_write_part_record(MARIA_HA *info, my_off_t filepos,
1209 ulong length, my_off_t next_filepos,
1210 uchar ** record, ulong *reclength,
1211 int *flag);
1212 extern void _ma_print_key(FILE *stream, MARIA_KEY *key);
1213 extern void _ma_print_keydata(FILE *stream, HA_KEYSEG *keyseg,
1214 const uchar *key, uint length);
1215 extern my_bool _ma_once_init_pack_row(MARIA_SHARE *share, File dfile);
1216 extern my_bool _ma_once_end_pack_row(MARIA_SHARE *share);
1217 extern int _ma_read_pack_record(MARIA_HA *info, uchar *buf,
1218 MARIA_RECORD_POS filepos);
1219 extern int _ma_read_rnd_pack_record(MARIA_HA *, uchar *, MARIA_RECORD_POS,
1220 my_bool);
1221 extern int _ma_pack_rec_unpack(MARIA_HA *info, MARIA_BIT_BUFF *bit_buff,
1222 uchar *to, uchar *from, ulong reclength);
1223 extern ulonglong _ma_safe_mul(ulonglong a, ulonglong b);
1224 extern int _ma_ft_update(MARIA_HA *info, uint keynr, uchar *keybuf,
1225 const uchar *oldrec, const uchar *newrec,
1226 my_off_t pos);
1227
1228 /*
1229 Parameter to _ma_get_block_info
1230 The dynamic row header is read into this struct. For an explanation of
1231 the fields, look at the function _ma_get_block_info().
1232 */
1233
1234 typedef struct st_maria_block_info
1235 {
1236 uchar header[MARIA_BLOCK_INFO_HEADER_LENGTH];
1237 ulong rec_len;
1238 ulong data_len;
1239 ulong block_len;
1240 ulong blob_len;
1241 MARIA_RECORD_POS filepos;
1242 MARIA_RECORD_POS next_filepos;
1243 MARIA_RECORD_POS prev_filepos;
1244 uint second_read;
1245 uint offset;
1246 } MARIA_BLOCK_INFO;
1247
1248
1249 /* bits in return from _ma_get_block_info */
1250
1251 #define BLOCK_FIRST 1U
1252 #define BLOCK_LAST 2U
1253 #define BLOCK_DELETED 4U
1254 #define BLOCK_ERROR 8U /* Wrong data */
1255 #define BLOCK_SYNC_ERROR 16U /* Right data at wrong place */
1256 #define BLOCK_FATAL_ERROR 32U /* hardware-error */
1257
1258 #define NEED_MEM ((uint) 10*4*(IO_SIZE+32)+32) /* Nead for recursion */
1259 #define MAXERR 20
1260 #define BUFFERS_WHEN_SORTING 16 /* Alloc for sort-key-tree */
1261 #define WRITE_COUNT MY_HOW_OFTEN_TO_WRITE
1262 #define INDEX_TMP_EXT ".TMM"
1263 #define DATA_TMP_EXT ".TMD"
1264
1265 #define UPDATE_TIME 1U
1266 #define UPDATE_STAT 2U
1267 #define UPDATE_SORT 4U
1268 #define UPDATE_AUTO_INC 8U
1269 #define UPDATE_OPEN_COUNT 16U
1270
1271 /* We use MY_ALIGN_DOWN here mainly to ensure that we get stable values for mysqld --help ) */
1272 #define PAGE_BUFFER_INIT MY_ALIGN_DOWN(1024L*1024L*256L-MALLOC_OVERHEAD, 8192)
1273 #define READ_BUFFER_INIT MY_ALIGN_DOWN(1024L*256L-MALLOC_OVERHEAD, 1024)
1274 #define SORT_BUFFER_INIT MY_ALIGN_DOWN(1024L*1024L*256L-MALLOC_OVERHEAD, 1024)
1275 #define MIN_SORT_BUFFER 4096U
1276
1277 #define fast_ma_writeinfo(INFO) if (!(INFO)->s->tot_locks) (void) _ma_writeinfo((INFO),0)
1278 #define fast_ma_readinfo(INFO) ((INFO)->lock_type == F_UNLCK) && _ma_readinfo((INFO),F_RDLCK,1)
1279
1280 extern uint _ma_get_block_info(MARIA_HA *, MARIA_BLOCK_INFO *, File, my_off_t);
1281 extern uint _ma_rec_pack(MARIA_HA *info, uchar *to, const uchar *from);
1282 extern uint _ma_pack_get_block_info(MARIA_HA *maria, MARIA_BIT_BUFF *bit_buff,
1283 MARIA_BLOCK_INFO *info, uchar **rec_buff_p,
1284 size_t *rec_buff_size,
1285 File file, my_off_t filepos);
1286 extern void _ma_store_blob_length(uchar *pos, uint pack_length, uint length);
1287 extern void _ma_report_error(int errcode, const LEX_STRING *file_name);
1288 extern my_bool _ma_memmap_file(MARIA_HA *info);
1289 extern void _ma_unmap_file(MARIA_HA *info);
1290 extern uint _ma_save_pack_length(uint version, uchar * block_buff,
1291 ulong length);
1292 extern uint _ma_calc_pack_length(uint version, ulong length);
1293 extern ulong _ma_calc_blob_length(uint length, const uchar *pos);
1294 extern size_t _ma_mmap_pread(MARIA_HA *info, uchar *Buffer,
1295 size_t Count, my_off_t offset, myf MyFlags);
1296 extern size_t _ma_mmap_pwrite(MARIA_HA *info, const uchar *Buffer,
1297 size_t Count, my_off_t offset, myf MyFlags);
1298 extern size_t _ma_nommap_pread(MARIA_HA *info, uchar *Buffer,
1299 size_t Count, my_off_t offset, myf MyFlags);
1300 extern size_t _ma_nommap_pwrite(MARIA_HA *info, const uchar *Buffer,
1301 size_t Count, my_off_t offset, myf MyFlags);
1302
1303 /* my_pwrite instead of my_write used */
1304 #define MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET 1
1305 /* info should be written */
1306 #define MA_STATE_INFO_WRITE_FULL_INFO 2
1307 /* intern_lock taking is needed */
1308 #define MA_STATE_INFO_WRITE_LOCK 4
1309 uint _ma_state_info_write(MARIA_SHARE *share, uint pWrite);
1310 uint _ma_state_info_write_sub(File file, MARIA_STATE_INFO *state, uint pWrite);
1311 uint _ma_state_info_read_dsk(File file, MARIA_STATE_INFO *state);
1312 uint _ma_base_info_write(File file, MARIA_BASE_INFO *base);
1313 my_bool _ma_keyseg_write(File file, const HA_KEYSEG *keyseg);
1314 uchar *_ma_keyseg_read(uchar *ptr, HA_KEYSEG *keyseg);
1315 my_bool _ma_keydef_write(File file, MARIA_KEYDEF *keydef);
1316 uchar *_ma_keydef_read(uchar *ptr, MARIA_KEYDEF *keydef);
1317 my_bool _ma_uniquedef_write(File file, MARIA_UNIQUEDEF *keydef);
1318 uchar *_ma_uniquedef_read(uchar *ptr, MARIA_UNIQUEDEF *keydef);
1319 my_bool _ma_columndef_write(File file, MARIA_COLUMNDEF *columndef);
1320 uchar *_ma_columndef_read(uchar *ptr, MARIA_COLUMNDEF *columndef);
1321 my_bool _ma_column_nr_write(File file, uint16 *offsets, uint columns);
1322 uchar *_ma_column_nr_read(uchar *ptr, uint16 *offsets, uint columns);
1323 ulong _ma_calc_total_blob_length(MARIA_HA *info, const uchar *record);
1324 ha_checksum _ma_checksum(MARIA_HA *info, const uchar *buf);
1325 ha_checksum _ma_static_checksum(MARIA_HA *info, const uchar *buf);
1326 my_bool _ma_check_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
1327 const uchar *record, ha_checksum unique_hash,
1328 MARIA_RECORD_POS pos);
1329 ha_checksum _ma_unique_hash(MARIA_UNIQUEDEF *def, const uchar *buf);
1330 my_bool _ma_cmp_static_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
1331 const uchar *record, MARIA_RECORD_POS pos);
1332 my_bool _ma_cmp_dynamic_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
1333 const uchar *record, MARIA_RECORD_POS pos);
1334 my_bool _ma_unique_comp(MARIA_UNIQUEDEF *def, const uchar *a, const uchar *b,
1335 my_bool null_are_equal);
1336 void _ma_get_status(void *param, my_bool concurrent_insert);
1337 void _ma_update_status(void *param);
1338 void _ma_restore_status(void *param);
1339 void _ma_copy_status(void *to, void *from);
1340 my_bool _ma_check_status(void *param);
1341 void _ma_restore_status(void *param);
1342 void _ma_reset_status(MARIA_HA *maria);
1343 int _ma_def_scan_remember_pos(MARIA_HA *info, MARIA_RECORD_POS *lastpos);
1344 int _ma_def_scan_restore_pos(MARIA_HA *info, MARIA_RECORD_POS lastpos);
1345
1346 #include "ma_commit.h"
1347
1348 extern MARIA_HA *_ma_test_if_reopen(const char *filename);
1349 my_bool _ma_check_table_is_closed(const char *name, const char *where);
1350 int _ma_open_datafile(MARIA_HA *info, MARIA_SHARE *share);
1351 int _ma_open_keyfile(MARIA_SHARE *share);
1352 void _ma_setup_functions(MARIA_SHARE *share);
1353 my_bool _ma_dynmap_file(MARIA_HA *info, my_off_t size);
1354 void _ma_remap_file(MARIA_HA *info, my_off_t size);
1355
1356 MARIA_RECORD_POS _ma_write_init_default(MARIA_HA *info, const uchar *record);
1357 my_bool _ma_write_abort_default(MARIA_HA *info);
1358 int maria_delete_table_files(const char *name, my_bool temporary,
1359 myf sync_dir);
1360
1361 /*
1362 This cannot be in my_base.h as it clashes with HA_SPATIAL.
1363 But it was introduced for Aria engine, and is only used there.
1364 So it can safely stay here, only visible to Aria
1365 */
1366 #define HA_RTREE_INDEX 16384 /* For RTREE search */
1367
1368 C_MODE_START
1369 #define MARIA_FLUSH_DATA 1
1370 #define MARIA_FLUSH_INDEX 2
1371 int _ma_flush_table_files(MARIA_HA *info, uint flush_data_or_index,
1372 enum flush_type flush_type_for_data,
1373 enum flush_type flush_type_for_index);
1374 /*
1375 Functions needed by _ma_check (are overridden in MySQL/ha_maria.cc).
1376 See ma_check_standalone.h .
1377 */
1378 int _ma_killed_ptr(HA_CHECK *param);
1379 void _ma_report_progress(HA_CHECK *param, ulonglong progress,
1380 ulonglong max_progress);
1381 void _ma_check_print_error(HA_CHECK *param, const char *fmt, ...)
1382 ATTRIBUTE_FORMAT(printf, 2, 3);
1383 void _ma_check_print_warning(HA_CHECK *param, const char *fmt, ...)
1384 ATTRIBUTE_FORMAT(printf, 2, 3);
1385 void _ma_check_print_info(HA_CHECK *param, const char *fmt, ...)
1386 ATTRIBUTE_FORMAT(printf, 2, 3);
1387 my_bool write_log_record_for_repair(const HA_CHECK *param, MARIA_HA *info);
1388 C_MODE_END
1389
1390 int _ma_flush_pending_blocks(MARIA_SORT_PARAM *param);
1391 int _ma_sort_ft_buf_flush(MARIA_SORT_PARAM *sort_param);
1392 int _ma_thr_write_keys(MARIA_SORT_PARAM *sort_param);
1393 pthread_handler_t _ma_thr_find_all_keys(void *arg);
1394
1395 int _ma_sort_write_record(MARIA_SORT_PARAM *sort_param);
1396 int _ma_create_index_by_sort(MARIA_SORT_PARAM *info, my_bool no_messages,
1397 size_t);
1398 int _ma_sync_table_files(const MARIA_HA *info);
1399 int _ma_initialize_data_file(MARIA_SHARE *share, File dfile);
1400 int _ma_update_state_lsns(MARIA_SHARE *share,
1401 LSN lsn, TrID create_trid, my_bool do_sync,
1402 my_bool update_create_rename_lsn);
1403 int _ma_update_state_lsns_sub(MARIA_SHARE *share, LSN lsn,
1404 TrID create_trid, my_bool do_sync,
1405 my_bool update_create_rename_lsn);
1406 void _ma_set_data_pagecache_callbacks(PAGECACHE_FILE *file,
1407 MARIA_SHARE *share);
1408 void _ma_set_index_pagecache_callbacks(PAGECACHE_FILE *file,
1409 MARIA_SHARE *share);
1410 void _ma_tmp_disable_logging_for_table(MARIA_HA *info,
1411 my_bool log_incomplete);
1412 my_bool _ma_reenable_logging_for_table(MARIA_HA *info, my_bool flush_pages);
1413 my_bool write_log_record_for_bulk_insert(MARIA_HA *info);
1414 void _ma_unpin_all_pages(MARIA_HA *info, LSN undo_lsn);
1415
1416 #define MARIA_NO_CRC_NORMAL_PAGE 0xffffffff
1417 #define MARIA_NO_CRC_BITMAP_PAGE 0xfffffffe
1418 extern my_bool maria_page_crc_set_index(PAGECACHE_IO_HOOK_ARGS *args);
1419 extern my_bool maria_page_crc_set_normal(PAGECACHE_IO_HOOK_ARGS *args);
1420 extern my_bool maria_page_crc_check_bitmap(int, PAGECACHE_IO_HOOK_ARGS *args);
1421 extern my_bool maria_page_crc_check_data(int, PAGECACHE_IO_HOOK_ARGS *args);
1422 extern my_bool maria_page_crc_check_index(int, PAGECACHE_IO_HOOK_ARGS *args);
1423 extern my_bool maria_page_crc_check_none(int, PAGECACHE_IO_HOOK_ARGS *args);
1424 extern my_bool maria_page_crc_check(uchar *page, pgcache_page_no_t page_no,
1425 MARIA_SHARE *share, uint32 no_crc_val,
1426 int data_length);
1427 extern my_bool maria_page_filler_set_bitmap(PAGECACHE_IO_HOOK_ARGS *args);
1428 extern my_bool maria_page_filler_set_normal(PAGECACHE_IO_HOOK_ARGS *args);
1429 extern my_bool maria_page_filler_set_none(PAGECACHE_IO_HOOK_ARGS *args);
1430 extern void maria_page_write_failure(int error, PAGECACHE_IO_HOOK_ARGS *args);
1431 extern my_bool maria_flush_log_for_page(PAGECACHE_IO_HOOK_ARGS *args);
1432 extern my_bool maria_flush_log_for_page_none(PAGECACHE_IO_HOOK_ARGS *args);
1433
1434 extern PAGECACHE *maria_log_pagecache;
1435 extern void ma_set_index_cond_func(MARIA_HA *info, index_cond_func_t func,
1436 void *func_arg);
1437 check_result_t ma_check_index_cond(MARIA_HA *info, uint keynr, uchar *record);
1438
1439 extern my_bool ma_yield_and_check_if_killed(MARIA_HA *info, int inx);
1440 extern my_bool ma_killed_standalone(MARIA_HA *);
1441
1442 extern uint _ma_file_callback_to_id(void *callback_data);
1443
unmap_file(MARIA_HA * info)1444 static inline void unmap_file(MARIA_HA *info __attribute__((unused)))
1445 {
1446 #ifdef HAVE_MMAP
1447 if (info->s->file_map)
1448 _ma_unmap_file(info);
1449 #endif
1450 }
1451