database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-08-07 00:04:31 +03:00
Code Activity

Merge rkalimullin@bk-internal.mysql.com:/home/bk/mysql-5.0

Browse Source 
into  mysql.com:/usr/home/ram/work/5.0.b10303


mysql-test/r/query_cache.result:
  Auto merged
mysql-test/t/query_cache.test:
  Auto merged
sql/sql_cache.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
This commit is contained in:
unknown
2005-10-24 11:36:29 +05:00
parent 811c6d216e d29ecd5e91
commit 39af58dbd4
882 changed files with 36837 additions and 13641 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
sql/sql_cache.cc
View File

@@ -573,13 +573,18 @@ void query_cache_insert(NET *net, const char *packet, ulong length)
{
DBUG_ENTER("query_cache_insert");
#ifndef DBUG_OFF
// Check if we have called query_cache.wreck() (which disables the cache)
if (query_cache.query_cache_size == 0)
DBUG_VOID_RETURN;
#endif
STRUCT_LOCK(&query_cache.structure_guard_mutex);
/*
It is very unlikely that following condition is TRUE (it is possible
only if other thread is resizing cache), so we check it only after guard
mutex lock
*/
if (unlikely(query_cache.query_cache_size == 0))
{
STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
DBUG_VOID_RETURN;
}
Query_cache_block *query_block = ((Query_cache_block*)
net->query_cache_query);
if (query_block)
@@ -623,14 +628,20 @@ void query_cache_abort(NET *net)
{
DBUG_ENTER("query_cache_abort");
#ifndef DBUG_OFF
// Check if we have called query_cache.wreck() (which disables the cache)
if (query_cache.query_cache_size == 0)
DBUG_VOID_RETURN;
#endif
if (net->query_cache_query != 0) // Quick check on unlocked structure
{
STRUCT_LOCK(&query_cache.structure_guard_mutex);
/*
It is very unlikely that following condition is TRUE (it is possible
only if other thread is resizing cache), so we check it only after guard
mutex lock
*/
if (unlikely(query_cache.query_cache_size == 0))
{
STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
DBUG_VOID_RETURN;
}
Query_cache_block *query_block = ((Query_cache_block*)
net->query_cache_query);
if (query_block) // Test if changed by other thread
@@ -652,11 +663,6 @@ void query_cache_end_of_result(THD *thd)
{
DBUG_ENTER("query_cache_end_of_result");
#ifndef DBUG_OFF
// Check if we have called query_cache.wreck() (which disables the cache)
if (query_cache.query_cache_size == 0) DBUG_VOID_RETURN;
#endif
if (thd->net.query_cache_query != 0) // Quick check on unlocked structure
{
#ifdef EMBEDDED_LIBRARY
@@ -664,6 +670,17 @@ void query_cache_end_of_result(THD *thd)
emb_count_querycache_size(thd));
#endif
STRUCT_LOCK(&query_cache.structure_guard_mutex);
/*
It is very unlikely that following condition is TRUE (it is possible
only if other thread is resizing cache), so we check it only after guard
mutex lock
*/
if (unlikely(query_cache.query_cache_size == 0))
{
STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
DBUG_VOID_RETURN;
}
Query_cache_block *query_block = ((Query_cache_block*)
thd->net.query_cache_query);
if (query_block)
@@ -743,9 +760,14 @@ ulong Query_cache::resize(ulong query_cache_size_arg)
DBUG_ENTER("Query_cache::resize");
DBUG_PRINT("qcache", ("from %lu to %lu",query_cache_size,
query_cache_size_arg));
free_cache(0);
DBUG_ASSERT(initialized);
STRUCT_LOCK(&structure_guard_mutex);
if (query_cache_size > 0)
free_cache();
query_cache_size= query_cache_size_arg;
DBUG_RETURN(::query_cache_size= init_cache());
::query_cache_size= init_cache();
STRUCT_UNLOCK(&structure_guard_mutex);
DBUG_RETURN(::query_cache_size);
}
@@ -779,6 +801,7 @@ void Query_cache::store_query(THD *thd, TABLE_LIST *tables_used)
CLIENT_PROTOCOL_41);
flags.more_results_exists= test(thd->server_status &
SERVER_MORE_RESULTS_EXISTS);
flags.pkt_nr= net->pkt_nr;
flags.character_set_client_num=
thd->variables.character_set_client->number;
flags.character_set_results_num=
@@ -792,12 +815,13 @@ void Query_cache::store_query(THD *thd, TABLE_LIST *tables_used)
flags.sql_mode= thd->variables.sql_mode;
flags.max_sort_length= thd->variables.max_sort_length;
flags.group_concat_max_len= thd->variables.group_concat_max_len;
DBUG_PRINT("qcache", ("long %d, 4.1: %d, more results %d, \
DBUG_PRINT("qcache", ("long %d, 4.1: %d, more results %d, pkt_nr: %d, \
CS client: %u, CS result: %u, CS conn: %u, limit: %lu, TZ: 0x%lx, \
sql mode: 0x%lx, sort len: %lu, conncat len: %lu",
(int)flags.client_long_flag,
(int)flags.client_protocol_41,
(int)flags.more_results_exists,
flags.pkt_nr,
flags.character_set_client_num,
flags.character_set_results_num,
flags.collation_connection_num,
@@ -997,6 +1021,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
CLIENT_PROTOCOL_41);
flags.more_results_exists= test(thd->server_status &
SERVER_MORE_RESULTS_EXISTS);
flags.pkt_nr= thd->net.pkt_nr;
flags.character_set_client_num= thd->variables.character_set_client->number;
flags.character_set_results_num=
(thd->variables.character_set_results ?
@@ -1008,12 +1033,13 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length)
flags.sql_mode= thd->variables.sql_mode;
flags.max_sort_length= thd->variables.max_sort_length;
flags.group_concat_max_len= thd->variables.group_concat_max_len;
DBUG_PRINT("qcache", ("long %d, 4.1: %d, more results %d, \
DBUG_PRINT("qcache", ("long %d, 4.1: %d, more results %d, pkt_nr: %d, \
CS client: %u, CS result: %u, CS conn: %u, limit: %lu, TZ: 0x%lx, \
sql mode: 0x%lx, sort len: %lu, conncat len: %lu",
(int)flags.client_long_flag,
(int)flags.client_protocol_41,
(int)flags.more_results_exists,
flags.pkt_nr,
flags.character_set_client_num,
flags.character_set_results_num,
flags.collation_connection_num,
@@ -1274,7 +1300,8 @@ void Query_cache::invalidate_locked_for_write(TABLE_LIST *tables_used)
DUMP(this);
for (; tables_used; tables_used= tables_used->next_local)
{
if (tables_used->lock_type & (TL_WRITE_LOW_PRIORITY | TL_WRITE))
if (tables_used->lock_type & (TL_WRITE_LOW_PRIORITY | TL_WRITE) &&
tables_used->table)
invalidate_table(tables_used->table);
}
}
@@ -1439,7 +1466,7 @@ void Query_cache::destroy()
}
else
{
free_cache(1);
free_cache();
pthread_mutex_destroy(&structure_guard_mutex);
initialized = 0;
}
@@ -1468,8 +1495,6 @@ ulong Query_cache::init_cache()
int align;
DBUG_ENTER("Query_cache::init_cache");
if (!initialized)
init();
approx_additional_data_size = (sizeof(Query_cache) +
sizeof(gptr)*(def_query_hash_size+
def_table_hash_size));
@@ -1527,14 +1552,9 @@ ulong Query_cache::init_cache()
goto err;
query_cache_size -= additional_data_size;
STRUCT_LOCK(&structure_guard_mutex);
if (!(cache = (byte *)
my_malloc_lock(query_cache_size+additional_data_size, MYF(0))))
{
STRUCT_UNLOCK(&structure_guard_mutex);
if (!(cache= (byte *)
my_malloc_lock(query_cache_size+additional_data_size, MYF(0))))
goto err;
}
DBUG_PRINT("qcache", ("cache length %lu, min unit %lu, %u bins",
query_cache_size, min_allocation_unit, mem_bin_num));
@@ -1630,7 +1650,6 @@ ulong Query_cache::init_cache()
queries_in_cache = 0;
queries_blocks = 0;
STRUCT_UNLOCK(&structure_guard_mutex);
DBUG_RETURN(query_cache_size +
additional_data_size + approx_additional_data_size);
@@ -1646,6 +1665,7 @@ void Query_cache::make_disabled()
{
DBUG_ENTER("Query_cache::make_disabled");
query_cache_size= 0;
queries_blocks= 0;
free_memory= 0;
bins= 0;
steps= 0;
@@ -1657,14 +1677,11 @@ void Query_cache::make_disabled()
}
void Query_cache::free_cache(my_bool destruction)
void Query_cache::free_cache()
{
DBUG_ENTER("Query_cache::free_cache");
if (query_cache_size > 0)
{
if (!destruction)
STRUCT_LOCK(&structure_guard_mutex);
flush_cache();
#ifndef DBUG_OFF
if (bins[0].free_blocks == 0)
@@ -1686,8 +1703,6 @@ void Query_cache::free_cache(my_bool destruction)
make_disabled();
hash_free(&queries);
hash_free(&tables);
if (!destruction)
STRUCT_UNLOCK(&structure_guard_mutex);
}
DBUG_VOID_RETURN;
}
@@ -2402,7 +2417,19 @@ Query_cache::allocate_block(ulong len, my_bool not_less, ulong min,
}
if (!under_guard)
{
STRUCT_LOCK(&structure_guard_mutex);
/*
It is very unlikely that following condition is TRUE (it is possible
only if other thread is resizing cache), so we check it only after
guard mutex lock
*/
if (unlikely(query_cache.query_cache_size == 0))
{
STRUCT_UNLOCK(&structure_guard_mutex);
DBUG_RETURN(0);
}
}
/* Free old queries until we have enough memory to store this block */
Query_cache_block *block;
@@ -2948,6 +2975,17 @@ void Query_cache::pack_cache()
{
DBUG_ENTER("Query_cache::pack_cache");
STRUCT_LOCK(&structure_guard_mutex);
/*
It is very unlikely that following condition is TRUE (it is possible
only if other thread is resizing cache), so we check it only after
guard mutex lock
*/
if (unlikely(query_cache_size == 0))
{
STRUCT_UNLOCK(&structure_guard_mutex);
DBUG_VOID_RETURN;
}
DBUG_EXECUTE("check_querycache",query_cache.check_integrity(1););
byte *border = 0;
@@ -3257,6 +3295,7 @@ my_bool Query_cache::join_results(ulong join_limit)
STRUCT_LOCK(&structure_guard_mutex);
if (queries_blocks != 0)
{
DBUG_ASSERT(query_cache_size > 0);
Query_cache_block *block = queries_blocks;
do
{
@@ -3553,7 +3592,19 @@ my_bool Query_cache::check_integrity(bool not_locked)
DBUG_RETURN(0);
}
if (!not_locked)
{
STRUCT_LOCK(&structure_guard_mutex);
/*
It is very unlikely that following condition is TRUE (it is possible
only if other thread is resizing cache), so we check it only after
guard mutex lock
*/
if (unlikely(query_cache_size == 0))
{
STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
DBUG_RETURN(0);
}
}
if (hash_check(&queries))
{