Skip to content

M
mariadb
Commit a995633a authored by msvensson@neptunus.homeip.net's avatar msvensson@neptunus.homeip.net
Browse files
Options

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

into neptunus.homeip.net:/home/msvensson/mysql/mysql-5.0
parents 7df94d5e facc7b4d
Hide whitespace changes
Inline Side-by-side
Showing with 87 additions and 87 deletions
sql/ha_ndbcluster.cc
View file @ a995633a
......@@ -4834,17 +4834,17 @@ uint8 ha_ndbcluster::table_cache_type()
}
uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
Uint64* commit_count)
uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
Uint64 *commit_count)
{
DBUG_ENTER("ndb_get_commitcount");
if (ndb_cache_check_time > 0)
{
// Use cached commit_count from share
/* Use cached commit_count from share */
char name[FN_REFLEN];
NDB_SHARE* share;
(void)strxnmov(name, FN_REFLEN,
NDB_SHARE *share;
(void)strxnmov(name, FN_REFLEN,
"./",dbname,"/",tabname,NullS);
DBUG_PRINT("info", ("name: %s", name));
pthread_mutex_lock(&ndbcluster_mutex);
......@@ -4855,18 +4855,18 @@ uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
pthread_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(1);
}
*commit_count= share->commit_count;
*commit_count= share->commit_count;
DBUG_PRINT("info", ("commit_count: %d", *commit_count));
pthread_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(0);
}
// Get commit_count from NDB
/* Get commit_count from NDB */
Ndb *ndb;
if (!(ndb= check_ndb_in_thd(thd)))
DBUG_RETURN(1);
ndb->setDatabaseName(dbname);
struct Ndb_statistics stat;
if (ndb_get_table_statistics(ndb, tabname, &stat))
DBUG_RETURN(1);
......@@ -4877,25 +4877,25 @@ uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
/*
Check if a cached query can be used.
This is done by comparing the supplied engine_data to commit_count of
This is done by comparing the supplied engine_data to commit_count of
the table.
The commit_count is either retrieved from the share for the table, where
it has been cached by the util thread. If the util thread is not started,
The commit_count is either retrieved from the share for the table, where
it has been cached by the util thread. If the util thread is not started,
NDB has to be contacetd to retrieve the commit_count, this will introduce
a small delay while waiting for NDB to answer.
SYNOPSIS
ndbcluster_cache_retrieval_allowed
thd thread handle
full_name concatenation of database name,
the null character '\0', and the table
name
full_name_len length of the full name,
name
full_name_len length of the full name,
i.e. len(dbname) + len(tablename) + 1
engine_data parameter retrieved when query was first inserted into
the cache. If the value of engine_data is changed,
engine_data parameter retrieved when query was first inserted into
the cache. If the value of engine_data is changed,
all queries for this table should be invalidated.
RETURN VALUE
......@@ -4905,17 +4905,17 @@ uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
*/
static my_bool
ndbcluster_cache_retrieval_allowed(THD* thd,
char* full_name, uint full_name_len,
static my_bool
ndbcluster_cache_retrieval_allowed(THD *thd,
char *full_name, uint full_name_len,
ulonglong *engine_data)
{
DBUG_ENTER("ndbcluster_cache_retrieval_allowed");
Uint64 commit_count;
bool is_autocommit= !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN));
char* dbname= full_name;
char* tabname= dbname+strlen(dbname)+1;
char *dbname= full_name;
char *tabname= dbname+strlen(dbname)+1;
DBUG_PRINT("enter",("dbname=%s, tabname=%s, autocommit=%d",
dbname, tabname, is_autocommit));
......@@ -4925,14 +4925,14 @@ ndbcluster_cache_retrieval_allowed(THD* thd,
if (ndb_get_commitcount(thd, dbname, tabname, &commit_count))
{
*engine_data+= 1; // invalidate
*engine_data+= 1; /* invalidate */
DBUG_RETURN(FALSE);
}
DBUG_PRINT("info", ("*engine_data=%llu, commit_count=%llu",
DBUG_PRINT("info", ("*engine_data=%llu, commit_count=%llu",
*engine_data, commit_count));
if (*engine_data != commit_count)
{
*engine_data= commit_count; // invalidate
*engine_data= commit_count; /* invalidate */
DBUG_PRINT("exit",("Do not use cache, commit_count has changed"));
DBUG_RETURN(FALSE);
}
......@@ -4944,7 +4944,7 @@ ndbcluster_cache_retrieval_allowed(THD* thd,
/**
Register a table for use in the query cache. Fetch the commit_count
for the table and return it in engine_data, this will later be used
for the table and return it in engine_data, this will later be used
to check if the table has changed, before the cached query is reused.
SYNOPSIS
......@@ -4952,10 +4952,10 @@ ndbcluster_cache_retrieval_allowed(THD* thd,
thd thread handle
full_name concatenation of database name,
the null character '\0', and the table
name
full_name_len length of the full name,
name
full_name_len length of the full name,
i.e. len(dbname) + len(tablename) + 1
qc_engine_callback function to be called before using cache on this table
qc_engine_callback function to be called before using cache on this table
engine_data out, commit_count for this table
RETURN VALUE
......@@ -4965,10 +4965,10 @@ ndbcluster_cache_retrieval_allowed(THD* thd,
*/
my_bool
ha_ndbcluster::register_query_cache_table(THD* thd,
char* full_name, uint full_name_len,
ha_ndbcluster::register_query_cache_table(THD *thd,
char *full_name, uint full_name_len,
qc_engine_callback *engine_callback,
ulonglong *engine_data)
ulonglong *engine_data)
{
DBUG_ENTER("ha_ndbcluster::register_query_cache_table");
......@@ -4978,7 +4978,6 @@ ha_ndbcluster::register_query_cache_table(THD* thd,
if (!is_autocommit)
DBUG_RETURN(FALSE);
Uint64 commit_count;
if (ndb_get_commitcount(thd, m_dbname, m_tabname, &commit_count))
{
......@@ -4992,8 +4991,9 @@ ha_ndbcluster::register_query_cache_table(THD* thd,
DBUG_RETURN(TRUE);
}
/*
Handling the shared NDB_SHARE structure that is needed to
Handling the shared NDB_SHARE structure that is needed to
provide table locking.
It's also used for sharing data with other NDB handlers
in the same MySQL Server. There is currently not much
......@@ -5610,7 +5610,7 @@ ha_ndbcluster::update_table_comment(
const char* comment)/* in: table comment defined by user */
{
uint length= strlen(comment);
if(length > 64000 - 3)
if(length > 64000 - 3)
{
return((char*)comment); /* string too long */
}
......@@ -5645,24 +5645,24 @@ ha_ndbcluster::update_table_comment(
// Utility thread main loop
extern "C" pthread_handler_decl(ndb_util_thread_func,
arg __attribute__((unused)))
extern "C" pthread_handler_decl(ndb_util_thread_func,
arg __attribute__((unused)))
{
THD *thd; // needs to be first for thread_stack
int error = 0;
THD *thd; /* needs to be first for thread_stack */
int error= 0;
struct timespec abstime;
my_thread_init();
DBUG_ENTER("ndb_util_thread");
DBUG_PRINT("enter", ("ndb_cache_check_time: %d", ndb_cache_check_time));
thd= new THD; // note that contructor of THD uses DBUG_ !
thd= new THD; /* note that contructor of THD uses DBUG_ */
THD_CHECK_SENTRY(thd);
pthread_detach_this_thread();
ndb_util_thread = pthread_self();
ndb_util_thread= pthread_self();
thd->thread_stack = (char*)&thd; // remember where our stack is
thd->thread_stack= (char*)&thd; /* remember where our stack is */
if (thd->store_globals())
{
thd->cleanup();
......@@ -5676,49 +5676,48 @@ extern "C" pthread_handler_decl(ndb_util_thread_func,
{
pthread_mutex_lock(&LOCK_ndb_util_thread);
error= pthread_cond_timedwait(&COND_ndb_util_thread,
&LOCK_ndb_util_thread,
&abstime);
error= pthread_cond_timedwait(&COND_ndb_util_thread,
&LOCK_ndb_util_thread,
&abstime);
pthread_mutex_unlock(&LOCK_ndb_util_thread);
DBUG_PRINT("ndb_util_thread", ("Started, ndb_cache_check_time: %d",
ndb_cache_check_time));
DBUG_PRINT("ndb_util_thread", ("Started, ndb_cache_check_time: %d",
ndb_cache_check_time));
if (abort_loop)
break; // Shutting down server
break; /* Shutting down server */
if (ndb_cache_check_time == 0)
{
set_timespec(abstime, 10);
continue;
}
// Set new time to wake up
/* Set new time to wake up */
set_timespec(abstime, ndb_cache_check_time);
// Lock mutex and fill list with pointers to all open tables
/* Lock mutex and fill list with pointers to all open tables */
NDB_SHARE *share;
pthread_mutex_lock(&ndbcluster_mutex);
for (uint i= 0; i < ndbcluster_open_tables.records; i++)
{
share= (NDB_SHARE *)hash_element(&ndbcluster_open_tables, i);
share->use_count++; // Make sure the table can't be closed
DBUG_PRINT("ndb_util_thread",
("Found open table[%d]: %s, use_count: %d",
i, share->table_name, share->use_count));
// Store pointer to table
share->use_count++; /* Make sure the table can't be closed */
DBUG_PRINT("ndb_util_thread",
("Found open table[%d]: %s, use_count: %d",
i, share->table_name, share->use_count));
/* Store pointer to table */
util_open_tables.push_back(share);
}
pthread_mutex_unlock(&ndbcluster_mutex);
// Iterate through the open files list
/* Iterate through the open files list */
List_iterator_fast<NDB_SHARE> it(util_open_tables);
while (share=it++)
{
// Split tab- and dbname
while (share= it++)
{
/* Split tab- and dbname */
char buf[FN_REFLEN];
char *tabname, *db;
uint length= dirname_length(share->table_name);
......@@ -5726,35 +5725,36 @@ extern "C" pthread_handler_decl(ndb_util_thread_func,
memcpy(buf, share->table_name, length-1);
buf[length-1]= 0;
db= buf+dirname_length(buf);
DBUG_PRINT("ndb_util_thread",
("Fetching commit count for: %s, db: %s, tab: %s",
share->table_name, db, tabname));
// Contact NDB to get commit count for table
DBUG_PRINT("ndb_util_thread",
("Fetching commit count for: %s, db: %s, tab: %s",
share->table_name, db, tabname));
/* Contact NDB to get commit count for table */
g_ndb->setDatabaseName(db);
struct Ndb_statistics stat;;
if(ndb_get_table_statistics(g_ndb, tabname, &stat) == 0){
DBUG_PRINT("ndb_util_thread",
("Table: %s, rows: %llu, commit_count: %llu",
share->table_name, stat.row_count, stat.commit_count));
share->commit_count= stat.commit_count;
if(ndb_get_table_statistics(g_ndb, tabname, &stat) == 0)
{
DBUG_PRINT("ndb_util_thread",
("Table: %s, rows: %llu, commit_count: %llu",
share->table_name, stat.row_count, stat.commit_count));
share->commit_count= stat.commit_count;
}
else
{
DBUG_PRINT("ndb_util_thread",
("Error: Could not get commit count for table %s",
share->table_name));
share->commit_count++; // Invalidate
DBUG_PRINT("ndb_util_thread",
("Error: Could not get commit count for table %s",
share->table_name));
share->commit_count++; /* Invalidate */
}
// Decrease the use count and possibly free share
/* Decrease the use count and possibly free share */
free_share(share);
}
// Clear the list of open tables
util_open_tables.empty();
/* Clear the list of open tables */
util_open_tables.empty();
}
thd->cleanup();
delete thd;
DBUG_PRINT("exit", ("ndb_util_thread"));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7