mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 20:42:30 +01:00
1a96259191
- WL#3240 "log DROP TABLE in Maria" - similarly, log RENAME TABLE, REPAIR/OPTIMIZE TABLE, and DELETE no_WHERE_clause (== the DELETE which just truncates the files) - create_rename_lsn added to MARIA_SHARE's state - all these operations (except DROP TABLE) also update the table's create_rename_lsn, which is needed for the correctness of Recovery (see function comment of _ma_repair_write_log_record() in ma_check.c) - write a COMMIT record when transaction commits. - don't log REDOs/UNDOs if this is an internal temporary table like inside ALTER TABLE (I expect this to be a big win). There was already no logging for user-created "CREATE TEMPORARY" tables. - don't fsync files/directories if the table is not transactional - in translog_write_record(), autogenerate a 2-byte-id for the table and log the "id->name" pair (LOGREC_FILE_ID); log LOGREC_LONG_TRANSACTION_ID; automatically store the table's 2-byte-id in any log record. - preparations for Checkpoint: translog_get_horizon(); pausing Checkpoint when some dirty pages are unknown; capturing trn->rec_lsn, trn->first_undo_lsn for Checkpoint and log's low-water-mark computing. - assertions, comments. storage/maria/Makefile.am: more files to build storage/maria/ha_maria.cc: - logging a REPAIR log record if REPAIR/OPTIMIZE was successful. - ha_maria::data_file_type does not have to be set in every info() call, just do it once in open(). - if caller said that transactionality can be disabled (like if caller is ALTER TABLE) i.e. thd->transaction.on==FALSE, then we temporarily disable transactionality of the table in external_lock(); that will ensure that no REDOs/UNDOs are logged for this possibly massive write operation (they are not needed, as if any write fails, the table will be dropped). We re-enable in external_lock(F_UNLCK), which in ALTER TABLE happens before the tmp table replaces the original one (which is good, as thus the final table will have a REDO RENAME and a correct create_rename_lsn). - when we commit we also have to write a log record, so trnman_commit_trn() calls become ma_commit() calls - at end of engine's initialization, we are potentially entering a multi-threaded dangerous world (clients are going to be accepted) and so some assertions of mutex-owning become enforceable, for that we set maria_multi_threaded=TRUE (see ma_control_file.c) storage/maria/ha_maria.h: new member ha_maria::save_transactional (see also ha_maria.cc) storage/maria/ma_blockrec.c: - fixing comments according to discussion with Monty - if a table is transactional but temporarily non-transactional (like in ALTER TABLE), we need to give a sensible LSN to the pages (and, if we give 0, pagecache asserts). - translog_write_record() now takes care of storing the share's 2-byte-id in the log record storage/maria/ma_blockrec.h: fixing comment according to discussion with Monty storage/maria/ma_check.c: When REPAIR/OPTIMIZE modify the data/index file, if this is a transactional table, they must sync it; if they remove files or rename files, they must sync the directory, so that everything is durable. This is just applying to REPAIR/OPTIMIZE the logic already implemented in CREATE/DROP/RENAME a few months ago. Adding a function to write a LOGREC_REPAIR_TABLE at end of REPAIR/OPTIMIZE (called only by ha_maria, not by maria_chk), and to update the table's create_rename_lsn. storage/maria/ma_close.c: fix for a future bug storage/maria/ma_control_file.c: ensuring that if Maria is running in multi-threaded mode, anybody wanting to write to the control file and update last_checkpoint_lsn/last_logno owns the log's lock. storage/maria/ma_control_file.h: see ma_control_file.c storage/maria/ma_create.c: when creating a table: - sync it and its directory only if this is a transactional table and there is a log (no point in syncing in maria_chk) - decouple the two uses of linkname/linkname_ptr (for index file and for data file) into more variables, as we need to know all links until the moment we write the LOGREC_CREATE_TABLE. - set share.data_file_type early so that _ma_initialize_data_file() knows it (Monty's bugfix so that a table always has at least a bitmap page when it is created; so data-file is not 0 bytes anymore). - log a LOGREC_CREATE_TABLE; it contains the bytes which we have just written to the index file's header. Update table's create_rename_lsn. - syncing of kfile had been bugified in a previous merge, correcting - syncing of dfile is now needed as it's not empty anymore - in _ma_initialize_data_file(), use share's block_size and not the global one. This is a gratuitous change, both variables are equal, just that I find it more future-proof to use share-bound variable rather than global one. storage/maria/ma_delete_all.c: log a LOGREC_DELETE_ALL record when doing ma_delete_all_rows(); update create_rename_lsn then. storage/maria/ma_delete_table.c: - logging LOGREC_DROP_TABLE; knowing if this is needed, requires knowing if the table is transactional, which requires opening the table. - we need to sync directories only if the table is transactional storage/maria/ma_extra.c: questions storage/maria/ma_init.c: when maria_end() is called, engine is not multithreaded storage/maria/ma_loghandler.c: - translog_inited has to be visible to ma_create() (see how it is used in ma_create()) - checkpoint record will be a single record, not three - no REDO for TRUNCATE (TRUNCATE calls ma_create() internally so will log a REDO_CREATE) - adding REDO for DELETE no_WHERE_clause (fast DELETE of all rows by truncating the files), REPAIR. - MY_WAIT_IF_FULL to wait&retry if a log write hits a full disk - in translog_write_record(), if MARIA_SHARE does not yet have a 2-byte-id, generate one for it and log LOGREC_FILE_ID; automatically store this short id into log records. - in translog_write_record(), if transaction has not logged its long trid, log LOGREC_LONG_TRANSACTION_ID. - For Checkpoint, we need to know the current end-of-log: adding translog_get_horizon(). - For Control File, adding an assertion that the thread owns the log's lock (control file is protected by this lock) storage/maria/ma_loghandler.h: Changes in log records (see ma_loghandler.c). new prototypes, new functions. storage/maria/ma_loghandler_lsn.h: adding a type LSN_WITH_FLAGS especially for TRN::first_undo_lsn, where the most significant byte is used for flags. storage/maria/ma_open.c: storing the create_rename_lsn in the index file's header (in the state, precisely) and retrieving it from there. storage/maria/ma_pagecache.c: - my set_if_bigger was wrong, correcting it - if the first_in_switch list is not empty, it means that changed_blocks misses some dirty pages, so Checkpoint cannot run and needs to wait. A variable missing_blocks_in_changed_list is added to tell that (should it be named missing_blocks_in_changed_blocks?) - pagecache_collect_changed_blocks_with_lsn() now also tells the minimum rec_lsn (needed for low-water mark computation). storage/maria/ma_pagecache.h: see ma_pagecache.c storage/maria/ma_panic.c: comment storage/maria/ma_range.c: comment storage/maria/ma_rename.c: - logging LOGREC_RENAME_TABLE; knowing if this is needed, requires knowing if the table is transactional, which requires opening the table. - update create_rename_lsn - we need to sync directories only if the table is transactional storage/maria/ma_static.c: comment storage/maria/ma_test_all.sh: - tip for Valgrind-ing ma_test_all - do "export maria_path=somepath" before calling ma_test_all, if you want to run ma_test_all out of storage/maria (useful to have parallel runs, like one normal and one Valgrind, they must not use the same tables so need to run in different directories) storage/maria/maria_def.h: - state now contains, in memory and on disk, the create_rename_lsn - share now contains a 2-byte-id storage/maria/trnman.c: preparations for Checkpoint: capture trn->rec_lsn, trn->first_undo_lsn; minimum first_undo_lsn needed to know log's low-water-mark storage/maria/trnman.h: using most significant byte of first_undo_lsn to hold miscellaneous flags, for now TRANSACTION_LOGGED_LONG_ID. dummy_transaction_object is already declared in ma_static.c. storage/maria/trnman_public.h: dummy_transaction_object was declared in all files including trnman_public.h, while in fact it's a single object. new prototype storage/maria/unittest/ma_test_loghandler-t.c: update for new prototype storage/maria/unittest/ma_test_loghandler_multigroup-t.c: update for new prototype storage/maria/unittest/ma_test_loghandler_multithread-t.c: update for new prototype storage/maria/unittest/ma_test_loghandler_pagecache-t.c: update for new prototype storage/maria/ma_commit.c: function which wraps: - writing a LOGREC_COMMIT record (==commit on disk) - calling trnman_commit_trn() (=commit in memory) storage/maria/ma_commit.h: new header file .tree-is-private: this file is now needed to keep our tree private (don't push it to public trees). When 5.1 is merged into mysql-maria, we can abandon our maria-specific post-commit trigger; .tree_is_private will take care of keeping commit mails private. Don't push this file to public trees.
488 lines
15 KiB
C
488 lines
15 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
|
|
|
|
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(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(info->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->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->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,info->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(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((byte*) info->lastkey+share->base.max_key_length*2,
|
|
(byte*) info->lastkey,info->lastkey_length);
|
|
info->save_update= info->update;
|
|
info->save_lastinx= info->lastinx;
|
|
info->save_lastpos= info->cur_row.lastpos;
|
|
info->save_lastkey_length=info->lastkey_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((byte*) info->lastkey,
|
|
(byte*) info->lastkey+share->base.max_key_length*2,
|
|
info->save_lastkey_length);
|
|
info->update= info->save_update | HA_STATE_WRITTEN;
|
|
info->lastinx= info->save_lastinx;
|
|
info->cur_row.lastpos= info->save_lastpos;
|
|
info->lastkey_length=info->save_lastkey_length;
|
|
}
|
|
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_DONT_WAIT;
|
|
break;
|
|
case HA_EXTRA_NO_KEYS:
|
|
if (info->lock_type == F_UNLCK)
|
|
{
|
|
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++;
|
|
}
|
|
}
|
|
share->state.state= *info->state;
|
|
error=_ma_state_info_write(share->kfile.file, &share->state, (1 | 2));
|
|
}
|
|
break;
|
|
case HA_EXTRA_FORCE_REOPEN:
|
|
pthread_mutex_lock(&THR_LOCK_maria);
|
|
share->last_version= 0L; /* Impossible version */
|
|
pthread_mutex_unlock(&THR_LOCK_maria);
|
|
break;
|
|
case HA_EXTRA_PREPARE_FOR_DELETE:
|
|
/* QQ: suggest to rename it to "PREPARE_FOR_DROP" */
|
|
pthread_mutex_lock(&THR_LOCK_maria);
|
|
share->last_version= 0L; /* Impossible version */
|
|
#ifdef __WIN__
|
|
/* Close the isam and data files as Win32 can't drop an open table */
|
|
pthread_mutex_lock(&share->intern_lock);
|
|
/*
|
|
If this is Windows we remove blocks from pagecache. If not Windows we
|
|
don't do it, so these pages stay in the pagecache? So they may later be
|
|
flushed to a wrong file?
|
|
Or is it that this flush_pagecache_blocks() never finds any blocks? Then
|
|
why do we do it on Windows?
|
|
Don't we wait for all instances to be closed before dropping the table?
|
|
Do we ever do something useful here?
|
|
BUG?
|
|
*/
|
|
if (flush_pagecache_blocks(share->pagecache, &share->kfile,
|
|
FLUSH_IGNORE_CHANGED))
|
|
{
|
|
error=my_errno;
|
|
share->changed=1;
|
|
maria_print_error(info->s, HA_ERR_CRASHED);
|
|
maria_mark_crashed(info); /* Fatal error found */
|
|
}
|
|
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);
|
|
}
|
|
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);
|
|
if (my_close(share->kfile,MYF(0)))
|
|
error=my_errno;
|
|
}
|
|
{
|
|
LIST *list_element ;
|
|
for (list_element=maria_open_list ;
|
|
list_element ;
|
|
list_element=list_element->next)
|
|
{
|
|
MARIA_HA *tmpinfo=(MARIA_HA*) list_element->data;
|
|
if (tmpinfo->s == info->s)
|
|
{
|
|
/**
|
|
@todo RECOVERY BUG: flush of bitmap and sync of dfile are missing
|
|
*/
|
|
if (tmpinfo->dfile.file >= 0 &&
|
|
my_close(tmpinfo->dfile.file, MYF(0)))
|
|
error = my_errno;
|
|
tmpinfo->dfile.file= -1;
|
|
}
|
|
}
|
|
}
|
|
share->kfile.file= -1; /* Files aren't open anymore */
|
|
pthread_mutex_unlock(&share->intern_lock);
|
|
#endif
|
|
pthread_mutex_unlock(&THR_LOCK_maria);
|
|
break;
|
|
case HA_EXTRA_FLUSH:
|
|
if (!share->temporary)
|
|
flush_pagecache_blocks(share->pagecache, &share->kfile, 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 */
|
|
}
|
|
}
|
|
if (share->base.blobs && 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);
|
|
}
|
|
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 and if there
|
|
are no other threads using this table. intern_lock prevents other
|
|
threads from starting to use the table while we are mapping it.
|
|
*/
|
|
if (!share->file_map && (share->tot_locks == 1))
|
|
{
|
|
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;
|
|
}
|
|
{
|
|
char tmp[1];
|
|
tmp[0]=function;
|
|
}
|
|
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);
|
|
}
|
|
if (share->base.blobs && 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 defined(HAVE_MMAP) && defined(HAVE_MADVISE)
|
|
if (info->opt_flag & MEMMAP_USED)
|
|
madvise(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(0)) ||
|
|
my_sync(info->s->kfile.file, MYF(0)));
|
|
}
|