From dc6a186659f83736141738424a1f4f287d4b5078 Mon Sep 17 00:00:00 2001 From: "wax@kishkin.ru" <> Date: Mon, 3 Jan 2005 18:37:08 +0500 Subject: [PATCH 01/31] WL#964 added sort of file names for all OS --- .bzrignore | 54 +++++++++++++++++++++++++++++++++ mysql-test/mysql_test_run_new.c | 37 +++++++++++----------- 2 files changed, 72 insertions(+), 19 deletions(-) diff --git a/.bzrignore b/.bzrignore index ee48342fd37..bfa4ef2058c 100644 --- a/.bzrignore +++ b/.bzrignore @@ -948,3 +948,57 @@ client/mysqladmin.c mysql-4.1.8-win-src.zip ndb/include/ndb_version.h ndb/include/ndb_global.h +mysql-test/mysql-test-run.log +mysql-test/r/alter_table.err +mysql-test/r/archive.err +mysql-test/r/bdb-alter-table-1.err +mysql-test/r/bdb-alter-table-2.err +mysql-test/r/bdb-crash.err +mysql-test/r/bdb-deadlock.err +mysql-test/r/bdb.err +mysql-test/r/bdb_cache.err +mysql-test/r/client_test.err +mysql-test/r/csv.err +mysql-test/r/ctype_ucs.err +mysql-test/r/derived.err +mysql-test/r/exampledb.err +mysql-test/r/func_encrypt.err +mysql-test/r/isam.err +mysql-test/r/lowercase_table2.err +mysql-test/r/multi_update.err +mysql-test/r/mysql_protocols.err +mysql-test/r/mysqlbinlog.err +mysql-test/r/mysqlbinlog2.err +mysql-test/r/mysqldump.err +mysql-test/r/mysqltest.err +mysql-test/r/ndb_alter_table.err +mysql-test/r/ndb_autodiscover.err +mysql-test/r/ndb_autodiscover2.err +mysql-test/r/ndb_basic.err +mysql-test/r/ndb_blob.err +mysql-test/r/ndb_cache.err +mysql-test/r/ndb_charset.err +mysql-test/r/ndb_index.err +mysql-test/r/ndb_index_ordered.err +mysql-test/r/ndb_index_unique.err +mysql-test/r/ndb_insert.err +mysql-test/r/ndb_limit.err +mysql-test/r/ndb_lock.err +mysql-test/r/ndb_minmax.err +mysql-test/r/ndb_replace.err +mysql-test/r/ndb_subquery.err +mysql-test/r/ndb_transaction.err +mysql-test/r/ndb_truncate.err +mysql-test/r/ndb_types.err +mysql-test/r/ndb_update.err +mysql-test/r/openssl_1.err +mysql-test/r/ps_1general.err +mysql-test/r/ps_6bdb.err +mysql-test/r/ps_7ndb.err +mysql-test/r/query_cache.err +mysql-test/r/query_cache_merge.err +mysql-test/r/raid.err +mysql-test/r/repair.err +mysql-test/r/replace.err +mysql-test/r/rpl000001.err +mysql-test/r/rpl000015.err diff --git a/mysql-test/mysql_test_run_new.c b/mysql-test/mysql_test_run_new.c index fe13d71c1c2..7b77fc5ced8 100644 --- a/mysql-test/mysql_test_run_new.c +++ b/mysql-test/mysql_test_run_new.c @@ -89,15 +89,15 @@ static char master_socket[FN_REFLEN]= "./var/tmp/master.sock"; static char slave_socket[FN_REFLEN]= "./var/tmp/slave.sock"; #endif +#define MAX_COUNT_TESTES 1024 /* comma delimited list of tests to skip or empty string */ #ifndef __WIN__ static char skip_test[FN_REFLEN]= " lowercase_table3 , system_mysql_db_fix "; +#define _stricmp strcasecmp #else /* The most ignore testes contain the calls of system command -*/ -#define MAX_COUNT_TESTES 1024 -/* + lowercase_table3 is disabled by Gerg system_mysql_db_fix is disabled by Gerg sp contains a command system @@ -1437,12 +1437,11 @@ void setup(char *file __attribute__((unused))) /* Compare names of testes for right order */ -#ifdef __WIN__ int compare( const void *arg1, const void *arg2 ) { return _stricmp( * ( char** ) arg1, * ( char** ) arg2 ); } -#endif + /****************************************************************************** @@ -1454,6 +1453,10 @@ int compare( const void *arg1, const void *arg2 ) int main(int argc, char **argv) { int is_ignore_list= 0; + char **names= 0; + char **testes= 0; + int name_index; + int index; /* setup */ setup(argv[0]); @@ -1517,6 +1520,9 @@ int main(int argc, char **argv) else { /* run all tests */ + names= malloc(MAX_COUNT_TESTES*4); + testes= names; + name_index= 0; #ifndef __WIN__ struct dirent *entry; DIR *parent; @@ -1536,8 +1542,11 @@ int main(int argc, char **argv) { /* null terminate at the suffix */ *(test + position - 1)= '\0'; - /* run test */ - run_test(test); + /* insert test */ + *names= malloc(FN_REFLEN); + strcpy(*names,test); + names++; + name_index++; } } closedir(parent); @@ -1549,10 +1558,6 @@ int main(int argc, char **argv) char mask[FN_REFLEN]; char *p; int position; - char **names= 0; - char **testes= 0; - int name_index; - int index; /* single test */ single_test= FALSE; @@ -1564,9 +1569,6 @@ int main(int argc, char **argv) die("Unable to open tests directory."); } - names= malloc(MAX_COUNT_TESTES*4); - testes= names; - name_index= 0; do { @@ -1577,10 +1579,8 @@ int main(int argc, char **argv) /* find the test suffix */ if ((position= strinstr(test, TEST_SUFFIX)) != 0) { - p= test + position - 1; /* null terminate at the suffix */ - *p= 0; - + *(test + position - 1)= '\0'; /* insert test */ *names= malloc(FN_REFLEN); strcpy(*names,test); @@ -1591,7 +1591,7 @@ int main(int argc, char **argv) }while (_findnext(handle,&dir) == 0); _findclose(handle); - +#endif qsort( (void *)testes, name_index, sizeof( char * ), compare ); for (index= 0; index <= name_index; index++) @@ -1601,7 +1601,6 @@ int main(int argc, char **argv) } free(testes); -#endif } /* stop server */ From 76d0f49495ea712054d07affd07f874c84934627 Mon Sep 17 00:00:00 2001 From: "ingo@mysql.com" <> Date: Mon, 3 Jan 2005 20:48:49 +0100 Subject: [PATCH 02/31] Fixed a typo. --- mysys/mf_keycaches.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mysys/mf_keycaches.c b/mysys/mf_keycaches.c index 8bf203e249f..fee3096de52 100644 --- a/mysys/mf_keycaches.c +++ b/mysys/mf_keycaches.c @@ -235,7 +235,7 @@ static my_bool safe_hash_set(SAFE_HASH *hash, const byte *key, uint length, if (my_hash_insert(&hash->hash, (byte*) entry)) { /* This can only happen if hash got out of memory */ - my_delete((char*) entry, MYF(0)); + my_free((char*) entry, MYF(0)); error= 1; goto end; } From 0f835244a6100ba573b166ce25ddd87b7d148dda Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Mon, 3 Jan 2005 23:02:26 +0100 Subject: [PATCH 03/31] Fix typo in crash-me 'MATCHES' test (Bug # 5875) --- sql-bench/crash-me.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql-bench/crash-me.sh b/sql-bench/crash-me.sh index 8ec62442b11..a40ef8fbc7d 100644 --- a/sql-bench/crash-me.sh +++ b/sql-bench/crash-me.sh @@ -1039,7 +1039,7 @@ try_and_report("Automatic row id", "automatic_rowid", ["MATCH UNIQUE","match_unique", "1 match unique (select a from crash_me)",1,0], ["MATCH","match","1 match (select a from crash_me)",1,0], - ["MATCHES","matches","b matcjhes 'a*'",1,0], + ["MATCHES","matches","b matches 'a*'",1,0], ["NOT BETWEEN","not_between","7 not between 4 and 6",1,0], ["NOT EXISTS","not_exists", "not exists (select * from crash_me where a = 2)",1,0], From 663396653ab5ebed874d7ec89daf6e8e86472c9e Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Tue, 4 Jan 2005 01:49:29 +0100 Subject: [PATCH 04/31] Use 'ps xaww' in mysqld_safe (on Linux) so whole command-line is searched for port and/or pid-file parameters. (Bug #5878) --- scripts/mysqld_safe.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/mysqld_safe.sh b/scripts/mysqld_safe.sh index 1f4d17f8885..270c08679eb 100644 --- a/scripts/mysqld_safe.sh +++ b/scripts/mysqld_safe.sh @@ -322,13 +322,13 @@ do # but should work for the rest of the servers. # The only thing is ps x => redhat 5 gives warnings when using ps -x. # kill -9 is used or the process won't react on the kill. - numofproces=`ps xa | grep -v "grep" | grep "$ledir/$MYSQLD\>" | grep -c "pid-file=$pid_file"` + numofproces=`ps xaww | grep -v "grep" | grep "$ledir/$MYSQLD\>" | grep -c "pid-file=$pid_file"` echo -e "\nNumber of processes running now: $numofproces" | tee -a $err_log I=1 while test "$I" -le "$numofproces" do - PROC=`ps xa | grep "$ledir/$MYSQLD\>" | grep -v "grep" | grep "pid-file=$pid_file" | sed -n '$p'` + PROC=`ps xaww | grep "$ledir/$MYSQLD\>" | grep -v "grep" | grep "pid-file=$pid_file" | sed -n '$p'` for T in $PROC do From 954d0181ec65595d887bd2953c0b8a4bbd228ef1 Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Tue, 4 Jan 2005 02:45:01 +0100 Subject: [PATCH 05/31] Make query_cache_wlock_invalidate visible in SHOW VARIABLES (Bug #7594) --- sql/set_var.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/sql/set_var.cc b/sql/set_var.cc index d5aadbfbdab..122daa0ea95 100644 --- a/sql/set_var.cc +++ b/sql/set_var.cc @@ -593,6 +593,8 @@ struct show_var_st init_vars[]= { {sys_query_cache_limit.name,(char*) &sys_query_cache_limit, SHOW_SYS}, {sys_query_cache_size.name, (char*) &sys_query_cache_size, SHOW_SYS}, {sys_query_cache_type.name, (char*) &sys_query_cache_type, SHOW_SYS}, + {sys_query_cache_wlock_invalidate.name, + (char*) &sys_query_cache_wlock_invalidate, SHOW_SYS}, #endif /* HAVE_QUERY_CACHE */ {sys_query_prealloc_size.name, (char*) &sys_query_prealloc_size, SHOW_SYS}, {sys_range_alloc_block_size.name, (char*) &sys_range_alloc_block_size, From 913f50576956b8b07c161f01aa09979c7dd34b64 Mon Sep 17 00:00:00 2001 From: "paul@kite-hub.kitebird.com" <> Date: Tue, 4 Jan 2005 10:32:42 -0600 Subject: [PATCH 06/31] client.c: Make multi-statements the preferred option name (to coincide with the renaming of the CLIENT_MULTI_RESULTS symbol to CLIENT_MULTI_STATEMENTS). Continue to allow multi-queries for backward compatibility. --- sql-common/client.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/sql-common/client.c b/sql-common/client.c index 87a781e0a0d..b6813ee4cfc 100644 --- a/sql-common/client.c +++ b/sql-common/client.c @@ -882,7 +882,7 @@ static const char *default_options[]= "connect-timeout", "local-infile", "disable-local-infile", "replication-probe", "enable-reads-from-master", "repl-parse-query", "ssl-cipher", "max-allowed-packet", "protocol", "shared-memory-base-name", - "multi-results", "multi-queries", "secure-auth", + "multi-results", "multi-statements", "multi-queries", "secure-auth", NullS }; @@ -1088,9 +1088,10 @@ void mysql_read_default_options(struct st_mysql_options *options, options->client_flag|= CLIENT_MULTI_RESULTS; break; case 31: + case 32: options->client_flag|= CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS; break; - case 32: /* secure-auth */ + case 33: /* secure-auth */ options->secure_auth= TRUE; break; default: From de85fdb78faa8531606e17aa2b2a15d55b5f2b5a Mon Sep 17 00:00:00 2001 From: "kent@mysql.com" <> Date: Tue, 4 Jan 2005 23:07:29 +0100 Subject: [PATCH 07/31] mysql_test_run_new.dsp: Link mysql_test_run_new as console application my_manage.c: The type intptr_t isn't defined for VC 6.0 Changed return type for CreateProcess() to bool mysql_test_run_new.c: The type intptr_t isn't defined for VC 6.0 mysqltest.dsp: Added regex to additional build types for mysqltest mysqldump.dsp: Added mysys.lib for linking mysqldump --- VC++Files/client/mysqldump.dsp | 12 ++++++------ VC++Files/client/mysqltest.dsp | 16 ++++++++-------- VC++Files/mysql-test/mysql_test_run_new.dsp | 4 ++-- mysql-test/my_manage.c | 10 +++++++++- mysql-test/mysql_test_run_new.c | 7 ++++++- 5 files changed, 31 insertions(+), 18 deletions(-) diff --git a/VC++Files/client/mysqldump.dsp b/VC++Files/client/mysqldump.dsp index a1ebdfe11a6..3c955639596 100644 --- a/VC++Files/client/mysqldump.dsp +++ b/VC++Files/client/mysqldump.dsp @@ -51,8 +51,8 @@ BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=xilink6.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 -# ADD LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"../client_release/mysqldump.exe" /libpath:"..\lib_release\\" +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib mysys.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib mysys.lib /nologo /subsystem:console /machine:I386 /out:"../client_release/mysqldump.exe" /libpath:"..\lib_release\\" !ELSEIF "$(CFG)" == "mysqldump - Win32 Debug" @@ -76,8 +76,8 @@ BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=xilink6.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept -# ADD LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no /debug /machine:I386 /out:"../client_debug/mysqldump.exe" /pdbtype:sept /libpath:"..\lib_debug\\" +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib mysys.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib mysys.lib /nologo /subsystem:console /incremental:no /debug /machine:I386 /out:"../client_debug/mysqldump.exe" /pdbtype:sept /libpath:"..\lib_debug\\" !ELSEIF "$(CFG)" == "mysqldump - Win32 classic" @@ -103,8 +103,8 @@ BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=xilink6.exe -# ADD BASE LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"../client_release/mysqldump.exe" /libpath:"..\lib_release\\" -# ADD LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"../client_classic/mysqldump.exe" /libpath:"..\lib_release\\" +# ADD BASE LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib mysys.lib /nologo /subsystem:console /machine:I386 /out:"../client_release/mysqldump.exe" /libpath:"..\lib_release\\" +# ADD LINK32 mysqlclient.lib wsock32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib mysys.lib /nologo /subsystem:console /machine:I386 /out:"../client_classic/mysqldump.exe" /libpath:"..\lib_release\\" !ENDIF diff --git a/VC++Files/client/mysqltest.dsp b/VC++Files/client/mysqltest.dsp index 1f1613026a9..d04dc5bfce8 100644 --- a/VC++Files/client/mysqltest.dsp +++ b/VC++Files/client/mysqltest.dsp @@ -67,8 +67,8 @@ LINK32=link.exe # PROP Output_Dir ".\classic" # PROP Intermediate_Dir ".\classic" # PROP Target_Dir "" -# ADD BASE CPP /nologo /MT /I "../include" /I "../" /W3 /Ob1 /G6 /D "_CONSOLE" /D "_WINDOWS" /D "LICENSE=Commercial" /D "DBUG_OFF" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\classic/mysqltest.pch" /Fo".\classic/" /Fd".\classic/" /c /GX -# ADD CPP /nologo /MT /I "../include" /I "../" /W3 /Ob1 /G6 /D "_CONSOLE" /D "_WINDOWS" /D "LICENSE=Commercial" /D "DBUG_OFF" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\classic/mysqltest.pch" /Fo".\classic/" /Fd".\classic/" /c /GX +# ADD BASE CPP /nologo /MT /I "../include" /I "../regex" /I "../" /W3 /Ob1 /G6 /D "_CONSOLE" /D "_WINDOWS" /D "LICENSE=Commercial" /D "DBUG_OFF" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\classic/mysqltest.pch" /Fo".\classic/" /Fd".\classic/" /c /GX +# ADD CPP /nologo /MT /I "../include" /I "../regex" /I "../" /W3 /Ob1 /G6 /D "_CONSOLE" /D "_WINDOWS" /D "LICENSE=Commercial" /D "DBUG_OFF" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\classic/mysqltest.pch" /Fo".\classic/" /Fd".\classic/" /c /GX # ADD BASE MTL /nologo /tlb".\classic\mysqltest.tlb" /win32 # ADD MTL /nologo /tlb".\classic\mysqltest.tlb" /win32 # ADD BASE RSC /l 1033 /d "NDEBUG" @@ -77,8 +77,8 @@ BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib /nologo /out:"..\client_classic\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\classic\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib /nologo /out:"..\client_classic\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\classic\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib mysys.lib regex.lib /nologo /out:"..\client_classic\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\classic\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib mysys.lib regex.lib /nologo /out:"..\client_classic\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\classic\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 !ELSEIF "$(CFG)" == "mysqltest - Win32 Release" @@ -92,8 +92,8 @@ LINK32=link.exe # PROP Output_Dir ".\release" # PROP Intermediate_Dir ".\release" # PROP Target_Dir "" -# ADD BASE CPP /nologo /MT /I "../include" /I "../" /W3 /Ob1 /G6 /D "DBUG_OFF" /D "_CONSOLE" /D "_WINDOWS" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\release/mysqltest.pch" /Fo".\release/" /Fd".\release/" /c /GX -# ADD CPP /nologo /MT /I "../include" /I "../" /W3 /Ob1 /G6 /D "DBUG_OFF" /D "_CONSOLE" /D "_WINDOWS" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\release/mysqltest.pch" /Fo".\release/" /Fd".\release/" /c /GX +# ADD BASE CPP /nologo /MT /I "../include" /I "../regex" /I "../" /W3 /Ob1 /G6 /D "DBUG_OFF" /D "_CONSOLE" /D "_WINDOWS" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\release/mysqltest.pch" /Fo".\release/" /Fd".\release/" /c /GX +# ADD CPP /nologo /MT /I "../include" /I "../regex" /I "../" /W3 /Ob1 /G6 /D "DBUG_OFF" /D "_CONSOLE" /D "_WINDOWS" /D "NDEBUG" /D "_MBCS" /GF /Gy /Fp".\release/mysqltest.pch" /Fo".\release/" /Fd".\release/" /c /GX # ADD BASE MTL /nologo /tlb".\release\mysqltest.tlb" /win32 # ADD MTL /nologo /tlb".\release\mysqltest.tlb" /win32 # ADD BASE RSC /l 1033 /d "NDEBUG" @@ -102,8 +102,8 @@ BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib /nologo /out:"..\client_release\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\release\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib /nologo /out:"..\client_release\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\release\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib mysys.lib regex.lib /nologo /out:"..\client_release\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\release\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib mysqlclient.lib wsock32.lib mysys.lib regex.lib /nologo /out:"..\client_release\mysqltest.exe" /incremental:no /libpath:"..\lib_release\" /pdb:".\release\mysqltest.pdb" /pdbtype:sept /subsystem:console /MACHINE:I386 !ENDIF diff --git a/VC++Files/mysql-test/mysql_test_run_new.dsp b/VC++Files/mysql-test/mysql_test_run_new.dsp index 7e43da20b26..61392b00b94 100644 --- a/VC++Files/mysql-test/mysql_test_run_new.dsp +++ b/VC++Files/mysql-test/mysql_test_run_new.dsp @@ -76,8 +76,8 @@ BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib Ws2_32.lib /nologo /out:"..\mysql-test\mysql_test_run_new.exe" /incremental:no /pdb:".\Release\mysql_test_run_new.pdb" /pdbtype:sept /subsystem:windows -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib Ws2_32.lib /nologo /out:"..\mysql-test\mysql_test_run_new.exe" /incremental:no /pdb:".\Release\mysql_test_run_new.pdb" /pdbtype:sept /subsystem:windows +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib Ws2_32.lib /nologo /out:"..\mysql-test\mysql_test_run_new.exe" /incremental:no /pdb:".\Release\mysql_test_run_new.pdb" /pdbtype:sept /subsystem:console +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib odbc32.lib odbccp32.lib Ws2_32.lib /nologo /out:"..\mysql-test\mysql_test_run_new.exe" /incremental:no /pdb:".\Release\mysql_test_run_new.pdb" /pdbtype:sept /subsystem:console !ENDIF diff --git a/mysql-test/my_manage.c b/mysql-test/my_manage.c index 472b0d32683..1f006f7ab90 100644 --- a/mysql-test/my_manage.c +++ b/mysql-test/my_manage.c @@ -327,7 +327,7 @@ int spawn(char *path, arg_list_t *al, int join, char *input, int spawn(char *path, arg_list_t *al, int join, char *input, char *output, char *error, HANDLE *pid) { - intptr_t result; + bool result; int i; STARTUPINFO startup_info; PROCESS_INFORMATION process_information; @@ -665,7 +665,11 @@ void del_tree(char *dir) rmdir(dir); #else struct _finddata_t parent; +#if defined(_MSC_VER) && _MSC_VER > 1200 intptr_t handle; +#else + long handle; +#endif /* _MSC_VER && _MSC_VER > 1200 */ char temp[FN_REFLEN]; char mask[FN_REFLEN]; @@ -728,7 +732,11 @@ int removef(const char *format, ...) va_list ap; char path[FN_REFLEN]; struct _finddata_t parent; +#if defined(_MSC_VER) && _MSC_VER > 1200 intptr_t handle; +#else + long handle; +#endif /* _MSC_VER && _MSC_VER > 1200 */ char temp[FN_REFLEN]; char *p; diff --git a/mysql-test/mysql_test_run_new.c b/mysql-test/mysql_test_run_new.c index fe13d71c1c2..3ffe7b28296 100644 --- a/mysql-test/mysql_test_run_new.c +++ b/mysql-test/mysql_test_run_new.c @@ -37,7 +37,8 @@ #include #endif #ifdef __WIN__ -#include +#include +#include #include #endif @@ -1544,7 +1545,11 @@ int main(int argc, char **argv) } #else struct _finddata_t dir; +#if defined(_MSC_VER) && _MSC_VER > 1200 intptr_t handle; +#else + long handle; +#endif /* _MSC_VER && _MSC_VER > 1200 */ char test[FN_LEN]; char mask[FN_REFLEN]; char *p; From 0ed892f1975a380066b4ac7cc38852021344dbbd Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Wed, 5 Jan 2005 01:08:45 +0100 Subject: [PATCH 08/31] Change mysqld_safe search for mysqld relative to the current working directory to only look for the mysqld binary (and english error strings) and assume the datadir from that. Then, if that datadir turns out to not exist, startup will fail. This avoids the behavior where mysqld_safe would go off and run a totally different binary because the data directory had been moved (even when --datadir was specified on the command line). (Bug #7249) --- scripts/mysqld_safe.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/mysqld_safe.sh b/scripts/mysqld_safe.sh index 270c08679eb..f6b0169d230 100644 --- a/scripts/mysqld_safe.sh +++ b/scripts/mysqld_safe.sh @@ -86,7 +86,7 @@ parse_arguments() { MY_PWD=`pwd` # Check if we are starting this relative (for the binary release) -if test -d $MY_PWD/data/mysql -a -f ./share/mysql/english/errmsg.sys -a \ +if test -f ./share/mysql/english/errmsg.sys -a \ -x ./bin/mysqld then MY_BASEDIR_VERSION=$MY_PWD # Where bin, share and data are @@ -97,7 +97,7 @@ then defaults="--defaults-extra-file=$MY_BASEDIR_VERSION/data/my.cnf" fi # Check if this is a 'moved install directory' -elif test -f ./var/mysql/db.frm -a -f ./share/mysql/english/errmsg.sys -a \ +elif test -f ./share/mysql/english/errmsg.sys -a \ -x ./libexec/mysqld then MY_BASEDIR_VERSION=$MY_PWD # Where libexec, share and var are From 30808e9ab993a98220cd96290ff49a4d6212cd10 Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Wed, 5 Jan 2005 02:04:12 +0100 Subject: [PATCH 09/31] Make sure to include ZLIB_LIBS in mysql_config --libs_r (Bug #7021) --- scripts/mysql_config.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/mysql_config.sh b/scripts/mysql_config.sh index 86cbe944416..79d8eef868b 100644 --- a/scripts/mysql_config.sh +++ b/scripts/mysql_config.sh @@ -88,7 +88,7 @@ client_libs='@CLIENT_LIBS@' libs="$ldflags -L$pkglibdir -lmysqlclient $client_libs" libs=`echo "$libs" | sed -e 's; \+; ;g' | sed -e 's;^ *;;' | sed -e 's; *\$;;'` -libs_r="$ldflags -L$pkglibdir -lmysqlclient_r @LIBS@ @openssl_libs@" +libs_r="$ldflags -L$pkglibdir -lmysqlclient_r @LIBS@ @ZLIB_LIBS@ @openssl_libs@" libs_r=`echo "$libs_r" | sed -e 's; \+; ;g' | sed -e 's;^ *;;' | sed -e 's; *\$;;'` cflags="-I$pkgincludedir @CFLAGS@ " #note: end space! include="-I$pkgincludedir" From d14f3d76752f311c6fe81ba808cf1131da517e29 Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Wed, 5 Jan 2005 03:43:37 +0100 Subject: [PATCH 10/31] Protect flags like -Wl,-O2 from being mangled by mysql_config (Bug #6964) (Second commit of this patch -- first included wrong changes.) --- scripts/mysql_config.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/mysql_config.sh b/scripts/mysql_config.sh index 86cbe944416..35ddbcac471 100644 --- a/scripts/mysql_config.sh +++ b/scripts/mysql_config.sh @@ -100,7 +100,7 @@ for remove in DDBUG_OFF DSAFEMALLOC USAFEMALLOC DSAFE_MUTEX \ DPEDANTIC_SAFEMALLOC DUNIV_MUST_NOT_INLINE DFORCE_INIT_OF_VARS \ DEXTRA_DEBUG DHAVE_purify 'O[0-9]' 'W[-A-Za-z]*' do - cflags=`echo "$cflags"|sed -e "s/-$remove *//g"` + cflags=`echo "$cflags"|sed -e "s/ -$remove */ /g"` done cflags=`echo "$cflags"|sed -e 's/ *\$//'` From 490d522408ddb4807def8641b8c216253a1c17f8 Mon Sep 17 00:00:00 2001 From: "serg@sergbook.mysql.com" <> Date: Wed, 5 Jan 2005 11:56:15 +0200 Subject: [PATCH 11/31] fix alignment issues --- sql/ha_federated.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sql/ha_federated.cc b/sql/ha_federated.cc index d7fb1950c0f..d4405e3e719 100755 --- a/sql/ha_federated.cc +++ b/sql/ha_federated.cc @@ -1522,7 +1522,7 @@ void ha_federated::position(const byte *record) { DBUG_ENTER("ha_federated::position"); //ha_store_ptr Add seek storage - *(MYSQL_ROW_OFFSET *)ref=current_position; + *(MYSQL_ROW_OFFSET *)ref=current_position; // ref is always aligned DBUG_VOID_RETURN; } @@ -1541,7 +1541,7 @@ int ha_federated::rnd_pos(byte * buf, byte *pos) { DBUG_ENTER("ha_federated::rnd_pos"); statistic_increment(table->in_use->status_var.ha_read_rnd_count,&LOCK_status); - current_position= *(MYSQL_ROW_OFFSET *)pos; + memcpy(current_position, pos, sizeof(MYSQL_ROW_OFFSET)); // pos is not aligned result->current_row= 0; result->data_cursor= current_position; DBUG_RETURN(rnd_next(buf)); From 795736fad60228c828adb7568bb0c2274824e5e9 Mon Sep 17 00:00:00 2001 From: "wax@kishkin.ru" <> Date: Wed, 5 Jan 2005 16:26:53 +0500 Subject: [PATCH 12/31] WL#964 _stricmp was replaved on sting_compare_func added breakes for windows --- mysql-test/mysql_test_run_new.c | 110 +++++++++++++++++++------------- 1 file changed, 67 insertions(+), 43 deletions(-) diff --git a/mysql-test/mysql_test_run_new.c b/mysql-test/mysql_test_run_new.c index 7b77fc5ced8..5f949015ee7 100644 --- a/mysql-test/mysql_test_run_new.c +++ b/mysql-test/mysql_test_run_new.c @@ -90,10 +90,20 @@ static char slave_socket[FN_REFLEN]= "./var/tmp/slave.sock"; #endif #define MAX_COUNT_TESTES 1024 + +#ifdef __WIN__ +# define sting_compare_func _stricmp +#else +# ifdef HAVE_STRCASECMP +# define sting_compare_func strcasecmp +# else +# define sting_compare_func strcmp +# endif +#endif + /* comma delimited list of tests to skip or empty string */ #ifndef __WIN__ static char skip_test[FN_REFLEN]= " lowercase_table3 , system_mysql_db_fix "; -#define _stricmp strcasecmp #else /* The most ignore testes contain the calls of system command @@ -1439,7 +1449,7 @@ void setup(char *file __attribute__((unused))) */ int compare( const void *arg1, const void *arg2 ) { - return _stricmp( * ( char** ) arg1, * ( char** ) arg2 ); + return sting_compare_func( * ( char** ) arg1, * ( char** ) arg2 ); } @@ -1520,7 +1530,9 @@ int main(int argc, char **argv) else { /* run all tests */ - names= malloc(MAX_COUNT_TESTES*4); + names= malloc(MAX_COUNT_TESTES*sizeof(void*)); + if (!names) + die("can not allcate memory for sorting"); testes= names; name_index= 0; #ifndef __WIN__ @@ -1540,57 +1552,69 @@ int main(int argc, char **argv) /* find the test suffix */ if ((position= strinstr(test, TEST_SUFFIX)) != 0) { - /* null terminate at the suffix */ - *(test + position - 1)= '\0'; - /* insert test */ - *names= malloc(FN_REFLEN); - strcpy(*names,test); - names++; - name_index++; + if (name_index < MAX_COUNT_TESTES) + { + /* null terminate at the suffix */ + *(test + position - 1)= '\0'; + /* insert test */ + *names= malloc(FN_REFLEN); + strcpy(*names,test); + names++; + name_index++; + } + else + die("can not sort files, array is overloaded"); } } closedir(parent); } #else - struct _finddata_t dir; - intptr_t handle; - char test[FN_LEN]; - char mask[FN_REFLEN]; - char *p; - int position; - - /* single test */ - single_test= FALSE; - - snprintf(mask,FN_REFLEN,"%s/*.test",test_dir); - - if ((handle=_findfirst(mask,&dir)) == -1L) { - die("Unable to open tests directory."); - } + struct _finddata_t dir; + int* handle; + char test[FN_LEN]; + char mask[FN_REFLEN]; + char *p; + int position; + /* single test */ + single_test= FALSE; - do - { - if (!(dir.attrib & _A_SUBDIR)) + snprintf(mask,FN_REFLEN,"%s/*.test",test_dir); + + if ((handle=_findfirst(mask,&dir)) == -1L) { - strcpy(test, strlwr(dir.name)); - - /* find the test suffix */ - if ((position= strinstr(test, TEST_SUFFIX)) != 0) - { - /* null terminate at the suffix */ - *(test + position - 1)= '\0'; - /* insert test */ - *names= malloc(FN_REFLEN); - strcpy(*names,test); - names++; - name_index++; - } + die("Unable to open tests directory."); } - }while (_findnext(handle,&dir) == 0); - _findclose(handle); + + do + { + if (!(dir.attrib & _A_SUBDIR)) + { + strcpy(test, strlwr(dir.name)); + + /* find the test suffix */ + if ((position= strinstr(test, TEST_SUFFIX)) != 0) + { + if (name_index < MAX_COUNT_TESTES) + { + /* null terminate at the suffix */ + *(test + position - 1)= '\0'; + /* insert test */ + *names= malloc(FN_REFLEN); + strcpy(*names,test); + names++; + name_index++; + } + else + die("can not sort files, array is overloaded"); + } + } + }while (_findnext(handle,&dir) == 0); + + _findclose(handle); + } #endif qsort( (void *)testes, name_index, sizeof( char * ), compare ); From 7a183dd3b1e545946f3afd288f2c45f321916a8c Mon Sep 17 00:00:00 2001 From: "serg@sergbook.mysql.com" <> Date: Wed, 5 Jan 2005 14:09:31 +0200 Subject: [PATCH 13/31] mysql-test/mysql-test-run.sh report test mode if case of failure (default/ps-protocol/embedded) --- mysql-test/mysql-test-run.sh | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/mysql-test/mysql-test-run.sh b/mysql-test/mysql-test-run.sh index 4c141e75baa..9684a880510 100644 --- a/mysql-test/mysql-test-run.sh +++ b/mysql-test/mysql-test-run.sh @@ -239,11 +239,12 @@ MYSQL_TEST_SSL_OPTS="" USE_TIMER="" USE_EMBEDDED_SERVER="" RESULT_EXT="" +TEST_MODE="default" while test $# -gt 0; do case "$1" in - --embedded-server) USE_EMBEDDED_SERVER=1 ; USE_MANAGER=0 ; NO_SLAVE=1 ; \ - USE_RUNNING_SERVER="" RESULT_EXT=".es" ;; + --embedded-server) USE_EMBEDDED_SERVER=1 USE_MANAGER=0 NO_SLAVE=1 ; \ + USE_RUNNING_SERVER="" RESULT_EXT=".es" TEST_MODE="embedded" ;; --user=*) DBUSER=`$ECHO "$1" | $SED -e "s;--user=;;"` ;; --force) FORCE=1 ;; --timer) USE_TIMER=1 ;; @@ -323,7 +324,7 @@ while test $# -gt 0; do SLEEP_TIME_AFTER_RESTART=`$ECHO "$1" | $SED -e "s;--sleep=;;"` ;; --ps-protocol) - EXTRA_MYSQL_TEST_OPT="$EXTRA_MYSQL_TEST_OPT $1" ;; + TEST_MODE="ps-protocol" EXTRA_MYSQL_TEST_OPT="$EXTRA_MYSQL_TEST_OPT $1" ;; --user-test=*) USER_TEST=`$ECHO "$1" | $SED -e "s;--user-test=;;"` ;; @@ -1561,7 +1562,7 @@ run_testcase () show_failed_diff $tname $ECHO if [ x$FORCE != x1 ] ; then - $ECHO "Aborting: $tname failed. To continue, re-run with '--force'." + $ECHO "Aborting: $tname failed in $TEST_MODE mode. To continue, re-run with '--force'." $ECHO if [ -z "$DO_GDB" ] && [ -z "$USE_RUNNING_SERVER" ] && \ [ -z "$DO_DDD" ] && [ -z "$USE_EMBEDDED_SERVER" ] @@ -1742,7 +1743,7 @@ $ECHO [ "$DO_GPROF" ] && gprof_collect # collect coverage information if [ $TOT_FAIL -ne 0 ]; then - $ECHO "mysql-test-run: *** Failing the test(s):$FAILED_CASES" + $ECHO "mysql-test-run in $TEST_MODE mode: *** Failing the test(s):$FAILED_CASES" $ECHO exit 1 else From 22639defce915ed0ca33654fa3b1d4517a44936c Mon Sep 17 00:00:00 2001 From: "wax@kishkin.ru" <> Date: Wed, 5 Jan 2005 17:14:29 +0500 Subject: [PATCH 14/31] replace position names and testes fixed bug --- mysql-test/mysql_test_run_new.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/mysql-test/mysql_test_run_new.c b/mysql-test/mysql_test_run_new.c index ecae0b6ad4d..bdebe912b97 100644 --- a/mysql-test/mysql_test_run_new.c +++ b/mysql-test/mysql_test_run_new.c @@ -1531,10 +1531,10 @@ int main(int argc, char **argv) else { /* run all tests */ - names= malloc(MAX_COUNT_TESTES*sizeof(void*)); - if (!names) + testes= malloc(MAX_COUNT_TESTES*sizeof(void*)); + if (!testes) die("can not allcate memory for sorting"); - testes= names; + names= testes; name_index= 0; #ifndef __WIN__ struct dirent *entry; @@ -1619,7 +1619,7 @@ int main(int argc, char **argv) #endif qsort( (void *)testes, name_index, sizeof( char * ), compare ); - for (index= 0; index <= name_index; index++) + for (index= 0; index < name_index; index++) { run_test(testes[index]); free(testes[index]); From 9fe6813a098e2165db61c0270137f465f069a2dd Mon Sep 17 00:00:00 2001 From: "kent@mysql.com" <> Date: Wed, 5 Jan 2005 16:35:43 +0100 Subject: [PATCH 15/31] my_sleep.c: On Windows my_sleep() always gave a zero microsecond sleep --- mysys/my_sleep.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/mysys/my_sleep.c b/mysys/my_sleep.c index 3de2d2abd13..31eaf7eeb96 100644 --- a/mysys/my_sleep.c +++ b/mysys/my_sleep.c @@ -23,6 +23,8 @@ void my_sleep(ulong m_seconds) { #ifdef __NETWARE__ delay(m_seconds/1000+1); +#elif defined(__WIN__) + Sleep(m_seconds/1000+1); /* Sleep() has millisecond arg */ #elif defined(OS2) DosSleep(m_seconds/1000+1); #elif defined(HAVE_SELECT) From c1593ecf6601fa93882af78100e48e42d19fafd7 Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Wed, 5 Jan 2005 19:02:17 +0100 Subject: [PATCH 16/31] Allow DEFAULT_THREAD_STACK to be set via -DDEFAULT_THREAD_STACK=... so our official binary builds for Linux that are built against a static glibc with a 128k thread stack size limit can be compiled with a default that doesn't result in a harmless (but oft-misunderstood) warning message. (Bug #6226) --- include/my_pthread.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/my_pthread.h b/include/my_pthread.h index 40302f48bd5..7620b46e08b 100644 --- a/include/my_pthread.h +++ b/include/my_pthread.h @@ -624,6 +624,7 @@ extern int pthread_dummy(int); /* All thread specific variables are in the following struct */ #define THREAD_NAME_SIZE 10 +#ifndef DEFAULT_THREAD_STACK #if defined(__ia64__) /* MySQL can survive with 32K, but some glibc libraries require > 128K stack @@ -633,6 +634,7 @@ extern int pthread_dummy(int); #else #define DEFAULT_THREAD_STACK (192*1024L) #endif +#endif struct st_my_thread_var { From 4d025523e57572901547479942998ad10d11ee87 Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Wed, 5 Jan 2005 21:56:18 +0100 Subject: [PATCH 17/31] Fix "mysqladmin password" to use correct password scrambling function when talking to pre-4.1 servers or 4.1 and later servers where the old_passwords option is enabled. "mysqladmin old-password" is unchanged. (Bug #7451) --- client/mysqladmin.cc | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/client/mysqladmin.cc b/client/mysqladmin.cc index 2e8b3cd588a..6916b4ea808 100644 --- a/client/mysqladmin.cc +++ b/client/mysqladmin.cc @@ -826,13 +826,39 @@ static int execute_commands(MYSQL *mysql,int argc, char **argv) if (argv[1][0]) { char *pw= argv[1]; + bool old= find_type(argv[0], &command_typelib, 2) == ADMIN_OLD_PASSWORD; #ifdef __WIN__ uint pw_len= strlen(pw); if (pw_len > 1 && pw[0] == '\'' && pw[pw_len-1] == '\'') printf("Warning: single quotes were not trimmed from the password by" " your command\nline client, as you might have expected.\n"); #endif - if (find_type(argv[0], &command_typelib, 2) == ADMIN_OLD_PASSWORD) + /* + If we don't already know to use an old-style password, see what + the server is using + */ + if (!old) { + if (mysql_query(mysql, "SHOW VARIABLES LIKE 'old_passwords'")) { + my_printf_error(0, "Could not determine old_passwords setting from server; error: '%s'", + MYF(ME_BELL),mysql_error(mysql)); + return -1; + } else { + MYSQL_RES *res= mysql_store_result(mysql); + if (!res) { + my_printf_error(0, "Could not get old_passwords setting from server; error: '%s'", + MYF(ME_BELL),mysql_error(mysql)); + return -1; + } + if (!mysql_num_rows(res)) { + old= 1; + } else { + MYSQL_ROW row= mysql_fetch_row(res); + old= !strncmp(row[1], "ON", 2); + } + mysql_free_result(res); + } + } + if (old) make_scrambled_password_323(crypted_pw, pw); else make_scrambled_password(crypted_pw, pw); From 9971b2f0f582ef3c744000a28421f1945609a89c Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Thu, 6 Jan 2005 01:08:03 +0100 Subject: [PATCH 18/31] Add support for --default-character-set to mysqladmin (Bug #7524) --- client/mysqladmin.cc | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/client/mysqladmin.cc b/client/mysqladmin.cc index 2e8b3cd588a..ae92765dfdf 100644 --- a/client/mysqladmin.cc +++ b/client/mysqladmin.cc @@ -33,7 +33,8 @@ #define SHUTDOWN_DEF_TIMEOUT 3600 /* Wait for shutdown */ #define MAX_TRUNC_LENGTH 3 -char *host= NULL, *user= 0, *opt_password= 0; +char *host= NULL, *user= 0, *opt_password= 0, + *default_charset= NULL; char truncated_var_names[MAX_MYSQL_VAR][MAX_TRUNC_LENGTH]; char ex_var_names[MAX_MYSQL_VAR][FN_REFLEN]; ulonglong last_values[MAX_MYSQL_VAR]; @@ -145,6 +146,9 @@ static struct my_option my_long_options[] = {"character-sets-dir", OPT_CHARSETS_DIR, "Directory where character sets are.", (gptr*) &charsets_dir, (gptr*) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, + {"default-character-set", OPT_DEFAULT_CHARSET, + "Set the default character set.", (gptr*) &default_charset, + (gptr*) &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0}, {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}, {"host", 'h', "Connect to host.", (gptr*) &host, (gptr*) &host, 0, GET_STR, @@ -343,6 +347,8 @@ int main(int argc,char *argv[]) if (shared_memory_base_name) mysql_options(&mysql,MYSQL_SHARED_MEMORY_BASE_NAME,shared_memory_base_name); #endif + if (default_charset) + mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, default_charset); if (sql_connect(&mysql, option_wait)) { unsigned int err= mysql_errno(&mysql); From 746fd9fdacc52ccc297db7703ea9288b67138167 Mon Sep 17 00:00:00 2001 From: "heikki@hundin.mysql.fi" <> Date: Thu, 6 Jan 2005 11:19:20 +0200 Subject: [PATCH 19/31] os0file.c: Use the fcntl() file flush method on OS X; Apple disabled fsync() for internal disk drives, which caused corruption in power outages; the patch was recommended by an Apple engineer --- innobase/os/os0file.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/innobase/os/os0file.c b/innobase/os/os0file.c index aa45030d93b..f02b81b8fd8 100644 --- a/innobase/os/os0file.c +++ b/innobase/os/os0file.c @@ -1763,7 +1763,21 @@ os_file_flush( #else int ret; -#ifdef HAVE_FDATASYNC +#ifdef HAVE_DARWIN_THREADS + /* Apple has disabled fsync() for internal disk drives in OS X. That + caused corruption for a user when he tested a power outage. Let us in + OS X use a nonstandard flush method recommended by an Apple + engineer. */ + + ret = fcntl(file, F_FULLFSYNC, NULL); + + if (ret) { + /* If we are not on a file system that supports this, then + fall back to a plain fsync. */ + + ret = fsync(file); + } +#elif HAVE_FDATASYNC ret = fdatasync(file); #else /* fprintf(stderr, "Flushing to file %p\n", file); */ From d35140a851e0eccc013f18bee7dee45c4f32d774 Mon Sep 17 00:00:00 2001 From: "monty@mysql.com" <> Date: Thu, 6 Jan 2005 13:00:13 +0200 Subject: [PATCH 20/31] First stage of table definition cache Split TABLE to TABLE and TABLE_SHARE (TABLE_SHARE is still allocated as part of table, will be fixed soon) Created Field::make_field() and made Field_num::make_field() to call this Added 'TABLE_SHARE->db' that points to database name; Changed all usage of table_cache_key as database name to use this instead Changed field->table_name to point to pointer to alias. This allows us to change alias for a table by just updating one pointer. Renamed TABLE_SHARE->real_name to table_name Renamed TABLE->table_name to alias Renamed TABLE_LIST->real_name to table_name --- include/myisam.h | 4 +- mysql-test/r/group_min_max.result | 2 +- mysql-test/t/group_min_max.test | 1 + sql/field.cc | 72 ++---- sql/field.h | 14 +- sql/field_conv.cc | 18 +- sql/filesort.cc | 4 +- sql/ha_berkeley.cc | 139 ++++++----- sql/ha_heap.cc | 37 +-- sql/ha_innodb.cc | 56 ++--- sql/ha_myisam.cc | 220 +++++++++-------- sql/ha_myisammrg.cc | 41 ++-- sql/ha_ndbcluster.cc | 104 ++++---- sql/handler.cc | 28 +-- sql/item.cc | 29 ++- sql/item_func.cc | 2 +- sql/item_subselect.cc | 4 +- sql/item_sum.cc | 20 +- sql/key.cc | 12 +- sql/lock.cc | 17 +- sql/log_event.cc | 6 +- sql/mysql_priv.h | 4 +- sql/opt_range.cc | 78 +++--- sql/opt_sum.cc | 2 +- sql/records.cc | 37 ++- sql/repl_failsafe.cc | 2 +- sql/slave.cc | 6 +- sql/sp.cc | 28 +-- sql/sp_head.cc | 4 +- sql/sql_acl.cc | 146 ++++++----- sql/sql_acl.h | 4 +- sql/sql_base.cc | 330 +++++++++++++------------ sql/sql_cache.cc | 38 +-- sql/sql_class.cc | 2 +- sql/sql_db.cc | 4 +- sql/sql_delete.cc | 24 +- sql/sql_derived.cc | 6 +- sql/sql_handler.cc | 48 ++-- sql/sql_help.cc | 12 +- sql/sql_insert.cc | 92 +++---- sql/sql_load.cc | 6 +- sql/sql_parse.cc | 52 ++-- sql/sql_rename.cc | 4 +- sql/sql_select.cc | 205 ++++++++-------- sql/sql_show.cc | 182 +++++++------- sql/sql_table.cc | 133 +++++----- sql/sql_test.cc | 20 +- sql/sql_trigger.cc | 10 +- sql/sql_udf.cc | 12 +- sql/sql_union.cc | 2 +- sql/sql_update.cc | 34 +-- sql/sql_view.cc | 42 ++-- sql/table.cc | 388 +++++++++++++++--------------- sql/table.h | 205 +++++++++------- sql/tztime.cc | 10 +- sql/unireg.cc | 5 +- sql/unireg.h | 10 +- 57 files changed, 1542 insertions(+), 1475 deletions(-) diff --git a/include/myisam.h b/include/myisam.h index fd75af2d997..e0eb8715aef 100644 --- a/include/myisam.h +++ b/include/myisam.h @@ -340,8 +340,8 @@ typedef struct st_mi_check_param ha_checksum key_crc[MI_MAX_POSSIBLE_KEY]; ulong rec_per_key_part[MI_MAX_KEY_SEG*MI_MAX_POSSIBLE_KEY]; void *thd; - char *db_name,*table_name; - char *op_name; + const char *db_name, *table_name; + const char *op_name; } MI_CHECK; typedef struct st_sort_ft_buf diff --git a/mysql-test/r/group_min_max.result b/mysql-test/r/group_min_max.result index 006e7052376..c7be93b0fd7 100644 --- a/mysql-test/r/group_min_max.result +++ b/mysql-test/r/group_min_max.result @@ -148,7 +148,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 range NULL idx_t1_1 147 NULL 17 Using index for group-by explain select a1,a2,b,max(c),min(c) from t2 group by a1,a2,b; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t2 range NULL idx_t2_1 163 NULL 21 Using index for group-by +1 SIMPLE t2 range NULL idx_t2_1 # NULL 21 Using index for group-by explain select min(a2), a1, max(a2), min(a2), a1 from t1 group by a1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 range NULL idx_t1_1 65 NULL 5 Using index for group-by diff --git a/mysql-test/t/group_min_max.test b/mysql-test/t/group_min_max.test index 17a6cc88597..b42125566d5 100644 --- a/mysql-test/t/group_min_max.test +++ b/mysql-test/t/group_min_max.test @@ -174,6 +174,7 @@ explain select a1, max(a2) from t1 group by a1; explain select a1, min(a2), max(a2) from t1 group by a1; explain select a1, a2, b, min(c), max(c) from t1 group by a1,a2,b; explain select a1,a2,b,max(c),min(c) from t1 group by a1,a2,b; +--replace_column 7 # explain select a1,a2,b,max(c),min(c) from t2 group by a1,a2,b; -- Select fields in different order explain select min(a2), a1, max(a2), min(a2), a1 from t1 group by a1; diff --git a/sql/field.cc b/sql/field.cc index a270f102cd5..d15db92e51f 100644 --- a/sql/field.cc +++ b/sql/field.cc @@ -351,10 +351,8 @@ String *Field::val_int_as_str(String *val_buffer, my_bool unsigned_flag) } -/**************************************************************************** -** Functions for the base classes -** This is an unpacked number. -****************************************************************************/ +/* This is used as a table name when the table structure is not set up */ +const char *unknown_table_name= 0; Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, uchar null_bit_arg, @@ -362,7 +360,7 @@ Field::Field(char *ptr_arg,uint32 length_arg,uchar *null_ptr_arg, struct st_table *table_arg) :ptr(ptr_arg),null_ptr(null_ptr_arg), table(table_arg),orig_table(table_arg), - table_name(table_arg ? table_arg->table_name : 0), + table_name(table_arg ? &table_arg->alias : &unknown_table_name), field_name(field_name_arg), query_id(0), key_start(0), part_of_key(0), part_of_sortkey(0), unireg_check(unireg_check_arg), @@ -407,35 +405,24 @@ void Field_num::add_zerofill_and_unsigned(String &res) const res.append(" zerofill"); } -void Field_num::make_field(Send_field *field) +void Field::make_field(Send_field *field) { - /* table_cache_key is not set for temp tables */ - field->db_name= (orig_table->table_cache_key ? orig_table->table_cache_key : - ""); - field->org_table_name= orig_table->real_name; - field->table_name= orig_table->table_name; - field->col_name=field->org_col_name=field_name; + field->db_name= orig_table->s->table_cache_key; + field->org_table_name= orig_table->s->table_name; + field->table_name= orig_table->alias; + field->col_name= field->org_col_name= field_name; field->charsetnr= charset()->number; field->length=field_length; field->type=type(); field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags; - field->decimals=dec; + field->decimals= 0; } -void Field_str::make_field(Send_field *field) +void Field_num::make_field(Send_field *field) { - /* table_cache_key is not set for temp tables */ - field->db_name= (orig_table->table_cache_key ? orig_table->table_cache_key : - ""); - field->org_table_name= orig_table->real_name; - field->table_name= orig_table->table_name; - field->col_name=field->org_col_name=field_name; - field->charsetnr= charset()->number; - field->length=field_length; - field->type=type(); - field->flags=table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags; - field->decimals=0; + Field::make_field(field); + field->decimals= dec; } @@ -448,7 +435,7 @@ uint Field::fill_cache_field(CACHE_FIELD *copy) { copy->blob_field=(Field_blob*) this; copy->strip=0; - copy->length-=table->blob_ptr_size; + copy->length-= table->s->blob_ptr_size; return copy->length; } else if (!zero_pack() && @@ -5189,7 +5176,7 @@ Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg, { flags|= BLOB_FLAG; if (table) - table->blob_fields++; + table->s->blob_fields++; } @@ -6295,22 +6282,6 @@ Field *Field_bit::new_key_field(MEM_ROOT *root, } -void Field_bit::make_field(Send_field *field) -{ - /* table_cache_key is not set for temp tables */ - field->db_name= (orig_table->table_cache_key ? orig_table->table_cache_key : - ""); - field->org_table_name= orig_table->real_name; - field->table_name= orig_table->table_name; - field->col_name= field->org_col_name= field_name; - field->charsetnr= charset()->number; - field->length= field_length; - field->type= type(); - field->flags= table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags; - field->decimals= 0; -} - - int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs) { int delta; @@ -6776,7 +6747,7 @@ create_field::create_field(Field *old_field,Field *orig_field) /* Fix if the original table had 4 byte pointer blobs */ if (flags & BLOB_FLAG) - pack_length= (pack_length- old_field->table->blob_ptr_size + + pack_length= (pack_length- old_field->table->s->blob_ptr_size + portable_sizeof_char_ptr); switch (sql_type) { @@ -6824,19 +6795,20 @@ create_field::create_field(Field *old_field,Field *orig_field) old_field->ptr && orig_field) { char buff[MAX_FIELD_WIDTH],*pos; - String tmp(buff,sizeof(buff), charset); + String tmp(buff,sizeof(buff), charset), *res; + my_ptrdiff_t diff; /* Get the value from default_values */ - my_ptrdiff_t diff= (my_ptrdiff_t) (orig_field->table->rec_buff_length*2); + diff= (my_ptrdiff_t) (orig_field->table->s->default_values- + orig_field->table->record[0]); orig_field->move_field(diff); // Points now at default_values bool is_null=orig_field->is_real_null(); - orig_field->val_str(&tmp); + res= orig_field->val_str(&tmp); orig_field->move_field(-diff); // Back to record[0] if (!is_null) { - pos= (char*) sql_memdup(tmp.ptr(),tmp.length()+1); - pos[tmp.length()]=0; - def= new Item_string(pos, tmp.length(), charset); + pos= (char*) sql_strmake(res->ptr(), res->length()); + def= new Item_string(pos, res->length(), charset); } } } diff --git a/sql/field.h b/sql/field.h index 9375fbc8d5a..9e690705801 100644 --- a/sql/field.h +++ b/sql/field.h @@ -47,7 +47,7 @@ public: */ struct st_table *table; // Pointer for table struct st_table *orig_table; // Pointer to original table - const char *table_name,*field_name; + const char **table_name, *field_name; LEX_STRING comment; ulong query_id; // For quick test of used fields /* Field is part of the following keys */ @@ -127,7 +127,7 @@ public: virtual void reset_fields() {} virtual void set_default() { - my_ptrdiff_t offset = (my_ptrdiff_t) (table->default_values - + my_ptrdiff_t offset = (my_ptrdiff_t) (table->s->default_values - table->record[0]); memcpy(ptr, ptr + offset, pack_length()); if (null_ptr) @@ -176,7 +176,7 @@ public: { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; } inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; } inline bool real_maybe_null(void) { return null_ptr != 0; } - virtual void make_field(Send_field *)=0; + virtual void make_field(Send_field *); virtual void sort_string(char *buff,uint length)=0; virtual bool optimize_range(uint idx, uint part); /* @@ -355,7 +355,6 @@ public: int store(double nr); int store(longlong nr)=0; int store(const char *to,uint length,CHARSET_INFO *cs)=0; - void make_field(Send_field *); uint size_of() const { return sizeof(*this); } CHARSET_INFO *charset(void) const { return field_charset; } void set_charset(CHARSET_INFO *charset) { field_charset=charset; } @@ -906,9 +905,9 @@ public: enum_field_types type() const { return ((orig_table && - orig_table->db_create_options & HA_OPTION_PACK_RECORD && + orig_table->s->db_create_options & HA_OPTION_PACK_RECORD && field_length >= 4) && - orig_table->frm_version < FRM_VER_TRUE_VARCHAR ? + orig_table->s->frm_version < FRM_VER_TRUE_VARCHAR ? MYSQL_TYPE_VAR_STRING : MYSQL_TYPE_STRING); } enum ha_base_keytype key_type() const @@ -1038,7 +1037,7 @@ public: uint32 key_length() const { return 0; } void sort_string(char *buff,uint length); uint32 pack_length() const - { return (uint32) (packlength+table->blob_ptr_size); } + { return (uint32) (packlength+table->s->blob_ptr_size); } inline uint32 max_data_length() const { return (uint32) (((ulonglong) 1 << (packlength*8)) -1); @@ -1212,7 +1211,6 @@ public: uint32 max_length() { return (uint32) field_length + (bit_len > 0); } uint size_of() const { return sizeof(*this); } Item_result result_type () const { return INT_RESULT; } - void make_field(Send_field *); void reset(void) { bzero(ptr, field_length); } int store(const char *to, uint length, CHARSET_INFO *charset); int store(double nr); diff --git a/sql/field_conv.cc b/sql/field_conv.cc index 9fd4f0228b3..b337ccd6306 100644 --- a/sql/field_conv.cc +++ b/sql/field_conv.cc @@ -487,16 +487,17 @@ void Copy_field::set(Field *to,Field *from,bool save) void (*Copy_field::get_copy_func(Field *to,Field *from))(Copy_field*) { + bool compatible_db_low_byte_first= (to->table->s->db_low_byte_first == + from->table->s->db_low_byte_first); if (to->flags & BLOB_FLAG) { if (!(from->flags & BLOB_FLAG) || from->charset() != to->charset()) return do_conv_blob; - if (from_length != to_length || - to->table->db_low_byte_first != from->table->db_low_byte_first) + if (from_length != to_length || !compatible_db_low_byte_first) { // Correct pointer to point at char pointer - to_ptr+=to_length - to->table->blob_ptr_size; - from_ptr+=from_length- from->table->blob_ptr_size; + to_ptr+= to_length - to->table->s->blob_ptr_size; + from_ptr+= from_length- from->table->s->blob_ptr_size; return do_copy_blob; } } @@ -509,7 +510,7 @@ void (*Copy_field::get_copy_func(Field *to,Field *from))(Copy_field*) if (from->result_type() == STRING_RESULT) { if (to->real_type() != from->real_type() || - to->table->db_low_byte_first != from->table->db_low_byte_first) + !compatible_db_low_byte_first) { if (from->real_type() == FIELD_TYPE_ENUM || from->real_type() == FIELD_TYPE_SET) @@ -541,7 +542,7 @@ void (*Copy_field::get_copy_func(Field *to,Field *from))(Copy_field*) } else if (to->real_type() != from->real_type() || to_length != from_length || - to->table->db_low_byte_first != from->table->db_low_byte_first) + !compatible_db_low_byte_first) { if (to->real_type() == FIELD_TYPE_DECIMAL || to->result_type() == STRING_RESULT) @@ -552,8 +553,7 @@ void (*Copy_field::get_copy_func(Field *to,Field *from))(Copy_field*) } else { - if (!to->eq_def(from) || - to->table->db_low_byte_first != from->table->db_low_byte_first) + if (!to->eq_def(from) || !compatible_db_low_byte_first) { if (to->real_type() == FIELD_TYPE_DECIMAL) return do_field_string; @@ -587,7 +587,7 @@ void field_conv(Field *to,Field *from) to->real_type() != FIELD_TYPE_ENUM && to->real_type() != FIELD_TYPE_SET && from->charset() == to->charset() && - to->table->db_low_byte_first == from->table->db_low_byte_first) + to->table->s->db_low_byte_first == from->table->s->db_low_byte_first) { // Identical fields memcpy(to->ptr,from->ptr,to->pack_length()); return; diff --git a/sql/filesort.cc b/sql/filesort.cc index 569ae3da357..41104106048 100644 --- a/sql/filesort.cc +++ b/sql/filesort.cc @@ -127,7 +127,7 @@ ha_rows filesort(THD *thd, TABLE *table, SORT_FIELD *sortorder, uint s_length, param.ref_length= table->file->ref_length; param.addon_field= 0; param.addon_length= 0; - if (!(table->tmp_table || table->fulltext_searched)) + if (!(table->s->tmp_table || table->fulltext_searched)) { /* Get the descriptors of all fields whose values are appended @@ -466,7 +466,7 @@ static ha_rows find_all_keys(SORTPARAM *param, SQL_SELECT *select, if (!flag) { my_store_ptr(ref_pos,ref_length,record); // Position to row - record+=sort_form->db_record_offset; + record+= sort_form->s->db_record_offset; } else file->position(sort_form->record[0]); diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc index 322126ff47b..fe266fdbf14 100644 --- a/sql/ha_berkeley.cc +++ b/sql/ha_berkeley.cc @@ -490,14 +490,16 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) { char name_buff[FN_REFLEN]; uint open_mode=(mode == O_RDONLY ? DB_RDONLY : 0) | DB_THREAD; + uint max_key_length; int error; + TABLE_SHARE *table_share= table->s; DBUG_ENTER("ha_berkeley::open"); /* Open primary key */ hidden_primary_key=0; - if ((primary_key=table->primary_key) >= MAX_KEY) + if ((primary_key= table_share->primary_key) >= MAX_KEY) { // No primary key - primary_key=table->keys; + primary_key= table_share->keys; key_used_on_scan=MAX_KEY; ref_length=hidden_primary_key=BDB_HIDDEN_PRIMARY_KEY_LENGTH; } @@ -505,18 +507,18 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) key_used_on_scan=primary_key; /* Need some extra memory in case of packed keys */ - uint max_key_length= table->max_key_length + MAX_REF_PARTS*3; + max_key_length= table_share->max_key_length + MAX_REF_PARTS*3; if (!(alloc_ptr= my_multi_malloc(MYF(MY_WME), &key_buff, max_key_length, &key_buff2, max_key_length, &primary_key_buff, (hidden_primary_key ? 0 : - table->key_info[table->primary_key].key_length), + table->key_info[table_share->primary_key].key_length), NullS))) DBUG_RETURN(1); /* purecov: inspected */ if (!(rec_buff= (byte*) my_malloc((alloced_rec_buff_length= - table->rec_buff_length), + table_share->rec_buff_length), MYF(MY_WME)))) { my_free(alloc_ptr,MYF(0)); /* purecov: inspected */ @@ -524,7 +526,7 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) } /* Init shared structure */ - if (!(share=get_share(name,table))) + if (!(share= get_share(name,table))) { my_free((char*) rec_buff,MYF(0)); /* purecov: inspected */ my_free(alloc_ptr,MYF(0)); /* purecov: inspected */ @@ -537,7 +539,7 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) /* Fill in shared structure, if needed */ pthread_mutex_lock(&share->mutex); - file = share->file; + file= share->file; if (!share->use_count++) { if ((error=db_create(&file, db_env, 0))) @@ -548,13 +550,13 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) my_errno=error; /* purecov: inspected */ DBUG_RETURN(1); /* purecov: inspected */ } - share->file = file; + share->file= file; file->set_bt_compare(file, (hidden_primary_key ? berkeley_cmp_hidden_key : berkeley_cmp_packed_key)); if (!hidden_primary_key) - file->app_private= (void*) (table->key_info+table->primary_key); + file->app_private= (void*) (table->key_info + table_share->primary_key); if ((error= txn_begin(db_env, 0, (DB_TXN**) &transaction, 0)) || (error= (file->open(file, transaction, fn_format(name_buff, name, "", ha_berkeley_ext, @@ -562,7 +564,7 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) "main", DB_BTREE, open_mode, 0))) || (error= transaction->commit(transaction, 0))) { - free_share(share,table, hidden_primary_key,1); /* purecov: inspected */ + free_share(share, table, hidden_primary_key,1); /* purecov: inspected */ my_free((char*) rec_buff,MYF(0)); /* purecov: inspected */ my_free(alloc_ptr,MYF(0)); /* purecov: inspected */ my_errno=error; /* purecov: inspected */ @@ -574,7 +576,7 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) key_type[primary_key]=DB_NOOVERWRITE; DB **ptr=key_file; - for (uint i=0, used_keys=0; i < table->keys ; i++, ptr++) + for (uint i=0, used_keys=0; i < table_share->keys ; i++, ptr++) { char part[7]; if (i != primary_key) @@ -606,7 +608,7 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) } } /* Calculate pack_length of primary key */ - share->fixed_length_primary_key=1; + share->fixed_length_primary_key= 1; if (!hidden_primary_key) { ref_length=0; @@ -616,18 +618,19 @@ int ha_berkeley::open(const char *name, int mode, uint test_if_locked) ref_length+= key_part->field->max_packed_col_length(key_part->length); share->fixed_length_primary_key= (ref_length == table->key_info[primary_key].key_length); - share->status|=STATUS_PRIMARY_KEY_INIT; + share->status|= STATUS_PRIMARY_KEY_INIT; } - share->ref_length=ref_length; + share->ref_length= ref_length; } - ref_length=share->ref_length; // If second open + ref_length= share->ref_length; // If second open pthread_mutex_unlock(&share->mutex); transaction=0; cursor=0; key_read=0; block_size=8192; // Berkeley DB block size - share->fixed_length_row=!(table->db_create_options & HA_OPTION_PACK_RECORD); + share->fixed_length_row= !(table_share->db_create_options & + HA_OPTION_PACK_RECORD); get_status(); info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST); @@ -667,9 +670,15 @@ bool ha_berkeley::fix_rec_buff_for_blob(ulong length) ulong ha_berkeley::max_row_length(const byte *buf) { - ulong length=table->reclength + table->fields*2; - for (Field_blob **ptr=table->blob_field ; *ptr ; ptr++) - length+= (*ptr)->get_length((char*) buf+(*ptr)->offset())+2; + ulong length= table->s->reclength + table->s->fields*2; + uint *ptr, *end; + for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ; + ptr != end ; + ptr++) + { + Field_blob *blob= ((Field_blob*) table->field[*ptr]); + length+= blob->get_length((char*) buf + blob->offset())+2; + } return length; } @@ -685,29 +694,30 @@ ulong ha_berkeley::max_row_length(const byte *buf) int ha_berkeley::pack_row(DBT *row, const byte *record, bool new_row) { + byte *ptr; bzero((char*) row,sizeof(*row)); if (share->fixed_length_row) { row->data=(void*) record; - row->size=table->reclength+hidden_primary_key; + row->size= table->s->reclength+hidden_primary_key; if (hidden_primary_key) { if (new_row) get_auto_primary_key(current_ident); - memcpy_fixed((char*) record+table->reclength, (char*) current_ident, + memcpy_fixed((char*) record+table->s->reclength, (char*) current_ident, BDB_HIDDEN_PRIMARY_KEY_LENGTH); } return 0; } - if (table->blob_fields) + if (table->s->blob_fields) { if (fix_rec_buff_for_blob(max_row_length(record))) return HA_ERR_OUT_OF_MEM; /* purecov: inspected */ } /* Copy null bits */ - memcpy(rec_buff, record, table->null_bytes); - byte *ptr=rec_buff + table->null_bytes; + memcpy(rec_buff, record, table->s->null_bytes); + ptr= rec_buff + table->s->null_bytes; for (Field **field=table->field ; *field ; field++) ptr=(byte*) (*field)->pack((char*) ptr, @@ -730,13 +740,13 @@ int ha_berkeley::pack_row(DBT *row, const byte *record, bool new_row) void ha_berkeley::unpack_row(char *record, DBT *row) { if (share->fixed_length_row) - memcpy(record,(char*) row->data,table->reclength+hidden_primary_key); + memcpy(record,(char*) row->data,table->s->reclength+hidden_primary_key); else { /* Copy null bits */ const char *ptr= (const char*) row->data; - memcpy(record, ptr, table->null_bytes); - ptr+=table->null_bytes; + memcpy(record, ptr, table->s->null_bytes); + ptr+= table->s->null_bytes; for (Field **field=table->field ; *field ; field++) ptr= (*field)->unpack(record + (*field)->offset(), ptr); } @@ -882,7 +892,7 @@ int ha_berkeley::write_row(byte * record) DBUG_RETURN(error); /* purecov: inspected */ table->insert_or_update= 1; // For handling of VARCHAR - if (table->keys + test(hidden_primary_key) == 1) + if (table->s->keys + test(hidden_primary_key) == 1) { error=file->put(file, transaction, create_key(&prim_key, primary_key, key_buff, record), @@ -893,7 +903,8 @@ int ha_berkeley::write_row(byte * record) { DB_TXN *sub_trans = transaction; /* Don't use sub transactions in temporary tables */ - ulong thd_options = table->tmp_table == NO_TMP_TABLE ? table->in_use->options : 0; + ulong thd_options= (table->s->tmp_table == NO_TMP_TABLE ? + table->in_use->options : 0); for (uint retry=0 ; retry < berkeley_trans_retry ; retry++) { key_map changed_keys(0); @@ -908,7 +919,7 @@ int ha_berkeley::write_row(byte * record) &row, key_type[primary_key]))) { changed_keys.set_bit(primary_key); - for (uint keynr=0 ; keynr < table->keys ; keynr++) + for (uint keynr=0 ; keynr < table->s->keys ; keynr++) { if (keynr == primary_key) continue; @@ -940,7 +951,8 @@ int ha_berkeley::write_row(byte * record) else if (!changed_keys.is_clear_all()) { new_error = 0; - for (uint keynr=0 ; keynr < table->keys+test(hidden_primary_key) ; + for (uint keynr=0; + keynr < table->s->keys+test(hidden_primary_key); keynr++) { if (changed_keys.is_set(keynr)) @@ -1090,7 +1102,7 @@ int ha_berkeley::restore_keys(DB_TXN *trans, key_map *changed_keys, that one just put back the old value. */ if (!changed_keys->is_clear_all()) { - for (keynr=0 ; keynr < table->keys+test(hidden_primary_key) ; keynr++) + for (keynr=0 ; keynr < table->s->keys+test(hidden_primary_key) ; keynr++) { if (changed_keys->is_set(keynr)) { @@ -1117,9 +1129,9 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row) DBT prim_key, key, old_prim_key; int error; DB_TXN *sub_trans; - ulong thd_options = table->tmp_table == NO_TMP_TABLE ? table->in_use->options : 0; + ulong thd_options= (table->s->tmp_table == NO_TMP_TABLE ? + table->in_use->options : 0); bool primary_key_changed; - DBUG_ENTER("update_row"); LINT_INIT(error); @@ -1163,7 +1175,7 @@ int ha_berkeley::update_row(const byte * old_row, byte * new_row) thd_options, using_ignore))) { // Update all other keys - for (uint keynr=0 ; keynr < table->keys ; keynr++) + for (uint keynr=0 ; keynr < table->s->keys ; keynr++) { if (keynr == primary_key) continue; @@ -1294,7 +1306,9 @@ int ha_berkeley::remove_keys(DB_TXN *trans, const byte *record, DBT *new_record, DBT *prim_key, key_map *keys) { int result = 0; - for (uint keynr=0 ; keynr < table->keys+test(hidden_primary_key) ; keynr++) + for (uint keynr=0; + keynr < table->s->keys+test(hidden_primary_key); + keynr++) { if (keys->is_set(keynr)) { @@ -1314,8 +1328,9 @@ int ha_berkeley::delete_row(const byte * record) { int error; DBT row, prim_key; - key_map keys=table->keys_in_use; - ulong thd_options = table->tmp_table == NO_TMP_TABLE ? table->in_use->options : 0; + key_map keys= table->s->keys_in_use; + ulong thd_options= (table->s->tmp_table == NO_TMP_TABLE ? + table->in_use->options : 0); DBUG_ENTER("delete_row"); statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status); @@ -1374,7 +1389,7 @@ int ha_berkeley::index_init(uint keynr) { int error; DBUG_ENTER("ha_berkeley::index_init"); - DBUG_PRINT("enter",("table: '%s' key: %d", table->real_name, keynr)); + DBUG_PRINT("enter",("table: '%s' key: %d", table->s->table_name, keynr)); /* Under some very rare conditions (like full joins) we may already have @@ -1401,7 +1416,7 @@ int ha_berkeley::index_end() DBUG_ENTER("ha_berkely::index_end"); if (cursor) { - DBUG_PRINT("enter",("table: '%s'", table->real_name)); + DBUG_PRINT("enter",("table: '%s'", table->s->table_name)); error=cursor->c_close(cursor); cursor=0; } @@ -1756,14 +1771,14 @@ void ha_berkeley::info(uint flag) if ((flag & HA_STATUS_CONST) || version != share->version) { version=share->version; - for (uint i=0 ; i < table->keys ; i++) + for (uint i=0 ; i < table->s->keys ; i++) { table->key_info[i].rec_per_key[table->key_info[i].key_parts-1]= share->rec_per_key[i]; } } /* Don't return key if we got an error for the internal primary key */ - if (flag & HA_STATUS_ERRKEY && last_dup_key < table->keys) + if (flag & HA_STATUS_ERRKEY && last_dup_key < table->s->keys) errkey= last_dup_key; DBUG_VOID_RETURN; } @@ -2005,9 +2020,9 @@ int ha_berkeley::create(const char *name, register TABLE *form, if ((error= create_sub_table(name_buff,"main",DB_BTREE,0))) DBUG_RETURN(error); /* purecov: inspected */ - primary_key=table->primary_key; + primary_key= table->s->primary_key; /* Create the keys */ - for (uint i=0; i < form->keys; i++) + for (uint i=0; i < form->s->keys; i++) { if (i != primary_key) { @@ -2029,7 +2044,7 @@ int ha_berkeley::create(const char *name, register TABLE *form, "status", DB_BTREE, DB_CREATE, 0)))) { char rec_buff[4+MAX_KEY*4]; - uint length= 4+ table->keys*4; + uint length= 4+ table->s->keys*4; bzero(rec_buff, length); error= write_status(status_block, rec_buff, length); status_block->close(status_block,0); @@ -2149,9 +2164,9 @@ ulonglong ha_berkeley::get_auto_increment() (void) ha_berkeley::extra(HA_EXTRA_KEYREAD); /* Set 'active_index' */ - ha_berkeley::index_init(table->next_number_index); + ha_berkeley::index_init(table->s->next_number_index); - if (!table->next_number_key_offset) + if (!table->s->next_number_key_offset) { // Autoincrement at key-start error=ha_berkeley::index_last(table->record[1]); } @@ -2164,7 +2179,7 @@ ulonglong ha_berkeley::get_auto_increment() /* Reading next available number for a sub key */ ha_berkeley::create_key(&last_key, active_index, key_buff, table->record[0], - table->next_number_key_offset); + table->s->next_number_key_offset); /* Store for compare */ memcpy(old_key.data=key_buff2, key_buff, (old_key.size=last_key.size)); old_key.app_private=(void*) key_info; @@ -2193,8 +2208,8 @@ ulonglong ha_berkeley::get_auto_increment() } } if (!error) - nr=(ulonglong) - table->next_number_field->val_int_offset(table->rec_buff_length)+1; + nr= (ulonglong) + table->next_number_field->val_int_offset(table->s->rec_buff_length)+1; ha_berkeley::index_end(); (void) ha_berkeley::extra(HA_EXTRA_NO_KEYREAD); return nr; @@ -2279,7 +2294,7 @@ int ha_berkeley::analyze(THD* thd, HA_CHECK_OPT* check_opt) free(txn_stat_ptr); } - for (i=0 ; i < table->keys ; i++) + for (i=0 ; i < table->s->keys ; i++) { if (stat) { @@ -2414,14 +2429,15 @@ static BDB_SHARE *get_share(const char *table_name, TABLE *table) char *tmp_name; DB **key_file; u_int32_t *key_type; + uint keys= table->s->keys; if ((share=(BDB_SHARE *) my_multi_malloc(MYF(MY_WME | MY_ZEROFILL), &share, sizeof(*share), - &rec_per_key, table->keys * sizeof(ha_rows), + &rec_per_key, keys * sizeof(ha_rows), &tmp_name, length+1, - &key_file, (table->keys+1) * sizeof(*key_file), - &key_type, (table->keys+1) * sizeof(u_int32_t), + &key_file, (keys+1) * sizeof(*key_file), + &key_type, (keys+1) * sizeof(u_int32_t), NullS))) { share->rec_per_key = rec_per_key; @@ -2448,7 +2464,7 @@ static int free_share(BDB_SHARE *share, TABLE *table, uint hidden_primary_key, bool mutex_is_locked) { int error, result = 0; - uint keys=table->keys + test(hidden_primary_key); + uint keys= table->s->keys + test(hidden_primary_key); pthread_mutex_lock(&bdb_mutex); if (mutex_is_locked) pthread_mutex_unlock(&share->mutex); /* purecov: inspected */ @@ -2512,8 +2528,8 @@ void ha_berkeley::get_status() } if (!(share->status & STATUS_ROW_COUNT_INIT) && share->status_block) { - share->org_rows=share->rows= - table->max_rows ? table->max_rows : HA_BERKELEY_MAX_ROWS; + share->org_rows= share->rows= + table->s->max_rows ? table->s->max_rows : HA_BERKELEY_MAX_ROWS; if (!share->status_block->cursor(share->status_block, 0, &cursor, 0)) { DBT row; @@ -2528,9 +2544,10 @@ void ha_berkeley::get_status() uint i; uchar *pos=(uchar*) row.data; share->org_rows=share->rows=uint4korr(pos); pos+=4; - for (i=0 ; i < table->keys ; i++) + for (i=0 ; i < table->s->keys ; i++) { - share->rec_per_key[i]=uint4korr(pos); pos+=4; + share->rec_per_key[i]=uint4korr(pos); + pos+=4; } } cursor->c_close(cursor); @@ -2588,7 +2605,7 @@ static void update_status(BDB_SHARE *share, TABLE *table) { char rec_buff[4+MAX_KEY*4], *pos=rec_buff; int4store(pos,share->rows); pos+=4; - for (uint i=0 ; i < table->keys ; i++) + for (uint i=0 ; i < table->s->keys ; i++) { int4store(pos,share->rec_per_key[i]); pos+=4; } @@ -2622,7 +2639,7 @@ int ha_berkeley::cmp_ref(const byte *ref1, const byte *ref2) int result; Field *field; - KEY *key_info=table->key_info+table->primary_key; + KEY *key_info=table->key_info+table->s->primary_key; KEY_PART_INFO *key_part=key_info->key_part; KEY_PART_INFO *end=key_part+key_info->key_parts; diff --git a/sql/ha_heap.cc b/sql/ha_heap.cc index 1556a18bfca..b5742699d7e 100644 --- a/sql/ha_heap.cc +++ b/sql/ha_heap.cc @@ -60,7 +60,7 @@ int ha_heap::open(const char *name, int mode, uint test_if_locked) { /* Initialize variables for the opened table */ set_keys_for_scanning(); - if (table->tmp_table == NO_TMP_TABLE) + if (table->s->tmp_table == NO_TMP_TABLE) update_key_stats(); } return (file ? 0 : 1); @@ -91,7 +91,7 @@ int ha_heap::close(void) void ha_heap::set_keys_for_scanning(void) { btree_keys.clear_all(); - for (uint i= 0 ; i < table->keys ; i++) + for (uint i= 0 ; i < table->s->keys ; i++) { if (table->key_info[i].algorithm == HA_KEY_ALG_BTREE) btree_keys.set_bit(i); @@ -101,7 +101,7 @@ void ha_heap::set_keys_for_scanning(void) void ha_heap::update_key_stats() { - for (uint i= 0; i < table->keys; i++) + for (uint i= 0; i < table->s->keys; i++) { KEY *key=table->key_info+i; if (key->algorithm != HA_KEY_ALG_BTREE) @@ -124,7 +124,7 @@ int ha_heap::write_row(byte * buf) if (table->next_number_field && buf == table->record[0]) update_auto_increment(); res= heap_write(file,buf); - if (!res && table->tmp_table == NO_TMP_TABLE && + if (!res && table->s->tmp_table == NO_TMP_TABLE && ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > file->s->records) update_key_stats(); return res; @@ -137,7 +137,7 @@ int ha_heap::update_row(const byte * old_data, byte * new_data) if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE) table->timestamp_field->set_time(); res= heap_update(file,old_data,new_data); - if (!res && table->tmp_table == NO_TMP_TABLE && + if (!res && table->s->tmp_table == NO_TMP_TABLE && ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > file->s->records) update_key_stats(); return res; @@ -148,7 +148,7 @@ int ha_heap::delete_row(const byte * buf) int res; statistic_increment(table->in_use->status_var.ha_delete_count,&LOCK_status); res= heap_delete(file,buf); - if (!res && table->tmp_table == NO_TMP_TABLE && + if (!res && table->s->tmp_table == NO_TMP_TABLE && ++records_changed*HEAP_STATS_UPDATE_THRESHOLD > file->s->records) update_key_stats(); return res; @@ -282,7 +282,7 @@ int ha_heap::extra(enum ha_extra_function operation) int ha_heap::delete_all_rows() { heap_clear(file); - if (table->tmp_table == NO_TMP_TABLE) + if (table->s->tmp_table == NO_TMP_TABLE) update_key_stats(); return 0; } @@ -448,23 +448,24 @@ ha_rows ha_heap::records_in_range(uint inx, key_range *min_key, int ha_heap::create(const char *name, TABLE *table_arg, HA_CREATE_INFO *create_info) { - uint key, parts, mem_per_row= 0; + uint key, parts, mem_per_row= 0, keys= table_arg->s->keys; uint auto_key= 0, auto_key_type= 0; ha_rows max_rows; HP_KEYDEF *keydef; HA_KEYSEG *seg; char buff[FN_REFLEN]; int error; + TABLE_SHARE *share= table_arg->s; - for (key= parts= 0; key < table_arg->keys; key++) + for (key= parts= 0; key < keys; key++) parts+= table_arg->key_info[key].key_parts; - if (!(keydef= (HP_KEYDEF*) my_malloc(table_arg->keys * sizeof(HP_KEYDEF) + + if (!(keydef= (HP_KEYDEF*) my_malloc(keys * sizeof(HP_KEYDEF) + parts * sizeof(HA_KEYSEG), MYF(MY_WME)))) return my_errno; - seg= my_reinterpret_cast(HA_KEYSEG*) (keydef + table_arg->keys); - for (key= 0; key < table_arg->keys; key++) + seg= my_reinterpret_cast(HA_KEYSEG*) (keydef + keys); + for (key= 0; key < keys; key++) { KEY *pos= table_arg->key_info+key; KEY_PART_INFO *key_part= pos->key_part; @@ -516,7 +517,7 @@ int ha_heap::create(const char *name, TABLE *table_arg, } } } - mem_per_row+= MY_ALIGN(table_arg->reclength + 1, sizeof(char*)); + mem_per_row+= MY_ALIGN(share->reclength + 1, sizeof(char*)); max_rows = (ha_rows) (table->in_use->variables.max_heap_table_size / mem_per_row); HP_CREATE_INFO hp_create_info; @@ -525,11 +526,11 @@ int ha_heap::create(const char *name, TABLE *table_arg, hp_create_info.auto_increment= (create_info->auto_increment_value ? create_info->auto_increment_value - 1 : 0); error= heap_create(fn_format(buff,name,"","",4+2), - table_arg->keys,keydef, table_arg->reclength, - (ulong) ((table_arg->max_rows < max_rows && - table_arg->max_rows) ? - table_arg->max_rows : max_rows), - (ulong) table_arg->min_rows, &hp_create_info); + keys,keydef, share->reclength, + (ulong) ((share->max_rows < max_rows && + share->max_rows) ? + share->max_rows : max_rows), + (ulong) share->min_rows, &hp_create_info); my_free((gptr) keydef, MYF(0)); if (file) info(HA_STATUS_NO_LOCK | HA_STATUS_CONST | HA_STATUS_VARIABLE); diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc index 91517770d04..31b15f89806 100644 --- a/sql/ha_innodb.cc +++ b/sql/ha_innodb.cc @@ -1768,7 +1768,7 @@ ha_innobase::open( fields when packed actually became 1 byte longer, when we also stored the string length as the first byte. */ - upd_and_key_val_buff_len = table->reclength + table->max_key_length + upd_and_key_val_buff_len = table->s->reclength + table->s->max_key_length + MAX_REF_PARTS * 3; if (!(mysql_byte*) my_multi_malloc(MYF(MY_WME), &upd_buff, upd_and_key_val_buff_len, @@ -1820,11 +1820,11 @@ ha_innobase::open( innobase_prebuilt = row_create_prebuilt(ib_table); - ((row_prebuilt_t*)innobase_prebuilt)->mysql_row_len = table->reclength; + ((row_prebuilt_t*)innobase_prebuilt)->mysql_row_len = table->s->reclength; /* Looks like MySQL-3.23 sometimes has primary key number != 0 */ - primary_key = table->primary_key; + primary_key = table->s->primary_key; key_used_on_scan = primary_key; /* Allocate a buffer for a 'row reference'. A row reference is @@ -1995,7 +1995,7 @@ reset_null_bits( TABLE* table, /* in: MySQL table object */ char* record) /* in: a row in MySQL format */ { - bzero(record, table->null_bytes); + bzero(record, table->s->null_bytes); } extern "C" { @@ -2349,7 +2349,7 @@ build_template( the clustered index */ } - n_fields = (ulint)table->fields; /* number of columns */ + n_fields = (ulint)table->s->fields; /* number of columns */ if (!prebuilt->mysql_template) { prebuilt->mysql_template = (mysql_row_templ_t*) @@ -2358,7 +2358,7 @@ build_template( } prebuilt->template_type = templ_type; - prebuilt->null_bitmap_len = table->null_bytes; + prebuilt->null_bitmap_len = table->s->null_bytes; prebuilt->templ_contains_blob = FALSE; @@ -2725,7 +2725,7 @@ calc_row_difference( ulint n_changed = 0; uint i; - n_fields = table->fields; + n_fields = table->s->fields; /* We use upd_buff to convert changed fields */ buf = (byte*) upd_buff; @@ -3215,7 +3215,7 @@ ha_innobase::change_active_index( active_index = keynr; - if (keynr != MAX_KEY && table->keys > 0) { + if (keynr != MAX_KEY && table->s->keys > 0) { key = table->key_info + active_index; prebuilt->index = dict_table_get_index_noninline( @@ -3635,7 +3635,7 @@ create_table_def( DBUG_ENTER("create_table_def"); DBUG_PRINT("enter", ("table_name: %s", table_name)); - n_cols = form->fields; + n_cols = form->s->fields; /* We pass 0 as the space id, and determine at a lower level the space id where to store the table */ @@ -3727,7 +3727,7 @@ create_index( ind_type = 0; - if (key_num == form->primary_key) { + if (key_num == form->s->primary_key) { ind_type = ind_type | DICT_CLUSTERED; } @@ -3750,7 +3750,7 @@ create_index( the length of the key part versus the column. */ field = NULL; - for (j = 0; j < form->fields; j++) { + for (j = 0; j < form->s->fields; j++) { field = form->field[j]; @@ -3763,7 +3763,7 @@ create_index( } } - ut_a(j < form->fields); + ut_a(j < form->s->fields); col_type = get_innobase_type_from_mysql_type(key_part->field); @@ -3857,7 +3857,7 @@ ha_innobase::create( DBUG_ASSERT(thd != NULL); - if (form->fields > 1000) { + if (form->s->fields > 1000) { /* The limit probably should be REC_MAX_N_FIELDS - 3 = 1020, but we play safe here */ @@ -3907,7 +3907,7 @@ ha_innobase::create( error = create_table_def(trx, form, norm_name, create_info->options & HA_LEX_CREATE_TMP_TABLE ? name2 : NULL, - !(form->db_options_in_use & HA_OPTION_PACK_RECORD)); + !(form->s->db_options_in_use & HA_OPTION_PACK_RECORD)); if (error) { innobase_commit_low(trx); @@ -3921,8 +3921,8 @@ ha_innobase::create( /* Look for a primary key */ - primary_key_no= (table->primary_key != MAX_KEY ? - (int) table->primary_key : + primary_key_no= (table->s->primary_key != MAX_KEY ? + (int) table->s->primary_key : -1); /* Our function row_get_mysql_key_number_for_index assumes @@ -3932,7 +3932,7 @@ ha_innobase::create( /* Create the keys */ - if (form->keys == 0 || primary_key_no == -1) { + if (form->s->keys == 0 || primary_key_no == -1) { /* Create an index which is used as the clustered index; order the rows by their row id which is internally generated by InnoDB */ @@ -3965,7 +3965,7 @@ ha_innobase::create( } } - for (i = 0; i < form->keys; i++) { + for (i = 0; i < form->s->keys; i++) { if (i != (uint) primary_key_no) { @@ -4330,11 +4330,11 @@ ha_innobase::records_in_range( KEY* key; dict_index_t* index; mysql_byte* key_val_buff2 = (mysql_byte*) my_malloc( - table->reclength - + table->max_key_length + 100, + table->s->reclength + + table->s->max_key_length + 100, MYF(MY_WME)); - ulint buff2_len = table->reclength - + table->max_key_length + 100; + ulint buff2_len = table->s->reclength + + table->s->max_key_length + 100; dtuple_t* range_start; dtuple_t* range_end; ib_longlong n_rows; @@ -4491,7 +4491,7 @@ ha_innobase::read_time( ha_rows total_rows; double time_for_scan; - if (index != table->primary_key) + if (index != table->s->primary_key) return handler::read_time(index, ranges, rows); // Not clustered if (rows <= 2) @@ -4610,7 +4610,7 @@ ha_innobase::info( index = dict_table_get_next_index_noninline(index); } - for (i = 0; i < table->keys; i++) { + for (i = 0; i < table->s->keys; i++) { if (index == NULL) { ut_print_timestamp(stderr); fprintf(stderr, @@ -5803,7 +5803,7 @@ ha_innobase::innobase_read_and_init_auto_inc( } (void) extra(HA_EXTRA_KEYREAD); - index_init(table->next_number_index); + index_init(table->s->next_number_index); /* We use an exclusive lock when we read the max key value from the auto-increment column index. This is because then build_template will @@ -5838,7 +5838,7 @@ ha_innobase::innobase_read_and_init_auto_inc( } else { /* Initialize to max(col) + 1 */ auto_inc = (longlong) table->next_number_field-> - val_int_offset(table->rec_buff_length) + 1; + val_int_offset(table->s->rec_buff_length) + 1; } dict_table_autoinc_initialize(prebuilt->table, auto_inc); @@ -5925,9 +5925,9 @@ ha_innobase::cmp_ref( /* Do type-aware comparison of Primary Key members. PK members are always NOT NULL, so no checks for NULL are performed */ - KEY_PART_INFO *key_part= table->key_info[table->primary_key].key_part; + KEY_PART_INFO *key_part= table->key_info[table->s->primary_key].key_part; KEY_PART_INFO *key_part_end= - key_part + table->key_info[table->primary_key].key_parts; + key_part + table->key_info[table->s->primary_key].key_parts; for (; key_part != key_part_end; ++key_part) { field = key_part->field; mysql_type = field->type(); diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc index c89eb4426ff..87329c6f4af 100644 --- a/sql/ha_myisam.cc +++ b/sql/ha_myisam.cc @@ -233,7 +233,7 @@ int ha_myisam::open(const char *name, int mode, uint test_if_locked) info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST); if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED)) VOID(mi_extra(file, HA_EXTRA_WAIT_LOCK, 0)); - if (!table->db_record_offset) + if (!table->s->db_record_offset) int_table_flags|=HA_REC_NOT_IN_SEQ; if (file->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD)) int_table_flags|=HA_HAS_CHECKSUM; @@ -275,9 +275,9 @@ int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt) thd->proc_info="Checking table"; myisamchk_init(¶m); param.thd = thd; - param.op_name = (char*)"check"; - param.db_name = table->table_cache_key; - param.table_name = table->table_name; + param.op_name = "check"; + param.db_name= table->s->db; + param.table_name= table->alias; param.testflag = check_opt->flags | T_CHECK | T_SILENT; if (!(table->db_stat & HA_READ_ONLY)) @@ -362,11 +362,11 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt) myisamchk_init(¶m); param.thd = thd; - param.op_name = (char*) "analyze"; - param.db_name = table->table_cache_key; - param.table_name = table->table_name; - param.testflag=(T_FAST | T_CHECK | T_SILENT | T_STATISTICS | - T_DONT_CHECK_CHECKSUM); + param.op_name= "analyze"; + param.db_name= table->s->db; + param.table_name= table->alias; + param.testflag= (T_FAST | T_CHECK | T_SILENT | T_STATISTICS | + T_DONT_CHECK_CHECKSUM); param.using_global_keycache = 1; if (!(share->state.changed & STATE_NOT_ANALYZED)) @@ -388,9 +388,9 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt) int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt) { HA_CHECK_OPT tmp_check_opt; - char* backup_dir= thd->lex->backup_dir; + char *backup_dir= thd->lex->backup_dir; char src_path[FN_REFLEN], dst_path[FN_REFLEN]; - char* table_name = table->real_name; + const char *table_name= table->s->table_name; int error; const char* errmsg; DBUG_ENTER("restore"); @@ -399,11 +399,11 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt) MI_NAME_DEXT)) DBUG_RETURN(HA_ADMIN_INVALID); - if (my_copy(src_path, fn_format(dst_path, table->path, "", + if (my_copy(src_path, fn_format(dst_path, table->s->path, "", MI_NAME_DEXT, 4), MYF(MY_WME))) { - error = HA_ADMIN_FAILED; - errmsg = "Failed in my_copy (Error %d)"; + error= HA_ADMIN_FAILED; + errmsg= "Failed in my_copy (Error %d)"; goto err; } @@ -415,11 +415,11 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt) { MI_CHECK param; myisamchk_init(¶m); - param.thd = thd; - param.op_name = (char*)"restore"; - param.db_name = table->table_cache_key; - param.table_name = table->table_name; - param.testflag = 0; + param.thd= thd; + param.op_name= "restore"; + param.db_name= table->s->db; + param.table_name= table->s->table_name; + param.testflag= 0; mi_check_print_error(¶m, errmsg, my_errno); DBUG_RETURN(error); } @@ -428,9 +428,9 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt) int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt) { - char* backup_dir= thd->lex->backup_dir; + char *backup_dir= thd->lex->backup_dir; char src_path[FN_REFLEN], dst_path[FN_REFLEN]; - char* table_name = table->real_name; + const char *table_name= table->s->table_name; int error; const char *errmsg; DBUG_ENTER("ha_myisam::backup"); @@ -438,12 +438,13 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt) if (fn_format_relative_to_data_home(dst_path, table_name, backup_dir, reg_ext)) { - errmsg = "Failed in fn_format() for .frm file (errno: %d)"; - error = HA_ADMIN_INVALID; + errmsg= "Failed in fn_format() for .frm file (errno: %d)"; + error= HA_ADMIN_INVALID; goto err; } - if (my_copy(fn_format(src_path, table->path,"", reg_ext, MY_UNPACK_FILENAME), + if (my_copy(fn_format(src_path, table->s->path, "", reg_ext, + MY_UNPACK_FILENAME), dst_path, MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_DONT_OVERWRITE_FILE))) { @@ -461,7 +462,7 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt) goto err; } - if (my_copy(fn_format(src_path, table->path,"", MI_NAME_DEXT, + if (my_copy(fn_format(src_path, table->s->path, "", MI_NAME_DEXT, MY_UNPACK_FILENAME), dst_path, MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_DONT_OVERWRITE_FILE))) @@ -476,11 +477,11 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt) { MI_CHECK param; myisamchk_init(¶m); - param.thd = thd; - param.op_name = (char*)"backup"; - param.db_name = table->table_cache_key; - param.table_name = table->table_name; - param.testflag = 0; + param.thd= thd; + param.op_name= "backup"; + param.db_name= table->s->db; + param.table_name= table->s->table_name; + param.testflag = 0; mi_check_print_error(¶m,errmsg, my_errno); DBUG_RETURN(error); } @@ -497,10 +498,10 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt) myisamchk_init(¶m); param.thd = thd; - param.op_name = (char*) "repair"; - param.testflag = ((check_opt->flags & ~(T_EXTEND)) | - T_SILENT | T_FORCE_CREATE | T_CALC_CHECKSUM | - (check_opt->flags & T_EXTEND ? T_REP : T_REP_BY_SORT)); + param.op_name= "repair"; + param.testflag= ((check_opt->flags & ~(T_EXTEND)) | + T_SILENT | T_FORCE_CREATE | T_CALC_CHECKSUM | + (check_opt->flags & T_EXTEND ? T_REP : T_REP_BY_SORT)); param.sort_buffer_length= check_opt->sort_buffer_size; start_records=file->state->records; while ((error=repair(thd,param,0)) && param.retry_repair) @@ -511,7 +512,7 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt) { param.testflag&= ~T_RETRY_WITHOUT_QUICK; sql_print_information("Retrying repair of: '%s' without quick", - table->path); + table->s->path); continue; } param.testflag&= ~T_QUICK; @@ -519,7 +520,7 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt) { param.testflag= (param.testflag & ~T_REP_BY_SORT) | T_REP; sql_print_information("Retrying repair of: '%s' with keycache", - table->path); + table->s->path); continue; } break; @@ -531,7 +532,7 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt) sql_print_information("Found %s of %s rows when repairing '%s'", llstr(file->state->records, llbuff), llstr(start_records, llbuff2), - table->path); + table->s->path); } return error; } @@ -544,9 +545,9 @@ int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt) myisamchk_init(¶m); param.thd = thd; - param.op_name = (char*) "optimize"; - param.testflag = (check_opt->flags | T_SILENT | T_FORCE_CREATE | - T_REP_BY_SORT | T_STATISTICS | T_SORT_INDEX); + param.op_name= "optimize"; + param.testflag= (check_opt->flags | T_SILENT | T_FORCE_CREATE | + T_REP_BY_SORT | T_STATISTICS | T_SORT_INDEX); param.sort_buffer_length= check_opt->sort_buffer_size; if ((error= repair(thd,param,1)) && param.retry_repair) { @@ -570,18 +571,18 @@ int ha_myisam::repair(THD *thd, MI_CHECK ¶m, bool optimize) ha_rows rows= file->state->records; DBUG_ENTER("ha_myisam::repair"); - param.db_name = table->table_cache_key; - param.table_name = table->table_name; + param.db_name= table->s->db; + param.table_name= table->alias; param.tmpfile_createflag = O_RDWR | O_TRUNC; param.using_global_keycache = 1; - param.thd=thd; - param.tmpdir=&mysql_tmpdir_list; - param.out_flag=0; + param.thd= thd; + param.tmpdir= &mysql_tmpdir_list; + param.out_flag= 0; strmov(fixed_name,file->filename); // Don't lock tables if we have used LOCK TABLE if (!thd->locked_tables && - mi_lock_database(file, table->tmp_table ? F_EXTRA_LCK : F_WRLCK)) + mi_lock_database(file, table->s->tmp_table ? F_EXTRA_LCK : F_WRLCK)) { mi_check_print_error(¶m,ER(ER_CANT_LOCK),my_errno); DBUG_RETURN(HA_ADMIN_FAILED); @@ -740,9 +741,9 @@ int ha_myisam::assign_to_keycache(THD* thd, HA_CHECK_OPT *check_opt) MI_CHECK param; myisamchk_init(¶m); param.thd= thd; - param.op_name= (char*)"assign_to_keycache"; - param.db_name= table->table_cache_key; - param.table_name= table->table_name; + param.op_name= "assign_to_keycache"; + param.db_name= table->s->db; + param.table_name= table->s->table_name; param.testflag= 0; mi_check_print_error(¶m, errmsg); } @@ -808,10 +809,10 @@ int ha_myisam::preload_keys(THD* thd, HA_CHECK_OPT *check_opt) MI_CHECK param; myisamchk_init(¶m); param.thd= thd; - param.op_name= (char*)"preload_keys"; - param.db_name= table->table_cache_key; - param.table_name= table->table_name; - param.testflag= 0; + param.op_name= "preload_keys"; + param.db_name= table->s->db; + param.table_name= table->s->table_name; + param.testflag= 0; mi_check_print_error(¶m, errmsg); DBUG_RETURN(error); } @@ -916,9 +917,9 @@ int ha_myisam::enable_indexes(uint mode) const char *save_proc_info=thd->proc_info; thd->proc_info="Creating index"; myisamchk_init(¶m); - param.op_name = (char*) "recreating_index"; - param.testflag = (T_SILENT | T_REP_BY_SORT | T_QUICK | - T_CREATE_MISSING_KEYS); + param.op_name= "recreating_index"; + param.testflag= (T_SILENT | T_REP_BY_SORT | T_QUICK | + T_CREATE_MISSING_KEYS); param.myf_rw&= ~MY_WAIT_IF_FULL; param.sort_buffer_length= thd->variables.myisam_sort_buff_size; param.tmpdir=&mysql_tmpdir_list; @@ -983,8 +984,9 @@ int ha_myisam::indexes_are_disabled(void) void ha_myisam::start_bulk_insert(ha_rows rows) { DBUG_ENTER("ha_myisam::start_bulk_insert"); - THD *thd=current_thd; - ulong size= min(thd->variables.read_buff_size, table->avg_row_length*rows); + THD *thd= current_thd; + ulong size= min(thd->variables.read_buff_size, + table->s->avg_row_length*rows); DBUG_PRINT("info",("start_bulk_insert: rows %lu size %lu", (ulong) rows, size)); @@ -1052,18 +1054,18 @@ bool ha_myisam::check_and_repair(THD *thd) // Don't use quick if deleted rows if (!file->state->del && (myisam_recover_options & HA_RECOVER_QUICK)) check_opt.flags|=T_QUICK; - sql_print_warning("Checking table: '%s'",table->path); + sql_print_warning("Checking table: '%s'",table->s->path); old_query= thd->query; old_query_length= thd->query_length; pthread_mutex_lock(&LOCK_thread_count); - thd->query= table->real_name; - thd->query_length= strlen(table->real_name); + thd->query= (char*) table->s->table_name; + thd->query_length= strlen(table->s->table_name); pthread_mutex_unlock(&LOCK_thread_count); if ((marked_crashed= mi_is_crashed(file)) || check(thd, &check_opt)) { - sql_print_warning("Recovering table: '%s'",table->path); + sql_print_warning("Recovering table: '%s'",table->s->path); check_opt.flags= ((myisam_recover_options & HA_RECOVER_BACKUP ? T_BACKUP_DATA : 0) | (marked_crashed ? 0 : T_QUICK) | @@ -1237,25 +1239,25 @@ void ha_myisam::info(uint flag) } if (flag & HA_STATUS_CONST) { - max_data_file_length=info.max_data_file_length; - max_index_file_length=info.max_index_file_length; - create_time = info.create_time; - sortkey = info.sortkey; - ref_length=info.reflength; - table->db_options_in_use = info.options; - block_size=myisam_block_size; - table->keys_in_use.set_prefix(table->keys); - table->keys_in_use.intersect(info.key_map); - table->keys_for_keyread= table->keys_in_use; - table->keys_for_keyread.subtract(table->read_only_keys); - table->db_record_offset=info.record_offset; - if (table->key_parts) + TABLE_SHARE *share= table->s; + max_data_file_length= info.max_data_file_length; + max_index_file_length= info.max_index_file_length; + create_time= info.create_time; + sortkey= info.sortkey; + ref_length= info.reflength; + share->db_options_in_use= info.options; + block_size= myisam_block_size; + share->keys_in_use.set_prefix(share->keys); + share->keys_in_use.intersect(info.key_map); + share->keys_for_keyread.intersect(share->keys_in_use); + share->db_record_offset= info.record_offset; + if (share->key_parts) memcpy((char*) table->key_info[0].rec_per_key, (char*) info.rec_per_key, - sizeof(table->key_info[0].rec_per_key)*table->key_parts); - raid_type=info.raid_type; - raid_chunks=info.raid_chunks; - raid_chunksize=info.raid_chunksize; + sizeof(table->key_info[0].rec_per_key)*share->key_parts); + raid_type= info.raid_type; + raid_chunks= info.raid_chunks; + raid_chunksize= info.raid_chunksize; /* Set data_file_name and index_file_name to point at the symlink value @@ -1311,7 +1313,7 @@ int ha_myisam::delete_table(const char *name) int ha_myisam::external_lock(THD *thd, int lock_type) { - return mi_lock_database(file, !table->tmp_table ? + return mi_lock_database(file, !table->s->tmp_table ? lock_type : ((lock_type == F_UNLCK) ? F_UNLCK : F_EXTRA_LCK)); } @@ -1356,21 +1358,23 @@ int ha_myisam::create(const char *name, register TABLE *table_arg, MI_KEYDEF *keydef; MI_COLUMNDEF *recinfo,*recinfo_pos; HA_KEYSEG *keyseg; - uint options=table_arg->db_options_in_use; + TABLE_SHARE *share= table->s; + uint options= share->db_options_in_use; DBUG_ENTER("ha_myisam::create"); type=HA_KEYTYPE_BINARY; // Keep compiler happy if (!(my_multi_malloc(MYF(MY_WME), - &recinfo,(table_arg->fields*2+2)*sizeof(MI_COLUMNDEF), - &keydef, table_arg->keys*sizeof(MI_KEYDEF), + &recinfo,(share->fields*2+2)* + sizeof(MI_COLUMNDEF), + &keydef, share->keys*sizeof(MI_KEYDEF), &keyseg, - ((table_arg->key_parts + table_arg->keys) * + ((share->key_parts + share->keys) * sizeof(HA_KEYSEG)), NullS))) DBUG_RETURN(HA_ERR_OUT_OF_MEM); pos=table_arg->key_info; - for (i=0; i < table_arg->keys ; i++, pos++) + for (i=0; i < share->keys ; i++, pos++) { keydef[i].flag= (pos->flags & (HA_NOSAME | HA_FULLTEXT | HA_SPATIAL)); keydef[i].key_alg= pos->algorithm == HA_KEY_ALG_UNDEF ? @@ -1431,7 +1435,7 @@ int ha_myisam::create(const char *name, register TABLE *table_arg, keydef[i].seg[j].flag|=HA_BLOB_PART; /* save number of bytes used to pack length */ keydef[i].seg[j].bit_start= (uint) (field->pack_length() - - table_arg->blob_ptr_size); + share->blob_ptr_size); } else if (field->type() == FIELD_TYPE_BIT) { @@ -1446,15 +1450,16 @@ int ha_myisam::create(const char *name, register TABLE *table_arg, if (table_arg->found_next_number_field) { - keydef[table_arg->next_number_index].flag|= HA_AUTO_KEY; - found_real_auto_increment= table_arg->next_number_key_offset == 0; + keydef[share->next_number_index].flag|= HA_AUTO_KEY; + found_real_auto_increment= share->next_number_key_offset == 0; } recpos=0; recinfo_pos=recinfo; - while (recpos < (uint) table_arg->reclength) + while (recpos < (uint) share->reclength) { Field **field,*found=0; - minpos=table_arg->reclength; length=0; + minpos= share->reclength; + length=0; for (field=table_arg->field ; *field ; field++) { @@ -1517,25 +1522,25 @@ int ha_myisam::create(const char *name, register TABLE *table_arg, } MI_CREATE_INFO create_info; bzero((char*) &create_info,sizeof(create_info)); - create_info.max_rows=table_arg->max_rows; - create_info.reloc_rows=table_arg->min_rows; + create_info.max_rows= share->max_rows; + create_info.reloc_rows= share->min_rows; create_info.with_auto_increment=found_real_auto_increment; create_info.auto_increment=(info->auto_increment_value ? info->auto_increment_value -1 : (ulonglong) 0); - create_info.data_file_length= ((ulonglong) table_arg->max_rows * - table_arg->avg_row_length); + create_info.data_file_length= ((ulonglong) share->max_rows * + share->avg_row_length); create_info.raid_type=info->raid_type; create_info.raid_chunks= (info->raid_chunks ? info->raid_chunks : RAID_DEFAULT_CHUNKS); - create_info.raid_chunksize=(info->raid_chunksize ? info->raid_chunksize : - RAID_DEFAULT_CHUNKSIZE); - create_info.data_file_name= info->data_file_name; - create_info.index_file_name=info->index_file_name; + create_info.raid_chunksize= (info->raid_chunksize ? info->raid_chunksize : + RAID_DEFAULT_CHUNKSIZE); + create_info.data_file_name= info->data_file_name; + create_info.index_file_name= info->index_file_name; /* TODO: Check that the following fn_format is really needed */ error=mi_create(fn_format(buff,name,"","",2+4), - table_arg->keys,keydef, + share->keys,keydef, (uint) (recinfo_pos-recinfo), recinfo, 0, (MI_UNIQUEDEF*) 0, &create_info, @@ -1562,26 +1567,29 @@ ulonglong ha_myisam::get_auto_increment() int error; byte key[MI_MAX_KEY_LENGTH]; - if (!table->next_number_key_offset) + if (!table->s->next_number_key_offset) { // Autoincrement at key-start ha_myisam::info(HA_STATUS_AUTO); return auto_increment_value; } /* it's safe to call the following if bulk_insert isn't on */ - mi_flush_bulk_insert(file, table->next_number_index); + mi_flush_bulk_insert(file, table->s->next_number_index); (void) extra(HA_EXTRA_KEYREAD); key_copy(key, table->record[0], - table->key_info + table->next_number_index, - table->next_number_key_offset); - error=mi_rkey(file,table->record[1],(int) table->next_number_index, - key,table->next_number_key_offset,HA_READ_PREFIX_LAST); + table->key_info + table->s->next_number_index, + table->s->next_number_key_offset); + error= mi_rkey(file,table->record[1],(int) table->s->next_number_index, + key,table->s->next_number_key_offset,HA_READ_PREFIX_LAST); if (error) nr= 1; else + { + /* Get data from record[1] */ nr= ((ulonglong) table->next_number_field-> - val_int_offset(table->rec_buff_length)+1); + val_int_offset(table->s->rec_buff_length)+1); + } extra(HA_EXTRA_NO_KEYREAD); return nr; } diff --git a/sql/ha_myisammrg.cc b/sql/ha_myisammrg.cc index 744128faf69..4cd39660728 100644 --- a/sql/ha_myisammrg.cc +++ b/sql/ha_myisammrg.cc @@ -67,15 +67,15 @@ int ha_myisammrg::open(const char *name, int mode, uint test_if_locked) if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED)) myrg_extra(file,HA_EXTRA_WAIT_LOCK,0); - if (table->reclength != mean_rec_length && mean_rec_length) + if (table->s->reclength != mean_rec_length && mean_rec_length) { DBUG_PRINT("error",("reclength: %d mean_rec_length: %d", - table->reclength, mean_rec_length)); + table->s->reclength, mean_rec_length)); goto err; } #if !defined(BIG_TABLES) || SIZEOF_OFF_T == 4 /* Merge table has more than 2G rows */ - if (table->crashed) + if (table->s->crashed) goto err; #endif return (0); @@ -241,14 +241,14 @@ void ha_myisammrg::info(uint flag) #if !defined(BIG_TABLES) || SIZEOF_OFF_T == 4 if ((info.records >= (ulonglong) 1 << 32) || (info.deleted >= (ulonglong) 1 << 32)) - table->crashed=1; + table->s->crashed= 1; #endif data_file_length=info.data_file_length; errkey = info.errkey; - table->keys_in_use.set_prefix(table->keys); - table->db_options_in_use = info.options; - table->is_view=1; - mean_rec_length=info.reclength; + table->s->keys_in_use.set_prefix(table->s->keys); + table->s->db_options_in_use= info.options; + table->s->is_view= 1; + mean_rec_length= info.reclength; block_size=0; update_time=0; #if SIZEOF_OFF_T > 4 @@ -258,10 +258,10 @@ void ha_myisammrg::info(uint flag) #endif if (flag & HA_STATUS_CONST) { - if (table->key_parts && info.rec_per_key) + if (table->s->key_parts && info.rec_per_key) memcpy((char*) table->key_info[0].rec_per_key, (char*) info.rec_per_key, - sizeof(table->key_info[0].rec_per_key)*table->key_parts); + sizeof(table->key_info[0].rec_per_key)*table->s->key_parts); } } @@ -361,7 +361,7 @@ void ha_myisammrg::update_create_info(HA_CREATE_INFO *create_info) if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST)))) goto err; split_file_name(open_table->table->filename, &db, &name); - if (!(ptr->real_name= thd->strmake(name.str, name.length))) + if (!(ptr->table_name= thd->strmake(name.str, name.length))) goto err; if (db.length && !(ptr->db= thd->strmake(db.str, db.length))) goto err; @@ -388,35 +388,36 @@ err: int ha_myisammrg::create(const char *name, register TABLE *form, HA_CREATE_INFO *create_info) { - char buff[FN_REFLEN],**table_names,**pos; + char buff[FN_REFLEN]; + const char **table_names, **pos; TABLE_LIST *tables= (TABLE_LIST*) create_info->merge_list.first; THD *thd= current_thd; DBUG_ENTER("ha_myisammrg::create"); - if (!(table_names= (char**) thd->alloc((create_info->merge_list.elements+1)* - sizeof(char*)))) + if (!(table_names= (const char**) + thd->alloc((create_info->merge_list.elements+1) * sizeof(char*)))) DBUG_RETURN(HA_ERR_OUT_OF_MEM); for (pos= table_names; tables; tables= tables->next_local) { - char *table_name; + const char *table_name; TABLE **tbl= 0; if (create_info->options & HA_LEX_CREATE_TMP_TABLE) - tbl= find_temporary_table(thd, tables->db, tables->real_name); + tbl= find_temporary_table(thd, tables->db, tables->table_name); if (!tbl) { uint length= my_snprintf(buff,FN_REFLEN,"%s%s/%s", mysql_real_data_home, - tables->db, tables->real_name); + tables->db, tables->table_name); if (!(table_name= thd->strmake(buff, length))) DBUG_RETURN(HA_ERR_OUT_OF_MEM); } else - table_name=(*tbl)->path; + table_name= (*tbl)->s->path; *pos++= table_name; } *pos=0; DBUG_RETURN(myrg_create(fn_format(buff,name,"","",2+4+16), - (const char **) table_names, + table_names, create_info->merge_insert_method, (my_bool) 0)); } @@ -436,7 +437,7 @@ void ha_myisammrg::append_create_info(String *packet) packet->append(" UNION=(",8); MYRG_TABLE *open_table,*first; - current_db= table->table_cache_key; + current_db= table->s->db; db_length= strlen(current_db); for (first=open_table=file->open_tables ; diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index d8616092dca..200c7ae1bc5 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -234,7 +234,7 @@ struct Ndb_table_local_info { void ha_ndbcluster::set_rec_per_key() { DBUG_ENTER("ha_ndbcluster::get_status_const"); - for (uint i=0 ; i < table->keys ; i++) + for (uint i=0 ; i < table->s->keys ; i++) { table->key_info[i].rec_per_key[table->key_info[i].key_parts-1]= 1; } @@ -343,7 +343,7 @@ int ha_ndbcluster::ndb_err(NdbConnection *trans) NDBDICT *dict= ndb->getDictionary(); DBUG_PRINT("info", ("invalidateTable %s", m_tabname)); dict->invalidateTable(m_tabname); - table->version=0L; /* Free when thread is ready */ + table->s->version= 0L; /* Free when thread is ready */ break; } default: @@ -353,7 +353,7 @@ int ha_ndbcluster::ndb_err(NdbConnection *trans) DBUG_PRINT("info", ("transformed ndbcluster error %d to mysql error %d", err.code, res)); if (res == HA_ERR_FOUND_DUPP_KEY) - m_dupkey= table->primary_key; + m_dupkey= table->s->primary_key; DBUG_RETURN(res); } @@ -565,7 +565,7 @@ int ha_ndbcluster::get_ndb_blobs_value(NdbBlob *last_ndb_blob) for (int loop= 0; loop <= 1; loop++) { uint32 offset= 0; - for (uint i= 0; i < table->fields; i++) + for (uint i= 0; i < table->s->fields; i++) { Field *field= table->field[i]; NdbValue value= m_value[i]; @@ -667,12 +667,12 @@ int ha_ndbcluster::get_ndb_value(NdbOperation *ndb_op, Field *field, */ bool ha_ndbcluster::uses_blob_value(bool all_fields) { - if (table->blob_fields == 0) + if (table->s->blob_fields == 0) return FALSE; if (all_fields) return TRUE; { - uint no_fields= table->fields; + uint no_fields= table->s->fields; int i; THD *thd= table->in_use; // They always put blobs at the end.. @@ -776,13 +776,13 @@ int ha_ndbcluster::build_index_list(TABLE *tab, enum ILBP phase) char unique_index_name[FN_LEN]; static const char* unique_suffix= "$unique"; KEY* key_info= tab->key_info; - const char **key_name= tab->keynames.type_names; + const char **key_name= tab->s->keynames.type_names; Ndb *ndb= get_ndb(); NdbDictionary::Dictionary *dict= ndb->getDictionary(); DBUG_ENTER("build_index_list"); // Save information about all known indexes - for (i= 0; i < tab->keys; i++, key_info++, key_name++) + for (i= 0; i < tab->s->keys; i++, key_info++, key_name++) { index_name= *key_name; NDB_INDEX_TYPE idx_type= get_index_type_from_table(i); @@ -855,12 +855,12 @@ int ha_ndbcluster::build_index_list(TABLE *tab, enum ILBP phase) NDB_INDEX_TYPE ha_ndbcluster::get_index_type_from_table(uint inx) const { bool is_hash_index= (table->key_info[inx].algorithm == HA_KEY_ALG_HASH); - if (inx == table->primary_key) + if (inx == table->s->primary_key) return is_hash_index ? PRIMARY_KEY_INDEX : PRIMARY_KEY_ORDERED_INDEX; - else - return ((table->key_info[inx].flags & HA_NOSAME) ? - (is_hash_index ? UNIQUE_INDEX : UNIQUE_ORDERED_INDEX) : - ORDERED_INDEX); + + return ((table->key_info[inx].flags & HA_NOSAME) ? + (is_hash_index ? UNIQUE_INDEX : UNIQUE_ORDERED_INDEX) : + ORDERED_INDEX); } int ha_ndbcluster::check_index_fields_not_null(uint inx) @@ -975,7 +975,7 @@ inline ulong ha_ndbcluster::index_flags(uint idx_no, uint part, int ha_ndbcluster::set_primary_key(NdbOperation *op, const byte *key) { - KEY* key_info= table->key_info + table->primary_key; + KEY* key_info= table->key_info + table->s->primary_key; KEY_PART_INFO* key_part= key_info->key_part; KEY_PART_INFO* end= key_part+key_info->key_parts; DBUG_ENTER("set_primary_key"); @@ -994,7 +994,7 @@ int ha_ndbcluster::set_primary_key(NdbOperation *op, const byte *key) int ha_ndbcluster::set_primary_key_from_old_data(NdbOperation *op, const byte *old_data) { - KEY* key_info= table->key_info + table->primary_key; + KEY* key_info= table->key_info + table->s->primary_key; KEY_PART_INFO* key_part= key_info->key_part; KEY_PART_INFO* end= key_part+key_info->key_parts; DBUG_ENTER("set_primary_key_from_old_data"); @@ -1013,7 +1013,7 @@ int ha_ndbcluster::set_primary_key_from_old_data(NdbOperation *op, const byte *o int ha_ndbcluster::set_primary_key(NdbOperation *op) { DBUG_ENTER("set_primary_key"); - KEY* key_info= table->key_info + table->primary_key; + KEY* key_info= table->key_info + table->s->primary_key; KEY_PART_INFO* key_part= key_info->key_part; KEY_PART_INFO* end= key_part+key_info->key_parts; @@ -1034,7 +1034,7 @@ int ha_ndbcluster::set_primary_key(NdbOperation *op) int ha_ndbcluster::pk_read(const byte *key, uint key_len, byte *buf) { - uint no_fields= table->fields, i; + uint no_fields= table->s->fields, i; NdbConnection *trans= m_active_trans; NdbOperation *op; THD *thd= current_thd; @@ -1048,7 +1048,7 @@ int ha_ndbcluster::pk_read(const byte *key, uint key_len, byte *buf) op->readTuple(lm) != 0) ERR_RETURN(trans->getNdbError()); - if (table->primary_key == MAX_KEY) + if (table->s->primary_key == MAX_KEY) { // This table has no primary key, use "hidden" primary key DBUG_PRINT("info", ("Using hidden key")); @@ -1104,7 +1104,7 @@ int ha_ndbcluster::pk_read(const byte *key, uint key_len, byte *buf) int ha_ndbcluster::complemented_pk_read(const byte *old_data, byte *new_data) { - uint no_fields= table->fields, i; + uint no_fields= table->s->fields, i; NdbConnection *trans= m_active_trans; NdbOperation *op; THD *thd= current_thd; @@ -1218,7 +1218,7 @@ int ha_ndbcluster::unique_index_read(const byte *key, } // Get non-index attribute(s) - for (i= 0; i < table->fields; i++) + for (i= 0; i < table->s->fields; i++) { Field *field= table->field[i]; if ((thd->query_id == field->query_id) || @@ -1502,7 +1502,7 @@ int ha_ndbcluster::define_read_attrs(byte* buf, NdbOperation* op) DBUG_ENTER("define_read_attrs"); // Define attributes to read - for (i= 0; i < table->fields; i++) + for (i= 0; i < table->s->fields; i++) { Field *field= table->field[i]; if ((thd->query_id == field->query_id) || @@ -1518,11 +1518,11 @@ int ha_ndbcluster::define_read_attrs(byte* buf, NdbOperation* op) } } - if (table->primary_key == MAX_KEY) + if (table->s->primary_key == MAX_KEY) { DBUG_PRINT("info", ("Getting hidden key")); // Scanning table with no primary key - int hidden_no= table->fields; + int hidden_no= table->s->fields; #ifndef DBUG_OFF const NDBTAB *tab= (const NDBTAB *) m_table; if (!tab->getColumn(hidden_no)) @@ -1722,13 +1722,13 @@ int ha_ndbcluster::write_row(byte *record) DBUG_ENTER("write_row"); - if(m_ignore_dup_key && table->primary_key != MAX_KEY) + if (m_ignore_dup_key && table->s->primary_key != MAX_KEY) { int peek_res= peek_row(); if (!peek_res) { - m_dupkey= table->primary_key; + m_dupkey= table->s->primary_key; DBUG_RETURN(HA_ERR_FOUND_DUPP_KEY); } if (peek_res != HA_ERR_KEY_NOT_FOUND) @@ -1747,12 +1747,12 @@ int ha_ndbcluster::write_row(byte *record) if (res != 0) ERR_RETURN(trans->getNdbError()); - if (table->primary_key == MAX_KEY) + if (table->s->primary_key == MAX_KEY) { // Table has hidden primary key Ndb *ndb= get_ndb(); Uint64 auto_value= ndb->getAutoIncrementValue((const NDBTAB *) m_table); - if (set_hidden_key(op, table->fields, (const byte*)&auto_value)) + if (set_hidden_key(op, table->s->fields, (const byte*)&auto_value)) ERR_RETURN(op->getNdbError()); } else @@ -1772,7 +1772,7 @@ int ha_ndbcluster::write_row(byte *record) // Set non-key attribute(s) bool set_blob_value= FALSE; - for (i= 0; i < table->fields; i++) + for (i= 0; i < table->s->fields; i++) { Field *field= table->field[i]; if (!(field->flags & PRI_KEY_FLAG) && @@ -1895,8 +1895,8 @@ int ha_ndbcluster::update_row(const byte *old_data, byte *new_data) table->timestamp_field->set_time(); /* Check for update of primary key for special handling */ - if ((table->primary_key != MAX_KEY) && - (key_cmp(table->primary_key, old_data, new_data))) + if ((table->s->primary_key != MAX_KEY) && + (key_cmp(table->s->primary_key, old_data, new_data))) { int read_res, insert_res, delete_res; @@ -1952,14 +1952,14 @@ int ha_ndbcluster::update_row(const byte *old_data, byte *new_data) op->updateTuple() != 0) ERR_RETURN(trans->getNdbError()); - if (table->primary_key == MAX_KEY) + if (table->s->primary_key == MAX_KEY) { // This table has no primary key, use "hidden" primary key DBUG_PRINT("info", ("Using hidden key")); // Require that the PK for this record has previously been // read into m_value - uint no_fields= table->fields; + uint no_fields= table->s->fields; NdbRecAttr* rec= m_value[no_fields].rec; DBUG_ASSERT(rec); DBUG_DUMP("key", (char*)rec->aRef(), NDB_HIDDEN_PRIMARY_KEY_LENGTH); @@ -1976,7 +1976,7 @@ int ha_ndbcluster::update_row(const byte *old_data, byte *new_data) } // Set non-key attribute(s) - for (i= 0; i < table->fields; i++) + for (i= 0; i < table->s->fields; i++) { Field *field= table->field[i]; if (((thd->query_id == field->query_id) || m_retrieve_all_fields) && @@ -2037,11 +2037,11 @@ int ha_ndbcluster::delete_row(const byte *record) no_uncommitted_rows_update(-1); - if (table->primary_key == MAX_KEY) + if (table->s->primary_key == MAX_KEY) { // This table has no primary key, use "hidden" primary key DBUG_PRINT("info", ("Using hidden key")); - uint no_fields= table->fields; + uint no_fields= table->s->fields; NdbRecAttr* rec= m_value[no_fields].rec; DBUG_ASSERT(rec != NULL); @@ -2088,8 +2088,8 @@ void ha_ndbcluster::unpack_record(byte* buf) DBUG_ENTER("unpack_record"); // Set null flag(s) - bzero(buf, table->null_bytes); - for (field= table->field, end= field+table->fields; + bzero(buf, table->s->null_bytes); + for (field= table->field, end= field+table->s->fields; field < end; field++, value++) { @@ -2114,10 +2114,10 @@ void ha_ndbcluster::unpack_record(byte* buf) #ifndef DBUG_OFF // Read and print all values that was fetched - if (table->primary_key == MAX_KEY) + if (table->s->primary_key == MAX_KEY) { // Table with hidden primary key - int hidden_no= table->fields; + int hidden_no= table->s->fields; const NDBTAB *tab= (const NDBTAB *) m_table; const NDBCOL *hidden_col= tab->getColumn(hidden_no); NdbRecAttr* rec= m_value[hidden_no].rec; @@ -2143,7 +2143,7 @@ void ha_ndbcluster::print_results() if (!_db_on_) DBUG_VOID_RETURN; - for (uint f=0; ffields;f++) + for (uint f=0; fs->fields;f++) { Field *field; const NDBCOL *col; @@ -2532,7 +2532,7 @@ int ha_ndbcluster::rnd_init(bool scan) int res= cursor->restart(m_force_send); DBUG_ASSERT(res == 0); } - index_init(table->primary_key); + index_init(table->s->primary_key); DBUG_RETURN(0); } @@ -2616,9 +2616,9 @@ void ha_ndbcluster::position(const byte *record) byte *buff; DBUG_ENTER("position"); - if (table->primary_key != MAX_KEY) + if (table->s->primary_key != MAX_KEY) { - key_info= table->key_info + table->primary_key; + key_info= table->key_info + table->s->primary_key; key_part= key_info->key_part; end= key_part + key_info->key_parts; buff= ref; @@ -2642,7 +2642,7 @@ void ha_ndbcluster::position(const byte *record) { // No primary key, get hidden key DBUG_PRINT("info", ("Getting hidden key")); - int hidden_no= table->fields; + int hidden_no= table->s->fields; NdbRecAttr* rec= m_value[hidden_no].rec; const NDBTAB *tab= (const NDBTAB *) m_table; const NDBCOL *hidden_col= tab->getColumn(hidden_no); @@ -3470,7 +3470,7 @@ int ha_ndbcluster::create(const char *name, NDBCOL col; uint pack_length, length, i, pk_length= 0; const void *data, *pack_data; - const char **key_names= form->keynames.type_names; + const char **key_names= form->s->keynames.type_names; char name2[FN_HEADLEN]; bool create_from_engine= (info->table_options & HA_CREATE_FROM_ENGINE); @@ -3506,7 +3506,7 @@ int ha_ndbcluster::create(const char *name, my_free((char*)data, MYF(0)); my_free((char*)pack_data, MYF(0)); - for (i= 0; i < form->fields; i++) + for (i= 0; i < form->s->fields; i++) { Field *field= form->field[i]; DBUG_PRINT("info", ("name: %s, type: %u, pack_length: %d", @@ -3520,7 +3520,7 @@ int ha_ndbcluster::create(const char *name, } // No primary key, create shadow key as 64 bit, auto increment - if (form->primary_key == MAX_KEY) + if (form->s->primary_key == MAX_KEY) { DBUG_PRINT("info", ("Generating shadow key")); col.setName("$PK"); @@ -3534,7 +3534,7 @@ int ha_ndbcluster::create(const char *name, } // Make sure that blob tables don't have to big part size - for (i= 0; i < form->fields; i++) + for (i= 0; i < form->s->fields; i++) { /** * The extra +7 concists @@ -3896,9 +3896,9 @@ int ha_ndbcluster::open(const char *name, int mode, uint test_if_locked) // Setup ref_length to make room for the whole // primary key to be written in the ref variable - if (table->primary_key != MAX_KEY) + if (table->s->primary_key != MAX_KEY) { - key= table->key_info+table->primary_key; + key= table->key_info+table->s->primary_key; ref_length= key->key_length; DBUG_PRINT("info", (" ref_length: %d", ref_length)); } @@ -4237,7 +4237,7 @@ int ndbcluster_find_files(THD *thd,const char *db,const char *path, TABLE_LIST table_list; bzero((char*) &table_list,sizeof(table_list)); table_list.db= (char*) db; - table_list.alias=table_list.real_name=(char*)file_name; + table_list.alias= table_list.table_name= (char*)file_name; (void)mysql_rm_table_part2(thd, &table_list, /* if_exists */ TRUE, /* drop_temporary */ FALSE, @@ -4372,7 +4372,7 @@ void ndbcluster_print_error(int error, const NdbOperation *error_op) DBUG_ENTER("ndbcluster_print_error"); TABLE tab; const char *tab_name= (error_op) ? error_op->getTableName() : ""; - tab.table_name= (char *) tab_name; + tab.alias= (char *) tab_name; ha_ndbcluster error_handler(&tab); tab.file= &error_handler; error_handler.print_error(error, MYF(0)); diff --git a/sql/handler.cc b/sql/handler.cc index cde2c7b02a8..bbe01dd93d5 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -1017,7 +1017,7 @@ int handler::ha_open(const char *name, int mode, int test_if_locked) int error; DBUG_ENTER("handler::ha_open"); DBUG_PRINT("enter",("name: %s db_type: %d db_stat: %d mode: %d lock_test: %d", - name, table->db_type, table->db_stat, mode, + name, table->s->db_type, table->db_stat, mode, test_if_locked)); if ((error=open(name,mode,test_if_locked))) @@ -1036,7 +1036,7 @@ int handler::ha_open(const char *name, int mode, int test_if_locked) } else { - if (table->db_options_in_use & HA_OPTION_READ_ONLY_DATA) + if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA) table->db_stat|=HA_READ_ONLY; (void) extra(HA_EXTRA_NO_READCHECK); // Not needed in SQL @@ -1214,7 +1214,7 @@ void handler::update_auto_increment() first key part, as there is no guarantee that the first parts will be in sequence */ - if (!table->next_number_key_offset) + if (!table->s->next_number_key_offset) { /* Set next insert id to point to next auto-increment value to be able to @@ -1252,8 +1252,8 @@ ulonglong handler::get_auto_increment() int error; (void) extra(HA_EXTRA_KEYREAD); - index_init(table->next_number_index); - if (!table->next_number_key_offset) + index_init(table->s->next_number_index); + if (!table->s->next_number_key_offset) { // Autoincrement at key-start error=index_last(table->record[1]); } @@ -1261,17 +1261,17 @@ ulonglong handler::get_auto_increment() { byte key[MAX_KEY_LENGTH]; key_copy(key, table->record[0], - table->key_info + table->next_number_index, - table->next_number_key_offset); - error=index_read(table->record[1], key, table->next_number_key_offset, - HA_READ_PREFIX_LAST); + table->key_info + table->s->next_number_index, + table->s->next_number_key_offset); + error= index_read(table->record[1], key, table->s->next_number_key_offset, + HA_READ_PREFIX_LAST); } if (error) nr=1; else - nr=((ulonglong) table->next_number_field-> - val_int_offset(table->rec_buff_length)+1); + nr= ((ulonglong) table->next_number_field-> + val_int_offset(table->s->rec_buff_length)+1); index_end(); (void) extra(HA_EXTRA_NO_KEYREAD); return nr; @@ -1396,10 +1396,10 @@ void handler::print_error(int error, myf errflag) */ char *db; char buff[FN_REFLEN]; - uint length=dirname_part(buff,table->path); + uint length= dirname_part(buff,table->s->path); buff[length-1]=0; db=buff+dirname_length(buff); - my_error(ER_NO_SUCH_TABLE, MYF(0), db, table->table_name); + my_error(ER_NO_SUCH_TABLE, MYF(0), db, table->alias); break; } default: @@ -1422,7 +1422,7 @@ void handler::print_error(int error, myf errflag) DBUG_VOID_RETURN; } } - my_error(textno, errflag, table->table_name, error); + my_error(textno, errflag, table->alias, error); DBUG_VOID_RETURN; } diff --git a/sql/item.cc b/sql/item.cc index 7dba1f3a66a..c84496f8eb7 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -569,7 +569,7 @@ bool DTCollation::aggregate(DTCollation &dt, uint flags) } Item_field::Item_field(Field *f) - :Item_ident(NullS, f->table_name, f->field_name), + :Item_ident(NullS, *f->table_name, f->field_name), item_equal(0), no_const_subst(0), have_privileges(0), any_privileges(0) { @@ -582,7 +582,7 @@ Item_field::Item_field(Field *f) } Item_field::Item_field(THD *thd, Field *f) - :Item_ident(f->table->table_cache_key, f->table_name, f->field_name), + :Item_ident(f->table->s->db, *f->table_name, f->field_name), item_equal(0), no_const_subst(0), have_privileges(0), any_privileges(0) { @@ -636,9 +636,9 @@ void Item_field::set_field(Field *field_par) maybe_null=field->maybe_null(); max_length=field_par->field_length; decimals= field->decimals(); - table_name=field_par->table_name; - field_name=field_par->field_name; - db_name=field_par->table->table_cache_key; + table_name= *field_par->table_name; + field_name= field_par->field_name; + db_name= field_par->table->s->db; alias_name_used= field_par->table->alias_name_used; unsigned_flag=test(field_par->flags & UNSIGNED_FLAG); collation.set(field_par->charset(), DERIVATION_IMPLICIT); @@ -1576,16 +1576,18 @@ bool Item_ref_null_helper::get_date(TIME *ltime, uint fuzzydate) static void mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current, Item_ident *item) { - // store pointer on SELECT_LEX from which item is dependent + const char *db_name= item->db_name ? item->db_name : ""; + const char *table_name= item->table_name ? item->table_name : ""; + /* store pointer on SELECT_LEX from which item is dependent */ item->depended_from= last; current->mark_as_dependent(last); if (thd->lex->describe & DESCRIBE_EXTENDED) { char warn_buff[MYSQL_ERRMSG_SIZE]; sprintf(warn_buff, ER(ER_WARN_FIELD_RESOLVED), - (item->db_name?item->db_name:""), (item->db_name?".":""), - (item->table_name?item->table_name:""), (item->table_name?".":""), - item->field_name, + db_name, (db_name[0] ? "." : ""), + table_name, (table_name [0] ? "." : ""), + item->field_name, current->select_number, last->select_number); push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_WARN_FIELD_RESOLVED, warn_buff); @@ -1745,8 +1747,9 @@ resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select) Search for a column or derived column named as 'ref' in the SELECT clause of the current select. */ - if (!(select_ref= find_item_in_list(ref, *(select->get_item_list()), &counter, - REPORT_EXCEPT_NOT_FOUND, ¬_used))) + if (!(select_ref= find_item_in_list(ref, *(select->get_item_list()), + &counter, REPORT_EXCEPT_NOT_FOUND, + ¬_used))) return NULL; /* Some error occurred. */ /* If this is a non-aggregated field inside HAVING, search in GROUP BY. */ @@ -2053,7 +2056,7 @@ bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **reference) else { db= cached_table->db; - tab= cached_table->real_name; + tab= cached_table->table_name; } if (!(have_privileges= (get_column_grant(thd, &field->table->grant, db, tab, field_name) & @@ -3195,7 +3198,7 @@ bool Item_default_value::fix_fields(THD *thd, if (!(def_field= (Field*) sql_alloc(field_arg->field->size_of()))) return TRUE; memcpy(def_field, field_arg->field, field_arg->field->size_of()); - def_field->move_field(def_field->table->default_values - + def_field->move_field(def_field->table->s->default_values - def_field->table->record[0]); set_field(def_field); return FALSE; diff --git a/sql/item_func.cc b/sql/item_func.cc index 69ddd21f913..7768caa2507 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -3198,7 +3198,7 @@ bool Item_func_match::fix_index() if (key == NO_SUCH_KEY) return 0; - for (keynr=0 ; keynr < table->keys ; keynr++) + for (keynr=0 ; keynr < table->s->keys ; keynr++) { if ((table->key_info[keynr].flags & HA_FULLTEXT) && (table->keys_in_use_for_query.is_set(keynr))) diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc index dbf30d7d793..2d4f88ed57b 100644 --- a/sql/item_subselect.cc +++ b/sql/item_subselect.cc @@ -1497,7 +1497,7 @@ void subselect_uniquesubquery_engine::print(String *str) str->append("(", 23); tab->ref.items[0]->print(str); str->append(" in ", 4); - str->append(tab->table->real_name); + str->append(tab->table->s->table_name); KEY *key_info= tab->table->key_info+ tab->ref.key; str->append(" on ", 4); str->append(key_info->name); @@ -1515,7 +1515,7 @@ void subselect_indexsubquery_engine::print(String *str) str->append("(", 15); tab->ref.items[0]->print(str); str->append(" in ", 4); - str->append(tab->table->real_name); + str->append(tab->table->s->table_name); KEY *key_info= tab->table->key_info+ tab->ref.key; str->append(" on ", 4); str->append(key_info->name); diff --git a/sql/item_sum.cc b/sql/item_sum.cc index 1c005cf60a9..168c68ad706 100644 --- a/sql/item_sum.cc +++ b/sql/item_sum.cc @@ -1225,7 +1225,7 @@ int composite_key_cmp(void* arg, byte* key1, byte* key2) { Item_sum_count_distinct* item = (Item_sum_count_distinct*)arg; Field **field = item->table->field; - Field **field_end= field + item->table->fields; + Field **field_end= field + item->table->s->fields; uint32 *lengths=item->field_lengths; for (; field < field_end; ++field) { @@ -1344,15 +1344,15 @@ bool Item_sum_count_distinct::setup(THD *thd) // no blobs, otherwise it would be MyISAM - if (table->db_type == DB_TYPE_HEAP) + if (table->s->db_type == DB_TYPE_HEAP) { qsort_cmp2 compare_key; void* cmp_arg; // to make things easier for dump_leaf if we ever have to dump to MyISAM - restore_record(table,default_values); + restore_record(table,s->default_values); - if (table->fields == 1) + if (table->s->fields == 1) { /* If we have only one field, which is the most common use of @@ -1396,10 +1396,10 @@ bool Item_sum_count_distinct::setup(THD *thd) { bool all_binary = 1; Field** field, **field_end; - field_end = (field = table->field) + table->fields; + field_end = (field = table->field) + table->s->fields; uint32 *lengths; if (!(field_lengths= - (uint32*) thd->alloc(sizeof(uint32) * table->fields))) + (uint32*) thd->alloc(sizeof(uint32) * table->s->fields))) return 1; for (key_length = 0, lengths=field_lengths; field < field_end; ++field) @@ -1410,7 +1410,7 @@ bool Item_sum_count_distinct::setup(THD *thd) if (!(*field)->binary()) all_binary = 0; // Can't break loop here } - rec_offset = table->reclength - key_length; + rec_offset= table->s->reclength - key_length; if (all_binary) { compare_key = (qsort_cmp2)simple_raw_key_cmp; @@ -1781,7 +1781,7 @@ int dump_leaf_key(byte* key, uint32 count __attribute__((unused)), String *res; char *save_ptr= field->ptr; uint offset= (uint) (save_ptr - record); - DBUG_ASSERT(offset < item->table->reclength); + DBUG_ASSERT(offset < item->table->s->reclength); field->ptr= (char *) key + offset; res= field->val_str(&tmp,&tmp2); item->result.append(*res); @@ -2124,10 +2124,10 @@ bool Item_func_group_concat::setup(THD *thd) table->file->extra(HA_EXTRA_NO_ROWS); table->no_rows= 1; - key_length= table->reclength; + key_length= table->s->reclength; /* Offset to first result field in table */ - field_list_offset= table->fields - (list.elements - const_fields); + field_list_offset= table->s->fields - (list.elements - const_fields); if (tree_mode) delete_tree(tree); diff --git a/sql/key.cc b/sql/key.cc index d54b8721cab..aec294e370a 100644 --- a/sql/key.cc +++ b/sql/key.cc @@ -38,7 +38,9 @@ int find_ref_key(TABLE *table,Field *field, uint *key_length) /* Test if some key starts as fieldpos */ - for (i=0, key_info=table->key_info ; i < (int) table->keys ; i++, key_info++) + for (i= 0, key_info= table->key_info ; + i < (int) table->s->keys ; + i++, key_info++) { if (key_info->key_part[0].offset == fieldpos) { /* Found key. Calc keylength */ @@ -48,7 +50,9 @@ int find_ref_key(TABLE *table,Field *field, uint *key_length) } /* Test if some key contains fieldpos */ - for (i=0, key_info=table->key_info ; i < (int) table->keys ; i++, key_info++) + for (i= 0, key_info= table->key_info ; + i < (int) table->s->keys ; + i++, key_info++) { uint j; KEY_PART_INFO *key_part; @@ -373,9 +377,9 @@ bool check_if_key_used(TABLE *table, uint idx, List &fields) If table handler has primary key as part of the index, check that primary key is not updated */ - if (idx != table->primary_key && table->primary_key < MAX_KEY && + if (idx != table->s->primary_key && table->s->primary_key < MAX_KEY && (table->file->table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX)) - return check_if_key_used(table, table->primary_key, fields); + return check_if_key_used(table, table->s->primary_key, fields); return 0; } diff --git a/sql/lock.cc b/sql/lock.cc index 973e82b7b10..fffd48d5305 100644 --- a/sql/lock.cc +++ b/sql/lock.cc @@ -401,7 +401,7 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count, *write_lock_used=0; for (i=tables=lock_count=0 ; i < count ; i++) { - if (table_ptr[i]->tmp_table != TMP_TABLE) + if (table_ptr[i]->s->tmp_table != TMP_TABLE) { tables+=table_ptr[i]->file->lock_count(); lock_count++; @@ -421,7 +421,7 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count, for (i=0 ; i < count ; i++) { TABLE *table; - if ((table=table_ptr[i])->tmp_table == TMP_TABLE) + if ((table=table_ptr[i])->s->tmp_table == TMP_TABLE) continue; *to++=table; enum thr_lock_type lock_type= table->reginfo.lock_type; @@ -430,7 +430,7 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count, *write_lock_used=table; if (table->db_stat & HA_READ_ONLY) { - my_error(ER_OPEN_AS_READONLY, MYF(0), table->table_name); + my_error(ER_OPEN_AS_READONLY, MYF(0), table->alias); my_free((gptr) sql_lock,MYF(0)); return 0; } @@ -526,11 +526,11 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list) char *db= table_list->db; uint key_length; DBUG_ENTER("lock_table_name"); - DBUG_PRINT("enter",("db: %s name: %s", db, table_list->real_name)); + DBUG_PRINT("enter",("db: %s name: %s", db, table_list->table_name)); safe_mutex_assert_owner(&LOCK_open); - key_length=(uint) (strmov(strmov(key,db)+1,table_list->real_name) + key_length=(uint) (strmov(strmov(key,db)+1,table_list->table_name) -key)+ 1; @@ -549,8 +549,9 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list) if (!(table= (TABLE*) my_malloc(sizeof(*table)+key_length, MYF(MY_WME | MY_ZEROFILL)))) DBUG_RETURN(-1); - memcpy((table->table_cache_key= (char*) (table+1)), key, key_length); - table->key_length=key_length; + table->s= &table->share_not_to_be_used; + memcpy((table->s->table_cache_key= (char*) (table+1)), key, key_length); + table->s->key_length=key_length; table->in_use=thd; table->locked_by_name=1; table_list->table=table; @@ -560,7 +561,7 @@ int lock_table_name(THD *thd, TABLE_LIST *table_list) my_free((gptr) table,MYF(0)); DBUG_RETURN(-1); } - if (remove_table_from_cache(thd, db, table_list->real_name)) + if (remove_table_from_cache(thd, db, table_list->table_name)) DBUG_RETURN(1); // Table is in use DBUG_RETURN(0); } diff --git a/sql/log_event.cc b/sql/log_event.cc index adebf446a82..2fa4e09913e 100644 --- a/sql/log_event.cc +++ b/sql/log_event.cc @@ -2495,7 +2495,7 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli, TABLE_LIST tables; bzero((char*) &tables,sizeof(tables)); tables.db = thd->db; - tables.alias = tables.real_name = (char*)table_name; + tables.alias = tables.table_name = (char*) table_name; tables.lock_type = TL_WRITE; tables.updating= 1; @@ -2516,11 +2516,11 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli, user in SHOW PROCESSLIST. Note that db is known in the 'db' column. */ if ((load_data_query= (char *) my_alloca(18 + strlen(fname) + 14 + - strlen(tables.real_name) + 8))) + strlen(tables.table_name) + 8))) { thd->query_length= (uint)(strxmov(load_data_query, "LOAD DATA INFILE '", fname, - "' INTO TABLE `", tables.real_name, + "' INTO TABLE `", tables.table_name, "` <...>", NullS) - load_data_query); thd->query= load_data_query; } diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 01e2510328d..6f569ea3ef4 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -1269,7 +1269,7 @@ inline void mark_as_null_row(TABLE *table) { table->null_row=1; table->status|=STATUS_NULL_ROW; - bfill(table->null_flags,table->null_bytes,255); + bfill(table->null_flags,table->s->null_bytes,255); } inline void table_case_convert(char * name, uint length) @@ -1319,7 +1319,7 @@ inline void setup_table_map(TABLE *table, TABLE_LIST *table_list, uint tablenr) table->const_table= 0; table->null_row= 0; table->status= STATUS_NO_RECORD; - table->keys_in_use_for_query= table->keys_in_use; + table->keys_in_use_for_query= table->s->keys_in_use; table->maybe_null= test(table->outer_join= table_list->outer_join); table->tablenr= tablenr; table->map= (table_map) 1 << tablenr; diff --git a/sql/opt_range.cc b/sql/opt_range.cc index e7f03b51fc0..7e05e51e182 100644 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@ -712,7 +712,7 @@ QUICK_SELECT_I::QUICK_SELECT_I() QUICK_RANGE_SELECT::QUICK_RANGE_SELECT(THD *thd, TABLE *table, uint key_nr, bool no_alloc, MEM_ROOT *parent_alloc) - :dont_free(0),error(0),free_file(0),cur_range(NULL),range(0),in_range(0) + :dont_free(0),error(0),free_file(0),in_range(0),cur_range(NULL),range(0) { sorted= 0; index= key_nr; @@ -822,7 +822,7 @@ QUICK_INDEX_MERGE_SELECT::push_quick_back(QUICK_RANGE_SELECT *quick_sel_range) processed separately. */ if (head->file->primary_key_is_clustered() && - quick_sel_range->index == head->primary_key) + quick_sel_range->index == head->s->primary_key) pk_quick_select= quick_sel_range; else return quick_selects.push_back(quick_sel_range); @@ -927,10 +927,10 @@ int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler) DBUG_RETURN(0); } - if (!(file= get_new_handler(head, head->db_type))) + if (!(file= get_new_handler(head, head->s->db_type))) goto failure; DBUG_PRINT("info", ("Allocated new handler %p", file)); - if (file->ha_open(head->path, head->db_stat, HA_OPEN_IGNORE_IF_LOCKED)) + if (file->ha_open(head->s->path, head->db_stat, HA_OPEN_IGNORE_IF_LOCKED)) { /* Caller will free the memory */ goto failure; @@ -1551,7 +1551,7 @@ public: static int fill_used_fields_bitmap(PARAM *param) { TABLE *table= param->table; - param->fields_bitmap_size= (table->fields/8 + 1); + param->fields_bitmap_size= (table->s->fields/8 + 1); uchar *tmp; uint pk; if (!(tmp= (uchar*)alloc_root(param->mem_root,param->fields_bitmap_size)) || @@ -1560,13 +1560,13 @@ static int fill_used_fields_bitmap(PARAM *param) return 1; bitmap_clear_all(¶m->needed_fields); - for (uint i= 0; i < table->fields; i++) + for (uint i= 0; i < table->s->fields; i++) { if (param->thd->query_id == table->field[i]->query_id) bitmap_set_bit(¶m->needed_fields, i+1); } - pk= param->table->primary_key; + pk= param->table->s->primary_key; if (param->table->file->primary_key_is_clustered() && pk != MAX_KEY) { /* The table uses clustered PK and it is not internally generated */ @@ -1674,10 +1674,10 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use, thd->no_errors=1; // Don't warn about NULL init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0); - if (!(param.key_parts = (KEY_PART*) alloc_root(&alloc, - sizeof(KEY_PART)* - head->key_parts)) - || fill_used_fields_bitmap(¶m)) + if (!(param.key_parts= (KEY_PART*) alloc_root(&alloc, + sizeof(KEY_PART)* + head->s->key_parts)) || + fill_used_fields_bitmap(¶m)) { thd->no_errors=0; free_root(&alloc,MYF(0)); // Return memory & allocator @@ -1692,7 +1692,7 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use, This is used in get_mm_parts function. */ key_info= head->key_info; - for (idx=0 ; idx < head->keys ; idx++, key_info++) + for (idx=0 ; idx < head->s->keys ; idx++, key_info++) { KEY_PART_INFO *key_part_info; if (!keys_to_use.is_set(idx)) @@ -1876,7 +1876,7 @@ double get_sweep_read_cost(const PARAM *param, ha_rows records) double result; if (param->table->file->primary_key_is_clustered()) { - result= param->table->file->read_time(param->table->primary_key, + result= param->table->file->read_time(param->table->s->primary_key, records, records); } else @@ -2040,7 +2040,8 @@ TABLE_READ_PLAN *get_best_disjunct_quick(PARAM *param, SEL_IMERGE *imerge, all_scans_ror_able &= ((*ptree)->n_ror_scans > 0); all_scans_rors &= (*cur_child)->is_ror; if (pk_is_clustered && - param->real_keynr[(*cur_child)->key_idx] == param->table->primary_key) + param->real_keynr[(*cur_child)->key_idx] == + param->table->s->primary_key) { cpk_scan= cur_child; cpk_scan_records= (*cur_child)->records; @@ -2763,13 +2764,15 @@ TRP_ROR_INTERSECT *get_best_ror_intersect(const PARAM *param, SEL_TREE *tree, */ ROR_SCAN_INFO **cur_ror_scan; ROR_SCAN_INFO *cpk_scan= NULL; + uint cpk_no; bool cpk_scan_used= FALSE; + if (!(tree->ror_scans= (ROR_SCAN_INFO**)alloc_root(param->mem_root, sizeof(ROR_SCAN_INFO*)* param->keys))) return NULL; - uint cpk_no= (param->table->file->primary_key_is_clustered())? - param->table->primary_key : MAX_KEY; + cpk_no= ((param->table->file->primary_key_is_clustered()) ? + param->table->s->primary_key : MAX_KEY); for (idx= 0, cur_ror_scan= tree->ror_scans; idx < param->keys; idx++) { @@ -3128,7 +3131,7 @@ static TRP_RANGE *get_key_scans_params(PARAM *param, SEL_TREE *tree, read_index_only && (param->table->file->index_flags(keynr, param->max_key_part,1) & HA_KEYREAD_ONLY) && - !(pk_is_clustered && keynr == param->table->primary_key)) + !(pk_is_clustered && keynr == param->table->s->primary_key)) /* We can resolve this by only reading through this key. */ found_read_time= get_index_only_read_time(param,found_records,keynr) + cpu_cost; @@ -4975,8 +4978,8 @@ check_quick_select(PARAM *param,uint idx,SEL_ARG *tree) Clustered PK scan is a special case, check_quick_keys doesn't recognize CPK scans as ROR scans (while actually any CPK scan is a ROR scan). */ - cpk_scan= (param->table->primary_key == param->real_keynr[idx]) && - param->table->file->primary_key_is_clustered(); + cpk_scan= ((param->table->s->primary_key == param->real_keynr[idx]) && + param->table->file->primary_key_is_clustered()); param->is_ror_scan= !cpk_scan; } @@ -5237,12 +5240,13 @@ static bool is_key_scan_ror(PARAM *param, uint keynr, uint8 nparts) { KEY *table_key= param->table->key_info + keynr; KEY_PART_INFO *key_part= table_key->key_part + nparts; - KEY_PART_INFO *key_part_end= table_key->key_part + - table_key->key_parts; + KEY_PART_INFO *key_part_end= (table_key->key_part + + table_key->key_parts); + uint pk_number; if (key_part == key_part_end) return TRUE; - uint pk_number= param->table->primary_key; + pk_number= param->table->s->primary_key; if (!param->table->file->primary_key_is_clustered() || pk_number == MAX_KEY) return FALSE; @@ -5947,7 +5951,7 @@ int QUICK_RANGE_SELECT::get_next_init(void) if (file->table_flags() & HA_NEED_READ_RANGE_BUFFER) { mrange_bufsiz= min(multi_range_bufsiz, - QUICK_SELECT_I::records * head->reclength); + QUICK_SELECT_I::records * head->s->reclength); while (mrange_bufsiz && ! my_multi_malloc(MYF(MY_WME), @@ -6795,7 +6799,6 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree) ORDER *tmp_group; Item *item; Item_field *item_field; - DBUG_ENTER("get_best_group_min_max"); /* Perform few 'cheap' tests whether this access method is applicable. */ @@ -6805,7 +6808,7 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree) ((!join->group_list) && /* Neither GROUP BY nor a DISTINCT query. */ (!join->select_distinct))) DBUG_RETURN(NULL); - if(table->keys == 0) /* There are no indexes to use. */ + if (table->s->keys == 0) /* There are no indexes to use. */ DBUG_RETURN(NULL); /* Analyze the query in more detail. */ @@ -6863,7 +6866,7 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree) first one. Here we set the variables: group_prefix_len and index_info. */ KEY *cur_index_info= table->key_info; - KEY *cur_index_info_end= cur_index_info + table->keys; + KEY *cur_index_info_end= cur_index_info + table->s->keys; KEY_PART_INFO *cur_part= NULL; KEY_PART_INFO *end_part; /* Last part for loops. */ /* Last index part. */ @@ -8279,21 +8282,26 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range() (cur_range->flag & (EQ_RANGE | NULL_RANGE))) continue; /* Check the next range. */ else if (result) - /* - In all other cases (HA_ERR_*, HA_READ_KEY_EXACT with NO_MIN_RANGE, - HA_READ_AFTER_KEY, HA_READ_KEY_OR_NEXT) if the lookup failed for this - range, it can't succeed for any other subsequent range. - */ + { + /* + In all other cases (HA_ERR_*, HA_READ_KEY_EXACT with NO_MIN_RANGE, + HA_READ_AFTER_KEY, HA_READ_KEY_OR_NEXT) if the lookup failed for this + range, it can't succeed for any other subsequent range. + */ break; + } /* A key was found. */ if (cur_range->flag & EQ_RANGE) break; /* No need to perform the checks below for equal keys. */ if (cur_range->flag & NULL_RANGE) - { /* Remember this key, and continue looking for a non-NULL key that */ - /* satisfies some other condition. */ - memcpy(tmp_record, record, head->rec_buff_length); + { + /* + Remember this key, and continue looking for a non-NULL key that + satisfies some other condition. + */ + memcpy(tmp_record, record, head->s->rec_buff_length); found_null= TRUE; continue; } @@ -8334,7 +8342,7 @@ int QUICK_GROUP_MIN_MAX_SELECT::next_min_in_range() */ if (found_null && result) { - memcpy(record, tmp_record, head->rec_buff_length); + memcpy(record, tmp_record, head->s->rec_buff_length); result= 0; } return result; diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc index 80226dcfa2c..ef9babf7713 100644 --- a/sql/opt_sum.cc +++ b/sql/opt_sum.cc @@ -644,7 +644,7 @@ static bool find_key_for_maxmin(bool max_fl, TABLE_REF *ref, uint idx= 0; KEY *keyinfo,*keyinfo_end; - for (keyinfo= table->key_info, keyinfo_end= keyinfo+table->keys ; + for (keyinfo= table->key_info, keyinfo_end= keyinfo+table->s->keys ; keyinfo != keyinfo_end; keyinfo++,idx++) { diff --git a/sql/records.cc b/sql/records.cc index 3c0143d2307..9a506cadf0c 100644 --- a/sql/records.cc +++ b/sql/records.cc @@ -26,7 +26,7 @@ static int rr_unpack_from_tempfile(READ_RECORD *info); static int rr_unpack_from_buffer(READ_RECORD *info); static int rr_from_pointers(READ_RECORD *info); static int rr_from_cache(READ_RECORD *info); -static int init_rr_cache(READ_RECORD *info); +static int init_rr_cache(THD *thd, READ_RECORD *info); static int rr_cmp(uchar *a,uchar *b); /* init struct for read with info->read_record */ @@ -84,14 +84,14 @@ void init_read_record(READ_RECORD *info,THD *thd, TABLE *table, !(table->file->table_flags() & HA_FAST_KEY_READ) && (table->db_stat & HA_READ_ONLY || table->reginfo.lock_type <= TL_READ_NO_INSERT) && - (ulonglong) table->reclength*(table->file->records+ - table->file->deleted) > + (ulonglong) table->s->reclength* (table->file->records+ + table->file->deleted) > (ulonglong) MIN_FILE_LENGTH_TO_USE_ROW_CACHE && - info->io_cache->end_of_file/info->ref_length*table->reclength > + info->io_cache->end_of_file/info->ref_length * table->s->reclength > (my_off_t) MIN_ROWS_TO_USE_TABLE_CACHE && - !table->blob_fields) + !table->s->blob_fields) { - if (! init_rr_cache(info)) + if (! init_rr_cache(thd, info)) { DBUG_PRINT("info",("using rr_from_cache")); info->read_record=rr_from_cache; @@ -133,7 +133,7 @@ void init_read_record(READ_RECORD *info,THD *thd, TABLE *table, if (!table->no_cache && (use_record_cache > 0 || (int) table->reginfo.lock_type <= (int) TL_READ_HIGH_PRIORITY || - !(table->db_options_in_use & HA_OPTION_PACK_RECORD) || + !(table->s->db_options_in_use & HA_OPTION_PACK_RECORD) || (use_record_cache < 0 && !(table->file->table_flags() & HA_NOT_DELETE_WITH_CACHE)))) VOID(table->file->extra_opt(HA_EXTRA_CACHE, @@ -329,23 +329,21 @@ static int rr_unpack_from_buffer(READ_RECORD *info) } /* cacheing of records from a database */ -static int init_rr_cache(READ_RECORD *info) +static int init_rr_cache(THD *thd, READ_RECORD *info) { uint rec_cache_size; - THD *thd= current_thd; - DBUG_ENTER("init_rr_cache"); - info->struct_length=3+MAX_REFLENGTH; - info->reclength=ALIGN_SIZE(info->table->reclength+1); + info->struct_length= 3+MAX_REFLENGTH; + info->reclength= ALIGN_SIZE(info->table->s->reclength+1); if (info->reclength < info->struct_length) - info->reclength=ALIGN_SIZE(info->struct_length); + info->reclength= ALIGN_SIZE(info->struct_length); - info->error_offset=info->table->reclength; - info->cache_records= thd->variables.read_rnd_buff_size / - (info->reclength+info->struct_length); - rec_cache_size=info->cache_records*info->reclength; - info->rec_cache_size=info->cache_records*info->ref_length; + info->error_offset= info->table->s->reclength; + info->cache_records= (thd->variables.read_rnd_buff_size / + (info->reclength+info->struct_length)); + rec_cache_size= info->cache_records*info->reclength; + info->rec_cache_size= info->cache_records*info->ref_length; // We have to allocate one more byte to use uint3korr (see comments for it) if (info->cache_records <= 2 || @@ -385,7 +383,8 @@ static int rr_from_cache(READ_RECORD *info) else { error=0; - memcpy(info->record,info->cache_pos,(size_t) info->table->reclength); + memcpy(info->record,info->cache_pos, + (size_t) info->table->s->reclength); } info->cache_pos+=info->reclength; return ((int) error); diff --git a/sql/repl_failsafe.cc b/sql/repl_failsafe.cc index 7852993b95b..de4ad83fdbb 100644 --- a/sql/repl_failsafe.cc +++ b/sql/repl_failsafe.cc @@ -739,7 +739,7 @@ static int fetch_db_tables(THD *thd, MYSQL *mysql, const char *db, { bzero((char*) &table, sizeof(table)); //just for safe table.db= (char*) db; - table.real_name= (char*) table_name; + table.table_name= (char*) table_name; table.updating= 1; if (!tables_ok(thd, &table)) diff --git a/sql/slave.cc b/sql/slave.cc index 6b8559859fc..0bcc1b7e852 100644 --- a/sql/slave.cc +++ b/sql/slave.cc @@ -893,7 +893,7 @@ bool tables_ok(THD* thd, TABLE_LIST* tables) some_tables_updating= 1; end= strmov(hash_key, tables->db ? tables->db : thd->db); *end++= '.'; - len= (uint) (strmov(end, tables->real_name) - hash_key); + len= (uint) (strmov(end, tables->table_name) - hash_key); if (do_table_inited) // if there are any do's { if (hash_search(&replicate_do_table, (byte*) hash_key, len)) @@ -1520,7 +1520,7 @@ static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db, bzero((char*) &tables,sizeof(tables)); tables.db = (char*)db; - tables.alias= tables.real_name= (char*)table_name; + tables.alias= tables.table_name= (char*)table_name; /* Drop the table if 'overwrite' is true */ if (overwrite && mysql_rm_table(thd,&tables,1,0)) /* drop if exists */ @@ -1580,7 +1580,7 @@ static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db, error=file->repair(thd,&check_opt) != 0; thd->net.vio = save_vio; if (error) - my_error(ER_INDEX_REBUILD, MYF(0), tables.table->real_name); + my_error(ER_INDEX_REBUILD, MYF(0), tables.table->s->table_name); err: close_thread_tables(thd); diff --git a/sql/sp.cc b/sql/sp.cc index 65dad60cda7..84b126e5ecd 100644 --- a/sql/sp.cc +++ b/sql/sp.cc @@ -97,8 +97,8 @@ db_find_routine_aux(THD *thd, int type, sp_name *name, else { for (table= thd->open_tables ; table ; table= table->next) - if (strcmp(table->table_cache_key, "mysql") == 0 && - strcmp(table->real_name, "proc") == 0) + if (strcmp(table->s->db, "mysql") == 0 && + strcmp(table->s->table_name, "proc") == 0) break; } if (table) @@ -109,7 +109,7 @@ db_find_routine_aux(THD *thd, int type, sp_name *name, memset(&tables, 0, sizeof(tables)); tables.db= (char*)"mysql"; - tables.real_name= tables.alias= (char*)"proc"; + tables.table_name= tables.alias= (char*)"proc"; if (! (table= open_ltable(thd, &tables, ltype))) { *tablep= NULL; @@ -158,7 +158,7 @@ db_find_routine(THD *thd, int type, sp_name *name, sp_head **sphp) if (ret != SP_OK) goto done; - if (table->fields != MYSQL_PROC_FIELD_COUNT) + if (table->s->fields != MYSQL_PROC_FIELD_COUNT) { ret= SP_GET_FIELD_FAILED; goto done; @@ -356,16 +356,16 @@ db_create_routine(THD *thd, int type, sp_head *sp) memset(&tables, 0, sizeof(tables)); tables.db= (char*)"mysql"; - tables.real_name= tables.alias= (char*)"proc"; + tables.table_name= tables.alias= (char*)"proc"; if (! (table= open_ltable(thd, &tables, TL_WRITE))) ret= SP_OPEN_TABLE_FAILED; else { - restore_record(table, default_values); // Get default values for fields + restore_record(table, s->default_values); // Get default values for fields strxmov(definer, thd->priv_user, "@", thd->priv_host, NullS); - if (table->fields != MYSQL_PROC_FIELD_COUNT) + if (table->s->fields != MYSQL_PROC_FIELD_COUNT) { ret= SP_GET_FIELD_FAILED; goto done; @@ -562,7 +562,7 @@ db_show_routine_status(THD *thd, int type, const char *wild) memset(&tables, 0, sizeof(tables)); tables.db= (char*)"mysql"; - tables.real_name= tables.alias= (char*)"proc"; + tables.table_name= tables.alias= (char*)"proc"; if (! (table= open_ltable(thd, &tables, TL_READ))) { @@ -668,8 +668,8 @@ sp_drop_db_routines(THD *thd, char *db) keylen= sizeof(key); for (table= thd->open_tables ; table ; table= table->next) - if (strcmp(table->table_cache_key, "mysql") == 0 && - strcmp(table->real_name, "proc") == 0) + if (strcmp(table->s->db, "mysql") == 0 && + strcmp(table->s->table_name, "proc") == 0) break; if (! table) { @@ -677,7 +677,7 @@ sp_drop_db_routines(THD *thd, char *db) memset(&tables, 0, sizeof(tables)); tables.db= (char*)"mysql"; - tables.real_name= tables.alias= (char*)"proc"; + tables.table_name= tables.alias= (char*)"proc"; if (! (table= open_ltable(thd, &tables, TL_WRITE))) DBUG_RETURN(SP_OPEN_TABLE_FAILED); } @@ -749,9 +749,9 @@ sp_exists_routine(THD *thd, TABLE_LIST *tables, bool any, bool no_error) LEX_STRING lex_db; LEX_STRING lex_name; lex_db.length= strlen(table->db); - lex_name.length= strlen(table->real_name); + lex_name.length= strlen(table->table_name); lex_db.str= thd->strmake(table->db, lex_db.length); - lex_name.str= thd->strmake(table->real_name, lex_name.length); + lex_name.str= thd->strmake(table->table_name, lex_name.length); name= new sp_name(lex_db, lex_name); name->init_qname(thd); if (sp_find_procedure(thd, name) != NULL || @@ -766,7 +766,7 @@ sp_exists_routine(THD *thd, TABLE_LIST *tables, bool any, bool no_error) if (!no_error) { my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "FUNCTION or PROCEDURE", - table->real_name); + table->table_name); DBUG_RETURN(-1); } DBUG_RETURN(0); diff --git a/sql/sp_head.cc b/sql/sp_head.cc index 9afc0c04631..3f2969768c5 100644 --- a/sql/sp_head.cc +++ b/sql/sp_head.cc @@ -834,10 +834,10 @@ sp_head::restore_lex(THD *thd) char **tb; while ((tb= li++)) - if (my_strcasecmp(system_charset_info, tables->real_name, *tb) == 0) + if (my_strcasecmp(system_charset_info, tables->table_name, *tb) == 0) break; if (! tb) - m_tables.push_back(&tables->real_name); + m_tables.push_back(&tables->table_name); } } #endif diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc index ba00c1d3fa7..4628f6746b2 100644 --- a/sql/sql_acl.cc +++ b/sql/sql_acl.cc @@ -166,9 +166,9 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables) thd->db= my_strdup("mysql",MYF(0)); thd->db_length=5; // Safety bzero((char*) &tables,sizeof(tables)); - tables[0].alias=tables[0].real_name=(char*) "host"; - tables[1].alias=tables[1].real_name=(char*) "user"; - tables[2].alias=tables[2].real_name=(char*) "db"; + tables[0].alias=tables[0].table_name=(char*) "host"; + tables[1].alias=tables[1].table_name=(char*) "user"; + tables[2].alias=tables[2].table_name=(char*) "db"; tables[0].next_local= tables[0].next_global= tables+1; tables[1].next_local= tables[1].next_global= tables+2; tables[0].lock_type=tables[1].lock_type=tables[2].lock_type=TL_READ; @@ -210,7 +210,7 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables) continue; } #ifndef TO_BE_REMOVED - if (table->fields == 8) + if (table->s->fields == 8) { // Without grant if (host.access & CREATE_ACL) host.access|=REFERENCES_ACL | INDEX_ACL | ALTER_ACL | CREATE_TMP_ACL; @@ -233,7 +233,7 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables) } DBUG_PRINT("info",("user table fields: %d, password length: %d", - table->fields, table->field[2]->field_length)); + table->s->fields, table->field[2]->field_length)); pthread_mutex_lock(&LOCK_global_system_variables); if (table->field[2]->field_length < SCRAMBLED_PASSWORD_CHAR_LENGTH) @@ -306,23 +306,24 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables) if it is pre 5.0.1 privilege table then map CREATE privilege on CREATE VIEW & SHOW VIEW privileges */ - if (table->fields <= 31 && (user.access & CREATE_ACL)) + if (table->s->fields <= 31 && (user.access & CREATE_ACL)) user.access|= (CREATE_VIEW_ACL | SHOW_VIEW_ACL); /* if it is pre 5.0.2 privilege table then map CREATE/ALTER privilege on CREATE PROCEDURE & ALTER PROCEDURE privileges */ - if (table->fields <= 33 && (user.access & CREATE_ACL)) + if (table->s->fields <= 33 && (user.access & CREATE_ACL)) user.access|= CREATE_PROC_ACL; - if (table->fields <= 33 && (user.access & ALTER_ACL)) + if (table->s->fields <= 33 && (user.access & ALTER_ACL)) user.access|= ALTER_PROC_ACL; user.sort= get_sort(2,user.host.hostname,user.user); user.hostname_length= (user.host.hostname ? (uint) strlen(user.host.hostname) : 0); - if (table->fields >= 31) /* Starting from 4.0.2 we have more fields */ + /* Starting from 4.0.2 we have more fields */ + if (table->s->fields >= 31) { char *ssl_type=get_field(&mem, table->field[next_field++]); if (!ssl_type) @@ -348,7 +349,7 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables) user.user_resource.conn_per_hour) mqh_used=1; - if (table->fields >= 36) + if (table->s->fields >= 36) { /* Starting from 5.0.3 we have max_user_connections field */ ptr= get_field(&mem, table->field[next_field++]); @@ -362,7 +363,7 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables) user.ssl_type=SSL_TYPE_NONE; bzero((char *)&(user.user_resource),sizeof(user.user_resource)); #ifndef TO_BE_REMOVED - if (table->fields <= 13) + if (table->s->fields <= 13) { // Without grant if (user.access & CREATE_ACL) user.access|=REFERENCES_ACL | INDEX_ACL | ALTER_ACL; @@ -410,7 +411,7 @@ my_bool acl_init(THD *org_thd, bool dont_read_acl_tables) db.access=fix_rights_for_db(db.access); db.sort=get_sort(3,db.host.hostname,db.db,db.user); #ifndef TO_BE_REMOVED - if (table->fields <= 9) + if (table->s->fields <= 9) { // Without grant if (db.access & CREATE_ACL) db.access|=REFERENCES_ACL | INDEX_ACL | ALTER_ACL; @@ -1464,7 +1465,7 @@ static bool update_user_table(THD *thd, const char *host, const char *user, DBUG_PRINT("enter",("user: %s host: %s",user,host)); bzero((char*) &tables,sizeof(tables)); - tables.alias=tables.real_name=(char*) "user"; + tables.alias=tables.table_name=(char*) "user"; tables.db=(char*) "mysql"; #ifdef HAVE_REPLICATION @@ -1527,7 +1528,7 @@ static bool test_if_create_new_users(THD *thd) ulong db_access; bzero((char*) &tl,sizeof(tl)); tl.db= (char*) "mysql"; - tl.real_name= (char*) "user"; + tl.table_name= (char*) "user"; db_access=acl_get(thd->host, thd->ip, thd->priv_user, tl.db, 0); @@ -1607,7 +1608,7 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo, goto end; } old_row_exists = 0; - restore_record(table,default_values); // cp empty row from default_values + restore_record(table,s->default_values); table->field[0]->store(combo.host.str,combo.host.length, system_charset_info); table->field[1]->store(combo.user.str,combo.user.length, @@ -1654,8 +1655,8 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo, (*tmp_field)->store(&what, 1, &my_charset_latin1); } rights= get_access(table, 3, &next_field); - DBUG_PRINT("info",("table->fields: %d",table->fields)); - if (table->fields >= 31) /* From 4.0.0 we have more fields */ + DBUG_PRINT("info",("table fields: %d",table->s->fields)); + if (table->s->fields >= 31) /* From 4.0.0 we have more fields */ { /* We write down SSL related ACL stuff */ switch (lex->ssl_type) { @@ -1704,7 +1705,7 @@ static int replace_user_table(THD *thd, TABLE *table, const LEX_USER &combo, table->field[next_field+1]->store((longlong) mqh.updates); if (mqh.specified_limits & USER_RESOURCES::CONNECTIONS_PER_HOUR) table->field[next_field+2]->store((longlong) mqh.conn_per_hour); - if (table->fields >= 36 && + if (table->s->fields >= 36 && (mqh.specified_limits & USER_RESOURCES::USER_CONNECTIONS)) table->field[next_field+3]->store((longlong) mqh.user_conn); mqh_used= mqh_used || mqh.questions || mqh.updates || mqh.conn_per_hour; @@ -1808,7 +1809,7 @@ static int replace_db_table(TABLE *table, const char *db, goto abort; } old_row_exists = 0; - restore_record(table,default_values); // cp empty row from default_values + restore_record(table, s->default_values); table->field[0]->store(combo.host.str,combo.host.length, system_charset_info); table->field[1]->store(db,(uint) strlen(db), system_charset_info); table->field[2]->store(combo.user.str,combo.user.length, system_charset_info); @@ -1820,7 +1821,7 @@ static int replace_db_table(TABLE *table, const char *db, } store_rights=get_rights_for_db(rights); - for (i= 3, priv= 1; i < table->fields; i++, priv <<= 1) + for (i= 3, priv= 1; i < table->s->fields; i++, priv <<= 1) { if (priv & store_rights) // do it if priv is chosen table->field [i]->store(&what,1, &my_charset_latin1);// set requested privileges @@ -2191,7 +2192,7 @@ static int replace_column_table(GRANT_TABLE *g_t, continue; /* purecov: inspected */ } old_row_exists = 0; - restore_record(table,default_values); // Get empty record + restore_record(table, s->default_values); // Get empty record key_restore(table->record[0],key,table->key_info, key_prefix_length); table->field[4]->store(xx->column.ptr(),xx->column.length(), @@ -2343,7 +2344,7 @@ static int replace_table_table(THD *thd, GRANT_TABLE *grant_table, DBUG_RETURN(-1); /* purecov: deadcode */ } - restore_record(table,default_values); // Get empty record + restore_record(table, s->default_values); // Get empty record table->field[0]->store(combo.host.str,combo.host.length, system_charset_info); table->field[1]->store(db,(uint) strlen(db), system_charset_info); table->field[2]->store(combo.user.str,combo.user.length, system_charset_info); @@ -2464,7 +2465,7 @@ static int replace_proc_table(THD *thd, GRANT_NAME *grant_name, DBUG_RETURN(-1); } - restore_record(table,default_values); // Get empty record + restore_record(table, s->default_values); // Get empty record table->field[0]->store(combo.host.str,combo.host.length, &my_charset_latin1); table->field[1]->store(db,(uint) strlen(db), &my_charset_latin1); table->field[2]->store(combo.user.str,combo.user.length, &my_charset_latin1); @@ -2573,7 +2574,7 @@ bool mysql_table_grant(THD *thd, TABLE_LIST *table_list, LEX_USER *Str; TABLE_LIST tables[3]; bool create_new_users=0; - char *db_name, *real_name; + char *db_name, *table_name; DBUG_ENTER("mysql_table_grant"); if (!initialized) @@ -2625,7 +2626,7 @@ bool mysql_table_grant(THD *thd, TABLE_LIST *table_list, { char buf[FN_REFLEN]; sprintf(buf,"%s/%s/%s.frm",mysql_data_home, table_list->db, - table_list->real_name); + table_list->table_name); fn_format(buf,buf,"","",4+16+32); if (access(buf,F_OK)) { @@ -2648,9 +2649,9 @@ bool mysql_table_grant(THD *thd, TABLE_LIST *table_list, /* open the mysql.tables_priv and mysql.columns_priv tables */ bzero((char*) &tables,sizeof(tables)); - tables[0].alias=tables[0].real_name= (char*) "user"; - tables[1].alias=tables[1].real_name= (char*) "tables_priv"; - tables[2].alias=tables[2].real_name= (char*) "columns_priv"; + tables[0].alias=tables[0].table_name= (char*) "user"; + tables[1].alias=tables[1].table_name= (char*) "tables_priv"; + tables[2].alias=tables[2].table_name= (char*) "columns_priv"; tables[0].next_local= tables[0].next_global= tables+1; /* Don't open column table if we don't need it ! */ tables[1].next_local= @@ -2717,24 +2718,24 @@ bool mysql_table_grant(THD *thd, TABLE_LIST *table_list, db_name= (table_list->view_db.length ? table_list->view_db.str : table_list->db); - real_name= (table_list->view_name.length ? + table_name= (table_list->view_name.length ? table_list->view_name.str : - table_list->real_name); + table_list->table_name); /* Find/create cached table grant */ grant_table= table_hash_search(Str->host.str, NullS, db_name, - Str->user.str, real_name, 1); + Str->user.str, table_name, 1); if (!grant_table) { if (revoke_grant) { my_error(ER_NONEXISTING_TABLE_GRANT, MYF(0), - Str->user.str, Str->host.str, table_list->real_name); + Str->user.str, Str->host.str, table_list->table_name); result= TRUE; continue; } grant_table = new GRANT_TABLE (Str->host.str, db_name, - Str->user.str, real_name, + Str->user.str, table_name, rights, column_priv); if (!grant_table) // end of memory @@ -2780,7 +2781,7 @@ bool mysql_table_grant(THD *thd, TABLE_LIST *table_list, /* update table and columns */ if (replace_table_table(thd, grant_table, tables[1].table, *Str, - db_name, real_name, + db_name, table_name, rights, column_priv, revoke_grant)) { /* Should only happen if table is crashed */ @@ -2790,7 +2791,7 @@ bool mysql_table_grant(THD *thd, TABLE_LIST *table_list, { if ((replace_column_table(grant_table, tables[2].table, *Str, columns, - db_name, real_name, + db_name, table_name, rights, revoke_grant))) { result= TRUE; @@ -2831,7 +2832,7 @@ bool mysql_procedure_grant(THD *thd, TABLE_LIST *table_list, LEX_USER *Str; TABLE_LIST tables[2]; bool create_new_users=0, result=0; - char *db_name, *real_name; + char *db_name, *table_name; DBUG_ENTER("mysql_procedure_grant"); if (!initialized) @@ -2858,8 +2859,8 @@ bool mysql_procedure_grant(THD *thd, TABLE_LIST *table_list, /* open the mysql.user and mysql.procs_priv tables */ bzero((char*) &tables,sizeof(tables)); - tables[0].alias=tables[0].real_name= (char*) "user"; - tables[1].alias=tables[1].real_name= (char*) "procs_priv"; + tables[0].alias=tables[0].table_name= (char*) "user"; + tables[1].alias=tables[1].table_name= (char*) "procs_priv"; tables[0].next_local= tables[0].next_global= tables+1; tables[0].lock_type=tables[1].lock_type=TL_WRITE; tables[0].db=tables[1].db=(char*) "mysql"; @@ -2920,22 +2921,22 @@ bool mysql_procedure_grant(THD *thd, TABLE_LIST *table_list, } db_name= table_list->db; - real_name= table_list->real_name; + table_name= table_list->table_name; grant_name= proc_hash_search(Str->host.str, NullS, db_name, - Str->user.str, real_name, 1); + Str->user.str, table_name, 1); if (!grant_name) { if (revoke_grant) { if (!no_error) my_error(ER_NONEXISTING_PROC_GRANT, MYF(0), - Str->user.str, Str->host.str, real_name); + Str->user.str, Str->host.str, table_name); result= TRUE; continue; } grant_name= new GRANT_NAME(Str->host.str, db_name, - Str->user.str, real_name, + Str->user.str, table_name, rights); if (!grant_name) { @@ -2946,7 +2947,7 @@ bool mysql_procedure_grant(THD *thd, TABLE_LIST *table_list, } if (replace_proc_table(thd, grant_name, tables[1].table, *Str, - db_name, real_name, rights, revoke_grant)) + db_name, table_name, rights, revoke_grant)) { result= TRUE; continue; @@ -2987,8 +2988,8 @@ bool mysql_grant(THD *thd, const char *db, List &list, /* open the mysql.user and mysql.db tables */ bzero((char*) &tables,sizeof(tables)); - tables[0].alias=tables[0].real_name=(char*) "user"; - tables[1].alias=tables[1].real_name=(char*) "db"; + tables[0].alias=tables[0].table_name=(char*) "user"; + tables[1].alias=tables[1].table_name=(char*) "db"; tables[0].next_local= tables[0].next_global= tables+1; tables[0].lock_type=tables[1].lock_type=TL_WRITE; tables[0].db=tables[1].db=(char*) "mysql"; @@ -3112,9 +3113,9 @@ my_bool grant_init(THD *org_thd) thd->db= my_strdup("mysql",MYF(0)); thd->db_length=5; // Safety bzero((char*) &tables, sizeof(tables)); - tables[0].alias=tables[0].real_name= (char*) "tables_priv"; - tables[1].alias=tables[1].real_name= (char*) "columns_priv"; - tables[2].alias=tables[2].real_name= (char*) "procs_priv"; + tables[0].alias=tables[0].table_name= (char*) "tables_priv"; + tables[1].alias=tables[1].table_name= (char*) "columns_priv"; + tables[2].alias=tables[2].table_name= (char*) "procs_priv"; tables[0].next_local= tables[0].next_global= tables+1; tables[1].next_local= tables[1].next_global= tables+2; tables[0].lock_type=tables[1].lock_type=tables[2].lock_type=TL_READ; @@ -3327,7 +3328,7 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables, continue; // Already checked } if (!(grant_table= table_hash_search(thd->host,thd->ip, - table->db,user, table->real_name,0))) + table->db,user, table->table_name,0))) { want_access &= ~table->grant.privilege; goto err; // No grants @@ -3363,14 +3364,14 @@ err: command, thd->priv_user, thd->host_or_ip, - table ? table->real_name : "unknown"); + table ? table->table_name : "unknown"); } DBUG_RETURN(1); } bool check_grant_column(THD *thd, GRANT_INFO *grant, - char *db_name, char *table_name, + const char *db_name, const char *table_name, const char *name, uint length, uint show_tables) { GRANT_TABLE *grant_table; @@ -3429,7 +3430,7 @@ err: bool check_grant_all_columns(THD *thd, ulong want_access, GRANT_INFO *grant, - char* db_name, char *table_name, + const char* db_name, const char *table_name, Field_iterator *fields) { GRANT_TABLE *grant_table; @@ -3552,7 +3553,7 @@ bool check_grant_procedure(THD *thd, ulong want_access, { GRANT_NAME *grant_proc; if ((grant_proc= proc_hash_search(host,thd->ip, - table->db, user, table->real_name, 0))) + table->db, user, table->table_name, 0))) table->grant.privilege|= grant_proc->privs; if (want_access & ~table->grant.privilege) @@ -3570,7 +3571,7 @@ err: char buff[1024]; const char *command=""; if (table) - strxmov(buff, table->db, ".", table->real_name, NullS); + strxmov(buff, table->db, ".", table->table_name, NullS); if (want_access & EXECUTE_ACL) command= "execute"; else if (want_access & ALTER_PROC_ACL) @@ -3600,7 +3601,7 @@ ulong get_table_grant(THD *thd, TABLE_LIST *table) grant_table= NULL; #else grant_table= table_hash_search(thd->host, thd->ip, db, user, - table->real_name, 0); + table->table_name, 0); #endif table->grant.grant_table=grant_table; // Remember for column test table->grant.version=grant_version; @@ -4169,11 +4170,11 @@ int open_grant_tables(THD *thd, TABLE_LIST *tables) } bzero((char*) tables, GRANT_TABLES*sizeof(*tables)); - tables->alias= tables->real_name= (char*) "user"; - (tables+1)->alias= (tables+1)->real_name= (char*) "db"; - (tables+2)->alias= (tables+2)->real_name= (char*) "tables_priv"; - (tables+3)->alias= (tables+3)->real_name= (char*) "columns_priv"; - (tables+4)->alias= (tables+4)->real_name= (char*) "procs_priv"; + tables->alias= tables->table_name= (char*) "user"; + (tables+1)->alias= (tables+1)->table_name= (char*) "db"; + (tables+2)->alias= (tables+2)->table_name= (char*) "tables_priv"; + (tables+3)->alias= (tables+3)->table_name= (char*) "columns_priv"; + (tables+4)->alias= (tables+4)->table_name= (char*) "procs_priv"; tables->next_local= tables->next_global= tables+1; (tables+1)->next_local= (tables+1)->next_global= tables+2; (tables+2)->next_local= (tables+2)->next_global= tables+3; @@ -4347,7 +4348,7 @@ static int handle_grant_table(TABLE_LIST *tables, uint table_no, bool drop, by the searched record, if it exists. */ DBUG_PRINT("info",("read table: '%s' search: '%s'@'%s'", - table->real_name, user_str, host_str)); + table->s->table_name, user_str, host_str)); host_field->store(host_str, user_from->host.length, system_charset_info); user_field->store(user_str, user_from->user.length, system_charset_info); @@ -4390,7 +4391,7 @@ static int handle_grant_table(TABLE_LIST *tables, uint table_no, bool drop, { #ifdef EXTRA_DEBUG DBUG_PRINT("info",("scan table: '%s' search: '%s'@'%s'", - table->real_name, user_str, host_str)); + table->s->table_name, user_str, host_str)); #endif while ((error= table->file->rnd_next(table->record[0])) != HA_ERR_END_OF_FILE) @@ -4439,7 +4440,7 @@ static int handle_grant_table(TABLE_LIST *tables, uint table_no, bool drop, SYNOPSIS handle_grant_struct() - struct_no The number of the structure to handle (0..2). + struct_no The number of the structure to handle (0..3). drop If user_from is to be dropped. user_from The the user to be searched/dropped/renamed. user_to The new name for the user if to be renamed, @@ -4460,6 +4461,7 @@ static int handle_grant_table(TABLE_LIST *tables, uint table_no, bool drop, RETURN > 0 At least one element matched. 0 OK, but no element matched. + -1 Wrong arguments to function */ static int handle_grant_struct(uint struct_no, bool drop, @@ -4481,8 +4483,7 @@ static int handle_grant_struct(uint struct_no, bool drop, struct_no, user_from->user.str, user_from->host.str)); /* Get the number of elements in the in-memory structure. */ - switch (struct_no) - { + switch (struct_no) { case 0: elements= acl_users.elements; break; @@ -4496,7 +4497,6 @@ static int handle_grant_struct(uint struct_no, bool drop, elements= proc_priv_hash.records; break; default: - DBUG_ASSERT((struct_no < 0) || (struct_no > 3)); return -1; } @@ -4511,8 +4511,7 @@ static int handle_grant_struct(uint struct_no, bool drop, Get a pointer to the element. Unfortunaltely, the host default differs for the structures. */ - switch (struct_no) - { + switch (struct_no) { case 0: acl_user= dynamic_element(&acl_users, idx, ACL_USER*); user= acl_user->user; @@ -4539,9 +4538,9 @@ static int handle_grant_struct(uint struct_no, bool drop, break; } if (! user) - user= ""; + user= ""; if (! host) - host= ""; + host= ""; #ifdef EXTRA_DEBUG DBUG_PRINT("loop",("scan struct: %u index: %u user: '%s' host: '%s'", struct_no, idx, user, host)); @@ -4576,8 +4575,7 @@ static int handle_grant_struct(uint struct_no, bool drop, } else if ( user_to ) { - switch ( struct_no ) - { + switch ( struct_no ) { case 0: acl_user->user= strdup_root(&mem, user_to->user.str); acl_user->host.hostname= strdup_root(&mem, user_to->host.str); @@ -5186,7 +5184,7 @@ bool sp_grant_privileges(THD *thd, const char *sp_db, const char *sp_name) user_list.empty(); tables->db= (char*)sp_db; - tables->real_name= tables->alias= (char*)sp_name; + tables->table_name= tables->alias= (char*)sp_name; combo->host.length= strlen(combo->host.str); combo->user.length= strlen(combo->user.str); @@ -5271,7 +5269,7 @@ void update_schema_privilege(TABLE *table, char *buff, const char* db, { int i= 2; CHARSET_INFO *cs= system_charset_info; - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[0]->store(buff, strlen(buff), cs); if (db) table->field[i++]->store(db, strlen(db), cs); diff --git a/sql/sql_acl.h b/sql/sql_acl.h index 4ebc3ad7707..b129ffcdcf8 100644 --- a/sql/sql_acl.h +++ b/sql/sql_acl.h @@ -193,10 +193,10 @@ void grant_reload(THD *thd); bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables, uint show_command, uint number, bool dont_print_error); bool check_grant_column (THD *thd, GRANT_INFO *grant, - char *db_name, char *table_name, + const char *db_name, const char *table_name, const char *name, uint length, uint show_command=0); bool check_grant_all_columns(THD *thd, ulong want_access, GRANT_INFO *grant, - char* db_name, char *table_name, + const char* db_name, const char *table_name, Field_iterator *fields); bool check_grant_procedure(THD *thd, ulong want_access, TABLE_LIST *procs, bool no_error); diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 0b0bf6df7ad..5e9a1f9eb55 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -49,8 +49,8 @@ extern "C" byte *table_cache_key(const byte *record,uint *length, my_bool not_used __attribute__((unused))) { TABLE *entry=(TABLE*) record; - *length=entry->key_length; - return (byte*) entry->table_cache_key; + *length= entry->s->key_length; + return (byte*) entry->s->table_cache_key; } bool table_cache_init(void) @@ -148,20 +148,21 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild) { OPEN_TABLE_LIST *table; TABLE *entry=(TABLE*) hash_element(&open_cache,idx); + TABLE_SHARE *share= entry->s; - DBUG_ASSERT(entry->real_name); - if ((!entry->real_name)) // To be removed + DBUG_ASSERT(share->table_name); + if ((!share->table_name)) // To be removed continue; // Shouldn't happen if (wild) { - strxmov(name,entry->table_cache_key,".",entry->real_name,NullS); + strxmov(name,share->table_cache_key,".",share->table_name,NullS); if (wild_compare(name,wild,0)) continue; } /* Check if user has SELECT privilege for any column in the table */ - table_list.db= (char*) entry->table_cache_key; - table_list.real_name= entry->real_name; + table_list.db= (char*) share->db; + table_list.table_name= (char*) share->table_name; table_list.grant.privilege=0; if (check_table_access(thd,SELECT_ACL | EXTRA_ACL,&table_list,1)) @@ -169,8 +170,8 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild) /* need to check if we haven't already listed it */ for (table= open_list ; table ; table=table->next) { - if (!strcmp(table->table,entry->real_name) && - !strcmp(table->db,entry->table_cache_key)) + if (!strcmp(table->table,share->table_name) && + !strcmp(table->db,entry->s->db)) { if (entry->in_use) table->in_use++; @@ -182,15 +183,15 @@ OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *wild) if (table) continue; if (!(*start_list = (OPEN_TABLE_LIST *) - sql_alloc(sizeof(**start_list)+entry->key_length))) + sql_alloc(sizeof(**start_list)+share->key_length))) { open_list=0; // Out of memory break; } strmov((*start_list)->table= strmov(((*start_list)->db= (char*) ((*start_list)+1)), - entry->table_cache_key)+1, - entry->real_name); + entry->s->db)+1, + entry->s->table_name); (*start_list)->in_use= entry->in_use ? 1 : 0; (*start_list)->locked= entry->locked_by_name ? 1 : 0; start_list= &(*start_list)->next; @@ -287,7 +288,7 @@ bool close_cached_tables(THD *thd, bool if_wait_for_refresh, bool found=0; for (TABLE_LIST *table= tables; table; table= table->next_local) { - if (remove_table_from_cache(thd, table->db, table->real_name, 1)) + if (remove_table_from_cache(thd, table->db, table->table_name, 1)) found=1; } if (!found) @@ -319,7 +320,7 @@ bool close_cached_tables(THD *thd, bool if_wait_for_refresh, for (uint idx=0 ; idx < open_cache.records ; idx++) { TABLE *table=(TABLE*) hash_element(&open_cache,idx); - if ((table->version) < refresh_version && table->db_stat) + if ((table->s->version) < refresh_version && table->db_stat) { found=1; pthread_cond_wait(&COND_refresh,&LOCK_open); @@ -337,7 +338,7 @@ bool close_cached_tables(THD *thd, bool if_wait_for_refresh, thd->in_lock_tables=0; /* Set version for table */ for (TABLE *table=thd->open_tables; table ; table= table->next) - table->version=refresh_version; + table->s->version= refresh_version; } VOID(pthread_mutex_unlock(&LOCK_open)); if (if_wait_for_refresh) @@ -439,7 +440,7 @@ bool close_thread_table(THD *thd, TABLE **table_ptr) DBUG_ASSERT(table->file->inited == handler::NONE); *table_ptr=table->next; - if (table->version != refresh_version || + if (table->s->version != refresh_version || thd->version != refresh_version || !table->db_stat) { VOID(hash_delete(&open_cache,(byte*) table)); @@ -447,9 +448,9 @@ bool close_thread_table(THD *thd, TABLE **table_ptr) } else { - if (table->flush_version != flush_version) + if (table->s->flush_version != flush_version) { - table->flush_version=flush_version; + table->s->flush_version= flush_version; table->file->extra(HA_EXTRA_FLUSH); } else @@ -477,8 +478,8 @@ void close_temporary(TABLE *table,bool delete_table) { DBUG_ENTER("close_temporary"); char path[FN_REFLEN]; - db_type table_type=table->db_type; - strmov(path,table->path); + db_type table_type=table->s->db_type; + strmov(path,table->s->path); free_io_cache(table); closefrm(table); my_free((char*) table,MYF(0)); @@ -507,7 +508,7 @@ void close_temporary_tables(THD *thd) enough; indeed it is enough, because table->key_length is greater (by 8, because of server_id and thread_id) than db||table. */ - query_buf_size+= table->key_length+1; + query_buf_size+= table->s->key_length+1; if ((query = alloc_root(thd->mem_root, query_buf_size))) // Better add "if exists", in case a RESET MASTER has been done @@ -518,14 +519,10 @@ void close_temporary_tables(THD *thd) if (query) // we might be out of memory, but this is not fatal { // skip temporary tables not created directly by the user - if (table->real_name[0] != '#') + if (table->s->table_name[0] != '#') found_user_tables = 1; - /* - Here we assume table_cache_key always starts - with \0 terminated db name - */ - end = strxmov(end,"`",table->table_cache_key,"`.`", - table->real_name,"`,", NullS); + end = strxmov(end,"`",table->s->db,"`.`", + table->s->table_name,"`,", NullS); } next=table->next; close_temporary(table); @@ -579,14 +576,14 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table, { for (; table; table= *(TABLE_LIST **) ((char*) table + offset)) { - if ((table->table == 0 || table->table->tmp_table == NO_TMP_TABLE) && + if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) && ((!strcmp(table->db, db_name) && - !strcmp(table->real_name, table_name)) || + !strcmp(table->table_name, table_name)) || (table->view && !my_strcasecmp(table_alias_charset, - table->table->table_cache_key, db_name) && + table->db, db_name) && !my_strcasecmp(table_alias_charset, - table->table->table_name, table_name)))) + table->table->alias, table_name)))) break; } } @@ -594,12 +591,12 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table, { for (; table; table= *(TABLE_LIST **) ((char*) table + offset)) { - if ((table->table == 0 || table->table->tmp_table == NO_TMP_TABLE) && + if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) && ((!strcmp(table->db, db_name) && - !strcmp(table->real_name, table_name)) || + !strcmp(table->table_name, table_name)) || (table->view && - !strcmp(table->table->table_cache_key, db_name) && - !strcmp(table->table->table_name, table_name)))) + !strcmp(table->table->s->db, db_name) && + !strcmp(table->table->alias, table_name)))) break; } } @@ -625,27 +622,27 @@ TABLE_LIST* unique_table(TABLE_LIST *table, TABLE_LIST *table_list) DBUG_ENTER("unique_table"); DBUG_PRINT("enter", ("table alias: %s", table->alias)); TABLE_LIST *res; - const char *d_name= table->db, *t_name= table->real_name; + const char *d_name= table->db, *t_name= table->table_name; char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME]; /* temporary table is always unique */ - if (table->table && table->table->tmp_table != NO_TMP_TABLE) + if (table->table && table->table->s->tmp_table != NO_TMP_TABLE) return 0; if (table->view) { /* it is view and table opened */ if (lower_case_table_names) { - strmov(t_name_buff, table->table->table_name); + strmov(t_name_buff, table->table->alias); my_casedn_str(files_charset_info, t_name_buff); t_name= t_name_buff; - strmov(d_name_buff, table->table->table_cache_key); + strmov(d_name_buff, table->table->s->db); my_casedn_str(files_charset_info, d_name_buff); d_name= d_name_buff; } else { - d_name= table->table->table_cache_key; - t_name= table->table->table_name; + d_name= table->table->s->db; + t_name= table->table->alias; } } @@ -677,8 +674,8 @@ TABLE **find_temporary_table(THD *thd, const char *db, const char *table_name) prev= &thd->temporary_tables; for (table=thd->temporary_tables ; table ; table=table->next) { - if (table->key_length == key_length && - !memcmp(table->table_cache_key,key,key_length)) + if (table->s->key_length == key_length && + !memcmp(table->s->table_cache_key,key,key_length)) return prev; prev= &table->next; } @@ -706,22 +703,26 @@ bool close_temporary_table(THD *thd, const char *db, const char *table_name) Prepares a table cache key, which is the concatenation of db, table_name and thd->slave_proxy_id, separated by '\0'. */ + bool rename_temporary_table(THD* thd, TABLE *table, const char *db, const char *table_name) { char *key; + TABLE_SHARE *share= table->s; + if (!(key=(char*) alloc_root(&table->mem_root, (uint) strlen(db)+ (uint) strlen(table_name)+6+4))) return 1; /* purecov: inspected */ - table->key_length=(uint) - (strmov((table->real_name=strmov(table->table_cache_key=key, - db)+1), - table_name) - table->table_cache_key)+1; - int4store(key+table->key_length,thd->server_id); - table->key_length += 4; - int4store(key+table->key_length,thd->variables.pseudo_thread_id); - table->key_length += 4; + share->key_length= (uint) + (strmov(((char*) share->table_name= strmov(share->table_cache_key= key, + db)+1), + table_name) - share->table_cache_key)+1; + share->db= share->table_cache_key; + int4store(key+share->key_length, thd->server_id); + share->key_length+= 4; + int4store(key+share->key_length, thd->variables.pseudo_thread_id); + share->key_length+= 4; return 0; } @@ -752,15 +753,16 @@ static void relink_unused(TABLE *table) TABLE *unlink_open_table(THD *thd, TABLE *list, TABLE *find) { char key[MAX_DBKEY_LENGTH]; - uint key_length=find->key_length; + uint key_length= find->s->key_length; TABLE *start=list,**prev,*next; prev= &start; - memcpy(key,find->table_cache_key,key_length); + + memcpy(key, find->s->table_cache_key, key_length); for (; list ; list=next) { next=list->next; - if (list->key_length == key_length && - !memcmp(list->table_cache_key,key,key_length)) + if (list->s->key_length == key_length && + !memcmp(list->s->table_cache_key, key, key_length)) { if (thd->locked_tables) mysql_lock_remove(thd, thd->locked_tables,list); @@ -811,12 +813,13 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list) DBUG_ENTER("reopen_name_locked_table"); if (thd->killed) DBUG_RETURN(0); - TABLE* table; + TABLE *table; + TABLE_SHARE *share; if (!(table = table_list->table)) DBUG_RETURN(0); char* db = thd->db ? thd->db : table_list->db; - char* table_name = table_list->real_name; + char* table_name = table_list->table_name; char key[MAX_DBKEY_LENGTH]; uint key_length; key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1; @@ -824,8 +827,8 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list) pthread_mutex_lock(&LOCK_open); if (open_unireg_entry(thd, table, db, table_name, table_name, 0, thd->mem_root) || - !(table->table_cache_key =memdup_root(&table->mem_root,(char*) key, - key_length))) + !(table->s->table_cache_key= memdup_root(&table->mem_root, (char*) key, + key_length))) { delete table->triggers; closefrm(table); @@ -833,9 +836,11 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list) DBUG_RETURN(0); } - table->key_length=key_length; - table->version=0; - table->flush_version=0; + share= table->s; + share->db= share->table_cache_key; + share->key_length=key_length; + share->version=0; + share->flush_version=0; table->in_use = thd; check_unused(); pthread_mutex_unlock(&LOCK_open); @@ -846,8 +851,8 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list) table->const_table=0; table->outer_join= table->null_row= table->maybe_null= table->force_index= 0; table->status=STATUS_NO_RECORD; - table->keys_in_use_for_query= table->keys_in_use; - table->used_keys= table->keys_for_keyread; + table->keys_in_use_for_query= share->keys_in_use; + table->used_keys= share->keys_for_keyread; DBUG_RETURN(table); } @@ -877,7 +882,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, if (thd->killed) DBUG_RETURN(0); key_length= (uint) (strmov(strmov(key, table_list->db)+1, - table_list->real_name)-key)+1; + table_list->table_name)-key)+1; int4store(key + key_length, thd->server_id); int4store(key + key_length + 4, thd->variables.pseudo_thread_id); @@ -885,13 +890,13 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, { for (table= thd->temporary_tables; table ; table=table->next) { - if (table->key_length == key_length + TMP_TABLE_KEY_EXTRA && - !memcmp(table->table_cache_key, key, + if (table->s->key_length == key_length + TMP_TABLE_KEY_EXTRA && + !memcmp(table->s->table_cache_key, key, key_length + TMP_TABLE_KEY_EXTRA)) { if (table->query_id == thd->query_id) { - my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->table_name); + my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias); DBUG_RETURN(0); } table->query_id= thd->query_id; @@ -907,9 +912,9 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, { // Using table locks for (table=thd->open_tables; table ; table=table->next) { - if (table->key_length == key_length && - !memcmp(table->table_cache_key,key,key_length) && - !my_strcasecmp(system_charset_info, table->table_name, alias) && + if (table->s->key_length == key_length && + !memcmp(table->s->table_cache_key,key,key_length) && + !my_strcasecmp(system_charset_info, table->alias, alias) && table->query_id != thd->query_id) { table->query_id=thd->query_id; @@ -925,7 +930,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, { char path[FN_REFLEN]; strxnmov(path, FN_REFLEN, mysql_data_home, "/", table_list->db, "/", - table_list->real_name, reg_ext, NullS); + table_list->table_name, reg_ext, NullS); (void) unpack_filename(path, path); if (mysql_frm_type(path) == FRMTYPE_VIEW) { @@ -933,7 +938,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, table= &tab; VOID(pthread_mutex_lock(&LOCK_open)); if (open_unireg_entry(thd, table, table_list->db, - table_list->real_name, + table_list->table_name, alias, table_list, mem_root)) { table->next=table->prev=table; @@ -972,7 +977,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, table && table->in_use ; table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length)) { - if (table->version != refresh_version) + if (table->s->version != refresh_version) { /* ** There is a refresh in progress for this table @@ -1004,6 +1009,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, } else { + TABLE_SHARE *share; /* Free cache if too big */ while (open_cache.records > table_cache_size && unused_tables) VOID(hash_delete(&open_cache,(byte*) unused_tables)); /* purecov: tested */ @@ -1014,11 +1020,12 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, VOID(pthread_mutex_unlock(&LOCK_open)); DBUG_RETURN(NULL); } - if (open_unireg_entry(thd, table, table_list->db, table_list->real_name, + if (open_unireg_entry(thd, table, table_list->db, table_list->table_name, alias, table_list, mem_root) || (!table_list->view && - !(table->table_cache_key= memdup_root(&table->mem_root, (char*) key, - key_length)))) + !(table->s->table_cache_key= memdup_root(&table->mem_root, + (char*) key, + key_length)))) { table->next=table->prev=table; free_cache_entry(table); @@ -1031,9 +1038,11 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, VOID(pthread_mutex_unlock(&LOCK_open)); DBUG_RETURN(0); // VIEW } - table->key_length=key_length; - table->version=refresh_version; - table->flush_version=flush_version; + share= table->s; + share->db= share->table_cache_key; + share->key_length= key_length; + share->version= refresh_version; + share->flush_version= flush_version; DBUG_PRINT("info", ("inserting table %p into the cache", table)); VOID(my_hash_insert(&open_cache,(byte*) table)); } @@ -1051,16 +1060,14 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, reset: if (thd->lex->need_correct_ident()) table->alias_name_used= my_strcasecmp(table_alias_charset, - table->real_name, alias); + table->s->table_name, alias); /* Fix alias if table name changes */ - if (strcmp(table->table_name, alias)) + if (strcmp(table->alias, alias)) { uint length=(uint) strlen(alias)+1; - table->table_name= (char*) my_realloc(table->table_name,length, - MYF(MY_WME)); - memcpy(table->table_name,alias,length); - for (uint i=0 ; i < table->fields ; i++) - table->field[i]->table_name=table->table_name; + table->alias= (char*) my_realloc((char*) table->alias, length, + MYF(MY_WME)); + memcpy((char*) table->alias, alias, length); } /* These variables are also set in reopen_table() */ table->tablenr=thd->current_tablenr++; @@ -1068,9 +1075,9 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root, table->const_table=0; table->outer_join= table->null_row= table->maybe_null= table->force_index= 0; table->status=STATUS_NO_RECORD; - table->keys_in_use_for_query= table->keys_in_use; + table->keys_in_use_for_query= table->s->keys_in_use; table->insert_values= 0; - table->used_keys= table->keys_for_keyread; + table->used_keys= table->s->keys_for_keyread; if (table->timestamp_field) table->timestamp_field_type= table->timestamp_field->get_auto_set_type(); table_list->updatable= 1; // It is not derived table nor non-updatable VIEW @@ -1086,8 +1093,8 @@ TABLE *find_locked_table(THD *thd, const char *db,const char *table_name) for (TABLE *table=thd->open_tables; table ; table=table->next) { - if (table->key_length == key_length && - !memcmp(table->table_cache_key,key,key_length)) + if (table->s->key_length == key_length && + !memcmp(table->s->table_cache_key,key,key_length)) return table; } return(0); @@ -1104,9 +1111,9 @@ TABLE *find_locked_table(THD *thd, const char *db,const char *table_name) bool reopen_table(TABLE *table,bool locked) { TABLE tmp; - char *db=table->table_cache_key; - char *table_name=table->real_name; - bool error=1; + char *db= table->s->table_cache_key; + const char *table_name= table->s->table_name; + bool error= 1; Field **field; uint key,part; DBUG_ENTER("reopen_table"); @@ -1114,24 +1121,25 @@ bool reopen_table(TABLE *table,bool locked) #ifdef EXTRA_DEBUG if (table->db_stat) sql_print_error("Table %s had a open data handler in reopen_table", - table->table_name); + table->alias); #endif if (!locked) VOID(pthread_mutex_lock(&LOCK_open)); safe_mutex_assert_owner(&LOCK_open); if (open_unireg_entry(table->in_use, &tmp, db, table_name, - table->table_name, 0, table->in_use->mem_root)) + table->alias, 0, table->in_use->mem_root)) goto end; free_io_cache(table); - if (!(tmp.table_cache_key= memdup_root(&tmp.mem_root,db, - table->key_length))) + if (!(tmp.s->table_cache_key= memdup_root(&tmp.mem_root,db, + table->s->key_length))) { delete tmp.triggers; closefrm(&tmp); // End of memory goto end; } + tmp.s->db= tmp.s->table_cache_key; /* This list copies variables set by open_table */ tmp.tablenr= table->tablenr; @@ -1141,16 +1149,16 @@ bool reopen_table(TABLE *table,bool locked) tmp.null_row= table->null_row; tmp.maybe_null= table->maybe_null; tmp.status= table->status; - tmp.keys_in_use_for_query= tmp.keys_in_use; - tmp.used_keys= tmp.keys_for_keyread; + tmp.keys_in_use_for_query= tmp.s->keys_in_use; + tmp.used_keys= tmp.s->keys_for_keyread; tmp.force_index= tmp.force_index; /* Get state */ - tmp.key_length= table->key_length; + tmp.s->key_length= table->s->key_length; tmp.in_use= table->in_use; tmp.reginfo.lock_type=table->reginfo.lock_type; - tmp.version= refresh_version; - tmp.tmp_table= table->tmp_table; + tmp.s->version= refresh_version; + tmp.s->tmp_table= table->s->tmp_table; tmp.grant= table->grant; /* Replace table in open list */ @@ -1161,16 +1169,17 @@ bool reopen_table(TABLE *table,bool locked) if (table->file) VOID(closefrm(table)); // close file, free everything - *table=tmp; + *table= tmp; + table->s= &table->share_not_to_be_used; table->file->change_table_ptr(table); - DBUG_ASSERT(table->table_name); + DBUG_ASSERT(table->alias); for (field=table->field ; *field ; field++) { (*field)->table= (*field)->orig_table= table; - (*field)->table_name=table->table_name; + (*field)->table_name= &table->alias; } - for (key=0 ; key < table->keys ; key++) + for (key=0 ; key < table->s->keys ; key++) for (part=0 ; part < table->key_info[key].usable_key_parts ; part++) table->key_info[key].key_part[part].field->table= table; VOID(pthread_cond_broadcast(&COND_refresh)); @@ -1194,8 +1203,8 @@ bool close_data_tables(THD *thd,const char *db, const char *table_name) TABLE *table; for (table=thd->open_tables; table ; table=table->next) { - if (!strcmp(table->real_name,table_name) && - !strcmp(table->table_cache_key,db)) + if (!strcmp(table->s->table_name, table_name) && + !strcmp(table->s->db, db)) { mysql_lock_remove(thd, thd->locked_tables,table); table->file->close(); @@ -1240,7 +1249,7 @@ bool reopen_tables(THD *thd,bool get_locks,bool in_refresh) next=table->next; if (!tables || (!db_stat && reopen_table(table,1))) { - my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->table_name); + my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias); VOID(hash_delete(&open_cache,(byte*) table)); error=1; } @@ -1252,7 +1261,7 @@ bool reopen_tables(THD *thd,bool get_locks,bool in_refresh) *tables_ptr++= table; // need new lock on this if (in_refresh) { - table->version=0; + table->s->version=0; table->locked_by_flush=0; } } @@ -1291,11 +1300,11 @@ void close_old_data_files(THD *thd, TABLE *table, bool abort_locks, bool found=send_refresh; for (; table ; table=table->next) { - if (table->version != refresh_version) + if (table->s->version != refresh_version) { found=1; if (!abort_locks) // If not from flush tables - table->version = refresh_version; // Let other threads use table + table->s->version= refresh_version; // Let other threads use table if (table->db_stat) { if (abort_locks) @@ -1325,8 +1334,8 @@ bool table_is_used(TABLE *table, bool wait_for_name_lock) { do { - char *key= table->table_cache_key; - uint key_length=table->key_length; + char *key= table->s->table_cache_key; + uint key_length= table->s->key_length; for (TABLE *search=(TABLE*) hash_search(&open_cache, (byte*) key,key_length) ; search ; @@ -1334,7 +1343,7 @@ bool table_is_used(TABLE *table, bool wait_for_name_lock) { if (search->locked_by_flush || search->locked_by_name && wait_for_name_lock || - search->db_stat && search->version < refresh_version) + search->db_stat && search->s->version < refresh_version) return 1; // Table is used } } while ((table=table->next)); @@ -1381,11 +1390,11 @@ bool drop_locked_tables(THD *thd,const char *db, const char *table_name) TABLE *table,*next,**prev; bool found=0; prev= &thd->open_tables; - for (table=thd->open_tables; table ; table=next) + for (table= thd->open_tables; table ; table=next) { next=table->next; - if (!strcmp(table->real_name,table_name) && - !strcmp(table->table_cache_key,db)) + if (!strcmp(table->s->table_name, table_name) && + !strcmp(table->s->db, db)) { mysql_lock_remove(thd, thd->locked_tables,table); VOID(hash_delete(&open_cache,(byte*) table)); @@ -1420,8 +1429,8 @@ void abort_locked_tables(THD *thd,const char *db, const char *table_name) TABLE *table; for (table= thd->open_tables; table ; table= table->next) { - if (!strcmp(table->real_name,table_name) && - !strcmp(table->table_cache_key,db)) + if (!strcmp(table->s->table_name,table_name) && + !strcmp(table->s->db, db)) { mysql_lock_abort(thd,table); break; @@ -1475,7 +1484,7 @@ static int open_unireg_entry(THD *thd, TABLE *entry, const char *db, thd->open_options, entry, table_desc, mem_root)))) { - if (!entry->crashed) + if (!entry->s || !entry->s->crashed) { /* Frm file could not be found on disk @@ -1496,7 +1505,7 @@ static int open_unireg_entry(THD *thd, TABLE *entry, const char *db, TABLE_LIST table_list; bzero((char*) &table_list, sizeof(table_list)); // just for safe table_list.db=(char*) db; - table_list.real_name=(char*) name; + table_list.table_name=(char*) name; safe_mutex_assert_owner(&LOCK_open); @@ -1663,9 +1672,9 @@ int open_tables(THD *thd, TABLE_LIST *start, uint *counter) for (TABLE_LIST *tmp= start; tmp; tmp= tmp->next_global) { /* Close normal (not temporary) changed tables */ - if (tmp->table && ! tmp->table->tmp_table) + if (tmp->table && ! tmp->table->s->tmp_table) { - if (tmp->table->version != refresh_version || + if (tmp->table->s->version != refresh_version || ! tmp->table->db_stat) { VOID(hash_delete(&open_cache,(byte*) tmp->table)); @@ -1724,7 +1733,7 @@ static bool check_lock_and_start_stmt(THD *thd, TABLE *table, if ((int) lock_type >= (int) TL_WRITE_ALLOW_READ && (int) table->reginfo.lock_type < (int) TL_WRITE_ALLOW_READ) { - my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->table_name); + my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias); DBUG_RETURN(1); } if ((error=table->file->start_stmt(thd))) @@ -1911,7 +1920,7 @@ int lock_tables(THD *thd, TABLE_LIST *tables, uint count) { DBUG_ASSERT(thd->lock == 0); // You must lock everything at once TABLE **start,**ptr; - if (!(ptr=start=(TABLE**) sql_alloc(sizeof(TABLE*)*count))) + if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count))) return -1; for (table= tables; table; table= table->next_global) { @@ -1947,6 +1956,7 @@ TABLE *open_temporary_table(THD *thd, const char *path, const char *db, const char *table_name, bool link_in_list) { TABLE *tmp_table; + TABLE_SHARE *share; DBUG_ENTER("open_temporary_table"); /* @@ -1971,20 +1981,22 @@ TABLE *open_temporary_table(THD *thd, const char *path, const char *db, DBUG_RETURN(0); } + share= tmp_table->s; tmp_table->reginfo.lock_type=TL_WRITE; // Simulate locked - tmp_table->tmp_table = (tmp_table->file->has_transactions() ? - TRANSACTIONAL_TMP_TABLE : TMP_TABLE); - tmp_table->table_cache_key=(char*) (tmp_table+1); - tmp_table->key_length= (uint) (strmov((tmp_table->real_name= - strmov(tmp_table->table_cache_key,db) - +1), table_name) - - tmp_table->table_cache_key)+1; - int4store(tmp_table->table_cache_key + tmp_table->key_length, - thd->server_id); - tmp_table->key_length += 4; - int4store(tmp_table->table_cache_key + tmp_table->key_length, + share->tmp_table= (tmp_table->file->has_transactions() ? + TRANSACTIONAL_TMP_TABLE : TMP_TABLE); + share->table_cache_key= (char*) (tmp_table+1); + share->db= share->table_cache_key; + share->key_length= (uint) (strmov(((char*) (share->table_name= + strmov(share->table_cache_key, + db)+1)), + table_name) - + share->table_cache_key) +1; + int4store(share->table_cache_key + share->key_length, thd->server_id); + share->key_length+= 4; + int4store(share->table_cache_key + share->key_length, thd->variables.pseudo_thread_id); - tmp_table->key_length += 4; + share->key_length+= 4; if (link_in_list) { @@ -2151,13 +2163,13 @@ Field *find_field_in_real_table(THD *thd, TABLE *table, uint cached_field_index= *cached_field_index_ptr; /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */ - if (cached_field_index < table->fields && + if (cached_field_index < table->s->fields && !my_strcasecmp(system_charset_info, table->field[cached_field_index]->field_name, name)) field_ptr= table->field + cached_field_index; - else if (table->name_hash.records) - field_ptr= (Field**)hash_search(&table->name_hash,(byte*) name, - length); + else if (table->s->name_hash.records) + field_ptr= (Field**) hash_search(&table->s->name_hash, (byte*) name, + length); else { if (!(field_ptr= table->field)) @@ -2193,8 +2205,8 @@ Field *find_field_in_real_table(THD *thd, TABLE *table, } #ifndef NO_EMBEDDED_ACCESS_CHECKS if (check_grants && check_grant_column(thd, &table->grant, - table->table_cache_key, - table->real_name, name, length)) + table->s->db, + table->s->table_name, name, length)) return WRONG_GRANT; #endif return field; @@ -2810,7 +2822,7 @@ bool setup_tables(THD *thd, TABLE_LIST *tables, Item **conds, tablenr= 0; } setup_table_map(table, table_list, tablenr); - table->used_keys= table->keys_for_keyread; + table->used_keys= table->s->keys_for_keyread; if (table_list->use_index) { key_map map; @@ -2874,12 +2886,13 @@ bool get_key_map_from_key_list(key_map *map, TABLE *table, map->clear_all(); while ((name=it++)) { - if (table->keynames.type_names == 0 || - (pos= find_type(&table->keynames, name->ptr(), name->length(), 1)) <= + if (table->s->keynames.type_names == 0 || + (pos= find_type(&table->s->keynames, name->ptr(), + name->length(), 1)) <= 0) { my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), - name->c_ptr(), table->real_name); + name->c_ptr(), table->s->table_name); map->set_all(); return 1; } @@ -2970,7 +2983,8 @@ insert_fields(THD *thd, TABLE_LIST *tables, const char *db_name, DBUG_ASSERT(table != 0); table_iter.set(tables); if (check_grant_all_columns(thd, SELECT_ACL, &table->grant, - table->table_cache_key, table->real_name, + table->s->db, + table->s->table_name, &table_iter)) goto err; } @@ -3064,7 +3078,7 @@ insert_fields(THD *thd, TABLE_LIST *tables, const char *db_name, else { db= tables->db; - tab= tables->real_name; + tab= tables->table_name; } if (!tables->schema_table && !(fld->have_privileges= (get_column_grant(thd, @@ -3115,7 +3129,7 @@ insert_fields(THD *thd, TABLE_LIST *tables, const char *db_name, fields marked in setup_tables during fix_fields of view columns */ if (table) - table->used_fields=table->fields; + table->used_fields= table->s->fields; } } if (found) @@ -3489,14 +3503,14 @@ void remove_db_from_cache(const my_string db) for (uint idx=0 ; idx < open_cache.records ; idx++) { TABLE *table=(TABLE*) hash_element(&open_cache,idx); - if (!strcmp(table->table_cache_key,db)) + if (!strcmp(table->s->db, db)) { - table->version=0L; /* Free when thread is ready */ + table->s->version= 0L; /* Free when thread is ready */ if (!table->in_use) relink_unused(table); } } - while (unused_tables && !unused_tables->version) + while (unused_tables && !unused_tables->s->version) VOID(hash_delete(&open_cache,(byte*) unused_tables)); } @@ -3541,7 +3555,7 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name, table = (TABLE*) hash_next(&open_cache,(byte*) key,key_length)) { THD *in_use; - table->version=0L; /* Free when thread is ready */ + table->s->version= 0L; /* Free when thread is ready */ if (!(in_use=table->in_use)) { DBUG_PRINT("info",("Table was not in use")); @@ -3581,7 +3595,7 @@ bool remove_table_from_cache(THD *thd, const char *db, const char *table_name, else result= result || return_if_owned_by_thd; } - while (unused_tables && !unused_tables->version) + while (unused_tables && !unused_tables->s->version) VOID(hash_delete(&open_cache,(byte*) unused_tables)); DBUG_RETURN(result); } diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc index 26b1eff49e7..f4345f8ce28 100644 --- a/sql/sql_cache.cc +++ b/sql/sql_cache.cc @@ -1031,7 +1031,6 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length) { TABLE_LIST table_list; TABLE *tmptable; - Query_cache_table *table = block_table->parent; /* @@ -1042,8 +1041,9 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length) */ for (tmptable= thd->temporary_tables; tmptable ; tmptable= tmptable->next) { - if (tmptable->key_length - TMP_TABLE_KEY_EXTRA == table->key_length() && - !memcmp(tmptable->table_cache_key, table->data(), + if (tmptable->s->key_length - TMP_TABLE_KEY_EXTRA == + table->key_length() && + !memcmp(tmptable->s->table_cache_key, table->data(), table->key_length())) { DBUG_PRINT("qcache", @@ -1063,7 +1063,7 @@ Query_cache::send_result_to_client(THD *thd, char *sql, uint query_length) bzero((char*) &table_list,sizeof(table_list)); table_list.db = table->db(); - table_list.alias= table_list.real_name= table->table(); + table_list.alias= table_list.table_name= table->table(); #ifndef NO_EMBEDDED_ACCESS_CHECKS if (check_table_access(thd,SELECT_ACL,&table_list,1)) { @@ -2056,7 +2056,7 @@ void Query_cache::invalidate_table(TABLE_LIST *table_list) uint key_length; Query_cache_block *table_block; key_length=(uint) (strmov(strmov(key,table_list->db)+1, - table_list->real_name) -key)+ 1; + table_list->table_name) -key)+ 1; // We don't store temporary tables => no key_length+=4 ... if ((table_block = (Query_cache_block*) @@ -2067,7 +2067,7 @@ void Query_cache::invalidate_table(TABLE_LIST *table_list) void Query_cache::invalidate_table(TABLE *table) { - invalidate_table((byte*) table->table_cache_key, table->key_length); + invalidate_table((byte*) table->s->table_cache_key, table->s->key_length); } void Query_cache::invalidate_table(byte * key, uint32 key_length) @@ -2116,18 +2116,18 @@ my_bool Query_cache::register_all_tables(Query_cache_block *block, { DBUG_PRINT("qcache", ("table %s, db %s, openinfo at 0x%lx, keylen %u, key at 0x%lx", - tables_used->real_name, tables_used->db, + tables_used->table_name, tables_used->db, (ulong) tables_used->table, - tables_used->table->key_length, - (ulong) tables_used->table->table_cache_key)); - block_table->n=n; - if (!insert_table(tables_used->table->key_length, - tables_used->table->table_cache_key, block_table, + tables_used->table->s->key_length, + (ulong) tables_used->table->s->table_cache_key)); + block_table->n= n; + if (!insert_table(tables_used->table->s->key_length, + tables_used->table->s->table_cache_key, block_table, tables_used->db_length, tables_used->table->file->table_cache_type())) break; - if (tables_used->table->db_type == DB_TYPE_MRG_MYISAM) + if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM) { ha_myisammrg *handler = (ha_myisammrg *) tables_used->table->file; MYRG_INFO *file = handler->myrg_info(); @@ -2663,15 +2663,15 @@ TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len, { table_count++; DBUG_PRINT("qcache", ("table %s, db %s, type %u", - tables_used->real_name, - tables_used->db, tables_used->table->db_type)); + tables_used->table_name, + tables_used->db, tables_used->table->s->db_type)); *tables_type|= tables_used->table->file->table_cache_type(); /* table_alias_charset used here because it depends of lower_case_table_names variable */ - if (tables_used->table->tmp_table != NO_TMP_TABLE || + if (tables_used->table->s->tmp_table != NO_TMP_TABLE || (*tables_type & HA_CACHE_TBL_NOCACHE) || (tables_used->db_length == 5 && my_strnncoll(table_alias_charset, (uchar*)tables_used->db, 6, @@ -2682,7 +2682,7 @@ TABLE_COUNTER_TYPE Query_cache::is_cacheable(THD *thd, uint32 query_len, other non-cacheable table(s)")); DBUG_RETURN(0); } - if (tables_used->table->db_type == DB_TYPE_MRG_MYISAM) + if (tables_used->table->s->db_type == DB_TYPE_MRG_MYISAM) { ha_myisammrg *handler = (ha_myisammrg *)tables_used->table->file; MYRG_INFO *file = handler->myrg_info(); @@ -2729,8 +2729,8 @@ my_bool Query_cache::ask_handler_allowance(THD *thd, for (; tables_used; tables_used= tables_used->next_global) { TABLE *table= tables_used->table; - if (!ha_caching_allowed(thd, table->table_cache_key, - table->key_length, + if (!ha_caching_allowed(thd, table->s->table_cache_key, + table->s->key_length, table->file->table_cache_type())) { DBUG_PRINT("qcache", ("Handler does not allow caching for %s.%s", diff --git a/sql/sql_class.cc b/sql/sql_class.cc index d369e85d775..c9545a0141e 100644 --- a/sql/sql_class.cc +++ b/sql/sql_class.cc @@ -650,7 +650,7 @@ void THD::add_changed_table(TABLE *table) DBUG_ASSERT((options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) && table->file->has_transactions()); - add_changed_table(table->table_cache_key, table->key_length); + add_changed_table(table->s->table_cache_key, table->s->key_length); DBUG_VOID_RETURN; } diff --git a/sql/sql_db.cc b/sql/sql_db.cc index d3b30de0bcd..26929ebc432 100644 --- a/sql/sql_db.cc +++ b/sql/sql_db.cc @@ -812,8 +812,8 @@ static long mysql_rm_known_files(THD *thd, MY_DIR *dirp, const char *db, if (!table_list) goto err; table_list->db= (char*) (table_list+1); - strmov(table_list->real_name= strmov(table_list->db,db)+1, file->name); - table_list->alias= table_list->real_name; // If lower_case_table_names=2 + strmov(table_list->table_name= strmov(table_list->db,db)+1, file->name); + table_list->alias= table_list->table_name; // If lower_case_table_names=2 /* Link into list */ (*tot_list_next)= table_list; tot_list_next= &table_list->next_local; diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc index 8edfc08fa82..15fbfcf928b 100644 --- a/sql/sql_delete.cc +++ b/sql/sql_delete.cc @@ -232,7 +232,7 @@ cleanup: delete select; transactional_table= table->file->has_transactions(); - log_delayed= (transactional_table || table->tmp_table); + log_delayed= (transactional_table || table->s->tmp_table); /* We write to the binary log even if we deleted no row, because maybe the user is using this command to ensure that a table is clean on master *and @@ -307,7 +307,7 @@ bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds) } if (unique_table(table_list, table_list->next_global)) { - my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->real_name); + my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name); DBUG_RETURN(TRUE); } select_lex->fix_prepare_information(thd, conds); @@ -366,7 +366,7 @@ bool mysql_multi_delete_prepare(THD *thd) check_key_in_view(thd, target_tbl->correspondent_table)) { my_error(ER_NON_UPDATABLE_TABLE, MYF(0), - target_tbl->real_name, "DELETE"); + target_tbl->table_name, "DELETE"); DBUG_RETURN(TRUE); } /* @@ -381,10 +381,10 @@ bool mysql_multi_delete_prepare(THD *thd) { if (un->first_select()->linkage != DERIVED_TABLE_TYPE && un->check_updateable(target_tbl->correspondent_table->db, - target_tbl->correspondent_table->real_name)) + target_tbl->correspondent_table->table_name)) { my_error(ER_UPDATE_TABLE_USED, MYF(0), - target_tbl->correspondent_table->real_name); + target_tbl->correspondent_table->table_name); DBUG_RETURN(TRUE); } } @@ -445,7 +445,7 @@ multi_delete::initialize_tables(JOIN *join) tbl->used_keys.clear_all(); if (tbl->file->has_transactions()) log_delayed= transactional_tables= 1; - else if (tbl->tmp_table != NO_TMP_TABLE) + else if (tbl->s->tmp_table != NO_TMP_TABLE) log_delayed= 1; else normal_tables= 1; @@ -717,19 +717,19 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok) bzero((char*) &create_info,sizeof(create_info)); /* If it is a temporary table, close and regenerate it */ if (!dont_send_ok && (table_ptr=find_temporary_table(thd,table_list->db, - table_list->real_name))) + table_list->table_name))) { TABLE *table= *table_ptr; table->file->info(HA_STATUS_AUTO | HA_STATUS_NO_LOCK); - db_type table_type=table->db_type; - strmov(path,table->path); + db_type table_type= table->s->db_type; + strmov(path, table->s->path); *table_ptr= table->next; // Unlink table from list close_temporary(table,0); *fn_ext(path)=0; // Remove the .frm extension ha_create_table(path, &create_info,1); // We don't need to call invalidate() because this table is not in cache if ((error= (int) !(open_temporary_table(thd, path, table_list->db, - table_list->real_name, 1)))) + table_list->table_name, 1)))) (void) rm_temporary_table(table_type, path); /* If we return here we will not have logged the truncation to the bin log @@ -739,7 +739,7 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok) } (void) sprintf(path,"%s/%s/%s%s",mysql_data_home,table_list->db, - table_list->real_name,reg_ext); + table_list->table_name,reg_ext); fn_format(path,path,"","",4); if (!dont_send_ok) @@ -748,7 +748,7 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok) if ((table_type=get_table_type(path)) == DB_TYPE_UNKNOWN) { my_error(ER_NO_SUCH_TABLE, MYF(0), - table_list->db, table_list->real_name); + table_list->db, table_list->table_name); DBUG_RETURN(TRUE); } if (!ha_supports_generate(table_type)) diff --git a/sql/sql_derived.cc b/sql/sql_derived.cc index 520393f8544..bed65f90c00 100644 --- a/sql/sql_derived.cc +++ b/sql/sql_derived.cc @@ -147,7 +147,7 @@ exit: { thd->clear_error(); my_error(ER_VIEW_INVALID, MYF(0), orig_table_list->db, - orig_table_list->real_name); + orig_table_list->table_name); } } @@ -168,9 +168,9 @@ exit: delete derived_result; orig_table_list->derived_result= derived_result; orig_table_list->table= table; - orig_table_list->real_name= table->real_name; + orig_table_list->table_name= (char*) table->s->table_name; table->derived_select_number= first_select->select_number; - table->tmp_table= TMP_TABLE; + table->s->tmp_table= TMP_TABLE; #ifndef NO_EMBEDDED_ACCESS_CHECKS table->grant.privilege= SELECT_ACL; #endif diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc index 2ee7734e4f3..c9c21d82568 100644 --- a/sql/sql_handler.cc +++ b/sql/sql_handler.cc @@ -152,7 +152,7 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, bool reopen) int error; DBUG_ENTER("mysql_ha_open"); DBUG_PRINT("enter",("'%s'.'%s' as '%s' reopen: %d", - tables->db, tables->real_name, tables->alias, + tables->db, tables->table_name, tables->alias, (int) reopen)); if (! hash_inited(&thd->handler_tables_hash)) @@ -206,7 +206,7 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, bool reopen) { /* copy the TABLE_LIST struct */ dblen= strlen(tables->db) + 1; - namelen= strlen(tables->real_name) + 1; + namelen= strlen(tables->table_name) + 1; aliaslen= strlen(tables->alias) + 1; if (!(my_multi_malloc(MYF(MY_WME), &hash_tables, sizeof(*hash_tables), @@ -218,10 +218,10 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, bool reopen) /* structure copy */ *hash_tables= *tables; hash_tables->db= db; - hash_tables->real_name= name; + hash_tables->table_name= name; hash_tables->alias= alias; memcpy(hash_tables->db, tables->db, dblen); - memcpy(hash_tables->real_name, tables->real_name, namelen); + memcpy(hash_tables->table_name, tables->table_name, namelen); memcpy(hash_tables->alias, tables->alias, aliaslen); /* add to hash */ @@ -266,7 +266,7 @@ bool mysql_ha_close(THD *thd, TABLE_LIST *tables) TABLE **table_ptr; DBUG_ENTER("mysql_ha_close"); DBUG_PRINT("enter",("'%s'.'%s' as '%s'", - tables->db, tables->real_name, tables->alias)); + tables->db, tables->table_name, tables->alias)); if ((hash_tables= (TABLE_LIST*) hash_search(&thd->handler_tables_hash, (byte*) tables->alias, @@ -348,7 +348,7 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, uint key_len; DBUG_ENTER("mysql_ha_read"); DBUG_PRINT("enter",("'%s'.'%s' as '%s'", - tables->db, tables->real_name, tables->alias)); + tables->db, tables->table_name, tables->alias)); LINT_INIT(key); LINT_INIT(key_len); @@ -363,7 +363,7 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, { table= hash_tables->table; DBUG_PRINT("info-in-hash",("'%s'.'%s' as '%s' tab %p", - hash_tables->db, hash_tables->real_name, + hash_tables->db, hash_tables->table_name, hash_tables->alias, table)); if (!table) { @@ -378,7 +378,7 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, table= hash_tables->table; DBUG_PRINT("info",("re-opened '%s'.'%s' as '%s' tab %p", - hash_tables->db, hash_tables->real_name, + hash_tables->db, hash_tables->table_name, hash_tables->alias, table)); } @@ -398,7 +398,7 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, #if MYSQL_VERSION_ID < 40100 char buff[MAX_DBKEY_LENGTH]; if (*tables->db) - strxnmov(buff, sizeof(buff), tables->db, ".", tables->real_name, NullS); + strxnmov(buff, sizeof(buff), tables->db, ".", tables->table_name, NullS); else strncpy(buff, tables->alias, sizeof(buff)); my_error(ER_UNKNOWN_TABLE, MYF(0), buff, "HANDLER"); @@ -417,7 +417,7 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, if (keyname) { - if ((keyno=find_type(keyname, &table->keynames, 1+2)-1)<0) + if ((keyno=find_type(keyname, &table->s->keynames, 1+2)-1)<0) { my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), keyname, tables->alias); goto err0; @@ -527,7 +527,7 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE) { sql_print_error("mysql_ha_read: Got error %d when reading table '%s'", - error, tables->real_name); + error, tables->table_name); table->file->print_error(error,MYF(0)); goto err; } @@ -609,22 +609,22 @@ int mysql_ha_flush(THD *thd, TABLE_LIST *tables, uint mode_flags) for (tmp_tables= tables ; tmp_tables; tmp_tables= tmp_tables->next_local) { DBUG_PRINT("info-in-tables-list",("'%s'.'%s' as '%s'", - tmp_tables->db, tmp_tables->real_name, + tmp_tables->db, tmp_tables->table_name, tmp_tables->alias)); /* Close all currently open handler tables with the same base table. */ table_ptr= &(thd->handler_tables); while (*table_ptr) { - if ((! *tmp_tables->db || - ! my_strcasecmp(&my_charset_latin1, (*table_ptr)->table_cache_key, + if ((!*tmp_tables->db || + !my_strcasecmp(&my_charset_latin1, (*table_ptr)->s->db, tmp_tables->db)) && - ! my_strcasecmp(&my_charset_latin1, (*table_ptr)->real_name, - tmp_tables->real_name)) + ! my_strcasecmp(&my_charset_latin1, (*table_ptr)->s->table_name, + tmp_tables->table_name)) { DBUG_PRINT("info",("*table_ptr '%s'.'%s' as '%s'", - (*table_ptr)->table_cache_key, - (*table_ptr)->real_name, - (*table_ptr)->table_name)); + (*table_ptr)->s->db, + (*table_ptr)->s->table_name, + (*table_ptr)->alias)); mysql_ha_flush_table(thd, table_ptr, mode_flags); continue; } @@ -641,7 +641,7 @@ int mysql_ha_flush(THD *thd, TABLE_LIST *tables, uint mode_flags) while (*table_ptr) { if ((mode_flags & MYSQL_HA_FLUSH_ALL) || - ((*table_ptr)->version != refresh_version)) + ((*table_ptr)->s->version != refresh_version)) { mysql_ha_flush_table(thd, table_ptr, mode_flags); continue; @@ -677,12 +677,12 @@ static int mysql_ha_flush_table(THD *thd, TABLE **table_ptr, uint mode_flags) TABLE *table= *table_ptr; DBUG_ENTER("mysql_ha_flush_table"); DBUG_PRINT("enter",("'%s'.'%s' as '%s' flags: 0x%02x", - table->table_cache_key, table->real_name, - table->table_name, mode_flags)); + table->s->db, table->s->table_name, + table->alias, mode_flags)); if ((hash_tables= (TABLE_LIST*) hash_search(&thd->handler_tables_hash, - (byte*) (*table_ptr)->table_name, - strlen((*table_ptr)->table_name) + 1))) + (byte*) (*table_ptr)->alias, + strlen((*table_ptr)->alias) + 1))) { if (! (mode_flags & MYSQL_HA_REOPEN_ON_USAGE)) { diff --git a/sql/sql_help.cc b/sql/sql_help.cc index 99273b42f2a..7bf28a439b6 100644 --- a/sql/sql_help.cc +++ b/sql/sql_help.cc @@ -272,9 +272,9 @@ int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations, DBUG_ENTER("get_topics_for_keyword"); if ((iindex_topic= find_type((char*) primary_key_name, - &topics->keynames, 1+2)-1)<0 || + &topics->s->keynames, 1+2)-1)<0 || (iindex_relations= find_type((char*) primary_key_name, - &relations->keynames, 1+2)-1)<0) + &relations->s->keynames, 1+2)-1)<0) { my_message(ER_CORRUPT_HELP_DB, ER(ER_CORRUPT_HELP_DB), MYF(0)); DBUG_RETURN(-1); @@ -620,16 +620,16 @@ bool mysqld_help(THD *thd, const char *mask) TABLE_LIST *leaves= 0; TABLE_LIST tables[4]; bzero((gptr)tables,sizeof(tables)); - tables[0].alias= tables[0].real_name= (char*) "help_topic"; + tables[0].alias= tables[0].table_name= (char*) "help_topic"; tables[0].lock_type= TL_READ; tables[0].next_global= tables[0].next_local= &tables[1]; - tables[1].alias= tables[1].real_name= (char*) "help_category"; + tables[1].alias= tables[1].table_name= (char*) "help_category"; tables[1].lock_type= TL_READ; tables[1].next_global= tables[1].next_local= &tables[2]; - tables[2].alias= tables[2].real_name= (char*) "help_relation"; + tables[2].alias= tables[2].table_name= (char*) "help_relation"; tables[2].lock_type= TL_READ; tables[2].next_global= tables[2].next_local= &tables[3]; - tables[3].alias= tables[3].real_name= (char*) "help_keyword"; + tables[3].alias= tables[3].table_name= (char*) "help_keyword"; tables[3].lock_type= TL_READ; tables[0].db= tables[1].db= tables[2].db= tables[3].db= (char*) "mysql"; diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index 45b62ef8d83..444f3dad3c0 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -71,7 +71,7 @@ check_insert_fields(THD *thd, TABLE_LIST *table_list, List &fields, table_list->view_db.str, table_list->view_name.str); return -1; } - if (values.elements != table->fields) + if (values.elements != table->s->fields) { my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter); return -1; @@ -82,7 +82,7 @@ check_insert_fields(THD *thd, TABLE_LIST *table_list, List &fields, Field_iterator_table fields; fields.set_table(table); if (check_grant_all_columns(thd, INSERT_ACL, &table->grant, - table->table_cache_key, table->real_name, + table->s->db, table->s->table_name, &fields)) return -1; } @@ -208,10 +208,10 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list, { if (find_locked_table(thd, table_list->db ? table_list->db : thd->db, - table_list->real_name)) + table_list->table_name)) { my_error(ER_DELAYED_INSERT_TABLE_LOCKED, MYF(0), - table_list->real_name); + table_list->table_name); DBUG_RETURN(TRUE); } } @@ -321,7 +321,7 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list, { if (fields.elements || !value_count) { - restore_record(table,default_values); // Get empty record + restore_record(table,s->default_values); // Get empty record if (fill_record(thd, fields, *values, 0)) { if (values_list.elements != 1 && !thd->net.report_error) @@ -341,9 +341,9 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list, else { if (thd->used_tables) // Column used in values() - restore_record(table,default_values); // Get empty record + restore_record(table,s->default_values); // Get empty record else - table->record[0][0]=table->default_values[0]; // Fix delete marker + table->record[0][0]= table->s->default_values[0]; // Fix delete marker if (fill_record(thd, table->field, *values, 0)) { if (values_list.elements != 1 && ! thd->net.report_error) @@ -442,7 +442,7 @@ bool mysql_insert(THD *thd,TABLE_LIST *table_list, transactional_table= table->file->has_transactions(); - log_delayed= (transactional_table || table->tmp_table); + log_delayed= (transactional_table || table->s->tmp_table); if ((info.copied || info.deleted || info.updated) && (error <= 0 || !transactional_table)) { @@ -703,7 +703,7 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list, TABLE *table, if (!select_insert && unique_table(table_list, table_list->next_global)) { - my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->real_name); + my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name); DBUG_RETURN(TRUE); } if (duplic == DUP_UPDATE || duplic == DUP_REPLACE) @@ -717,7 +717,7 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list, TABLE *table, static int last_uniq_key(TABLE *table,uint keynr) { - while (++keynr < table->keys) + while (++keynr < table->s->keys) if (table->key_info[keynr].flags & HA_NOSAME) return 0; return 1; @@ -759,7 +759,7 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info) */ if (info->handle_duplicates == DUP_REPLACE && table->next_number_field && - key_nr == table->next_number_index && + key_nr == table->s->next_number_index && table->file->auto_increment_column_changed) goto err; if (table->file->table_flags() & HA_DUPP_POS) @@ -777,7 +777,7 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info) if (!key) { - if (!(key=(char*) my_safe_alloca(table->max_unique_length, + if (!(key=(char*) my_safe_alloca(table->s->max_unique_length, MAX_KEY_LENGTH))) { error=ENOMEM; @@ -860,7 +860,7 @@ int write_record(THD *thd, TABLE *table,COPY_INFO *info) else info->copied++; if (key) - my_safe_afree(key,table->max_unique_length,MAX_KEY_LENGTH); + my_safe_afree(key,table->s->max_unique_length,MAX_KEY_LENGTH); if (!table->file->has_transactions()) thd->no_trans_update= 1; DBUG_RETURN(0); @@ -1019,7 +1019,7 @@ delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list) while ((tmp=it++)) { if (!strcmp(tmp->thd.db,table_list->db) && - !strcmp(table_list->real_name,tmp->table->real_name)) + !strcmp(table_list->table_name,tmp->table->s->table_name)) { tmp->lock(); break; @@ -1060,7 +1060,7 @@ static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list) thread_count++; pthread_mutex_unlock(&LOCK_thread_count); if (!(tmp->thd.db=my_strdup(table_list->db,MYF(MY_WME))) || - !(tmp->thd.query=my_strdup(table_list->real_name,MYF(MY_WME)))) + !(tmp->thd.query=my_strdup(table_list->table_name,MYF(MY_WME)))) { delete tmp; thd->fatal_error(); @@ -1070,7 +1070,7 @@ static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list) } tmp->table_list= *table_list; // Needed to open table tmp->table_list.db= tmp->thd.db; - tmp->table_list.alias= tmp->table_list.real_name=tmp->thd.query; + tmp->table_list.alias= tmp->table_list.table_name= tmp->thd.query; tmp->lock(); pthread_mutex_lock(&tmp->mutex); if ((error=pthread_create(&tmp->thd.real_id,&connection_attrib, @@ -1168,17 +1168,19 @@ TABLE *delayed_insert::get_local_table(THD* client_thd) client_thd->proc_info="allocating local table"; copy= (TABLE*) client_thd->alloc(sizeof(*copy)+ - (table->fields+1)*sizeof(Field**)+ - table->reclength); + (table->s->fields+1)*sizeof(Field**)+ + table->s->reclength); if (!copy) goto error; *copy= *table; - bzero((char*) ©->name_hash,sizeof(copy->name_hash)); // No name hashing + copy->s= ©->share_not_to_be_used; + // No name hashing + bzero((char*) ©->s->name_hash,sizeof(copy->s->name_hash)); /* We don't need to change the file handler here */ field=copy->field=(Field**) (copy+1); - copy->record[0]=(byte*) (field+table->fields+1); - memcpy((char*) copy->record[0],(char*) table->record[0],table->reclength); + copy->record[0]=(byte*) (field+table->s->fields+1); + memcpy((char*) copy->record[0],(char*) table->record[0],table->s->reclength); /* Make a copy of all fields */ @@ -1201,7 +1203,7 @@ TABLE *delayed_insert::get_local_table(THD* client_thd) { /* Restore offset as this may have been reset in handle_inserts */ copy->timestamp_field= - (Field_timestamp*) copy->field[table->timestamp_field_offset]; + (Field_timestamp*) copy->field[table->s->timestamp_field_offset]; copy->timestamp_field->unireg_check= table->timestamp_field->unireg_check; copy->timestamp_field_type= copy->timestamp_field->get_auto_set_type(); } @@ -1243,13 +1245,13 @@ static int write_delayed(THD *thd,TABLE *table,enum_duplicates duplic, bool igno if (!query) query_length=0; - if (!(row->record= (char*) my_malloc(table->reclength+query_length+1, + if (!(row->record= (char*) my_malloc(table->s->reclength+query_length+1, MYF(MY_WME)))) goto err; - memcpy(row->record,table->record[0],table->reclength); + memcpy(row->record, table->record[0], table->s->reclength); if (query_length) { - row->query=row->record+table->reclength; + row->query= row->record+table->s->reclength; memcpy(row->query,query,query_length+1); } row->query_length= query_length; @@ -1263,7 +1265,7 @@ static int write_delayed(THD *thd,TABLE *table,enum_duplicates duplic, bool igno di->rows.push_back(row); di->stacked_inserts++; di->status=1; - if (table->blob_fields) + if (table->s->blob_fields) unlink_blobs(table); pthread_cond_signal(&di->cond); @@ -1380,7 +1382,7 @@ extern "C" pthread_handler_decl(handle_delayed_insert,arg) if (!(di->table->file->table_flags() & HA_CAN_INSERT_DELAYED)) { thd->fatal_error(); - my_error(ER_ILLEGAL_HA, MYF(0), di->table_list.real_name); + my_error(ER_ILLEGAL_HA, MYF(0), di->table_list.table_name); goto end; } di->table->copy_blobs=1; @@ -1568,13 +1570,13 @@ bool delayed_insert::handle_inserts(void) if (thr_upgrade_write_delay_lock(*thd.lock->locks)) { /* This can only happen if thread is killed by shutdown */ - sql_print_error(ER(ER_DELAYED_CANT_CHANGE_LOCK),table->real_name); + sql_print_error(ER(ER_DELAYED_CANT_CHANGE_LOCK),table->s->table_name); goto err; } thd.proc_info="insert"; max_rows=delayed_insert_limit; - if (thd.killed || table->version != refresh_version) + if (thd.killed || table->s->version != refresh_version) { thd.killed= THD::KILL_CONNECTION; max_rows= ~0; // Do as much as possible @@ -1592,7 +1594,7 @@ bool delayed_insert::handle_inserts(void) { stacked_inserts--; pthread_mutex_unlock(&mutex); - memcpy(table->record[0],row->record,table->reclength); + memcpy(table->record[0],row->record,table->s->reclength); thd.start_time=row->start_time; thd.query_start_used=row->query_start_used; @@ -1626,7 +1628,7 @@ bool delayed_insert::handle_inserts(void) Query_log_event qinfo(&thd, row->query, row->query_length, 0, FALSE); mysql_bin_log.write(&qinfo); } - if (table->blob_fields) + if (table->s->blob_fields) free_delayed_insert_blobs(table); thread_safe_sub(delayed_rows_in_use,1,&LOCK_delayed_status); thread_safe_increment(delayed_insert_writes,&LOCK_delayed_status); @@ -1661,7 +1663,7 @@ bool delayed_insert::handle_inserts(void) if (thr_reschedule_write_lock(*thd.lock->locks)) { /* This should never happen */ - sql_print_error(ER(ER_DELAYED_CANT_CHANGE_LOCK),table->real_name); + sql_print_error(ER(ER_DELAYED_CANT_CHANGE_LOCK),table->s->table_name); } if (!using_bin_log) table->file->extra(HA_EXTRA_WRITE_CACHE); @@ -1803,7 +1805,7 @@ select_insert::prepare(List &values, SELECT_LEX_UNIT *u) thd->lex->current_select->join->select_options|= OPTION_BUFFER_RESULT; } - restore_record(table,default_values); // Get empty record + restore_record(table,s->default_values); // Get empty record table->next_number_field=table->found_next_number_field; thd->cuted_fields=0; if (info.ignore || info.handle_duplicates == DUP_REPLACE) @@ -1914,7 +1916,7 @@ void select_insert::send_error(uint errcode,const char *err) table->file->has_transactions(), FALSE); mysql_bin_log.write(&qinfo); } - if (!table->tmp_table) + if (!table->s->tmp_table) thd->options|=OPTION_STATUS_NO_TRANS_UPDATE; } if (info.copied || info.deleted || info.updated) @@ -1942,7 +1944,7 @@ bool select_insert::send_eof() if (info.copied || info.deleted || info.updated) { query_cache_invalidate3(thd, table, 1); - if (!(table->file->has_transactions() || table->tmp_table)) + if (!(table->file->has_transactions() || table->s->tmp_table)) thd->options|=OPTION_STATUS_NO_TRANS_UPDATE; } @@ -1992,21 +1994,21 @@ select_create::prepare(List &values, SELECT_LEX_UNIT *u) if (!table) DBUG_RETURN(-1); // abort() deletes table - if (table->fields < values.elements) + if (table->s->fields < values.elements) { my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1); DBUG_RETURN(-1); } /* First field to copy */ - field=table->field+table->fields - values.elements; + field=table->field+table->s->fields - values.elements; /* Don't set timestamp if used */ table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; table->next_number_field=table->found_next_number_field; - restore_record(table,default_values); // Get empty record + restore_record(table,s->default_values); // Get empty record thd->cuted_fields=0; if (info.ignore || info.handle_duplicates == DUP_REPLACE) table->file->extra(HA_EXTRA_IGNORE_DUP_KEY); @@ -2053,9 +2055,9 @@ bool select_create::send_eof() Check if we can remove the following two rows. We should be able to just keep the table in the table cache. */ - if (!table->tmp_table) + if (!table->s->tmp_table) { - ulong version= table->version; + ulong version= table->s->version; hash_delete(&open_cache,(byte*) table); /* Tell threads waiting for refresh that something has happened */ if (version != refresh_version) @@ -2079,19 +2081,19 @@ void select_create::abort() if (table) { table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY); - enum db_type table_type=table->db_type; - if (!table->tmp_table) + enum db_type table_type=table->s->db_type; + if (!table->s->tmp_table) { - ulong version= table->version; + ulong version= table->s->version; hash_delete(&open_cache,(byte*) table); if (!create_info->table_existed) - quick_rm_table(table_type, create_table->db, create_table->real_name); + quick_rm_table(table_type, create_table->db, create_table->table_name); /* Tell threads waiting for refresh that something has happened */ if (version != refresh_version) VOID(pthread_cond_broadcast(&COND_refresh)); } else if (!create_info->table_existed) - close_temporary_table(thd, create_table->db, create_table->real_name); + close_temporary_table(thd, create_table->db, create_table->table_name); table=0; } VOID(pthread_mutex_unlock(&LOCK_open)); diff --git a/sql/sql_load.cc b/sql/sql_load.cc index 6c29a0184fa..7858632fff2 100644 --- a/sql/sql_load.cc +++ b/sql/sql_load.cc @@ -133,7 +133,7 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list, } table= table_list->table; transactional_table= table->file->has_transactions(); - log_delayed= (transactional_table || table->tmp_table); + log_delayed= (transactional_table || table->s->tmp_table); if (!fields.elements) { @@ -257,7 +257,7 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list, lf_info.thd = thd; lf_info.ex = ex; lf_info.db = db; - lf_info.table_name = table_list->real_name; + lf_info.table_name = table_list->table_name; lf_info.fields = &fields; lf_info.ignore= ignore; lf_info.handle_dup = handle_duplicates; @@ -268,7 +268,7 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list, } #endif /*!EMBEDDED_LIBRARY*/ - restore_record(table,default_values); + restore_record(table, s->default_values); thd->count_cuted_fields= CHECK_FIELD_WARN; /* calc cuted fields */ thd->cuted_fields=0L; diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 442d398889f..f74b3b587a9 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1228,7 +1228,7 @@ int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd) if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST)))) DBUG_RETURN(1); // out of memory table_list->db= db; - table_list->real_name= table_list->alias= tbl_name; + table_list->table_name= table_list->alias= tbl_name; table_list->lock_type= TL_READ_NO_INSERT; table_list->prev_global= &table_list; // can be removed after merge with 4.1 @@ -1239,7 +1239,7 @@ int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd) } if (lower_case_table_names) my_casedn_str(files_charset_info, tbl_name); - remove_escape(table_list->real_name); + remove_escape(table_list->table_name); if (!(table=open_ltable(thd, table_list, TL_READ_NO_INSERT))) DBUG_RETURN(1); @@ -1601,7 +1601,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd, pend= strend(packet); thd->convert_string(&conv_name, system_charset_info, packet, (uint) (pend-packet), thd->charset()); - table_list.alias= table_list.real_name= conv_name.str; + table_list.alias= table_list.table_name= conv_name.str; packet= pend+1; if (!my_strcasecmp(system_charset_info, table_list.db, @@ -1615,10 +1615,10 @@ bool dispatch_command(enum enum_server_command command, THD *thd, /* command not cachable => no gap for data base name */ if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1))) break; - mysql_log.write(thd,command,"%s %s",table_list.real_name,fields); + mysql_log.write(thd,command,"%s %s",table_list.table_name, fields); if (lower_case_table_names) - my_casedn_str(files_charset_info, table_list.real_name); - remove_escape(table_list.real_name); // This can't have wildcards + my_casedn_str(files_charset_info, table_list.table_name); + remove_escape(table_list.table_name); // This can't have wildcards if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege, 0, 0)) @@ -1975,7 +1975,7 @@ int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident, TABLE_LIST *table_list= (TABLE_LIST*) sel->table_list.first; char *db= table_list->db; remove_escape(db); // Fix escaped '_' - remove_escape(table_list->real_name); + remove_escape(table_list->table_name); if (check_access(thd,SELECT_ACL | EXTRA_ACL,db, &table_list->grant.privilege, 0, 0)) DBUG_RETURN(1); /* purecov: inspected */ @@ -2534,9 +2534,9 @@ mysql_execute_command(THD *thd) if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0)) goto error; } - if (strlen(first_table->real_name) > NAME_LEN) + if (strlen(first_table->table_name) > NAME_LEN) { - my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->real_name); + my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name); break; } pthread_mutex_lock(&LOCK_active_mi); @@ -2544,7 +2544,7 @@ mysql_execute_command(THD *thd) fetch_master_table will send the error to the client on failure. Give error if the table already exists. */ - if (!fetch_master_table(thd, first_table->db, first_table->real_name, + if (!fetch_master_table(thd, first_table->db, first_table->table_name, active_mi, 0, 0)) { send_ok(thd); @@ -2570,9 +2570,9 @@ mysql_execute_command(THD *thd) #else /* Fix names if symlinked tables */ if (append_file_to_dir(thd, &lex->create_info.data_file_name, - create_table->real_name) || + create_table->table_name) || append_file_to_dir(thd, &lex->create_info.index_file_name, - create_table->real_name)) + create_table->table_name)) goto create_error; #endif /* @@ -2604,7 +2604,7 @@ mysql_execute_command(THD *thd) if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) && unique_table(create_table, select_tables)) { - my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table->real_name); + my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table->table_name); goto create_error; } /* If we create merge table, we have to test tables in merge, too */ @@ -2617,7 +2617,7 @@ mysql_execute_command(THD *thd) { if (unique_table(tab, select_tables)) { - my_error(ER_UPDATE_TABLE_USED, MYF(0), tab->real_name); + my_error(ER_UPDATE_TABLE_USED, MYF(0), tab->table_name); goto create_error; } } @@ -2654,7 +2654,7 @@ mysql_execute_command(THD *thd) else { res= mysql_create_table(thd, create_table->db, - create_table->real_name, &lex->create_info, + create_table->table_name, &lex->create_info, lex->create_list, lex->key_list, 0, 0); } @@ -2747,7 +2747,7 @@ create_error: { // Rename of table TABLE_LIST tmp_table; bzero((char*) &tmp_table,sizeof(tmp_table)); - tmp_table.real_name=lex->name; + tmp_table.table_name=lex->name; tmp_table.db=select_lex->db; tmp_table.grant.privilege=priv; if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0, @@ -4331,7 +4331,7 @@ check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables, for (; tables; tables= tables->next_global) { if (tables->derived || tables->schema_table || - (tables->table && (int)tables->table->tmp_table) || + (tables->table && (int)tables->table->s->tmp_table) || my_tz_check_n_skip_implicit_tables(&tables, thd->lex->time_zone_tables_used)) continue; @@ -4370,7 +4370,7 @@ check_procedure_access(THD *thd, ulong want_access,char *db, char *name, bzero((char *)tables, sizeof(TABLE_LIST)); tables->db= db; - tables->real_name= tables->alias= name; + tables->table_name= tables->alias= name; if ((thd->master_access & want_access) == want_access && !thd->db) tables->grant.privilege= want_access; @@ -5319,8 +5319,8 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd, ptr->alias= alias_str; if (lower_case_table_names && table->table.length) my_casedn_str(files_charset_info, table->table.str); - ptr->real_name=table->table.str; - ptr->real_name_length=table->table.length; + ptr->table_name=table->table.str; + ptr->table_name_length=table->table.length; ptr->lock_type= lock_type; ptr->updating= test(table_options & TL_OPTION_UPDATING); ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX); @@ -5329,13 +5329,13 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd, if (!my_strcasecmp(system_charset_info, ptr->db, information_schema_name.str)) { - ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->real_name); + ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name); if (!schema_table || (schema_table->hidden && lex->orig_sql_command == SQLCOM_END)) // not a 'show' command { my_error(ER_UNKNOWN_TABLE, MYF(0), - ptr->real_name, information_schema_name.str); + ptr->table_name, information_schema_name.str); DBUG_RETURN(0); } ptr->schema_table= schema_table; @@ -6039,7 +6039,7 @@ bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List &keys) bzero((char*) &create_info,sizeof(create_info)); create_info.db_type=DB_TYPE_DEFAULT; create_info.default_table_charset= thd->variables.collation_database; - DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->real_name, + DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name, &create_info, table_list, fields, keys, 0, (ORDER*)0, DUP_ERROR, 0, &alter_info)); @@ -6057,7 +6057,7 @@ bool mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info) create_info.default_table_charset= thd->variables.collation_database; alter_info->clear(); alter_info->flags= ALTER_DROP_INDEX; - DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->real_name, + DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name, &create_info, table_list, fields, keys, 0, (ORDER*)0, DUP_ERROR, 0, alter_info)); @@ -6193,7 +6193,7 @@ bool multi_delete_precheck(THD *thd, TABLE_LIST *tables, uint *table_count) if (!walk) { my_error(ER_UNKNOWN_TABLE, MYF(0), - target_tbl->real_name, "MULTI DELETE"); + target_tbl->table_name, "MULTI DELETE"); DBUG_RETURN(TRUE); } walk->lock_type= target_tbl->lock_type; @@ -6343,7 +6343,7 @@ bool create_table_precheck(THD *thd, TABLE_LIST *tables, */ if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) && find_table_in_global_list(tables, create_table->db, - create_table->real_name)) + create_table->table_name)) { error= FALSE; goto err; diff --git a/sql/sql_rename.cc b/sql/sql_rename.cc index 1640fc1a634..8bc1891ef1b 100644 --- a/sql/sql_rename.cc +++ b/sql/sql_rename.cc @@ -149,8 +149,8 @@ rename_tables(THD *thd, TABLE_LIST *table_list, bool skip_error) } else { - old_alias= ren_table->real_name; - new_alias= new_table->real_name; + old_alias= ren_table->table_name; + new_alias= new_table->table_name; } sprintf(name,"%s/%s/%s%s",mysql_data_home, new_table->db, new_alias, reg_ext); diff --git a/sql/sql_select.cc b/sql/sql_select.cc index dce7c754f03..a44628d66a9 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -2152,7 +2152,7 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables, COND *conds, table->quick_keys.clear_all(); table->reginfo.join_tab=s; table->reginfo.not_exists_optimize=0; - bzero((char*) table->const_key_parts, sizeof(key_part_map)*table->keys); + bzero((char*) table->const_key_parts, sizeof(key_part_map)*table->s->keys); all_table_map|= table->map; s->join=join; s->info=0; // For describe @@ -2189,7 +2189,7 @@ make_join_statistics(JOIN *join, TABLE_LIST *tables, COND *conds, continue; } - if ((table->system || table->file->records <= 1) && ! s->dependent && + if ((table->s->system || table->file->records <= 1) && ! s->dependent && !(table->file->table_flags() & HA_NOT_EXACT_COUNT) && !table->fulltext_searched) { @@ -2915,7 +2915,7 @@ add_key_part(DYNAMIC_ARRAY *keyuse_array,KEY_FIELD *key_field) if (key_field->eq_func && !(key_field->optimize & KEY_OPTIMIZE_EXISTS)) { - for (uint key=0 ; key < form->keys ; key++) + for (uint key=0 ; key < form->s->keys ; key++) { if (!(form->keys_in_use_for_query.is_set(key))) continue; @@ -3427,8 +3427,8 @@ best_access_path(JOIN *join, records= ((double) s->records / (double) rec * (1.0 + - ((double) (table->max_key_length-keyinfo->key_length) / - (double) table->max_key_length))); + ((double) (table->s->max_key_length-keyinfo->key_length) / + (double) table->s->max_key_length))); if (records < 2.0) records=2.0; /* Can't be as good as a unique */ } @@ -4412,8 +4412,8 @@ find_best(JOIN *join,table_map rest_tables,uint idx,double record_count, records= ((double) s->records / (double) rec * (1.0 + - ((double) (table->max_key_length-keyinfo->key_length) / - (double) table->max_key_length))); + ((double) (table->s->max_key_length-keyinfo->key_length) / + (double) table->s->max_key_length))); if (records < 2.0) records=2.0; // Can't be as good as a unique } @@ -4689,13 +4689,13 @@ static void calc_used_field_length(THD *thd, JOIN_TAB *join_tab) } } if (null_fields) - rec_length+=(join_tab->table->null_fields+7)/8; + rec_length+=(join_tab->table->s->null_fields+7)/8; if (join_tab->table->maybe_null) rec_length+=sizeof(my_bool); if (blobs) { uint blob_length=(uint) (join_tab->table->file->mean_rec_length- - (join_tab->table->reclength- rec_length)); + (join_tab->table->s->reclength- rec_length)); rec_length+=(uint) max(4,blob_length); } join_tab->used_fields=fields; @@ -5281,7 +5281,7 @@ make_join_select(JOIN *join,SQL_SELECT *select,COND *cond) } if (tmp || !cond) { - DBUG_EXECUTE("where",print_where(tmp,tab->table->table_name);); + DBUG_EXECUTE("where",print_where(tmp,tab->table->alias);); SQL_SELECT *sel=tab->select=(SQL_SELECT*) join->thd->memdup((gptr) select, sizeof(SQL_SELECT)); if (!sel) @@ -7586,7 +7586,7 @@ static Field* create_tmp_field_from_field(THD *thd, Field* org_field, new_field->flags&= ~NOT_NULL_FLAG; // Because of outer join if (org_field->type() == MYSQL_TYPE_VAR_STRING || org_field->type() == MYSQL_TYPE_VARCHAR) - table->db_create_options|= HA_OPTION_PACK_RECORD; + table->s->db_create_options|= HA_OPTION_PACK_RECORD; } return new_field; } @@ -7802,7 +7802,8 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, char *tmpname,path[FN_REFLEN], filename[FN_REFLEN]; byte *pos,*group_buff; uchar *null_flags; - Field **reg_field, **from_field, **blob_field; + Field **reg_field, **from_field; + uint *blob_field; Copy_field *copy=0; KEY *keyinfo; KEY_PART_INFO *key_part_info; @@ -7851,7 +7852,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, if (!my_multi_malloc(MYF(MY_WME), &table,sizeof(*table), ®_field, sizeof(Field*)*(field_count+1), - &blob_field, sizeof(Field*)*(field_count+1), + &blob_field, sizeof(uint)*(field_count+1), &from_field, sizeof(Field*)*field_count, ©_func,sizeof(*copy_func)*(param->func_count+1), ¶m->keyinfo,sizeof(*param->keyinfo), @@ -7881,26 +7882,31 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, bzero((char*) reg_field,sizeof(Field*)*(field_count+1)); bzero((char*) from_field,sizeof(Field*)*field_count); table->field=reg_field; - table->blob_field= (Field_blob**) blob_field; - table->real_name=table->path=tmpname; - table->table_name= table_alias; + table->alias= table_alias; table->reginfo.lock_type=TL_WRITE; /* Will be updated */ table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE; - table->blob_ptr_size=mi_portable_sizeof_char_ptr; table->map=1; - table->tmp_table= TMP_TABLE; - table->db_low_byte_first=1; // True for HEAP and MyISAM table->temp_pool_slot = temp_pool_slot; table->copy_blobs= 1; table->in_use= thd; - table->table_charset= param->table_charset; - table->keys_for_keyread.init(); - table->keys_in_use.init(); - table->read_only_keys.init(); table->quick_keys.init(); table->used_keys.init(); table->keys_in_use_for_query.init(); + table->s= &table->share_not_to_be_used; + table->s->blob_field= blob_field; + table->s->table_name= table->s->path= tmpname; + table->s->db= ""; + table->s->blob_ptr_size= mi_portable_sizeof_char_ptr; + table->s->tmp_table= TMP_TABLE; + table->s->db_low_byte_first=1; // True for HEAP and MyISAM + table->s->table_charset= param->table_charset; + table->s->keys_for_keyread.init(); + table->s->keys_in_use.init(); + /* For easier error reporting */ + table->s->table_cache_key= (char*) table->s->db= ""; + + /* Calculate which type of fields we will store in the temporary table */ reclength= string_total_length= 0; @@ -7944,13 +7950,13 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, if (!new_field) goto err; // Should be OOM tmp_from_field++; - *(reg_field++)= new_field; reclength+=new_field->pack_length(); if (new_field->flags & BLOB_FLAG) { - *blob_field++= new_field; + *blob_field++= (uint) (reg_field - table->field); blob_count++; } + *(reg_field++)= new_field; if (new_field->real_type() == MYSQL_TYPE_STRING || new_field->real_type() == MYSQL_TYPE_VARCHAR) { @@ -8002,7 +8008,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, total_uneven_bit_length+= new_field->field_length & 7; if (new_field->flags & BLOB_FLAG) { - *blob_field++= new_field; + *blob_field++= (uint) (reg_field - table->field); blob_count++; } if (item->marker == 4 && item->maybe_null) @@ -8024,7 +8030,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) == OPTION_BIG_TABLES) { - table->file=get_new_handler(table,table->db_type=DB_TYPE_MYISAM); + table->file=get_new_handler(table,table->s->db_type= DB_TYPE_MYISAM); if (group && (param->group_parts > table->file->max_key_parts() || param->group_length > table->file->max_key_length())) @@ -8032,13 +8038,13 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, } else { - table->file=get_new_handler(table,table->db_type=DB_TYPE_HEAP); + table->file=get_new_handler(table,table->s->db_type= DB_TYPE_HEAP); } if (!using_unique_constraint) reclength+= group_null_items; // null flag is stored separately - table->blob_fields=blob_count; + table->s->blob_fields= blob_count; if (blob_count == 0) { /* We need to ensure that first byte is not 0 for the delete link */ @@ -8060,15 +8066,15 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, string_total_length / string_count >= AVG_STRING_LENGTH_TO_PACK_ROWS)) use_packed_rows= 1; - table->fields=field_count; - table->reclength=reclength; + table->s->fields= field_count; + table->s->reclength= reclength; { uint alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1); - table->rec_buff_length=alloc_length; + table->s->rec_buff_length= alloc_length; if (!(table->record[0]= (byte *) my_malloc(alloc_length*3, MYF(MY_WME)))) goto err; table->record[1]= table->record[0]+alloc_length; - table->default_values= table->record[1]+alloc_length; + table->s->default_values= table->record[1]+alloc_length; } copy_func[0]=0; // End marker @@ -8084,8 +8090,8 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, bfill(null_flags,null_pack_length,255); // Set null fields table->null_flags= (uchar*) table->record[0]; - table->null_fields= null_count+ hidden_null_count; - table->null_bytes= null_pack_length; + table->s->null_fields= null_count+ hidden_null_count; + table->s->null_bytes= null_pack_length; } null_count= (blob_count == 0) ? 1 : 0; hidden_field_count=param->hidden_field_count; @@ -8143,30 +8149,30 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, null_count=(null_count+7) & ~7; // move to next byte // fix table name in field entry - field->table_name= table->table_name; + field->table_name= &table->alias; } param->copy_field_end=copy; param->recinfo=recinfo; - store_record(table,default_values); // Make empty default record + store_record(table,s->default_values); // Make empty default record if (thd->variables.tmp_table_size == ~(ulong) 0) // No limit - table->max_rows= ~(ha_rows) 0; + table->s->max_rows= ~(ha_rows) 0; else - table->max_rows=(((table->db_type == DB_TYPE_HEAP) ? - min(thd->variables.tmp_table_size, - thd->variables.max_heap_table_size) : - thd->variables.tmp_table_size)/ table->reclength); - set_if_bigger(table->max_rows,1); // For dummy start options - keyinfo=param->keyinfo; + table->s->max_rows= (((table->s->db_type == DB_TYPE_HEAP) ? + min(thd->variables.tmp_table_size, + thd->variables.max_heap_table_size) : + thd->variables.tmp_table_size)/ table->s->reclength); + set_if_bigger(table->s->max_rows,1); // For dummy start options + keyinfo= param->keyinfo; if (group) { DBUG_PRINT("info",("Creating group key in temporary table")); table->group=group; /* Table is grouped by key */ param->group_buff=group_buff; - table->keys=1; - table->uniques= test(using_unique_constraint); + table->s->keys=1; + table->s->uniques= test(using_unique_constraint); table->key_info=keyinfo; keyinfo->key_part=key_part_info; keyinfo->flags=HA_NOSAME; @@ -8234,14 +8240,14 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, null_pack_length-=hidden_null_pack_length; keyinfo->key_parts= ((field_count-param->hidden_field_count)+ test(null_pack_length)); - set_if_smaller(table->max_rows, rows_limit); + set_if_smaller(table->s->max_rows, rows_limit); param->end_write_records= rows_limit; - table->distinct=1; - table->keys=1; + table->distinct= 1; + table->s->keys= 1; if (blob_count) { using_unique_constraint=1; - table->uniques=1; + table->s->uniques= 1; } if (!(key_part_info= (KEY_PART_INFO*) sql_calloc((keyinfo->key_parts)*sizeof(KEY_PART_INFO)))) @@ -8286,23 +8292,16 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, } if (thd->is_fatal_error) // If end of memory goto err; /* purecov: inspected */ - table->db_record_offset=1; - if (table->db_type == DB_TYPE_MYISAM) + table->s->db_record_offset= 1; + if (table->s->db_type == DB_TYPE_MYISAM) { if (create_myisam_tmp_table(table,param,select_options)) goto err; } - /* Set table_name for easier debugging */ - table->table_name= base_name(tmpname); if (!open_tmp_table(table)) DBUG_RETURN(table); err: - /* - Hack to ensure that free_blobs() doesn't fail if blob_field is not yet - complete - */ - *table->blob_field= 0; free_tmp_table(thd,table); /* purecov: inspected */ bitmap_clear_bit(&temp_pool, temp_pool_slot); DBUG_RETURN(NULL); /* purecov: inspected */ @@ -8312,7 +8311,8 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List &fields, static bool open_tmp_table(TABLE *table) { int error; - if ((error=table->file->ha_open(table->real_name,O_RDWR,HA_OPEN_TMP_TABLE))) + if ((error=table->file->ha_open(table->s->table_name,O_RDWR, + HA_OPEN_TMP_TABLE))) { table->file->print_error(error,MYF(0)); /* purecov: inspected */ table->db_stat=0; @@ -8332,7 +8332,7 @@ static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param, KEY *keyinfo=param->keyinfo; DBUG_ENTER("create_myisam_tmp_table"); - if (table->keys) + if (table->s->keys) { // Get keys for ni_create bool using_unique_constraint=0; HA_KEYSEG *seg= (HA_KEYSEG*) sql_calloc(sizeof(*seg) * @@ -8342,11 +8342,11 @@ static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param, if (keyinfo->key_length >= table->file->max_key_length() || keyinfo->key_parts > table->file->max_key_parts() || - table->uniques) + table->s->uniques) { /* Can't create a key; Make a unique constraint instead of a key */ - table->keys=0; - table->uniques=1; + table->s->keys= 0; + table->s->uniques= 1; using_unique_constraint=1; bzero((char*) &uniquedef,sizeof(uniquedef)); uniquedef.keysegs=keyinfo->key_parts; @@ -8358,7 +8358,7 @@ static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param, param->recinfo->type= FIELD_CHECK; param->recinfo->length=MI_UNIQUE_HASH_LENGTH; param->recinfo++; - table->reclength+=MI_UNIQUE_HASH_LENGTH; + table->s->reclength+=MI_UNIQUE_HASH_LENGTH; } else { @@ -8380,7 +8380,7 @@ static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param, seg->type= ((keyinfo->key_part[i].key_type & FIELDFLAG_BINARY) ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2); - seg->bit_start= field->pack_length() - table->blob_ptr_size; + seg->bit_start= field->pack_length() - table->s->blob_ptr_size; seg->flag= HA_BLOB_PART; seg->length=0; // Whole blob in unique constraint } @@ -8413,10 +8413,10 @@ static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param, OPTION_BIG_TABLES) create_info.data_file_length= ~(ulonglong) 0; - if ((error=mi_create(table->real_name,table->keys,&keydef, + if ((error=mi_create(table->s->table_name,table->s->keys,&keydef, (uint) (param->recinfo-param->start_recinfo), param->start_recinfo, - table->uniques, &uniquedef, + table->s->uniques, &uniquedef, &create_info, HA_CREATE_TMP_TABLE))) { @@ -8426,7 +8426,7 @@ static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param, } statistic_increment(table->in_use->status_var.created_tmp_disk_tables, &LOCK_status); - table->db_record_offset=1; + table->s->db_record_offset= 1; DBUG_RETURN(0); err: DBUG_RETURN(1); @@ -8438,7 +8438,7 @@ free_tmp_table(THD *thd, TABLE *entry) { const char *save_proc_info; DBUG_ENTER("free_tmp_table"); - DBUG_PRINT("enter",("table: %s",entry->table_name)); + DBUG_PRINT("enter",("table: %s",entry->alias)); save_proc_info=thd->proc_info; thd->proc_info="removing tmp table"; @@ -8454,8 +8454,9 @@ free_tmp_table(THD *thd, TABLE *entry) here and we have to ensure that delete_table gets the table name in the original case. */ - if (!(test_flags & TEST_KEEP_TMP_TABLES) || entry->db_type == DB_TYPE_HEAP) - entry->file->delete_table(entry->real_name); + if (!(test_flags & TEST_KEEP_TMP_TABLES) || + entry->s->db_type == DB_TYPE_HEAP) + entry->file->delete_table(entry->s->table_name); delete entry->file; } @@ -8485,14 +8486,15 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param, int write_err; DBUG_ENTER("create_myisam_from_heap"); - if (table->db_type != DB_TYPE_HEAP || error != HA_ERR_RECORD_FILE_FULL) + if (table->s->db_type != DB_TYPE_HEAP || error != HA_ERR_RECORD_FILE_FULL) { table->file->print_error(error,MYF(0)); DBUG_RETURN(1); } new_table= *table; - new_table.db_type=DB_TYPE_MYISAM; - if (!(new_table.file=get_new_handler(&new_table,DB_TYPE_MYISAM))) + new_table.s= &new_table.share_not_to_be_used; + new_table.s->db_type= DB_TYPE_MYISAM; + if (!(new_table.file= get_new_handler(&new_table,DB_TYPE_MYISAM))) DBUG_RETURN(1); // End of memory save_proc_info=thd->proc_info; @@ -8542,10 +8544,11 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param, /* remove heap table and change to use myisam table */ (void) table->file->ha_rnd_end(); (void) table->file->close(); - (void) table->file->delete_table(table->real_name); + (void) table->file->delete_table(table->s->table_name); delete table->file; table->file=0; - *table =new_table; + *table= new_table; + table->s= &table->share_not_to_be_used; table->file->change_table_ptr(table); thd->proc_info= (!strcmp(save_proc_info,"Copying to tmp table") ? "Copying to tmp table on disk" : save_proc_info); @@ -8557,7 +8560,7 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param, (void) table->file->ha_rnd_end(); (void) new_table.file->close(); err1: - new_table.file->delete_table(new_table.real_name); + new_table.file->delete_table(new_table.s->table_name); delete new_table.file; err2: thd->proc_info=save_proc_info; @@ -8600,7 +8603,7 @@ do_select(JOIN *join,List *fields,TABLE *table,Procedure *procedure) { if (table->group && join->tmp_table_param.sum_func_count) { - if (table->keys) + if (table->s->keys) { DBUG_PRINT("info",("Using end_update")); end_select=end_update; @@ -9003,7 +9006,7 @@ sub_select(JOIN *join,JOIN_TAB *join_tab,bool end_of_records) join_tab->found= 1; join_tab->not_null_compl= 0; /* The outer row is complemented by nulls for each inner tables */ - restore_record(join_tab->table,default_values); // Make empty record + restore_record(join_tab->table,s->default_values); // Make empty record mark_as_null_row(join_tab->table); // For group by without error select_cond= join_tab->select_cond; /* Check all attached conditions for inner table rows. */ @@ -9138,7 +9141,7 @@ int report_error(TABLE *table, int error) */ if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT) sql_print_error("Got error %d when reading table '%s'", - error, table->path); + error, table->s->path); table->file->print_error(error,MYF(0)); return 1; } @@ -9220,7 +9223,7 @@ join_read_system(JOIN_TAB *tab) if (table->status & STATUS_GARBAGE) // If first read { if ((error=table->file->read_first_row(table->record[0], - table->primary_key))) + table->s->primary_key))) { if (error != HA_ERR_END_OF_FILE) return report_error(table, error); @@ -9804,7 +9807,7 @@ end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)), if (create_myisam_from_heap(join->thd, table, &join->tmp_table_param, error,1)) DBUG_RETURN(-1); // Not a table_is_full error - table->uniques=0; // To ensure rows are the same + table->s->uniques=0; // To ensure rows are the same } if (++join->send_records >= join->tmp_table_param.end_write_records && join->do_send_rows) @@ -10243,7 +10246,7 @@ uint find_shortest_key(TABLE *table, const key_map *usable_keys) uint best= MAX_KEY; if (!usable_keys->is_clear_all()) { - for (uint nr=0; nr < table->keys ; nr++) + for (uint nr=0; nr < table->s->keys ; nr++) { if (usable_keys->is_set(nr)) { @@ -10309,7 +10312,7 @@ test_if_subkey(ORDER *order, TABLE *table, uint ref, uint ref_key_parts, KEY_PART_INFO *ref_key_part= table->key_info[ref].key_part; KEY_PART_INFO *ref_key_part_end= ref_key_part + ref_key_parts; - for (nr= 0 ; nr < table->keys ; nr++) + for (nr= 0 ; nr < table->s->keys ; nr++) { if (usable_keys->is_set(nr) && table->key_info[nr].key_length < min_length && @@ -10510,7 +10513,7 @@ test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit, else keys= usable_keys; - for (nr=0; nr < table->keys ; nr++) + for (nr=0; nr < table->s->keys ; nr++) { uint not_used; if (keys.is_set(nr)) @@ -10624,7 +10627,7 @@ create_sort_index(THD *thd, JOIN *join, ORDER *order, goto err; } } - if (table->tmp_table) + if (table->s->tmp_table) table->file->info(HA_STATUS_VARIABLE); // Get record count table->sort.found_records=filesort(thd, table,sortorder, length, select, filesort_limit, &examined_rows); @@ -10700,7 +10703,7 @@ static bool compare_record(TABLE *table, Field **ptr) { for (; *ptr ; ptr++) { - if ((*ptr)->cmp_offset(table->rec_buff_length)) + if ((*ptr)->cmp_offset(table->s->rec_buff_length)) return 1; } return 0; @@ -10753,14 +10756,14 @@ remove_duplicates(JOIN *join, TABLE *entry,List &fields, Item *having) join->unit->select_limit_cnt= 1; // Only send first row DBUG_RETURN(0); } - Field **first_field=entry->field+entry->fields - field_count; - offset=entry->field[entry->fields - field_count]->offset(); - reclength=entry->reclength-offset; + Field **first_field=entry->field+entry->s->fields - field_count; + offset=entry->field[entry->s->fields - field_count]->offset(); + reclength=entry->s->reclength-offset; free_io_cache(entry); // Safety entry->file->info(HA_STATUS_VARIABLE); - if (entry->db_type == DB_TYPE_HEAP || - (!entry->blob_fields && + if (entry->s->db_type == DB_TYPE_HEAP || + (!entry->s->blob_fields && ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->file->records < thd->variables.sortbuff_size))) error=remove_dup_with_hash_index(join->thd, entry, @@ -10782,7 +10785,7 @@ static int remove_dup_with_compare(THD *thd, TABLE *table, Field **first_field, char *org_record,*new_record; byte *record; int error; - ulong reclength=table->reclength-offset; + ulong reclength= table->s->reclength-offset; DBUG_ENTER("remove_dup_with_compare"); org_record=(char*) (record=table->record[0])+offset; @@ -11058,10 +11061,10 @@ join_init_cache(THD *thd,JOIN_TAB *tables,uint table_count) } } /* Copy null bits from table */ - if (null_fields && tables[i].table->null_fields) + if (null_fields && tables[i].table->s->null_fields) { /* must copy null bits */ copy->str=(char*) tables[i].table->null_flags; - copy->length=tables[i].table->null_bytes; + copy->length= tables[i].table->s->null_bytes; copy->strip=0; copy->blob_field=0; length+=copy->length; @@ -12690,8 +12693,8 @@ static void select_describe(JOIN *join, bool need_tmp_table, bool need_order, item_list.push_back(new Item_string(table_name_buffer, len, cs)); } else - item_list.push_back(new Item_string(table->table_name, - strlen(table->table_name), + item_list.push_back(new Item_string(table->alias, + strlen(table->alias), cs)); /* type */ item_list.push_back(new Item_string(join_type_str[tab->type], @@ -12701,7 +12704,7 @@ static void select_describe(JOIN *join, bool need_tmp_table, bool need_order, if (!tab->keys.is_clear_all()) { uint j; - for (j=0 ; j < table->keys ; j++) + for (j=0 ; j < table->s->keys ; j++) { if (tab->keys.is_set(j)) { @@ -12999,8 +13002,8 @@ void st_table_list::print(THD *thd, String *str) } else { - append_identifier(thd, str, real_name, real_name_length); - cmp_name= real_name; + append_identifier(thd, str, table_name, table_name_length); + cmp_name= table_name; } } if (my_strcasecmp(table_alias_charset, cmp_name, alias)) diff --git a/sql/sql_show.cc b/sql/sql_show.cc index 6ffad1e2bff..1e284891b90 100644 --- a/sql/sql_show.cc +++ b/sql/sql_show.cc @@ -311,7 +311,7 @@ mysql_find_files(THD *thd,List *files, const char *db,const char *path, if (db && !(col_access & TABLE_ACLS)) { table_list.db= (char*) db; - table_list.real_name=file->name; + table_list.table_name= file->name; table_list.grant.privilege=col_access; if (check_grant(thd, TABLE_ACLS, &table_list, 1, UINT_MAX, 1)) continue; @@ -342,7 +342,7 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list) int res; DBUG_ENTER("mysqld_show_create"); DBUG_PRINT("enter",("db: %s table: %s",table_list->db, - table_list->real_name)); + table_list->table_name)); /* Only one table for now, but VIEW can involve several tables */ if (open_and_lock_tables(thd, table_list)) @@ -353,7 +353,7 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list) if (thd->lex->only_view && !table_list->view) { my_error(ER_WRONG_OBJECT, MYF(0), - table_list->db, table_list->real_name, "VIEW"); + table_list->db, table_list->table_name, "VIEW"); DBUG_RETURN(TRUE); } @@ -395,7 +395,7 @@ mysqld_show_create(THD *thd, TABLE_LIST *table_list) if (table_list->schema_table) protocol->store(table_list->schema_table_name, system_charset_info); else - protocol->store(table->table_name, system_charset_info); + protocol->store(table->alias, system_charset_info); if (store_create_info(thd, table_list, &buffer)) DBUG_RETURN(TRUE); } @@ -535,7 +535,7 @@ mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild) TABLE *table; int res; DBUG_ENTER("mysqld_list_fields"); - DBUG_PRINT("enter",("table: %s",table_list->real_name)); + DBUG_PRINT("enter",("table: %s",table_list->table_name)); table_list->lock_type= TL_UNLOCK; if (open_and_lock_tables(thd, table_list)) @@ -551,7 +551,7 @@ mysqld_list_fields(THD *thd, TABLE_LIST *table_list, const char *wild) !wild_case_compare(system_charset_info, field->field_name,wild)) field_list.push_back(new Item_field(field)); } - restore_record(table,default_values); // Get empty record + restore_record(table, s->default_values); // Get empty record if (thd->protocol->send_fields(&field_list, Protocol::SEND_DEFAULTS | Protocol::SEND_EOF)) DBUG_VOID_RETURN; @@ -566,7 +566,7 @@ mysqld_dump_create_info(THD *thd, TABLE_LIST *table_list, int fd) Protocol *protocol= thd->protocol; String *packet= protocol->storage_packet(); DBUG_ENTER("mysqld_dump_create_info"); - DBUG_PRINT("enter",("table: %s",table_list->table->real_name)); + DBUG_PRINT("enter",("table: %s",table_list->table->s->table_name)); protocol->prepare_for_resend(); if (store_create_info(thd, table_list, packet)) @@ -715,13 +715,15 @@ static int store_create_info(THD *thd, TABLE_LIST *table_list, String *packet) { List field_list; - char tmp[MAX_FIELD_WIDTH], *for_str, buff[128], *end, *alias; + char tmp[MAX_FIELD_WIDTH], *for_str, buff[128], *end; + const char *alias; String type(tmp, sizeof(tmp), system_charset_info); Field **ptr,*field; uint primary_key; KEY *key_info; TABLE *table= table_list->table; handler *file= table->file; + TABLE_SHARE *share= table->s; HA_CREATE_INFO create_info; my_bool foreign_db_mode= (thd->variables.sql_mode & (MODE_POSTGRESQL | MODE_ORACLE | @@ -732,21 +734,20 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet) my_bool limited_mysql_mode= (thd->variables.sql_mode & (MODE_NO_FIELD_OPTIONS | MODE_MYSQL323 | MODE_MYSQL40)) != 0; - DBUG_ENTER("store_create_info"); - DBUG_PRINT("enter",("table: %s",table->real_name)); + DBUG_PRINT("enter",("table: %s", table->s->table_name)); - restore_record(table,default_values); // Get empty record + restore_record(table, s->default_values); // Get empty record - if (table->tmp_table) + if (share->tmp_table) packet->append("CREATE TEMPORARY TABLE ", 23); else packet->append("CREATE TABLE ", 13); if (table_list->schema_table) alias= table_list->schema_table_name; else - alias= (lower_case_table_names == 2 ? table->table_name : - table->real_name); + alias= (lower_case_table_names == 2 ? table->alias : + share->table_name); append_identifier(thd, packet, alias, strlen(alias)); packet->append(" (\n", 3); @@ -773,7 +774,7 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet) if (field->has_charset() && !limited_mysql_mode && !foreign_db_mode) { - if (field->charset() != table->table_charset) + if (field->charset() != share->table_charset) { packet->append(" character set ", 15); packet->append(field->charset()->csname); @@ -859,9 +860,9 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet) file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK | HA_STATUS_TIME); bzero((char*) &create_info, sizeof(create_info)); file->update_create_info(&create_info); - primary_key= table->primary_key; + primary_key= share->primary_key; - for (uint i=0 ; i < table->keys ; i++,key_info++) + for (uint i=0 ; i < share->keys ; i++,key_info++) { KEY_PART_INFO *key_part= key_info->key_part; bool found_primary=0; @@ -886,7 +887,7 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet) if (!(thd->variables.sql_mode & MODE_NO_KEY_OPTIONS) && !limited_mysql_mode && !foreign_db_mode) { - if (table->db_type == DB_TYPE_HEAP && + if (share->db_type == DB_TYPE_HEAP && key_info->algorithm == HA_KEY_ALG_BTREE) packet->append(" TYPE BTREE", 11); @@ -941,58 +942,58 @@ store_create_info(THD *thd, TABLE_LIST *table_list, String *packet) packet->append(" ENGINE=", 8); packet->append(file->table_type()); - if (table->table_charset && + if (share->table_charset && !(thd->variables.sql_mode & MODE_MYSQL323) && !(thd->variables.sql_mode & MODE_MYSQL40)) { packet->append(" DEFAULT CHARSET=", 17); - packet->append(table->table_charset->csname); - if (!(table->table_charset->state & MY_CS_PRIMARY)) + packet->append(share->table_charset->csname); + if (!(share->table_charset->state & MY_CS_PRIMARY)) { packet->append(" COLLATE=", 9); - packet->append(table->table_charset->name); + packet->append(table->s->table_charset->name); } } - if (table->min_rows) + if (share->min_rows) { packet->append(" MIN_ROWS=", 10); - end= longlong10_to_str(table->min_rows, buff, 10); + end= longlong10_to_str(share->min_rows, buff, 10); packet->append(buff, (uint) (end- buff)); } - if (table->max_rows) + if (share->max_rows) { packet->append(" MAX_ROWS=", 10); - end= longlong10_to_str(table->max_rows, buff, 10); + end= longlong10_to_str(share->max_rows, buff, 10); packet->append(buff, (uint) (end - buff)); } - if (table->avg_row_length) + if (share->avg_row_length) { packet->append(" AVG_ROW_LENGTH=", 16); - end= longlong10_to_str(table->avg_row_length, buff,10); + end= longlong10_to_str(share->avg_row_length, buff,10); packet->append(buff, (uint) (end - buff)); } - if (table->db_create_options & HA_OPTION_PACK_KEYS) + if (share->db_create_options & HA_OPTION_PACK_KEYS) packet->append(" PACK_KEYS=1", 12); - if (table->db_create_options & HA_OPTION_NO_PACK_KEYS) + if (share->db_create_options & HA_OPTION_NO_PACK_KEYS) packet->append(" PACK_KEYS=0", 12); - if (table->db_create_options & HA_OPTION_CHECKSUM) + if (share->db_create_options & HA_OPTION_CHECKSUM) packet->append(" CHECKSUM=1", 11); - if (table->db_create_options & HA_OPTION_DELAY_KEY_WRITE) + if (share->db_create_options & HA_OPTION_DELAY_KEY_WRITE) packet->append(" DELAY_KEY_WRITE=1",18); - if (table->row_type != ROW_TYPE_DEFAULT) + if (share->row_type != ROW_TYPE_DEFAULT) { packet->append(" ROW_FORMAT=",12); - packet->append(ha_row_type[(uint) table->row_type]); + packet->append(ha_row_type[(uint) share->row_type]); } table->file->append_create_info(packet); - if (table->comment && table->comment[0]) + if (share->comment && share->comment[0]) { packet->append(" COMMENT=", 9); - append_unescaped(packet, table->comment, strlen(table->comment)); + append_unescaped(packet, share->comment, strlen(share->comment)); } if (file->raid_type) { @@ -1516,7 +1517,7 @@ static bool show_status_array(THD *thd, const char *wild, default: break; } - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[0]->store(name_buffer, strlen(name_buffer), system_charset_info); table->field[1]->store(pos, (uint32) (end - pos), system_charset_info); @@ -1802,7 +1803,7 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond) bool res= open_and_lock_tables(thd, show_table_list); if (schema_table->process_table(thd, show_table_list, table, res, show_table_list->db, - show_table_list->real_name)) + show_table_list->table_name)) { DBUG_RETURN(1); } @@ -1870,7 +1871,7 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond) List_iterator_fast it(files); while ((file_name=it++)) { - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[schema_table->idx_field1]-> store(base_name, strlen(base_name), system_charset_info); table->field[schema_table->idx_field2]-> @@ -1939,7 +1940,7 @@ int get_all_tables(THD *thd, TABLE_LIST *tables, COND *cond) void store_schema_shemata(TABLE *table, const char *db_name, const char* cs_name) { - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[1]->store(db_name, strlen(db_name), system_charset_info); table->field[2]->store(cs_name, strlen(cs_name), system_charset_info); table->file->write_row(table->record[0]); @@ -2009,9 +2010,9 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, const char *tmp_buff; TIME time; CHARSET_INFO *cs= system_charset_info; - DBUG_ENTER("get_schema_tables_record"); - restore_record(table, default_values); + + restore_record(table, s->default_values); table->field[1]->store(base_name, strlen(base_name), cs); table->field[2]->store(file_name, strlen(file_name), cs); if (res) @@ -2031,9 +2032,11 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, else { TABLE *show_table= tables->table; + TABLE_SHARE *share= show_table->s; handler *file= show_table->file; + file->info(HA_STATUS_VARIABLE | HA_STATUS_TIME | HA_STATUS_NO_LOCK); - if (show_table->tmp_table == TMP_TABLE) + if (share->tmp_table == TMP_TABLE) table->field[3]->store("TEMPORARY", 9, cs); else table->field[3]->store("BASE TABLE", 10, cs); @@ -2046,10 +2049,10 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, } tmp_buff= file->table_type(); table->field[4]->store(tmp_buff, strlen(tmp_buff), cs); - table->field[5]->store((longlong) show_table->frm_version); - tmp_buff= ((show_table->db_options_in_use & + table->field[5]->store((longlong) share->frm_version); + tmp_buff= ((share->db_options_in_use & HA_OPTION_COMPRESS_RECORD) ? "Compressed" : - (show_table->db_options_in_use & HA_OPTION_PACK_RECORD) ? + (share->db_options_in_use & HA_OPTION_PACK_RECORD) ? "Dynamic" : "Fixed"); table->field[6]->store(tmp_buff, strlen(tmp_buff), cs); if (!tables->schema_table) @@ -2095,8 +2098,8 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, table->field[16]->store_time(&time, MYSQL_TIMESTAMP_DATETIME); table->field[16]->set_notnull(); } - tmp_buff= (show_table->table_charset ? show_table-> - table_charset->name : "default"); + tmp_buff= (share->table_charset ? + share->table_charset->name : "default"); table->field[17]->store(tmp_buff, strlen(tmp_buff), cs); if (file->table_flags() & (ulong) HA_HAS_CHECKSUM) { @@ -2106,32 +2109,32 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, char option_buff[350],*ptr; ptr=option_buff; - if (show_table->min_rows) + if (share->min_rows) { ptr=strmov(ptr," min_rows="); - ptr=longlong10_to_str(show_table->min_rows,ptr,10); + ptr=longlong10_to_str(share->min_rows,ptr,10); } - if (show_table->max_rows) + if (share->max_rows) { ptr=strmov(ptr," max_rows="); - ptr=longlong10_to_str(show_table->max_rows,ptr,10); + ptr=longlong10_to_str(share->max_rows,ptr,10); } - if (show_table->avg_row_length) + if (share->avg_row_length) { ptr=strmov(ptr," avg_row_length="); - ptr=longlong10_to_str(show_table->avg_row_length,ptr,10); + ptr=longlong10_to_str(share->avg_row_length,ptr,10); } - if (show_table->db_create_options & HA_OPTION_PACK_KEYS) + if (share->db_create_options & HA_OPTION_PACK_KEYS) ptr=strmov(ptr," pack_keys=1"); - if (show_table->db_create_options & HA_OPTION_NO_PACK_KEYS) + if (share->db_create_options & HA_OPTION_NO_PACK_KEYS) ptr=strmov(ptr," pack_keys=0"); - if (show_table->db_create_options & HA_OPTION_CHECKSUM) + if (share->db_create_options & HA_OPTION_CHECKSUM) ptr=strmov(ptr," checksum=1"); - if (show_table->db_create_options & HA_OPTION_DELAY_KEY_WRITE) + if (share->db_create_options & HA_OPTION_DELAY_KEY_WRITE) ptr=strmov(ptr," delay_key_write=1"); - if (show_table->row_type != ROW_TYPE_DEFAULT) + if (share->row_type != ROW_TYPE_DEFAULT) ptr=strxmov(ptr, " row_format=", - ha_row_type[(uint) show_table->row_type], + ha_row_type[(uint) share->row_type], NullS); if (file->raid_type) { @@ -2146,13 +2149,13 @@ static int get_schema_tables_record(THD *thd, struct st_table_list *tables, (ptr == option_buff ? 0 : (uint) (ptr-option_buff)-1), cs); { - char *comment= show_table->file-> - update_table_comment(show_table->comment); + char *comment; + comment= show_table->file->update_table_comment(share->comment); if (comment) { table->field[20]->store(comment, strlen(comment), cs); - if (comment != show_table->comment) - my_free(comment,MYF(0)); + if (comment != share->comment) + my_free(comment, MYF(0)); } } } @@ -2190,7 +2193,7 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables, TABLE *show_table= tables->table; handler *file= show_table->file; file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK); - restore_record(show_table, default_values); + restore_record(show_table, s->default_values); Field **ptr,*field; int count= 0; for (ptr=show_table->field; (field= *ptr) ; ptr++) @@ -2207,7 +2210,7 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables, String type(tmp,sizeof(tmp), system_charset_info); char tmp_buffer[128]; count++; - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[1]->store(base_name, strlen(base_name), cs); table->field[2]->store(file_name, strlen(file_name), cs); table->field[3]->store(field->field_name, strlen(field->field_name), @@ -2317,7 +2320,7 @@ static int get_schema_column_record(THD *thd, struct st_table_list *tables, check_access(thd,SELECT_ACL | EXTRA_ACL, base_name, &tables->grant.privilege, 0, 0); col_access= get_column_grant(thd, &tables->grant, tables->db, - tables->real_name, + tables->table_name, field->field_name) & COL_ACLS; for (uint bitnr=0; col_access ; col_access>>=1,bitnr++) { @@ -2354,7 +2357,7 @@ int fill_schema_charsets(THD *thd, TABLE_LIST *tables, COND *cond) !(wild && wild[0] && wild_case_compare(scs, tmp_cs->csname,wild))) { - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[0]->store(tmp_cs->csname, strlen(tmp_cs->csname), scs); table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs); table->field[2]->store(tmp_cs->comment ? tmp_cs->comment : "", @@ -2391,7 +2394,7 @@ int fill_schema_collation(THD *thd, TABLE_LIST *tables, COND *cond) wild_case_compare(scs, tmp_cl->name,wild))) { const char *tmp_buff; - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs); table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs); table->field[2]->store((longlong) tmp_cl->number); @@ -2427,7 +2430,7 @@ int fill_schema_coll_charset_app(THD *thd, TABLE_LIST *tables, COND *cond) if (!tmp_cl || !(tmp_cl->state & MY_CS_AVAILABLE) || !my_charset_same(tmp_cs,tmp_cl)) continue; - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs); table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs); table->file->write_row(table->record[0]); @@ -2445,7 +2448,7 @@ void store_schema_proc(THD *thd, TABLE *table, TIME time; LEX *lex= thd->lex; CHARSET_INFO *cs= system_charset_info; - restore_record(table, default_values); + restore_record(table, s->default_values); if (lex->orig_sql_command == SQLCOM_SHOW_STATUS_PROC && proc_table->field[2]->val_int() == TYPE_ENUM_PROCEDURE || lex->orig_sql_command == SQLCOM_SHOW_STATUS_FUNC && @@ -2520,7 +2523,7 @@ int fill_schema_proc(THD *thd, TABLE_LIST *tables, COND *cond) bzero((char*) &proc_tables,sizeof(proc_tables)); proc_tables.db= (char*) "mysql"; - proc_tables.real_name= proc_tables.alias= (char*) "proc"; + proc_tables.table_name= proc_tables.alias= (char*) "proc"; proc_tables.lock_type= TL_READ; if (!(proc_table= open_ltable(thd, &proc_tables, TL_READ))) { @@ -2573,13 +2576,13 @@ static int get_schema_stat_record(THD *thd, struct st_table_list *tables, show_table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK | HA_STATUS_TIME); - for (uint i=0 ; i < show_table->keys ; i++,key_info++) + for (uint i=0 ; i < show_table->s->keys ; i++,key_info++) { KEY_PART_INFO *key_part= key_info->key_part; const char *str; for (uint j=0 ; j < key_info->key_parts ; j++,key_part++) { - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[1]->store(base_name, strlen(base_name), cs); table->field[2]->store(file_name, strlen(file_name), cs); table->field[3]->store((longlong) ((key_info->flags & @@ -2618,7 +2621,7 @@ static int get_schema_stat_record(THD *thd, struct st_table_list *tables, table->field[12]->store(pos, strlen(pos), cs); pos= show_table->file->index_type(i); table->field[13]->store(pos, strlen(pos), cs); - if (!show_table->keys_in_use.is_set(i)) + if (!show_table->s->keys_in_use.is_set(i)) table->field[14]->store("disabled", 8, cs); else table->field[14]->store("", 0, cs); @@ -2642,9 +2645,10 @@ static int get_schema_views_record(THD *thd, struct st_table_list *tables, { if (tables->view) { - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[1]->store(tables->view_db.str, tables->view_db.length, cs); - table->field[2]->store(tables->view_name.str,tables->view_name.length,cs); + table->field[2]->store(tables->view_name.str, tables->view_name.length, + cs); table->field[3]->store(tables->query.str, tables->query.length, cs); if (tables->with_check != VIEW_CHECK_NONE) @@ -2680,7 +2684,7 @@ void store_constraints(TABLE *table, const char*db, const char *tname, const char *con_type, uint con_len) { CHARSET_INFO *cs= system_charset_info; - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[1]->store(db, strlen(db), cs); table->field[2]->store(key_name, key_len, cs); table->field[3]->store(db, strlen(db), cs); @@ -2709,11 +2713,11 @@ static int get_schema_constraints_record(THD *thd, struct st_table_list *tables, List f_key_list; TABLE *show_table= tables->table; KEY *key_info=show_table->key_info; - uint primary_key= show_table->primary_key; + uint primary_key= show_table->s->primary_key; show_table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK | HA_STATUS_TIME); - for (uint i=0 ; i < show_table->keys ; i++, key_info++) + for (uint i=0 ; i < show_table->s->keys ; i++, key_info++) { if (i != primary_key && !(key_info->flags & HA_NOSAME)) continue; @@ -2774,11 +2778,11 @@ static int get_schema_key_column_usage_record(THD *thd, List f_key_list; TABLE *show_table= tables->table; KEY *key_info=show_table->key_info; - uint primary_key= show_table->primary_key; + uint primary_key= show_table->s->primary_key; show_table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK | HA_STATUS_TIME); - for (uint i=0 ; i < show_table->keys ; i++, key_info++) + for (uint i=0 ; i < show_table->s->keys ; i++, key_info++) { if (i != primary_key && !(key_info->flags & HA_NOSAME)) continue; @@ -2790,7 +2794,7 @@ static int get_schema_key_column_usage_record(THD *thd, if (key_part->field) { f_idx++; - restore_record(table, default_values); + restore_record(table, s->default_values); store_key_column_usage(table, base_name, file_name, key_info->name, strlen(key_info->name), @@ -2815,7 +2819,7 @@ static int get_schema_key_column_usage_record(THD *thd, { r_info= it1++; f_idx++; - restore_record(table, default_values); + restore_record(table, s->default_values); store_key_column_usage(table, base_name, file_name, f_key_info->forein_id->str, f_key_info->forein_id->length, @@ -2843,7 +2847,7 @@ int fill_open_tables(THD *thd, TABLE_LIST *tables, COND *cond) for (; open_list ; open_list=open_list->next) { - restore_record(table, default_values); + restore_record(table, s->default_values); table->field[0]->store(open_list->db, strlen(open_list->db), cs); table->field[1]->store(open_list->table, strlen(open_list->table), cs); table->field[2]->store((longlong) open_list->in_use); @@ -3182,13 +3186,13 @@ int mysql_schema_table(THD *thd, LEX *lex, TABLE_LIST *table_list) { DBUG_RETURN(1); } - table->tmp_table= TMP_TABLE; + table->s->tmp_table= TMP_TABLE; table->grant.privilege= SELECT_ACL; table->alias_name_used= my_strcasecmp(table_alias_charset, - table_list->real_name, + table_list->table_name, table_list->alias); - table_list->schema_table_name= table_list->real_name; - table_list->real_name= table->real_name; + table_list->schema_table_name= table_list->table_name; + table_list->table_name= (char*) table->s->table_name; table_list->table= table; table->next= thd->derived_tables; thd->derived_tables= table; diff --git a/sql/sql_table.cc b/sql/sql_table.cc index 757e968a582..d7a272f804c 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -79,7 +79,7 @@ bool mysql_rm_table(THD *thd,TABLE_LIST *tables, my_bool if_exists, { if (thd->global_read_lock) { - my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), tables->real_name); + my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), tables->table_name); error= TRUE; goto err; } @@ -194,7 +194,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, { char *db=table->db; mysql_ha_flush(thd, table, MYSQL_HA_CLOSE_FINAL); - if (!close_temporary_table(thd, db, table->real_name)) + if (!close_temporary_table(thd, db, table->table_name)) { tmp_table_deleted=1; continue; // removed temporary table @@ -203,17 +203,17 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, error=0; if (!drop_temporary) { - abort_locked_tables(thd,db,table->real_name); - while (remove_table_from_cache(thd,db,table->real_name) && !thd->killed) + abort_locked_tables(thd,db,table->table_name); + while (remove_table_from_cache(thd,db,table->table_name) && !thd->killed) { dropping_tables++; (void) pthread_cond_wait(&COND_refresh,&LOCK_open); dropping_tables--; } - drop_locked_tables(thd,db,table->real_name); + drop_locked_tables(thd,db,table->table_name); if (thd->killed) DBUG_RETURN(-1); - alias= (lower_case_table_names == 2) ? table->alias : table->real_name; + alias= (lower_case_table_names == 2) ? table->alias : table->table_name; /* remove form file and isam files */ strxmov(path, mysql_data_home, "/", db, "/", alias, reg_ext, NullS); (void) unpack_filename(path,path); @@ -225,7 +225,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, if (if_exists) push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), - table->real_name); + table->table_name); else error= 1; } @@ -254,7 +254,7 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists, { if (wrong_tables.length()) wrong_tables.append(','); - wrong_tables.append(String(table->real_name,system_charset_info)); + wrong_tables.append(String(table->table_name,system_charset_info)); } } thd->tmp_table_used= tmp_table_deleted; @@ -1548,19 +1548,20 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, { TABLE tmp_table; // Used during 'create_field()' TABLE *table= 0; - tmp_table.table_name=0; uint select_field_count= items->elements; - DBUG_ENTER("create_table_from_items"); - /* Add selected items to field list */ List_iterator_fast it(*items); Item *item; Field *tmp_field; - tmp_table.db_create_options=0; + DBUG_ENTER("create_table_from_items"); + + tmp_table.alias= 0; + tmp_table.s= &tmp_table.share_not_to_be_used; + tmp_table.s->db_create_options=0; + tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr; + tmp_table.s->db_low_byte_first= test(create_info->db_type == DB_TYPE_MYISAM || + create_info->db_type == DB_TYPE_HEAP); tmp_table.null_row=tmp_table.maybe_null=0; - tmp_table.blob_ptr_size=portable_sizeof_char_ptr; - tmp_table.db_low_byte_first= test(create_info->db_type == DB_TYPE_MYISAM || - create_info->db_type == DB_TYPE_HEAP); while ((item=it++)) { @@ -1593,13 +1594,13 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, */ { tmp_disable_binlog(thd); - if (!mysql_create_table(thd, create_table->db, create_table->real_name, + if (!mysql_create_table(thd, create_table->db, create_table->table_name, create_info, *extra_fields, *keys, 0, select_field_count)) { if (!(table= open_table(thd, create_table, thd->mem_root, (bool*) 0))) quick_rm_table(create_info->db_type, create_table->db, - table_case_name(create_info, create_table->real_name)); + table_case_name(create_info, create_table->table_name)); } reenable_binlog(thd); if (!table) // open failed @@ -1613,7 +1614,7 @@ TABLE *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info, hash_delete(&open_cache,(byte*) table); VOID(pthread_mutex_unlock(&LOCK_open)); quick_rm_table(create_info->db_type, create_table->db, - table_case_name(create_info, create_table->real_name)); + table_case_name(create_info, create_table->table_name)); DBUG_RETURN(0); } table->file->extra(HA_EXTRA_WRITE_CACHE); @@ -1696,7 +1697,7 @@ mysql_rename_table(enum db_type base, static void wait_while_table_is_used(THD *thd,TABLE *table, enum ha_extra_function function) { - DBUG_PRINT("enter",("table: %s", table->real_name)); + DBUG_PRINT("enter",("table: %s", table->s->table_name)); DBUG_ENTER("wait_while_table_is_used"); safe_mutex_assert_owner(&LOCK_open); @@ -1705,8 +1706,7 @@ static void wait_while_table_is_used(THD *thd,TABLE *table, mysql_lock_abort(thd, table); // end threads waiting on lock /* Wait until all there are no other threads that has this table open */ - while (remove_table_from_cache(thd,table->table_cache_key, - table->real_name)) + while (remove_table_from_cache(thd, table->s->db, table->s->table_name)) { dropping_tables++; (void) pthread_cond_wait(&COND_refresh,&LOCK_open); @@ -1783,7 +1783,7 @@ static int prepare_for_restore(THD* thd, TABLE_LIST* table, { char* backup_dir= thd->lex->backup_dir; char src_path[FN_REFLEN], dst_path[FN_REFLEN]; - char* table_name = table->real_name; + char* table_name = table->table_name; char* db = thd->db ? thd->db : table->db; if (fn_format_relative_to_data_home(src_path, table_name, backup_dir, @@ -1844,7 +1844,7 @@ static int prepare_for_repair(THD* thd, TABLE_LIST *table_list, { char name[FN_REFLEN]; strxmov(name, mysql_data_home, "/", table_list->db, "/", - table_list->real_name, NullS); + table_list->table_name, NullS); if (openfrm(thd, name, "", 0, 0, 0, &tmp_table)) DBUG_RETURN(0); // Can't open frm file table= &tmp_table; @@ -1871,7 +1871,7 @@ static int prepare_for_repair(THD* thd, TABLE_LIST *table_list, if (!ext[0] || !ext[1]) goto end; // No data file - strxmov(from, table->path, ext[1], NullS); // Name of data file + strxmov(from, table->s->path, ext[1], NullS); // Name of data file if (!my_stat(from, &stat_info, MYF(0))) goto end; // Can't use USE_FRM flag @@ -1979,7 +1979,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables, char table_name[NAME_LEN*2+2]; char* db = (table->db) ? table->db : thd->db; bool fatal_error=0; - strxmov(table_name,db ? db : "",".",table->real_name,NullS); + strxmov(table_name,db ? db : "",".",table->table_name,NullS); thd->open_options|= extra_open_options; table->lock_type= lock_type; @@ -2065,14 +2065,14 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables, } /* Close all instances of the table to allow repair to rename files */ - if (lock_type == TL_WRITE && table->table->version) + if (lock_type == TL_WRITE && table->table->s->version) { pthread_mutex_lock(&LOCK_open); const char *old_message=thd->enter_cond(&COND_refresh, &LOCK_open, "Waiting to get writelock"); mysql_lock_abort(thd,table->table); - while (remove_table_from_cache(thd, table->table->table_cache_key, - table->table->real_name) && + while (remove_table_from_cache(thd, table->table->s->db, + table->table->s->table_name) && ! thd->killed) { dropping_tables++; @@ -2180,12 +2180,12 @@ send_result_message: break; } if (fatal_error) - table->table->version=0; // Force close of table + table->table->s->version=0; // Force close of table else if (open_for_modify) { pthread_mutex_lock(&LOCK_open); - remove_table_from_cache(thd, table->table->table_cache_key, - table->table->real_name); + remove_table_from_cache(thd, table->table->s->db, + table->table->s->table_name); pthread_mutex_unlock(&LOCK_open); /* May be something modified consequently we have to invalidate cache */ query_cache_invalidate3(thd, table->table, 0); @@ -2363,7 +2363,7 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table, TABLE **tmp_table; char src_path[FN_REFLEN], dst_path[FN_REFLEN]; char *db= table->db; - char *table_name= table->real_name; + char *table_name= table->table_name; char *src_db= thd->db; char *src_table= table_ident->table.str; int err; @@ -2385,13 +2385,13 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table, bzero((gptr)&src_tables_list, sizeof(src_tables_list)); src_tables_list.db= table_ident->db.str ? table_ident->db.str : thd->db; - src_tables_list.real_name= table_ident->table.str; + src_tables_list.table_name= table_ident->table.str; if (lock_and_wait_for_table_name(thd, &src_tables_list)) goto err; if ((tmp_table= find_temporary_table(thd, src_db, src_table))) - strxmov(src_path, (*tmp_table)->path, reg_ext, NullS); + strxmov(src_path, (*tmp_table)->s->path, reg_ext, NullS); else { strxmov(src_path, mysql_data_home, "/", src_db, "/", src_table, @@ -2669,7 +2669,7 @@ int mysql_create_indexes(THD *thd, TABLE_LIST *table_list, List &keys) create_info.default_table_charset= thd->variables.collation_database; /* Cleanup the fields list. We do not want to create existing fields. */ fields.delete_elements(); - if (real_alter_table(thd, table_list->db, table_list->real_name, + if (real_alter_table(thd, table_list->db, table_list->table_name, &create_info, table_list, table, fields, keys, drop, alter, 0, (ORDER*)0, ALTER_ADD_INDEX, DUP_ERROR)) @@ -2681,7 +2681,7 @@ int mysql_create_indexes(THD *thd, TABLE_LIST *table_list, List &keys) if (table->file->add_index(table, key_info_buffer, key_count)|| (my_snprintf(path, sizeof(path), "%s/%s/%s%s", mysql_data_home, table_list->db, (lower_case_table_names == 2) ? - table_list->alias: table_list->real_name, reg_ext) >= + table_list->alias: table_list->table_name, reg_ext) >= (int) sizeof(path)) || ! unpack_filename(path, path) || mysql_create_frm(thd, path, &create_info, @@ -2766,7 +2766,7 @@ int mysql_drop_indexes(THD *thd, TABLE_LIST *table_list, if ((drop_key)|| (drop.elements<= 0)) { - if (real_alter_table(thd, table_list->db, table_list->real_name, + if (real_alter_table(thd, table_list->db, table_list->table_name, &create_info, table_list, table, fields, keys, drop, alter, 0, (ORDER*)0, ALTER_DROP_INDEX, DUP_ERROR)) @@ -2783,7 +2783,7 @@ int mysql_drop_indexes(THD *thd, TABLE_LIST *table_list, /*select_field_count*/ 0)|| (snprintf(path, sizeof(path), "%s/%s/%s%s", mysql_data_home, table_list->db, (lower_case_table_names == 2)? - table_list->alias: table_list->real_name, reg_ext)>= + table_list->alias: table_list->table_name, reg_ext)>= (int)sizeof(path))|| ! unpack_filename(path, path)|| mysql_create_frm(thd, path, &create_info, @@ -2823,7 +2823,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, DBUG_ENTER("mysql_alter_table"); thd->proc_info="init"; - table_name=table_list->real_name; + table_name=table_list->table_name; alias= (lower_case_table_names == 2) ? table_list->alias : table_name; db=table_list->db; @@ -2864,7 +2864,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, } else { - if (table->tmp_table) + if (table->s->tmp_table) { if (find_temporary_table(thd,new_db,new_name_buff)) { @@ -2892,9 +2892,9 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, new_name= table_name; } - old_db_type=table->db_type; + old_db_type= table->s->db_type; if (create_info->db_type == DB_TYPE_DEFAULT) - create_info->db_type=old_db_type; + create_info->db_type= old_db_type; if ((new_db_type= ha_checktype(create_info->db_type)) != create_info->db_type) { @@ -2906,11 +2906,11 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, new_name); } if (create_info->row_type == ROW_TYPE_NOT_USED) - create_info->row_type=table->row_type; + create_info->row_type= table->s->row_type; thd->proc_info="setup"; if (!(alter_info->flags & ~(ALTER_RENAME | ALTER_KEYS_ONOFF)) && - !table->tmp_table) // no need to touch frm + !table->s->tmp_table) // no need to touch frm { error=0; if (new_name != table_name || new_db != db) @@ -2960,7 +2960,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, { push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA), - table->table_name); + table->alias); error=0; } if (!error) @@ -2988,15 +2988,15 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, /* Let new create options override the old ones */ if (!(used_fields & HA_CREATE_USED_MIN_ROWS)) - create_info->min_rows=table->min_rows; + create_info->min_rows= table->s->min_rows; if (!(used_fields & HA_CREATE_USED_MAX_ROWS)) - create_info->max_rows=table->max_rows; + create_info->max_rows= table->s->max_rows; if (!(used_fields & HA_CREATE_USED_AVG_ROW_LENGTH)) - create_info->avg_row_length=table->avg_row_length; + create_info->avg_row_length= table->s->avg_row_length; if (!(used_fields & HA_CREATE_USED_DEFAULT_CHARSET)) - create_info->default_table_charset= table->table_charset; + create_info->default_table_charset= table->s->table_charset; - restore_record(table,default_values); // Empty record for DEFAULT + restore_record(table, s->default_values); // Empty record for DEFAULT List_iterator drop_it(alter_info->drop_list); List_iterator def_it(fields); List_iterator alter_it(alter_info->alter_list); @@ -3126,7 +3126,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, List key_parts; KEY *key_info=table->key_info; - for (uint i=0 ; i < table->keys ; i++,key_info++) + for (uint i=0 ; i < table->s->keys ; i++,key_info++) { char *key_name= key_info->name; Alter_drop *drop; @@ -3220,7 +3220,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, goto err; } - db_create_options=table->db_create_options & ~(HA_OPTION_PACK_RECORD); + db_create_options= table->s->db_create_options & ~(HA_OPTION_PACK_RECORD); my_snprintf(tmp_name, sizeof(tmp_name), "%s-%lx_%lx", tmp_file_prefix, current_pid, thd->thread_id); /* Safety fix for innodb */ @@ -3228,7 +3228,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, my_casedn_str(files_charset_info, tmp_name); create_info->db_type=new_db_type; if (!create_info->comment) - create_info->comment=table->comment; + create_info->comment= table->s->comment; table->file->update_create_info(create_info); if ((create_info->table_options & @@ -3244,7 +3244,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, HA_OPTION_NO_DELAY_KEY_WRITE); create_info->table_options|= db_create_options; - if (table->tmp_table) + if (table->s->tmp_table) create_info->options|=HA_LEX_CREATE_TMP_TABLE; /* @@ -3254,7 +3254,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, */ need_copy_table=(alter_info->flags & ~(ALTER_CHANGE_COLUMN_DEFAULT|ALTER_OPTIONS) || create_info->used_fields & ~(HA_CREATE_USED_COMMENT|HA_CREATE_USED_PASSWORD) || - table->tmp_table); + table->s->tmp_table); create_info->frm_only= !need_copy_table; /* @@ -3315,12 +3315,12 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, } if (need_copy_table) { - if (table->tmp_table) + if (table->s->tmp_table) { TABLE_LIST tbl; bzero((void*) &tbl, sizeof(tbl)); tbl.db= new_db; - tbl.real_name= tbl.alias= tmp_name; + tbl.table_name= tbl.alias= tmp_name; new_table= open_table(thd, &tbl, thd->mem_root, 0); } else @@ -3344,7 +3344,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, thd->proc_info="copy to tmp table"; next_insert_id=thd->next_insert_id; // Remember for logging copied=deleted=0; - if (new_table && !new_table->is_view) + if (new_table && !new_table->s->is_view) { new_table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET; new_table->next_number_field=new_table->found_next_number_field; @@ -3355,7 +3355,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, thd->last_insert_id=next_insert_id; // Needed for correct log thd->count_cuted_fields= CHECK_FIELD_IGNORE; - if (table->tmp_table) + if (table->s->tmp_table) { /* We changed a temporary table */ if (error) @@ -3374,7 +3374,7 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name, thd->lock=0; } /* Remove link to old table and rename the new one */ - close_temporary_table(thd,table->table_cache_key,table_name); + close_temporary_table(thd, table->s->db, table_name); if (rename_temporary_table(thd, new_table, new_db, new_alias)) { // Fatal error close_temporary_table(thd,new_db,tmp_name); @@ -3588,7 +3588,7 @@ copy_data_between_tables(TABLE *from,TABLE *to, ulong save_sql_mode; DBUG_ENTER("copy_data_between_tables"); - if (!(copy= new Copy_field[to->fields])) + if (!(copy= new Copy_field[to->s->fields])) DBUG_RETURN(-1); /* purecov: inspected */ if (to->file->external_lock(thd, F_WRLCK)) @@ -3630,9 +3630,9 @@ copy_data_between_tables(TABLE *from,TABLE *to, from->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE), MYF(MY_FAE | MY_ZEROFILL)); bzero((char*) &tables,sizeof(tables)); - tables.table = from; - tables.alias = tables.real_name= from->real_name; - tables.db = from->table_cache_key; + tables.table= from; + tables.alias= tables.table_name= (char*) from->s->table_name; + tables.db= (char*) from->s->db; error=1; if (thd->lex->select_lex.setup_ref_array(thd, order_num) || @@ -3666,6 +3666,7 @@ copy_data_between_tables(TABLE *from,TABLE *to, handle_duplicates == DUP_REPLACE) to->file->extra(HA_EXTRA_IGNORE_DUP_KEY); thd->row_count= 0; + restore_record(to, s->default_values); // Create empty record while (!(error=info.read_record(&info))) { if (thd->killed) @@ -3791,7 +3792,7 @@ bool mysql_checksum_table(THD *thd, TABLE_LIST *tables, HA_CHECK_OPT *check_opt) char table_name[NAME_LEN*2+2]; TABLE *t; - strxmov(table_name, table->db ,".", table->real_name, NullS); + strxmov(table_name, table->db ,".", table->table_name, NullS); t= table->table= open_ltable(thd, table, TL_READ_NO_INSERT); thd->clear_error(); // these errors shouldn't get client @@ -3836,7 +3837,7 @@ bool mysql_checksum_table(THD *thd, TABLE_LIST *tables, HA_CHECK_OPT *check_opt) row_crc= my_checksum(row_crc, t->record[0], ((byte*) t->field[0]->ptr) - t->record[0]); - for (uint i= 0; i < t->fields; i++ ) + for (uint i= 0; i < t->s->fields; i++ ) { Field *f= t->field[i]; if (f->type() == FIELD_TYPE_BLOB) diff --git a/sql/sql_test.cc b/sql/sql_test.cc index 6cffa9df2c6..2739fe865f7 100644 --- a/sql/sql_test.cc +++ b/sql/sql_test.cc @@ -79,7 +79,7 @@ void print_cached_tables(void) { TABLE *entry=(TABLE*) hash_element(&open_cache,idx); printf("%-14.14s %-32s%6ld%8ld%10ld%6d %s\n", - entry->table_cache_key,entry->real_name,entry->version, + entry->s->db, entry->s->table_name, entry->s->version, entry->in_use ? entry->in_use->thread_id : 0L, entry->in_use ? entry->in_use->dbug_thread_id : 0L, entry->db_stat ? 1 : 0, entry->in_use ? lock_descriptions[(int)entry->reginfo.lock_type] : "Not in use"); @@ -131,7 +131,7 @@ void TEST_filesort(SORT_FIELD *sortorder,uint s_length) { if (sortorder->field->table_name) { - out.append(sortorder->field->table_name); + out.append(*sortorder->field->table_name); out.append('.'); } out.append(sortorder->field->field_name ? sortorder->field->field_name: @@ -167,7 +167,7 @@ TEST_join(JOIN *join) TABLE *form=tab->table; char key_map_buff[128]; fprintf(DBUG_FILE,"%-16.16s type: %-7s q_keys: %s refs: %d key: %d len: %d\n", - form->table_name, + form->alias, join_type_str[tab->type], tab->keys.print(key_map_buff), tab->ref.key_parts, @@ -261,7 +261,7 @@ print_plan(JOIN* join, double read_time, double record_count, pos = join->positions[i]; table= pos.table->table; if (table) - fputs(table->real_name, DBUG_FILE); + fputs(table->s->table_name, DBUG_FILE); fputc(' ', DBUG_FILE); } fputc('\n', DBUG_FILE); @@ -278,7 +278,7 @@ print_plan(JOIN* join, double read_time, double record_count, pos= join->best_positions[i]; table= pos.table->table; if (table) - fputs(table->real_name, DBUG_FILE); + fputs(table->s->table_name, DBUG_FILE); fputc(' ', DBUG_FILE); } } @@ -289,7 +289,7 @@ print_plan(JOIN* join, double read_time, double record_count, for (plan_nodes= join->best_ref ; *plan_nodes ; plan_nodes++) { join_table= (*plan_nodes); - fputs(join_table->table->real_name, DBUG_FILE); + fputs(join_table->table->s->table_name, DBUG_FILE); fprintf(DBUG_FILE, "(%lu,%lu,%lu)", (ulong) join_table->found_records, (ulong) join_table->records, @@ -332,12 +332,12 @@ static void push_locks_into_array(DYNAMIC_ARRAY *ar, THR_LOCK_DATA *data, if (data) { TABLE *table=(TABLE *)data->debug_print_param; - if (table && table->tmp_table == NO_TMP_TABLE) + if (table && table->s->tmp_table == NO_TMP_TABLE) { TABLE_LOCK_INFO table_lock_info; - table_lock_info.thread_id=table->in_use->thread_id; - memcpy(table_lock_info.table_name, table->table_cache_key, - table->key_length); + table_lock_info.thread_id= table->in_use->thread_id; + memcpy(table_lock_info.table_name, table->s->table_cache_key, + table->s->key_length); table_lock_info.table_name[strlen(table_lock_info.table_name)]='.'; table_lock_info.waiting=wait; table_lock_info.lock_text=text; diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc index 96ede3fbe6b..5968d13efde 100644 --- a/sql/sql_trigger.cc +++ b/sql/sql_trigger.cc @@ -70,7 +70,7 @@ bool mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create) Table_triggers_list::create_trigger() because we want to avoid messing with table cash for views and temporary tables. */ - if (tables->view || table->tmp_table != NO_TMP_TABLE) + if (tables->view || table->s->tmp_table != NO_TMP_TABLE) { my_error(ER_TRG_ON_VIEW_OR_TEMP_TABLE, MYF(0), tables->alias); DBUG_RETURN(TRUE); @@ -188,7 +188,7 @@ bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables) strxnmov(dir_buff, FN_REFLEN, mysql_data_home, "/", tables->db, "/", NullS); dir.length= unpack_filename(dir_buff, dir_buff); dir.str= dir_buff; - file.length= strxnmov(file_buff, FN_REFLEN, tables->real_name, + file.length= strxnmov(file_buff, FN_REFLEN, tables->table_name, triggers_file_ext, NullS) - file_buff; file.str= file_buff; @@ -257,7 +257,7 @@ bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables) elsewhere). */ strxnmov(path, FN_REFLEN, mysql_data_home, "/", tables->db, "/", - tables->real_name, triggers_file_ext, NullS); + tables->table_name, triggers_file_ext, NullS); unpack_filename(path, path); return my_delete(path, MYF(MY_WME)); } @@ -270,7 +270,7 @@ bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables) "/", NullS); dir.length= unpack_filename(dir_buff, dir_buff); dir.str= dir_buff; - file.length= strxnmov(file_buff, FN_REFLEN, tables->real_name, + file.length= strxnmov(file_buff, FN_REFLEN, tables->table_name, triggers_file_ext, NullS) - file_buff; file.str= file_buff; @@ -315,7 +315,7 @@ bool Table_triggers_list::prepare_old_row_accessors(TABLE *table) Field **fld, **old_fld; if (!(old_field= (Field **)alloc_root(&table->mem_root, - (table->fields + 1) * + (table->s->fields + 1) * sizeof(Field*)))) return 1; diff --git a/sql/sql_udf.cc b/sql/sql_udf.cc index 7fd81f22e66..ec47fb055e2 100644 --- a/sql/sql_udf.cc +++ b/sql/sql_udf.cc @@ -146,7 +146,7 @@ void udf_init() new_thd->db_length=5; bzero((gptr) &tables,sizeof(tables)); - tables.alias= tables.real_name= (char*) "func"; + tables.alias= tables.table_name= (char*) "func"; tables.lock_type = TL_READ; tables.db=new_thd->db; @@ -168,7 +168,7 @@ void udf_init() char *dl_name= get_field(&mem, table->field[2]); bool new_dl=0; Item_udftype udftype=UDFTYPE_FUNCTION; - if (table->fields >= 4) // New func table + if (table->s->fields >= 4) // New func table udftype=(Item_udftype) table->field[3]->val_int(); if (!(tmp = add_udf(&name,(Item_result) table->field[1]->val_int(), @@ -429,16 +429,16 @@ int mysql_create_function(THD *thd,udf_func *udf) bzero((char*) &tables,sizeof(tables)); tables.db= (char*) "mysql"; - tables.real_name= tables.alias= (char*) "func"; + tables.table_name= tables.alias= (char*) "func"; /* Allow creation of functions even if we can't open func table */ if (!(table = open_ltable(thd,&tables,TL_WRITE))) goto err; - restore_record(table,default_values); // Default values for fields + restore_record(table, s->default_values); // Default values for fields table->field[0]->store(u_d->name.str, u_d->name.length, system_charset_info); table->field[1]->store((longlong) u_d->returns); table->field[2]->store(u_d->dl,(uint) strlen(u_d->dl), system_charset_info); - if (table->fields >= 4) // If not old func format + if (table->s->fields >= 4) // If not old func format table->field[3]->store((longlong) u_d->type); error = table->file->write_row(table->record[0]); @@ -488,7 +488,7 @@ int mysql_drop_function(THD *thd,const LEX_STRING *udf_name) bzero((char*) &tables,sizeof(tables)); tables.db=(char*) "mysql"; - tables.real_name= tables.alias= (char*) "func"; + tables.table_name= tables.alias= (char*) "func"; if (!(table = open_ltable(thd,&tables,TL_WRITE))) goto err; if (!table->file->index_read_idx(table->record[0],0,(byte*) udf_name->str, diff --git a/sql/sql_union.cc b/sql/sql_union.cc index 901cb0ba496..ce84be47243 100644 --- a/sql/sql_union.cc +++ b/sql/sql_union.cc @@ -313,7 +313,7 @@ bool st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result, table->file->extra(HA_EXTRA_IGNORE_DUP_KEY); bzero((char*) &result_table_list, sizeof(result_table_list)); result_table_list.db= (char*) ""; - result_table_list.real_name= result_table_list.alias= (char*) "union"; + result_table_list.table_name= result_table_list.alias= (char*) "union"; result_table_list.table= table; union_result->set_table(table); diff --git a/sql/sql_update.cc b/sql/sql_update.cc index 5ca25bbac3e..3908c4a7456 100644 --- a/sql/sql_update.cc +++ b/sql/sql_update.cc @@ -31,18 +31,18 @@ static bool safe_update_on_fly(JOIN_TAB *join_tab, List *fields); static bool compare_record(TABLE *table, ulong query_id) { - if (!table->blob_fields) + if (!table->s->blob_fields) return cmp_record(table,record[1]); /* Compare null bits */ if (memcmp(table->null_flags, - table->null_flags+table->rec_buff_length, - table->null_bytes)) + table->null_flags+table->s->rec_buff_length, + table->s->null_bytes)) return TRUE; // Diff in NULL value /* Compare updated fields */ for (Field **ptr=table->field ; *ptr ; ptr++) { if ((*ptr)->query_id == query_id && - (*ptr)->cmp_binary_offset(table->rec_buff_length)) + (*ptr)->cmp_binary_offset(table->s->rec_buff_length)) return TRUE; } return FALSE; @@ -166,7 +166,7 @@ int mysql_update(THD *thd, table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK); /* Calculate "table->used_keys" based on the WHERE */ - table->used_keys=table->keys_in_use; + table->used_keys= table->s->keys_in_use; table->quick_keys.clear_all(); #ifndef NO_EMBEDDED_ACCESS_CHECKS @@ -471,7 +471,7 @@ int mysql_update(THD *thd, query_cache_invalidate3(thd, table_list, 1); } - log_delayed= (transactional_table || table->tmp_table); + log_delayed= (transactional_table || table->s->tmp_table); if ((updated || (error < 0)) && (error <= 0 || !transactional_table)) { if (mysql_bin_log.is_open()) @@ -572,7 +572,7 @@ bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list, /* Check that we are not using table that we are updating in a sub select */ if (unique_table(table_list, table_list->next_global)) { - my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->real_name); + my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name); DBUG_RETURN(TRUE); } select_lex->fix_prepare_information(thd, conds); @@ -698,9 +698,9 @@ bool mysql_multi_update_prepare(THD *thd) single SELECT on top and have to check underlying SELECTs of it */ if (lex->select_lex.check_updateable_in_subqueries(tl->db, - tl->real_name)) + tl->table_name)) { - my_error(ER_UPDATE_TABLE_USED, MYF(0), tl->real_name); + my_error(ER_UPDATE_TABLE_USED, MYF(0), tl->table_name); DBUG_RETURN(TRUE); } DBUG_PRINT("info",("setting table `%s` for update", tl->alias)); @@ -924,7 +924,7 @@ int multi_update::prepare(List ¬_used_values, table_count= update.elements; update_tables= (TABLE_LIST*) update.first; - tmp_tables = (TABLE **) thd->calloc(sizeof(TABLE *) * table_count); + tmp_tables = (TABLE**) thd->calloc(sizeof(TABLE *) * table_count); tmp_table_param = (TMP_TABLE_PARAM*) thd->calloc(sizeof(TMP_TABLE_PARAM) * table_count); fields_for_table= (List_item **) thd->alloc(sizeof(List_item *) * @@ -976,7 +976,7 @@ int multi_update::prepare(List ¬_used_values, TABLE *table=table_ref->table; if (!(tables_to_update & table->map) && find_table_in_local_list(update_tables, table_ref->db, - table_ref->real_name)) + table_ref->table_name)) table->no_cache= 1; // Disable row cache } DBUG_RETURN(thd->is_fatal_error != 0); @@ -1002,7 +1002,7 @@ multi_update::initialize_tables(JOIN *join) DBUG_RETURN(1); main_table=join->join_tab->table; trans_safe= transactional_tables= main_table->file->has_transactions(); - log_delayed= trans_safe || main_table->tmp_table != NO_TMP_TABLE; + log_delayed= trans_safe || main_table->s->tmp_table != NO_TMP_TABLE; table_to_update= 0; /* Create a temporary table for keys to all tables, except main table */ @@ -1105,8 +1105,8 @@ static bool safe_update_on_fly(JOIN_TAB *join_tab, List *fields) return !join_tab->quick->check_if_keys_used(fields); /* If scanning in clustered key */ if ((table->file->table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) && - table->primary_key < MAX_KEY) - return !check_if_key_used(table, table->primary_key, *fields); + table->s->primary_key < MAX_KEY) + return !check_if_key_used(table, table->s->primary_key, *fields); return TRUE; default: break; // Avoid compler warning @@ -1337,14 +1337,14 @@ int multi_update::do_updates(bool from_send_error) goto err; } updated++; - if (table->tmp_table != NO_TMP_TABLE) + if (table->s->tmp_table != NO_TMP_TABLE) log_delayed= 1; } } if (updated != org_updated) { - if (table->tmp_table != NO_TMP_TABLE) + if (table->s->tmp_table != NO_TMP_TABLE) log_delayed= 1; // Tmp tables forces delay log if (table->file->has_transactions()) log_delayed= transactional_tables= 1; @@ -1368,7 +1368,7 @@ err: if (updated != org_updated) { - if (table->tmp_table != NO_TMP_TABLE) + if (table->s->tmp_table != NO_TMP_TABLE) log_delayed= 1; if (table->file->has_transactions()) log_delayed= transactional_tables= 1; diff --git a/sql/sql_view.cc b/sql/sql_view.cc index bafb57c44b0..6680ea95561 100644 --- a/sql/sql_view.cc +++ b/sql/sql_view.cc @@ -118,7 +118,7 @@ bool mysql_create_view(THD *thd, if (check_some_access(thd, VIEW_ANY_ACL, tbl)) { my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), - "ANY", thd->priv_user, thd->host_or_ip, tbl->real_name); + "ANY", thd->priv_user, thd->host_or_ip, tbl->table_name); DBUG_RETURN(TRUE); } /* @@ -136,11 +136,11 @@ bool mysql_create_view(THD *thd, /* Make sure that all rights are loaded to the TABLE::grant field. - tbl->real_name will be correct name of table because VIEWs are + tbl->table_name will be correct name of table because VIEWs are not opened yet. */ fill_effective_table_privileges(thd, &tbl->grant, tbl->db, - tbl->real_name); + tbl->table_name); } } @@ -187,7 +187,7 @@ bool mysql_create_view(THD *thd, for (tbl= tables; tbl; tbl= tbl->next_global) { /* is this table temporary and is not view? */ - if (tbl->table->tmp_table != NO_TMP_TABLE && !tbl->view && + if (tbl->table->s->tmp_table != NO_TMP_TABLE && !tbl->view && !tbl->schema_table) { my_error(ER_VIEW_SELECT_TMPTABLE, MYF(0), tbl->alias); @@ -198,7 +198,7 @@ bool mysql_create_view(THD *thd, /* is this table view and the same view which we creates now? */ if (tbl->view && strcmp(tbl->view_db.str, view->db) == 0 && - strcmp(tbl->view_name.str, view->real_name) == 0) + strcmp(tbl->view_name.str, view->table_name) == 0) { my_error(ER_NO_SUCH_TABLE, MYF(0), tbl->view_db.str, tbl->view_name.str); res= TRUE; @@ -272,24 +272,24 @@ bool mysql_create_view(THD *thd, List_iterator_fast it(sl->item_list); Item *item; fill_effective_table_privileges(thd, &view->grant, db, - view->real_name); + view->table_name); while ((item= it++)) { Item_field *fld; uint priv= (get_column_grant(thd, &view->grant, db, - view->real_name, item->name) & + view->table_name, item->name) & VIEW_ANY_ACL); if ((fld= item->filed_for_view_update())) { /* Do we have more privileges on view field then underlying table field? */ - if (!fld->field->table->tmp_table && (~fld->have_privileges & priv)) + if (!fld->field->table->s->tmp_table && (~fld->have_privileges & priv)) { /* VIEW column has more privileges */ my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0), "create view", thd->priv_user, thd->host_or_ip, item->name, - view->real_name); + view->table_name); DBUG_RETURN(TRUE); } } @@ -404,7 +404,7 @@ static int mysql_register_view(THD *thd, TABLE_LIST *view, dir.length= strlen(dir_buff); file.str= file_buff; - file.length= (strxnmov(file_buff, FN_REFLEN, view->real_name, reg_ext, + file.length= (strxnmov(file_buff, FN_REFLEN, view->table_name, reg_ext, NullS) - file_buff); /* init timestamp */ if (!view->timestamp.str) @@ -435,7 +435,7 @@ static int mysql_register_view(THD *thd, TABLE_LIST *view, strncmp("VIEW", parser->type()->str, parser->type()->length)) { my_error(ER_WRONG_OBJECT, MYF(0), - (view->db ? view->db : thd->db), view->real_name, "VIEW"); + (view->db ? view->db : thd->db), view->table_name, "VIEW"); DBUG_RETURN(-1); } @@ -518,7 +518,7 @@ loop_out: !((TABLE_LIST*)lex->select_lex.table_list.first)->next_local && find_table_in_global_list(lex->query_tables->next_global, lex->query_tables->db, - lex->query_tables->real_name)) + lex->query_tables->table_name)) { view->updatable_view= 0; } @@ -526,7 +526,7 @@ loop_out: if (view->with_check != VIEW_CHECK_NONE && !view->updatable_view) { - my_error(ER_VIEW_NONUPD_CHECK, MYF(0), view->db, view->real_name); + my_error(ER_VIEW_NONUPD_CHECK, MYF(0), view->db, view->table_name); DBUG_RETURN(-1); } @@ -598,8 +598,8 @@ mysql_make_view(File_parser *parser, TABLE_LIST *table) */ table->view_db.str= table->db; table->view_db.length= table->db_length; - table->view_name.str= table->real_name; - table->view_name.length= table->real_name_length; + table->view_name.str= table->table_name; + table->view_name.length= table->table_name_length; /*TODO: md5 test here and warning if it is differ */ @@ -669,8 +669,8 @@ mysql_make_view(File_parser *parser, TABLE_LIST *table) TABLE_LIST *table= old_lex->proc_table; table->db= (char*)"mysql"; table->db_length= 5; - table->real_name= table->alias= (char*)"proc"; - table->real_name_length= 4; + table->table_name= table->alias= (char*)"proc"; + table->table_name_length= 4; table->cacheable_table= 1; old_lex->add_to_query_tables(table); } @@ -889,13 +889,13 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) for (view= views; view; view= view->next_local) { strxnmov(path, FN_REFLEN, mysql_data_home, "/", view->db, "/", - view->real_name, reg_ext, NullS); + view->table_name, reg_ext, NullS); (void) unpack_filename(path, path); VOID(pthread_mutex_lock(&LOCK_open)); if (access(path, F_OK) || (type= (mysql_frm_type(path) != FRMTYPE_VIEW))) { char name[FN_REFLEN]; - my_snprintf(name, sizeof(name), "%s.%s", view->db, view->real_name); + my_snprintf(name, sizeof(name), "%s.%s", view->db, view->table_name); if (thd->lex->drop_if_exists) { push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, @@ -905,7 +905,7 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode) continue; } if (type) - my_error(ER_WRONG_OBJECT, MYF(0), view->db, view->real_name, "VIEW"); + my_error(ER_WRONG_OBJECT, MYF(0), view->db, view->table_name, "VIEW"); else my_error(ER_BAD_TABLE_ERROR, MYF(0), name); goto err; @@ -998,7 +998,7 @@ bool check_key_in_view(THD *thd, TABLE_LIST *view) if (view->belong_to_view) view= view->belong_to_view; trans= view->field_translation; - key_info_end= (key_info= table->key_info)+ table->keys; + key_info_end= (key_info= table->key_info)+ table->s->keys; elements_in_view= view->view->select_lex.item_list.elements; DBUG_ASSERT(table != 0 && view->field_translation != 0); diff --git a/sql/table.cc b/sql/table.cc index e9b89d6b124..b8d4d3fea94 100644 --- a/sql/table.cc +++ b/sql/table.cc @@ -85,27 +85,29 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, uint null_bit_pos, new_frm_ver, field_pack_length; SQL_CRYPT *crypted=0; MEM_ROOT **root_ptr, *old_root; + TABLE_SHARE *share; DBUG_ENTER("openfrm"); DBUG_PRINT("enter",("name: '%s' form: 0x%lx",name,outparam)); - error=1; - disk_buff=NULL; + error= 1; + disk_buff= NULL; root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC); old_root= *root_ptr; + bzero((char*) outparam,sizeof(*outparam)); + outparam->in_use= thd; + outparam->s= share= &outparam->share_not_to_be_used; + if ((file=my_open(fn_format(index_file, name, "", reg_ext, MY_UNPACK_FILENAME), O_RDONLY | O_SHARE, MYF(0))) < 0) - { goto err_w_init; - } + error= 4; if (my_read(file,(byte*) head,64,MYF(MY_NABP))) - { goto err_w_init; - } if (memcmp(head, "TYPE=", 5) == 0) { @@ -116,28 +118,22 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, DBUG_RETURN(5); // caller can't process new .frm - error= 4; goto err_w_init; } - bzero((char*) outparam,sizeof(*outparam)); - outparam->in_use= thd; - outparam->blob_ptr_size=sizeof(char*); - outparam->db_stat = db_stat; + share->blob_ptr_size= sizeof(char*); + outparam->db_stat= db_stat; init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0); *root_ptr= &outparam->mem_root; - outparam->real_name=strdup_root(&outparam->mem_root, - name+dirname_length(name)); - *fn_ext(outparam->real_name)='\0'; // Remove extension - outparam->table_name=my_strdup(alias,MYF(MY_WME)); - if (!outparam->real_name || !outparam->table_name) - goto err_end; - - error=4; - if (!(outparam->path= strdup_root(&outparam->mem_root,name))) + share->table_name= strdup_root(&outparam->mem_root, + name+dirname_length(name)); + share->path= strdup_root(&outparam->mem_root, name); + outparam->alias= my_strdup(alias, MYF(MY_WME)); + if (!share->table_name || !share->path || !outparam->alias) goto err_not_open; - *fn_ext(outparam->path)='\0'; // Remove extension + *fn_ext(share->table_name)='\0'; // Remove extension + *fn_ext(share->path)='\0'; // Remove extension if (head[0] != (uchar) 254 || head[1] != 1 || (head[2] != FRM_VER && head[2] != FRM_VER+1 && @@ -152,31 +148,34 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, goto err_not_open; /* purecov: inspected */ *fn_ext(index_file)='\0'; // Remove .frm extension - outparam->frm_version= head[2]; - outparam->db_type=ha_checktype((enum db_type) (uint) *(head+3)); - outparam->db_create_options=db_create_options=uint2korr(head+30); - outparam->db_options_in_use=outparam->db_create_options; - null_field_first=0; + share->frm_version= head[2]; + share->db_type= ha_checktype((enum db_type) (uint) *(head+3)); + share->db_create_options= db_create_options=uint2korr(head+30); + share->db_options_in_use= share->db_create_options; + null_field_first= 0; if (!head[32]) // New frm file in 3.23 { - outparam->avg_row_length=uint4korr(head+34); - outparam->row_type=(row_type) head[40]; - outparam->raid_type= head[41]; - outparam->raid_chunks= head[42]; - outparam->raid_chunksize= uint4korr(head+43); - outparam->table_charset=get_charset((uint) head[38],MYF(0)); - null_field_first=1; + share->avg_row_length= uint4korr(head+34); + share-> row_type= (row_type) head[40]; + share->raid_type= head[41]; + share->raid_chunks= head[42]; + share->raid_chunksize= uint4korr(head+43); + share->table_charset= get_charset((uint) head[38],MYF(0)); + null_field_first= 1; } - if (!outparam->table_charset) /* unknown charset in head[38] or pre-3.23 frm */ - outparam->table_charset=default_charset_info; - outparam->db_record_offset=1; + if (!share->table_charset) + { + /* unknown charset in head[38] or pre-3.23 frm */ + share->table_charset= default_charset_info; + } + share->db_record_offset= 1; if (db_create_options & HA_OPTION_LONG_BLOB_PTR) - outparam->blob_ptr_size=portable_sizeof_char_ptr; + share->blob_ptr_size= portable_sizeof_char_ptr; /* Set temporarily a good value for db_low_byte_first */ - outparam->db_low_byte_first=test(outparam->db_type != DB_TYPE_ISAM); + share->db_low_byte_first= test(share->db_type != DB_TYPE_ISAM); error=4; - outparam->max_rows=uint4korr(head+18); - outparam->min_rows=uint4korr(head+22); + share->max_rows= uint4korr(head+18); + share->min_rows= uint4korr(head+22); /* Read keyinformation */ key_info_length= (uint) uint2korr(head+28); @@ -185,17 +184,16 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, goto err_not_open; /* purecov: inspected */ if (disk_buff[0] & 0x80) { - outparam->keys= keys= (disk_buff[1] << 7) | (disk_buff[0] & 0x7f); - outparam->key_parts= key_parts= uint2korr(disk_buff+2); + share->keys= keys= (disk_buff[1] << 7) | (disk_buff[0] & 0x7f); + share->key_parts= key_parts= uint2korr(disk_buff+2); } else { - outparam->keys= keys= disk_buff[0]; - outparam->key_parts= key_parts= disk_buff[1]; + share->keys= keys= disk_buff[0]; + share->key_parts= key_parts= disk_buff[1]; } - outparam->keys_for_keyread.init(0); - outparam->keys_in_use.init(keys); - outparam->read_only_keys.init(keys); + share->keys_for_keyread.init(0); + share->keys_in_use.init(keys); outparam->quick_keys.init(); outparam->used_keys.init(); outparam->keys_in_use_for_query.init(); @@ -206,7 +204,6 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, goto err_not_open; /* purecov: inspected */ bzero((char*) keyinfo,n_length); outparam->key_info=keyinfo; - outparam->max_key_length= outparam->total_key_length= 0; key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys); strpos=disk_buff+6; @@ -267,9 +264,9 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, keynames=(char*) key_part; strpos+= (strmov(keynames, (char *) strpos) - keynames)+1; - outparam->reclength = uint2korr((head+16)); + share->reclength = uint2korr((head+16)); if (*(head+26) == 1) - outparam->system=1; /* one-record-database */ + share->system= 1; /* one-record-database */ #ifdef HAVE_CRYPTED_FRM else if (*(head+26) == 2) { @@ -281,45 +278,37 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, #endif /* Allocate handler */ - if (!(outparam->file= get_new_handler(outparam,outparam->db_type))) + if (!(outparam->file= get_new_handler(outparam, share->db_type))) goto err_not_open; error=4; outparam->reginfo.lock_type= TL_UNLOCK; outparam->current_lock=F_UNLCK; - if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN)) records=2; - else records=1; + if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN)) + records=2; + else + records=1; if (prgflag & (READ_ALL+EXTRA_RECORD)) records++; /* QQ: TODO, remove the +1 from below */ - rec_buff_length=ALIGN_SIZE(outparam->reclength+1+ - outparam->file->extra_rec_buf_length()); - if (!(outparam->record[0]= (byte*) - (record = (char *) alloc_root(&outparam->mem_root, - rec_buff_length * records)))) + rec_buff_length= ALIGN_SIZE(share->reclength + 1 + + outparam->file->extra_rec_buf_length()); + share->rec_buff_length= rec_buff_length; + if (!(record= (char *) alloc_root(&outparam->mem_root, + rec_buff_length * records))) goto err_not_open; /* purecov: inspected */ - record[outparam->reclength]=0; // For purify and ->c_ptr() - outparam->rec_buff_length=rec_buff_length; - if (my_pread(file,(byte*) record,(uint) outparam->reclength, + share->default_values= record; + if (my_pread(file,(byte*) record, (uint) share->reclength, (ulong) (uint2korr(head+6)+ ((uint2korr(head+14) == 0xffff ? uint4korr(head+47) : uint2korr(head+14)))), MYF(MY_NABP))) goto err_not_open; /* purecov: inspected */ - /* HACK: table->record[2] is used instead of table->default_values here */ - for (i=0 ; i < records ; i++, record+=rec_buff_length) - { - outparam->record[i]=(byte*) record; - if (i) - memcpy(record,record-rec_buff_length,(uint) outparam->reclength); - } - if (records == 2) - { /* fix for select */ - outparam->default_values=outparam->record[1]; - if (db_stat & HA_READ_ONLY) - outparam->record[1]=outparam->record[0]; /* purecov: inspected */ - } - outparam->insert_values=0; /* for INSERT ... UPDATE */ + outparam->record[0]= record+ rec_buff_length; + if (records > 2) + outparam->record[1]= record+ rec_buff_length*2; + else + outparam->record[1]= outparam->record[0]; // Safety VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0))); if (my_read(file,(byte*) head,288,MYF(MY_NABP))) goto err_not_open; @@ -330,30 +319,29 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, goto err_not_open; // Wrong password } - outparam->fields= uint2korr(head+258); - pos=uint2korr(head+260); /* Length of all screens */ - n_length=uint2korr(head+268); - interval_count=uint2korr(head+270); - interval_parts=uint2korr(head+272); - int_length=uint2korr(head+274); - outparam->null_fields=uint2korr(head+282); - com_length=uint2korr(head+284); - outparam->comment=strdup_root(&outparam->mem_root, - (char*) head+47); + share->fields= uint2korr(head+258); + pos= uint2korr(head+260); /* Length of all screens */ + n_length= uint2korr(head+268); + interval_count= uint2korr(head+270); + interval_parts= uint2korr(head+272); + int_length= uint2korr(head+274); + share->null_fields= uint2korr(head+282); + com_length= uint2korr(head+284); + share->comment= strdup_root(&outparam->mem_root, (char*) head+47); - DBUG_PRINT("info",("i_count: %d i_parts: %d index: %d n_length: %d int_length: %d com_length: %d", interval_count,interval_parts, outparam->keys,n_length,int_length, com_length)); + DBUG_PRINT("info",("i_count: %d i_parts: %d index: %d n_length: %d int_length: %d com_length: %d", interval_count,interval_parts, share->keys,n_length,int_length, com_length)); if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root, - (uint) ((outparam->fields+1)*sizeof(Field*)+ + (uint) ((share->fields+1)*sizeof(Field*)+ interval_count*sizeof(TYPELIB)+ - (outparam->fields+interval_parts+ + (share->fields+interval_parts+ keys+3)*sizeof(my_string)+ (n_length+int_length+com_length))))) goto err_not_open; /* purecov: inspected */ outparam->field=field_ptr; - read_length=(uint) (outparam->fields * field_pack_length + + read_length=(uint) (share->fields * field_pack_length + pos+ (uint) (n_length+int_length+com_length)); if (read_string(file,(gptr*) &disk_buff,read_length)) goto err_not_open; /* purecov: inspected */ @@ -365,25 +353,25 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, } strpos= disk_buff+pos; - outparam->intervals= (TYPELIB*) (field_ptr+outparam->fields+1); - int_array= (const char **) (outparam->intervals+interval_count); - names= (char*) (int_array+outparam->fields+interval_parts+keys+3); + share->intervals= (TYPELIB*) (field_ptr+share->fields+1); + int_array= (const char **) (share->intervals+interval_count); + names= (char*) (int_array+share->fields+interval_parts+keys+3); if (!interval_count) - outparam->intervals=0; // For better debugging - memcpy((char*) names, strpos+(outparam->fields*field_pack_length), + share->intervals= 0; // For better debugging + memcpy((char*) names, strpos+(share->fields*field_pack_length), (uint) (n_length+int_length)); - comment_pos=names+(n_length+int_length); + comment_pos= names+(n_length+int_length); memcpy(comment_pos, disk_buff+read_length-com_length, com_length); - fix_type_pointers(&int_array,&outparam->fieldnames,1,&names); - fix_type_pointers(&int_array,outparam->intervals,interval_count, + fix_type_pointers(&int_array, &share->fieldnames, 1, &names); + fix_type_pointers(&int_array, share->intervals, interval_count, &names); { /* Set ENUM and SET lengths */ TYPELIB *interval; - for (interval= outparam->intervals; - interval < outparam->intervals + interval_count; + for (interval= share->intervals; + interval < share->intervals + interval_count; interval++) { uint count= (uint) (interval->count + 1) * sizeof(uint); @@ -397,33 +385,33 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, } if (keynames) - fix_type_pointers(&int_array,&outparam->keynames,1,&keynames); + fix_type_pointers(&int_array, &share->keynames, 1, &keynames); VOID(my_close(file,MYF(MY_WME))); file= -1; - record=(char*) outparam->record[0]-1; /* Fieldstart = 1 */ + record= (char*) outparam->record[0]-1; /* Fieldstart = 1 */ if (null_field_first) { outparam->null_flags=null_pos=(uchar*) record+1; null_bit_pos= (db_create_options & HA_OPTION_PACK_RECORD) ? 0 : 1; - outparam->null_bytes= (outparam->null_fields + null_bit_pos + 7) / 8; + share->null_bytes= (share->null_fields + null_bit_pos + 7) / 8; } else { - outparam->null_bytes=(outparam->null_fields+7)/8; - outparam->null_flags=null_pos= - (uchar*) (record+1+outparam->reclength-outparam->null_bytes); + share->null_bytes= (share->null_fields+7)/8; + outparam->null_flags= null_pos= + (uchar*) (record+1+share->reclength-share->null_bytes); null_bit_pos= 0; } - use_hash= outparam->fields >= MAX_FIELDS_BEFORE_HASH; + use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH; if (use_hash) - use_hash= !hash_init(&outparam->name_hash, + use_hash= !hash_init(&share->name_hash, system_charset_info, - outparam->fields,0,0, + share->fields,0,0, (hash_get_key) get_field_name,0,0); - for (i=0 ; i < outparam->fields; i++, strpos+=field_pack_length, field_ptr++) + for (i=0 ; i < share->fields; i++, strpos+=field_pack_length, field_ptr++) { uint pack_flag, interval_nr, unireg_type, recpos, field_length; enum_field_types field_type; @@ -498,7 +486,7 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, if (!f_is_blob(pack_flag)) { // 3.23 or 4.0 string - if (!(charset= get_charset_by_csname(outparam->table_charset->csname, + if (!(charset= get_charset_by_csname(share->table_charset->csname, MY_CS_BINSORT, MYF(0)))) charset= &my_charset_bin; } @@ -506,14 +494,14 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, charset= &my_charset_bin; } else - charset= outparam->table_charset; + charset= share->table_charset; bzero((char*) &comment, sizeof(comment)); } if (interval_nr && charset->mbminlen > 1) { /* Unescape UCS2 intervals from HEX notation */ - TYPELIB *interval= outparam->intervals + interval_nr - 1; + TYPELIB *interval= share->intervals + interval_nr - 1; unhex_type2(interval); } @@ -527,9 +515,9 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, geom_type, (Field::utype) MTYP_TYPENR(unireg_type), (interval_nr ? - outparam->intervals+interval_nr-1 : + share->intervals+interval_nr-1 : (TYPELIB*) 0), - outparam->fieldnames.type_names[i], + share->fieldnames.type_names[i], outparam); if (!reg_field) // Not supported field type { @@ -555,9 +543,9 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, if (reg_field->unireg_check == Field::NEXT_NUMBER) outparam->found_next_number_field= reg_field; if (outparam->timestamp_field == reg_field) - outparam->timestamp_field_offset=i; + share->timestamp_field_offset= i; if (use_hash) - (void) my_hash_insert(&outparam->name_hash,(byte*) field_ptr); // Will never fail + (void) my_hash_insert(&share->name_hash,(byte*) field_ptr); // never fail } *field_ptr=0; // End marker @@ -565,15 +553,15 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, if (key_parts) { uint primary_key=(uint) (find_type((char*) primary_key_name, - &outparam->keynames, 3) - 1); + &share->keynames, 3) - 1); uint ha_option=outparam->file->table_flags(); keyinfo=outparam->key_info; key_part=keyinfo->key_part; - for (uint key=0 ; key < outparam->keys ; key++,keyinfo++) + for (uint key=0 ; key < share->keys ; key++,keyinfo++) { uint usable_parts=0; - keyinfo->name=(char*) outparam->keynames.type_names[key]; + keyinfo->name=(char*) share->keynames.type_names[key]; /* Fix fulltext keys for old .frm files */ if (outparam->key_info[key].flags & HA_FULLTEXT) outparam->key_info[key].algorithm= HA_KEY_ALG_FULLTEXT; @@ -606,7 +594,7 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, (uint) key_part->offset, (uint) key_part->length); #ifdef EXTRA_DEBUG - if (key_part->fieldnr > outparam->fields) + if (key_part->fieldnr > share->fields) goto err_not_open; // sanity check #endif if (key_part->fieldnr) @@ -654,8 +642,7 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, { if (outparam->file->index_flags(key, i, 0) & HA_KEYREAD_ONLY) { - outparam->read_only_keys.clear_bit(key); - outparam->keys_for_keyread.set_bit(key); + share->keys_for_keyread.set_bit(key); field->part_of_key.set_bit(key); } if (outparam->file->index_flags(key, i, 1) & HA_READ_ORDER) @@ -673,7 +660,7 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, the primary key, then we can use any key to find this column */ if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX) - field->part_of_key= outparam->keys_in_use; + field->part_of_key= share->keys_in_use; } if (field->key_length() != key_part->length) { @@ -701,16 +688,16 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, } keyinfo->usable_key_parts=usable_parts; // Filesort - set_if_bigger(outparam->max_key_length,keyinfo->key_length+ + set_if_bigger(share->max_key_length,keyinfo->key_length+ keyinfo->key_parts); - outparam->total_key_length+= keyinfo->key_length; + share->total_key_length+= keyinfo->key_length; if (keyinfo->flags & HA_NOSAME) - set_if_bigger(outparam->max_unique_length,keyinfo->key_length); + set_if_bigger(share->max_unique_length, keyinfo->key_length); } if (primary_key < MAX_KEY && - (outparam->keys_in_use.is_set(primary_key))) + (share->keys_in_use.is_set(primary_key))) { - outparam->primary_key=primary_key; + share->primary_key= primary_key; /* If we are using an integer as the primary key then allow the user to refer to it as '_rowid' @@ -723,27 +710,25 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, } } else - outparam->primary_key = MAX_KEY; // we do not have a primary key + share->primary_key = MAX_KEY; // we do not have a primary key } else - outparam->primary_key= MAX_KEY; + share->primary_key= MAX_KEY; x_free((gptr) disk_buff); disk_buff=0; if (new_field_pack_flag <= 1) - { /* Old file format with default null */ - uint null_length=(outparam->null_fields+7)/8; - bfill(outparam->null_flags,null_length,255); - bfill(outparam->null_flags+outparam->rec_buff_length,null_length,255); - if (records > 2) - bfill(outparam->null_flags+outparam->rec_buff_length*2,null_length,255); + { + /* Old file format with default as not null */ + uint null_length= (share->null_fields+7)/8; + bfill(share->default_values + (outparam->null_flags - (uchar*) record), + null_length, 255); } - if ((reg_field=outparam->found_next_number_field)) { - if ((int) (outparam->next_number_index= (uint) + if ((int) (share->next_number_index= (uint) find_ref_key(outparam,reg_field, - &outparam->next_number_key_offset)) < 0) + &share->next_number_key_offset)) < 0) { reg_field->unireg_check=Field::NONE; /* purecov: inspected */ outparam->found_next_number_field=0; @@ -752,26 +737,22 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, reg_field->flags|=AUTO_INCREMENT_FLAG; } - if (outparam->blob_fields) + if (share->blob_fields) { Field **ptr; - Field_blob **save; + uint i, *save; - if (!(outparam->blob_field=save= - (Field_blob**) alloc_root(&outparam->mem_root, - (uint) (outparam->blob_fields+1)* - sizeof(Field_blob*)))) + /* Store offsets to blob fields to find them fast */ + if (!(share->blob_field= save= + (uint*) alloc_root(&outparam->mem_root, + (uint) (share->blob_fields* sizeof(uint))))) goto err_not_open; - for (ptr=outparam->field ; *ptr ; ptr++) + for (i=0, ptr= outparam->field ; *ptr ; ptr++, i++) { if ((*ptr)->flags & BLOB_FLAG) - (*save++)= (Field_blob*) *ptr; + (*save++)= i; } - *save=0; // End marker } - else - outparam->blob_field= - (Field_blob**) (outparam->field+outparam->fields); // Point at null ptr /* The table struct is now initialized; Open the table */ error=2; @@ -791,11 +772,11 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags)))) { /* Set a flag if the table is crashed and it can be auto. repaired */ - outparam->crashed=((err == HA_ERR_CRASHED_ON_USAGE) && - outparam->file->auto_repair() && - !(ha_open_flags & HA_OPEN_FOR_REPAIR)); + share->crashed= ((err == HA_ERR_CRASHED_ON_USAGE) && + outparam->file->auto_repair() && + !(ha_open_flags & HA_OPEN_FOR_REPAIR)); - if (err==HA_ERR_NO_SUCH_TABLE) + if (err == HA_ERR_NO_SUCH_TABLE) { /* The table did not exists in storage engine, use same error message as if the .frm file didn't exist */ @@ -810,27 +791,29 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, goto err_not_open; /* purecov: inspected */ } } - outparam->db_low_byte_first=outparam->file->low_byte_first(); + share->db_low_byte_first= outparam->file->low_byte_first(); *root_ptr= old_root; thd->status_var.opened_tables++; #ifndef DBUG_OFF if (use_hash) - (void) hash_check(&outparam->name_hash); + (void) hash_check(&share->name_hash); #endif DBUG_RETURN (0); err_w_init: - /* Avoid problem with uninitialized data */ + /* + Avoid problem with uninitialized data + Note that we don't have to initialize outparam->s here becasue + the caller will check if the pointer exists in case of errors + */ bzero((char*) outparam,sizeof(*outparam)); - outparam->real_name= (char*)name+dirname_length(name); err_not_open: x_free((gptr) disk_buff); if (file > 0) VOID(my_close(file,MYF(MY_WME))); - err_end: /* Here when no file */ delete crypted; *root_ptr= old_root; if (! error_reported) @@ -838,9 +821,9 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat, delete outparam->file; outparam->file=0; // For easier errorchecking outparam->db_stat=0; - hash_free(&outparam->name_hash); - free_root(&outparam->mem_root,MYF(0)); - my_free(outparam->table_name,MYF(MY_ALLOW_ZERO_PTR)); + hash_free(&share->name_hash); + free_root(&share->mem_root, MYF(0)); + my_free((char*) outparam->alias, MYF(MY_ALLOW_ZERO_PTR)); DBUG_RETURN (error); } /* openfrm */ @@ -853,21 +836,18 @@ int closefrm(register TABLE *table) DBUG_ENTER("closefrm"); if (table->db_stat) error=table->file->close(); - if (table->table_name) - { - my_free(table->table_name,MYF(0)); - table->table_name=0; - } - if (table->fields) + my_free((char*) table->alias, MYF(MY_ALLOW_ZERO_PTR)); + table->alias= 0; + if (table->field) { for (Field **ptr=table->field ; *ptr ; ptr++) delete *ptr; - table->fields=0; + table->field= 0; } delete table->file; - table->file=0; /* For easier errorchecking */ - hash_free(&table->name_hash); - free_root(&table->mem_root,MYF(0)); + table->file= 0; /* For easier errorchecking */ + hash_free(&table->s->name_hash); + free_root(&table->mem_root, MYF(0)); DBUG_RETURN(error); } @@ -876,8 +856,11 @@ int closefrm(register TABLE *table) void free_blobs(register TABLE *table) { - for (Field_blob **ptr=table->blob_field ; *ptr ; ptr++) - (*ptr)->free(); + uint *ptr, *end; + for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ; + ptr != end ; + ptr++) + ((Field_blob*) table->field[*ptr])->free(); } @@ -1025,6 +1008,7 @@ static void frm_error(int error, TABLE *form, const char *name, int err_no; char buff[FN_REFLEN]; const char *form_dev="",*datext; + const char *real_name= (char*) name+dirname_length(name); DBUG_ENTER("frm_error"); switch (error) { @@ -1035,7 +1019,7 @@ static void frm_error(int error, TABLE *form, const char *name, uint length=dirname_part(buff,name); buff[length-1]=0; db=buff+dirname_length(buff); - my_error(ER_NO_SUCH_TABLE, MYF(0), db, form->real_name); + my_error(ER_NO_SUCH_TABLE, MYF(0), db, real_name); } else my_error(ER_FILE_NOT_FOUND, errortype, @@ -1048,7 +1032,7 @@ static void frm_error(int error, TABLE *form, const char *name, err_no= (my_errno == ENOENT) ? ER_FILE_NOT_FOUND : (my_errno == EAGAIN) ? ER_FILE_USED : ER_CANT_OPEN_FILE; my_error(err_no,errortype, - fn_format(buff,form->real_name,form_dev,datext,2),my_errno); + fn_format(buff,real_name,form_dev,datext,2),my_errno); break; } case 5: @@ -1062,7 +1046,7 @@ static void frm_error(int error, TABLE *form, const char *name, } my_printf_error(ER_UNKNOWN_COLLATION, "Unknown collation '%s' in table '%-.64s' definition", - MYF(0), csname, form->real_name); + MYF(0), csname, real_name); break; } default: /* Better wrong error than none */ @@ -1139,22 +1123,27 @@ TYPELIB *typelib(List &strings) } - /* - ** Search after a field with given start & length - ** If an exact field isn't found, return longest field with starts - ** at right position. - ** Return 0 on error, else field number+1 - ** This is needed because in some .frm fields 'fieldnr' was saved wrong - */ +/* + Search after a field with given start & length + If an exact field isn't found, return longest field with starts + at right position. + + NOTES + This is needed because in some .frm fields 'fieldnr' was saved wrong + + RETURN + 0 error + # field number +1 +*/ static uint find_field(TABLE *form,uint start,uint length) { Field **field; - uint i,pos; + uint i, pos, fields; pos=0; - - for (field=form->field, i=1 ; i<= form->fields ; i++,field++) + fields= form->s->fields; + for (field=form->field, i=1 ; i<= fields ; i++,field++) { if ((*field)->offset() == start) { @@ -1322,17 +1311,20 @@ File create_frm(register my_string name, uint reclength, uchar *fileinfo, void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table) { + TABLE_SHARE *share= table->s; DBUG_ENTER("update_create_info_from_table"); - create_info->max_rows=table->max_rows; - create_info->min_rows=table->min_rows; - create_info->table_options=table->db_create_options; - create_info->avg_row_length=table->avg_row_length; - create_info->row_type=table->row_type; - create_info->raid_type=table->raid_type; - create_info->raid_chunks=table->raid_chunks; - create_info->raid_chunksize=table->raid_chunksize; - create_info->default_table_charset=table->table_charset; + + create_info->max_rows= share->max_rows; + create_info->min_rows= share->min_rows; + create_info->table_options= share->db_create_options; + create_info->avg_row_length= share->avg_row_length; + create_info->row_type= share->row_type; + create_info->raid_type= share->raid_type; + create_info->raid_chunks= share->raid_chunks; + create_info->raid_chunksize= share->raid_chunksize; + create_info->default_table_charset= share->table_charset; create_info->table_charset= 0; + DBUG_VOID_RETURN; } @@ -2012,7 +2004,7 @@ bool st_table_list::set_insert_values(MEM_ROOT *mem_root) { if (!table->insert_values && !(table->insert_values= (byte *)alloc_root(mem_root, - table->rec_buff_length))) + table->s->rec_buff_length))) return TRUE; } else diff --git a/sql/table.h b/sql/table.h index 391b4908f96..2eca4e49a10 100644 --- a/sql/table.h +++ b/sql/table.h @@ -38,7 +38,7 @@ typedef struct st_order { bool counter_used; /* parameter was counter of columns */ Field *field; /* If tmp-table group */ char *buff; /* If tmp-table group */ - table_map used,depend_map; + table_map used, depend_map; } ORDER; typedef struct st_grant_info @@ -80,48 +80,118 @@ enum timestamp_auto_set_type TIMESTAMP_AUTO_SET_ON_UPDATE= 2, TIMESTAMP_AUTO_SET_ON_BOTH= 3 }; -/* Table cache entry struct */ - class Field_timestamp; class Field_blob; class Table_triggers_list; -struct st_table { - handler *file; - Field **field; /* Pointer to fields */ - Field_blob **blob_field; /* Pointer to blob fields */ +/* This structure is shared between different table objects */ + +typedef struct st_table_share +{ /* hash of field names (contains pointers to elements of field array) */ - HASH name_hash; - byte *record[2]; /* Pointer to records */ - byte *default_values; /* Default values for INSERT */ - byte *insert_values; /* used by INSERT ... UPDATE */ - uint fields; /* field count */ - uint reclength; /* Recordlength */ - uint rec_buff_length; - uint keys,key_parts,primary_key,max_key_length,max_unique_length; - uint total_key_length; - uint uniques; - uint null_fields; /* number of null fields */ - uint blob_fields; /* number of blob fields */ - key_map keys_in_use, keys_for_keyread, read_only_keys; - key_map quick_keys, used_keys, keys_in_use_for_query; - KEY *key_info; /* data of keys in database */ + HASH name_hash; /* hash of field names */ + MEM_ROOT mem_root; TYPELIB keynames; /* Pointers to keynames */ - ha_rows max_rows; /* create information */ - ha_rows min_rows; /* create information */ - ulong avg_row_length; /* create information */ - ulong raid_chunksize; TYPELIB fieldnames; /* Pointer to fieldnames */ TYPELIB *intervals; /* pointer to interval info */ +#ifdef NOT_YET + pthread_mutex_t mutex; /* For locking the share */ + pthread_cond_t cond; /* To signal that share is ready */ + struct st_table *open_tables; /* link to open tables */ + struct st_table *used_next, /* Link to used tables */ + **used_prev; + /* The following is copied to each TABLE on OPEN */ + Field **field; + KEY *key_info; /* data of keys in database */ +#endif + uint *blob_field; /* Index to blobs in Field arrray*/ + byte *default_values; /* row with default values */ + char *comment; /* Comment about table */ + CHARSET_INFO *table_charset; /* Default charset of string fields */ + + /* A pair "database_name\0table_name\0", widely used as simply a db name */ + char *table_cache_key; + const char *db; /* Pointer to db */ + const char *table_name; /* Table name (for open) */ + const char *path; /* Path to .frm file (from datadir) */ + key_map keys_in_use; /* Keys in use for table */ + key_map keys_for_keyread; + ulong avg_row_length; /* create information */ + ulong raid_chunksize; + ulong version, flush_version; + ulong timestamp_offset; /* Set to offset+1 of record */ + ulong reclength; /* Recordlength */ + + ha_rows min_rows, max_rows; /* create information */ enum db_type db_type; /* table_type for handler */ enum row_type row_type; /* How rows are stored */ + enum tmp_table_type tmp_table; + + uint blob_ptr_size; /* 4 or 8 */ + uint null_bytes; + uint key_length; /* Length of table_cache_key */ + uint fields; /* Number of fields */ + uint rec_buff_length; /* Size of table->record[] buffer */ + uint keys, key_parts; + uint max_key_length, max_unique_length, total_key_length; + uint uniques; /* Number of UNIQUE index */ + uint null_fields; /* number of null fields */ + uint blob_fields; /* number of blob fields */ uint db_create_options; /* Create options from database */ uint db_options_in_use; /* Options in use */ uint db_record_offset; /* if HA_REC_IN_SEQ */ - uint db_stat; /* mode of file as in handler.h */ - uint raid_type,raid_chunks; - uint status; /* Used by postfix.. */ - uint system; /* Set if system record */ + uint raid_type, raid_chunks; + uint open_count; /* Number of tables in open list */ + /* Index of auto-updated TIMESTAMP field in field array */ + uint primary_key; + uint timestamp_field_offset; + uint next_number_index; + uint next_number_key_offset; + uchar frm_version; + my_bool system; /* Set if system record */ + my_bool crypted; /* If .frm file is crypted */ + my_bool db_low_byte_first; /* Portable row format */ + my_bool crashed; + my_bool is_view; + my_bool name_lock, replace_with_name_lock; +} TABLE_SHARE; + + +/* Information for one open table */ + +struct st_table { + TABLE_SHARE *s; + handler *file; +#ifdef NOT_YET + struct st_table *used_next, **used_prev; /* Link to used tables */ + struct st_table *open_next, **open_prev; /* Link to open tables */ +#endif + struct st_table *next, *prev; + + THD *in_use; /* Which thread uses this */ + Field **field; /* Pointer to fields */ + + byte *record[2]; /* Pointer to records */ + byte *insert_values; /* used by INSERT ... UPDATE */ + key_map quick_keys, used_keys, keys_in_use_for_query; + KEY *key_info; /* data of keys in database */ + + Field *next_number_field, /* Set if next_number is activated */ + *found_next_number_field, /* Set on open */ + *rowid_field; + Field_timestamp *timestamp_field; + + /* Table's triggers, 0 if there are no of them */ + Table_triggers_list *triggers; + struct st_table_list *pos_in_table_list;/* Element referring to this table */ + ORDER *group; + const char *alias; /* alias or table name */ + uchar *null_flags; + ulong query_id; + + ha_rows quick_rows[MAX_KEY]; + key_part_map const_key_parts[MAX_KEY]; + uint quick_key_parts[MAX_KEY]; /* If this table has TIMESTAMP field with auto-set property (pointed by @@ -136,14 +206,15 @@ struct st_table { as example). */ timestamp_auto_set_type timestamp_field_type; - /* Index of auto-updated TIMESTAMP field in field array */ - uint timestamp_field_offset; + table_map map; /* ID bit of table (1,2,4,8,16...) */ - uint next_number_index; - uint blob_ptr_size; /* 4 or 8 */ - uint next_number_key_offset; - int current_lock; /* Type of lock on table */ - enum tmp_table_type tmp_table; + uint tablenr,used_fields; + uint temp_pool_slot; /* Used by intern temp tables */ + uint status; /* What's in record[0] */ + uint db_stat; /* mode of file as in handler.h */ + /* number of select if it is derived table */ + uint derived_select_number; + int current_lock; /* Type of lock on table */ my_bool copy_blobs; /* copy_blobs when storing */ /* Used in outer joins: if true, all columns are considered to have NULL @@ -155,60 +226,22 @@ struct st_table { my_bool maybe_null; /* true if (outer_join != 0) */ my_bool force_index; my_bool distinct,const_table,no_rows; - my_bool key_read; - my_bool crypted; - my_bool db_low_byte_first; /* Portable row format */ + my_bool key_read, no_keyread; my_bool locked_by_flush; my_bool locked_by_name; my_bool fulltext_searched; - my_bool crashed; - my_bool is_view; - my_bool no_keyread, no_cache; - my_bool clear_query_id; /* To reset query_id for tables and cols */ + my_bool no_cache; + /* To signal that we should reset query_id for tables and cols */ + my_bool clear_query_id; my_bool auto_increment_field_not_null; my_bool insert_or_update; /* Can be used by the handler */ my_bool alias_name_used; /* true if table_name is alias */ - Field *next_number_field, /* Set if next_number is activated */ - *found_next_number_field, /* Set on open */ - *rowid_field; - Field_timestamp *timestamp_field; -#if MYSQL_VERSION_ID < 40100 - /* - Indicates whenever we have to set field_length members of all TIMESTAMP - fields to 19 (to honour 'new_mode' variable) or to original - field_length values. - */ - my_bool timestamp_mode; -#endif - my_string comment; /* Comment about table */ - CHARSET_INFO *table_charset; /* Default charset of string fields */ + REGINFO reginfo; /* field connections */ MEM_ROOT mem_root; GRANT_INFO grant; - /* Table's triggers, 0 if there are no of them */ - Table_triggers_list *triggers; - - /* A pair "database_name\0table_name\0", widely used as simply a db name */ - char *table_cache_key; - char *table_name,*real_name,*path; - uint key_length; /* Length of key */ - uint tablenr,used_fields,null_bytes; - table_map map; /* ID bit of table (1,2,4,8,16...) */ - ulong version,flush_version; - uchar *null_flags; FILESORT_INFO sort; - ORDER *group; - ha_rows quick_rows[MAX_KEY]; - uint quick_key_parts[MAX_KEY]; - key_part_map const_key_parts[MAX_KEY]; - ulong query_id; - uchar frm_version; - uint temp_pool_slot; /* Used by intern temp tables */ - struct st_table_list *pos_in_table_list;/* Element referring to this table */ - /* number of select if it is derived table */ - uint derived_select_number; - THD *in_use; /* Which thread uses this */ - struct st_table *next,*prev; + TABLE_SHARE share_not_to_be_used; /* To be deleted when true shares */ }; @@ -243,6 +276,7 @@ typedef struct st_field_info const char* old_name; } ST_FIELD_INFO; + struct st_table_list; typedef class Item COND; @@ -283,19 +317,21 @@ typedef struct st_schema_table struct st_lex; class select_union; + struct Field_translator { Item *item; const char *name; }; + typedef struct st_table_list { /* link in a local table list (used by SQL_LIST) */ struct st_table_list *next_local; /* link in a global list of all queries tables */ struct st_table_list *next_global, **prev_global; - char *db, *alias, *real_name, *schema_table_name; + char *db, *alias, *table_name, *schema_table_name; char *option; /* Used by cache index */ Item *on_expr; /* Used with outer join */ COND_EQUAL *cond_equal; /* Used with outer join */ @@ -353,7 +389,7 @@ typedef struct st_table_list thr_lock_type lock_type; uint outer_join; /* Which join type */ uint shared; /* Used in multi-upd */ - uint32 db_length, real_name_length; + uint32 db_length, table_name_length; bool updatable; /* VIEW/TABLE can be updated now */ bool straight; /* optimize with prev table */ bool updating; /* for replicate-do/ignore table */ @@ -431,6 +467,7 @@ public: Field *field() { return 0; } }; + typedef struct st_nested_join { List join_list; /* list of elements in the nested join */ @@ -440,6 +477,7 @@ typedef struct st_nested_join uint counter; /* to count tables in the nested join */ } NESTED_JOIN; + typedef struct st_changed_table_list { struct st_changed_table_list *next; @@ -447,6 +485,7 @@ typedef struct st_changed_table_list uint32 key_length; } CHANGED_TABLE_LIST; + typedef struct st_open_table_list{ struct st_open_table_list *next; char *db,*table; diff --git a/sql/tztime.cc b/sql/tztime.cc index dc38580f3b6..b9b9e4821c4 100644 --- a/sql/tztime.cc +++ b/sql/tztime.cc @@ -1416,10 +1416,10 @@ static void tz_init_table_list(TABLE_LIST *tz_tabs, TABLE_LIST ***global_next_ptr) { bzero(tz_tabs, sizeof(TABLE_LIST) * 4); - tz_tabs[0].alias= tz_tabs[0].real_name= (char*)"time_zone_name"; - tz_tabs[1].alias= tz_tabs[1].real_name= (char*)"time_zone"; - tz_tabs[2].alias= tz_tabs[2].real_name= (char*)"time_zone_transition_type"; - tz_tabs[3].alias= tz_tabs[3].real_name= (char*)"time_zone_transition"; + tz_tabs[0].alias= tz_tabs[0].table_name= (char*)"time_zone_name"; + tz_tabs[1].alias= tz_tabs[1].table_name= (char*)"time_zone"; + tz_tabs[2].alias= tz_tabs[2].table_name= (char*)"time_zone_transition_type"; + tz_tabs[3].alias= tz_tabs[3].table_name= (char*)"time_zone_transition"; tz_tabs[0].next_global= tz_tabs[0].next_local= tz_tabs+1; tz_tabs[1].next_global= tz_tabs[1].next_local= tz_tabs+2; tz_tabs[2].next_global= tz_tabs[2].next_local= tz_tabs+3; @@ -1582,7 +1582,7 @@ my_tz_init(THD *org_thd, const char *default_tzname, my_bool bootstrap) thd->db= my_strdup("mysql",MYF(0)); thd->db_length= 5; // Safety bzero((char*) &tables_buff, sizeof(TABLE_LIST)); - tables_buff[0].alias= tables_buff[0].real_name= + tables_buff[0].alias= tables_buff[0].table_name= (char*)"time_zone_leap_second"; tables_buff[0].lock_type= TL_READ; tables_buff[0].db= thd->db; diff --git a/sql/unireg.cc b/sql/unireg.cc index ee036ed113d..dd94098fbf3 100644 --- a/sql/unireg.cc +++ b/sql/unireg.cc @@ -656,6 +656,7 @@ static bool make_empty_rec(File file,enum db_type table_type, /* We need a table to generate columns for default values */ bzero((char*) &table,sizeof(table)); + table.s= &table.share_not_to_be_used; handler= get_new_handler((TABLE*) 0, table_type); if (!handler || @@ -666,8 +667,8 @@ static bool make_empty_rec(File file,enum db_type table_type, } table.in_use= current_thd; - table.db_low_byte_first= handler->low_byte_first(); - table.blob_ptr_size=portable_sizeof_char_ptr; + table.s->db_low_byte_first= handler->low_byte_first(); + table.s->blob_ptr_size= portable_sizeof_char_ptr; firstpos=reclength; null_count=0; diff --git a/sql/unireg.h b/sql/unireg.h index 053ca393ad0..eca540b61b9 100644 --- a/sql/unireg.h +++ b/sql/unireg.h @@ -121,12 +121,12 @@ #define SPECIAL_LOG_QUERIES_NOT_USING_INDEXES 4096 /* Log q not using indexes */ /* Extern defines */ -#define store_record(A,B) bmove_align((A)->B,(A)->record[0],(size_t) (A)->reclength) -#define restore_record(A,B) bmove_align((A)->record[0],(A)->B,(size_t) (A)->reclength) -#define cmp_record(A,B) memcmp((A)->record[0],(A)->B,(size_t) (A)->reclength) +#define store_record(A,B) bmove_align((A)->B,(A)->record[0],(size_t) (A)->s->reclength) +#define restore_record(A,B) bmove_align((A)->record[0],(A)->B,(size_t) (A)->s->reclength) +#define cmp_record(A,B) memcmp((A)->record[0],(A)->B,(size_t) (A)->s->reclength) #define empty_record(A) { \ - restore_record((A),default_values); \ - bfill((A)->null_flags,(A)->null_bytes,255);\ + restore_record((A),s->default_values); \ + bfill((A)->null_flags,(A)->s->null_bytes,255);\ } /* Defines for use with openfrm, openprt and openfrd */ From 57099ef6c6f14fa3e6b912f1f8884b9b5feb7c54 Mon Sep 17 00:00:00 2001 From: "lenz@mysql.com" <> Date: Thu, 6 Jan 2005 14:35:14 +0100 Subject: [PATCH 21/31] - enable "with-extra-charsets=complex" for the "compile-dist" distribution build (to make the test suite pass) --- BUILD/compile-dist | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/BUILD/compile-dist b/BUILD/compile-dist index 2344d4dfffd..ef6302f0d9c 100755 --- a/BUILD/compile-dist +++ b/BUILD/compile-dist @@ -42,5 +42,6 @@ fi --with-embedded-server \ --with-berkeley-db \ --with-innodb \ - --enable-thread-safe-client + --enable-thread-safe-client \ + --with-extra-charsets=complex make From 7f73e8b81bd58208c86f3f8c5ad647ba0ec4358b Mon Sep 17 00:00:00 2001 From: "joerg@mysql.com" <> Date: Thu, 6 Jan 2005 15:09:33 +0100 Subject: [PATCH 22/31] Ensure that a 'bool' function really returns a value - was compiler error on some problems causing build failure. --- sql/sql_prepare.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 3afe810321e..f7ca9b4d665 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -1445,7 +1445,7 @@ static bool mysql_insert_select_prepare_tester(THD *thd) and item_list belong to SELECT */ first_select->resolve_mode= SELECT_LEX::SELECT_MODE; - mysql_insert_select_prepare(thd); + return mysql_insert_select_prepare(thd); } From ef74d8d89880fe5c76971f5cc22a11184445f6d6 Mon Sep 17 00:00:00 2001 From: "monty@mysql.com" <> Date: Thu, 6 Jan 2005 16:59:29 +0200 Subject: [PATCH 23/31] Fixed a bug in prepared statements error handling After merge fixes --- libmysql/libmysql.c | 7 ++++--- mysql-test/r/delayed.result | 3 +++ mysql-test/t/delayed.test | 4 +++- sql/sql_base.cc | 6 ++++-- sql/sql_prepare.cc | 4 ++-- 5 files changed, 16 insertions(+), 8 deletions(-) diff --git a/libmysql/libmysql.c b/libmysql/libmysql.c index 209dcf5756a..29c6f469098 100644 --- a/libmysql/libmysql.c +++ b/libmysql/libmysql.c @@ -1864,12 +1864,13 @@ void set_stmt_errmsg(MYSQL_STMT * stmt, const char *err, int errcode, my_bool cli_read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt) { uchar *pos; - uint field_count, param_count, packet_length; + uint field_count, param_count; + ulong packet_length; MYSQL_DATA *fields_data; - DBUG_ENTER("read_prepare_result"); + DBUG_ENTER("cli_read_prepare_result"); mysql= mysql->last_used_con; - if ((packet_length=net_safe_read(mysql)) == packet_error) + if ((packet_length= net_safe_read(mysql)) == packet_error) DBUG_RETURN(1); mysql->warning_count= 0; diff --git a/mysql-test/r/delayed.result b/mysql-test/r/delayed.result index ceb511a7891..e9766622cf6 100644 --- a/mysql-test/r/delayed.result +++ b/mysql-test/r/delayed.result @@ -22,6 +22,9 @@ insert delayed into t1 values (null,"c"); insert delayed into t1 values (3,"d"),(null,"e"); insert delayed into t1 values (3,"this will give an","error"); ERROR 21S01: Column count doesn't match value count at row 1 +show status like 'not_flushed_delayed_rows'; +Variable_name Value +Not_flushed_delayed_rows 0 select * from t1; a b 1 b diff --git a/mysql-test/t/delayed.test b/mysql-test/t/delayed.test index 40bd7a912f3..513de990165 100644 --- a/mysql-test/t/delayed.test +++ b/mysql-test/t/delayed.test @@ -31,6 +31,8 @@ insert delayed into t1 values (null,"c"); insert delayed into t1 values (3,"d"),(null,"e"); --error 1136 insert delayed into t1 values (3,"this will give an","error"); ---sleep 2 +# 2 was not enough for --ps-protocol +--sleep 4 +show status like 'not_flushed_delayed_rows'; select * from t1; drop table t1; diff --git a/sql/sql_base.cc b/sql/sql_base.cc index f915fc68bd9..405d95bf456 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -2323,8 +2323,10 @@ find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *tables, bool found_table=0; for (; tables; tables= tables->next_local) { + /* TODO; Ensure that db and tables->db always points to something ! */ if (!my_strcasecmp(table_alias_charset, tables->alias, table_name) && - (!db || !tables->db || !tables->db[0] || !strcmp(db,tables->db))) + (!db || !db[0] || !tables->db || !tables->db[0] || + !strcmp(db,tables->db))) { found_table=1; Field *find= find_field_in_table(thd, tables, name, item->name, @@ -3039,7 +3041,7 @@ insert_fields(THD *thd, TABLE_LIST *tables, const char *db_name, iterator= &view_iter; view= 1; alias_used= my_strcasecmp(table_alias_charset, - tables->real_name, tables->alias); + tables->table_name, tables->alias); } else { diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc index 3afe810321e..6364d5ae039 100644 --- a/sql/sql_prepare.cc +++ b/sql/sql_prepare.cc @@ -935,7 +935,7 @@ static bool mysql_test_insert(Prepared_statement *stmt, { my_error(ER_ILLEGAL_HA, MYF(0), (table_list->view ? table_list->view_name.str : - table_list->real_name)); + table_list->table_name)); goto error; } while ((values= its++)) @@ -1445,7 +1445,7 @@ static bool mysql_insert_select_prepare_tester(THD *thd) and item_list belong to SELECT */ first_select->resolve_mode= SELECT_LEX::SELECT_MODE; - mysql_insert_select_prepare(thd); + return mysql_insert_select_prepare(thd); } From 421738e8ce0382c4d72f36766765c3e49a74d72f Mon Sep 17 00:00:00 2001 From: "bell@sanja.is.com.ua" <> Date: Thu, 6 Jan 2005 17:08:38 +0200 Subject: [PATCH 24/31] removed unused label --- sql/sql_parse.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index 55d26a68116..cd8e73c446d 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -2429,7 +2429,6 @@ mysql_execute_command(THD *thd) create_table_local); break; -create_error: res= 1; //error reported unsent_create_error: // put tables back for PS rexecuting From 779c33a5e7c3f3513db09ad330eb6469d32efc23 Mon Sep 17 00:00:00 2001 From: "bell@sanja.is.com.ua" <> Date: Thu, 6 Jan 2005 19:13:58 +0200 Subject: [PATCH 25/31] fixed comparation with string constant on some platform (BUG#7651) --- client/mysqldump.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/client/mysqldump.c b/client/mysqldump.c index 98de9e0b069..da409d44cd1 100644 --- a/client/mysqldump.c +++ b/client/mysqldump.c @@ -106,7 +106,14 @@ FILE *md_result_file; static char *shared_memory_base_name=0; #endif static uint opt_protocol= 0; -static char *default_charset= (char*) MYSQL_UNIVERSAL_CLIENT_CHARSET; +/* + Constant for detection default value of default_charset (if + default_charset equal to mysql_universal_client_charset, then it is + default value which assigned in very beginning on main()) +*/ +const static char *mysql_universal_client_charset= + MYSQL_UNIVERSAL_CLIENT_CHARSET; +static char *default_charset; static CHARSET_INFO *charset_info= &my_charset_latin1; const char *default_dbug_option="d:t:o,/tmp/mysqldump.trace"; @@ -678,7 +685,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)), Set charset to the default compiled value if it hasn't been reset yet by --default-character-set=xxx. */ - if (default_charset == (char*) MYSQL_UNIVERSAL_CLIENT_CHARSET) + if (default_charset == mysql_universal_client_charset) default_charset= (char*) MYSQL_DEFAULT_CHARSET_NAME; break; } @@ -2403,6 +2410,7 @@ cleanup: int main(int argc, char **argv) { compatible_mode_normal_str[0]= 0; + default_charset= (char *)mysql_universal_client_charset; MY_INIT(argv[0]); if (get_options(&argc, &argv)) From d944dc9a782aa6eb2a66d3e98d3df6c97d56b407 Mon Sep 17 00:00:00 2001 From: "bell@sanja.is.com.ua" <> Date: Thu, 6 Jan 2005 20:47:08 +0200 Subject: [PATCH 26/31] postreview changes --- client/mysqldump.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/client/mysqldump.c b/client/mysqldump.c index da409d44cd1..d511dc3bbde 100644 --- a/client/mysqldump.c +++ b/client/mysqldump.c @@ -107,11 +107,11 @@ static char *shared_memory_base_name=0; #endif static uint opt_protocol= 0; /* - Constant for detection default value of default_charset (if - default_charset equal to mysql_universal_client_charset, then it is - default value which assigned in very beginning on main()) + Constant for detection of default value of default_charset. + If default_charset is equal to mysql_universal_client_charset, then + it is the default value which assigned at the very beginning of main(). */ -const static char *mysql_universal_client_charset= +static const char *mysql_universal_client_charset= MYSQL_UNIVERSAL_CLIENT_CHARSET; static char *default_charset; static CHARSET_INFO *charset_info= &my_charset_latin1; From 2acb7387842baec2b3171afe7de08e1a52d7e8ce Mon Sep 17 00:00:00 2001 From: "jimw@mysql.com" <> Date: Thu, 6 Jan 2005 19:57:02 +0100 Subject: [PATCH 27/31] Add comment to make code for option-stripping in mysql_config more clear --- scripts/mysql_config.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/mysql_config.sh b/scripts/mysql_config.sh index 35ddbcac471..3676e03ab48 100644 --- a/scripts/mysql_config.sh +++ b/scripts/mysql_config.sh @@ -100,6 +100,8 @@ for remove in DDBUG_OFF DSAFEMALLOC USAFEMALLOC DSAFE_MUTEX \ DPEDANTIC_SAFEMALLOC DUNIV_MUST_NOT_INLINE DFORCE_INIT_OF_VARS \ DEXTRA_DEBUG DHAVE_purify 'O[0-9]' 'W[-A-Za-z]*' do + # The first option we might strip will always have a space before it because + # we set -I$pkgincludedir as the first option cflags=`echo "$cflags"|sed -e "s/ -$remove */ /g"` done cflags=`echo "$cflags"|sed -e 's/ *\$//'` From b8a1b9a4380724c6f76102fb468d599b1947067a Mon Sep 17 00:00:00 2001 From: "tulin@build.mysql.com" <> Date: Thu, 6 Jan 2005 21:01:32 +0100 Subject: [PATCH 28/31] main.cpp: correcting 4.1 merge error --- ndb/src/mgmsrv/main.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/ndb/src/mgmsrv/main.cpp b/ndb/src/mgmsrv/main.cpp index 4a8b79d3ddc..a638b85426e 100644 --- a/ndb/src/mgmsrv/main.cpp +++ b/ndb/src/mgmsrv/main.cpp @@ -155,6 +155,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)), "Tcp connections will now be used instead\n"); opt_ndb_shm= 0; #endif + break; case '?': usage(); exit(0); From 75f282df27ed728d2d4ef318e14ec108561e3289 Mon Sep 17 00:00:00 2001 From: "brian@zim.(none)" <> Date: Thu, 6 Jan 2005 16:31:18 -0800 Subject: [PATCH 29/31] Fix for compiling error in sql_parse --- BitKeeper/etc/logging_ok | 1 + sql/sql_parse.cc | 9 +++++---- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/BitKeeper/etc/logging_ok b/BitKeeper/etc/logging_ok index 40db2499a81..71088830ed7 100644 --- a/BitKeeper/etc/logging_ok +++ b/BitKeeper/etc/logging_ok @@ -34,6 +34,7 @@ bk@mysql.r18.ru brian@avenger.(none) brian@brian-akers-computer.local brian@private-client-ip-101.oz.net +brian@zim.(none) carsten@tsort.bitbybit.dk cps@silver_beast.(none) davida@isil.mysql.com diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index af62a81450a..4b484500527 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -2564,7 +2564,7 @@ mysql_execute_command(THD *thd) TABLE_LIST *select_tables= lex->query_tables; if ((res= create_table_precheck(thd, select_tables, create_table))) - goto create_error; + goto unsent_create_error; #ifndef HAVE_READLINK lex->create_info.data_file_name=lex->create_info.index_file_name=0; @@ -2574,7 +2574,7 @@ mysql_execute_command(THD *thd) create_table->table_name) || append_file_to_dir(thd, &lex->create_info.index_file_name, create_table->table_name)) - goto create_error; + goto unsent_create_error; #endif /* If we are using SET CHARSET without DEFAULT, add an implicit @@ -2606,7 +2606,7 @@ mysql_execute_command(THD *thd) unique_table(create_table, select_tables)) { my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table->table_name); - goto create_error; + goto unsent_create_error; } /* If we create merge table, we have to test tables in merge, too */ if (lex->create_info.used_fields & HA_CREATE_USED_UNION) @@ -2619,7 +2619,7 @@ mysql_execute_command(THD *thd) if (unique_table(tab, select_tables)) { my_error(ER_UPDATE_TABLE_USED, MYF(0), tab->table_name); - goto create_error; + goto unsent_create_error; } } } @@ -2666,6 +2666,7 @@ mysql_execute_command(THD *thd) break; /* put tables back for PS rexecuting */ +unsent_create_error: lex->link_first_table_back(create_table, link_to_local); goto error; } From 2ee9d854b4acc34f4b686c79b2d7eea9b2caf9aa Mon Sep 17 00:00:00 2001 From: "brian@zim.(none)" <> Date: Thu, 6 Jan 2005 18:34:17 -0800 Subject: [PATCH 30/31] Updates for Monty's changes in the table structure. All tests pass currently. Seems like such a short commit message... --- sql/examples/ha_archive.cc | 44 ++++++++++++++++++++++---------------- sql/examples/ha_tina.cc | 2 +- 2 files changed, 26 insertions(+), 20 deletions(-) diff --git a/sql/examples/ha_archive.cc b/sql/examples/ha_archive.cc index f79ca903e7a..f04853fd482 100644 --- a/sql/examples/ha_archive.cc +++ b/sql/examples/ha_archive.cc @@ -520,7 +520,7 @@ error: int ha_archive::write_row(byte * buf) { z_off_t written; - Field_blob **field; + uint *ptr, *end; DBUG_ENTER("ha_archive::write_row"); if (share->crashed) @@ -530,25 +530,27 @@ int ha_archive::write_row(byte * buf) if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT) table->timestamp_field->set_time(); pthread_mutex_lock(&share->mutex); - written= gzwrite(share->archive_write, buf, table->reclength); - DBUG_PRINT("ha_archive::write_row", ("Wrote %d bytes expected %d", written, table->reclength)); + written= gzwrite(share->archive_write, buf, table->s->reclength); + DBUG_PRINT("ha_archive::write_row", ("Wrote %d bytes expected %d", written, table->s->reclength)); if (!delayed_insert || !bulk_insert) share->dirty= TRUE; - if (written != table->reclength) + if (written != table->s->reclength) goto error; /* We should probably mark the table as damagaged if the record is written but the blob fails. */ - for (field= table->blob_field ; *field ; field++) + for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ; + ptr != end ; + ptr++) { char *ptr; - uint32 size= (*field)->get_length(); + uint32 size= ((Field_blob*) table->field[*ptr])->get_length(); if (size) { - (*field)->get_ptr(&ptr); + ((Field_blob*) table->field[*ptr])->get_ptr(&ptr); written= gzwrite(share->archive_write, ptr, (unsigned)size); if (written != size) goto error; @@ -614,13 +616,13 @@ int ha_archive::rnd_init(bool scan) int ha_archive::get_row(gzFile file_to_read, byte *buf) { int read; // Bytes read, gzread() returns int + uint *ptr, *end; char *last; size_t total_blob_length= 0; - Field_blob **field; DBUG_ENTER("ha_archive::get_row"); - read= gzread(file_to_read, buf, table->reclength); - DBUG_PRINT("ha_archive::get_row", ("Read %d bytes expected %d", read, table->reclength)); + read= gzread(file_to_read, buf, table->s->reclength); + DBUG_PRINT("ha_archive::get_row", ("Read %d bytes expected %d", read, table->s->reclength)); if (read == Z_STREAM_ERROR) DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE); @@ -633,27 +635,31 @@ int ha_archive::get_row(gzFile file_to_read, byte *buf) If the record is the wrong size, the file is probably damaged, unless we are dealing with a delayed insert or a bulk insert. */ - if ((ulong) read != table->reclength) + if ((ulong) read != table->s->reclength) DBUG_RETURN(HA_ERR_END_OF_FILE); /* Calculate blob length, we use this for our buffer */ - for (field=table->blob_field; *field ; field++) - total_blob_length += (*field)->get_length(); + for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ; + ptr != end ; + ptr++) + total_blob_length += ((Field_blob*) table->field[*ptr])->get_length(); /* Adjust our row buffer if we need be */ buffer.alloc(total_blob_length); last= (char *)buffer.ptr(); /* Loop through our blobs and read them */ - for (field=table->blob_field; *field ; field++) + for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ; + ptr != end ; + ptr++) { - size_t size= (*field)->get_length(); + size_t size= ((Field_blob*) table->field[*ptr])->get_length(); if (size) { read= gzread(file_to_read, last, size); if ((size_t) read != size) DBUG_RETURN(HA_ERR_END_OF_FILE); - (*field)->set_ptr(size, last); + ((Field_blob*) table->field[*ptr])->set_ptr(size, last); last += size; } } @@ -753,8 +759,8 @@ int ha_archive::repair(THD* thd, HA_CHECK_OPT* check_opt) I know, this malloc'ing memory but this should be a very rare event. */ - if (!(buf= (byte*) my_malloc(table->rec_buff_length > sizeof(ulonglong) +1 ? - table->rec_buff_length : sizeof(ulonglong) +1 , + if (!(buf= (byte*) my_malloc(table->s->rec_buff_length > sizeof(ulonglong) +1 ? + table->s->rec_buff_length : sizeof(ulonglong) +1 , MYF(MY_WME)))) { rc= HA_ERR_CRASHED_ON_USAGE; @@ -894,7 +900,7 @@ void ha_archive::info(uint flag) VOID(my_stat(share->data_file_name, &file_stat, MYF(MY_WME))); - mean_rec_length= table->reclength + buffer.alloced_length(); + mean_rec_length= table->s->reclength + buffer.alloced_length(); data_file_length= file_stat.st_size; create_time= file_stat.st_ctime; update_time= file_stat.st_mtime; diff --git a/sql/examples/ha_tina.cc b/sql/examples/ha_tina.cc index 39573a8f54c..46a22614566 100644 --- a/sql/examples/ha_tina.cc +++ b/sql/examples/ha_tina.cc @@ -375,7 +375,7 @@ int ha_tina::find_current_row(byte *buf) } next_position= (end_ptr - share->mapped_file)+1; /* Maybe use \N for null? */ - memset(buf, 0, table->null_bytes); /* We do not implement nulls! */ + memset(buf, 0, table->s->null_bytes); /* We do not implement nulls! */ DBUG_RETURN(0); } From 3be57f961b894ddd742310d0b21efdf5cebd2201 Mon Sep 17 00:00:00 2001 From: "brian@zim.(none)" <> Date: Thu, 6 Jan 2005 19:37:16 -0800 Subject: [PATCH 31/31] This just fixes the compile issues for table structure changes. The test case does not currently work (I am comitting this so that Patrick will have a working copy). I am going to look at the test case next. It is suspected that it is failing do to a change in mysql_test_run. --- sql/ha_federated.cc | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/sql/ha_federated.cc b/sql/ha_federated.cc index d4405e3e719..abd33f2eaef 100755 --- a/sql/ha_federated.cc +++ b/sql/ha_federated.cc @@ -370,7 +370,7 @@ static byte* federated_get_key(FEDERATED_SHARE *share,uint *length, } /* - Parse connection info from table->comment + Parse connection info from table->s->comment SYNOPSIS parse_url() @@ -412,7 +412,7 @@ static int parse_url(FEDERATED_SHARE *share, TABLE *table, uint table_create_fla share->port= 0; uint error_num= table_create_flag ? ER_CANT_CREATE_TABLE : ER_CONNECT_TO_MASTER ; - share->scheme= my_strdup(table->comment, MYF(0)); + share->scheme= my_strdup(table->s->comment, MYF(0)); if (share->username= strstr(share->scheme, "://")) @@ -569,7 +569,7 @@ uint ha_federated::convert_row_to_internal_format(byte *record, MYSQL_ROW row) DBUG_ENTER("ha_federated::convert_row_to_internal_format"); // Question this - memset(record, 0, table->null_bytes); + memset(record, 0, table->s->null_bytes); for (Field **field=table->field; *field ; field++, x++) { @@ -742,8 +742,6 @@ int load_conn_info(FEDERATED_SHARE *share, TABLE *table) static FEDERATED_SHARE *get_share(const char *table_name, TABLE *table) { FEDERATED_SHARE *share; - // FIX : need to redo - //String query; char query_buffer[IO_SIZE]; String query(query_buffer, sizeof(query_buffer), &my_charset_bin); query.length(0); @@ -753,7 +751,7 @@ static FEDERATED_SHARE *get_share(const char *table_name, TABLE *table) // share->table_name has the file location - we want the actual table's // name! - table_base_name= table->table_name; + table_base_name= (char *)table->s->table_name; DBUG_PRINT("ha_federated::get_share",("table_name %s", table_base_name)); /* So why does this exist? There is no way currently to init a storage engine. @@ -1160,9 +1158,9 @@ int ha_federated::update_row( DBUG_ENTER("ha_federated::update_row"); - has_a_primary_key= table->primary_key == 0 ? 1 : 0; + has_a_primary_key= table->s->primary_key == 0 ? 1 : 0; primary_key_field_num= has_a_primary_key ? - table->key_info[table->primary_key].key_part->fieldnr -1 : -1; + table->key_info[table->s->primary_key].key_part->fieldnr -1 : -1; if (has_a_primary_key) DBUG_PRINT("ha_federated::update_row", ("has a primary key")); @@ -1243,7 +1241,7 @@ int ha_federated::update_row( update_string.append(new_field_value); new_field_value.length(0); - if (x+1 < table->fields) + if (x+1 < table->s->fields) { update_string.append(", "); if (! has_a_primary_key) @@ -1319,7 +1317,7 @@ int ha_federated::delete_row(const byte * buf) delete_string.append(data_string); data_string.length(0); - if (x+1 < table->fields) + if (x+1 < table->s->fields) delete_string.append(" AND "); } @@ -1422,7 +1420,7 @@ int ha_federated::index_init(uint keynr) int error; DBUG_ENTER("ha_federated::index_init"); DBUG_PRINT("ha_federated::index_init", - ("table: '%s' key: %d", table->real_name, keynr)); + ("table: '%s' key: %d", table->s->table_name, keynr)); active_index= keynr; DBUG_RETURN(0); }