database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Added MARIA_SHARE *share to a lot of places to make code simpler

Browse Source 
Changed info->s -> share to get more efficent code
Updated arguments to page accessor functions to use MARIA_SHARE * instead of MARIA_HA *.
Tested running tests in quick mode (no balance page on insert and only when critical on delete)
Fixed bug in underflow handling in quick mode
Fixed bug in log handler where it accessed not initialized variable
Fixed bug in log handler where it didn't free mutex in unlikely error condition
Removed double write of page in case of of some underflow conditions
Added DBUG_PRINT in safemutex lock/unlock


dbug/dbug.c:
  Compile without SAFE_MUTEX (to be able to use DBUG_PRINT in safe_mutex code)
  Use calls to get/set my_thread_var->dbug. (Make dbug independent of compile time options for mysys)
include/my_pthread.h:
  Added prototypes for my_thread_var_get_dbug() & my_thread_var_set_dbug()
mysql-test/lib/mtr_report.pl:
  Don't check warnings in log files if we are using --extern
mysys/my_thr_init.c:
  Added my_thread_var_get_dbug() & my_thread_var_set_dbug()
mysys/thr_mutex.c:
  Added DBUG printing of addresses to mutex for lock/unlock
storage/maria/ma_blockrec.c:
  Fixed comment
storage/maria/ma_check.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_close.c:
  Indentation fixes
storage/maria/ma_create.c:
  Calculate min_key_length correctly
storage/maria/ma_dbug.c:
  Indentation fixes
storage/maria/ma_delete.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
  Removed some writing of key pages that underflow (will be written by caller)
  Fixed crashing bug in underflow handling when using quick mode
storage/maria/ma_delete_all.c:
  Indentation fixes
storage/maria/ma_dynrec.c:
  Indentation fixes
storage/maria/ma_extra.c:
  Fixed indentation
  Removed old useless code
  Reset share->changed if we have written state
storage/maria/ma_ft_update.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_info.c:
  Indentation fixes
storage/maria/ma_key_recover.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_locking.c:
  Indentation fixes
storage/maria/ma_loghandler.c:
  Removed wrapper functions translog_mutex_lock and translog_mutex_unlock (safemutex now does same kind of printing)
  Renamed LOGREC_REDO_INSERT_ROW_BLOB to LOGREC_REDO_INSERT_NOT_USED to mark it free
  Fixed some DBUG_PRINT to ensure that convert-dbug-for-diff works
  Fixed bug in translog_flush() that caused log to stop syncing to disk
  Added missing mutex_unlock in case of error
storage/maria/ma_loghandler.h:
  Renamed LOGREC_REDO_INSERT_ROW_BLOB to LOGREC_REDO_INSERT_NOT_USED to mark it free
storage/maria/ma_open.c:
  Indentation fixes
storage/maria/ma_packrec.c:
  Indentation fixes
storage/maria/ma_page.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
  Added check that we never write a key page without content (except in recovery where a key page may temporary be without content)
storage/maria/ma_preload.c:
  Updated arguments to page accessor functions
storage/maria/ma_range.c:
  Updated arguments to page accessor functions
storage/maria/ma_rkey.c:
  Indentation fixes
storage/maria/ma_rprev.c:
  Indentation fixes
storage/maria/ma_rt_index.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_rt_index.h:
  Updated arguments to page accessor functions
storage/maria/ma_rt_key.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_rt_mbr.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_rt_split.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_search.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/ma_sort.c:
  Indentation fixes
storage/maria/ma_statrec.c:
  Indentation fixes
storage/maria/ma_test1.c:
  Added extra undo test
  Flush also keys in -u1, to ensure that the full log is flushed
storage/maria/ma_test2.c:
  Added extra undo test
  Flush also keys in -u1, to ensure that the full log is flushed
storage/maria/ma_test_recovery.expected:
  Updated results
storage/maria/ma_test_recovery:
  Added extra undo test
storage/maria/ma_update.c:
  Indentation fixes
storage/maria/ma_write.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
  Prepare for quick mode for insert (don't balance page)
storage/maria/maria_chk.c:
  Added MARIA_SHARE *share to a lot of places to make code simpler
  info->s -> share
  Updated arguments to page accessor functions
storage/maria/maria_def.h:
  Updated arguments to page accessor functions
This commit is contained in:
unknown
2007-12-10 02:32:00 +02:00
parent 14a07e822d
commit 2f6f08ed88
43 changed files with 1227 additions and 799 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
dbug/dbug.c
View File

@ -71,7 +71,12 @@
*
*/
/*
We can't have SAFE_MUTEX defined here as this will cause recursion
in pthread_mutex_lock
*/
#undef SAFE_MUTEX
#include <my_global.h>
#include <m_string.h>
#include <errno.h>
@ -79,7 +84,6 @@
#include <process.h>
#endif
#ifndef DBUG_OFF
@ -322,12 +326,12 @@ static unsigned long Clock(void);
#ifdef THREAD
#include <my_pthread.h>
pthread_mutex_t THR_LOCK_dbug;
static pthread_mutex_t THR_LOCK_dbug;
static CODE_STATE *code_state(void)
{
CODE_STATE *cs=0;
struct st_my_thread_var *tmp;
my_bool error;
if (!init_done)
{
@ -338,9 +342,7 @@ static CODE_STATE *code_state(void)
init_done=TRUE;
}
if ((tmp=my_thread_var))
{
if (!(cs=(CODE_STATE *) tmp->dbug))
if (!(cs= (CODE_STATE*) my_thread_var_get_dbug(&error)) && !error)
{
cs=(CODE_STATE*) DbugMalloc(sizeof(*cs));
bzero((uchar*) cs,sizeof(*cs));
@ -348,8 +350,7 @@ static CODE_STATE *code_state(void)
cs->func="?func";
cs->file="?file";
cs->stack=&init_settings;
tmp->dbug= (void*) cs;
}
my_thread_var_set_dbug((void*) cs);
}
return cs;
}

2
include/my_pthread.h
View File

@ -680,6 +680,8 @@ struct st_my_thread_var
};
extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
extern void *my_thread_var_get_dbug(my_bool *error);
extern void my_thread_var_set_dbug(void *dbug);
extern uint my_thread_end_wait_time;
#define my_thread_var (_my_thread_var())
#define my_errno my_thread_var->thr_errno

2
mysql-test/lib/mtr_report.pl
View File

