1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge sanja.is.com.ua:/home/bell/mysql/bk/mysql-5.0

Browse Source 
into sanja.is.com.ua:/home/bell/mysql/bk/work-5.0
This commit is contained in:
bell@sanja.is.com.ua 2005-02-09 16:03:20 +02:00
commit 5936c19629
3 changed files with 96 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.bzrignore
View File

@ -254,11 +254,14 @@ bkpush.log
bkpush.log* bkpush.log*
build.log build.log
build_tags.sh build_tags.sh
client/decimal.c
client/insert_test client/insert_test
client/log_event.cc client/log_event.cc
client/log_event.h client/log_event.h
client/mf_iocache.c client/mf_iocache.c
client/mf_iocache.cc client/mf_iocache.cc
client/my_decimal.cc
client/my_decimal.h
client/mysql client/mysql
client/mysqladmin client/mysqladmin
client/mysqladmin.c client/mysqladmin.c
@ -328,9 +331,12 @@ help.h
include/my_config.h include/my_config.h
include/my_global.h include/my_global.h
include/mysql_version.h include/mysql_version.h
include/mysqld_ername.h
include/mysqld_error.h
include/readline include/readline
include/readline/*.h include/readline/*.h
include/readline/readline.h include/readline/readline.h
include/sql_state.h
include/widec.h include/widec.h
innobase/autom4te-2.53.cache/* innobase/autom4te-2.53.cache/*
innobase/autom4te-2.53.cache/output.0 innobase/autom4te-2.53.cache/output.0
@ -432,6 +438,7 @@ libmysqld/log_event.cc
libmysqld/md5.c libmysqld/md5.c
libmysqld/mf_iocache.cc libmysqld/mf_iocache.cc
libmysqld/mini_client.cc libmysqld/mini_client.cc
libmysqld/my_decimal.cc
libmysqld/my_time.c libmysqld/my_time.c
libmysqld/net_pkg.cc libmysqld/net_pkg.cc
libmysqld/net_serv.cc libmysqld/net_serv.cc
@ -985,6 +992,7 @@ support-files/mysql-3.23.29-gamma.spec
support-files/mysql-log-rotate support-files/mysql-log-rotate
support-files/mysql.server support-files/mysql.server
support-files/mysql.spec support-files/mysql.spec
support-files/ndb-config-2-node.ini
tags tags
test/ndbapi/bank/bankCreator test/ndbapi/bank/bankCreator
test/ndbapi/bank/bankMakeGL test/ndbapi/bank/bankMakeGL
@ -1052,11 +1060,3 @@ vio/test-ssl
vio/test-sslclient vio/test-sslclient
vio/test-sslserver vio/test-sslserver
vio/viotest-ssl vio/viotest-ssl
include/mysqld_ername.h
include/mysqld_error.h
include/sql_state.h
support-files/ndb-config-2-node.ini
client/decimal.c
client/my_decimal.cc
client/my_decimal.h
libmysqld/my_decimal.cc

174
sql/ha_ndbcluster.cc
View File

@ -4834,17 +4834,17 @@ uint8 ha_ndbcluster::table_cache_type()
} }
uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname, uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
Uint64* commit_count) Uint64 *commit_count)
{ {
DBUG_ENTER("ndb_get_commitcount"); DBUG_ENTER("ndb_get_commitcount");
if (ndb_cache_check_time > 0) if (ndb_cache_check_time > 0)
{ {
// Use cached commit_count from share /* Use cached commit_count from share */
char name[FN_REFLEN]; char name[FN_REFLEN];
NDB_SHARE* share; NDB_SHARE *share;
(void)strxnmov(name, FN_REFLEN, (void)strxnmov(name, FN_REFLEN,
"./",dbname,"/",tabname,NullS); "./",dbname,"/",tabname,NullS);
DBUG_PRINT("info", ("name: %s", name)); DBUG_PRINT("info", ("name: %s", name));
pthread_mutex_lock(&ndbcluster_mutex); pthread_mutex_lock(&ndbcluster_mutex);
@ -4855,18 +4855,18 @@ uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
pthread_mutex_unlock(&ndbcluster_mutex); pthread_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
*commit_count= share->commit_count; *commit_count= share->commit_count;
DBUG_PRINT("info", ("commit_count: %d", *commit_count)); DBUG_PRINT("info", ("commit_count: %d", *commit_count));
pthread_mutex_unlock(&ndbcluster_mutex); pthread_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(0); DBUG_RETURN(0);
} }
// Get commit_count from NDB /* Get commit_count from NDB */
Ndb *ndb; Ndb *ndb;
if (!(ndb= check_ndb_in_thd(thd))) if (!(ndb= check_ndb_in_thd(thd)))
DBUG_RETURN(1); DBUG_RETURN(1);
ndb->setDatabaseName(dbname); ndb->setDatabaseName(dbname);
struct Ndb_statistics stat; struct Ndb_statistics stat;
if (ndb_get_table_statistics(ndb, tabname, &stat)) if (ndb_get_table_statistics(ndb, tabname, &stat))
DBUG_RETURN(1); 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. 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 table.
The commit_count is either retrieved from the share for the table, where 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, 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 NDB has to be contacetd to retrieve the commit_count, this will introduce
a small delay while waiting for NDB to answer. a small delay while waiting for NDB to answer.
SYNOPSIS SYNOPSIS
ndbcluster_cache_retrieval_allowed ndbcluster_cache_retrieval_allowed
thd thread handle thd thread handle
full_name concatenation of database name, full_name concatenation of database name,
the null character '\0', and the table the null character '\0', and the table
name name
full_name_len length of the full name, full_name_len length of the full name,
i.e. len(dbname) + len(tablename) + 1 i.e. len(dbname) + len(tablename) + 1
engine_data parameter retrieved when query was first inserted into engine_data parameter retrieved when query was first inserted into
the cache. If the value of engine_data is changed, the cache. If the value of engine_data is changed,
all queries for this table should be invalidated. all queries for this table should be invalidated.
RETURN VALUE RETURN VALUE
@ -4905,17 +4905,17 @@ uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
*/ */
static my_bool static my_bool
ndbcluster_cache_retrieval_allowed(THD* thd, ndbcluster_cache_retrieval_allowed(THD *thd,
char* full_name, uint full_name_len, char *full_name, uint full_name_len,
ulonglong *engine_data) ulonglong *engine_data)
{ {
DBUG_ENTER("ndbcluster_cache_retrieval_allowed"); DBUG_ENTER("ndbcluster_cache_retrieval_allowed");
Uint64 commit_count; Uint64 commit_count;
bool is_autocommit= !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)); bool is_autocommit= !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN));
char* dbname= full_name; char *dbname= full_name;
char* tabname= dbname+strlen(dbname)+1; char *tabname= dbname+strlen(dbname)+1;
DBUG_PRINT("enter",("dbname=%s, tabname=%s, autocommit=%d", DBUG_PRINT("enter",("dbname=%s, tabname=%s, autocommit=%d",
dbname, tabname, is_autocommit)); dbname, tabname, is_autocommit));
@ -4925,14 +4925,14 @@ ndbcluster_cache_retrieval_allowed(THD* thd,
if (ndb_get_commitcount(thd, dbname, tabname, &commit_count)) if (ndb_get_commitcount(thd, dbname, tabname, &commit_count))
{ {
*engine_data+= 1; // invalidate *engine_data+= 1; /* invalidate */
DBUG_RETURN(FALSE); 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)); *engine_data, commit_count));
if (*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_PRINT("exit",("Do not use cache, commit_count has changed"));
DBUG_RETURN(FALSE); 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 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. to check if the table has changed, before the cached query is reused.
SYNOPSIS SYNOPSIS
@ -4952,10 +4952,10 @@ ndbcluster_cache_retrieval_allowed(THD* thd,
thd thread handle thd thread handle
full_name concatenation of database name, full_name concatenation of database name,
the null character '\0', and the table the null character '\0', and the table
name name
full_name_len length of the full name, full_name_len length of the full name,
i.e. len(dbname) + len(tablename) + 1 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 engine_data out, commit_count for this table
RETURN VALUE RETURN VALUE
@ -4965,10 +4965,10 @@ ndbcluster_cache_retrieval_allowed(THD* thd,
*/ */
my_bool my_bool
ha_ndbcluster::register_query_cache_table(THD* thd, ha_ndbcluster::register_query_cache_table(THD *thd,
char* full_name, uint full_name_len, char *full_name, uint full_name_len,
qc_engine_callback *engine_callback, qc_engine_callback *engine_callback,
ulonglong *engine_data) ulonglong *engine_data)
{ {
DBUG_ENTER("ha_ndbcluster::register_query_cache_table"); DBUG_ENTER("ha_ndbcluster::register_query_cache_table");
@ -4978,7 +4978,6 @@ ha_ndbcluster::register_query_cache_table(THD* thd,
if (!is_autocommit) if (!is_autocommit)
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
Uint64 commit_count; Uint64 commit_count;
if (ndb_get_commitcount(thd, m_dbname, m_tabname, &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); 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. provide table locking.
It's also used for sharing data with other NDB handlers It's also used for sharing data with other NDB handlers
in the same MySQL Server. There is currently not much 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 */ const char* comment)/* in: table comment defined by user */
{ {
uint length= strlen(comment); uint length= strlen(comment);
if(length > 64000 - 3) if(length > 64000 - 3)
{ {
return((char*)comment); /* string too long */ return((char*)comment); /* string too long */
} }
@ -5645,24 +5645,24 @@ ha_ndbcluster::update_table_comment(
// Utility thread main loop // Utility thread main loop
extern "C" pthread_handler_decl(ndb_util_thread_func, extern "C" pthread_handler_decl(ndb_util_thread_func,
arg __attribute__((unused))) arg __attribute__((unused)))
{ {
THD *thd; // needs to be first for thread_stack THD *thd; /* needs to be first for thread_stack */
int error = 0; int error= 0;
struct timespec abstime; struct timespec abstime;
my_thread_init(); my_thread_init();
DBUG_ENTER("ndb_util_thread"); DBUG_ENTER("ndb_util_thread");
DBUG_PRINT("enter", ("ndb_cache_check_time: %d", ndb_cache_check_time)); 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); THD_CHECK_SENTRY(thd);
pthread_detach_this_thread(); 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()) if (thd->store_globals())
{ {
thd->cleanup(); thd->cleanup();
@ -5676,49 +5676,48 @@ extern "C" pthread_handler_decl(ndb_util_thread_func,
{ {
pthread_mutex_lock(&LOCK_ndb_util_thread); pthread_mutex_lock(&LOCK_ndb_util_thread);
error= pthread_cond_timedwait(&COND_ndb_util_thread, error= pthread_cond_timedwait(&COND_ndb_util_thread,
&LOCK_ndb_util_thread, &LOCK_ndb_util_thread,
&abstime); &abstime);
pthread_mutex_unlock(&LOCK_ndb_util_thread); pthread_mutex_unlock(&LOCK_ndb_util_thread);
DBUG_PRINT("ndb_util_thread", ("Started, ndb_cache_check_time: %d", DBUG_PRINT("ndb_util_thread", ("Started, ndb_cache_check_time: %d",
ndb_cache_check_time)); ndb_cache_check_time));
if (abort_loop) if (abort_loop)
break; // Shutting down server break; /* Shutting down server */
if (ndb_cache_check_time == 0) if (ndb_cache_check_time == 0)
{ {
set_timespec(abstime, 10); set_timespec(abstime, 10);
continue; continue;
} }
// Set new time to wake up /* Set new time to wake up */
set_timespec(abstime, ndb_cache_check_time); 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; NDB_SHARE *share;
pthread_mutex_lock(&ndbcluster_mutex); pthread_mutex_lock(&ndbcluster_mutex);
for (uint i= 0; i < ndbcluster_open_tables.records; i++) for (uint i= 0; i < ndbcluster_open_tables.records; i++)
{ {
share= (NDB_SHARE *)hash_element(&ndbcluster_open_tables, i); share= (NDB_SHARE *)hash_element(&ndbcluster_open_tables, i);
share->use_count++; // Make sure the table can't be closed share->use_count++; /* Make sure the table can't be closed */
DBUG_PRINT("ndb_util_thread", DBUG_PRINT("ndb_util_thread",
("Found open table[%d]: %s, use_count: %d", ("Found open table[%d]: %s, use_count: %d",
i, share->table_name, share->use_count)); i, share->table_name, share->use_count));
// Store pointer to table /* Store pointer to table */
util_open_tables.push_back(share); util_open_tables.push_back(share);
} }
pthread_mutex_unlock(&ndbcluster_mutex); 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); List_iterator_fast<NDB_SHARE> it(util_open_tables);
while (share=it++) while (share= it++)
{ {
// Split tab- and dbname /* Split tab- and dbname */
char buf[FN_REFLEN]; char buf[FN_REFLEN];
char *tabname, *db; char *tabname, *db;
uint length= dirname_length(share->table_name); 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); memcpy(buf, share->table_name, length-1);
buf[length-1]= 0; buf[length-1]= 0;
db= buf+dirname_length(buf); db= buf+dirname_length(buf);
DBUG_PRINT("ndb_util_thread", DBUG_PRINT("ndb_util_thread",
("Fetching commit count for: %s, db: %s, tab: %s", ("Fetching commit count for: %s, db: %s, tab: %s",
share->table_name, db, tabname)); share->table_name, db, tabname));
// Contact NDB to get commit count for table /* Contact NDB to get commit count for table */
g_ndb->setDatabaseName(db); g_ndb->setDatabaseName(db);
struct Ndb_statistics stat;; struct Ndb_statistics stat;;
if(ndb_get_table_statistics(g_ndb, tabname, &stat) == 0){ if(ndb_get_table_statistics(g_ndb, tabname, &stat) == 0)
DBUG_PRINT("ndb_util_thread", {
("Table: %s, rows: %llu, commit_count: %llu", DBUG_PRINT("ndb_util_thread",
share->table_name, stat.row_count, stat.commit_count)); ("Table: %s, rows: %llu, commit_count: %llu",
share->commit_count= stat.commit_count; share->table_name, stat.row_count, stat.commit_count));
share->commit_count= stat.commit_count;
} }
else else
{ {
DBUG_PRINT("ndb_util_thread", DBUG_PRINT("ndb_util_thread",
("Error: Could not get commit count for table %s", ("Error: Could not get commit count for table %s",
share->table_name)); share->table_name));
share->commit_count++; // Invalidate share->commit_count++; /* Invalidate */
} }
// Decrease the use count and possibly free share /* Decrease the use count and possibly free share */
free_share(share); free_share(share);
} }
// Clear the list of open tables /* Clear the list of open tables */
util_open_tables.empty(); util_open_tables.empty();
} }
thd->cleanup(); thd->cleanup();
delete thd; delete thd;
DBUG_PRINT("exit", ("ndb_util_thread")); DBUG_PRINT("exit", ("ndb_util_thread"));

2
sql/sql_yacc.yy
View File

@ -4817,7 +4817,7 @@ in_sum_expr:
cast_type: cast_type:
BINARY opt_len { $$=ITEM_CAST_CHAR; Lex->charset= &my_charset_bin; Lex->dec= 0; } BINARY opt_len { $$=ITEM_CAST_CHAR; Lex->charset= &my_charset_bin; Lex->dec= 0; }
| CHAR_SYM opt_len opt_binary { $$=ITEM_CAST_CHAR; Lex->dec= 0; } | CHAR_SYM opt_len opt_binary { $$=ITEM_CAST_CHAR; Lex->dec= 0; }
| NCHAR_SYM opt_len { $$=ITEM_CAST_CHAR; Lex->charset= national_charset_info; } | NCHAR_SYM opt_len { $$=ITEM_CAST_CHAR; Lex->charset= national_charset_info; Lex->dec=0; }
| SIGNED_SYM { $$=ITEM_CAST_SIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; } | SIGNED_SYM { $$=ITEM_CAST_SIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
| SIGNED_SYM INT_SYM { $$=ITEM_CAST_SIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; } | SIGNED_SYM INT_SYM { $$=ITEM_CAST_SIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }
| UNSIGNED { $$=ITEM_CAST_UNSIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; } | UNSIGNED { $$=ITEM_CAST_UNSIGNED_INT; Lex->charset= NULL; Lex->dec=Lex->length= (char*)0; }