mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 04:22:27 +01:00
52cb0c24a6
Store max_trid in index file as state.create_trid. This is used to pack all transids in the index pages relative to max possible transid for file. Enable versioning for transactional tables with index. Tables with an auto-increment key, rtree or fulltext keys are not versioned. Changed info->lastkey to type MARIA_KEY. Removed info->lastkey_length as this is now part of info->lastkey Renamed old info->lastkey to info->lastkey_buff Use exact key lenghts for keys, not USE_WHOLE_KEY For partial key searches, use SEARCH_PART_KEY When searching to insert new key on page, use SEARCH_INSERT to mark that key has rowid Changes done in a lot of files: - Modified functions to use MARIA_KEY instead of key pointer and key length - Use keyinfo->root_lock instead of share->key_root_lock[keynr] - Simplify code by using local variable keyinfo instead if share->keyinfo[i] - Added #fdef EXTERNAL_LOCKING around removed state elements - HA_MAX_KEY_BUFF -> MARIA_MAX_KEY_BUFF (to reserve space for transid) - Changed type of 'nextflag' to uint32 to ensure all SEARCH_xxx flags fits into it .bzrignore: Added missing temporary directory extra/Makefile.am: comp_err is now deleted on make distclean include/maria.h: Added structure MARIA_KEY, which is used for intern key objects in Maria. Changed functions to take MARIA_KEY as an argument instead of pointer to packed key. Changed some functions that always return true or false to my_bool. Added virtual function make_key() to avoid if in _ma_make_key() Moved rw_lock_t for locking trees from share->key_root_lock to MARIA_KEYDEF. This makes usage of the locks simpler and faster include/my_base.h: Added HA_RTREE_INDEX flag to mark rtree index. Used for easier checks in ma_check() Added SEARCH_INSERT to be used when inserting new keys Added SEARCH_PART_KEY for partial searches Added SEARCH_USER_KEY_HAS_TRANSID to be used when key we use for searching in btree has a TRANSID Added SEARCH_PAGE_KEY_HAS_TRANSID to be used when key we found in btree has a transid include/my_handler.h: Make next_flag 32 bit to make sure we can handle all SEARCH_ bits mysql-test/include/maria_empty_logs.inc: Read and restore current database; Don't assume we are using mysqltest. Don't log use databasename to log. Using this include should not cause any result changes. mysql-test/r/maria-gis-rtree-dynamic.result: Updated results after adding some check table commands to help pinpoint errors mysql-test/r/maria-mvcc.result: New tests mysql-test/r/maria-purge.result: New result after adding removal of logs mysql-test/r/maria-recovery-big.result: maria_empty_logs doesn't log 'use mysqltest' anymore mysql-test/r/maria-recovery-bitmap.result: maria_empty_logs doesn't log 'use mysqltest' anymore mysql-test/r/maria-recovery-rtree-ft.result: maria_empty_logs doesn't log 'use mysqltest' anymore mysql-test/r/maria-recovery.result: maria_empty_logs doesn't log 'use mysqltest' anymore mysql-test/r/maria.result: New tests mysql-test/r/variables-big.result: Don't log id as it's not predictable mysql-test/suite/rpl_ndb/r/rpl_truncate_7ndb_2.result: Updated results to new binlog results. (Test has not been run in a long time as it requires --big) mysql-test/suite/rpl_ndb/t/rpl_truncate_7ndb_2-master.opt: Moved file to ndb replication test directory mysql-test/suite/rpl_ndb/t/rpl_truncate_7ndb_2.test: Fixed wrong path to included tests mysql-test/t/maria-gis-rtree-dynamic.test: Added some check table commands to help pinpoint errors mysql-test/t/maria-mvcc.test: New tests mysql-test/t/maria-purge.test: Remove logs to make test results predictable mysql-test/t/maria.test: New tests for some possible problems mysql-test/t/variables-big.test: Don't log id as it's not predictable mysys/my_handler.c: Updated function comment to reflect old code Changed nextflag to be uint32 to ensure we can have flags > 16 bit Changed checking if we are in insert with NULL keys as next_flag can now include additional bits that have to be ignored. Added SEARCH_INSERT flag to be used when inserting new keys in btree. This flag tells us the that the keys includes row position and it's thus safe to remove SEARCH_FIND Added comparision of transid. This is only done if the keys actually have a transid, which is indicated by nextflag mysys/my_lock.c: Fixed wrong test (Found by Guilhem) scripts/Makefile.am: Ensure that test programs are deleted by make clean sql/rpl_rli.cc: Moved assignment order to fix compiler warning storage/heap/hp_write.c: Add SEARCH_INSERT to signal ha_key_cmp that we we should also compare rowid for keys storage/maria/Makefile.am: Remove also maria log files when doing make distclean storage/maria/ha_maria.cc: Use 'file->start_state' as default state for transactional tables without versioning At table unlock, set file->state to point to live state. (Needed for information schema to pick up right number of rows) In ha_maria::implicit_commit() move all locked (ie open) tables to new transaction. This is needed to ensure ha_maria->info doesn't point to a deleted history event. Disable concurrent inserts for insert ... select and table changes with subqueries if statement based replication as this would cause wrong results on slave storage/maria/ma_blockrec.c: Updated comment storage/maria/ma_check.c: Compact key pages (removes transid) when doing --zerofill Check that 'page_flag' on key pages contains KEYPAGE_FLAG_HAS_TRANSID if there is a single key on the page with a transid Modified functions to use MARIA_KEY instead of key pointer and key length Use new interface to _ma_rec_pos(), _ma_dpointer(), _ma_ft_del(), ma_update_state_lsn() Removed not needed argument from get_record_for_key() Fixed that we check doesn't give errors for RTREE; We now treath these like SPATIAL Remove some SPATIAL specific code where the virtual functions can handle this in a general manner Use info->lastkey_buff instead of info->lastkey _ma_dpos() -> _ma_row_pos_from_key() _ma_make_key() -> keyinfo->make_key() _ma_print_key() -> _ma_print_keydata() _ma_move_key() -> ma_copy_copy() Add SEARCH_INSERT to signal ha_key_cmp that we we should also compare rowid for keys Ensure that data on page doesn't overwrite page checksum position Use DBUG_DUMP_KEY instead of DBUG_DUMP Use exact key lengths instead of USE_WHOLE_KEY to ha_key_cmp() Fixed check if rowid points outside of BLOCK_RECORD data file Use info->lastkey_buff instead of key on stack in some safe places Added #fdef EXTERNAL_LOCKING around removed state elements storage/maria/ma_close.c: Use keyinfo->root_lock instead of share->key_root_lock[keynr] storage/maria/ma_create.c: Removed assert that is already checked in maria_init() Force transactinal tables to be of type BLOCK_RECORD Fixed wrong usage of HA_PACK_RECORD (should be HA_OPTION_PACK_RECORD) Mark keys that uses HA_KEY_ALG_RTREE with HA_RTREE_INDEX for easier handling of these in ma_check Store max_trid in index file as state.create_trid. This is used to pack all transids in the index pages relative to max possible transid for file. storage/maria/ma_dbug.c: Changed _ma_print_key() to use MARIA_KEY storage/maria/ma_delete.c: Modified functions to use MARIA_KEY instead of key pointer and key length info->lastkey2-> info->lastkey_buff2 Added SEARCH_INSERT to signal ha_key_cmp that we we should also compare rowid for keys Use new interface for get_key(), _ma_get_last_key() and others _ma_dpos() -> ma_row_pos_from_key() Simplify setting of prev_key in del() Ensure that KEYPAGE_FLAG_HAS_TRANSID is set in page_flag if key page has transid Treath key pages that may have a transid as if keys would be of variable length storage/maria/ma_delete_all.c: Reset history state if maria_delete_all_rows() are called Update parameters to _ma_update_state_lsns() call storage/maria/ma_extra.c: Store and restore info->lastkey storage/maria/ma_ft_boolean_search.c: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_ft_nlq_search.c: Modified functions to use MARIA_KEY instead of key pointer and key length Use lastkey_buff2 instead of info->lastkey+info->s->base.max_key_length (same thing) storage/maria/ma_ft_update.c: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_ftdefs.h: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_fulltext.h: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_init.c: Check if blocksize is legal (Moved test here from ma_open()) storage/maria/ma_key.c: Added functions for storing/reading of transid Modified functions to use MARIA_KEY instead of key pointer and key length Moved _ma_sp_make_key() out of _ma_make_key() as we now use keyinfo->make_key to create keys Add transid to keys if table is versioned Added _ma_copy_key() storage/maria/ma_key_recover.c: Add logging of page_flag (holds information if there are keys with transid on page) Changed DBUG_PRINT("info" -> DBUG_PRINT("redo" as the redo logging can be quite extensive Added lots of DBUG_PRINT() Added support for index page operations: KEY_OP_SET_PAGEFLAG and KEY_OP_COMPACT_PAGE storage/maria/ma_key_recover.h: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_locking.c: Added new arguments to _ma_update_state_lsns_sub() storage/maria/ma_loghandler.c: Fixed all logging of LSN to look similar in DBUG log Changed if (left != 0) to if (left) as the later is used also later in the code storage/maria/ma_loghandler.h: Added new index page operations storage/maria/ma_open.c: Removed allocated "state_dummy" and instead use share->state.common for transactional tables that are not versioned This is needed to not get double increments of state.records (one in ma_write.c and on when log is written) Changed info->lastkey to MARIA_KEY type Removed resetting of MARIA_HA variables that have 0 as default value (as info is zerofilled) Enable versioning for transactional tables with index. Tables with an auto-increment key, rtree or fulltext keys are not versioned. Check on open that state.create_trid is correct Extend share->base.max_key_length in case of transactional table so that it can hold transid Removed 4.0 compatible fulltext key mode as this is not relevant for Maria Removed old and wrong #ifdef ENABLE_WHEN_WE_HAVE_TRANS_ROW_ID code block Initialize all new virtual function pointers Removed storing of state->unique, state->process and store state->create_trid instead storage/maria/ma_page.c: Added comment to describe key page structure Added functions to compact key page and log the compact operation storage/maria/ma_range.c: Modified functions to use MARIA_KEY instead of key pointer and key length Use SEARCH_PART_KEY indicator instead of USE_WHOLE_KEY to detect if we are doing a part key search Added handling of pages with transid storage/maria/ma_recovery.c: Don't assert if table we opened are not transactional. This may be a table which has been changed from transactional to not transactinal Added new arguments to _ma_update_state_lsns() storage/maria/ma_rename.c: Added new arguments to _ma_update_state_lsns() storage/maria/ma_rkey.c: Modified functions to use MARIA_KEY instead of key pointer and key length Don't use USE_WHOLE_KEY, use real length of key Use share->row_is_visible() to test if row is visible Moved search_flag == HA_READ_KEY_EXACT out of 'read-next-row' loop as this only need to be tested once Removed test if last_used_keyseg != 0 as this is always true storage/maria/ma_rnext.c: Modified functions to use MARIA_KEY instead of key pointer and key length Simplify code by using local variable keyinfo instead if share->keyinfo[i] Use share->row_is_visible() to test if row is visible storage/maria/ma_rnext_same.c: Modified functions to use MARIA_KEY instead of key pointer and key length lastkey2 -> lastkey_buff2 storage/maria/ma_rprev.c: Modified functions to use MARIA_KEY instead of key pointer and key length Simplify code by using local variable keyinfo instead if share->keyinfo[i] Use share->row_is_visible() to test if row is visible storage/maria/ma_rsame.c: Updated comment Simplify code by using local variable keyinfo instead if share->keyinfo[i] Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_rsamepos.c: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_rt_index.c: Modified functions to use MARIA_KEY instead of key pointer and key length Use better variable names Removed not needed casts _ma_dpos() -> _ma_row_pos_from_key() Use info->last_rtree_keypos to save position to key instead of info->int_keypos Simplify err: condition Changed return type for maria_rtree_insert() to my_bool as we are only intressed in ok/fail from this function storage/maria/ma_rt_index.h: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_rt_key.c: Modified functions to use MARIA_KEY instead of key pointer and key length Simplify maria_rtree_add_key by combining idenitcal code and removing added_len storage/maria/ma_rt_key.h: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_rt_mbr.c: Changed type of 'nextflag' to uint32 Added 'to' argument to RT_PAGE_MBR_XXX functions to more clearly see which variables changes value storage/maria/ma_rt_mbr.h: Changed type of 'nextflag' to uint32 storage/maria/ma_rt_split.c: Modified functions to use MARIA_KEY instead of key pointer and key length key_length -> key_data_length to catch possible errors storage/maria/ma_rt_test.c: Fixed wrong comment Reset recinfo to avoid valgrind varnings Fixed wrong argument to create_record() that caused test to fail storage/maria/ma_search.c: Modified functions to use MARIA_KEY instead of key pointer and key length Added support of keys with optional trid Test for SEARCH_PART_KEY instead of USE_WHOLE_KEY to detect part key reads _ma_dpos() -> _ma_row_pos_from_key() If there may be keys with transid on the page, have _ma_bin_search() call _ma_seq_search() Add _ma_skip_xxx() functions to quickly step over keys (faster than calling get_key() in most cases as we don't have to copy key data) Combine similar code at end of _ma_get_binary_pack_key() Removed not used function _ma_move_key() In _ma_search_next() don't call _ma_search() if we aren't on a nod page. Update info->cur_row.trid with trid for found key Removed some not needed casts Added _ma_trid_from_key() Use MARIA_SHARE instead of MARIA_HA as arguments to _ma_rec_pos(), _ma_dpointer() and _ma_xxx_keypos_to_recpos() to make functions faster and smaller storage/maria/ma_sort.c: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_sp_defs.h: _ma_sp_make_key() now fills in and returns (MARIA_KEY *) value storage/maria/ma_sp_key.c: _ma_sp_make_key() now fills in and returns (MARIA_KEY *) value Don't test sizeof(double), test against 8 as we are using float8store() Use mi_float8store() instead of doing swap of value (same thing but faster) storage/maria/ma_state.c: maria_versioning() now only calls _ma_block_get_status() if table supports versioning Added _ma_row_visible_xxx() functions for different occasions When emptying history, set info->state to point to the first history event. storage/maria/ma_state.h: Added _ma_row_visible_xxx() prototypes storage/maria/ma_static.c: Indentation changes storage/maria/ma_statrec.c: Fixed arguments to _ma_dpointer() and _ma_rec_pos() storage/maria/ma_test1.c: Call init_thr_lock() if we have versioning storage/maria/ma_test2.c: Call init_thr_lock() if we have versioning storage/maria/ma_unique.c: Modified functions to use MARIA_KEY storage/maria/ma_update.c: Modified functions to use MARIA_KEY instead of key pointer and key length storage/maria/ma_write.c: Modified functions to use MARIA_KEY instead of key pointer and key length Simplify code by using local variable keyinfo instead if share->keyinfo[i] In _ma_enlarge_root(), mark in page_flag if new key has transid _ma_dpos() -> _ma_row_pos_from_key() Changed return type of _ma_ck_write_tree() to my_bool as we are only testing if result is true or not Moved 'reversed' to outside block as area was used later storage/maria/maria_chk.c: Added error if trying to sort with HA_BINARY_PACK_KEY Use new interface to get_key() and _ma_dpointer() _ma_dpos() -> _ma_row_pos_from_key() storage/maria/maria_def.h: Modified functions to use MARIA_KEY instead of key pointer and key length Added 'common' to MARIA_SHARE->state for storing state for transactional tables without versioning Added create_trid to MARIA_SHARE Removed not used state variables 'process' and 'unique' Added defines for handling TRID's in index pages Changed to use MARIA_SHARE instead of MARIA_HA for some functions Added 'have_versioning' flag if table supports versioning Moved key_root_lock from MARIA_SHARE to MARIA_KEYDEF Changed last_key to be of type MARIA_KEY. Removed lastkey_length lastkey -> lastkey_buff, lastkey2 -> lastkey_buff2 Added _ma_get_used_and_nod_with_flag() for faster access to page data when page_flag is read Added DBUG_DUMP_KEY for easier DBUG_DUMP of a key Changed 'nextflag' and assocaited variables to uint32 storage/maria/maria_ftdump.c: lastkey -> lastkey_buff storage/maria/trnman.c: Fixed wrong initialization of min_read_from and max_commit_trid Added trnman_get_min_safe_trid() storage/maria/unittest/ma_test_all-t: Added --start-from storage/myisam/mi_check.c: Added SEARCH_INSERT, as ha_key_cmp() needs it when doing key comparision for inserting key on page in rowid order storage/myisam/mi_delete.c: Added SEARCH_INSERT, as ha_key_cmp() needs it when doing key comparision for inserting key on page in rowid order storage/myisam/mi_range.c: Updated comment storage/myisam/mi_write.c: Added SEARCH_INSERT, as ha_key_cmp() needs it when doing key comparision for inserting key on page in rowid order storage/myisam/rt_index.c: Fixed wrong parameter to rtree_get_req() which could cause crash
587 lines
19 KiB
C
587 lines
19 KiB
C
/* Copyright (C) 2006 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
#include "maria_def.h"
|
|
#ifdef HAVE_SYS_MMAN_H
|
|
#include <sys/mman.h>
|
|
#endif
|
|
#include "ma_blockrec.h"
|
|
|
|
static void maria_extra_keyflag(MARIA_HA *info,
|
|
enum ha_extra_function function);
|
|
|
|
/**
|
|
@brief Set options and buffers to optimize table handling
|
|
|
|
@param name table's name
|
|
@param info open table
|
|
@param function operation
|
|
@param extra_arg Pointer to extra argument (normally pointer to
|
|
ulong); used when function is one of:
|
|
HA_EXTRA_WRITE_CACHE
|
|
HA_EXTRA_CACHE
|
|
|
|
@return Operation status
|
|
@retval 0 ok
|
|
@retval !=0 error
|
|
*/
|
|
|
|
int maria_extra(MARIA_HA *info, enum ha_extra_function function,
|
|
void *extra_arg)
|
|
{
|
|
int error= 0;
|
|
ulong cache_size;
|
|
MARIA_SHARE *share= info->s;
|
|
my_bool block_records= share->data_file_type == BLOCK_RECORD;
|
|
DBUG_ENTER("maria_extra");
|
|
DBUG_PRINT("enter",("function: %d",(int) function));
|
|
|
|
switch (function) {
|
|
case HA_EXTRA_RESET_STATE: /* Reset state (don't free buffers) */
|
|
info->lastinx= 0; /* Use first index as def */
|
|
info->last_search_keypage= info->cur_row.lastpos= HA_OFFSET_ERROR;
|
|
info->page_changed= 1;
|
|
/* Next/prev gives first/last */
|
|
if (info->opt_flag & READ_CACHE_USED)
|
|
{
|
|
reinit_io_cache(&info->rec_cache,READ_CACHE,0,
|
|
(pbool) (info->lock_type != F_UNLCK),
|
|
(pbool) test(info->update & HA_STATE_ROW_CHANGED)
|
|
);
|
|
}
|
|
info->update= ((info->update & HA_STATE_CHANGED) | HA_STATE_NEXT_FOUND |
|
|
HA_STATE_PREV_FOUND);
|
|
break;
|
|
case HA_EXTRA_CACHE:
|
|
if (block_records)
|
|
break; /* Not supported */
|
|
|
|
if (info->lock_type == F_UNLCK &&
|
|
(share->options & HA_OPTION_PACK_RECORD))
|
|
{
|
|
error= 1; /* Not possibly if not locked */
|
|
my_errno= EACCES;
|
|
break;
|
|
}
|
|
if (info->s->file_map) /* Don't use cache if mmap */
|
|
break;
|
|
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
|
|
if ((share->options & HA_OPTION_COMPRESS_RECORD))
|
|
{
|
|
pthread_mutex_lock(&share->intern_lock);
|
|
if (_ma_memmap_file(info))
|
|
{
|
|
/* We don't nead MADV_SEQUENTIAL if small file */
|
|
madvise((char*) share->file_map, share->state.state.data_file_length,
|
|
share->state.state.data_file_length <= RECORD_CACHE_SIZE*16 ?
|
|
MADV_RANDOM : MADV_SEQUENTIAL);
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
break;
|
|
}
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
}
|
|
#endif
|
|
if (info->opt_flag & WRITE_CACHE_USED)
|
|
{
|
|
info->opt_flag&= ~WRITE_CACHE_USED;
|
|
if ((error= end_io_cache(&info->rec_cache)))
|
|
break;
|
|
}
|
|
if (!(info->opt_flag &
|
|
(READ_CACHE_USED | WRITE_CACHE_USED | MEMMAP_USED)))
|
|
{
|
|
cache_size= (extra_arg ? *(ulong*) extra_arg :
|
|
my_default_record_cache_size);
|
|
if (!(init_io_cache(&info->rec_cache, info->dfile.file,
|
|
(uint) min(share->state.state.data_file_length+1,
|
|
cache_size),
|
|
READ_CACHE,0L,(pbool) (info->lock_type != F_UNLCK),
|
|
MYF(share->write_flag & MY_WAIT_IF_FULL))))
|
|
{
|
|
info->opt_flag|= READ_CACHE_USED;
|
|
info->update&= ~HA_STATE_ROW_CHANGED;
|
|
}
|
|
if (share->non_transactional_concurrent_insert)
|
|
info->rec_cache.end_of_file= info->state->data_file_length;
|
|
}
|
|
break;
|
|
case HA_EXTRA_REINIT_CACHE:
|
|
if (info->opt_flag & READ_CACHE_USED)
|
|
{
|
|
reinit_io_cache(&info->rec_cache, READ_CACHE, info->cur_row.nextpos,
|
|
(pbool) (info->lock_type != F_UNLCK),
|
|
(pbool) test(info->update & HA_STATE_ROW_CHANGED));
|
|
info->update&= ~HA_STATE_ROW_CHANGED;
|
|
if (share->non_transactional_concurrent_insert)
|
|
info->rec_cache.end_of_file= info->state->data_file_length;
|
|
}
|
|
break;
|
|
case HA_EXTRA_WRITE_CACHE:
|
|
if (info->lock_type == F_UNLCK)
|
|
{
|
|
error= 1; /* Not possibly if not locked */
|
|
break;
|
|
}
|
|
if (block_records)
|
|
break; /* Not supported */
|
|
|
|
cache_size= (extra_arg ? *(ulong*) extra_arg :
|
|
my_default_record_cache_size);
|
|
if (!(info->opt_flag &
|
|
(READ_CACHE_USED | WRITE_CACHE_USED | OPT_NO_ROWS)) &&
|
|
!share->state.header.uniques)
|
|
if (!(init_io_cache(&info->rec_cache, info->dfile.file, cache_size,
|
|
WRITE_CACHE,share->state.state.data_file_length,
|
|
(pbool) (info->lock_type != F_UNLCK),
|
|
MYF(share->write_flag & MY_WAIT_IF_FULL))))
|
|
{
|
|
info->opt_flag|= WRITE_CACHE_USED;
|
|
info->update&= ~(HA_STATE_ROW_CHANGED |
|
|
HA_STATE_WRITE_AT_END |
|
|
HA_STATE_EXTEND_BLOCK);
|
|
}
|
|
break;
|
|
case HA_EXTRA_PREPARE_FOR_UPDATE:
|
|
if (info->s->data_file_type != DYNAMIC_RECORD)
|
|
break;
|
|
/* Remove read/write cache if dynamic rows */
|
|
case HA_EXTRA_NO_CACHE:
|
|
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
|
|
{
|
|
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
|
|
error= end_io_cache(&info->rec_cache);
|
|
/* Sergei will insert full text index caching here */
|
|
}
|
|
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
|
|
if (info->opt_flag & MEMMAP_USED)
|
|
madvise((char*) share->file_map, share->state.state.data_file_length,
|
|
MADV_RANDOM);
|
|
#endif
|
|
break;
|
|
case HA_EXTRA_FLUSH_CACHE:
|
|
if (info->opt_flag & WRITE_CACHE_USED)
|
|
{
|
|
if ((error= flush_io_cache(&info->rec_cache)))
|
|
{
|
|
maria_print_error(info->s, HA_ERR_CRASHED);
|
|
maria_mark_crashed(info); /* Fatal error found */
|
|
}
|
|
}
|
|
break;
|
|
case HA_EXTRA_NO_READCHECK:
|
|
info->opt_flag&= ~READ_CHECK_USED; /* No readcheck */
|
|
break;
|
|
case HA_EXTRA_READCHECK:
|
|
info->opt_flag|= READ_CHECK_USED;
|
|
break;
|
|
case HA_EXTRA_KEYREAD: /* Read only keys to record */
|
|
case HA_EXTRA_REMEMBER_POS:
|
|
info->opt_flag|= REMEMBER_OLD_POS;
|
|
bmove((uchar*) info->last_key.data + share->base.max_key_length*2,
|
|
(uchar*) info->last_key.data,
|
|
info->last_key.data_length + info->last_key.ref_length);
|
|
info->save_update= info->update;
|
|
info->save_lastinx= info->lastinx;
|
|
info->save_lastpos= info->cur_row.lastpos;
|
|
info->save_lastkey_data_length= info->last_key.data_length;
|
|
info->save_lastkey_ref_length= info->last_key.ref_length;
|
|
if (function == HA_EXTRA_REMEMBER_POS)
|
|
break;
|
|
/* fall through */
|
|
case HA_EXTRA_KEYREAD_CHANGE_POS:
|
|
info->opt_flag|= KEY_READ_USED;
|
|
info->read_record= _ma_read_key_record;
|
|
break;
|
|
case HA_EXTRA_NO_KEYREAD:
|
|
case HA_EXTRA_RESTORE_POS:
|
|
if (info->opt_flag & REMEMBER_OLD_POS)
|
|
{
|
|
bmove((uchar*) info->last_key.data,
|
|
(uchar*) info->last_key.data + share->base.max_key_length*2,
|
|
info->save_lastkey_data_length + info->save_lastkey_ref_length);
|
|
info->update= info->save_update | HA_STATE_WRITTEN;
|
|
info->lastinx= info->save_lastinx;
|
|
info->cur_row.lastpos= info->save_lastpos;
|
|
info->last_key.data_length= info->save_lastkey_data_length;
|
|
info->last_key.ref_length= info->save_lastkey_ref_length;
|
|
info->last_key.flag= 0;
|
|
}
|
|
info->read_record= share->read_record;
|
|
info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
|
|
break;
|
|
case HA_EXTRA_NO_USER_CHANGE: /* Database is somehow locked agains changes */
|
|
info->lock_type= F_EXTRA_LCK; /* Simulate as locked */
|
|
break;
|
|
case HA_EXTRA_WAIT_LOCK:
|
|
info->lock_wait= 0;
|
|
break;
|
|
case HA_EXTRA_NO_WAIT_LOCK:
|
|
info->lock_wait= MY_SHORT_WAIT;
|
|
break;
|
|
case HA_EXTRA_NO_KEYS:
|
|
/* we're going to modify pieces of the state, stall Checkpoint */
|
|
pthread_mutex_lock(&share->intern_lock);
|
|
if (info->lock_type == F_UNLCK)
|
|
{
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
error= 1; /* Not possibly if not lock */
|
|
break;
|
|
}
|
|
if (maria_is_any_key_active(share->state.key_map))
|
|
{
|
|
MARIA_KEYDEF *key= share->keyinfo;
|
|
uint i;
|
|
for (i =0 ; i < share->base.keys ; i++,key++)
|
|
{
|
|
if (!(key->flag & HA_NOSAME) && info->s->base.auto_key != i+1)
|
|
{
|
|
maria_clear_key_active(share->state.key_map, i);
|
|
info->update|= HA_STATE_CHANGED;
|
|
}
|
|
}
|
|
|
|
if (!share->changed)
|
|
{
|
|
share->state.changed|= STATE_CHANGED | STATE_NOT_ANALYZED;
|
|
share->changed= 1; /* Update on close */
|
|
if (!share->global_changed)
|
|
{
|
|
share->global_changed= 1;
|
|
share->state.open_count++;
|
|
}
|
|
}
|
|
if (!share->now_transactional)
|
|
share->state.state= *info->state;
|
|
/*
|
|
That state write to disk must be done, even for transactional tables;
|
|
indeed the table's share is going to be lost (there was a
|
|
HA_EXTRA_FORCE_REOPEN before, which set share->last_version to
|
|
0), and so the only way it leaves information (share->state.key_map)
|
|
for the posterity is by writing it to disk.
|
|
*/
|
|
DBUG_ASSERT(!maria_in_recovery);
|
|
error= _ma_state_info_write(share, 1|2);
|
|
}
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
break;
|
|
case HA_EXTRA_FORCE_REOPEN:
|
|
/*
|
|
MySQL uses this case after it has closed all other instances
|
|
of this table.
|
|
We however do a flush here for additional safety.
|
|
*/
|
|
/** @todo consider porting these flush-es to MyISAM */
|
|
DBUG_ASSERT(share->reopen == 1);
|
|
error= _ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
|
|
FLUSH_FORCE_WRITE, FLUSH_FORCE_WRITE);
|
|
if (!error && share->changed)
|
|
{
|
|
pthread_mutex_lock(&share->intern_lock);
|
|
if (!(error= _ma_state_info_write(share, 1|2)))
|
|
share->changed= 0;
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
}
|
|
pthread_mutex_lock(&THR_LOCK_maria);
|
|
pthread_mutex_lock(&share->intern_lock); /* protect against Checkpoint */
|
|
/* this makes the share not be re-used next time the table is opened */
|
|
share->last_version= 0L; /* Impossible version */
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
pthread_mutex_unlock(&THR_LOCK_maria);
|
|
break;
|
|
case HA_EXTRA_PREPARE_FOR_DROP:
|
|
case HA_EXTRA_PREPARE_FOR_RENAME:
|
|
{
|
|
my_bool do_flush= test(function != HA_EXTRA_PREPARE_FOR_DROP);
|
|
enum flush_type type;
|
|
pthread_mutex_lock(&THR_LOCK_maria);
|
|
/*
|
|
This share, to have last_version=0, needs to save all its data/index
|
|
blocks to disk if this is not for a DROP TABLE. Otherwise they would be
|
|
invisible to future openers; and they could even go to disk late and
|
|
cancel the work of future openers.
|
|
*/
|
|
if (info->lock_type != F_UNLCK && !info->was_locked)
|
|
{
|
|
info->was_locked= info->lock_type;
|
|
if (maria_lock_database(info, F_UNLCK))
|
|
error= my_errno;
|
|
info->lock_type= F_UNLCK;
|
|
}
|
|
if (share->kfile.file >= 0)
|
|
_ma_decrement_open_count(info);
|
|
pthread_mutex_lock(&share->intern_lock);
|
|
type= do_flush ? FLUSH_RELEASE : FLUSH_IGNORE_CHANGED;
|
|
if (_ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
|
|
type, type))
|
|
{
|
|
error=my_errno;
|
|
share->changed= 1;
|
|
}
|
|
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
|
|
{
|
|
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
|
|
if (end_io_cache(&info->rec_cache))
|
|
error= 1;
|
|
}
|
|
if (share->kfile.file >= 0)
|
|
{
|
|
if (do_flush)
|
|
{
|
|
/* Save the state so that others can find it from disk. */
|
|
if (_ma_state_info_write(share, 1 | 2) ||
|
|
my_sync(share->kfile.file, MYF(0)))
|
|
error= my_errno;
|
|
else
|
|
share->changed= 0;
|
|
}
|
|
else
|
|
{
|
|
/* be sure that state is not tried for write as file may be closed */
|
|
share->changed= 0;
|
|
}
|
|
}
|
|
if (share->data_file_type == BLOCK_RECORD &&
|
|
share->bitmap.file.file >= 0)
|
|
{
|
|
if (do_flush && my_sync(share->bitmap.file.file, MYF(0)))
|
|
error= my_errno;
|
|
}
|
|
/* For protection against Checkpoint, we set under intern_lock: */
|
|
share->last_version= 0L; /* Impossible version */
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
pthread_mutex_unlock(&THR_LOCK_maria);
|
|
break;
|
|
}
|
|
case HA_EXTRA_FLUSH:
|
|
if (!share->temporary)
|
|
error= _ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
|
|
FLUSH_KEEP, FLUSH_KEEP);
|
|
#ifdef HAVE_PWRITE
|
|
_ma_decrement_open_count(info);
|
|
#endif
|
|
if (share->not_flushed)
|
|
{
|
|
share->not_flushed= 0;
|
|
if (_ma_sync_table_files(info))
|
|
error= my_errno;
|
|
if (error)
|
|
{
|
|
share->changed= 1;
|
|
maria_print_error(info->s, HA_ERR_CRASHED);
|
|
maria_mark_crashed(info); /* Fatal error found */
|
|
}
|
|
}
|
|
break;
|
|
case HA_EXTRA_NORMAL: /* Theese isn't in use */
|
|
info->quick_mode= 0;
|
|
break;
|
|
case HA_EXTRA_QUICK:
|
|
info->quick_mode= 1;
|
|
break;
|
|
case HA_EXTRA_NO_ROWS:
|
|
if (!share->state.header.uniques)
|
|
info->opt_flag|= OPT_NO_ROWS;
|
|
break;
|
|
case HA_EXTRA_PRELOAD_BUFFER_SIZE:
|
|
info->preload_buff_size= *((ulong *) extra_arg);
|
|
break;
|
|
case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
|
|
case HA_EXTRA_CHANGE_KEY_TO_DUP:
|
|
maria_extra_keyflag(info, function);
|
|
break;
|
|
case HA_EXTRA_MMAP:
|
|
#ifdef HAVE_MMAP
|
|
if (block_records)
|
|
break; /* Not supported */
|
|
pthread_mutex_lock(&share->intern_lock);
|
|
/*
|
|
Memory map the data file if it is not already mapped. It is safe
|
|
to memory map a file while other threads are using file I/O on it.
|
|
Assigning a new address to a function pointer is an atomic
|
|
operation. intern_lock prevents that two or more mappings are done
|
|
at the same time.
|
|
*/
|
|
if (!share->file_map)
|
|
{
|
|
if (_ma_dynmap_file(info, share->state.state.data_file_length))
|
|
{
|
|
DBUG_PRINT("warning",("mmap failed: errno: %d",errno));
|
|
error= my_errno= errno;
|
|
}
|
|
else
|
|
{
|
|
share->file_read= _ma_mmap_pread;
|
|
share->file_write= _ma_mmap_pwrite;
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
#endif
|
|
break;
|
|
case HA_EXTRA_MARK_AS_LOG_TABLE:
|
|
pthread_mutex_lock(&share->intern_lock);
|
|
share->is_log_table= TRUE;
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
break;
|
|
case HA_EXTRA_KEY_CACHE:
|
|
case HA_EXTRA_NO_KEY_CACHE:
|
|
default:
|
|
break;
|
|
}
|
|
DBUG_RETURN(error);
|
|
} /* maria_extra */
|
|
|
|
|
|
/*
|
|
Start/Stop Inserting Duplicates Into a Table, WL#1648.
|
|
*/
|
|
|
|
static void maria_extra_keyflag(MARIA_HA *info,
|
|
enum ha_extra_function function)
|
|
{
|
|
uint idx;
|
|
|
|
for (idx= 0; idx< info->s->base.keys; idx++)
|
|
{
|
|
switch (function) {
|
|
case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
|
|
info->s->keyinfo[idx].flag|= HA_NOSAME;
|
|
break;
|
|
case HA_EXTRA_CHANGE_KEY_TO_DUP:
|
|
info->s->keyinfo[idx].flag&= ~(HA_NOSAME);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int maria_reset(MARIA_HA *info)
|
|
{
|
|
int error= 0;
|
|
MARIA_SHARE *share= info->s;
|
|
DBUG_ENTER("maria_reset");
|
|
/*
|
|
Free buffers and reset the following flags:
|
|
EXTRA_CACHE, EXTRA_WRITE_CACHE, EXTRA_KEYREAD, EXTRA_QUICK
|
|
|
|
If the row buffer cache is large (for dynamic tables), reduce it
|
|
to save memory.
|
|
*/
|
|
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
|
|
{
|
|
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
|
|
error= end_io_cache(&info->rec_cache);
|
|
}
|
|
/* Free memory used for keeping blobs */
|
|
if (share->base.blobs)
|
|
{
|
|
if (info->rec_buff_size > share->base.default_rec_buff_size)
|
|
{
|
|
info->rec_buff_size= 1; /* Force realloc */
|
|
_ma_alloc_buffer(&info->rec_buff, &info->rec_buff_size,
|
|
share->base.default_rec_buff_size);
|
|
}
|
|
if (info->blob_buff_size > MARIA_SMALL_BLOB_BUFFER)
|
|
{
|
|
info->blob_buff_size= 1; /* Force realloc */
|
|
_ma_alloc_buffer(&info->blob_buff, &info->blob_buff_size,
|
|
MARIA_SMALL_BLOB_BUFFER);
|
|
}
|
|
}
|
|
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
|
|
if (info->opt_flag & MEMMAP_USED)
|
|
madvise((char*) share->file_map, share->state.state.data_file_length,
|
|
MADV_RANDOM);
|
|
#endif
|
|
info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
|
|
info->quick_mode= 0;
|
|
info->lastinx= 0; /* Use first index as def */
|
|
info->last_search_keypage= info->cur_row.lastpos= HA_OFFSET_ERROR;
|
|
info->page_changed= 1;
|
|
info->update= ((info->update & HA_STATE_CHANGED) | HA_STATE_NEXT_FOUND |
|
|
HA_STATE_PREV_FOUND);
|
|
DBUG_RETURN(error);
|
|
}
|
|
|
|
|
|
int _ma_sync_table_files(const MARIA_HA *info)
|
|
{
|
|
return (my_sync(info->dfile.file, MYF(MY_WME)) ||
|
|
my_sync(info->s->kfile.file, MYF(MY_WME)));
|
|
}
|
|
|
|
|
|
/**
|
|
@brief flushes the data and/or index file of a table
|
|
|
|
This is useful when one wants to read a table using OS syscalls (like
|
|
my_copy()) and first wants to be sure that MySQL-level caches go down to
|
|
the OS so that OS syscalls can see all data. It can flush rec_cache,
|
|
bitmap, pagecache of data file, pagecache of index file.
|
|
|
|
@param info table
|
|
@param flush_data_or_index one or two of these flags:
|
|
MARIA_FLUSH_DATA, MARIA_FLUSH_INDEX
|
|
@param flush_type_for_data
|
|
@param flush_type_for_index
|
|
|
|
@note does not sync files (@see _ma_sync_table_files()).
|
|
@note Progressively this function will be used in all places where we flush
|
|
the index but not the data file (probable bugs).
|
|
|
|
@return Operation status
|
|
@retval 0 OK
|
|
@retval 1 Error
|
|
*/
|
|
|
|
int _ma_flush_table_files(MARIA_HA *info, uint flush_data_or_index,
|
|
enum flush_type flush_type_for_data,
|
|
enum flush_type flush_type_for_index)
|
|
{
|
|
int error= 0;
|
|
MARIA_SHARE *share= info->s;
|
|
/* flush data file first because it's more critical */
|
|
if (flush_data_or_index & MARIA_FLUSH_DATA)
|
|
{
|
|
if ((info->opt_flag & WRITE_CACHE_USED) &&
|
|
flush_type_for_data != FLUSH_IGNORE_CHANGED &&
|
|
flush_io_cache(&info->rec_cache))
|
|
error= 1;
|
|
if (share->data_file_type == BLOCK_RECORD)
|
|
{
|
|
if (flush_type_for_data != FLUSH_IGNORE_CHANGED)
|
|
{
|
|
if (_ma_bitmap_flush(share))
|
|
error= 1;
|
|
}
|
|
else
|
|
info->s->bitmap.changed= 0;
|
|
if (flush_pagecache_blocks(share->pagecache, &info->dfile,
|
|
flush_type_for_data))
|
|
error= 1;
|
|
}
|
|
}
|
|
if ((flush_data_or_index & MARIA_FLUSH_INDEX) &&
|
|
flush_pagecache_blocks(share->pagecache, &share->kfile,
|
|
flush_type_for_index))
|
|
error= 1;
|
|
if (!error)
|
|
return 0;
|
|
|
|
maria_print_error(info->s, HA_ERR_CRASHED);
|
|
maria_mark_crashed(info);
|
|
return 1;
|
|
}
|