@ -216,7 +216,7 @@ sub mtr_report_stats ($) {
# the "var/log/*.err" files. We save this info in "var/log/warnings"
# ----------------------------------------------------------------------
if ( ! $::glob_use_running_server )
if ( ! $::glob_use_running_server && !$::opt_extern)
{
# Save and report if there was any fatal warnings/errors in err logs

29
mysys/my_thr_init.c
View File

@ -347,6 +347,9 @@ void my_thread_end(void)
tmp->init= 0;
#endif
#if !defined(__WIN__) || defined(USE_TLS)
pthread_setspecific(THR_KEY_mysys,0);
#endif
/*
Decrement counter for number of running threads. We are using this
in my_thread_global_end() to wait until all threads have called
@ -359,10 +362,12 @@ void my_thread_end(void)
pthread_cond_signal(&THR_COND_threads);
pthread_mutex_unlock(&THR_LOCK_threads);
}
/* The following free has to be done, even if my_thread_var() is 0 */
else
{
#if !defined(__WIN__) || defined(USE_TLS)
pthread_setspecific(THR_KEY_mysys,0);
#endif
}
}
struct st_my_thread_var *_my_thread_var(void)
@ -380,6 +385,28 @@ struct st_my_thread_var *_my_thread_var(void)
return tmp;
}
extern void *my_thread_var_get_dbug(my_bool *error)
{
struct st_my_thread_var *tmp=
my_pthread_getspecific(struct st_my_thread_var*,THR_KEY_mysys);
my_bool tmp_error;
if (!error)
error= &tmp_error;
if (tmp)
{
*error= 0;
return tmp->dbug;
}
*error= 1; /* no THR_KEY_mysys */
return (void*) 0;
}
extern void my_thread_var_set_dbug(void *dbug)
{
struct st_my_thread_var *tmp= _my_thread_var();
tmp->dbug= dbug;
}
/****************************************************************************
Get name of current thread.

12
mysys/thr_mutex.c
View File

@ -94,6 +94,10 @@ int safe_mutex_init(safe_mutex_t *mp,
int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line)
{
int error;
#ifndef DBUG_OFF
if (my_thread_var_get_dbug((my_bool*) 0))
DBUG_PRINT("mutex", ("Locking mutex: 0x%lx", (ulong) mp));
#endif
if (!mp->file)
{
fprintf(stderr,
@ -131,6 +135,10 @@ line %d more than 1 time\n", file,line);
mp->file= file;
mp->line=line;
pthread_mutex_unlock(&mp->global);
#ifndef DBUG_OFF
if (my_thread_var_get_dbug((my_bool*) 0))
DBUG_PRINT("mutex", ("mutex: 0x%lx locked", (ulong) mp));
#endif
return error;
}
@ -138,6 +146,10 @@ line %d more than 1 time\n", file,line);
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line)
{
int error;
#ifndef DBUG_OFF
if (my_thread_var_get_dbug((my_bool*) 0))
DBUG_PRINT("mutex", ("Unlocking mutex 0x%lx", (ulong) mp));
#endif
pthread_mutex_lock(&mp->global);
if (mp->count == 0)
{

411
storage/maria/ma_check.c
View File

File diff suppressed because it is too large Load Diff

2
storage/maria/ma_close.c
View File

@ -26,7 +26,7 @@ int maria_close(register MARIA_HA *info)
{
int error=0,flag;
my_bool share_can_be_freed= FALSE;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_close");
DBUG_PRINT("enter",("base: 0x%lx reopen: %u locks: %u",
(long) info, (uint) share->reopen,

47
storage/maria/ma_create.c
View File

@ -47,7 +47,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
int errpos,save_errno, create_mode= O_RDWR | O_TRUNC, res;
myf create_flag;
uint length,max_key_length,packed,pack_bytes,pointer,real_length_diff,
key_length,info_length,key_segs,options,min_key_length_skip,
key_length,info_length,key_segs,options,min_key_length,
base_pos,long_varchar_count,varchar_length,
unique_key_parts,fulltext_keys,offset, not_block_record_extra_length;
uint max_field_lengths, extra_header_size, column_nr;
@ -396,8 +396,8 @@ int maria_create(const char *name, enum data_file_type datafile_type,
for (i=0, keydef=keydefs ; i < keys ; i++ , keydef++)
{
share.state.key_root[i]= HA_OFFSET_ERROR;
min_key_length_skip=length=real_length_diff=0;
key_length=pointer;
length= real_length_diff= 0;
min_key_length= key_length= pointer;
if (keydef->flag & HA_SPATIAL)
{
#ifdef HAVE_SPATIAL
@ -431,7 +431,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
keydef->keysegs+=sp_segs;
key_length+=SPLEN*sp_segs;
length++; /* At least one length uchar */
min_key_length_skip+=SPLEN*2*SPDIMS;
min_key_length++;
#else
my_errno= HA_ERR_UNSUPPORTED;
goto err_no_lock;
@ -467,7 +467,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
fulltext_keys++;
key_length+= HA_FT_MAXBYTELEN+HA_FT_WLEN;
length++; /* At least one length uchar */
min_key_length_skip+=HA_FT_MAXBYTELEN;
min_key_length+= 1 + HA_FT_WLEN;
real_length_diff=HA_FT_MAXBYTELEN-FT_MAX_WORD_LEN_FOR_SORT;
}
else
@ -536,35 +536,44 @@ int maria_create(const char *name, enum data_file_type datafile_type,
}
if (keyseg->flag & HA_SPACE_PACK)
{
DBUG_ASSERT(!(keyseg->flag & HA_VAR_LENGTH_PART));
DBUG_ASSERT(!(keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART)));
keydef->flag |= HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY;
options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
length++; /* At least one length uchar */
min_key_length_skip+=keyseg->length;
min_key_length++;
key_length+= keyseg->length;
if (keyseg->length >= 255)
{ /* prefix may be 3 bytes */
min_key_length_skip+=2;
length+=2;
{
/* prefix may be 3 bytes */
length+= 2;
}
}
if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
else if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
{
DBUG_ASSERT(!test_all_bits(keyseg->flag,
(HA_VAR_LENGTH_PART | HA_BLOB_PART)));
keydef->flag|=HA_VAR_LENGTH_KEY;
length++; /* At least one length uchar */
min_key_length++;
options|=HA_OPTION_PACK_KEYS; /* Using packed keys */
min_key_length_skip+=keyseg->length;
if (keyseg->length >= 255)
{ /* prefix may be 3 bytes */
min_key_length_skip+=2;
length+=2;
}
}
key_length+= keyseg->length;
if (keyseg->length >= 255)
{
/* prefix may be 3 bytes */
length+= 2;
}
}
else
{
key_length+= keyseg->length;
if (!keyseg->null_bit)
min_key_length+= keyseg->length;
}
if (keyseg->null_bit)
{
key_length++;
/* min key part is 1 byte */
min_key_length++;
options|=HA_OPTION_PACK_KEYS;
keyseg->flag|=HA_NULL_PART;
keydef->flag|=HA_VAR_LENGTH_KEY | HA_NULL_PART_KEY;
@ -598,7 +607,7 @@ int maria_create(const char *name, enum data_file_type datafile_type,
}
keydef->block_length= maria_block_size;
keydef->keylength= (uint16) key_length;
keydef->minlength= (uint16) (length-min_key_length_skip);
keydef->minlength= (uint16) min_key_length;
keydef->maxlength= (uint16) length;
if (length > max_key_length)

2
storage/maria/ma_dbug.c
View File

@ -177,7 +177,7 @@ my_bool _ma_check_table_is_closed(const char *name, const char *where)
for (pos=maria_open_list ; pos ; pos=pos->next)
{
MARIA_HA *info=(MARIA_HA*) pos->data;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
if (!strcmp(share->unique_file_name,filename))
{
if (share->last_version)

201
storage/maria/ma_delete.c
View File

@ -45,7 +45,7 @@ int maria_delete(MARIA_HA *info,const uchar *record)
uchar *old_key;
int save_errno;
char lastpos[8];
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_delete");
/* Test if record is in datafile */
@ -153,22 +153,23 @@ err:
int _ma_ck_delete(register MARIA_HA *info, uint keynr, uchar *key,
uint key_length)
{
MARIA_SHARE *share= info->s;
int res;
LSN lsn= LSN_IMPOSSIBLE;
my_off_t new_root= info->s->state.key_root[keynr];
my_off_t new_root= share->state.key_root[keynr];
uchar key_buff[HA_MAX_KEY_BUFF];
DBUG_ENTER("_ma_ck_delete");
if (info->s->now_transactional)
if (share->now_transactional)
{
/* Save original value as the key may change */
memcpy(key_buff, key, key_length + info->s->rec_reflength);
memcpy(key_buff, key, key_length + share->rec_reflength);
}
res= _ma_ck_real_delete(info, info->s->keyinfo+keynr, key, key_length,
res= _ma_ck_real_delete(info, share->keyinfo+keynr, key, key_length,
&new_root);
if (!res && info->s->now_transactional)
if (!res && share->now_transactional)
{
uchar log_data[LSN_STORE_SIZE + FILEID_STORE_SIZE +
KEY_NR_STORE_SIZE + PAGE_STORE_SIZE], *log_pos;
@ -181,23 +182,23 @@ int _ma_ck_delete(register MARIA_HA *info, uint keynr, uchar *key,
key_nr_store(log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE, keynr);
log_pos= log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE + KEY_NR_STORE_SIZE;
if (new_root != info->s->state.key_root[keynr])
if (new_root != share->state.key_root[keynr])
{
my_off_t page;
page= ((new_root == HA_OFFSET_ERROR) ? IMPOSSIBLE_PAGE_NO :
new_root / info->s->block_size);
new_root / share->block_size);
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
log_type= LOGREC_UNDO_KEY_DELETE_WITH_ROOT;
}
key_length+= info->s->rec_reflength;
key_length+= share->rec_reflength;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= (char*) log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos - log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= (char*) key_buff;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= key_length;
msg.root= &info->s->state.key_root[keynr];
msg.root= &share->state.key_root[keynr];
msg.value= new_root;
if (translog_write_record(&lsn, log_type,
@ -210,7 +211,7 @@ int _ma_ck_delete(register MARIA_HA *info, uint keynr, uchar *key,
}
else
{
info->s->state.key_root[keynr]= new_root;
share->state.key_root[keynr]= new_root;
_ma_fast_unlock_key_del(info);
}
_ma_unpin_all_pages_and_finalize_row(info, lsn);
@ -260,13 +261,14 @@ int _ma_ck_real_delete(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
else /* error == 1 */
{
uint used_length;
_ma_get_used_and_nod(info, root_buff, used_length, nod_flag);
MARIA_SHARE *share= info->s;
_ma_get_used_and_nod(share, root_buff, used_length, nod_flag);
page_link->changed= 1;
if (used_length <= nod_flag + info->s->keypage_header + 1)
if (used_length <= nod_flag + share->keypage_header + 1)
{
error=0;
if (nod_flag)
*root= _ma_kpos(nod_flag, root_buff +info->s->keypage_header +
*root= _ma_kpos(nod_flag, root_buff +share->keypage_header +
nod_flag);
else
*root=HA_OFFSET_ERROR;
@ -311,8 +313,9 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
uchar lastkey[HA_MAX_KEY_BUFF];
MARIA_PINNED_PAGE *leaf_page_link;
MARIA_KEY_PARAM s_temp;
MARIA_SHARE *share= info->s;
DBUG_ENTER("d_search");
DBUG_DUMP("page",anc_buff,_ma_get_page_used(info, anc_buff));
DBUG_DUMP("page",anc_buff,_ma_get_page_used(share, anc_buff));
search_key_length= (comp_flag & SEARCH_FIND) ? key_length : USE_WHOLE_KEY;
flag=(*keyinfo->bin_search)(info,keyinfo,anc_buff,key, search_key_length,
@ -322,9 +325,9 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
DBUG_PRINT("error",("Found wrong key"));
DBUG_RETURN(-1);
}
nod_flag=_ma_test_if_nod(info, anc_buff);
nod_flag= _ma_test_if_nod(share, anc_buff);
if (!flag && keyinfo->flag & HA_FULLTEXT)
if (!flag && (keyinfo->flag & HA_FULLTEXT))
{
uint off;
int subkeys;
@ -359,7 +362,7 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (!(tmp_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&kpos,
lastkey)))
{
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno= HA_ERR_CRASHED;
DBUG_RETURN(-1);
}
@ -373,12 +376,12 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
}
else
{
keyinfo=&info->s->ft2_keyinfo;
keyinfo=&share->ft2_keyinfo;
/* we'll modify key entry 'in vivo' */
kpos-=keyinfo->keylength+nod_flag;
get_key_full_length_rdonly(off, key);
key+=off;
ret_value= _ma_ck_real_delete(info, &info->s->ft2_keyinfo,
ret_value= _ma_ck_real_delete(info, &share->ft2_keyinfo,
key, HA_FT_WLEN, &root);
_ma_dpointer(info, kpos+HA_FT_WLEN, root);
subkeys++;
@ -399,6 +402,7 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
LINT_INIT(leaf_page);
if (nod_flag)
{
/* Read left child page */
leaf_page= _ma_kpos(nod_flag,keypos);
if (!(leaf_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
HA_MAX_KEY_BUFF*2)))
@ -418,7 +422,7 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (!nod_flag)
{
DBUG_PRINT("error",("Didn't find key"));
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED; /* This should newer happend */
goto err;
}
@ -429,7 +433,7 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
else
{ /* Found key */
uint tmp;
uint anc_buff_length= _ma_get_page_used(info, anc_buff);
uint anc_buff_length= _ma_get_page_used(share, anc_buff);
if (!(tmp= remove_key(keyinfo,nod_flag,keypos,lastkey,
anc_buff + anc_buff_length,
&next_block, &s_temp)))
@ -437,23 +441,23 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
anc_page_link->changed= 1;
anc_buff_length-= tmp;
_ma_store_page_used(info, anc_buff, anc_buff_length);
_ma_store_page_used(share, anc_buff, anc_buff_length);
/*
Log initial changes on pages
If there is an underflow, there will be more changes logged to the
page
*/
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_delete(info, anc_page, anc_buff, s_temp.key_pos,
s_temp.changed_length, s_temp.move_length))
DBUG_RETURN(-1);
if (!nod_flag)
{ /* On leaf page */
if (test(anc_buff_length <= (info->quick_mode ?
if (anc_buff_length <= (info->quick_mode ?
MARIA_MIN_KEYBLOCK_LENGTH :
(uint) keyinfo->underflow_block_length)))
(uint) keyinfo->underflow_block_length))
{
/* Page will be written by caller if we return 1 */
DBUG_RETURN(1);
@ -485,7 +489,7 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
(MARIA_PINNED_PAGE*) 0, (uchar*) 0, (my_bool) 0);
}
}
if (ret_value == 0 && _ma_get_page_used(info, anc_buff) >
if (ret_value == 0 && _ma_get_page_used(share, anc_buff) >
(uint) (keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE))
{
/* parent buffer got too big ; We have to split the page */
@ -504,7 +508,7 @@ static int d_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
}
else
{
DBUG_DUMP("page", anc_buff, _ma_get_page_used(info, anc_buff));
DBUG_DUMP("page", anc_buff, _ma_get_page_used(share, anc_buff));
}
my_afree(leaf_buff);
DBUG_PRINT("exit",("Return: %d",ret_value));
@ -532,13 +536,15 @@ err:
@param ret_key Key before keypos in anc_buff
@notes
leaf_buff is written to disk
leaf_buff must be written to disk if retval > 0
anc_buff is not updated on disk. Caller should do this
@return
@retval < 0 Error
@retval 0 OK
@retval 0 OK. leaf_buff is written to disk
@retval 1 key contains key to upper level (from balance page)
leaf_buff has underflow
@retval 2 key contains key to upper level (from split space)
*/
@ -549,17 +555,17 @@ static int del(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uchar *keypos, my_off_t next_block, uchar *ret_key)
{
int ret_value,length;
uint a_length, nod_flag, leaf_length, tmp;
uint a_length, nod_flag, leaf_length, new_leaf_length, tmp;
my_off_t next_page;
uchar keybuff[HA_MAX_KEY_BUFF],*endpos,*next_buff,*key_start, *prev_key;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
MARIA_KEY_PARAM s_temp;
MARIA_PINNED_PAGE *next_page_link;
DBUG_ENTER("del");
DBUG_PRINT("enter",("leaf_page: %ld keypos: 0x%lx", (long) leaf_page,
(ulong) keypos));
_ma_get_used_and_nod(info, leaf_buff, leaf_length, nod_flag);
_ma_get_used_and_nod(share, leaf_buff, leaf_length, nod_flag);
DBUG_DUMP("leaf_buff", leaf_buff, leaf_length);
endpos= leaf_buff + leaf_length;
@ -578,19 +584,19 @@ static int del(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
ret_value= -1;
else
{
DBUG_DUMP("next_page", next_buff, _ma_get_page_used(info, next_buff));
DBUG_DUMP("next_page", next_buff, _ma_get_page_used(share, next_buff));
if ((ret_value= del(info, keyinfo, key, anc_page, anc_buff, next_page,
next_buff, next_page_link, keypos, next_block,
ret_key)) >0)
{
/* Get new length after key was deleted */
endpos=leaf_buff+_ma_get_page_used(info, leaf_buff);
endpos=leaf_buff+_ma_get_page_used(share, leaf_buff);
if (ret_value == 1)
{
ret_value= underflow(info, keyinfo, leaf_page, leaf_buff, next_page,
next_buff, next_page_link, endpos);
if (ret_value == 0 &&
_ma_get_page_used(info, leaf_buff) >
_ma_get_page_used(share, leaf_buff) >
(uint) (keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE))
{
ret_value= (_ma_split_page(info, keyinfo, key,
@ -613,7 +619,13 @@ static int del(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
}
}
leaf_page_link->changed= 1;
if (_ma_write_keypage(info, keyinfo, leaf_page,
/*
If ret_value <> 0, then leaf_page underflowed and caller will have
to handle underflow and write leaf_page to disk.
We can't write it here, as if leaf_page is empty we get an assert
in _ma_write_keypage.
*/
if (ret_value == 0 && _ma_write_keypage(info, keyinfo, leaf_page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, leaf_buff))
goto err;
@ -622,28 +634,44 @@ static int del(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
DBUG_RETURN(ret_value);
}
/* Remove last key from leaf page */
_ma_store_page_used(info, leaf_buff, key_start-leaf_buff);
/*
Remove last key from leaf page
Note that leaf_page page may only have had one key (can normally only
happen in quick mode), in which ase it will now temporary have 0 keys
on it. This will be corrected by the caller as we will return 0.
*/
new_leaf_length= (uint) (key_start - leaf_buff);
_ma_store_page_used(share, leaf_buff, new_leaf_length);
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_suffix(info, leaf_page, leaf_buff, leaf_length,
(uint) (key_start - leaf_buff)))
new_leaf_length))
goto err;
leaf_page_link->changed= 1;
if (new_leaf_length <= (info->quick_mode ? MARIA_MIN_KEYBLOCK_LENGTH :
(uint) keyinfo->underflow_block_length))
{
/* Underflow, leaf_page will be written by caller */
ret_value= 1;
leaf_page_link->changed= 1; /* Safety */
}
else
{
ret_value= 0;
if (_ma_write_keypage(info, keyinfo, leaf_page,
PAGECACHE_LOCK_LEFT_WRITELOCKED, DFLT_INIT_HITS,
leaf_buff))
goto err;
}
/* Place last key in ancestor page on deleted key position */
a_length= _ma_get_page_used(info, anc_buff);
a_length= _ma_get_page_used(share, anc_buff);
endpos=anc_buff+a_length;
if (keypos != anc_buff+info->s->keypage_header + share->base.key_reflength &&
if (keypos != anc_buff+share->keypage_header + share->base.key_reflength &&
!_ma_get_last_key(info,keyinfo,anc_buff,ret_key,keypos,&tmp))
goto err;
prev_key= (keypos == anc_buff + info->s->keypage_header +
prev_key= (keypos == anc_buff + share->keypage_header +
share->base.key_reflength ? 0 : ret_key);
length=(*keyinfo->pack_key)(keyinfo,share->base.key_reflength,
keypos == endpos ? (uchar*) 0 : keypos,
@ -660,14 +688,14 @@ static int del(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
if (!(*keyinfo->get_key)(keyinfo,share->base.key_reflength,&keypos,ret_key))
goto err;
_ma_kpointer(info,keypos - share->base.key_reflength,next_block);
_ma_store_page_used(info, anc_buff, a_length + length);
_ma_store_page_used(share, anc_buff, a_length + length);
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_add(info, anc_page, anc_buff, a_length,
key_start, s_temp.changed_length, s_temp.move_length, 1))
goto err;
DBUG_RETURN(_ma_get_page_used(info, leaf_buff) <=
DBUG_RETURN(new_leaf_length <=
(info->quick_mode ? MARIA_MIN_KEYBLOCK_LENGTH :
(uint) keyinfo->underflow_block_length));
err:
@ -687,6 +715,7 @@ err:
@note
This function writes redo entries for all changes
leaf_page is saved to disk
Caller must save anc_buff
@return
@ -710,26 +739,26 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
uchar *buff,*endpos,*next_keypos,*anc_pos,*half_pos,*prev_key;
uchar *after_key, *anc_end_pos;
MARIA_KEY_PARAM key_deleted, key_inserted;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
MARIA_PINNED_PAGE *next_page_link;
my_bool first_key;
DBUG_ENTER("underflow");
DBUG_PRINT("enter",("leaf_page: %ld keypos: 0x%lx",(long) leaf_page,
(ulong) keypos));
DBUG_DUMP("anc_buff", anc_buff, _ma_get_page_used(info, anc_buff));
DBUG_DUMP("leaf_buff", leaf_buff, _ma_get_page_used(info, leaf_buff));
DBUG_DUMP("anc_buff", anc_buff, _ma_get_page_used(share, anc_buff));
DBUG_DUMP("leaf_buff", leaf_buff, _ma_get_page_used(share, leaf_buff));
buff=info->buff;
info->keyread_buff_used=1;
next_keypos=keypos;
nod_flag= _ma_test_if_nod(info, leaf_buff);
p_length= nod_flag+info->s->keypage_header;
anc_length= _ma_get_page_used(info, anc_buff);
leaf_length= _ma_get_page_used(info, leaf_buff);
nod_flag= _ma_test_if_nod(share, leaf_buff);
p_length= nod_flag+share->keypage_header;
anc_length= _ma_get_page_used(share, anc_buff);
leaf_length= _ma_get_page_used(share, leaf_buff);
key_reflength=share->base.key_reflength;
if (info->s->keyinfo+info->lastinx == keyinfo)
if (share->keyinfo+info->lastinx == keyinfo)
info->page_changed=1;
first_key= keypos == anc_buff + info->s->keypage_header + key_reflength;
first_key= keypos == anc_buff + share->keypage_header + key_reflength;
if ((keypos < anc_buff + anc_length && (info->state->records & 1)) ||
first_key)
@ -755,11 +784,11 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (!_ma_fetch_keypage(info,keyinfo, next_page, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, buff, 0, &next_page_link))
goto err;
next_buff_length= _ma_get_page_used(info, buff);
next_buff_length= _ma_get_page_used(share, buff);
DBUG_DUMP("next", buff, next_buff_length);
/* find keys to make a big key-page */
bmove(next_keypos-key_reflength, buff + info->s->keypage_header,
bmove(next_keypos-key_reflength, buff + share->keypage_header,
key_reflength);
if (!_ma_get_last_key(info,keyinfo,anc_buff,anc_key,next_keypos,&length) ||
!_ma_get_last_key(info,keyinfo,leaf_buff,leaf_key,
@ -778,7 +807,7 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
memcpy(buff, leaf_buff,(size_t) leaf_length);
(*keyinfo->store_key)(keyinfo, buff+leaf_length, &key_inserted);
buff_length= (uint) (endpos-buff);
_ma_store_page_used(info, buff, buff_length);
_ma_store_page_used(share, buff, buff_length);
/* remove key from anc_buff */
if (!(s_length=remove_key(keyinfo,key_reflength,keypos,anc_key,
@ -787,7 +816,7 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
goto err;
new_anc_length= anc_length - s_length;
_ma_store_page_used(info, anc_buff, new_anc_length);
_ma_store_page_used(share, anc_buff, new_anc_length);
if (buff_length <= (uint) (keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE))
{
@ -798,7 +827,7 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
memcpy(leaf_buff, buff, (size_t) buff_length);
if (info->s->now_transactional)
if (share->now_transactional)
{
/* Log changes to parent page */
if (_ma_log_delete(info, anc_page, anc_buff, key_deleted.key_pos,
@ -838,7 +867,7 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
goto err;
new_leaf_length= (uint) (half_pos-buff);
memcpy(leaf_buff, buff, (size_t) new_leaf_length);
_ma_store_page_used(info, leaf_buff, new_leaf_length);
_ma_store_page_used(share, leaf_buff, new_leaf_length);
/* Correct new keypointer to leaf_page */
half_pos=after_key;
@ -858,11 +887,11 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
bmove(keypos,keypos-t_length,(uint) (anc_end_pos-keypos)+t_length);
(*keyinfo->store_key)(keyinfo,keypos, &anc_key_inserted);
new_anc_length+= t_length;
_ma_store_page_used(info, anc_buff, new_anc_length);
_ma_store_page_used(share, anc_buff, new_anc_length);
/* Store key first in new page */
if (nod_flag)
bmove(buff+info->s->keypage_header, half_pos-nod_flag,
bmove(buff+share->keypage_header, half_pos-nod_flag,
(size_t) nod_flag);
if (!(*keyinfo->get_key)(keyinfo,nod_flag,&half_pos,leaf_key))
goto err;
@ -874,9 +903,9 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
bmove(buff+p_length+t_length, half_pos, (size_t) length);
(*keyinfo->store_key)(keyinfo,buff+p_length, &key_inserted);
new_buff_length= length + t_length + p_length;
_ma_store_page_used(info, buff, new_buff_length);
_ma_store_page_used(share, buff, new_buff_length);
if (info->s->now_transactional)
if (share->now_transactional)
{
/*
Log changes to parent page
@ -940,7 +969,8 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
PAGECACHE_LOCK_LEFT_WRITELOCKED, DFLT_INIT_HITS,
leaf_buff))
goto err;
DBUG_RETURN(new_anc_length <= ((info->quick_mode ? MARIA_MIN_BLOCK_LENGTH :
DBUG_RETURN(new_anc_length <=
((info->quick_mode ? MARIA_MIN_KEYBLOCK_LENGTH :
(uint) keyinfo->underflow_block_length)));
}
@ -953,12 +983,12 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (!_ma_fetch_keypage(info, keyinfo, next_page, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, buff, 0, &next_page_link))
goto err;
buff_length= _ma_get_page_used(info, buff);
buff_length= _ma_get_page_used(share, buff);
endpos= buff + buff_length;
DBUG_DUMP("prev",buff,buff_length);
/* find keys to make a big key-page */
bmove(next_keypos - key_reflength, leaf_buff + info->s->keypage_header,
bmove(next_keypos - key_reflength, leaf_buff + share->keypage_header,
key_reflength);
next_keypos=keypos;
if (!(*keyinfo->get_key)(keyinfo,key_reflength,&next_keypos,
@ -988,7 +1018,7 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
key_inserted.move_length);
new_buff_length= buff_length + leaf_length - p_length + t_length;
_ma_store_page_used(info, buff, new_buff_length);
_ma_store_page_used(share, buff, new_buff_length);
/* remove key from anc_buff */
if (!(s_length= remove_key(keyinfo,key_reflength,keypos,anc_key,
@ -997,7 +1027,7 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
goto err;
new_anc_length= anc_length - s_length;
_ma_store_page_used(info, anc_buff, new_anc_length);
_ma_store_page_used(share, anc_buff, new_anc_length);
if (new_buff_length <= (uint) (keyinfo->block_length -
KEYPAGE_CHECKSUM_SIZE))
@ -1007,7 +1037,7 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (_ma_dispose(info, leaf_page, 0))
goto err;
if (info->s->now_transactional)
if (share->now_transactional)
{
/* Log changes to parent page */
if (_ma_log_delete(info, anc_page, anc_buff, key_deleted.key_pos,
@ -1064,11 +1094,11 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
bmove(keypos,keypos-t_length,(uint) (anc_end_pos-keypos)+t_length);
(*keyinfo->store_key)(keyinfo,keypos, &anc_key_inserted);
new_anc_length+= t_length;
_ma_store_page_used(info, anc_buff, new_anc_length);
_ma_store_page_used(share, anc_buff, new_anc_length);
/* Store first key on new page */
if (nod_flag)
bmove(leaf_buff + info->s->keypage_header, half_pos-nod_flag,
bmove(leaf_buff + share->keypage_header, half_pos-nod_flag,
(size_t) nod_flag);
if (!(length=(*keyinfo->get_key)(keyinfo,nod_flag,&half_pos,leaf_key)))
goto err;
@ -1082,11 +1112,11 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
bmove(leaf_buff+p_length+t_length, half_pos, (size_t) length);
(*keyinfo->store_key)(keyinfo,leaf_buff+p_length, &key_inserted);
new_leaf_length= length + t_length + p_length;
_ma_store_page_used(info, leaf_buff, new_leaf_length);
_ma_store_page_used(share, leaf_buff, new_leaf_length);
new_buff_length= (uint) (endpos - buff);
_ma_store_page_used(info, buff, new_buff_length);
_ma_store_page_used(share, buff, new_buff_length);
if (info->s->now_transactional)
if (share->now_transactional)
{
/*
Log changes to parent page
@ -1136,8 +1166,10 @@ static int underflow(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (_ma_write_keypage(info, keyinfo, next_page,
PAGECACHE_LOCK_LEFT_WRITELOCKED, DFLT_INIT_HITS, buff))
goto err;
DBUG_RETURN(new_anc_length <= (uint)
(keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE)/2);
DBUG_RETURN(new_anc_length <=
((info->quick_mode ? MARIA_MIN_KEYBLOCK_LENGTH :
(uint) keyinfo->underflow_block_length)));
err:
DBUG_RETURN(-1);
@ -1326,16 +1358,17 @@ static my_bool _ma_log_delete(MARIA_HA *info, my_off_t page, uchar *buff,
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 9 + 7], *log_pos;
LEX_STRING log_array[TRANSLOG_INTERNAL_PARTS + 3];
MARIA_SHARE *share= info->s;
uint translog_parts;
uint offset= (uint) (key_pos - buff);
DBUG_ENTER("_ma_log_delete");
DBUG_PRINT("enter", ("page: %lu changed_length: %u move_length: %d",
(ulong) page, changed_length, move_length));
DBUG_ASSERT(info->s->now_transactional && move_length);
DBUG_ASSERT(offset + changed_length <= _ma_get_page_used(info, buff));
DBUG_ASSERT(share->now_transactional && move_length);
DBUG_ASSERT(offset + changed_length <= _ma_get_page_used(share, buff));
/* Store address of new root page */
page/= info->s->block_size;
page/= share->block_size;
page_store(log_data + FILEID_STORE_SIZE, page);
log_pos= log_data+ FILEID_STORE_SIZE + PAGE_STORE_SIZE;
log_pos[0]= KEY_OP_OFFSET;
@ -1356,7 +1389,7 @@ static my_bool _ma_log_delete(MARIA_HA *info, my_off_t page, uchar *buff,
#ifdef EXTRA_DEBUG_KEY_CHANGES
{
int page_length= _ma_get_page_used(info, buff);
int page_length= _ma_get_page_used(share, buff);
ha_checksum crc;
crc= my_checksum(0, buff + LSN_STORE_SIZE, page_length - LSN_STORE_SIZE);
log_pos[0]= KEY_OP_CHECK;

2
storage/maria/ma_delete_all.c
View File

@ -31,7 +31,7 @@
int maria_delete_all_rows(MARIA_HA *info)
{
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
my_bool log_record;
DBUG_ENTER("maria_delete_all_rows");

2
storage/maria/ma_dynrec.c
View File

@ -1671,7 +1671,7 @@ int _ma_read_rnd_dynamic_record(MARIA_HA *info,
uint left_len,b_type;
uchar *to;
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_read_rnd_dynamic_record");
info_read=0;

84
storage/maria/ma_extra.c
View File

@ -41,11 +41,10 @@ static void maria_extra_keyflag(MARIA_HA *info,
int maria_extra(MARIA_HA *info, enum ha_extra_function function,
void *extra_arg)
{
int error=0;
int error= 0;
ulong cache_size;
MARIA_SHARE *share=info->s;
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));
@ -53,7 +52,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function 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;
info->page_changed= 1;
/* Next/prev gives first/last */
if (info->opt_flag & READ_CACHE_USED)
{
@ -72,8 +71,8 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
if (info->lock_type == F_UNLCK &&
(share->options & HA_OPTION_PACK_RECORD))
{
error=1; /* Not possibly if not locked */
my_errno=EACCES;
error= 1; /* Not possibly if not locked */
my_errno= EACCES;
break;
}
if (info->s->file_map) /* Don't use cache if mmap */
@ -97,7 +96,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
if (info->opt_flag & WRITE_CACHE_USED)
{
info->opt_flag&= ~WRITE_CACHE_USED;
if ((error=end_io_cache(&info->rec_cache)))
if ((error= end_io_cache(&info->rec_cache)))
break;
}
if (!(info->opt_flag &
@ -111,11 +110,11 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
READ_CACHE,0L,(pbool) (info->lock_type != F_UNLCK),
MYF(share->write_flag & MY_WAIT_IF_FULL))))
{
info->opt_flag|=READ_CACHE_USED;
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;
info->rec_cache.end_of_file= info->state->data_file_length;
}
break;
case HA_EXTRA_REINIT_CACHE:
@ -126,13 +125,13 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
(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;
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 */
error= 1; /* Not possibly if not locked */
break;
}
if (block_records)
@ -148,7 +147,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
(pbool) (info->lock_type != F_UNLCK),
MYF(share->write_flag & MY_WAIT_IF_FULL))))
{
info->opt_flag|=WRITE_CACHE_USED;
info->opt_flag|= WRITE_CACHE_USED;
info->update&= ~(HA_STATE_ROW_CHANGED |
HA_STATE_WRITE_AT_END |
HA_STATE_EXTEND_BLOCK);
@ -162,7 +161,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
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);
error= end_io_cache(&info->rec_cache);
/* Sergei will insert full text index caching here */
}
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
@ -174,7 +173,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
case HA_EXTRA_FLUSH_CACHE:
if (info->opt_flag & WRITE_CACHE_USED)
{
if ((error=flush_io_cache(&info->rec_cache)))
if ((error= flush_io_cache(&info->rec_cache)))
{
maria_print_error(info->s, HA_ERR_CRASHED);
maria_mark_crashed(info); /* Fatal error found */
@ -189,18 +188,18 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
break;
case HA_EXTRA_KEYREAD: /* Read only keys to record */
case HA_EXTRA_REMEMBER_POS:
info->opt_flag |= REMEMBER_OLD_POS;
info->opt_flag|= REMEMBER_OLD_POS;
bmove((uchar*) info->lastkey+share->base.max_key_length*2,
(uchar*) 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;
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->opt_flag|= KEY_READ_USED;
info->read_record= _ma_read_key_record;
break;
case HA_EXTRA_NO_KEYREAD:
@ -213,7 +212,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
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->lastkey_length= info->save_lastkey_length;
}
info->read_record= share->read_record;
info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
@ -222,10 +221,10 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
info->lock_type= F_EXTRA_LCK; /* Simulate as locked */
break;
case HA_EXTRA_WAIT_LOCK:
info->lock_wait=0;
info->lock_wait= 0;
break;
case HA_EXTRA_NO_WAIT_LOCK:
info->lock_wait=MY_DONT_WAIT;
info->lock_wait= MY_DONT_WAIT;
break;
case HA_EXTRA_NO_KEYS:
/* we're going to modify pieces of the state, stall Checkpoint */
@ -233,14 +232,14 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
if (info->lock_type == F_UNLCK)
{
pthread_mutex_unlock(&share->intern_lock);
error=1; /* Not possibly if not lock */
error= 1; /* Not possibly if not lock */
break;
}
if (maria_is_any_key_active(share->state.key_map))
{
MARIA_KEYDEF *key=share->keyinfo;
MARIA_KEYDEF *key= share->keyinfo;
uint i;
for (i=0 ; i < share->base.keys ; i++,key++)
for (i =0 ; i < share->base.keys ; i++,key++)
{
if (!(key->flag & HA_NOSAME) && info->s->base.auto_key != i+1)
{
@ -252,10 +251,10 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
if (!share->changed)
{
share->state.changed|= STATE_CHANGED | STATE_NOT_ANALYZED;
share->changed=1; /* Update on close */
share->changed= 1; /* Update on close */
if (!share->global_changed)
{
share->global_changed=1;
share->global_changed= 1;
share->state.open_count++;
}
}
@ -280,11 +279,15 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
*/
/** @todo consider porting these flush-es to MyISAM */
error= _ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_FORCE_WRITE, FLUSH_FORCE_WRITE) ||
_ma_state_info_write(share, 1|2|4);
#ifdef ASK_MONTY
|| (share->changed= 0);
#endif
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);
}
/**
@todo RECOVERY BUG
Though we flushed the state, IF some other thread may have the same
@ -308,6 +311,7 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
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
@ -325,12 +329,12 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
if (share->kfile.file >= 0)
_ma_decrement_open_count(info);
pthread_mutex_lock(&share->intern_lock);
enum flush_type type= do_flush ? FLUSH_RELEASE : FLUSH_IGNORE_CHANGED;
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;
share->changed= 1;
}
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
{
@ -378,12 +382,12 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
#endif
if (share->not_flushed)
{
share->not_flushed=0;
share->not_flushed= 0;
if (_ma_sync_table_files(info))
error= my_errno;
if (error)
{
share->changed=1;
share->changed= 1;
maria_print_error(info->s, HA_ERR_CRASHED);
maria_mark_crashed(info); /* Fatal error found */
}
@ -397,10 +401,10 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
}
break;
case HA_EXTRA_NORMAL: /* Theese isn't in use */
info->quick_mode=0;
info->quick_mode= 0;
break;
case HA_EXTRA_QUICK:
info->quick_mode=1;
info->quick_mode= 1;
break;
case HA_EXTRA_NO_ROWS:
if (!share->state.header.uniques)
@ -451,10 +455,6 @@ int maria_extra(MARIA_HA *info, enum ha_extra_function function,
default:
break;
}
{
char tmp[1];
tmp[0]=function;
}
DBUG_RETURN(error);
} /* maria_extra */
@ -487,7 +487,7 @@ static void maria_extra_keyflag(MARIA_HA *info,
int maria_reset(MARIA_HA *info)
{
int error= 0;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_reset");
/*
Free buffers and reset the following flags:
@ -514,7 +514,7 @@ int maria_reset(MARIA_HA *info)
MADV_RANDOM);
#endif
info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
info->quick_mode=0;
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;

15
storage/maria/ma_ft_update.c
View File

@ -304,9 +304,10 @@ uint _ma_ft_make_key(MARIA_HA *info, uint keynr, uchar *keybuf, FT_WORD *wptr,
uint _ma_ft_convert_to_ft2(MARIA_HA *info, uint keynr, uchar *key)
{
MARIA_SHARE *share= info->s;
my_off_t root;
DYNAMIC_ARRAY *da=info->ft1_to_ft2;
MARIA_KEYDEF *keyinfo=&info->s->ft2_keyinfo;
MARIA_KEYDEF *keyinfo=&share->ft2_keyinfo;
uchar *key_ptr= (uchar*) dynamic_array_ptr(da, 0), *end;
uint length, key_length;
MARIA_PINNED_PAGE tmp_page_link, *page_link= &tmp_page_link;
@ -328,10 +329,10 @@ uint _ma_ft_convert_to_ft2(MARIA_HA *info, uint keynr, uchar *key)
}
/* creating pageful of keys */
bzero(info->buff, info->s->keypage_header);
_ma_store_keynr(info, info->buff, keynr);
_ma_store_page_used(info, info->buff, length + info->s->keypage_header);
memcpy(info->buff + info->s->keypage_header, key_ptr, length);
bzero(info->buff, share->keypage_header);
_ma_store_keynr(share, info->buff, keynr);
_ma_store_page_used(share, info->buff, length + share->keypage_header);
memcpy(info->buff + share->keypage_header, key_ptr, length);
info->keyread_buff_used= info->page_changed=1; /* info->buff is used */
if ((root= _ma_new(info, DFLT_INIT_HITS, &page_link)) == HA_OFFSET_ERROR ||
_ma_write_keypage(info, keyinfo, root, page_link->write_lock,
@ -349,8 +350,8 @@ uint _ma_ft_convert_to_ft2(MARIA_HA *info, uint keynr, uchar *key)
_ma_dpointer(info, key+key_length+HA_FT_WLEN, root);
DBUG_RETURN(_ma_ck_real_write_btree(info,
info->s->keyinfo+keynr,
share->keyinfo+keynr,
key, 0,
&info->s->state.key_root[keynr],
&share->state.key_root[keynr],
SEARCH_SAME));
}

2
storage/maria/ma_info.c
View File

@ -34,7 +34,7 @@ MARIA_RECORD_POS maria_position(MARIA_HA *info)
int maria_status(MARIA_HA *info, register MARIA_INFO *x, uint flag)
{
MY_STAT state;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_status");
x->recpos= info->cur_row.lastpos;

17
storage/maria/ma_key_recover.c
View File

@ -258,7 +258,7 @@ my_bool _ma_log_prefix(MARIA_HA *info, my_off_t page,
#ifdef EXTRA_DEBUG_KEY_CHANGES
{
int page_length= _ma_get_page_used(info, buff);
int page_length= _ma_get_page_used(info->s, buff);
ha_checksum crc;
crc= my_checksum(0, buff + LSN_STORE_SIZE, page_length - LSN_STORE_SIZE);
log_pos[0]= KEY_OP_CHECK;
@ -442,10 +442,11 @@ my_bool _ma_log_add(MARIA_HA *info, my_off_t page, uchar *buff,
#ifdef EXTRA_DEBUG_KEY_CHANGES
{
MARIA_SHARE *share= info->s;
ha_checksum crc;
uint save_page_length= _ma_get_page_used(info, buff);
uint save_page_length= _ma_get_page_used(share, buff);
uint new_length= buff_length + move_length;
_ma_store_page_used(info, buff, new_length);
_ma_store_page_used(share, buff, new_length);
crc= my_checksum(0, buff + LSN_STORE_SIZE, new_length - LSN_STORE_SIZE);
log_pos[0]= KEY_OP_CHECK;
int2store(log_pos+1, new_length);
@ -455,7 +456,7 @@ my_bool _ma_log_add(MARIA_HA *info, my_off_t page, uchar *buff,
log_array[TRANSLOG_INTERNAL_PARTS + translog_parts].length= 7;
changed_length+= 7;
translog_parts++;
_ma_store_page_used(info, buff, save_page_length);
_ma_store_page_used(share, buff, save_page_length);
}
#endif
@ -635,7 +636,7 @@ uint _ma_apply_redo_index_free_page(MARIA_HA *info,
}
/* Free page */
bzero(buff + LSN_STORE_SIZE, share->keypage_header - LSN_STORE_SIZE);
_ma_store_keynr(info, buff, (uchar) MARIA_DELETE_KEY_NR);
_ma_store_keynr(info->s, buff, (uchar) MARIA_DELETE_KEY_NR);
mi_sizestore(buff + share->keypage_header, old_link);
share->state.changed|= STATE_NOT_SORTED_PAGES;
@ -727,7 +728,7 @@ uint _ma_apply_redo_index(MARIA_HA *info,
goto err;
}
_ma_get_used_and_nod(info, buff, page_length, nod_flag);
_ma_get_used_and_nod(share, buff, page_length, nod_flag);
keypage_header= share->keypage_header;
org_page_length= page_length;
DBUG_PRINT("info", ("page_length: %u", page_length));
@ -818,7 +819,7 @@ uint _ma_apply_redo_index(MARIA_HA *info,
ha_checksum crc;
check_page_length= uint2korr(header);
crc= uint4korr(header+2);
_ma_store_page_used(info, buff, page_length);
_ma_store_page_used(share, buff, page_length);
DBUG_ASSERT(check_page_length == page_length);
DBUG_ASSERT(crc == (uint32) my_checksum(0, buff + LSN_STORE_SIZE,
page_length- LSN_STORE_SIZE));
@ -836,7 +837,7 @@ uint _ma_apply_redo_index(MARIA_HA *info,
DBUG_ASSERT(header == header_end);
/* Write modified page */
_ma_store_page_used(info, buff, page_length);
_ma_store_page_used(share, buff, page_length);
/*
Clean old stuff up. Gives us better compression of we archive things

10
storage/maria/ma_locking.c
View File

@ -28,7 +28,7 @@ int maria_lock_database(MARIA_HA *info, int lock_type)
{
int error;
uint count;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_lock_database");
DBUG_PRINT("enter",("lock_type: %d old lock %d r_locks: %u w_locks: %u "
"global_changed: %d open_count: %u name: '%s'",
@ -383,7 +383,7 @@ int _ma_readinfo(register MARIA_HA *info __attribute__ ((unused)),
if (info->lock_type == F_UNLCK)
{
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
if (!share->tot_locks)
{
/* should not be done for transactional tables */
@ -471,7 +471,7 @@ int _ma_writeinfo(register MARIA_HA *info, uint operation)
int _ma_test_if_changed(register MARIA_HA *info)
{
#ifdef EXTERNAL_LOCKING
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
if (share->state.process != share->last_process ||
share->state.unique != info->last_unique ||
share->state.update_count != info->last_loop)
@ -518,7 +518,7 @@ int _ma_test_if_changed(register MARIA_HA *info)
int _ma_mark_file_changed(MARIA_HA *info)
{
uchar buff[3];
register MARIA_SHARE *share=info->s;
register MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_mark_file_changed");
if (!(share->state.changed & STATE_CHANGED) || ! share->global_changed)
@ -556,7 +556,7 @@ int _ma_mark_file_changed(MARIA_HA *info)
int _ma_decrement_open_count(MARIA_HA *info)
{
uchar buff[2];
register MARIA_SHARE *share=info->s;
register MARIA_SHARE *share= info->s;
int lock_error=0,write_error=0;
if (share->global_changed)
{

112
storage/maria/ma_loghandler.c
View File

@ -63,30 +63,6 @@
#define COMPRESSED_LSN_MAX_STORE_SIZE (2 + LSN_STORE_SIZE)
#define MAX_NUMBER_OF_LSNS_PER_RECORD 2
#ifndef DBUG_OFF
static int translog_mutex_lock(pthread_mutex_t *M)
{
int rc;
DBUG_PRINT("info", ("Going to lock mutex 0x%lx", (ulong)M));
rc= pthread_mutex_lock(M);
DBUG_PRINT("info", ("Mutex locked 0x%lx rc: %d", (ulong)M, rc));
return (rc);
}
static int translog_mutex_unlock(pthread_mutex_t *M)
{
int rc;
DBUG_PRINT("info", ("Going to unlock mutex 0x%lx", (ulong)M));
rc= pthread_mutex_unlock(M);
DBUG_PRINT("info", ("Mutex unlocked 0x%lx rc: %d", (ulong)M, rc));
return(rc);
}
#else
#define translog_mutex_lock(M) pthread_mutex_lock(M)
#define translog_mutex_unlock(M) pthread_mutex_unlock(M)
#endif
/* log write buffer descriptor */
struct st_translog_buffer
@ -377,8 +353,8 @@ static LOG_DESC INIT_LOGREC_REDO_INSERT_ROW_TAIL=
write_hook_for_redo, NULL, 0,
"redo_insert_row_tail", LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};
/** @todo RECOVERY BUG unused, remove? */
static LOG_DESC INIT_LOGREC_REDO_INSERT_ROW_BLOB=
/* Use this entry next time we need to add a new entry */
static LOG_DESC INIT_LOGREC_REDO_NOT_USED=
{LOGRECTYPE_VARIABLE_LENGTH, 0, 8, NULL, write_hook_for_redo, NULL, 0,
"redo_insert_row_blob", LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};
@ -565,8 +541,8 @@ static void loghandler_init()
INIT_LOGREC_REDO_INSERT_ROW_HEAD;
log_record_type_descriptor[LOGREC_REDO_INSERT_ROW_TAIL]=
INIT_LOGREC_REDO_INSERT_ROW_TAIL;
log_record_type_descriptor[LOGREC_REDO_INSERT_ROW_BLOB]=
INIT_LOGREC_REDO_INSERT_ROW_BLOB;
log_record_type_descriptor[LOGREC_REDO_NOT_USED]=
INIT_LOGREC_REDO_NOT_USED;
log_record_type_descriptor[LOGREC_REDO_INSERT_ROW_BLOBS]=
INIT_LOGREC_REDO_INSERT_ROW_BLOBS;
log_record_type_descriptor[LOGREC_REDO_PURGE_ROW_HEAD]=
@ -951,7 +927,7 @@ static my_bool translog_set_lsn_for_files(uint32 from_file, uint32 to_file,
translog_unlock();
/* Checks finished files if they are */
translog_mutex_lock(&log_descriptor.file_header_lock);
pthread_mutex_lock(&log_descriptor.file_header_lock);
for (file= from_file; file <= to_file; file++)
{
LOGHANDLER_FILE_INFO info;
@ -962,7 +938,7 @@ static my_bool translog_set_lsn_for_files(uint32 from_file, uint32 to_file,
translog_max_lsn_to_header(fd, lsn)))
DBUG_RETURN(1);
}
translog_mutex_unlock(&log_descriptor.file_header_lock);
pthread_mutex_unlock(&log_descriptor.file_header_lock);
DBUG_RETURN(0);
}
@ -991,7 +967,7 @@ static void translog_mark_file_unfinished(uint32 file)
DBUG_ENTER("translog_mark_file_unfinished");
DBUG_PRINT("enter", ("file: %lu", (ulong) file));
translog_mutex_lock(&log_descriptor.unfinished_files_lock);
pthread_mutex_lock(&log_descriptor.unfinished_files_lock);
if (log_descriptor.unfinished_files.elements == 0)
{
@ -1042,7 +1018,7 @@ static void translog_mark_file_unfinished(uint32 file)
place + 1, struct st_file_counter *),
&fc, sizeof(struct st_file_counter));
end:
translog_mutex_unlock(&log_descriptor.unfinished_files_lock);
pthread_mutex_unlock(&log_descriptor.unfinished_files_lock);
DBUG_VOID_RETURN;
}
@ -1063,7 +1039,7 @@ static void translog_mark_file_finished(uint32 file)
LINT_INIT(fc_ptr);
translog_mutex_lock(&log_descriptor.unfinished_files_lock);
pthread_mutex_lock(&log_descriptor.unfinished_files_lock);
DBUG_ASSERT(log_descriptor.unfinished_files.elements > 0);
for (i= 0;
@ -1081,7 +1057,7 @@ static void translog_mark_file_finished(uint32 file)
if (! --fc_ptr->counter)
delete_dynamic_element(&log_descriptor.unfinished_files, i);
translog_mutex_unlock(&log_descriptor.unfinished_files_lock);
pthread_mutex_unlock(&log_descriptor.unfinished_files_lock);
DBUG_VOID_RETURN;
}
@ -1104,7 +1080,7 @@ LSN translog_get_file_max_lsn_stored(uint32 file)
DBUG_PRINT("enter", ("file: %lu", (ulong)file));
DBUG_ASSERT(translog_inited == 1);
translog_mutex_lock(&log_descriptor.unfinished_files_lock);
pthread_mutex_lock(&log_descriptor.unfinished_files_lock);
/* find file with minimum file number "in progress" */
if (log_descriptor.unfinished_files.elements > 0)
@ -1114,7 +1090,7 @@ LSN translog_get_file_max_lsn_stored(uint32 file)
0, struct st_file_counter *);
limit= fc_ptr->file; /* minimal file number "in progress" */
}
translog_mutex_unlock(&log_descriptor.unfinished_files_lock);
pthread_mutex_unlock(&log_descriptor.unfinished_files_lock);
/*
if there is no "in progress file" then unfinished file is in progress
@ -1280,7 +1256,7 @@ static my_bool translog_buffer_lock(struct st_translog_buffer *buffer)
("Lock buffer #%u: (0x%lx) mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
res= (translog_mutex_lock(&buffer->mutex) != 0);
res= (pthread_mutex_lock(&buffer->mutex) != 0);
DBUG_RETURN(test(res));
}
#else
@ -1311,8 +1287,8 @@ static my_bool translog_buffer_unlock(struct st_translog_buffer *buffer)
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
res= (translog_mutex_unlock(&buffer->mutex) != 0);
DBUG_PRINT("enter", ("Unlocked buffer... #%u: 0x%lx mutex: 0x%lx",
res= (pthread_mutex_unlock(&buffer->mutex) != 0);
DBUG_PRINT("exit", ("Unlocked buffer... #%u: 0x%lx mutex: 0x%lx",
(uint) buffer->buffer_no, (ulong) buffer,
(ulong) &buffer->mutex));
DBUG_RETURN(res);
@ -1779,7 +1755,7 @@ static my_bool translog_buffer_next(TRANSLOG_ADDRESS *horizon,
static void translog_set_sent_to_disk(LSN lsn, TRANSLOG_ADDRESS in_buffers)
{
DBUG_ENTER("translog_set_sent_to_disk");
translog_mutex_lock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
DBUG_PRINT("enter", ("lsn: (%lu,0x%lx) in_buffers: (%lu,0x%lx) "
"in_buffers_only: (%lu,0x%lx)",
LSN_IN_PARTS(lsn),
@ -1793,7 +1769,7 @@ static void translog_set_sent_to_disk(LSN lsn, TRANSLOG_ADDRESS in_buffers)
log_descriptor.in_buffers_only= in_buffers;
DBUG_PRINT("info", ("set new in_buffers_only"));
}
translog_mutex_unlock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_VOID_RETURN;
}
@ -1810,7 +1786,7 @@ static void translog_set_sent_to_disk(LSN lsn, TRANSLOG_ADDRESS in_buffers)
static void translog_set_only_in_buffers(TRANSLOG_ADDRESS in_buffers)
{
DBUG_ENTER("translog_set_only_in_buffers");
translog_mutex_lock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
DBUG_PRINT("enter", ("in_buffers: (%lu,0x%lx) "
"in_buffers_only: (%lu,0x%lx)",
LSN_IN_PARTS(in_buffers),
@ -1821,7 +1797,7 @@ static void translog_set_only_in_buffers(TRANSLOG_ADDRESS in_buffers)
log_descriptor.in_buffers_only= in_buffers;
DBUG_PRINT("info", ("set new in_buffers_only"));
}
translog_mutex_unlock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_VOID_RETURN;
}
@ -1840,9 +1816,9 @@ static TRANSLOG_ADDRESS translog_only_in_buffers()
{
register TRANSLOG_ADDRESS addr;
DBUG_ENTER("translog_only_in_buffers");
translog_mutex_lock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
addr= log_descriptor.in_buffers_only;
translog_mutex_unlock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_RETURN(addr);
}
@ -1861,9 +1837,9 @@ static LSN translog_get_sent_to_disk()
{
register LSN lsn;
DBUG_ENTER("translog_get_sent_to_disk");
translog_mutex_lock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_lock(&log_descriptor.sent_to_disk_lock);
lsn= log_descriptor.sent_to_disk;
translog_mutex_unlock(&log_descriptor.sent_to_disk_lock);
pthread_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_RETURN(lsn);
}
@ -2075,8 +2051,7 @@ static my_bool translog_buffer_flush(struct st_translog_buffer *buffer)
PAGECACHE_FILE file;
DBUG_ENTER("translog_buffer_flush");
DBUG_PRINT("enter",
("Buffer: #%u 0x%lx: "
"file: %d offset: (%lu,0x%lx) size: %lu",
("Buffer: #%u 0x%lx file: %d offset: (%lu,0x%lx) size: %lu",
(uint) buffer->buffer_no, (ulong) buffer,
buffer->file,
LSN_IN_PARTS(buffer->offset),
@ -3648,7 +3623,7 @@ translog_buffer_increase_writers(struct st_translog_buffer *buffer)
DBUG_ENTER("translog_buffer_increase_writers");
translog_buffer_lock_assert_owner(buffer);
buffer->copy_to_buffer_in_progress++;
DBUG_PRINT("info", ("copy_to_buffer_in_progress. Buffer #%u 0x%lx: %d",
DBUG_PRINT("info", ("copy_to_buffer_in_progress. Buffer #%u 0x%lx progress: %d",
(uint) buffer->buffer_no, (ulong) buffer,
buffer->copy_to_buffer_in_progress));
DBUG_VOID_RETURN;
@ -3669,7 +3644,8 @@ static void translog_buffer_decrease_writers(struct st_translog_buffer *buffer)
DBUG_ENTER("translog_buffer_decrease_writers");
translog_buffer_lock_assert_owner(buffer);
buffer->copy_to_buffer_in_progress--;
DBUG_PRINT("info", ("copy_to_buffer_in_progress. Buffer #%u 0x%lx: %d",
DBUG_PRINT("info",
("copy_to_buffer_in_progress. Buffer #%u 0x%lx progress: %d",
(uint) buffer->buffer_no, (ulong) buffer,
buffer->copy_to_buffer_in_progress));
if (buffer->copy_to_buffer_in_progress == 0 &&
@ -6620,7 +6596,7 @@ my_bool translog_flush(LSN lsn)
DBUG_ASSERT(translog_inited == 1);
LINT_INIT(sent_to_disk);
translog_mutex_lock(&log_descriptor.log_flush_lock);
pthread_mutex_lock(&log_descriptor.log_flush_lock);
translog_lock();
flush_horizon= LSN_IMPOSSIBLE;
old_flushed= log_descriptor.flushed;
@ -6630,16 +6606,16 @@ my_bool translog_flush(LSN lsn)
uint16 buffer_start= buffer_no;
struct st_translog_buffer *buffer_unlock= log_descriptor.bc.buffer;
struct st_translog_buffer *buffer= log_descriptor.bc.buffer;
if (cmp_translog_addr(log_descriptor.flushed, lsn) >= 0 ||
full_circle)
if (cmp_translog_addr(log_descriptor.flushed, lsn) >= 0)
{
DBUG_PRINT("info", ("already flushed: (%lu,0x%lx)",
LSN_IN_PARTS(log_descriptor.flushed)));
goto sync;
translog_unlock();
goto out;
}
/* send to the file if it is not sent */
sent_to_disk= translog_get_sent_to_disk();
if (cmp_translog_addr(sent_to_disk, lsn) >= 0)
if (cmp_translog_addr(sent_to_disk, lsn) >= 0 || full_circle)
break;
do
@ -6679,6 +6655,8 @@ my_bool translog_flush(LSN lsn)
if ((log_descriptor.log_file_num[cache_index]=
open_logfile_by_number_no_cache(fn)) == -1)
{
/* We don't need translog_unlock() here */
translog_buffer_unlock(buffer);
rc= 1;
goto out;
}
@ -6694,13 +6672,9 @@ my_bool translog_flush(LSN lsn)
rc= translog_buffer_flush(buffer);
translog_buffer_unlock(buffer);
if (rc)
{
rc= 1;
goto out;
}
goto out; /* rc is 1 */
translog_lock();
}
sync:
translog_unlock();
{
@ -6723,7 +6697,7 @@ sync:
rc|= my_sync(log_descriptor.directory_fd, MYF(MY_WME | MY_IGNORE_BADFD));
log_descriptor.previous_flush_horizon= flush_horizon;
out:
translog_mutex_unlock(&log_descriptor.log_flush_lock);
pthread_mutex_unlock(&log_descriptor.log_flush_lock);
DBUG_RETURN(rc);
}
@ -6754,7 +6728,7 @@ int translog_assign_id_to_share(MARIA_HA *tbl_info, TRN *trn)
*/
DBUG_ASSERT(share->data_file_type == BLOCK_RECORD);
/* re-check under mutex to avoid having 2 ids for the same share */
translog_mutex_lock(&share->intern_lock);
pthread_mutex_lock(&share->intern_lock);
if (likely(share->id == 0))
{
/* Inspired by set_short_trid() of trnman.c */
@ -6801,7 +6775,7 @@ int translog_assign_id_to_share(MARIA_HA *tbl_info, TRN *trn)
log_array, log_data, NULL)))
return 1;
}
translog_mutex_unlock(&share->intern_lock);
pthread_mutex_unlock(&share->intern_lock);
return 0;
}
@ -6878,14 +6852,14 @@ static uint32 translog_first_file(TRANSLOG_ADDRESS horizon, int is_protected)
uint min_file= 1, max_file;
DBUG_ENTER("translog_first_file");
if (!is_protected)
translog_mutex_lock(&log_descriptor.purger_lock);
pthread_mutex_lock(&log_descriptor.purger_lock);
if (log_descriptor.min_file_number &&
translog_is_file(log_descriptor.min_file_number))
{
DBUG_PRINT("info", ("cached %lu",
(ulong) log_descriptor.min_file_number));
if (!is_protected)
translog_mutex_unlock(&log_descriptor.purger_lock);
pthread_mutex_unlock(&log_descriptor.purger_lock);
DBUG_RETURN(log_descriptor.min_file_number);
}
@ -6912,7 +6886,7 @@ static uint32 translog_first_file(TRANSLOG_ADDRESS horizon, int is_protected)
}
log_descriptor.min_file_number= max_file;
if (!is_protected)
translog_mutex_unlock(&log_descriptor.purger_lock);
pthread_mutex_unlock(&log_descriptor.purger_lock);
DBUG_RETURN(max_file);
}
@ -7102,7 +7076,7 @@ my_bool translog_purge(TRANSLOG_ADDRESS low)
DBUG_PRINT("enter", ("low: (%lu,0x%lx)", LSN_IN_PARTS(low)));
DBUG_ASSERT(translog_inited == 1);
translog_mutex_lock(&log_descriptor.purger_lock);
pthread_mutex_lock(&log_descriptor.purger_lock);
if (LSN_FILE_NO(log_descriptor.last_lsn_checked) < last_need_file)
{
uint32 i;
@ -7130,6 +7104,6 @@ my_bool translog_purge(TRANSLOG_ADDRESS low)
}
}
translog_mutex_unlock(&log_descriptor.purger_lock);
pthread_mutex_unlock(&log_descriptor.purger_lock);
DBUG_RETURN(rc);
}

2
storage/maria/ma_loghandler.h
View File

@ -105,7 +105,7 @@ enum translog_record_type
LOGREC_RESERVED_FOR_CHUNKS23= 0,
LOGREC_REDO_INSERT_ROW_HEAD,
LOGREC_REDO_INSERT_ROW_TAIL,
LOGREC_REDO_INSERT_ROW_BLOB,
LOGREC_REDO_NOT_USED, /* Reserver for next tag */
LOGREC_REDO_INSERT_ROW_BLOBS,
LOGREC_REDO_PURGE_ROW_HEAD,
LOGREC_REDO_PURGE_ROW_TAIL,

2
storage/maria/ma_open.c
View File

@ -64,7 +64,7 @@ MARIA_HA *_ma_test_if_reopen(const char *filename)
for (pos=maria_open_list ; pos ; pos=pos->next)
{
MARIA_HA *info=(MARIA_HA*) pos->data;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
if (!strcmp(share->unique_file_name,filename) && share->last_version)
return info;
}

10
storage/maria/ma_packrec.c
View File

@ -774,7 +774,7 @@ int _ma_pack_rec_unpack(register MARIA_HA *info, MARIA_BIT_BUFF *bit_buff,
uchar *end_field;
reg3 MARIA_COLUMNDEF *end;
MARIA_COLUMNDEF *current_field;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_pack_rec_unpack");
if (info->s->base.null_bytes)
@ -1349,7 +1349,7 @@ int _ma_read_rnd_pack_record(MARIA_HA *info,
{
File file;
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_read_rnd_pack_record");
if (filepos >= info->state->data_file_length)
@ -1544,7 +1544,7 @@ static int _ma_read_rnd_mempack_record(MARIA_HA*, uchar *, MARIA_RECORD_POS,
my_bool _ma_memmap_file(MARIA_HA *info)
{
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_memmap_file");
if (!info->s->file_map)
@ -1601,7 +1601,7 @@ static int _ma_read_mempack_record(MARIA_HA *info, uchar *buf,
MARIA_RECORD_POS filepos)
{
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
uchar *pos;
DBUG_ENTER("maria_read_mempack_record");
@ -1627,7 +1627,7 @@ static int _ma_read_rnd_mempack_record(MARIA_HA *info,
__attribute__((unused)))
{
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
uchar *pos,*start;
DBUG_ENTER("_ma_read_rnd_mempack_record");

55
storage/maria/ma_page.c
View File

@ -30,14 +30,15 @@ uchar *_ma_fetch_keypage(register MARIA_HA *info,
{
uchar *tmp;
uint page_size;
uint block_size= info->s->block_size;
MARIA_PINNED_PAGE page_link;
MARIA_SHARE *share= info->s;
uint block_size= share->block_size;
DBUG_ENTER("_ma_fetch_keypage");
DBUG_PRINT("enter",("page: %ld", (long) page));
tmp= pagecache_read(info->s->pagecache, &info->s->kfile,
tmp= pagecache_read(share->pagecache, &share->kfile,
page / block_size, level, buff,
info->s->page_type, lock, &page_link.link);
share->page_type, lock, &page_link.link);
if (lock != PAGECACHE_LOCK_LEFT_UNLOCKED)
{
@ -56,22 +57,22 @@ uchar *_ma_fetch_keypage(register MARIA_HA *info,
{
DBUG_PRINT("error",("Got errno: %d from pagecache_read",my_errno));
info->last_keypage=HA_OFFSET_ERROR;
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(0);
}
info->last_keypage=page;
#ifdef EXTRA_DEBUG
page_size= _ma_get_page_used(info, tmp);
page_size= _ma_get_page_used(share, tmp);
if (page_size < 4 || page_size > block_size ||
_ma_get_keynr(info, tmp) != keyinfo->key_nr)
_ma_get_keynr(share, tmp) != keyinfo->key_nr)
{
DBUG_PRINT("error",("page %lu had wrong page length: %u keynr: %u",
(ulong) page, page_size,
_ma_get_keynr(info, tmp)));
_ma_get_keynr(share, tmp)));
DBUG_DUMP("page", (char*) tmp, page_size);
info->last_keypage = HA_OFFSET_ERROR;
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno= HA_ERR_CRASHED;
tmp= 0;
}
@ -86,30 +87,38 @@ int _ma_write_keypage(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
my_off_t page, enum pagecache_page_lock lock,
int level, uchar *buff)
{
uint block_size= info->s->block_size;
MARIA_SHARE *share= info->s;
MARIA_PINNED_PAGE page_link;
uint block_size= share->block_size;
int res;
DBUG_ENTER("_ma_write_keypage");
#ifdef EXTRA_DEBUG /* Safety check */
if (page < info->s->base.keystart ||
{
uint page_length, nod;
_ma_get_used_and_nod(share, buff, page_length, nod);
if (page < share->base.keystart ||
page+block_size > info->state->key_file_length ||
(page & (MARIA_MIN_KEY_BLOCK_LENGTH-1)))
{
DBUG_PRINT("error",("Trying to write inside key status region: "
"key_start: %lu length: %lu page: %lu",
(long) info->s->base.keystart,
(long) share->base.keystart,
(long) info->state->key_file_length,
(long) page));
my_errno=EINVAL;
DBUG_ASSERT(0);
DBUG_RETURN((-1));
}
DBUG_PRINT("page",("write page at: %lu",(long) page));
DBUG_DUMP("buff", buff,_ma_get_page_used(info, buff));
DBUG_DUMP("buff", buff, page_length);
DBUG_ASSERT(page_length >= share->keypage_header + nod +
keyinfo->minlength || maria_in_recovery);
}
#endif
/* Verify that keynr is correct */
DBUG_ASSERT(_ma_get_keynr(info, buff) == keyinfo->key_nr);
DBUG_ASSERT(_ma_get_keynr(share, buff) == keyinfo->key_nr);
#if defined(EXTRA_DEBUG) && defined(HAVE_purify)
{
@ -121,19 +130,19 @@ int _ma_write_keypage(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
#ifdef IDENTICAL_PAGES_AFTER_RECOVERY
{
uint length= _ma_get_page_used(info, buff);
uint length= _ma_get_page_used(share, buff);
DBUG_ASSERT(length <= block_size - KEYPAGE_CHECKSUM_SIZE);
bzero(buff + length, block_size - length);
}
#endif
DBUG_ASSERT(info->s->pagecache->block_size == block_size);
if (!(info->s->options & HA_OPTION_PAGE_CHECKSUM))
DBUG_ASSERT(share->pagecache->block_size == block_size);
if (!(share->options & HA_OPTION_PAGE_CHECKSUM))
bfill(buff + block_size - KEYPAGE_CHECKSUM_SIZE,
KEYPAGE_CHECKSUM_SIZE, (uchar) 255);
res= pagecache_write(info->s->pagecache,
&info->s->kfile, page / block_size,
level, buff, info->s->page_type,
res= pagecache_write(share->pagecache,
&share->kfile, page / block_size,
level, buff, share->page_type,
lock,
lock == PAGECACHE_LOCK_LEFT_WRITELOCKED ?
PAGECACHE_PIN_LEFT_PINNED :
@ -191,11 +200,11 @@ int _ma_dispose(register MARIA_HA *info, my_off_t pos, my_bool page_not_read)
share->current_key_del= pos;
page_no= pos / block_size;
bzero(buff, share->keypage_header);
_ma_store_keynr(info, buff, (uchar) MARIA_DELETE_KEY_NR);
_ma_store_keynr(share, buff, (uchar) MARIA_DELETE_KEY_NR);
mi_sizestore(buff + share->keypage_header, old_link);
share->state.changed|= STATE_NOT_SORTED_PAGES;
if (info->s->now_transactional)
if (share->now_transactional)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE * 2];
@ -207,7 +216,7 @@ int _ma_dispose(register MARIA_HA *info, my_off_t pos, my_bool page_not_read)
/* Store link to next unused page (the link that is written to page) */
page= (old_link == HA_OFFSET_ERROR ? IMPOSSIBLE_PAGE_NO :
old_link / info->s->block_size);
old_link / block_size);
page_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE, page);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= (char*) log_data;
@ -315,7 +324,7 @@ my_off_t _ma_new(register MARIA_HA *info, int level,
else
{
share->current_key_del= mi_sizekorr(buff+share->keypage_header);
DBUG_ASSERT(share->current_key_del != info->s->state.key_del &&
DBUG_ASSERT(share->current_key_del != share->state.key_del &&
share->current_key_del);
}

4
storage/maria/ma_preload.c
View File

@ -73,8 +73,8 @@ int maria_preload(MARIA_HA *info, ulonglong key_map, my_bool ignore_leaves)
for (end= buff + length ; buff < end ; buff+= block_length)
{
uint keynr= _ma_get_keynr(info, buff);
if ((ignore_leaves && !_ma_test_if_nod(info, buff)) ||
uint keynr= _ma_get_keynr(share, buff);
if ((ignore_leaves && !_ma_test_if_nod(share, buff)) ||
keynr == MARIA_DELETE_KEY_NR ||
!(key_map & ((ulonglong) 1 << keynr)))
{

4
storage/maria/ma_range.c
View File

@ -217,7 +217,7 @@ static double _ma_search_pos(register MARIA_HA *info,
goto err;
flag=(*keyinfo->bin_search)(info, keyinfo, buff, key, key_len, nextflag,
&keypos,info->lastkey, &after_key);
nod_flag=_ma_test_if_nod(info, buff);
nod_flag=_ma_test_if_nod(info->s, buff);
keynr= _ma_keynr(info,keyinfo,buff,keypos,&max_keynr);
if (flag)
@ -272,7 +272,7 @@ static uint _ma_keynr(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
uint nod_flag, used_length, keynr, max_key;
uchar t_buff[HA_MAX_KEY_BUFF],*end;
_ma_get_used_and_nod(info, page, used_length, nod_flag);
_ma_get_used_and_nod(info->s, page, used_length, nod_flag);
end= page+ used_length;
page+= info->s->keypage_header + nod_flag;

2
storage/maria/ma_rkey.c
View File

@ -25,7 +25,7 @@ int maria_rkey(MARIA_HA *info, uchar *buf, int inx, const uchar *key,
key_part_map keypart_map, enum ha_rkey_function search_flag)
{
uchar *key_buff;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo;
HA_KEYSEG *last_used_keyseg;
uint pack_key_length, use_key_length, nextflag;

2
storage/maria/ma_rprev.c
View File

@ -26,7 +26,7 @@ int maria_rprev(MARIA_HA *info, uchar *buf, int inx)
{
int error,changed;
register uint flag;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_rprev");
if ((inx = _ma_check_index(info,inx)) < 0)

127
storage/maria/ma_rt_index.c
View File

@ -56,6 +56,7 @@ static int maria_rtree_find_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint search_flag,
uint nod_cmp_flag, my_off_t page, int level)
{
MARIA_SHARE *share= info->s;
uint nod_flag;
int res;
uchar *page_buf, *k, *last;
@ -70,9 +71,9 @@ static int maria_rtree_find_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0, 0))
goto err1;
nod_flag= _ma_test_if_nod(info, page_buf);
nod_flag= _ma_test_if_nod(share, page_buf);
k_len= keyinfo->keylength - info->s->base.rec_reflength;
k_len= keyinfo->keylength - share->base.rec_reflength;
if (info->maria_rtree_recursion_depth >= level)
{
@ -80,11 +81,11 @@ static int maria_rtree_find_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
}
else
{
k= rt_PAGE_FIRST_KEY(info, page_buf, nod_flag);
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
}
last= rt_PAGE_END(info, page_buf);
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag))
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag))
{
if (nod_flag)
{
@ -116,9 +117,9 @@ static int maria_rtree_find_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
if (!maria_rtree_key_cmp(keyinfo->seg, info->first_mbr_key,
k, info->last_rkey_length, search_flag))
{
uchar *after_key= (uchar*) rt_PAGE_NEXT_KEY(k, k_len, nod_flag);
uchar *after_key= (uchar*) rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag);
info->cur_row.lastpos= _ma_dpos(info, 0, after_key);
info->lastkey_length= k_len + info->s->base.rec_reflength;
info->lastkey_length= k_len + share->base.rec_reflength;
memcpy(info->lastkey, k, info->lastkey_length);
info->maria_rtree_recursion_depth= level;
*saved_key= last - page_buf;
@ -280,6 +281,7 @@ int maria_rtree_find_next(MARIA_HA *info, uint keynr, uint search_flag)
static int maria_rtree_get_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint key_length, my_off_t page, int level)
{
MARIA_SHARE *share= info->s;
uchar *page_buf, *last, *k;
uint nod_flag, k_len;
int res;
@ -290,9 +292,9 @@ static int maria_rtree_get_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0, 0))
goto err1;
nod_flag= _ma_test_if_nod(info, page_buf);
nod_flag= _ma_test_if_nod(share, page_buf);
k_len= keyinfo->keylength - info->s->base.rec_reflength;
k_len= keyinfo->keylength - share->base.rec_reflength;
if(info->maria_rtree_recursion_depth >= level)
{
@ -301,16 +303,16 @@ static int maria_rtree_get_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
{
/* Only leaf pages contain data references. */
/* Need to check next key with data reference. */
k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag);
k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag);
}
}
else
{
k= rt_PAGE_FIRST_KEY(info, page_buf, nod_flag);
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
}
last= rt_PAGE_END(info, page_buf);
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag))
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag))
{
if (nod_flag)
{
@ -332,9 +334,9 @@ static int maria_rtree_get_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
else
{
/* this is a leaf */
uchar *after_key= rt_PAGE_NEXT_KEY(k, k_len, nod_flag);
uchar *after_key= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag);
info->cur_row.lastpos= _ma_dpos(info, 0, after_key);
info->lastkey_length= k_len + info->s->base.rec_reflength;
info->lastkey_length= k_len + share->base.rec_reflength;
memcpy(info->lastkey, k, info->lastkey_length);
info->maria_rtree_recursion_depth= level;
@ -344,7 +346,7 @@ static int maria_rtree_get_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
{
info->int_keypos= (uchar*) saved_key;
memcpy(info->buff, page_buf, keyinfo->block_length);
info->int_maxpos= rt_PAGE_END(info, info->buff);
info->int_maxpos= rt_PAGE_END(share, info->buff);
info->keyread_buff_used= 0;
}
else
@ -491,18 +493,19 @@ static uchar *maria_rtree_pick_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint key_length, uchar *page_buf,
uint nod_flag)
{
MARIA_SHARE *share= info->s;
double increase;
double best_incr= DBL_MAX;
double area;
double best_area;
uchar *best_key;
uchar *k= rt_PAGE_FIRST_KEY(info, page_buf, nod_flag);
uchar *last= rt_PAGE_END(info, page_buf);
uchar *k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
uchar *last= rt_PAGE_END(share, page_buf);
LINT_INIT(best_area);
LINT_INIT(best_key);
for (; k < last; k= rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, key_length, nod_flag))
{
/* The following is safe as -1.0 is an exact number */
if ((increase= maria_rtree_area_increase(keyinfo->seg, k, key, key_length,
@ -561,7 +564,7 @@ static int maria_rtree_insert_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, page_buf, 0, &page_link))
goto err1;
nod_flag= _ma_test_if_nod(info, page_buf);
nod_flag= _ma_test_if_nod(info->s, page_buf);
DBUG_PRINT("rtree", ("page: %lu level: %d ins_level: %d nod_flag: %u",
(ulong) page, level, ins_level, nod_flag));
@ -646,13 +649,14 @@ static int maria_rtree_insert_level(MARIA_HA *info, uint keynr, uchar *key,
uint key_length, int ins_level)
{
my_off_t old_root;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= share->keyinfo + keynr;
int res;
my_off_t new_page;
MARIA_PINNED_PAGE *page_link;
DBUG_ENTER("maria_rtree_insert_level");
if ((old_root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
if ((old_root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
MARIA_PINNED_PAGE tmp_page_link;
page_link= &tmp_page_link;
@ -660,9 +664,9 @@ static int maria_rtree_insert_level(MARIA_HA *info, uint keynr, uchar *key,
HA_OFFSET_ERROR)
DBUG_RETURN(-1);
info->keyread_buff_used= 1;
bzero(info->buff, info->s->keypage_header);
_ma_store_keynr(info, info->buff, keynr);
_ma_store_page_used(info, info->buff, info->s->keypage_header);
bzero(info->buff, share->keypage_header);
_ma_store_keynr(share, info->buff, keynr);
_ma_store_page_used(share, info->buff, share->keypage_header);
res= maria_rtree_add_key(info, keyinfo, key, key_length, info->buff,
NULL);
@ -670,7 +674,7 @@ static int maria_rtree_insert_level(MARIA_HA *info, uint keynr, uchar *key,
page_link->write_lock,
DFLT_INIT_HITS, info->buff))
DBUG_RETURN(1);
info->s->state.key_root[keynr]= old_root;
share->state.key_root[keynr]= old_root;
DBUG_RETURN(res);
}
@ -685,7 +689,7 @@ static int maria_rtree_insert_level(MARIA_HA *info, uint keynr, uchar *key,
{
uchar *new_root_buf, *new_key;
my_off_t new_root;
uint nod_flag= info->s->base.key_reflength;
uint nod_flag= share->base.key_reflength;
MARIA_PINNED_PAGE tmp_page_link;
page_link= &tmp_page_link;
@ -697,11 +701,11 @@ static int maria_rtree_insert_level(MARIA_HA *info, uint keynr, uchar *key,
DBUG_RETURN(-1); /* purecov: inspected */
}
bzero(new_root_buf, info->s->keypage_header);
bzero(new_root_buf, share->keypage_header);
if (nod_flag)
_ma_store_keypage_flag(info, new_root_buf, KEYPAGE_FLAG_ISNOD);
_ma_store_keynr(info, new_root_buf, keynr);
_ma_store_page_used(info, new_root_buf, info->s->keypage_header);
_ma_store_keypage_flag(share, new_root_buf, KEYPAGE_FLAG_ISNOD);
_ma_store_keynr(share, new_root_buf, keynr);
_ma_store_page_used(share, new_root_buf, share->keypage_header);
if ((new_root= _ma_new(info, DFLT_INIT_HITS, &page_link)) ==
HA_OFFSET_ERROR)
goto err1;
@ -727,10 +731,10 @@ static int maria_rtree_insert_level(MARIA_HA *info, uint keynr, uchar *key,
if (_ma_write_keypage(info, keyinfo, new_root, page_link->write_lock,
DFLT_INIT_HITS, new_root_buf))
goto err1;
info->s->state.key_root[keynr]= new_root;
share->state.key_root[keynr]= new_root;
DBUG_PRINT("rtree", ("new root page: %lu level: %d nod_flag: %u",
(ulong) new_root, 0,
_ma_test_if_nod(info, new_root_buf)));
_ma_test_if_nod(share, new_root_buf)));
my_afree((uchar*)new_root_buf);
break;
@ -817,6 +821,7 @@ static int maria_rtree_delete_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
int res;
uchar *page_buf, *last, *k;
MARIA_PINNED_PAGE *page_link;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_rtree_delete_req");
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length)))
@ -827,14 +832,16 @@ static int maria_rtree_delete_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
if (!_ma_fetch_keypage(info, keyinfo, page, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, page_buf, 0, &page_link))
goto err1;
nod_flag= _ma_test_if_nod(info, page_buf);
nod_flag= _ma_test_if_nod(share, page_buf);
DBUG_PRINT("rtree", ("page: %lu level: %d nod_flag: %u",
(ulong) page, level, nod_flag));
k= rt_PAGE_FIRST_KEY(info, page_buf, nod_flag);
last= rt_PAGE_END(info, page_buf);
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
last= rt_PAGE_END(share, page_buf);
for (i= 0; k < last; k= rt_PAGE_NEXT_KEY(k, key_length, nod_flag), i++)
for (i= 0;
k < last;
k= rt_PAGE_NEXT_KEY(share, k, key_length, nod_flag), i++)
{
if (nod_flag)
{
@ -887,7 +894,7 @@ static int maria_rtree_delete_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size= _ma_get_page_used(info, page_buf);
*page_size= _ma_get_page_used(share, page_buf);
}
goto ok;
@ -904,7 +911,7 @@ static int maria_rtree_delete_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size= _ma_get_page_used(info, page_buf);
*page_size= _ma_get_page_used(share, page_buf);
res= 0;
goto ok;
}
@ -925,7 +932,7 @@ static int maria_rtree_delete_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
page_link->changed= 1;
maria_rtree_delete_key(info, page_buf, k, key_length, nod_flag);
*page_size= _ma_get_page_used(info, page_buf);
*page_size= _ma_get_page_used(share, page_buf);
if (*page_size == info->s->keypage_header)
{
/* last key in the leaf */
@ -967,6 +974,7 @@ err1:
int maria_rtree_delete(MARIA_HA *info, uint keynr, uchar *key, uint key_length)
{
MARIA_SHARE *share= info->s;
uint page_size;
stPageList ReinsertList;
my_off_t old_root;
@ -974,7 +982,7 @@ int maria_rtree_delete(MARIA_HA *info, uint keynr, uchar *key, uint key_length)
MARIA_PINNED_PAGE *page_link, *root_page_link;
DBUG_ENTER("maria_rtree_delete");
if ((old_root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
if ((old_root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
DBUG_RETURN(-1); /* purecov: inspected */
@ -990,7 +998,7 @@ int maria_rtree_delete(MARIA_HA *info, uint keynr, uchar *key, uint key_length)
&page_size, &ReinsertList, 0)) {
case 2: /* empty */
{
info->s->state.key_root[keynr]= HA_OFFSET_ERROR;
share->state.key_root[keynr]= HA_OFFSET_ERROR;
DBUG_RETURN(0);
}
case 0: /* deleted */
@ -1010,15 +1018,15 @@ int maria_rtree_delete(MARIA_HA *info, uint keynr, uchar *key, uint key_length)
PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, page_buf, 0, &page_link))
goto err1;
nod_flag= _ma_test_if_nod(info, page_buf);
nod_flag= _ma_test_if_nod(share, page_buf);
DBUG_PRINT("rtree", ("reinserting keys from "
"page: %lu level: %d nod_flag: %u",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level, nod_flag));
k= rt_PAGE_FIRST_KEY(info, page_buf, nod_flag);
last= rt_PAGE_END(info, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, key_length, nod_flag))
{
int res;
if ((res=
@ -1050,24 +1058,24 @@ int maria_rtree_delete(MARIA_HA *info, uint keynr, uchar *key, uint key_length)
my_free((uchar*) ReinsertList.pages, MYF(0));
/* check for redundant root (not leaf, 1 child) and eliminate */
if ((old_root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
if ((old_root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
goto err1;
if (!_ma_fetch_keypage(info, keyinfo, old_root,
PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, info->buff, 0, &root_page_link))
goto err1;
nod_flag= _ma_test_if_nod(info, info->buff);
page_size= _ma_get_page_used(info, info->buff);
if (nod_flag && (page_size == info->s->keypage_header + key_length +
nod_flag= _ma_test_if_nod(share, info->buff);
page_size= _ma_get_page_used(share, info->buff);
if (nod_flag && (page_size == share->keypage_header + key_length +
nod_flag))
{
my_off_t new_root= _ma_kpos(nod_flag,
rt_PAGE_FIRST_KEY(info, info->buff,
rt_PAGE_FIRST_KEY(share, info->buff,
nod_flag));
root_page_link->changed= 1;
if (_ma_dispose(info, old_root, 0))
goto err1;
info->s->state.key_root[keynr]= new_root;
share->state.key_root[keynr]= new_root;
}
info->update= HA_STATE_DELETED;
DBUG_RETURN(0);
@ -1097,7 +1105,8 @@ err1:
ha_rows maria_rtree_estimate(MARIA_HA *info, uint keynr, uchar *key,
uint key_length, uint flag)
{
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= share->keyinfo + keynr;
my_off_t root;
uint i= 0;
uint nod_flag, k_len;
@ -1108,21 +1117,21 @@ ha_rows maria_rtree_estimate(MARIA_HA *info, uint keynr, uchar *key,
if (flag & MBR_DISJOINT)
return info->state->records;
if ((root= info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
if ((root= share->state.key_root[keynr]) == HA_OFFSET_ERROR)
return HA_POS_ERROR;
if (!(page_buf= (uchar*) my_alloca((uint)keyinfo->block_length)))
return HA_POS_ERROR;
if (!_ma_fetch_keypage(info, keyinfo, root, PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0, 0))
goto err1;
nod_flag= _ma_test_if_nod(info, page_buf);
nod_flag= _ma_test_if_nod(share, page_buf);
k_len= keyinfo->keylength - info->s->base.rec_reflength;
k_len= keyinfo->keylength - share->base.rec_reflength;
k= rt_PAGE_FIRST_KEY(info, page_buf, nod_flag);
last= rt_PAGE_END(info, page_buf);
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
last= rt_PAGE_END(share, page_buf);
for (; k < last; k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag), i++)
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag), i++)
{
if (nod_flag)
{

8
storage/maria/ma_rt_index.h
View File

@ -19,10 +19,10 @@
#ifdef HAVE_RTREE_KEYS
#define rt_PAGE_FIRST_KEY(info, page, nod_flag) (page + info->s->keypage_header + nod_flag)
#define rt_PAGE_NEXT_KEY(key, key_length, nod_flag) (key + key_length + \
(nod_flag ? nod_flag : info->s->base.rec_reflength))
#define rt_PAGE_END(info, page) (page + _ma_get_page_used(info, page))
#define rt_PAGE_FIRST_KEY(share, page, nod_flag) (page + share->keypage_header + nod_flag)
#define rt_PAGE_NEXT_KEY(share, key, key_length, nod_flag) (key + key_length +\
(nod_flag ? nod_flag : share->base.rec_reflength))
#define rt_PAGE_END(share, page) (page + _ma_get_page_used(share, page))
#define rt_PAGE_MIN_SIZE(block_length) ((uint)(block_length - KEYPAGE_CHECKSUM_SIZE) / 3)

28
storage/maria/ma_rt_key.c
View File

@ -32,11 +32,12 @@
int maria_rtree_add_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo, uchar *key,
uint key_length, uchar *page_buf, my_off_t *new_page)
{
uint page_size= _ma_get_page_used(info, page_buf);
uint nod_flag= _ma_test_if_nod(info, page_buf);
MARIA_SHARE *share= info->s;
uint page_size= _ma_get_page_used(share, page_buf);
uint nod_flag= _ma_test_if_nod(share, page_buf);
DBUG_ENTER("maria_rtree_add_key");
if (page_size + key_length + info->s->base.rec_reflength <=
if (page_size + key_length + share->base.rec_reflength <=
keyinfo->block_length)
{
/* split won't be necessary */
@ -44,7 +45,7 @@ int maria_rtree_add_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo, uchar *key,
{
/* save key */
DBUG_ASSERT(_ma_kpos(nod_flag, key) < info->state->key_file_length);
memcpy(rt_PAGE_END(info, page_buf), key - nod_flag,
memcpy(rt_PAGE_END(share, page_buf), key - nod_flag,
key_length + nod_flag);
page_size+= key_length + nod_flag;
}
@ -52,14 +53,14 @@ int maria_rtree_add_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo, uchar *key,
{
/* save key */
DBUG_ASSERT(_ma_dpos(info, nod_flag, key + key_length +
info->s->base.rec_reflength) <
share->base.rec_reflength) <
info->state->data_file_length +
info->s->base.pack_reclength);
memcpy(rt_PAGE_END(info, page_buf), key, key_length +
info->s->base.rec_reflength);
page_size+= key_length + info->s->base.rec_reflength;
share->base.pack_reclength);
memcpy(rt_PAGE_END(share, page_buf), key, key_length +
share->base.rec_reflength);
page_size+= key_length + share->base.rec_reflength;
}
_ma_store_page_used(info, page_buf, page_size);
_ma_store_page_used(share, page_buf, page_size);
DBUG_RETURN(0);
}
@ -75,18 +76,19 @@ int maria_rtree_add_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo, uchar *key,
int maria_rtree_delete_key(MARIA_HA *info, uchar *page_buf, uchar *key,
uint key_length, uint nod_flag)
{
uint16 page_size= _ma_get_page_used(info, page_buf);
MARIA_SHARE *share= info->s;
uint16 page_size= _ma_get_page_used(share, page_buf);
uchar *key_start;
key_start= key - nod_flag;
if (!nod_flag)
key_length+= info->s->base.rec_reflength;
key_length+= share->base.rec_reflength;
memmove(key_start, key + key_length, page_size - key_length -
(key - page_buf));
page_size-= key_length + nod_flag;
_ma_store_page_used(info, page_buf, page_size);
_ma_store_page_used(share, page_buf, page_size);
return 0;
}

43
storage/maria/ma_rt_mbr.c
View File

@ -687,13 +687,13 @@ double maria_rtree_perimeter_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
}
#define RT_PAGE_MBR_KORR(type, korr_func, store_func, len) \
#define RT_PAGE_MBR_KORR(share, type, korr_func, store_func, len) \
{ \
type amin, amax, bmin, bmax; \
amin= korr_func(k + inc); \
amax= korr_func(k + inc + len); \
k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag); \
for (; k < last; k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag)) \
k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag); \
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag)) \
{ \
bmin= korr_func(k + inc); \
bmax= korr_func(k + inc + len); \
@ -709,13 +709,13 @@ double maria_rtree_perimeter_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
inc += 2 * len; \
}
#define RT_PAGE_MBR_GET(type, get_func, store_func, len) \
#define RT_PAGE_MBR_GET(share, type, get_func, store_func, len) \
{ \
type amin, amax, bmin, bmax; \
get_func(amin, k + inc); \
get_func(amax, k + inc + len); \
k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag); \
for (; k < last; k= rt_PAGE_NEXT_KEY(k, k_len, nod_flag)) \
k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag); \
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, k_len, nod_flag)) \
{ \
get_func(bmin, k + inc); \
get_func(bmax, k + inc + len); \
@ -737,11 +737,12 @@ double maria_rtree_perimeter_increase(HA_KEYSEG *keyseg, uchar* a, uchar* b,
int maria_rtree_page_mbr(MARIA_HA *info, HA_KEYSEG *keyseg, uchar *page_buf,
uchar *c, uint key_length)
{
MARIA_SHARE *share= info->s;
uint inc= 0;
uint k_len= key_length;
uint nod_flag= _ma_test_if_nod(info, page_buf);
uint nod_flag= _ma_test_if_nod(share, page_buf);
uchar *k;
uchar *last= rt_PAGE_END(info, page_buf);
uchar *last= rt_PAGE_END(share, page_buf);
for (; (int)key_length > 0; keyseg += 2)
{
@ -753,46 +754,46 @@ int maria_rtree_page_mbr(MARIA_HA *info, HA_KEYSEG *keyseg, uchar *page_buf,
return 1;
}
k= rt_PAGE_FIRST_KEY(info, page_buf, nod_flag);
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_INT8:
RT_PAGE_MBR_KORR(int8, mi_sint1korr, mi_int1store, 1);
RT_PAGE_MBR_KORR(share, int8, mi_sint1korr, mi_int1store, 1);
break;
case HA_KEYTYPE_BINARY:
RT_PAGE_MBR_KORR(uint8, mi_uint1korr, mi_int1store, 1);
RT_PAGE_MBR_KORR(share, uint8, mi_uint1korr, mi_int1store, 1);
break;
case HA_KEYTYPE_SHORT_INT:
RT_PAGE_MBR_KORR(int16, mi_sint2korr, mi_int2store, 2);
RT_PAGE_MBR_KORR(share, int16, mi_sint2korr, mi_int2store, 2);
break;
case HA_KEYTYPE_USHORT_INT:
RT_PAGE_MBR_KORR(uint16, mi_uint2korr, mi_int2store, 2);
RT_PAGE_MBR_KORR(share, uint16, mi_uint2korr, mi_int2store, 2);
break;
case HA_KEYTYPE_INT24:
RT_PAGE_MBR_KORR(int32, mi_sint3korr, mi_int3store, 3);
RT_PAGE_MBR_KORR(share, int32, mi_sint3korr, mi_int3store, 3);
break;
case HA_KEYTYPE_UINT24:
RT_PAGE_MBR_KORR(uint32, mi_uint3korr, mi_int3store, 3);
RT_PAGE_MBR_KORR(share, uint32, mi_uint3korr, mi_int3store, 3);
break;
case HA_KEYTYPE_LONG_INT:
RT_PAGE_MBR_KORR(int32, mi_sint4korr, mi_int4store, 4);
RT_PAGE_MBR_KORR(share, int32, mi_sint4korr, mi_int4store, 4);
break;
case HA_KEYTYPE_ULONG_INT:
RT_PAGE_MBR_KORR(uint32, mi_uint4korr, mi_int4store, 4);
RT_PAGE_MBR_KORR(share, uint32, mi_uint4korr, mi_int4store, 4);
break;
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
RT_PAGE_MBR_KORR(longlong, mi_sint8korr, mi_int8store, 8);
RT_PAGE_MBR_KORR(share, longlong, mi_sint8korr, mi_int8store, 8);
break;
case HA_KEYTYPE_ULONGLONG:
RT_PAGE_MBR_KORR(ulonglong, mi_uint8korr, mi_int8store, 8);
RT_PAGE_MBR_KORR(share, ulonglong, mi_uint8korr, mi_int8store, 8);
break;
#endif
case HA_KEYTYPE_FLOAT:
RT_PAGE_MBR_GET(float, mi_float4get, mi_float4store, 4);
RT_PAGE_MBR_GET(share, float, mi_float4get, mi_float4store, 4);
break;
case HA_KEYTYPE_DOUBLE:
RT_PAGE_MBR_GET(double, mi_float8get, mi_float8store, 8);
RT_PAGE_MBR_GET(share, double, mi_float8get, mi_float8store, 8);
break;
case HA_KEYTYPE_END:
return 0;

35
storage/maria/ma_rt_split.c
View File

@ -251,6 +251,7 @@ int maria_rtree_split_page(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uchar *page, uchar *key,
uint key_length, my_off_t *new_page_offs)
{
MARIA_SHARE *share= info->s;
int n1, n2; /* Number of items in groups */
SplitStruct *task;
SplitStruct *cur;
@ -262,10 +263,10 @@ int maria_rtree_split_page(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uchar *source_cur, *cur1, *cur2;
uchar *new_page;
int err_code= 0;
uint nod_flag= _ma_test_if_nod(info, page);
uint nod_flag= _ma_test_if_nod(share, page);
uint full_length= key_length + (nod_flag ? nod_flag :
info->s->base.rec_reflength);
int max_keys= ((_ma_get_page_used(info, page) - info->s->keypage_header) /
share->base.rec_reflength);
int max_keys= ((_ma_get_page_used(share, page) - share->keypage_header) /
(full_length));
MARIA_PINNED_PAGE tmp_page_link, *page_link= &tmp_page_link;
DBUG_ENTER("maria_rtree_split_page");
@ -283,10 +284,12 @@ int maria_rtree_split_page(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
next_coord= coord_buf;
stop= task + max_keys;
source_cur= rt_PAGE_FIRST_KEY(info, page, nod_flag);
source_cur= rt_PAGE_FIRST_KEY(share, page, nod_flag);
for (cur= task; cur < stop; cur++, source_cur= rt_PAGE_NEXT_KEY(source_cur,
key_length, nod_flag))
for (cur= task;
cur < stop;
cur++, source_cur= rt_PAGE_NEXT_KEY(share, source_cur, key_length,
nod_flag))
{
cur->coords= reserve_coords(&next_coord, n_dim);
cur->key= source_cur;
@ -300,7 +303,7 @@ int maria_rtree_split_page(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
old_coord= next_coord;
if (split_maria_rtree_node(task, max_keys + 1,
_ma_get_page_used(info, page) + full_length + 2,
_ma_get_page_used(share, page) + full_length + 2,
full_length,
rt_PAGE_MIN_SIZE(keyinfo->block_length),
2, 2, &next_coord, n_dim))
@ -316,8 +319,8 @@ int maria_rtree_split_page(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
}
stop= task + (max_keys + 1);
cur1= rt_PAGE_FIRST_KEY(info, page, nod_flag);
cur2= rt_PAGE_FIRST_KEY(info, new_page, nod_flag);
cur1= rt_PAGE_FIRST_KEY(share, page, nod_flag);
cur2= rt_PAGE_FIRST_KEY(share, new_page, nod_flag);
n1= n2= 0;
for (cur= task; cur < stop; cur++)
@ -326,25 +329,25 @@ int maria_rtree_split_page(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
if (cur->n_node == 1)
{
to= cur1;
cur1= rt_PAGE_NEXT_KEY(cur1, key_length, nod_flag);
cur1= rt_PAGE_NEXT_KEY(share, cur1, key_length, nod_flag);
n1++;
}
else
{
to= cur2;
cur2= rt_PAGE_NEXT_KEY(cur2, key_length, nod_flag);
cur2= rt_PAGE_NEXT_KEY(share, cur2, key_length, nod_flag);
n2++;
}
if (to != cur->key)
memcpy(to - nod_flag, cur->key - nod_flag, full_length);
}
bzero(new_page, info->s->keypage_header);
bzero(new_page, share->keypage_header);
if (nod_flag)
_ma_store_keypage_flag(info, new_page, KEYPAGE_FLAG_ISNOD);
_ma_store_keynr(info, new_page, keyinfo->key_nr);
_ma_store_page_used(info, page, info->s->keypage_header + n1 * full_length)
_ma_store_page_used(info, new_page, info->s->keypage_header +
_ma_store_keypage_flag(share, new_page, KEYPAGE_FLAG_ISNOD);
_ma_store_keynr(share, new_page, keyinfo->key_nr);
_ma_store_page_used(share, page, share->keypage_header + n1 * full_length)
_ma_store_page_used(share, new_page, share->keypage_header +
n2 * full_length);
if ((*new_page_offs= _ma_new(info, DFLT_INIT_HITS, &page_link)) ==

44
storage/maria/ma_search.c
View File

@ -84,13 +84,13 @@ int _ma_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
DFLT_INIT_HITS, info->keyread_buff,
test(!(nextflag & SEARCH_SAVE_BUFF)), 0)))
goto err;
DBUG_DUMP("page", buff, _ma_get_page_used(info, buff));
DBUG_DUMP("page", buff, _ma_get_page_used(info->s, buff));
flag=(*keyinfo->bin_search)(info,keyinfo,buff,key,key_len,nextflag,
&keypos,lastkey, &last_key);
if (flag == MARIA_FOUND_WRONG_KEY)
DBUG_RETURN(-1);
_ma_get_used_and_nod(info, buff, used_length, nod_flag);
_ma_get_used_and_nod(info->s, buff, used_length, nod_flag);
maxpos= buff + used_length -1;
if (flag)
@ -189,18 +189,21 @@ int _ma_bin_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
int flag;
uint start, mid, end, save_end, totlength, nod_flag, used_length;
uint not_used[2];
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_bin_search");
LINT_INIT(flag);
_ma_get_used_and_nod(info, page, used_length, nod_flag);
_ma_get_used_and_nod(share, page, used_length, nod_flag);
totlength= keyinfo->keylength + nod_flag;
DBUG_ASSERT(used_length >= share->keypage_header + nod_flag + totlength);
start=0;
mid=1;
save_end= end= ((used_length - nod_flag - info->s->keypage_header) /
save_end= end= ((used_length - nod_flag - share->keypage_header) /
totlength-1);
DBUG_PRINT("test",("page_length: %u end: %u", used_length, end));
page+= info->s->keypage_header + nod_flag;
page+= share->keypage_header + nod_flag;
while (start != end)
{
@ -255,6 +258,7 @@ int _ma_seq_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
uint comp_flag, uchar **ret_pos,
uchar *buff, my_bool *last_key)
{
MARIA_SHARE *share= info->s;
int flag;
uint nod_flag, length, used_length, not_used[2];
uchar t_buff[HA_MAX_KEY_BUFF], *end;
@ -263,9 +267,9 @@ int _ma_seq_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
LINT_INIT(flag);
LINT_INIT(length);
_ma_get_used_and_nod(info, page, used_length, nod_flag);
_ma_get_used_and_nod(share, page, used_length, nod_flag);
end= page + used_length;
page+= info->s->keypage_header + nod_flag;
page+= share->keypage_header + nod_flag;
*ret_pos= (uchar*) page;
t_buff[0]=0; /* Avoid bugs */
while (page < end)
@ -273,7 +277,7 @@ int _ma_seq_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,t_buff);
if (length == 0 || page > end)
{
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_PRINT("error",
("Found wrong key: length: %u page: 0x%lx end: 0x%lx",
@ -303,6 +307,7 @@ int _ma_prefix_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
uint nextflag, uchar **ret_pos, uchar *buff,
my_bool *last_key)
{
MARIA_SHARE *share= info->s;
/*
my_flag is raw comparison result to be changed according to
SEARCH_NO_FIND,SEARCH_LAST and HA_REVERSE_SORT flags.
@ -330,9 +335,9 @@ int _ma_prefix_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
LINT_INIT(saved_vseg);
t_buff[0]=0; /* Avoid bugs */
_ma_get_used_and_nod(info, page, used_length, nod_flag);
_ma_get_used_and_nod(share, page, used_length, nod_flag);
end= page + used_length;
page+= info->s->keypage_header + nod_flag;
page+= share->keypage_header + nod_flag;
*ret_pos= page;
kseg= key;
@ -434,7 +439,7 @@ int _ma_prefix_search(MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (page > end)
{
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_PRINT("error",
("Found wrong key: length: %u page: 0x%lx end: %lx",
@ -1112,7 +1117,7 @@ uchar *_ma_get_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo, uchar *page,
uint nod_flag;
DBUG_ENTER("_ma_get_key");
nod_flag=_ma_test_if_nod(info, page);
nod_flag=_ma_test_if_nod(info->s, page);
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
{
bmove((uchar*) key,(uchar*) keypos,keyinfo->keylength+nod_flag);
@ -1154,7 +1159,7 @@ static my_bool _ma_get_prev_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint nod_flag;
DBUG_ENTER("_ma_get_prev_key");
nod_flag=_ma_test_if_nod(info, page);
nod_flag=_ma_test_if_nod(info->s, page);
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
{
*return_key_length=keyinfo->keylength;
@ -1200,7 +1205,7 @@ uchar *_ma_get_last_key(MARIA_HA *info, MARIA_KEYDEF *keyinfo, uchar *page,
DBUG_PRINT("enter",("page: 0x%lx endpos: 0x%lx", (long) page,
(long) endpos));
nod_flag=_ma_test_if_nod(info, page);
nod_flag= _ma_test_if_nod(info->s, page);
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
{
lastpos=endpos-keyinfo->keylength-nod_flag;
@ -1348,7 +1353,7 @@ int _ma_search_next(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
}
/* Last used buffer is in info->keyread_buff */
nod_flag=_ma_test_if_nod(info, info->keyread_buff);
nod_flag= _ma_test_if_nod(info->s, info->keyread_buff);
if (nextflag & SEARCH_BIGGER) /* Next key */
{
@ -1400,6 +1405,7 @@ int _ma_search_first(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
{
uint nod_flag;
uchar *page;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_search_first");
if (pos == HA_OFFSET_ERROR)
@ -1417,8 +1423,8 @@ int _ma_search_first(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
info->cur_row.lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
nod_flag=_ma_test_if_nod(info, info->keyread_buff);
page= info->keyread_buff + info->s->keypage_header + nod_flag;
nod_flag=_ma_test_if_nod(share, info->keyread_buff);
page= info->keyread_buff + share->keypage_header + nod_flag;
} while ((pos= _ma_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
if (!(info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,
@ -1427,7 +1433,7 @@ int _ma_search_first(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
info->int_keypos=page;
info->int_maxpos= (info->keyread_buff +
_ma_get_page_used(info, info->keyread_buff)-1);
_ma_get_page_used(share, info->keyread_buff)-1);
info->int_nod_flag=nod_flag;
info->int_keytree_version=keyinfo->version;
info->last_search_keypage=info->last_keypage;
@ -1466,7 +1472,7 @@ int _ma_search_last(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
info->cur_row.lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
_ma_get_used_and_nod(info, buff, used_length, nod_flag);
_ma_get_used_and_nod(info->s, buff, used_length, nod_flag);
end_of_page= buff + used_length;
} while ((pos= _ma_kpos(nod_flag, end_of_page)) != HA_OFFSET_ERROR);

2
storage/maria/ma_sort.c
View File

@ -499,7 +499,7 @@ int _ma_thr_write_keys(MARIA_SORT_PARAM *sort_param)
int got_error=sort_info->got_error;
uint i;
MARIA_HA *info=sort_info->info;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
MARIA_SORT_PARAM *sinfo;
uchar *mergebuf=0;
DBUG_ENTER("_ma_thr_write_keys");

2
storage/maria/ma_statrec.c
View File

@ -208,7 +208,7 @@ int _ma_read_rnd_static_record(MARIA_HA *info, uchar *buf,
{
int locked,error,cache_read;
uint cache_length;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_read_rnd_static_record");
cache_read=0;

18
storage/maria/ma_test1.c
View File

@ -452,8 +452,8 @@ end:
Flush changed pages go to disk. That will also flush log. Recovery
will skip REDOs and apply UNDOs.
*/
_ma_flush_table_files(file, MARIA_FLUSH_DATA, FLUSH_RELEASE,
FLUSH_RELEASE);
_ma_flush_table_files(file, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_RELEASE, FLUSH_RELEASE);
break;
case 2:
/*
@ -469,6 +469,20 @@ end:
will then do nothing.
*/
break;
case 4:
/*
Flush changed data pages go to disk. Changed index pages are not
flushed. Recovery will skip some REDOs and apply UNDOs.
*/
_ma_flush_table_files(file, MARIA_FLUSH_DATA, FLUSH_RELEASE,
FLUSH_RELEASE);
/*
We have to flush log separately as the redo for the last key page
may not be flushed
*/
if (translog_flush(file->trn->undo_lsn))
goto err;
break;
}
printf("Dying on request without maria_commit()/maria_close()\n");
exit(0);

22
storage/maria/ma_test2.c
View File

@ -901,11 +901,11 @@ end:
switch (die_in_middle_of_transaction) {
case 1:
/*
Flush changed pages go to disk. That will also flush log. Recovery
will skip REDOs and apply UNDOs.
Flush changed data and index pages go to disk
That will also flush log. Recovery will skip REDOs and apply UNDOs.
*/
_ma_flush_table_files(file, MARIA_FLUSH_DATA, FLUSH_RELEASE,
FLUSH_RELEASE);
_ma_flush_table_files(file, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_RELEASE, FLUSH_RELEASE);
break;
case 2:
/*
@ -921,6 +921,20 @@ end:
will then do nothing.
*/
break;
case 4:
/*
Flush changed data pages go to disk. Changed index pages are not
flushed. Recovery will skip some REDOs and apply UNDOs.
*/
_ma_flush_table_files(file, MARIA_FLUSH_DATA, FLUSH_RELEASE,
FLUSH_RELEASE);
/*
We have to flush log separately as the redo for the last key page
may not be flushed
*/
if (translog_flush(file->trn->undo_lsn))
goto err;
break;
}
printf("Dying on request without maria_commit()/maria_close()\n");
exit(0);

5
storage/maria/ma_test_recovery
View File

@ -1,5 +1,6 @@
#!/bin/sh
#set -x -v
set -e
silent="-s"
if [ -z "$maria_path" ]
@ -121,7 +122,7 @@ for take_checkpoint in "no" "yes"
do
for blobs in "" "-b" # we test table without blobs and then table with blobs
do
for test_undo in 1 2 3
for test_undo in 1 2 3 4
do
# first iteration tests rollback of insert, second tests rollback of delete
set -- "ma_test1 $silent -M -T -c -N $blobs -H1" "--testflag=1" "--testflag=2 --test-undo=" "ma_test1 $silent -M -T -c -N $blobs -H2" "--testflag=3" "--testflag=4 --test-undo=" "ma_test1 $silent -M -T -c -N $blobs -H2 " "--testflag=2" "--testflag=3 --test-undo=" "ma_test2 $silent -L -K -W -P -M -T -c $blobs -H1" "-t1" "-t2 -u"
@ -154,7 +155,7 @@ do
rm -f $tmp/maria_log.* $tmp/maria_log_control
cp $maria_path/maria_log* $tmp
if [ $test_undo -lt 3 ]
if [ "$test_undo" != "3" ]
then
apply_log "shouldchangelog" # should undo aborted work
else

298
storage/maria/ma_test_recovery.expected
View File

@ -222,6 +222,76 @@ Differences in maria_chk -dvv, recovery not yet perfect !
---
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N --testflag=2 --test-undo=4 (additional aborted work)
Terminating after inserts
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N --testflag=3 (commit at end)
Terminating after updates
TEST WITH ma_test1 -s -M -T -c -N --testflag=4 --test-undo=4 (additional aborted work)
Terminating after deletes
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N --testflag=2 (commit at end)
Terminating after inserts
TEST WITH ma_test1 -s -M -T -c -N --testflag=3 --test-undo=4 (additional aborted work)
Terminating after updates
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -t1 (commit at end)
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -t2 -u4 (additional aborted work)
Dying on request without maria_commit()/maria_close()
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
testing idempotency
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
testing applying of CLRs to recreate table
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=2 --test-undo=1 (additional aborted work)
Terminating after inserts
@ -404,7 +474,77 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 122880 Keyfile length: 212992
> Datafile length: 147456 Keyfile length: 212992
========DIFF END=======
testing idempotency
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 147456 Keyfile length: 212992
========DIFF END=======
testing applying of CLRs to recreate table
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 147456 Keyfile length: 212992
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=2 --test-undo=4 (additional aborted work)
Terminating after inserts
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=3 (commit at end)
Terminating after updates
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=4 --test-undo=4 (additional aborted work)
Terminating after deletes
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=2 (commit at end)
Terminating after inserts
TEST WITH ma_test1 -s -M -T -c -N -b --testflag=3 --test-undo=4 (additional aborted work)
Terminating after updates
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -b -t1 (commit at end)
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -b -t2 -u4 (additional aborted work)
Dying on request without maria_commit()/maria_close()
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 155648 Keyfile length: 212992
========DIFF END=======
testing idempotency
applying log
@ -570,7 +710,7 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 90112 Keyfile length: 204800
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N -H1 --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N -H1 --testflag=2 --test-undo=3 (additional aborted work)
@ -614,7 +754,7 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 81920 Keyfile length: 204800
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
testing idempotency
applying log
@ -627,7 +767,7 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 81920 Keyfile length: 204800
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
testing applying of CLRs to recreate table
applying log
@ -640,7 +780,77 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 81920 Keyfile length: 204800
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N -H1 --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N -H1 --testflag=2 --test-undo=4 (additional aborted work)
Terminating after inserts
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N -H2 --testflag=3 (commit at end)
Terminating after updates
TEST WITH ma_test1 -s -M -T -c -N -H2 --testflag=4 --test-undo=4 (additional aborted work)
Terminating after deletes
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N -H2 --testflag=2 (commit at end)
Terminating after inserts
TEST WITH ma_test1 -s -M -T -c -N -H2 --testflag=3 --test-undo=4 (additional aborted work)
Terminating after updates
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -H1 -t1 (commit at end)
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -H1 -t2 -u4 (additional aborted work)
Dying on request without maria_commit()/maria_close()
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
testing idempotency
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
testing applying of CLRs to recreate table
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 114688 Keyfile length: 204800
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N -b -H1 --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N -b -H1 --testflag=2 --test-undo=1 (additional aborted work)
@ -754,7 +964,7 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 122880 Keyfile length: 212992
> Datafile length: 155648 Keyfile length: 212992
========DIFF END=======
testing idempotency
applying log
@ -767,7 +977,7 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 122880 Keyfile length: 212992
> Datafile length: 155648 Keyfile length: 212992
========DIFF END=======
testing applying of CLRs to recreate table
applying log
@ -780,7 +990,7 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 122880 Keyfile length: 212992
> Datafile length: 155648 Keyfile length: 212992
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N -b -H1 --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N -b -H1 --testflag=2 --test-undo=3 (additional aborted work)
@ -824,7 +1034,77 @@ Differences in maria_chk -dvv, recovery not yet perfect !
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 122880 Keyfile length: 212992
> Datafile length: 147456 Keyfile length: 212992
========DIFF END=======
testing idempotency
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 147456 Keyfile length: 212992
========DIFF END=======
testing applying of CLRs to recreate table
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 147456 Keyfile length: 212992
========DIFF END=======
TEST WITH ma_test1 -s -M -T -c -N -b -H1 --testflag=1 (commit at end)
TEST WITH ma_test1 -s -M -T -c -N -b -H1 --testflag=2 --test-undo=4 (additional aborted work)
Terminating after inserts
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N -b -H2 --testflag=3 (commit at end)
Terminating after updates
TEST WITH ma_test1 -s -M -T -c -N -b -H2 --testflag=4 --test-undo=4 (additional aborted work)
Terminating after deletes
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test1 -s -M -T -c -N -b -H2 --testflag=2 (commit at end)
Terminating after inserts
TEST WITH ma_test1 -s -M -T -c -N -b -H2 --testflag=3 --test-undo=4 (additional aborted work)
Terminating after updates
Dying on request without maria_commit()/maria_close()
applying log
testing idempotency
applying log
testing applying of CLRs to recreate table
applying log
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -b -H1 -t1 (commit at end)
TEST WITH ma_test2 -s -L -K -W -P -M -T -c -b -H1 -t2 -u4 (additional aborted work)
Dying on request without maria_commit()/maria_close()
applying log
Differences in maria_chk -dvv, recovery not yet perfect !
========DIFF START=======
6c6
< Status: checked,analyzed,optimized keys,sorted index pages
---
> Status: changed
11c11
< Datafile length: 8192 Keyfile length: 8192
---
> Datafile length: 155648 Keyfile length: 212992
========DIFF END=======
testing idempotency
applying log

2
storage/maria/ma_update.c
View File

@ -26,7 +26,7 @@ int maria_update(register MARIA_HA *info, const uchar *oldrec, uchar *newrec)
uchar old_key[HA_MAX_KEY_BUFF],*new_key;
bool auto_key_changed=0;
ulonglong changed;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_update");
LINT_INIT(new_key);
LINT_INIT(changed);

219
storage/maria/ma_write.c
View File

@ -92,7 +92,7 @@ my_bool _ma_write_abort_default(MARIA_HA *info __attribute__((unused)))
int maria_write(MARIA_HA *info, uchar *record)
{
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
uint i;
int save_errno;
MARIA_RECORD_POS filepos;
@ -101,7 +101,7 @@ int maria_write(MARIA_HA *info, uchar *record)
my_bool fatal_error;
DBUG_ENTER("maria_write");
DBUG_PRINT("enter",("index_file: %d data_file: %d",
info->s->kfile.file, info->dfile.file));
share->kfile.file, info->dfile.file));
DBUG_EXECUTE_IF("maria_pretend_crashed_table_on_usage",
maria_print_error(info->s, HA_ERR_CRASHED);
@ -215,7 +215,7 @@ int maria_write(MARIA_HA *info, uchar *record)
if updated here, it's not recoverable (no mutex => checkpoint may see a
crazy value and flush it into the table's state on disk).
*/
set_if_bigger(info->s->state.auto_increment,
set_if_bigger(share->state.auto_increment,
ma_retrieve_auto_increment(info, record));
}
info->update= (HA_STATE_CHANGED | HA_STATE_AKTIV | HA_STATE_WRITTEN |
@ -225,8 +225,9 @@ int maria_write(MARIA_HA *info, uchar *record)
VOID(_ma_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
if (info->invalidator != 0)
{
DBUG_PRINT("info", ("invalidator... '%s' (update)", info->s->open_file_name));
(*info->invalidator)(info->s->open_file_name);
DBUG_PRINT("info", ("invalidator... '%s' (update)",
share->open_file_name));
(*info->invalidator)(share->open_file_name);
info->invalidator=0;
}
@ -376,21 +377,22 @@ static int _ma_ck_write_btree_with_log(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uchar *key, uint key_length,
my_off_t *root, uint comp_flag)
{
MARIA_SHARE *share= info->s;
LSN lsn= LSN_IMPOSSIBLE;
int error;
my_off_t new_root= *root;
uchar key_buff[HA_MAX_KEY_BUFF];
DBUG_ENTER("_ma_ck_write_btree_with_log");
if (info->s->now_transactional)
if (share->now_transactional)
{
/* Save original value as the key may change */
memcpy(key_buff, key, key_length + info->s->rec_reflength);
memcpy(key_buff, key, key_length + share->rec_reflength);
}
error= _ma_ck_real_write_btree(info, keyinfo, key, key_length, &new_root,
comp_flag);
if (!error && info->s->now_transactional)
if (!error && share->now_transactional)
{
uchar log_data[LSN_STORE_SIZE + FILEID_STORE_SIZE +
KEY_NR_STORE_SIZE];
@ -402,7 +404,7 @@ static int _ma_ck_write_btree_with_log(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
lsn_store(log_data, info->trn->undo_lsn);
key_nr_store(log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE,
keyinfo->key_nr);
key_length+= info->s->rec_reflength;
key_length+= share->rec_reflength;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= (char*) log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= (char*) key_buff;
@ -466,24 +468,24 @@ int _ma_enlarge_root(MARIA_HA *info, MARIA_KEYDEF *keyinfo, const uchar *key,
{
uint t_length, nod_flag, page_length;
MARIA_KEY_PARAM s_temp;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
MARIA_PINNED_PAGE tmp_page_link, *page_link= &tmp_page_link;
int res= 0;
DBUG_ENTER("_ma_enlarge_root");
nod_flag= (*root != HA_OFFSET_ERROR) ? share->base.key_reflength : 0;
/* Store pointer to prev page if nod */
_ma_kpointer(info, info->buff + info->s->keypage_header, *root);
_ma_kpointer(info, info->buff + share->keypage_header, *root);
t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar*) 0,
(uchar*) 0, (uchar*) 0, key,&s_temp);
page_length= info->s->keypage_header + t_length + nod_flag;
page_length= share->keypage_header + t_length + nod_flag;
bzero(info->buff, info->s->keypage_header);
_ma_store_keynr(info, info->buff, keyinfo->key_nr);
_ma_store_page_used(info, info->buff, page_length);
bzero(info->buff, share->keypage_header);
_ma_store_keynr(share, info->buff, keyinfo->key_nr);
_ma_store_page_used(share, info->buff, page_length);
if (nod_flag)
_ma_store_keypage_flag(info, info->buff, KEYPAGE_FLAG_ISNOD);
(*keyinfo->store_key)(keyinfo, info->buff + info->s->keypage_header +
_ma_store_keypage_flag(share, info->buff, KEYPAGE_FLAG_ISNOD);
(*keyinfo->store_key)(keyinfo, info->buff + share->keypage_header +
nod_flag, &s_temp);
/* Mark that info->buff was used */
@ -500,7 +502,7 @@ int _ma_enlarge_root(MARIA_HA *info, MARIA_KEYDEF *keyinfo, const uchar *key,
bzero(info->buff + page_length, share->block_size - page_length);
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_new(info, *root, info->buff, page_length, keyinfo->key_nr, 1))
res= -1;
if (_ma_write_keypage(info, keyinfo, *root, page_link->write_lock,
@ -533,6 +535,7 @@ static int w_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
my_bool was_last_key;
my_off_t next_page, dup_key_pos;
MARIA_PINNED_PAGE *page_link;
MARIA_SHARE *share= info->s;
DBUG_ENTER("w_search");
DBUG_PRINT("enter",("page: %ld", (long) page));
@ -546,7 +549,7 @@ static int w_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
flag=(*keyinfo->bin_search)(info,keyinfo,temp_buff,key,search_key_length,
comp_flag, &keypos, keybuff, &was_last_key);
nod_flag= _ma_test_if_nod(info, temp_buff);
nod_flag= _ma_test_if_nod(share, temp_buff);
if (flag == 0)
{
uint tmp_key_length;
@ -576,7 +579,7 @@ static int w_search(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
{
/* popular word. two-level tree. going down */
my_off_t root=dup_key_pos;
keyinfo=&info->s->ft2_keyinfo;
keyinfo= &share->ft2_keyinfo;
get_key_full_length_rdonly(off, key);
key+=off;
/* we'll modify key entry 'in vivo' */
@ -674,22 +677,23 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
int t_length;
uchar *endpos, *prev_key;
MARIA_KEY_PARAM s_temp;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_insert");
DBUG_PRINT("enter",("key_pos: 0x%lx", (ulong) key_pos));
DBUG_EXECUTE("key", _ma_print_key(DBUG_FILE,keyinfo->seg,key,
USE_WHOLE_KEY););
_ma_get_used_and_nod(info, anc_buff, a_length, nod_flag);
_ma_get_used_and_nod(share, anc_buff, a_length, nod_flag);
org_anc_length= a_length;
endpos= anc_buff+ a_length;
prev_key= (key_pos == anc_buff + info->s->keypage_header + nod_flag ?
prev_key= (key_pos == anc_buff + share->keypage_header + nod_flag ?
(uchar*) 0 : key_buff);
t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,
(key_pos == endpos ? (uchar*) 0 : key_pos),
prev_key, prev_key,
key,&s_temp);
#ifndef DBUG_OFF
if (key_pos != anc_buff + info->s->keypage_header + nod_flag &&
if (key_pos != anc_buff + share->keypage_header + nod_flag &&
(keyinfo->flag & (HA_BINARY_PACK_KEY | HA_PACK_KEY)))
{
DBUG_DUMP("prev_key",(uchar*) key_buff, _ma_keylength(keyinfo,key_buff));
@ -706,7 +710,7 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
{
if (t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
{
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(-1);
}
@ -716,7 +720,7 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
{
if (-t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
{
maria_print_error(info->s, HA_ERR_CRASHED);
maria_print_error(share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(-1);
}
@ -724,7 +728,7 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
}
(*keyinfo->store_key)(keyinfo,key_pos,&s_temp);
a_length+=t_length;
_ma_store_page_used(info, anc_buff, a_length);
_ma_store_page_used(share, anc_buff, a_length);
/*
Check if the new key fits totally into the the page
@ -734,16 +738,16 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
{
if (keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE - a_length < 32 &&
(keyinfo->flag & HA_FULLTEXT) && key_pos == endpos &&
info->s->base.key_reflength <= info->s->base.rec_reflength &&
info->s->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
share->base.key_reflength <= share->base.rec_reflength &&
share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
{
/*
Normal word. One-level tree. Page is almost full.
Let's consider converting.
We'll compare 'key' and the first key at anc_buff
*/
const uchar *a= key, *b= anc_buff + info->s->keypage_header + nod_flag;
uint alen, blen, ft2len=info->s->ft2_keyinfo.keylength;
const uchar *a= key, *b= anc_buff + share->keypage_header + nod_flag;
uint alen, blen, ft2len= share->ft2_keyinfo.keylength;
/* the very first key on the page is always unpacked */
DBUG_ASSERT((*b & 128) == 0);
#if HA_FT_MAXLEN >= 127
@ -777,7 +781,7 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
insert_dynamic(info->ft1_to_ft2, (uchar*) b);
/* fixing the page's length - it contains only one key now */
_ma_store_page_used(info, anc_buff, info->s->keypage_header + blen +
_ma_store_page_used(share, anc_buff, share->keypage_header + blen +
ft2len + 2);
}
/* the rest will be done when we're back from recursion */
@ -785,7 +789,7 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
}
else
{
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_add(info, anc_page, anc_buff, (uint) (endpos - anc_buff),
key_pos, s_temp.changed_length, t_length, 0))
DBUG_RETURN(-1);
@ -796,7 +800,7 @@ int _ma_insert(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
if (nod_flag)
insert_last=0;
if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)) &&
father_buff && !insert_last)
father_buff && !insert_last && !info->quick_mode)
{
s_temp.key_pos= key_pos;
father_page_link->changed= 1;
@ -848,17 +852,18 @@ int _ma_split_page(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
my_off_t new_pos;
MARIA_KEY_PARAM s_temp;
MARIA_PINNED_PAGE tmp_page_link, *page_link= &tmp_page_link;
MARIA_SHARE *share= info->s;
int res;
DBUG_ENTER("maria_split_page");
LINT_INIT(after_key);
DBUG_DUMP("buff", split_buff, _ma_get_page_used(info, split_buff));
DBUG_DUMP("buff", split_buff, _ma_get_page_used(share, split_buff));
info->page_changed=1; /* Info->buff is used */
info->keyread_buff_used=1;
new_buff= info->buff;
nod_flag=_ma_test_if_nod(info, split_buff);
key_ref_length= info->s->keypage_header + nod_flag;
nod_flag= _ma_test_if_nod(share, split_buff);
key_ref_length= share->keypage_header + nod_flag;
if (insert_last_key)
key_pos= _ma_find_last_pos(info, keyinfo, split_buff,
key_buff, &key_length,
@ -870,15 +875,15 @@ int _ma_split_page(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
DBUG_RETURN(-1);
split_length= (uint) (key_pos - split_buff);
a_length= _ma_get_page_used(info, split_buff);
_ma_store_page_used(info, split_buff, split_length);
a_length= _ma_get_page_used(share, split_buff);
_ma_store_page_used(share, split_buff, split_length);
key_pos=after_key;
if (nod_flag)
{
DBUG_PRINT("test",("Splitting nod"));
pos=key_pos-nod_flag;
memcpy((uchar*) new_buff + info->s->keypage_header, (uchar*) pos,
memcpy((uchar*) new_buff + share->keypage_header, (uchar*) pos,
(size_t) nod_flag);
}
@ -901,28 +906,28 @@ int _ma_split_page(register MARIA_HA *info, register MARIA_KEYDEF *keyinfo,
(*keyinfo->store_key)(keyinfo,new_buff+key_ref_length,&s_temp);
page_length= length + t_length + key_ref_length;
bzero(new_buff, info->s->keypage_header);
bzero(new_buff, share->keypage_header);
if (nod_flag)
_ma_store_keypage_flag(info, new_buff, KEYPAGE_FLAG_ISNOD);
_ma_store_page_used(info, new_buff, page_length);
_ma_store_keypage_flag(share, new_buff, KEYPAGE_FLAG_ISNOD);
_ma_store_page_used(share, new_buff, page_length);
/* Copy key number */
new_buff[info->s->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_KEYID_SIZE -
new_buff[share->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_KEYID_SIZE -
KEYPAGE_FLAG_SIZE]=
split_buff[info->s->keypage_header - KEYPAGE_USED_SIZE -
split_buff[share->keypage_header - KEYPAGE_USED_SIZE -
KEYPAGE_KEYID_SIZE - KEYPAGE_FLAG_SIZE];
res= 2; /* Middle key up */
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_new(info, new_pos, new_buff, page_length, keyinfo->key_nr, 0))
res= -1;
bzero(new_buff + page_length, info->s->block_size - page_length);
bzero(new_buff + page_length, share->block_size - page_length);
if (_ma_write_keypage(info, keyinfo, new_pos, page_link->write_lock,
DFLT_INIT_HITS, new_buff))
res= -1;
/* Save changes to split pages */
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_split(info, split_page, split_buff, org_split_length,
split_length,
inserted_key_pos, changed_length, move_length,
@ -949,10 +954,11 @@ uchar *_ma_find_half_pos(MARIA_HA *info, uint nod_flag, MARIA_KEYDEF *keyinfo,
{
uint keys,length,key_ref_length;
uchar *end,*lastpos;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_find_half_pos");
key_ref_length= info->s->keypage_header + nod_flag;
length= _ma_get_page_used(info, page) - key_ref_length;
key_ref_length= share->keypage_header + nod_flag;
length= _ma_get_page_used(share, page) - key_ref_length;
page+= key_ref_length; /* Point to first key */
if (!(keyinfo->flag &
(HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
@ -997,10 +1003,11 @@ static uchar *_ma_find_last_pos(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint keys,length,last_length,key_ref_length;
uchar *end,*lastpos,*prevpos;
uchar key_buff[HA_MAX_KEY_BUFF];
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_find_last_pos");
key_ref_length= info->s->keypage_header;
length= _ma_get_page_used(info, page) - key_ref_length;
key_ref_length= share->keypage_header;
length= _ma_get_page_used(share, page) - key_ref_length;
page+=key_ref_length;
if (!(keyinfo->flag &
(HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
@ -1063,6 +1070,7 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
{
MARIA_PINNED_PAGE *next_page_link;
MARIA_PINNED_PAGE tmp_page_link, *new_page_link= &tmp_page_link;
MARIA_SHARE *share= info->s;
my_bool right;
uint k_length,father_length,father_keylength,nod_flag,curr_keylength;
uint right_length,left_length,new_right_length,new_left_length,extra_length;
@ -1073,19 +1081,19 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
DBUG_ENTER("_ma_balance_page");
k_length=keyinfo->keylength;
father_length= _ma_get_page_used(info, father_buff);
father_keylength= k_length + info->s->base.key_reflength;
nod_flag=_ma_test_if_nod(info, curr_buff);
father_length= _ma_get_page_used(share, father_buff);
father_keylength= k_length + share->base.key_reflength;
nod_flag= _ma_test_if_nod(share, curr_buff);
curr_keylength=k_length+nod_flag;
info->page_changed=1;
if ((father_key_pos != father_buff+father_length &&
(info->state->records & 1)) ||
father_key_pos == father_buff+ info->s->keypage_header +
info->s->base.key_reflength)
father_key_pos == father_buff+ share->keypage_header +
share->base.key_reflength)
{
right=1;
next_page= _ma_kpos(info->s->base.key_reflength,
next_page= _ma_kpos(share->base.key_reflength,
father_key_pos+father_keylength);
buff=info->buff;
DBUG_PRINT("info", ("use right page: %lu", (ulong) next_page));
@ -1094,7 +1102,7 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
{
right=0;
father_key_pos-=father_keylength;
next_page= _ma_kpos(info->s->base.key_reflength,father_key_pos);
next_page= _ma_kpos(share->base.key_reflength,father_key_pos);
/* Move curr_buff so that it's on the left */
buff= curr_buff;
curr_buff= info->buff;
@ -1105,23 +1113,23 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
DFLT_INIT_HITS, info->buff, 0, &next_page_link))
goto err;
next_page_link->changed= 1;
DBUG_DUMP("next", info->buff, _ma_get_page_used(info, info->buff));
DBUG_DUMP("next", info->buff, _ma_get_page_used(share, info->buff));
/* Test if there is room to share keys */
left_length= _ma_get_page_used(info, curr_buff);
right_length= _ma_get_page_used(info, buff);
keys= ((left_length+right_length-info->s->keypage_header*2-nod_flag*2)/
left_length= _ma_get_page_used(share, curr_buff);
right_length= _ma_get_page_used(share, buff);
keys= ((left_length+right_length-share->keypage_header*2-nod_flag*2)/
curr_keylength);
if ((right ? right_length : left_length) + curr_keylength <=
(uint) keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE)
{
/* Enough space to hold all keys in the two buffers ; Balance bufferts */
new_left_length= info->s->keypage_header+nod_flag+(keys/2)*curr_keylength;
new_right_length=info->s->keypage_header+nod_flag+(((keys+1)/2)*
new_left_length= share->keypage_header+nod_flag+(keys/2)*curr_keylength;
new_right_length=share->keypage_header+nod_flag+(((keys+1)/2)*
curr_keylength);
_ma_store_page_used(info, curr_buff, new_left_length);
_ma_store_page_used(info, buff, new_right_length);
_ma_store_page_used(share, curr_buff, new_left_length);
_ma_store_page_used(share, buff, new_right_length);
DBUG_PRINT("info", ("left_length: %u -> %u right_length: %u -> %u",
left_length, new_left_length,
@ -1134,13 +1142,13 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
/* Move keys buff -> curr_buff */
pos=curr_buff+left_length;
memcpy(pos,father_key_pos, (size_t) k_length);
memcpy(pos+k_length, buff + info->s->keypage_header,
memcpy(pos+k_length, buff + share->keypage_header,
(size_t) (length=new_left_length - left_length - k_length));
pos= buff + info->s->keypage_header + length;
pos= buff + share->keypage_header + length;
memcpy(father_key_pos, pos, (size_t) k_length);
bmove(buff + info->s->keypage_header, pos + k_length, new_right_length);
bmove(buff + share->keypage_header, pos + k_length, new_right_length);
if (info->s->now_transactional)
if (share->now_transactional)
{
if (right)
{
@ -1197,15 +1205,15 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
DBUG_PRINT("info", ("move keys to start of buff"));
bmove_upp(buff + new_right_length, buff + right_length,
right_length - info->s->keypage_header);
right_length - share->keypage_header);
length= new_right_length -right_length - k_length;
memcpy(buff + info->s->keypage_header + length, father_key_pos,
memcpy(buff + share->keypage_header + length, father_key_pos,
(size_t) k_length);
pos=curr_buff+new_left_length;
memcpy(father_key_pos, pos, (size_t) k_length);
memcpy(buff + info->s->keypage_header, pos+k_length, (size_t) length);
memcpy(buff + share->keypage_header, pos+k_length, (size_t) length);
if (info->s->now_transactional)
if (share->now_transactional)
{
if (right)
{
@ -1246,7 +1254,7 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
s_temp->changed_length,
s_temp->move_length,
KEY_OP_ADD_PREFIX,
buff + info->s->keypage_header,
buff + share->keypage_header,
diff_length, diff_length + k_length))
goto err;
/*
@ -1261,7 +1269,7 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
/* Log changes to father (one level up) page */
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_change(info, father_page, father_buff, father_key_pos,
k_length))
goto err;
@ -1282,8 +1290,8 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
/* curr_buff[] and buff[] are full, lets split and make new nod */
extra_buff= info->buff+info->s->base.max_key_block_length;
new_left_length= new_right_length= (info->s->keypage_header + nod_flag +
extra_buff= info->buff+share->base.max_key_block_length;
new_left_length= new_right_length= (share->keypage_header + nod_flag +
(keys+1) / 3 * curr_keylength);
/*
5 is the minum number of keys we can have here. This comes from
@ -1294,42 +1302,42 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
new_left_length-=curr_keylength;
extra_length= (nod_flag + left_length + right_length -
new_left_length - new_right_length - curr_keylength);
extra_buff_length= extra_length + info->s->keypage_header;
extra_buff_length= extra_length + share->keypage_header;
DBUG_PRINT("info",("left_length: %d right_length: %d new_left_length: %d new_right_length: %d extra_length: %d",
left_length, right_length,
new_left_length, new_right_length,
extra_length));
_ma_store_page_used(info, curr_buff, new_left_length);
_ma_store_page_used(info, buff, new_right_length);
_ma_store_page_used(share, curr_buff, new_left_length);
_ma_store_page_used(share, buff, new_right_length);
bzero(extra_buff, info->s->keypage_header);
bzero(extra_buff, share->keypage_header);
if (nod_flag)
_ma_store_keypage_flag(info, extra_buff, KEYPAGE_FLAG_ISNOD);
_ma_store_keypage_flag(share, extra_buff, KEYPAGE_FLAG_ISNOD);
/* Copy key number */
extra_buff[info->s->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_KEYID_SIZE -
extra_buff[share->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_KEYID_SIZE -
KEYPAGE_FLAG_SIZE]=
buff[info->s->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_KEYID_SIZE -
buff[share->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_KEYID_SIZE -
KEYPAGE_FLAG_SIZE];
_ma_store_page_used(info, extra_buff, extra_buff_length);
_ma_store_page_used(share, extra_buff, extra_buff_length);
/* move first largest keys to new page */
pos=buff+right_length-extra_length;
memcpy(extra_buff + info->s->keypage_header, pos, extra_length);
memcpy(extra_buff + share->keypage_header, pos, extra_length);
/* Zero old data from buffer */
bzero(extra_buff + extra_buff_length,
info->s->block_size - extra_buff_length);
share->block_size - extra_buff_length);
/* Save new parting key between buff and extra_buff */
memcpy(tmp_part_key, pos-k_length,k_length);
/* Make place for new keys */
bmove_upp(buff+ new_right_length, pos - k_length,
right_length - extra_length - k_length - info->s->keypage_header);
right_length - extra_length - k_length - share->keypage_header);
/* Copy keys from left page */
pos= curr_buff+new_left_length;
memcpy(buff + info->s->keypage_header, pos + k_length,
memcpy(buff + share->keypage_header, pos + k_length,
(size_t) (tmp_length= left_length - new_left_length - k_length));
/* Copy old parting key */
parting_key= buff + info->s->keypage_header + tmp_length;
parting_key= buff + share->keypage_header + tmp_length;
memcpy(parting_key, father_key_pos, (size_t) k_length);
/* Move new parting keys up to caller */
@ -1341,7 +1349,7 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
goto err;
_ma_kpointer(info,key+k_length,new_pos);
if (info->s->now_transactional)
if (share->now_transactional)
{
if (right)
{
@ -1416,7 +1424,7 @@ static int _ma_balance_page(register MARIA_HA *info, MARIA_KEYDEF *keyinfo,
}
/* Log changes to father (one level up) page */
if (info->s->now_transactional &&
if (share->now_transactional &&
_ma_log_change(info, father_page, father_buff, father_key_pos,
k_length))
goto err;
@ -1481,27 +1489,28 @@ static int keys_free(uchar *key, TREE_FREE mode, bulk_insert_param *param)
Probably I can use info->lastkey here, but I'm not sure,
and to be safe I'd better use local lastkey.
*/
MARIA_SHARE *share= param->info->s;
uchar lastkey[HA_MAX_KEY_BUFF];
uint keylen;
MARIA_KEYDEF *keyinfo;
switch (mode) {
case free_init:
if (param->info->s->concurrent_insert)
if (share->concurrent_insert)
{
rw_wrlock(&param->info->s->key_root_lock[param->keynr]);
param->info->s->keyinfo[param->keynr].version++;
rw_wrlock(&share->key_root_lock[param->keynr]);
share->keyinfo[param->keynr].version++;
}
return 0;
case free_free:
keyinfo=param->info->s->keyinfo+param->keynr;
keyinfo=share->keyinfo+param->keynr;
keylen= _ma_keylength(keyinfo, key);
memcpy(lastkey, key, keylen);
return _ma_ck_write_btree(param->info, param->keynr, lastkey,
keylen - param->info->s->rec_reflength);
keylen - share->rec_reflength);
case free_end:
if (param->info->s->concurrent_insert)
rw_unlock(&param->info->s->key_root_lock[param->keynr]);
if (share->concurrent_insert)
rw_unlock(&share->key_root_lock[param->keynr]);
return 0;
}
return -1;
@ -1510,7 +1519,7 @@ static int keys_free(uchar *key, TREE_FREE mode, bulk_insert_param *param)
int maria_init_bulk_insert(MARIA_HA *info, ulong cache_size, ha_rows rows)
{
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *key=share->keyinfo;
bulk_insert_param *params;
uint i, num_keys, total_keylength;
@ -1619,14 +1628,14 @@ static my_bool _ma_log_new(MARIA_HA *info, my_off_t page, uchar *buff,
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE
+1];
LEX_STRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_log_new");
DBUG_PRINT("enter", ("page: %lu", (ulong) page));
DBUG_ASSERT(info->s->now_transactional);
DBUG_ASSERT(share->now_transactional);
/* Store address of new root page */
page/= info->s->block_size;
page/= share->block_size;
page_store(log_data + FILEID_STORE_SIZE, page);
/* Store link to next unused page */
@ -1634,7 +1643,7 @@ static my_bool _ma_log_new(MARIA_HA *info, my_off_t page, uchar *buff,
page= 0; /* key_del not changed */
else
page= ((share->current_key_del == HA_OFFSET_ERROR) ? IMPOSSIBLE_PAGE_NO :
share->current_key_del / info->s->block_size);
share->current_key_del / share->block_size);
page_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE, page);
key_nr_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE*2, key_nr);

23
storage/maria/maria_chk.c
View File

@ -855,7 +855,7 @@ static int maria_chk(HA_CHECK *param, char *filename)
}
DBUG_RETURN(1);
}
share=info->s;
share= info->s;
share->tot_locks-= share->r_locks;
share->r_locks=0;
maria_block_size= share->base.block_size;
@ -958,7 +958,7 @@ static int maria_chk(HA_CHECK *param, char *filename)
printf("- '%s' has old table-format. Recreating index\n",filename);
rep_quick|=T_QUICK;
}
share=info->s;
share= info->s;
share->tot_locks-= share->r_locks;
share->r_locks=0;
}
@ -1244,7 +1244,7 @@ static void descript(HA_CHECK *param, register MARIA_HA *info, char *name)
reg4 const char *text;
char buff[160],length[10],*pos,*end;
enum en_fieldtype type;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
char llbuff[22],llbuff2[22];
DBUG_ENTER("describe");
@ -1514,7 +1514,7 @@ static int maria_sort_records(HA_CHECK *param,
File new_file;
uchar *temp_buff;
ha_rows old_record_count;
MARIA_SHARE *share=info->s;
MARIA_SHARE *share= info->s;
char llbuff[22],llbuff2[22];
MARIA_SORT_INFO sort_info;
MARIA_SORT_PARAM sort_param;
@ -1684,6 +1684,7 @@ static int sort_record_index(MARIA_SORT_PARAM *sort_param,MARIA_HA *info,
my_off_t page, uchar *buff, uint sort_key,
File new_file,my_bool update_index)
{
MARIA_SHARE *share= info->s;
uint nod_flag,used_length,key_length;
uchar *temp_buff,*keypos,*endpos;
my_off_t next_page,rec_pos;
@ -1693,7 +1694,7 @@ static int sort_record_index(MARIA_SORT_PARAM *sort_param,MARIA_HA *info,
HA_CHECK *param=sort_info->param;
DBUG_ENTER("sort_record_index");
nod_flag=_ma_test_if_nod(info, buff);
nod_flag=_ma_test_if_nod(share, buff);
temp_buff=0;
if (nod_flag)
@ -1704,8 +1705,8 @@ static int sort_record_index(MARIA_SORT_PARAM *sort_param,MARIA_HA *info,
DBUG_RETURN(-1);
}
}
used_length= _ma_get_page_used(info, buff);
keypos= buff + info->s->keypage_header + nod_flag;
used_length= _ma_get_page_used(share, buff);
keypos= buff + share->keypage_header + nod_flag;
endpos= buff + used_length;
for ( ;; )
{
@ -1713,7 +1714,7 @@ static int sort_record_index(MARIA_SORT_PARAM *sort_param,MARIA_HA *info,
if (nod_flag)
{
next_page= _ma_kpos(nod_flag, keypos);
if (my_pread(info->s->kfile.file, (uchar*)temp_buff,
if (my_pread(share->kfile.file, (uchar*)temp_buff,
(uint) keyinfo->block_length, next_page,
MYF(MY_NABP+MY_WME)))
{
@ -1733,14 +1734,14 @@ static int sort_record_index(MARIA_SORT_PARAM *sort_param,MARIA_HA *info,
break;
rec_pos= _ma_dpos(info,0,lastkey+key_length);
if ((*info->s->read_record)(info,sort_param->record,rec_pos))
if ((*share->read_record)(info,sort_param->record,rec_pos))
{
_ma_check_print_error(param,"%d when reading datafile",my_errno);
goto err;
}
if (rec_pos != sort_param->filepos && update_index)
{
_ma_dpointer(info,keypos-nod_flag-info->s->rec_reflength,
_ma_dpointer(info,keypos-nod_flag-share->rec_reflength,
sort_param->filepos);
if (maria_movepoint(info,sort_param->record,rec_pos,sort_param->filepos,
sort_key))
@ -1754,7 +1755,7 @@ static int sort_record_index(MARIA_SORT_PARAM *sort_param,MARIA_HA *info,
}
/* Clear end of block to get better compression if the table is backuped */
bzero((uchar*) buff+used_length,keyinfo->block_length-used_length);
if (my_pwrite(info->s->kfile.file, (uchar*)buff, (uint)keyinfo->block_length,
if (my_pwrite(share->kfile.file, (uchar*)buff, (uint)keyinfo->block_length,
page,param->myf_rw))
{
_ma_check_print_error(param,"%d when updating keyblock",my_errno);

26
storage/maria/maria_def.h
View File

@ -550,26 +550,26 @@ struct st_maria_handler
TRANSID_SIZE)
#define KEYPAGE_FLAG_ISNOD 1
#define _ma_get_page_used(info,x) \
((uint) mi_uint2korr((x) + (info)->s->keypage_header - KEYPAGE_USED_SIZE))
#define _ma_store_page_used(info,x,y) \
mi_int2store((x) + (info)->s->keypage_header - KEYPAGE_USED_SIZE, (y))
#define _ma_test_if_nod(info,x) \
((_ma_get_keypage_flag(info,x) & KEYPAGE_FLAG_ISNOD) ? (info)->s->base.key_reflength : 0)
#define _ma_get_page_used(share,x) \
((uint) mi_uint2korr((x) + (share)->keypage_header - KEYPAGE_USED_SIZE))
#define _ma_store_page_used(share,x,y) \
mi_int2store((x) + (share)->keypage_header - KEYPAGE_USED_SIZE, (y))
#define _ma_test_if_nod(share,x) \
((_ma_get_keypage_flag(share,x) & KEYPAGE_FLAG_ISNOD) ? (share)->base.key_reflength : 0)
#define _ma_get_used_and_nod(info,buff,length,nod) \
#define _ma_get_used_and_nod(share,buff,length,nod) \
{ \
nod= _ma_test_if_nod((info),(buff)); \
length= _ma_get_page_used((info),(buff)); \
nod= _ma_test_if_nod((share),(buff)); \
length= _ma_get_page_used((share),(buff)); \
}
#define _ma_store_keynr(info, x, nr) x[(info)->s->keypage_header - KEYPAGE_KEYID_SIZE - KEYPAGE_FLAG_SIZE - KEYPAGE_USED_SIZE]= (nr)
#define _ma_get_keynr(info, x) ((uchar) x[(info)->s->keypage_header - KEYPAGE_KEYID_SIZE - KEYPAGE_FLAG_SIZE - KEYPAGE_USED_SIZE])
#define _ma_store_keynr(share, x, nr) x[(share)->keypage_header - KEYPAGE_KEYID_SIZE - KEYPAGE_FLAG_SIZE - KEYPAGE_USED_SIZE]= (nr)
#define _ma_get_keynr(share, x) ((uchar) x[(share)->keypage_header - KEYPAGE_KEYID_SIZE - KEYPAGE_FLAG_SIZE - KEYPAGE_USED_SIZE])
#define _ma_store_transid(buff, transid) \
int6store((buff) + LSN_STORE_SIZE, (transid))
#define _ma_korr_transid(buff) \
uint6korr((buff) + LSN_STORE_SIZE)
#define _ma_get_keypage_flag(info,x) x[(info)->s->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]
#define _ma_store_keypage_flag(info,x,flag) x[(info)->s->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]= (flag)
#define _ma_get_keypage_flag(share,x) x[(share)->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]
#define _ma_store_keypage_flag(share,x,flag) x[(share)->keypage_header - KEYPAGE_USED_SIZE - KEYPAGE_FLAG_SIZE]= (flag)
#define maria_mark_crashed(x) do{(x)->s->state.changed|= STATE_CRASHED; \