my_bool has_path(const char *name)
{
return MY_TEST(strchr(name, FN_LIBCHAR))
#if FN_LIBCHAR != '/'
|| MY_TEST(strchr(name, '/'))
#endif
#ifdef FN_DEVCHAR
|| MY_TEST(strchr(name, FN_DEVCHAR))
#endif
;
}
static unsigned long _mask_to_int(MY_MASK *mask)
{
int i;
unsigned long rc = 0;
for (i=0; i<NUMA_NUM_NODES; i++) {
#if NEW_TOOLS
if (MY_TEST(*mask, i))
#else
if (MY_TEST(mask, i))
#endif
rc += (1 << i);
}
return rc;
}
void hp_make_key(HP_KEYDEF *keydef, uchar *key, const uchar *rec)
{
HA_KEYSEG *seg,*endseg;
for (seg=keydef->seg,endseg=seg+keydef->keysegs ; seg < endseg ; seg++)
{
CHARSET_INFO *cs= seg->charset;
uint char_length= seg->length;
uchar *pos= (uchar*) rec + seg->start;
if (seg->null_bit)
*key++= MY_TEST(rec[seg->null_pos] & seg->null_bit);
if (cs->mbmaxlen > 1)
{
char_length= my_charpos(cs, pos, pos + seg->length,
char_length / cs->mbmaxlen);
set_if_smaller(char_length, seg->length); /* QQ: ok to remove? */
}
if (seg->type == HA_KEYTYPE_VARTEXT1)
char_length+= seg->bit_start; /* Copy also length */
else if (seg->type == HA_KEYTYPE_BIT && seg->bit_length)
{
*key++= get_rec_bits(rec + seg->bit_pos,
seg->bit_start, seg->bit_length);
char_length--;
}
memcpy(key,rec+seg->start,(size_t) char_length);
key+= char_length;
}
}
static void
dummy_notify (GObject *object,
GParamSpec *pspec)
{
GTest *test;
test = MY_TEST (object);
test->count++;
}
static void
my_test_dispose (GObject * object)
{
GTest *test;
test = MY_TEST (object);
g_print ("dispose %p!\n", test);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
my_test_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GTest *test = MY_TEST (object);
switch (prop_id)
{
case ARG_TEST_PROP:
g_value_set_int (value, test->value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
my_bool
check_scramble(const uchar *scramble_arg, const char *message,
const uint8 *hash_stage2)
{
uint8 buf[SHA1_HASH_SIZE];
uint8 hash_stage2_reassured[SHA1_HASH_SIZE];
/* create key to encrypt scramble */
compute_sha1_hash_multi(buf, message, SCRAMBLE_LENGTH,
(const char *) hash_stage2, SHA1_HASH_SIZE);
/* encrypt scramble */
my_crypt((char *) buf, buf, scramble_arg, SCRAMBLE_LENGTH);
/* now buf supposedly contains hash_stage1: so we can get hash_stage2 */
compute_sha1_hash(hash_stage2_reassured, (const char *) buf, SHA1_HASH_SIZE);
return MY_TEST(memcmp(hash_stage2, hash_stage2_reassured, SHA1_HASH_SIZE));
}
void hp_make_key(HP_KEYDEF *keydef, uchar *key, const uchar *rec)
{
HA_KEYSEG *seg,*endseg;
for (seg=keydef->seg,endseg=seg+keydef->keysegs ; seg < endseg ; seg++)
{
const CHARSET_INFO *cs= seg->charset;
uint char_length= seg->length;
const uchar *pos= rec + seg->start;
if (seg->null_bit)
*key++= MY_TEST(rec[seg->null_pos] & seg->null_bit);
if (seg->flag & HA_BLOB_PART)
{
uint tmp_length= hp_calc_blob_length(seg->bit_start, pos);
uint length= MY_MIN(seg->length, tmp_length);
memcpy(&pos, rec + seg->bit_start, sizeof(char *));
if (cs->mbmaxlen > 1)
{
char_length= my_charpos(cs, pos, pos + seg->length,
char_length / cs->mbmaxlen);
set_if_smaller(char_length, length); /* QQ: ok to remove? */
}
store_key_length_inc(key, char_length);
}
else
{
if (cs->mbmaxlen > 1)
{
char_length= my_charpos(cs, pos, pos + seg->length,
char_length / cs->mbmaxlen);
set_if_smaller(char_length, seg->length); /* QQ: ok to remove? */
}
if (seg->type == HA_KEYTYPE_VARTEXT1)
char_length+= seg->bit_start; /* Copy also length */
}
memcpy(key, pos, (size_t) char_length);
key+= char_length;
}
}
static void
my_test_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GTest *test;
test = MY_TEST (object);
switch (prop_id)
{
case PROP_DUMMY:
test->dummy = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
int _mi_decrement_open_count(MI_INFO *info)
{
uchar buff[2];
MYISAM_SHARE *share=info->s;
int lock_error=0,write_error=0;
if (share->global_changed)
{
uint old_lock=info->lock_type;
share->global_changed=0;
lock_error=mi_lock_database(info,F_WRLCK);
/* Its not fatal even if we couldn't get the lock ! */
if (share->state.open_count > 0)
{
share->state.open_count--;
mi_int2store(buff,share->state.open_count);
write_error= mysql_file_pwrite(share->kfile, buff, sizeof(buff),
sizeof(share->state.header),
MYF(MY_NABP));
}
if (!lock_error)
lock_error=mi_lock_database(info,old_lock);
}
return MY_TEST(lock_error || write_error);
}
int mi_extra(MI_INFO *info, enum ha_extra_function function, void *extra_arg)
{
int error=0;
ulong cache_size;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("mi_extra");
DBUG_PRINT("enter",("function: %d",(int) function));
switch (function) {
case HA_EXTRA_RESET_STATE: /* Reset state (don't free buffers) */
info->lastinx= 0; /* Use first index as def */
info->last_search_keypage=info->lastpos= HA_OFFSET_ERROR;
info->page_changed=1;
/* Next/prev gives first/last */
if (info->opt_flag & READ_CACHE_USED)
{
reinit_io_cache(&info->rec_cache,READ_CACHE,0,
(pbool) (info->lock_type != F_UNLCK),
(pbool) MY_TEST(info->update & HA_STATE_ROW_CHANGED)
);
}
info->update= ((info->update & HA_STATE_CHANGED) | HA_STATE_NEXT_FOUND |
HA_STATE_PREV_FOUND);
break;
case HA_EXTRA_CACHE:
if (info->lock_type == F_UNLCK &&
(share->options & HA_OPTION_PACK_RECORD))
{
error=1; /* Not possibly if not locked */
my_errno=EACCES;
break;
}
if (info->s->file_map) /* Don't use cache if mmap */
break;
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
if ((share->options & HA_OPTION_COMPRESS_RECORD))
{
mysql_mutex_lock(&share->intern_lock);
if (_mi_memmap_file(info))
{
/* We don't nead MADV_SEQUENTIAL if small file */
madvise((char*) share->file_map, share->state.state.data_file_length,
share->state.state.data_file_length <= RECORD_CACHE_SIZE*16 ?
MADV_RANDOM : MADV_SEQUENTIAL);
mysql_mutex_unlock(&share->intern_lock);
break;
}
mysql_mutex_unlock(&share->intern_lock);
}
#endif
if (info->opt_flag & WRITE_CACHE_USED)
{
info->opt_flag&= ~WRITE_CACHE_USED;
if ((error=end_io_cache(&info->rec_cache)))
break;
}
if (!(info->opt_flag &
(READ_CACHE_USED | WRITE_CACHE_USED | MEMMAP_USED)))
{
cache_size= (extra_arg ? *(ulong*) extra_arg :
my_default_record_cache_size);
if (!(init_io_cache(&info->rec_cache,info->dfile,
(uint) MY_MIN(info->state->data_file_length + 1,
cache_size),
READ_CACHE,0L,(pbool) (info->lock_type != F_UNLCK),
MYF(share->write_flag & MY_WAIT_IF_FULL))))
{
info->opt_flag|=READ_CACHE_USED;
info->update&= ~HA_STATE_ROW_CHANGED;
}
if (share->concurrent_insert)
info->rec_cache.end_of_file=info->state->data_file_length;
}
break;
case HA_EXTRA_REINIT_CACHE:
if (info->opt_flag & READ_CACHE_USED)
{
reinit_io_cache(&info->rec_cache,READ_CACHE,info->nextpos,
(pbool) (info->lock_type != F_UNLCK),
(pbool) MY_TEST(info->update & HA_STATE_ROW_CHANGED));
info->update&= ~HA_STATE_ROW_CHANGED;
if (share->concurrent_insert)
info->rec_cache.end_of_file=info->state->data_file_length;
}
break;
case HA_EXTRA_WRITE_CACHE:
if (info->lock_type == F_UNLCK)
{
error=1; /* Not possibly if not locked */
break;
}
cache_size= (extra_arg ? *(ulong*) extra_arg :
my_default_record_cache_size);
if (!(info->opt_flag &
(READ_CACHE_USED | WRITE_CACHE_USED | OPT_NO_ROWS)) &&
!share->state.header.uniques)
if (!(init_io_cache(&info->rec_cache,info->dfile, cache_size,
WRITE_CACHE,info->state->data_file_length,
(pbool) (info->lock_type != F_UNLCK),
MYF(share->write_flag & MY_WAIT_IF_FULL))))
{
info->opt_flag|=WRITE_CACHE_USED;
info->update&= ~(HA_STATE_ROW_CHANGED |
HA_STATE_WRITE_AT_END |
HA_STATE_EXTEND_BLOCK);
}
break;
case HA_EXTRA_PREPARE_FOR_UPDATE:
if (info->s->data_file_type != DYNAMIC_RECORD)
break;
/* Remove read/write cache if dynamic rows */
case HA_EXTRA_NO_CACHE:
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
{
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
error=end_io_cache(&info->rec_cache);
/* Sergei will insert full text index caching here */
}
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
if (info->opt_flag & MEMMAP_USED)
madvise((char*) share->file_map, share->state.state.data_file_length,
MADV_RANDOM);
#endif
break;
case HA_EXTRA_FLUSH_CACHE:
if (info->opt_flag & WRITE_CACHE_USED)
{
if ((error=flush_io_cache(&info->rec_cache)))
{
mi_print_error(info->s, HA_ERR_CRASHED);
mi_mark_crashed(info); /* Fatal error found */
}
}
break;
case HA_EXTRA_NO_READCHECK:
info->opt_flag&= ~READ_CHECK_USED; /* No readcheck */
break;
case HA_EXTRA_READCHECK:
info->opt_flag|= READ_CHECK_USED;
break;
case HA_EXTRA_KEYREAD: /* Read only keys to record */
case HA_EXTRA_REMEMBER_POS:
info->opt_flag |= REMEMBER_OLD_POS;
bmove((uchar*) info->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->lastpos;
info->save_lastkey_length=info->lastkey_length;
if (function == HA_EXTRA_REMEMBER_POS)
break;
/* fall through */
case HA_EXTRA_KEYREAD_CHANGE_POS:
info->opt_flag |= KEY_READ_USED;
info->read_record=_mi_read_key_record;
break;
case HA_EXTRA_NO_KEYREAD:
case HA_EXTRA_RESTORE_POS:
if (info->opt_flag & REMEMBER_OLD_POS)
{
bmove((uchar*) info->lastkey,
(uchar*) info->lastkey+share->base.max_key_length*2,
info->save_lastkey_length);
info->update= info->save_update | HA_STATE_WRITTEN;
info->lastinx= info->save_lastinx;
info->lastpos= info->save_lastpos;
info->lastkey_length=info->save_lastkey_length;
}
info->read_record= share->read_record;
info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
break;
case HA_EXTRA_NO_USER_CHANGE: /* Database is somehow locked agains changes */
info->lock_type= F_EXTRA_LCK; /* Simulate as locked */
break;
case HA_EXTRA_WAIT_LOCK:
info->lock_wait=0;
break;
case HA_EXTRA_NO_WAIT_LOCK:
info->lock_wait=MY_DONT_WAIT;
break;
case HA_EXTRA_NO_KEYS:
if (info->lock_type == F_UNLCK)
{
error=1; /* Not possibly if not lock */
break;
}
if (mi_is_any_key_active(share->state.key_map))
{
MI_KEYDEF *key=share->keyinfo;
uint i;
for (i=0 ; i < share->base.keys ; i++,key++)
{
if (!(key->flag & HA_NOSAME) && info->s->base.auto_key != i+1)
{
mi_clear_key_active(share->state.key_map, i);
info->update|= HA_STATE_CHANGED;
}
}
if (!share->changed)
{
share->state.changed|= STATE_CHANGED | STATE_NOT_ANALYZED;
share->changed=1; /* Update on close */
if (!share->global_changed)
{
share->global_changed=1;
share->state.open_count++;
}
}
share->state.state= *info->state;
error=mi_state_info_write(share->kfile,&share->state,1 | 2);
}
break;
case HA_EXTRA_FORCE_REOPEN:
mysql_mutex_lock(&THR_LOCK_myisam);
share->last_version= 0L; /* Impossible version */
mysql_mutex_unlock(&THR_LOCK_myisam);
break;
case HA_EXTRA_PREPARE_FOR_DROP:
mysql_mutex_lock(&THR_LOCK_myisam);
share->last_version= 0L; /* Impossible version */
#ifdef __WIN__REMOVE_OBSOLETE_WORKAROUND
/* Close the isam and data files as Win32 can't drop an open table */
mysql_mutex_lock(&share->intern_lock);
if (flush_key_blocks(share->key_cache, share->kfile,
(function == HA_EXTRA_FORCE_REOPEN ?
FLUSH_RELEASE : FLUSH_IGNORE_CHANGED)))
{
error=my_errno;
share->changed=1;
mi_print_error(info->s, HA_ERR_CRASHED);
mi_mark_crashed(info); /* Fatal error found */
}
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
{
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
error=end_io_cache(&info->rec_cache);
}
if (info->lock_type != F_UNLCK && ! info->was_locked)
{
info->was_locked=info->lock_type;
if (mi_lock_database(info,F_UNLCK))
error=my_errno;
info->lock_type = F_UNLCK;
}
if (share->kfile >= 0)
_mi_decrement_open_count(info);
if (share->kfile >= 0 && mysql_file_close(share->kfile, MYF(0)))
error=my_errno;
{
LIST *list_element ;
for (list_element=myisam_open_list ;
list_element ;
list_element=list_element->next)
{
MI_INFO *tmpinfo=(MI_INFO*) list_element->data;
if (tmpinfo->s == info->s)
{
if (tmpinfo->dfile >= 0 && mysql_file_close(tmpinfo->dfile, MYF(0)))
error = my_errno;
tmpinfo->dfile= -1;
}
}
}
share->kfile= -1; /* Files aren't open anymore */
mysql_mutex_unlock(&share->intern_lock);
#endif
mysql_mutex_unlock(&THR_LOCK_myisam);
break;
case HA_EXTRA_FLUSH:
if (!share->temporary)
flush_key_blocks(share->key_cache, share->kfile, FLUSH_KEEP);
#ifdef HAVE_PWRITE
_mi_decrement_open_count(info);
#endif
if (share->not_flushed)
{
share->not_flushed=0;
if (mysql_file_sync(share->kfile, MYF(0)))
error= my_errno;
if (mysql_file_sync(info->dfile, MYF(0)))
error= my_errno;
if (error)
{
share->changed=1;
mi_print_error(info->s, HA_ERR_CRASHED);
mi_mark_crashed(info); /* Fatal error found */
}
}
if (share->base.blobs)
mi_alloc_rec_buff(info, -1, &info->rec_buff);
break;
case HA_EXTRA_NORMAL: /* Theese isn't in use */
info->quick_mode=0;
break;
case HA_EXTRA_QUICK:
info->quick_mode=1;
break;
case HA_EXTRA_NO_ROWS:
if (!share->state.header.uniques)
info->opt_flag|= OPT_NO_ROWS;
break;
case HA_EXTRA_PRELOAD_BUFFER_SIZE:
info->preload_buff_size= *((ulong *) extra_arg);
break;
case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
case HA_EXTRA_CHANGE_KEY_TO_DUP:
mi_extra_keyflag(info, function);
break;
case HA_EXTRA_MMAP:
#ifdef HAVE_MMAP
mysql_mutex_lock(&share->intern_lock);
/*
Memory map the data file if it is not already mapped. It is safe
to memory map a file while other threads are using file I/O on it.
Assigning a new address to a function pointer is an atomic
operation. intern_lock prevents that two or more mappings are done
at the same time.
*/
if (!share->file_map)
{
if (mi_dynmap_file(info, share->state.state.data_file_length))
{
DBUG_PRINT("warning",("mmap failed: errno: %d",errno));
error= my_errno= errno;
}
}
mysql_mutex_unlock(&share->intern_lock);
#endif
break;
case HA_EXTRA_MARK_AS_LOG_TABLE:
mysql_mutex_lock(&share->intern_lock);
share->is_log_table= TRUE;
mysql_mutex_unlock(&share->intern_lock);
break;
case HA_EXTRA_KEY_CACHE:
case HA_EXTRA_NO_KEY_CACHE:
default:
break;
}
{
char tmp[1];
tmp[0]=function;
myisam_log_command(MI_LOG_EXTRA,info,(uchar*) tmp,1,error);
}
DBUG_RETURN(error);
} /* mi_extra */
static int run_test(const char *filename)
{
MARIA_HA *file;
int i,j= 0,error,deleted,rec_length,uniques=0;
uint offset_to_key;
ha_rows found,row_count;
uchar record[MAX_REC_LENGTH],key[MAX_REC_LENGTH],read_record[MAX_REC_LENGTH];
MARIA_UNIQUEDEF uniquedef;
MARIA_CREATE_INFO create_info;
if (die_in_middle_of_transaction)
null_fields= 1;
bzero((char*) recinfo,sizeof(recinfo));
bzero((char*) &create_info,sizeof(create_info));
/* First define 2 columns */
create_info.null_bytes= 1;
recinfo[0].type= key_field;
recinfo[0].length= (key_field == FIELD_BLOB ? 4+portable_sizeof_char_ptr :
key_length);
if (key_field == FIELD_VARCHAR)
recinfo[0].length+= HA_VARCHAR_PACKLENGTH(key_length);
recinfo[1].type=extra_field;
recinfo[1].length= (extra_field == FIELD_BLOB ? 4 + portable_sizeof_char_ptr : 24);
if (extra_field == FIELD_VARCHAR)
recinfo[1].length+= HA_VARCHAR_PACKLENGTH(recinfo[1].length);
recinfo[1].null_bit= null_fields ? 2 : 0;
if (opt_unique)
{
recinfo[2].type=FIELD_CHECK;
recinfo[2].length=MARIA_UNIQUE_HASH_LENGTH;
}
rec_length= recinfo[0].length + recinfo[1].length + recinfo[2].length +
create_info.null_bytes;
if (key_type == HA_KEYTYPE_VARTEXT1 &&
key_length > 255)
key_type= HA_KEYTYPE_VARTEXT2;
/* Define a key over the first column */
keyinfo[0].seg=keyseg;
keyinfo[0].keysegs=1;
keyinfo[0].block_length= 0; /* Default block length */
keyinfo[0].key_alg=HA_KEY_ALG_BTREE;
keyinfo[0].seg[0].type= key_type;
keyinfo[0].seg[0].flag= pack_seg;
keyinfo[0].seg[0].start=1;
keyinfo[0].seg[0].length=key_length;
keyinfo[0].seg[0].null_bit= null_fields ? 2 : 0;
keyinfo[0].seg[0].null_pos=0;
keyinfo[0].seg[0].language= default_charset_info->number;
if (pack_seg & HA_BLOB_PART)
{
keyinfo[0].seg[0].bit_start=4; /* Length of blob length */
}
keyinfo[0].flag = (uint8) (pack_keys | unique_key);
bzero((uchar*) flags,sizeof(flags));
if (opt_unique)
{
uint start;
uniques=1;
bzero((char*) &uniquedef,sizeof(uniquedef));
bzero((char*) uniqueseg,sizeof(uniqueseg));
uniquedef.seg=uniqueseg;
uniquedef.keysegs=2;
/* Make a unique over all columns (except first NULL fields) */
for (i=0, start=1 ; i < 2 ; i++)
{
uniqueseg[i].start=start;
start+=recinfo[i].length;
uniqueseg[i].length=recinfo[i].length;
uniqueseg[i].language= default_charset_info->number;
}
uniqueseg[0].type= key_type;
uniqueseg[0].null_bit= null_fields ? 2 : 0;
uniqueseg[1].type= HA_KEYTYPE_TEXT;
if (extra_field == FIELD_BLOB)
{
uniqueseg[1].length=0; /* The whole blob */
uniqueseg[1].bit_start=4; /* long blob */
uniqueseg[1].flag|= HA_BLOB_PART;
}
else if (extra_field == FIELD_VARCHAR)
{
uniqueseg[1].flag|= HA_VAR_LENGTH_PART;
uniqueseg[1].type= (HA_VARCHAR_PACKLENGTH(recinfo[1].length-1) == 1 ?
HA_KEYTYPE_VARTEXT1 : HA_KEYTYPE_VARTEXT2);
}
}
else
uniques=0;
offset_to_key= MY_TEST(null_fields);
if (key_field == FIELD_BLOB || key_field == FIELD_VARCHAR)
offset_to_key+= 2;
if (!silent)
printf("- Creating maria file\n");
create_info.max_rows=(ulong) (rec_pointer_size ?
(1L << (rec_pointer_size*8))/40 :
0);
create_info.transactional= transactional;
if (maria_create(filename, record_type, 1, keyinfo,2+opt_unique,recinfo,
uniques, &uniquedef, &create_info,
create_flag))
goto err;
if (!(file=maria_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
goto err;
if (!silent)
printf("- Writing key:s\n");
if (maria_begin(file))
goto err;
if (opt_versioning)
maria_versioning(file, 1);
my_errno=0;
row_count=deleted=0;
for (i=49 ; i>=1 ; i-=2 )
{
if (insert_count-- == 0)
{
if (testflag)
break;
maria_close(file);
exit(0);
}
j=i%25 +1;
create_record(record,j);
error=maria_write(file,record);
if (!error)
row_count++;
flags[j]=1;
if (verbose || error)
printf("J= %2d maria_write: %d errno: %d\n", j,error,my_errno);
}
if (maria_commit(file) || maria_begin(file))
goto err;
if (checkpoint == 1 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (testflag == 1)
goto end;
/* Insert 2 rows with null values */
if (null_fields)
{
create_record(record,0);
error=maria_write(file,record);
if (!error)
row_count++;
if (verbose || error)
printf("J= NULL maria_write: %d errno: %d\n", error,my_errno);
error=maria_write(file,record);
if (!error)
row_count++;
if (verbose || error)
printf("J= NULL maria_write: %d errno: %d\n", error,my_errno);
flags[0]=2;
}
if (checkpoint == 2 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (testflag == 2)
{
printf("Terminating after inserts\n");
goto end;
}
if (maria_commit(file) || maria_begin(file))
goto err;
if (!skip_update)
{
if (opt_unique)
{
if (!silent)
printf("- Checking unique constraint\n");
create_record(record,j); /* Check last created row */
if (!maria_write(file,record) || my_errno != HA_ERR_FOUND_DUPP_UNIQUE)
{
printf("unique check failed\n");
}
}
if (!silent)
printf("- Updating rows\n");
/* Update first last row to force extend of file */
if (maria_rsame(file,read_record,-1))
{
printf("Can't find last row with maria_rsame\n");
}
else
{
memcpy(record,read_record,rec_length);
update_record(record);
if (maria_update(file,read_record,record))
{
printf("Can't update last row: %.*s\n",
keyinfo[0].seg[0].length,read_record+1);
}
}
/* Read through all rows and update them */
maria_scan_init(file);
found=0;
while ((error= maria_scan(file,read_record)) == 0)
{
if (--update_count == 0) { maria_close(file); exit(0) ; }
memcpy(record,read_record,rec_length);
update_record(record);
if (maria_update(file,read_record,record))
{
printf("Can't update row: %.*s, error: %d\n",
keyinfo[0].seg[0].length,record+1,my_errno);
}
found++;
}
if (found != row_count)
printf("Found %ld of %ld rows\n", (ulong) found, (ulong) row_count);
maria_scan_end(file);
}
if (checkpoint == 3 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (testflag == 3)
{
printf("Terminating after updates\n");
goto end;
}
if (!silent)
printf("- Reopening file\n");
if (maria_commit(file))
goto err;
if (maria_close(file))
goto err;
if (!(file=maria_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
goto err;
if (maria_begin(file))
goto err;
if (opt_versioning)
maria_versioning(file, 1);
if (!skip_delete)
{
if (!silent)
printf("- Removing keys\n");
for (i=0 ; i <= 10 ; i++)
{
/*
If you want to debug the problem in ma_test_recovery with BLOBs
(see @todo there), you can break out of the loop after just one
delete, it is enough, like this:
if (i==1) break;
*/
/* testing */
if (remove_count-- == 0)
{
fprintf(stderr,
"delete-rows number of rows deleted; Going down hard!\n");
goto end;
}
j=i*2;
if (!flags[j])
continue;
create_key(key,j);
my_errno=0;
if ((error = maria_rkey(file, read_record, 0, key,
HA_WHOLE_KEY, HA_READ_KEY_EXACT)))
{
if (verbose || (flags[j] >= 1 ||
(error && my_errno != HA_ERR_KEY_NOT_FOUND)))
printf("key: '%.*s' maria_rkey: %3d errno: %3d\n",
(int) key_length,key+offset_to_key,error,my_errno);
}
else
{
error=maria_delete(file,read_record);
if (verbose || error)
printf("key: '%.*s' maria_delete: %3d errno: %3d\n",
(int) key_length, key+offset_to_key, error, my_errno);
if (! error)
{
deleted++;
flags[j]--;
}
}
}
}
if (checkpoint == 4 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (testflag == 4)
{
printf("Terminating after deletes\n");
goto end;
}
if (!silent)
printf("- Reading rows with key\n");
record[1]= 0; /* For nicer printf */
if (record_type == NO_RECORD)
maria_extra(file, HA_EXTRA_KEYREAD, 0);
for (i=0 ; i <= 25 ; i++)
{
create_key(key,i);
my_errno=0;
error=maria_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT);
if (verbose ||
(error == 0 && flags[i] == 0 && unique_key) ||
(error && (flags[i] != 0 || my_errno != HA_ERR_KEY_NOT_FOUND)))
{
printf("key: '%.*s' maria_rkey: %3d errno: %3d record: %s\n",
(int) key_length,key+offset_to_key,error,my_errno,record+1);
}
}
if (record_type == NO_RECORD)
{
maria_extra(file, HA_EXTRA_NO_KEYREAD, 0);
goto end;
}
if (!silent)
printf("- Reading rows with position\n");
if (maria_scan_init(file))
{
fprintf(stderr, "maria_scan_init failed\n");
goto err;
}
for (i=1,found=0 ; i <= 30 ; i++)
{
my_errno=0;
if ((error= maria_scan(file, read_record)) == HA_ERR_END_OF_FILE)
{
if (found != row_count-deleted)
printf("Found only %ld of %ld rows\n", (ulong) found,
(ulong) (row_count - deleted));
break;
}
if (!error)
found++;
if (verbose || (error != 0 && error != HA_ERR_RECORD_DELETED &&
error != HA_ERR_END_OF_FILE))
{
printf("pos: %2d maria_rrnd: %3d errno: %3d record: %s\n",
i-1,error,my_errno,read_record+1);
}
}
maria_scan_end(file);
end:
if (die_in_middle_of_transaction)
{
/* As commit record is not done, UNDO entries needs to be rolled back */
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.
*/
_ma_flush_table_files(file, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_RELEASE, FLUSH_RELEASE);
break;
case 2:
/*
Just flush log. Pages are likely to not be on disk. Recovery will
then execute REDOs and UNDOs.
*/
if (translog_flush(file->trn->undo_lsn))
goto err;
break;
case 3:
/*
Flush nothing. Pages and log are likely to not be on disk. Recovery
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");
sf_leaking_memory= 1;
exit(0);
}
if (maria_commit(file))
goto err;
if (maria_close(file))
goto err;
maria_end();
my_uuid_end();
my_end(MY_CHECK_ERROR);
return (0);
err:
printf("got error: %3d when using maria-database\n",my_errno);
return 1; /* skip warning */
}
uint hp_rb_make_key(HP_KEYDEF *keydef, uchar *key,
const uchar *rec, uchar *recpos)
{
uchar *start_key= key;
HA_KEYSEG *seg, *endseg;
for (seg= keydef->seg, endseg= seg + keydef->keysegs; seg < endseg; seg++)
{
uint char_length;
if (seg->null_bit)
{
if (!(*key++= 1 - MY_TEST(rec[seg->null_pos] & seg->null_bit)))
continue;
}
if (seg->flag & HA_SWAP_KEY)
{
uint length= seg->length;
uchar *pos= (uchar*) rec + seg->start;
DBUG_ASSERT(seg->type != HA_KEYTYPE_BIT);
#ifdef HAVE_ISNAN
if (seg->type == HA_KEYTYPE_FLOAT)
{
float nr;
float4get(nr, pos);
if (isnan(nr))
{
/* Replace NAN with zero */
bzero(key, length);
key+= length;
continue;
}
}
else if (seg->type == HA_KEYTYPE_DOUBLE)
{
double nr;
float8get(nr, pos);
if (isnan(nr))
{
bzero(key, length);
key+= length;
continue;
}
}
#endif
pos+= length;
while (length--)
{
*key++= *--pos;
}
continue;
}
if (seg->flag & HA_VAR_LENGTH_PART)
{
uchar *pos= (uchar*) rec + seg->start;
uint length= seg->length;
uint pack_length= seg->bit_start;
uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
uint2korr(pos));
CHARSET_INFO *cs= seg->charset;
char_length= length/cs->mbmaxlen;
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy((uchar*) key,(uchar*) pos,(size_t) char_length);
key+= char_length;
continue;
}
char_length= seg->length;
if (seg->charset->mbmaxlen > 1)
{
char_length= my_charpos(seg->charset,
rec + seg->start, rec + seg->start + char_length,
char_length / seg->charset->mbmaxlen);
set_if_smaller(char_length, seg->length); /* QQ: ok to remove? */
if (char_length < seg->length)
seg->charset->cset->fill(seg->charset, (char*) key + char_length,
seg->length - char_length, ' ');
}
if (seg->type == HA_KEYTYPE_BIT && seg->bit_length)
{
*key++= get_rec_bits(rec + seg->bit_pos,
seg->bit_start, seg->bit_length);
char_length--;
}
memcpy(key, rec + seg->start, (size_t) char_length);
key+= seg->length;
}
memcpy(key, &recpos, sizeof(uchar*));
return (uint) (key - start_key);
}
static int run_test(const char *filename)
{
MI_INFO *file;
int i,j,error,deleted,rec_length,uniques=0;
ha_rows found,row_count;
my_off_t pos;
uchar record[MAX_REC_LENGTH],key[MAX_REC_LENGTH],read_record[MAX_REC_LENGTH];
MI_UNIQUEDEF uniquedef;
MI_CREATE_INFO create_info;
memset(recinfo, 0, sizeof(recinfo));
/* First define 2 columns */
recinfo[0].type=FIELD_NORMAL; recinfo[0].length=1; /* For NULL bits */
recinfo[1].type=key_field;
recinfo[1].length= (key_field == FIELD_BLOB ? 4+portable_sizeof_char_ptr :
key_length);
if (key_field == FIELD_VARCHAR)
recinfo[1].length+= HA_VARCHAR_PACKLENGTH(key_length);;
recinfo[2].type=extra_field;
recinfo[2].length= (extra_field == FIELD_BLOB ? 4 + portable_sizeof_char_ptr : 24);
if (extra_field == FIELD_VARCHAR)
recinfo[2].length+= HA_VARCHAR_PACKLENGTH(recinfo[2].length);
if (opt_unique)
{
recinfo[3].type=FIELD_CHECK;
recinfo[3].length=MI_UNIQUE_HASH_LENGTH;
}
rec_length=recinfo[0].length+recinfo[1].length+recinfo[2].length+
recinfo[3].length;
if (key_type == HA_KEYTYPE_VARTEXT1 &&
key_length > 255)
key_type= HA_KEYTYPE_VARTEXT2;
/* Define a key over the first column */
keyinfo[0].seg=keyseg;
keyinfo[0].keysegs=1;
keyinfo[0].block_length= 0; /* Default block length */
keyinfo[0].key_alg=HA_KEY_ALG_BTREE;
keyinfo[0].seg[0].type= key_type;
keyinfo[0].seg[0].flag= pack_seg;
keyinfo[0].seg[0].start=1;
keyinfo[0].seg[0].length=key_length;
keyinfo[0].seg[0].null_bit= null_fields ? 2 : 0;
keyinfo[0].seg[0].null_pos=0;
keyinfo[0].seg[0].language= default_charset_info->number;
if (pack_seg & HA_BLOB_PART)
{
keyinfo[0].seg[0].bit_start=4; /* Length of blob length */
}
keyinfo[0].flag = (uint8) (pack_keys | unique_key);
memset(flags, 0, sizeof(flags));
if (opt_unique)
{
uint start;
uniques=1;
memset(&uniquedef, 0, sizeof(uniquedef));
memset(uniqueseg, 0, sizeof(uniqueseg));
uniquedef.seg=uniqueseg;
uniquedef.keysegs=2;
/* Make a unique over all columns (except first NULL fields) */
for (i=0, start=1 ; i < 2 ; i++)
{
uniqueseg[i].start=start;
start+=recinfo[i+1].length;
uniqueseg[i].length=recinfo[i+1].length;
uniqueseg[i].language= default_charset_info->number;
}
uniqueseg[0].type= key_type;
uniqueseg[0].null_bit= null_fields ? 2 : 0;
uniqueseg[1].type= HA_KEYTYPE_TEXT;
if (extra_field == FIELD_BLOB)
{
uniqueseg[1].length=0; /* The whole blob */
uniqueseg[1].bit_start=4; /* long blob */
uniqueseg[1].flag|= HA_BLOB_PART;
}
else if (extra_field == FIELD_VARCHAR)
uniqueseg[1].flag|= HA_VAR_LENGTH_PART;
}
else
uniques=0;
if (!silent)
printf("- Creating isam-file\n");
memset(&create_info, 0, sizeof(create_info));
create_info.max_rows=(ulong) (rec_pointer_size ?
(1L << (rec_pointer_size*8))/40 :
0);
if (mi_create(filename,1,keyinfo,3+opt_unique,recinfo,
uniques, &uniquedef, &create_info,
create_flag))
goto err;
if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
goto err;
if (!silent)
printf("- Writing key:s\n");
my_errno=0;
row_count=deleted=0;
for (i=49 ; i>=1 ; i-=2 )
{
if (insert_count-- == 0) { (void) mi_close(file); exit(0) ; }
j=i%25 +1;
create_record(record,j);
error=mi_write(file,record);
if (!error)
row_count++;
flags[j]=1;
if (verbose || error)
printf("J= %2d mi_write: %d errno: %d\n", j,error,my_errno);
}
/* Insert 2 rows with null values */
if (null_fields)
{
create_record(record,0);
error=mi_write(file,record);
if (!error)
row_count++;
if (verbose || error)
printf("J= NULL mi_write: %d errno: %d\n", error,my_errno);
error=mi_write(file,record);
if (!error)
row_count++;
if (verbose || error)
printf("J= NULL mi_write: %d errno: %d\n", error,my_errno);
flags[0]=2;
}
if (!skip_update)
{
if (opt_unique)
{
if (!silent)
printf("- Checking unique constraint\n");
create_record(record,j);
if (!mi_write(file,record) || my_errno != HA_ERR_FOUND_DUPP_UNIQUE)
{
printf("unique check failed\n");
}
}
if (!silent)
printf("- Updating rows\n");
/* Update first last row to force extend of file */
if (mi_rsame(file,read_record,-1))
{
printf("Can't find last row with mi_rsame\n");
}
else
{
memcpy(record,read_record,rec_length);
update_record(record);
if (mi_update(file,read_record,record))
{
printf("Can't update last row: %.*s\n",
keyinfo[0].seg[0].length,read_record+1);
}
}
/* Read through all rows and update them */
pos=(my_off_t) 0;
found=0;
while ((error=mi_rrnd(file,read_record,pos)) == 0)
{
if (update_count-- == 0) { (void) mi_close(file); exit(0) ; }
memcpy(record,read_record,rec_length);
update_record(record);
if (mi_update(file,read_record,record))
{
printf("Can't update row: %.*s, error: %d\n",
keyinfo[0].seg[0].length,record+1,my_errno);
}
found++;
pos=HA_OFFSET_ERROR;
}
if (found != row_count)
printf("Found %ld of %ld rows\n", (ulong) found, (ulong) row_count);
}
if (!silent)
printf("- Reopening file\n");
if (mi_close(file)) goto err;
if (!(file=mi_open(filename,2,HA_OPEN_ABORT_IF_LOCKED))) goto err;
if (!skip_update)
{
if (!silent)
printf("- Removing keys\n");
for (i=0 ; i <= 10 ; i++)
{
/* testing */
if (remove_count-- == 0) { (void) mi_close(file); exit(0) ; }
j=i*2;
if (!flags[j])
continue;
create_key(key,j);
my_errno=0;
if ((error = mi_rkey(file,read_record,0,key,HA_WHOLE_KEY,
HA_READ_KEY_EXACT)))
{
if (verbose || (flags[j] >= 1 ||
(error && my_errno != HA_ERR_KEY_NOT_FOUND)))
printf("key: '%.*s' mi_rkey: %3d errno: %3d\n",
(int) key_length,key+MY_TEST(null_fields),error,my_errno);
}
else
{
error=mi_delete(file,read_record);
if (verbose || error)
printf("key: '%.*s' mi_delete: %3d errno: %3d\n",
(int) key_length, key+MY_TEST(null_fields), error, my_errno);
if (! error)
{
deleted++;
flags[j]--;
}
}
}
}
if (!silent)
printf("- Reading rows with key\n");
for (i=0 ; i <= 25 ; i++)
{
create_key(key,i);
my_errno=0;
error=mi_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT);
if (verbose ||
(error == 0 && flags[i] == 0 && unique_key) ||
(error && (flags[i] != 0 || my_errno != HA_ERR_KEY_NOT_FOUND)))
{
printf("key: '%.*s' mi_rkey: %3d errno: %3d record: %s\n",
(int) key_length,key+MY_TEST(null_fields),error,my_errno,record+1);
}
}
if (!silent)
printf("- Reading rows with position\n");
for (i=1,found=0 ; i <= 30 ; i++)
{
my_errno=0;
if ((error=mi_rrnd(file,read_record,i == 1 ? 0L : HA_OFFSET_ERROR)) == -1)
{
if (found != row_count-deleted)
printf("Found only %ld of %ld rows\n", (ulong) found,
(ulong) (row_count - deleted));
break;
}
if (!error)
found++;
if (verbose || (error != 0 && error != HA_ERR_RECORD_DELETED &&
error != HA_ERR_END_OF_FILE))
{
printf("pos: %2d mi_rrnd: %3d errno: %3d record: %s\n",
i-1,error,my_errno,read_record+1);
}
}
if (mi_close(file)) goto err;
my_end(MY_CHECK_ERROR);
return (0);
err:
printf("got error: %3d when using myisam-database\n",my_errno);
return 1; /* skip warning */
}
int hp_key_cmp(HP_KEYDEF *keydef, const uchar *rec, const uchar *key)
{
HA_KEYSEG *seg,*endseg;
for (seg=keydef->seg,endseg=seg+keydef->keysegs ;
seg < endseg ;
key+= (seg++)->length)
{
if (seg->null_bit)
{
int found_null= MY_TEST(rec[seg->null_pos] & seg->null_bit);
if (found_null != (int) *key++)
return 1;
if (found_null)
{
/* Add key pack length (2) to key for VARCHAR segments */
if (seg->type == HA_KEYTYPE_VARTEXT1)
key+= 2;
continue;
}
}
if (seg->type == HA_KEYTYPE_TEXT)
{
CHARSET_INFO *cs= seg->charset;
uint char_length_key;
uint char_length_rec;
uchar *pos= (uchar*) rec + seg->start;
if (cs->mbmaxlen > 1)
{
uint char_length= seg->length / cs->mbmaxlen;
char_length_key= my_charpos(cs, key, key + seg->length, char_length);
set_if_smaller(char_length_key, seg->length);
char_length_rec= my_charpos(cs, pos, pos + seg->length, char_length);
set_if_smaller(char_length_rec, seg->length);
}
else
{
char_length_key= seg->length;
char_length_rec= seg->length;
}
if (seg->charset->coll->strnncollsp(seg->charset,
(uchar*) pos, char_length_rec,
(uchar*) key, char_length_key, 0))
return 1;
}
else if (seg->type == HA_KEYTYPE_VARTEXT1) /* Any VARCHAR segments */
{
uchar *pos= (uchar*) rec + seg->start;
CHARSET_INFO *cs= seg->charset;
uint pack_length= seg->bit_start;
uint char_length_rec= (pack_length == 1 ? (uint) *(uchar*) pos :
uint2korr(pos));
/* Key segments are always packed with 2 bytes */
uint char_length_key= uint2korr(key);
pos+= pack_length;
key+= 2; /* skip key pack length */
if (cs->mbmaxlen > 1)
{
uint char_length1, char_length2;
char_length1= char_length2= seg->length / cs->mbmaxlen;
char_length1= my_charpos(cs, key, key + char_length_key, char_length1);
set_if_smaller(char_length_key, char_length1);
char_length2= my_charpos(cs, pos, pos + char_length_rec, char_length2);
set_if_smaller(char_length_rec, char_length2);
}
else
set_if_smaller(char_length_rec, seg->length);
if (cs->coll->strnncollsp(seg->charset,
(uchar*) pos, char_length_rec,
(uchar*) key, char_length_key, 0))
return 1;
}
else
{
uint dec= 0;
if (seg->type == HA_KEYTYPE_BIT && seg->bit_length)
{
uchar bits= get_rec_bits(rec + seg->bit_pos,
seg->bit_start, seg->bit_length);
if (bits != (*key))
return 1;
dec= 1;
key++;
}
if (bcmp(rec + seg->start, key, seg->length - dec))
return 1;
}
}
return 0;
}
static my_bool maria_page_crc_check(uchar *page,
pgcache_page_no_t page_no,
MARIA_SHARE *share,
uint32 no_crc_val,
int data_length)
{
uint32 crc= uint4korr(page + share->block_size - CRC_SIZE), new_crc;
my_bool res;
DBUG_ENTER("maria_page_crc_check");
DBUG_ASSERT((uint)data_length <= share->block_size - CRC_SIZE);
/* we need this assert to get following comparison working */
compile_time_assert(MARIA_NO_CRC_BITMAP_PAGE ==
MARIA_NO_CRC_NORMAL_PAGE - 1 &&
MARIA_NO_CRC_NORMAL_PAGE == 0xffffffff);
/*
If crc is no_crc_val then
the page has no crc, so there is nothing to check.
*/
if (crc >= MARIA_NO_CRC_BITMAP_PAGE)
{
DBUG_PRINT("info", ("No crc: %lu crc: %lu page: %lu ",
(ulong) no_crc_val, (ulong) crc, (ulong) page_no));
if (crc != no_crc_val)
{
my_errno= HA_ERR_WRONG_CRC;
DBUG_PRINT("error", ("Wrong no CRC value"));
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
new_crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ASSERT(new_crc != no_crc_val);
res= MY_TEST(new_crc != crc);
if (res)
{
/*
Bitmap pages may be totally zero filled in some cases.
This happens when we get a crash after the pagecache has written
out a page that is on a newly created bitmap page and we get
a crash before the bitmap page is written out.
We handle this case with the following logic:
When reading, approve of bitmap pages where all bytes are zero
(This is after all a bitmap pages where no data is reserved and
the CRC will be corrected at next write)
*/
if (no_crc_val == MARIA_NO_CRC_BITMAP_PAGE &&
crc == 0 && _ma_check_if_zero(page, data_length))
{
DBUG_PRINT("warning", ("Found bitmap page that was not initialized"));
DBUG_RETURN(0);
}
DBUG_PRINT("error", ("Page: %lu crc: %lu calculated crc: %lu",
(ulong) page_no, (ulong) crc, (ulong) new_crc));
my_errno= HA_ERR_WRONG_CRC;
}
DBUG_RETURN(res);
}
int maria_extra(MARIA_HA *info, enum ha_extra_function function,
void *extra_arg)
{
int error= 0;
ulong cache_size;
MARIA_SHARE *share= info->s;
my_bool block_records= share->data_file_type == BLOCK_RECORD;
DBUG_ENTER("maria_extra");
DBUG_PRINT("enter",("function: %d",(int) function));
switch (function) {
case HA_EXTRA_RESET_STATE: /* Reset state (don't free buffers) */
info->lastinx= ~0; /* Detect index changes */
info->last_search_keypage= info->cur_row.lastpos= HA_OFFSET_ERROR;
info->page_changed= 1;
/* Next/prev gives first/last */
if (info->opt_flag & READ_CACHE_USED)
{
reinit_io_cache(&info->rec_cache,READ_CACHE,0,
(pbool) (info->lock_type != F_UNLCK),
(pbool) MY_TEST(info->update & HA_STATE_ROW_CHANGED)
);
}
info->update= ((info->update & HA_STATE_CHANGED) | HA_STATE_NEXT_FOUND |
HA_STATE_PREV_FOUND);
break;
case HA_EXTRA_CACHE:
if (block_records)
break; /* Not supported */
if (info->lock_type == F_UNLCK &&
(share->options & HA_OPTION_PACK_RECORD))
{
error= 1; /* Not possibly if not locked */
my_errno= EACCES;
break;
}
if (info->s->file_map) /* Don't use cache if mmap */
break;
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
if ((share->options & HA_OPTION_COMPRESS_RECORD))
{
mysql_mutex_lock(&share->intern_lock);
if (_ma_memmap_file(info))
{
/* We don't nead MADV_SEQUENTIAL if small file */
madvise((char*) share->file_map, share->state.state.data_file_length,
share->state.state.data_file_length <= RECORD_CACHE_SIZE*16 ?
MADV_RANDOM : MADV_SEQUENTIAL);
mysql_mutex_unlock(&share->intern_lock);
break;
}
mysql_mutex_unlock(&share->intern_lock);
}
#endif
if (info->opt_flag & WRITE_CACHE_USED)
{
info->opt_flag&= ~WRITE_CACHE_USED;
if ((error= end_io_cache(&info->rec_cache)))
break;
}
if (!(info->opt_flag &
(READ_CACHE_USED | WRITE_CACHE_USED | MEMMAP_USED)))
{
cache_size= (extra_arg ? *(ulong*) extra_arg :
my_default_record_cache_size);
if (!(init_io_cache(&info->rec_cache, info->dfile.file,
(uint) MY_MIN(share->state.state.data_file_length+1,
cache_size),
READ_CACHE,0L,(pbool) (info->lock_type != F_UNLCK),
MYF(share->write_flag & MY_WAIT_IF_FULL))))
{
info->opt_flag|= READ_CACHE_USED;
info->update&= ~HA_STATE_ROW_CHANGED;
}
if (share->non_transactional_concurrent_insert)
info->rec_cache.end_of_file= info->state->data_file_length;
}
break;
case HA_EXTRA_REINIT_CACHE:
if (info->opt_flag & READ_CACHE_USED)
{
reinit_io_cache(&info->rec_cache, READ_CACHE, info->cur_row.nextpos,
(pbool) (info->lock_type != F_UNLCK),
(pbool) MY_TEST(info->update & HA_STATE_ROW_CHANGED));
info->update&= ~HA_STATE_ROW_CHANGED;
if (share->non_transactional_concurrent_insert)
info->rec_cache.end_of_file= info->state->data_file_length;
}
break;
case HA_EXTRA_WRITE_CACHE:
if (info->lock_type == F_UNLCK)
{
error= 1; /* Not possibly if not locked */
break;
}
if (block_records)
break; /* Not supported */
cache_size= (extra_arg ? *(ulong*) extra_arg :
my_default_record_cache_size);
if (!(info->opt_flag &
(READ_CACHE_USED | WRITE_CACHE_USED | OPT_NO_ROWS)) &&
!share->state.header.uniques)
if (!(init_io_cache(&info->rec_cache, info->dfile.file, cache_size,
WRITE_CACHE, info->state->data_file_length,
(pbool) (info->lock_type != F_UNLCK),
MYF(share->write_flag & MY_WAIT_IF_FULL))))
{
info->opt_flag|= WRITE_CACHE_USED;
info->update&= ~(HA_STATE_ROW_CHANGED |
HA_STATE_WRITE_AT_END |
HA_STATE_EXTEND_BLOCK);
}
break;
case HA_EXTRA_PREPARE_FOR_UPDATE:
if (info->s->data_file_type != DYNAMIC_RECORD)
break;
/* Remove read/write cache if dynamic rows */
case HA_EXTRA_NO_CACHE:
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
{
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
error= end_io_cache(&info->rec_cache);
/* Sergei will insert full text index caching here */
}
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
if (info->opt_flag & MEMMAP_USED)
madvise((char*) share->file_map, share->state.state.data_file_length,
MADV_RANDOM);
#endif
break;
case HA_EXTRA_FLUSH_CACHE:
if (info->opt_flag & WRITE_CACHE_USED)
{
if ((error= flush_io_cache(&info->rec_cache)))
{
/* Fatal error found */
_ma_set_fatal_error(share, HA_ERR_CRASHED);
}
}
break;
case HA_EXTRA_NO_READCHECK:
info->opt_flag&= ~READ_CHECK_USED; /* No readcheck */
break;
case HA_EXTRA_READCHECK:
info->opt_flag|= READ_CHECK_USED;
break;
case HA_EXTRA_KEYREAD: /* Read only keys to record */
case HA_EXTRA_REMEMBER_POS:
info->opt_flag|= REMEMBER_OLD_POS;
bmove(info->last_key.data + share->base.max_key_length*2,
info->last_key.data,
info->last_key.data_length + info->last_key.ref_length);
info->save_update= info->update;
info->save_lastinx= info->lastinx;
info->save_lastpos= info->cur_row.lastpos;
info->save_lastkey_data_length= info->last_key.data_length;
info->save_lastkey_ref_length= info->last_key.ref_length;
if (function == HA_EXTRA_REMEMBER_POS)
break;
/* fall through */
case HA_EXTRA_KEYREAD_CHANGE_POS:
info->opt_flag|= KEY_READ_USED;
info->read_record= _ma_read_key_record;
break;
case HA_EXTRA_NO_KEYREAD:
case HA_EXTRA_RESTORE_POS:
if (info->opt_flag & REMEMBER_OLD_POS)
{
bmove(info->last_key.data,
info->last_key.data + share->base.max_key_length*2,
info->save_lastkey_data_length + info->save_lastkey_ref_length);
info->update= info->save_update | HA_STATE_WRITTEN;
info->lastinx= info->save_lastinx;
info->cur_row.lastpos= info->save_lastpos;
info->last_key.data_length= info->save_lastkey_data_length;
info->last_key.ref_length= info->save_lastkey_ref_length;
info->last_key.flag= 0;
}
info->read_record= share->read_record;
info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
break;
case HA_EXTRA_NO_USER_CHANGE: /* Database is somehow locked agains changes */
info->lock_type= F_EXTRA_LCK; /* Simulate as locked */
break;
case HA_EXTRA_WAIT_LOCK:
info->lock_wait= 0;
break;
case HA_EXTRA_NO_WAIT_LOCK:
info->lock_wait= MY_SHORT_WAIT;
break;
case HA_EXTRA_NO_KEYS:
/* we're going to modify pieces of the state, stall Checkpoint */
mysql_mutex_lock(&share->intern_lock);
if (info->lock_type == F_UNLCK)
{
mysql_mutex_unlock(&share->intern_lock);
error= 1; /* Not possibly if not lock */
break;
}
if (maria_is_any_key_active(share->state.key_map))
{
MARIA_KEYDEF *key= share->keyinfo;
uint i;
for (i =0 ; i < share->base.keys ; i++,key++)
{
if (!(key->flag & HA_NOSAME) && info->s->base.auto_key != i+1)
{
maria_clear_key_active(share->state.key_map, i);
info->update|= HA_STATE_CHANGED;
}
}
if (!share->changed)
{
share->changed= 1; /* Update on close */
share->state.changed|= STATE_CHANGED | STATE_NOT_ANALYZED;
if (!share->global_changed)
{
share->global_changed= 1;
share->state.open_count++;
}
}
if (!share->now_transactional)
share->state.state= *info->state;
/*
That state write to disk must be done, even for transactional tables;
indeed the table's share is going to be lost (there was a
HA_EXTRA_FORCE_REOPEN before, which set share->last_version to
0), and so the only way it leaves information (share->state.key_map)
for the posterity is by writing it to disk.
*/
DBUG_ASSERT(!maria_in_recovery);
error= _ma_state_info_write(share,
MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
MA_STATE_INFO_WRITE_FULL_INFO);
}
mysql_mutex_unlock(&share->intern_lock);
break;
case HA_EXTRA_FORCE_REOPEN:
/*
MySQL uses this case after it has closed all other instances
of this table.
We however do a flush here for additional safety.
*/
/** @todo consider porting these flush-es to MyISAM */
DBUG_ASSERT(share->reopen == 1);
error= _ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_FORCE_WRITE, FLUSH_FORCE_WRITE);
if (!error && share->changed)
{
mysql_mutex_lock(&share->intern_lock);
error= _ma_state_info_write(share,
MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET|
MA_STATE_INFO_WRITE_FULL_INFO);
mysql_mutex_unlock(&share->intern_lock);
}
mysql_mutex_lock(&THR_LOCK_maria);
mysql_mutex_lock(&share->intern_lock); /* protect against Checkpoint */
/* Safety against assert in checkpoint */
share->bitmap.changed_not_flushed= 0;
/* this makes the share not be re-used next time the table is opened */
share->last_version= 0L; /* Impossible version */
mysql_mutex_unlock(&share->intern_lock);
mysql_mutex_unlock(&THR_LOCK_maria);
break;
case HA_EXTRA_PREPARE_FOR_DROP:
/* Signals about intent to delete this table */
share->deleting= TRUE;
share->global_changed= FALSE; /* force writing changed flag */
/* To force repair if reopened */
share->state.open_count= 1;
share->changed= 1;
_ma_mark_file_changed_now(share);
/* Fall trough */
case HA_EXTRA_PREPARE_FOR_RENAME:
{
my_bool do_flush= MY_TEST(function != HA_EXTRA_PREPARE_FOR_DROP);
my_bool save_global_changed;
enum flush_type type;
/*
This share, to have last_version=0, needs to save all its data/index
blocks to disk if this is not for a DROP TABLE. Otherwise they would be
invisible to future openers; and they could even go to disk late and
cancel the work of future openers.
*/
if (info->lock_type != F_UNLCK && !info->was_locked)
{
info->was_locked= info->lock_type;
if (maria_lock_database(info, F_UNLCK))
error= my_errno;
info->lock_type= F_UNLCK;
}
/*
We don't need to call _mi_decrement_open_count() if we are
dropping the table, as the files will be removed anyway. If we
are aborted before the files is removed, it's better to not
call it as in that case the automatic repair on open will add
the missing index entries
*/
mysql_mutex_lock(&share->intern_lock);
if (share->kfile.file >= 0 && function != HA_EXTRA_PREPARE_FOR_DROP)
_ma_decrement_open_count(info, 0);
if (info->trn)
{
_ma_remove_table_from_trnman(share, info->trn);
/* Ensure we don't point to the deleted data in trn */
info->state= info->state_start= &share->state.state;
}
/* Remove history for table */
_ma_reset_state(info);
type= do_flush ? FLUSH_RELEASE : FLUSH_IGNORE_CHANGED;
save_global_changed= share->global_changed;
share->global_changed= 1; /* Don't increment open count */
mysql_mutex_unlock(&share->intern_lock);
if (_ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
type, type))
{
error=my_errno;
share->changed= 1;
}
mysql_mutex_lock(&share->intern_lock);
share->global_changed= save_global_changed;
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
{
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
if (end_io_cache(&info->rec_cache))
error= 1;
}
if (share->kfile.file >= 0)
{
if (do_flush)
{
/* Save the state so that others can find it from disk. */
if ((share->changed &&
_ma_state_info_write(share,
MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
MA_STATE_INFO_WRITE_FULL_INFO)) ||
mysql_file_sync(share->kfile.file, MYF(0)))
error= my_errno;
}
else
{
/* be sure that state is not tried for write as file may be closed */
share->changed= 0;
share->global_changed= 0;
share->state.open_count= 0;
}
}
if (share->data_file_type == BLOCK_RECORD &&
share->bitmap.file.file >= 0)
{
DBUG_ASSERT(share->bitmap.non_flushable == 0 &&
share->bitmap.changed == 0);
if (do_flush && my_sync(share->bitmap.file.file, MYF(0)))
error= my_errno;
share->bitmap.changed_not_flushed= 0;
}
/* last_version must be protected by intern_lock; See collect_tables() */
share->last_version= 0L; /* Impossible version */
mysql_mutex_unlock(&share->intern_lock);
break;
}
case HA_EXTRA_PREPARE_FOR_FORCED_CLOSE:
if (info->trn)
{
mysql_mutex_lock(&share->intern_lock);
_ma_remove_table_from_trnman(share, info->trn);
/* Ensure we don't point to the deleted data in trn */
info->state= info->state_start= &share->state.state;
mysql_mutex_unlock(&share->intern_lock);
}
break;
case HA_EXTRA_FLUSH:
if (!share->temporary)
error= _ma_flush_table_files(info, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_KEEP, FLUSH_KEEP);
_ma_decrement_open_count(info, 1);
if (share->not_flushed)
{
share->not_flushed= 0;
if (_ma_sync_table_files(info))
error= my_errno;
if (error)
{
/* Fatal error found */
share->changed= 1;
_ma_set_fatal_error(share, HA_ERR_CRASHED);
}
}
break;
case HA_EXTRA_NORMAL: /* Theese isn't in use */
info->quick_mode= 0;
break;
case HA_EXTRA_QUICK:
info->quick_mode= 1;
break;
case HA_EXTRA_NO_ROWS:
if (!share->state.header.uniques)
info->opt_flag|= OPT_NO_ROWS;
break;
case HA_EXTRA_PRELOAD_BUFFER_SIZE:
info->preload_buff_size= *((ulong *) extra_arg);
break;
case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
case HA_EXTRA_CHANGE_KEY_TO_DUP:
maria_extra_keyflag(info, function);
break;
case HA_EXTRA_MMAP:
#ifdef HAVE_MMAP
if (block_records)
break; /* Not supported */
mysql_mutex_lock(&share->intern_lock);
/*
Memory map the data file if it is not already mapped. It is safe
to memory map a file while other threads are using file I/O on it.
Assigning a new address to a function pointer is an atomic
operation. intern_lock prevents that two or more mappings are done
at the same time.
*/
if (!share->file_map)
{
if (_ma_dynmap_file(info, share->state.state.data_file_length))
{
DBUG_PRINT("warning",("mmap failed: errno: %d",errno));
error= my_errno= errno;
}
else
{
share->file_read= _ma_mmap_pread;
share->file_write= _ma_mmap_pwrite;
}
}
mysql_mutex_unlock(&share->intern_lock);
#endif
break;
case HA_EXTRA_MARK_AS_LOG_TABLE:
mysql_mutex_lock(&share->intern_lock);
share->is_log_table= TRUE;
mysql_mutex_unlock(&share->intern_lock);
break;
case HA_EXTRA_KEY_CACHE:
case HA_EXTRA_NO_KEY_CACHE:
default:
break;
}
DBUG_RETURN(error);
} /* maria_extra */
int my_copy(const char *from, const char *to, myf MyFlags)
{
size_t Count;
my_bool new_file_stat= 0; /* 1 if we could stat "to" */
int create_flag;
File from_file,to_file;
uchar buff[IO_SIZE];
MY_STAT stat_buff,new_stat_buff;
my_bool file_created= 0;
DBUG_ENTER("my_copy");
DBUG_PRINT("my",("from %s to %s MyFlags %lu", from, to, MyFlags));
from_file=to_file= -1;
DBUG_ASSERT(!(MyFlags & (MY_FNABP | MY_NABP))); /* for my_read/my_write */
if (MyFlags & MY_HOLD_ORIGINAL_MODES) /* Copy stat if possible */
new_file_stat= MY_TEST(my_stat((char*) to, &new_stat_buff, MYF(0)));
if ((from_file=my_open(from,O_RDONLY | O_SHARE,MyFlags)) >= 0)
{
if (!my_stat(from, &stat_buff, MyFlags))
{
my_errno=errno;
goto err;
}
if (MyFlags & MY_HOLD_ORIGINAL_MODES && new_file_stat)
stat_buff=new_stat_buff;
create_flag= (MyFlags & MY_DONT_OVERWRITE_FILE) ? O_EXCL : O_TRUNC;
if ((to_file= my_create(to,(int) stat_buff.st_mode,
O_WRONLY | create_flag | O_BINARY | O_SHARE,
MyFlags)) < 0)
goto err;
file_created= 1;
while ((Count=my_read(from_file, buff, sizeof(buff), MyFlags)) != 0)
{
if (Count == (uint) -1 ||
my_write(to_file,buff,Count,MYF(MyFlags | MY_NABP)))
goto err;
}
/* sync the destination file */
if (MyFlags & MY_SYNC)
{
if (my_sync(to_file, MyFlags))
goto err;
}
if (my_close(from_file,MyFlags) | my_close(to_file,MyFlags))
DBUG_RETURN(-1); /* Error on close */
from_file=to_file= -1; /* Files are closed */
/* Copy modes if possible */
if (MyFlags & MY_HOLD_ORIGINAL_MODES && !new_file_stat)
DBUG_RETURN(0); /* File copyed but not stat */
/* Copy modes */
if (chmod(to, stat_buff.st_mode & 07777))
{
my_errno= errno;
if (MyFlags & MY_WME)
my_error(EE_CHANGE_PERMISSIONS, MYF(ME_BELL+ME_WAITTANG), to, errno);
if (MyFlags & MY_FAE)
goto err;
}
#if !defined(__WIN__)
/* Copy ownership */
if (chown(to, stat_buff.st_uid, stat_buff.st_gid))
{
my_errno= errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_COPY_OWNERSHIP, MYF(ME_BELL+ME_WAITTANG), to, errno);
if (MyFlags & MY_FAE)
goto err;
}
#endif
if (MyFlags & MY_COPYTIME)
{
struct utimbuf timep;
timep.actime = stat_buff.st_atime;
timep.modtime = stat_buff.st_mtime;
(void) utime((char*) to, &timep); /* last accessed and modified times */
}
DBUG_RETURN(0);
}
err:
if (from_file >= 0) (void) my_close(from_file,MyFlags);
if (to_file >= 0) (void) my_close(to_file, MyFlags);
/* attempt to delete the to-file we've partially written */
if (file_created)
(void) my_delete(to, MyFlags);
DBUG_RETURN(-1);
} /* my_copy */
