void safe_hash_change(SAFE_HASH *hash, uchar *old_data, uchar *new_data)
{
SAFE_HASH_ENTRY *entry, *next;
DBUG_ENTER("safe_hash_change");
mysql_rwlock_wrlock(&hash->mutex);
for (entry= hash->root ; entry ; entry= next)
{
next= entry->next;
if (entry->data == old_data)
{
if (new_data == hash->default_value)
{
if ((*entry->prev= entry->next))
entry->next->prev= entry->prev;
my_hash_delete(&hash->hash, (uchar*) entry);
}
else
entry->data= new_data;
}
}
mysql_rwlock_unlock(&hash->mutex);
DBUG_VOID_RETURN;
}
uchar *safe_hash_search(SAFE_HASH *hash, const uchar *key, uint length,
uchar *def)
{
uchar *result;
DBUG_ENTER("safe_hash_search");
mysql_rwlock_rdlock(&hash->mutex);
result= my_hash_search(&hash->hash, key, length);
mysql_rwlock_unlock(&hash->mutex);
if (!result)
result= def;
else
result= ((SAFE_HASH_ENTRY*) result)->data;
DBUG_PRINT("exit",("data: 0x%lx", (long) result));
DBUG_RETURN(result);
}
int mi_rsame(MI_INFO *info, uchar *record, int inx)
{
DBUG_ENTER("mi_rsame");
if (inx != -1 && ! mi_is_key_active(info->s->state.key_map, inx))
{
set_my_errno(HA_ERR_WRONG_INDEX);
DBUG_RETURN(HA_ERR_WRONG_INDEX);
}
if (info->lastpos == HA_OFFSET_ERROR || info->update & HA_STATE_DELETED)
{
set_my_errno(HA_ERR_KEY_NOT_FOUND);
DBUG_RETURN(HA_ERR_KEY_NOT_FOUND); /* No current record */
}
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
/* Read row from data file */
if (fast_mi_readinfo(info))
DBUG_RETURN(my_errno());
if (inx >= 0)
{
info->lastinx=inx;
info->lastkey_length=_mi_make_key(info,(uint) inx,info->lastkey,record,
info->lastpos);
if (info->s->concurrent_insert)
mysql_rwlock_rdlock(&info->s->key_root_lock[inx]);
(void) _mi_search(info,info->s->keyinfo+inx,info->lastkey, USE_WHOLE_KEY,
SEARCH_SAME,
info->s->state.key_root[inx]);
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->key_root_lock[inx]);
}
if (!(*info->read_record)(info,info->lastpos,record))
DBUG_RETURN(0);
if (my_errno() == HA_ERR_RECORD_DELETED)
set_my_errno(HA_ERR_KEY_NOT_FOUND);
DBUG_RETURN(my_errno());
} /* mi_rsame */
int mi_rnext(MI_INFO *info, uchar *buf, int inx)
{
int error,changed;
uint flag;
uint update_mask= HA_STATE_NEXT_FOUND;
DBUG_ENTER("mi_rnext");
if ((inx = _mi_check_index(info,inx)) < 0)
DBUG_RETURN(my_errno);
flag=SEARCH_BIGGER; /* Read next */
if (info->lastpos == HA_OFFSET_ERROR && info->update & HA_STATE_PREV_FOUND)
flag=0; /* Read first */
if (fast_mi_readinfo(info))
DBUG_RETURN(my_errno);
if (info->s->concurrent_insert)
mysql_rwlock_rdlock(&info->s->key_root_lock[inx]);
changed=_mi_test_if_changed(info);
if (!flag)
{
switch(info->s->keyinfo[inx].key_alg){
#ifdef HAVE_RTREE_KEYS
case HA_KEY_ALG_RTREE:
error=rtree_get_first(info,inx,info->lastkey_length);
break;
#endif
case HA_KEY_ALG_BTREE:
default:
error=_mi_search_first(info,info->s->keyinfo+inx,
info->s->state.key_root[inx]);
break;
}
/*
"search first" failed. This means we have no pivot for
"search next", or in other words MI_INFO::lastkey is
likely uninitialized.
Normally SQL layer would never request "search next" if
"search first" failed. But HANDLER may do anything.
As mi_rnext() without preceeding mi_rkey()/mi_rfirst()
equals to mi_rfirst(), we must restore original state
as if failing mi_rfirst() was not called.
*/
if (error)
update_mask|= HA_STATE_PREV_FOUND;
}
else
{
switch (info->s->keyinfo[inx].key_alg) {
#ifdef HAVE_RTREE_KEYS
case HA_KEY_ALG_RTREE:
/*
Note that rtree doesn't support that the table
may be changed since last call, so we do need
to skip rows inserted by other threads like in btree
*/
error= rtree_get_next(info,inx,info->lastkey_length);
break;
#endif
case HA_KEY_ALG_BTREE:
default:
if (!changed)
error= _mi_search_next(info,info->s->keyinfo+inx,info->lastkey,
info->lastkey_length,flag,
info->s->state.key_root[inx]);
else
error= _mi_search(info,info->s->keyinfo+inx,info->lastkey,
USE_WHOLE_KEY,flag, info->s->state.key_root[inx]);
}
}
if (info->s->concurrent_insert)
{
if (!error)
{
while (info->lastpos >= info->state->data_file_length)
{
/* Skip rows inserted by other threads since we got a lock */
if ((error=_mi_search_next(info,info->s->keyinfo+inx,
info->lastkey,
info->lastkey_length,
SEARCH_BIGGER,
info->s->state.key_root[inx])))
break;
}
}
mysql_rwlock_unlock(&info->s->key_root_lock[inx]);
}
/* Don't clear if database-changed */
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
info->update|= update_mask;
if (error)
{
if (my_errno == HA_ERR_KEY_NOT_FOUND)
my_errno=HA_ERR_END_OF_FILE;
}
else if (!buf)
{
DBUG_RETURN(info->lastpos==HA_OFFSET_ERROR ? my_errno : 0);
}
else if (!(*info->read_record)(info,info->lastpos,buf))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
DBUG_RETURN(0);
}
DBUG_PRINT("error",("Got error: %d, errno: %d",error, my_errno));
DBUG_RETURN(my_errno);
} /* mi_rnext */
int mi_rnext_same(MI_INFO *info, uchar *buf)
{
int error;
uint inx,not_used[2];
MI_KEYDEF *keyinfo;
DBUG_ENTER("mi_rnext_same");
if ((int) (inx=info->lastinx) < 0 || info->lastpos == HA_OFFSET_ERROR)
{
set_my_errno(HA_ERR_WRONG_INDEX);
DBUG_RETURN(HA_ERR_WRONG_INDEX);
}
keyinfo=info->s->keyinfo+inx;
if (fast_mi_readinfo(info))
DBUG_RETURN(my_errno());
if (info->s->concurrent_insert)
mysql_rwlock_rdlock(&info->s->key_root_lock[inx]);
switch (keyinfo->key_alg)
{
case HA_KEY_ALG_RTREE:
if ((error=rtree_find_next(info,inx,
myisam_read_vec[info->last_key_func])))
{
error=1;
set_my_errno(HA_ERR_END_OF_FILE);
info->lastpos= HA_OFFSET_ERROR;
break;
}
break;
case HA_KEY_ALG_BTREE:
default:
if (info->set_rnext_same_key)
{
/* First rnext_same and lastkey is filled in mi_rkey */
memcpy(info->rnext_same_key, info->lastkey, info->last_rkey_length);
info->set_rnext_same_key= FALSE;
}
for (;;)
{
if ((error=_mi_search_next(info,keyinfo,info->lastkey,
info->lastkey_length,SEARCH_BIGGER,
info->s->state.key_root[inx])))
break;
if (ha_key_cmp(keyinfo->seg, info->lastkey, info->rnext_same_key,
info->last_rkey_length, SEARCH_FIND, not_used))
{
error=1;
set_my_errno(HA_ERR_END_OF_FILE);
info->lastpos= HA_OFFSET_ERROR;
break;
}
/* Skip rows that are inserted by other threads since we got a lock */
if (info->lastpos < info->state->data_file_length &&
(!info->index_cond_func || mi_check_index_cond(info, inx, buf)))
break;
}
}
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->key_root_lock[inx]);
/* Don't clear if database-changed */
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
info->update|= HA_STATE_NEXT_FOUND;
if (error)
{
if (my_errno() == HA_ERR_KEY_NOT_FOUND)
set_my_errno(HA_ERR_END_OF_FILE);
}
else if (!buf)
{
DBUG_RETURN(info->lastpos==HA_OFFSET_ERROR ? my_errno() : 0);
}
else if (!(*info->read_record)(info,info->lastpos,buf))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
DBUG_RETURN(0);
}
DBUG_RETURN(my_errno());
} /* mi_rnext_same */
int mi_rprev(MI_INFO *info, uchar *buf, int inx)
{
int error,changed;
register uint flag;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("mi_rprev");
if ((inx = _mi_check_index(info,inx)) < 0)
DBUG_RETURN(my_errno);
flag=SEARCH_SMALLER; /* Read previous */
if (info->lastpos == HA_OFFSET_ERROR && info->update & HA_STATE_NEXT_FOUND)
flag=0; /* Read last */
if (fast_mi_readinfo(info))
DBUG_RETURN(my_errno);
changed=_mi_test_if_changed(info);
if (share->concurrent_insert)
mysql_rwlock_rdlock(&share->key_root_lock[inx]);
if (!flag)
error=_mi_search_last(info, share->keyinfo+inx,
share->state.key_root[inx]);
else if (!changed)
error=_mi_search_next(info,share->keyinfo+inx,info->lastkey,
info->lastkey_length,flag,
share->state.key_root[inx]);
else
error=_mi_search(info,share->keyinfo+inx,info->lastkey,
USE_WHOLE_KEY, flag, share->state.key_root[inx]);
if (share->concurrent_insert)
{
if (!error)
{
while (info->lastpos >= info->state->data_file_length)
{
/* Skip rows that are inserted by other threads since we got a lock */
if ((error=_mi_search_next(info,share->keyinfo+inx,info->lastkey,
info->lastkey_length,
SEARCH_SMALLER,
share->state.key_root[inx])))
break;
}
}
mysql_rwlock_unlock(&share->key_root_lock[inx]);
}
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
info->update|= HA_STATE_PREV_FOUND;
if (error)
{
if (my_errno == HA_ERR_KEY_NOT_FOUND)
my_errno=HA_ERR_END_OF_FILE;
}
else if (!buf)
{
DBUG_RETURN(info->lastpos==HA_OFFSET_ERROR ? my_errno : 0);
}
else if (!(*info->read_record)(info,info->lastpos,buf))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
DBUG_RETURN(0);
}
DBUG_RETURN(my_errno);
} /* mi_rprev */
int maria_rprev(MARIA_HA *info, uchar *buf, int inx)
{
int error,changed;
register uint flag;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo;
ICP_RESULT icp_res= ICP_MATCH;
DBUG_ENTER("maria_rprev");
if ((inx = _ma_check_index(info,inx)) < 0)
DBUG_RETURN(my_errno);
flag=SEARCH_SMALLER; /* Read previous */
if (info->cur_row.lastpos == HA_OFFSET_ERROR &&
info->update & HA_STATE_NEXT_FOUND)
flag=0; /* Read last */
if (fast_ma_readinfo(info))
DBUG_RETURN(my_errno);
keyinfo= share->keyinfo + inx;
changed= _ma_test_if_changed(info);
if (share->lock_key_trees)
mysql_rwlock_rdlock(&keyinfo->root_lock);
if (!flag)
error= _ma_search_last(info, keyinfo, share->state.key_root[inx]);
else if (!changed)
error= _ma_search_next(info, &info->last_key,
flag | info->last_key.flag,
share->state.key_root[inx]);
else
error= _ma_search(info, &info->last_key, flag | info->last_key.flag,
share->state.key_root[inx]);
if (!error)
{
my_off_t cur_keypage= info->last_keypage;
while (!(*share->row_is_visible)(info) ||
((icp_res= ma_check_index_cond(info, inx, buf)) == ICP_NO_MATCH))
{
/*
If we are at the last (i.e. first?) key on the key page,
allow writers to access the index.
*/
if (info->last_keypage != cur_keypage)
{
cur_keypage= info->last_keypage;
if (ma_yield_and_check_if_killed(info, inx))
{
error= 1;
break;
}
}
/* Skip rows that are inserted by other threads since we got a lock */
if ((error= _ma_search_next(info, &info->last_key,
SEARCH_SMALLER,
share->state.key_root[inx])))
break;
}
}
if (share->lock_key_trees)
mysql_rwlock_unlock(&keyinfo->root_lock);
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
info->update|= HA_STATE_PREV_FOUND;
if (error || icp_res != ICP_MATCH)
{
fast_ma_writeinfo(info);
if (my_errno == HA_ERR_KEY_NOT_FOUND)
my_errno= HA_ERR_END_OF_FILE;
}
else if (!buf)
{
fast_ma_writeinfo(info);
DBUG_RETURN(info->cur_row.lastpos == HA_OFFSET_ERROR ? my_errno : 0);
}
else if (!(*info->read_record)(info, buf, info->cur_row.lastpos))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
DBUG_RETURN(0);
}
DBUG_RETURN(my_errno);
} /* maria_rprev */
int mi_lock_database(MI_INFO *info, int lock_type)
{
int error;
uint count;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("mi_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'",
lock_type, info->lock_type, share->r_locks,
share->w_locks,
share->global_changed, share->state.open_count,
share->index_file_name));
if (share->options & HA_OPTION_READ_ONLY_DATA ||
info->lock_type == lock_type)
DBUG_RETURN(0);
if (lock_type == F_EXTRA_LCK) /* Used by TMP tables */
{
++share->w_locks;
++share->tot_locks;
info->lock_type= lock_type;
info->s->in_use= list_add(info->s->in_use, &info->in_use);
DBUG_RETURN(0);
}
error= 0;
mysql_mutex_lock(&share->intern_lock);
if (share->kfile >= 0) /* May only be false on windows */
{
switch (lock_type) {
case F_UNLCK:
ftparser_call_deinitializer(info);
if (info->lock_type == F_RDLCK)
count= --share->r_locks;
else
count= --share->w_locks;
--share->tot_locks;
if (info->lock_type == F_WRLCK && !share->w_locks &&
!share->delay_key_write && flush_key_blocks(share->key_cache,
keycache_thread_var(),
share->kfile,FLUSH_KEEP))
{
error=my_errno();
mi_print_error(info->s, HA_ERR_CRASHED);
mi_mark_crashed(info); /* Mark that table must be checked */
}
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
{
if (end_io_cache(&info->rec_cache))
{
error=my_errno();
mi_print_error(info->s, HA_ERR_CRASHED);
mi_mark_crashed(info);
}
}
if (!count)
{
DBUG_PRINT("info",("changed: %u w_locks: %u",
(uint) share->changed, share->w_locks));
if (share->changed && !share->w_locks)
{
if ((info->s->mmaped_length != info->s->state.state.data_file_length) &&
(info->s->nonmmaped_inserts > MAX_NONMAPPED_INSERTS))
{
if (info->s->concurrent_insert)
mysql_rwlock_wrlock(&info->s->mmap_lock);
mi_remap_file(info, info->s->state.state.data_file_length);
info->s->nonmmaped_inserts= 0;
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
}
share->state.process= share->last_process=share->this_process;
share->state.unique= info->last_unique= info->this_unique;
share->state.update_count= info->last_loop= ++info->this_loop;
if (mi_state_info_write(share->kfile, &share->state, 1))
error=my_errno();
share->changed=0;
if (myisam_flush)
{
if (mysql_file_sync(share->kfile, MYF(0)))
error= my_errno();
if (mysql_file_sync(info->dfile, MYF(0)))
error= my_errno();
}
else
share->not_flushed=1;
if (error)
{
mi_print_error(info->s, HA_ERR_CRASHED);
mi_mark_crashed(info);
}
}
if (info->lock_type != F_EXTRA_LCK)
{
if (share->r_locks)
{ /* Only read locks left */
if (my_lock(share->kfile,F_RDLCK,0L,F_TO_EOF,
MYF(MY_WME | MY_SEEK_NOT_DONE)) && !error)
error=my_errno();
}
else if (!share->w_locks)
{ /* No more locks */
if (my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
MYF(MY_WME | MY_SEEK_NOT_DONE)) && !error)
error=my_errno();
}
}
}
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
info->lock_type= F_UNLCK;
info->s->in_use= list_delete(info->s->in_use, &info->in_use);
break;
case F_RDLCK:
if (info->lock_type == F_WRLCK)
{
/*
Change RW to READONLY
mysqld does not turn write locks to read locks,
so we're never here in mysqld.
*/
if (share->w_locks == 1)
{
if (my_lock(share->kfile,lock_type,0L,F_TO_EOF,
MYF(MY_SEEK_NOT_DONE)))
{
error=my_errno();
break;
}
}
share->w_locks--;
share->r_locks++;
info->lock_type=lock_type;
break;
}
if (!share->r_locks && !share->w_locks)
{
if (my_lock(share->kfile,lock_type,0L,F_TO_EOF,
info->lock_wait | MY_SEEK_NOT_DONE))
{
error=my_errno();
break;
}
if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
{
error=my_errno();
(void) my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
set_my_errno(error);
break;
}
}
(void) _mi_test_if_changed(info);
share->r_locks++;
share->tot_locks++;
info->lock_type=lock_type;
info->s->in_use= list_add(info->s->in_use, &info->in_use);
break;
case F_WRLCK:
if (info->lock_type == F_RDLCK)
{ /* Change READONLY to RW */
if (share->r_locks == 1)
{
if (my_lock(share->kfile,lock_type,0L,F_TO_EOF,
MYF(info->lock_wait | MY_SEEK_NOT_DONE)))
{
error=my_errno();
break;
}
share->r_locks--;
share->w_locks++;
info->lock_type=lock_type;
break;
}
}
if (!(share->options & HA_OPTION_READ_ONLY_DATA))
{
if (!share->w_locks)
{
if (my_lock(share->kfile,lock_type,0L,F_TO_EOF,
info->lock_wait | MY_SEEK_NOT_DONE))
{
error=my_errno();
break;
}
if (!share->r_locks)
{
if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
{
error=my_errno();
(void) my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
info->lock_wait | MY_SEEK_NOT_DONE);
set_my_errno(error);
break;
}
}
}
}
(void) _mi_test_if_changed(info);
info->lock_type=lock_type;
info->invalidator=info->s->invalidator;
share->w_locks++;
share->tot_locks++;
info->s->in_use= list_add(info->s->in_use, &info->in_use);
break;
default:
break; /* Impossible */
}
}
#ifdef _WIN32
else
{
/*
Check for bad file descriptors if this table is part
of a merge union. Failing to capture this may cause
a crash on windows if the table is renamed and
later on referenced by the merge table.
*/
if( info->owned_by_merge && (info->s)->kfile < 0 )
{
error = HA_ERR_NO_SUCH_TABLE;
}
}
#endif
mysql_mutex_unlock(&share->intern_lock);
DBUG_RETURN(error);
} /* mi_lock_database */
int maria_rnext(MARIA_HA *info, uchar *buf, int inx)
{
int error,changed;
uint flag;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo;
ICP_RESULT icp_res= ICP_MATCH;
uint update_mask= HA_STATE_NEXT_FOUND;
DBUG_ENTER("maria_rnext");
if ((inx = _ma_check_index(info,inx)) < 0)
DBUG_RETURN(my_errno);
flag=SEARCH_BIGGER; /* Read next */
if (info->cur_row.lastpos == HA_OFFSET_ERROR &&
info->update & HA_STATE_PREV_FOUND)
flag=0; /* Read first */
if (fast_ma_readinfo(info))
DBUG_RETURN(my_errno);
keyinfo= share->keyinfo + inx;
if (share->lock_key_trees)
mysql_rwlock_rdlock(&keyinfo->root_lock);
changed= _ma_test_if_changed(info);
if (!flag)
{
switch (keyinfo->key_alg){
#ifdef HAVE_RTREE_KEYS
case HA_KEY_ALG_RTREE:
error=maria_rtree_get_first(info, inx,
info->last_key.data_length +
info->last_key.ref_length);
break;
#endif
case HA_KEY_ALG_BTREE:
default:
error= _ma_search_first(info, keyinfo, share->state.key_root[inx]);
break;
}
/*
"search first" failed. This means we have no pivot for
"search next", or in other words MI_INFO::lastkey is
likely uninitialized.
Normally SQL layer would never request "search next" if
"search first" failed. But HANDLER may do anything.
As mi_rnext() without preceding mi_rkey()/mi_rfirst()
equals to mi_rfirst(), we must restore original state
as if failing mi_rfirst() was not called.
*/
if (error)
update_mask|= HA_STATE_PREV_FOUND;
}
else
{
switch (keyinfo->key_alg) {
#ifdef HAVE_RTREE_KEYS
case HA_KEY_ALG_RTREE:
/*
Note that rtree doesn't support that the table
may be changed since last call, so we do need
to skip rows inserted by other threads like in btree
*/
error= maria_rtree_get_next(info, inx, info->last_key.data_length +
info->last_key.ref_length);
break;
#endif
case HA_KEY_ALG_BTREE:
default:
if (!changed)
error= _ma_search_next(info, &info->last_key,
flag | info->last_key.flag,
share->state.key_root[inx]);
else
error= _ma_search(info, &info->last_key, flag | info->last_key.flag,
share->state.key_root[inx]);
}
}
if (!error)
{
while (!(*share->row_is_visible)(info) ||
((icp_res= ma_check_index_cond(info, inx, buf)) == ICP_NO_MATCH))
{
/*
If we are at the last key on the key page, allow writers to
access the index.
*/
if (info->int_keypos >= info->int_maxpos &&
ma_yield_and_check_if_killed(info, inx))
{
/* my_errno is set by ma_yield_and_check_if_killed() */
error= 1;
break;
}
/* Skip rows inserted by other threads since we got a lock */
if ((error= _ma_search_next(info, &info->last_key,
SEARCH_BIGGER,
share->state.key_root[inx])))
break;
}
}
if (share->lock_key_trees)
mysql_rwlock_unlock(&keyinfo->root_lock);
/* Don't clear if database-changed */
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
info->update|= update_mask;
if (error || icp_res != ICP_MATCH)
{
fast_ma_writeinfo(info);
if (my_errno == HA_ERR_KEY_NOT_FOUND)
my_errno= HA_ERR_END_OF_FILE;
}
else if (!buf)
{
fast_ma_writeinfo(info);
DBUG_RETURN(info->cur_row.lastpos == HA_OFFSET_ERROR ? my_errno : 0);
}
else if (!(*info->read_record)(info, buf, info->cur_row.lastpos))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
DBUG_RETURN(0);
}
DBUG_PRINT("error",("Got error: %d, errno: %d",error, my_errno));
DBUG_RETURN(my_errno);
} /* maria_rnext */
my_bool safe_hash_set(SAFE_HASH *hash, const uchar *key, uint length,
uchar *data)
{
SAFE_HASH_ENTRY *entry;
my_bool error= 0;
DBUG_ENTER("safe_hash_set");
DBUG_PRINT("enter",("key: %.*s data: 0x%lx", length, key, (long) data));
mysql_rwlock_wrlock(&hash->mutex);
entry= (SAFE_HASH_ENTRY*) my_hash_search(&hash->hash, key, length);
if (data == hash->default_value)
{
/*
The key is to be associated with the default entry. In this case
we can just delete the entry (if it existed) from the hash as a
search will return the default entry
*/
if (!entry) /* nothing to do */
goto end;
/* unlink entry from list */
if ((*entry->prev= entry->next))
entry->next->prev= entry->prev;
my_hash_delete(&hash->hash, (uchar*) entry);
goto end;
}
if (entry)
{
/* Entry existed; Just change the pointer to point at the new data */
entry->data= data;
}
else
{
if (!(entry= (SAFE_HASH_ENTRY *) my_malloc(sizeof(*entry) + length,
MYF(MY_WME))))
{
error= 1;
goto end;
}
entry->key= (uchar*) (entry +1);
memcpy((char*) entry->key, (char*) key, length);
entry->length= length;
entry->data= data;
/* Link entry to list */
if ((entry->next= hash->root))
entry->next->prev= &entry->next;
entry->prev= &hash->root;
hash->root= entry;
if (my_hash_insert(&hash->hash, (uchar*) entry))
{
/* This can only happen if hash got out of memory */
my_free(entry);
error= 1;
goto end;
}
}
end:
mysql_rwlock_unlock(&hash->mutex);
DBUG_RETURN(error);
}