st_mrn_slot_data *mrn_get_slot_data(THD *thd, bool can_create)
{
MRN_DBUG_ENTER_FUNCTION();
st_mrn_slot_data *slot_data =
(st_mrn_slot_data*) *thd_ha_data(thd, mrn_hton_ptr);
if (slot_data == NULL) {
slot_data = (st_mrn_slot_data*) malloc(sizeof(st_mrn_slot_data));
slot_data->last_insert_record_id = GRN_ID_NIL;
slot_data->first_wrap_hton = NULL;
slot_data->alter_create_info = NULL;
slot_data->disable_keys_create_info = NULL;
slot_data->alter_connect_string = NULL;
slot_data->alter_comment = NULL;
*thd_ha_data(thd, mrn_hton_ptr) = (void *) slot_data;
{
mrn::Lock lock(&mrn_allocated_thds_mutex);
if (my_hash_insert(&mrn_allocated_thds, (uchar*) thd))
{
free(slot_data);
DBUG_RETURN(NULL);
}
}
}
DBUG_RETURN(slot_data);
}
int update_server_record_in_cache(FOREIGN_SERVER *existing,
FOREIGN_SERVER *altered)
{
int error= 0;
DBUG_ENTER("update_server_record_in_cache");
/*
update the members that haven't been change in the altered server struct
with the values of the existing server struct
*/
merge_server_struct(existing, altered);
/*
delete the existing server struct from the server cache
*/
VOID(hash_delete(&servers_cache, (uchar*)existing));
/*
Insert the altered server struct into the server cache
*/
if (my_hash_insert(&servers_cache, (uchar*)altered))
{
DBUG_PRINT("info", ("had a problem inserting server %s at %lx",
altered->server_name, (long unsigned int) altered));
error= ER_OUT_OF_RESOURCES;
}
DBUG_RETURN(error);
}
static bool
get_server_from_table_to_cache(TABLE *table)
{
/* alloc a server struct */
char *ptr;
char * const blank= (char*)"";
FOREIGN_SERVER *server= (FOREIGN_SERVER *)alloc_root(&mem,
sizeof(FOREIGN_SERVER));
DBUG_ENTER("get_server_from_table_to_cache");
table->use_all_columns();
/* get each field into the server struct ptr */
server->server_name= get_field(&mem, table->field[0]);
server->server_name_length= (uint) strlen(server->server_name);
ptr= get_field(&mem, table->field[1]);
server->host= ptr ? ptr : blank;
ptr= get_field(&mem, table->field[2]);
server->db= ptr ? ptr : blank;
ptr= get_field(&mem, table->field[3]);
server->username= ptr ? ptr : blank;
ptr= get_field(&mem, table->field[4]);
server->password= ptr ? ptr : blank;
ptr= get_field(&mem, table->field[5]);
server->sport= ptr ? ptr : blank;
server->port= server->sport ? atoi(server->sport) : 0;
ptr= get_field(&mem, table->field[6]);
server->socket= ptr && strlen(ptr) ? ptr : blank;
ptr= get_field(&mem, table->field[7]);
server->scheme= ptr ? ptr : blank;
ptr= get_field(&mem, table->field[8]);
server->owner= ptr ? ptr : blank;
DBUG_PRINT("info", ("server->server_name %s", server->server_name));
DBUG_PRINT("info", ("server->host %s", server->host));
DBUG_PRINT("info", ("server->db %s", server->db));
DBUG_PRINT("info", ("server->username %s", server->username));
DBUG_PRINT("info", ("server->password %s", server->password));
DBUG_PRINT("info", ("server->socket %s", server->socket));
if (my_hash_insert(&servers_cache, (uchar*) server))
{
DBUG_PRINT("info", ("had a problem inserting server %s at %lx",
server->server_name, (long unsigned int) server));
// error handling needed here
DBUG_RETURN(TRUE);
}
DBUG_RETURN(FALSE);
}
bool insert(const K& k, const T& v, bool replace = false) {
Entry* entry = new Entry(k, v);
if (my_hash_insert(&m_hash, (const uchar*)entry) != 0) {
// An entry already existed
delete entry;
T* p;
if (replace && search(k, &p)) {
*p = v;
return true;
}
return false;
}
return true;
}
MRN_LONG_TERM_SHARE *mrn_get_long_term_share(const char *table_name,
uint table_name_length,
int *error)
{
MRN_LONG_TERM_SHARE *long_term_share;
char *tmp_name;
MRN_DBUG_ENTER_FUNCTION();
DBUG_PRINT("info", ("mroonga: table_name=%s", table_name));
mrn::Lock lock(&mrn_long_term_share_mutex);
if (!(long_term_share = (MRN_LONG_TERM_SHARE*)
my_hash_search(&mrn_long_term_share, (uchar*) table_name,
table_name_length)))
{
if (!(long_term_share = (MRN_LONG_TERM_SHARE *)
mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
&long_term_share, sizeof(*long_term_share),
&tmp_name, table_name_length + 1,
NullS))
) {
*error = HA_ERR_OUT_OF_MEM;
goto error_alloc_long_term_share;
}
long_term_share->table_name = tmp_name;
long_term_share->table_name_length = table_name_length;
memcpy(long_term_share->table_name, table_name, table_name_length);
if (mysql_mutex_init(mrn_long_term_share_auto_inc_mutex_key,
&long_term_share->auto_inc_mutex,
MY_MUTEX_INIT_FAST) != 0)
{
*error = HA_ERR_OUT_OF_MEM;
goto error_init_auto_inc_mutex;
}
if (my_hash_insert(&mrn_long_term_share, (uchar*) long_term_share))
{
*error = HA_ERR_OUT_OF_MEM;
goto error_hash_insert;
}
}
DBUG_RETURN(long_term_share);
error_hash_insert:
mysql_mutex_destroy(&long_term_share->auto_inc_mutex);
error_init_auto_inc_mutex:
my_free(long_term_share);
error_alloc_long_term_share:
DBUG_RETURN(NULL);
}
static int
insert_server_record_into_cache(FOREIGN_SERVER *server)
{
int error=0;
DBUG_ENTER("insert_server_record_into_cache");
/*
We succeded in insertion of the server to the table, now insert
the server to the cache
*/
DBUG_PRINT("info", ("inserting server %s at %lx, length %d",
server->server_name, (long unsigned int) server,
server->server_name_length));
if (my_hash_insert(&servers_cache, (uchar*) server))
{
DBUG_PRINT("info", ("had a problem inserting server %s at %lx",
server->server_name, (long unsigned int) server));
// error handling needed here
error= 1;
}
DBUG_RETURN(error);
}
MRN_SHARE *mrn_get_share(const char *table_name, TABLE *table, int *error)
{
MRN_SHARE *share;
char *tmp_name, **index_table, **key_tokenizer, **col_flags, **col_type;
uint length, *wrap_key_nr, *index_table_length;
uint *key_tokenizer_length, *col_flags_length, *col_type_length, i, j;
KEY *wrap_key_info;
TABLE_SHARE *wrap_table_share;
MRN_DBUG_ENTER_FUNCTION();
length = (uint) strlen(table_name);
mrn::Lock lock(&mrn_open_tables_mutex);
if (!(share = (MRN_SHARE*) my_hash_search(&mrn_open_tables,
(uchar*) table_name, length)))
{
if (!(share = (MRN_SHARE *)
mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
&share, sizeof(*share),
&tmp_name, length + 1,
&index_table, sizeof(char *) * table->s->keys,
&index_table_length, sizeof(uint) * table->s->keys,
&key_tokenizer, sizeof(char *) * table->s->keys,
&key_tokenizer_length, sizeof(uint) * table->s->keys,
&col_flags, sizeof(char *) * table->s->fields,
&col_flags_length, sizeof(uint) * table->s->fields,
&col_type, sizeof(char *) * table->s->fields,
&col_type_length, sizeof(uint) * table->s->fields,
&wrap_key_nr, sizeof(*wrap_key_nr) * table->s->keys,
&wrap_key_info, sizeof(*wrap_key_info) * table->s->keys,
&wrap_table_share, sizeof(*wrap_table_share),
NullS))
) {
*error = HA_ERR_OUT_OF_MEM;
goto error_alloc_share;
}
share->use_count = 0;
share->table_name_length = length;
share->table_name = tmp_name;
share->index_table = index_table;
share->index_table_length = index_table_length;
share->key_tokenizer = key_tokenizer;
share->key_tokenizer_length = key_tokenizer_length;
share->col_flags = col_flags;
share->col_flags_length = col_flags_length;
share->col_type = col_type;
share->col_type_length = col_type_length;
mrn_my_stpmov(share->table_name, table_name);
share->table_share = table->s;
if (
(*error = mrn_parse_table_param(share, table)) ||
(*error = mrn_parse_column_param(share, table)) ||
(*error = mrn_parse_index_param(share, table))
)
goto error_parse_table_param;
if (share->wrapper_mode)
{
j = 0;
for (i = 0; i < table->s->keys; i++)
{
if (table->s->key_info[i].algorithm != HA_KEY_ALG_FULLTEXT &&
!mrn_is_geo_key(&table->s->key_info[i]))
{
wrap_key_nr[i] = j;
memcpy(&wrap_key_info[j], &table->s->key_info[i],
sizeof(*wrap_key_info));
j++;
} else {
wrap_key_nr[i] = MAX_KEY;
}
}
share->wrap_keys = j;
share->base_keys = table->s->keys;
share->base_key_info = table->s->key_info;
share->base_primary_key = table->s->primary_key;
if (i)
{
share->wrap_key_nr = wrap_key_nr;
share->wrap_key_info = wrap_key_info;
if (table->s->primary_key == MAX_KEY)
share->wrap_primary_key = MAX_KEY;
else
share->wrap_primary_key = wrap_key_nr[table->s->primary_key];
} else {
share->wrap_key_nr = NULL;
share->wrap_key_info = NULL;
share->wrap_primary_key = MAX_KEY;
}
memcpy(wrap_table_share, table->s, sizeof(*wrap_table_share));
mrn_init_sql_alloc(current_thd, &(wrap_table_share->mem_root));
wrap_table_share->keys = share->wrap_keys;
wrap_table_share->key_info = share->wrap_key_info;
wrap_table_share->primary_key = share->wrap_primary_key;
wrap_table_share->keys_in_use.init(share->wrap_keys);
wrap_table_share->keys_for_keyread.init(share->wrap_keys);
#ifdef MRN_TABLE_SHARE_HAVE_LOCK_SHARE
# ifdef WIN32
mysql_mutex_init(*mrn_table_share_lock_share,
&(wrap_table_share->LOCK_share), MY_MUTEX_INIT_SLOW);
# else
mysql_mutex_init(key_TABLE_SHARE_LOCK_share,
&(wrap_table_share->LOCK_share), MY_MUTEX_INIT_SLOW);
# endif
#endif
#ifdef WIN32
mysql_mutex_init(*mrn_table_share_lock_ha_data,
&(wrap_table_share->LOCK_ha_data), MY_MUTEX_INIT_FAST);
#else
mysql_mutex_init(key_TABLE_SHARE_LOCK_ha_data,
&(wrap_table_share->LOCK_ha_data), MY_MUTEX_INIT_FAST);
#endif
share->wrap_table_share = wrap_table_share;
}
if (mysql_mutex_init(mrn_share_mutex_key,
&share->record_mutex,
MY_MUTEX_INIT_FAST) != 0)
{
*error = HA_ERR_OUT_OF_MEM;
goto error_init_mutex;
}
thr_lock_init(&share->lock);
if (!(share->long_term_share = mrn_get_long_term_share(table_name, length,
error)))
{
goto error_get_long_term_share;
}
if (my_hash_insert(&mrn_open_tables, (uchar*) share))
{
*error = HA_ERR_OUT_OF_MEM;
goto error_hash_insert;
}
}
share->use_count++;
DBUG_RETURN(share);
error_hash_insert:
error_get_long_term_share:
mysql_mutex_destroy(&share->record_mutex);
error_init_mutex:
error_parse_table_param:
mrn_free_share_alloc(share);
my_free(share);
error_alloc_share:
DBUG_RETURN(NULL);
}
/**
Inserts a sp_head object into a hash table.
@returns Success status
@return TRUE Failure
@return FALSE Success
*/
inline bool insert(sp_head *sp)
{
return my_hash_insert(&m_hashtable, (const uchar *)sp);
}
main(int argc, char **argv)
{
char c;
extern char *optarg;
malloc_options = "A";
a = 0;
while ((c = getopt(argc, argv, "f:i:M:l:m:r:N")) != -1) {
switch (c) {
case 'N':
mem_pools_on = 0;
break;
case 'r':
run_stats = atoi(optarg);
break;
case 'f':
fn = xstrdup(optarg);
fp = fopen(fn, "r");
break;
case 'i':
initsiz = atoi(optarg);
break;
case 'l':
mem_max_size = atoi(optarg) * 1024 * 1024;
break;
case 'M':
maxsiz = atoi(optarg);
break;
case 'm':
minchunk = atoi(optarg);
break;
default:
fprintf(stderr,
"Usage: %s -f file -M maxsiz -i initsiz -m minchunk", argv[0]);
exit(1);
}
}
if (!fp) {
fprintf(stderr,
"%s pummels %s\n%s . o O ( You't supply a valid tracefile.)\n",
argv[0], getenv("USER"), argv[0]);
exit(1);
}
#ifdef WITH_LIB
sizeToPoolInit();
#endif
mem_table = hash_create(ptrcmp, 229, hash4); /* small hash table */
init_stats();
while (fgets(mbuf, 256, fp) != NULL) {
if (run_stats > 0 && (++a) % run_stats == 0)
print_stats();
p = NULL;
switch (mbuf[0]) {
case 'm': /* malloc */
p = strtok(&mbuf[2], ":");
if (!p)
badformat();
size = atoi(p);
p = strtok(NULL, "\n");
if (!p)
badformat();
mi = malloc(sizeof(memitem));
strcpy(mi->orig_ptr, p);
mi->size = size;
size2id(size, mi);
mi->my_ptr = xmemAlloc(mi); /* (void *)xmalloc(size); */
assert(mi->my_ptr);
my_hash_insert(mem_table, mi->orig_ptr, mi);
mstat.mallocs++;
break;
case 'c': /* calloc */
p = strtok(&mbuf[2], ":");
if (!p)
badformat();
amt = atoi(p);
p = strtok(NULL, ":");
if (!p)
badformat();
size = atoi(p);
p = strtok(NULL, "\n");
if (!p)
badformat();
mi = malloc(sizeof(memitem));
strcpy(mi->orig_ptr, p);
size2id(size, mi);
mi->size = amt * size;
mi->my_ptr = xmemAlloc(mi); /*(void *)xmalloc(amt*size); */
assert(mi->my_ptr);
my_hash_insert(mem_table, mi->orig_ptr, mi);
mstat.callocs++;
break;
case 'r':
p = strtok(&mbuf[2], ":");
if (!p)
badformat();
strcpy(abuf, p);
p = strtok(NULL, ":");
if (!p)
badformat();
mem_entry = hash_lookup(mem_table, p);
if (mem_entry == NULL) {
fprintf(stderr, "invalid realloc (%s)!\n", p);
break;
}
mi = (memitem *) (mem_entry->item);
assert(mi->pool);
assert(mi->my_ptr);
xmemFree(mi); /* xfree(mi->my_ptr); */
size2id(atoi(p), mi); /* we don't need it here I guess? */
strcpy(mi->orig_ptr, abuf);
p = strtok(NULL, "\n");
if (!p)
badformat();
mi->my_ptr = xmemAlloc(mi); /* (char *)xmalloc(atoi(p)); */
assert(mi->my_ptr);
mstat.reallocs++;
break;
case 'f':
p = strtok(&mbuf[2], "\n");
mem_entry = hash_lookup(mem_table, p);
if (mem_entry == NULL) {
if (p[0] != '0')
fprintf(stderr, "invalid free (%s) at line %d!\n", p, a);
break;
}
mi = (memitem *) (mem_entry->item);
assert(mi->pool);
assert(mi->my_ptr);
xmemFree(mi); /* xfree(mi->my_ptr); */
hash_unlink(mem_table, mem_entry, 1);
free(mi);
mstat.frees++;
break;
default:
fprintf(stderr, "%s pummels %s.bad.format\n", argv[0], fn);
exit(1);
}
}
fclose(fp);
print_stats();
}
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);
}