From 629557ff13e28e3422dfa1c354c44ef2fd62e4d0 Mon Sep 17 00:00:00 2001 From: Georgi Kodinov Date: Thu, 3 Sep 2009 18:03:46 +0300 Subject: [PATCH 01/13] Bug #46791: Assertion failed:(table->key_read==0),function unknown function,file sql_base.cc When uncacheable queries are written to a temp table the optimizer must preserve the original JOIN structure, because it is re-using the JOIN structure to read from the resulting temporary table. This was done only for uncacheable sub-queries. But top level queries can also benefit from this mechanism, specially if they're using index access and need a reset. Fixed by not limiting the saving of JOIN structure to subqueries exclusively. Added a new test file to extend the existing (large) subquery.test. --- mysql-test/r/subselect4.result | 30 ++++++++++++++++++++++++++++++ mysql-test/t/subselect4.test | 32 ++++++++++++++++++++++++++++++++ sql/sql_select.cc | 8 ++------ 3 files changed, 64 insertions(+), 6 deletions(-) create mode 100644 mysql-test/r/subselect4.result create mode 100644 mysql-test/t/subselect4.test diff --git a/mysql-test/r/subselect4.result b/mysql-test/r/subselect4.result new file mode 100644 index 00000000000..68577cb2a4c --- /dev/null +++ b/mysql-test/r/subselect4.result @@ -0,0 +1,30 @@ +# +# Bug #46791: Assertion failed:(table->key_read==0),function unknown +# function,file sql_base.cc +# +CREATE TABLE t1 (a INT, b INT, KEY(a)); +INSERT INTO t1 VALUES (1,1),(2,2); +CREATE TABLE t2 LIKE t1; +INSERT INTO t2 VALUES (1,1),(2,2); +CREATE TABLE t3 LIKE t1; +# should have 1 impossible where and 2 dependent subqueries +EXPLAIN +SELECT 1 FROM t1 +WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE 1 = (SELECT MIN(t2.b) FROM t3)) +ORDER BY count(*); +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY t1 index NULL a 5 NULL 2 Using index; Using temporary +2 DEPENDENT SUBQUERY t2 ALL NULL NULL NULL NULL 2 Using where +3 DEPENDENT SUBQUERY NULL NULL NULL NULL NULL NULL NULL no matching row in const table +# should not crash the next statement +SELECT 1 FROM t1 +WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE 1 = (SELECT MIN(t2.b) FROM t3)) +ORDER BY count(*); +1 +1 +# should not crash: the crash is caused by the previous statement +SELECT 1; +1 +1 +DROP TABLE t1,t2,t3; +End of 5.0 tests. diff --git a/mysql-test/t/subselect4.test b/mysql-test/t/subselect4.test new file mode 100644 index 00000000000..ff4cdf3c439 --- /dev/null +++ b/mysql-test/t/subselect4.test @@ -0,0 +1,32 @@ +# General purpose bug fix tests go here : subselect.test too large + + +--echo # +--echo # Bug #46791: Assertion failed:(table->key_read==0),function unknown +--echo # function,file sql_base.cc +--echo # + +CREATE TABLE t1 (a INT, b INT, KEY(a)); +INSERT INTO t1 VALUES (1,1),(2,2); +CREATE TABLE t2 LIKE t1; +INSERT INTO t2 VALUES (1,1),(2,2); +CREATE TABLE t3 LIKE t1; + +--echo # should have 1 impossible where and 2 dependent subqueries +EXPLAIN +SELECT 1 FROM t1 +WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE 1 = (SELECT MIN(t2.b) FROM t3)) +ORDER BY count(*); + +--echo # should not crash the next statement +SELECT 1 FROM t1 +WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE 1 = (SELECT MIN(t2.b) FROM t3)) +ORDER BY count(*); + +--echo # should not crash: the crash is caused by the previous statement +SELECT 1; + +DROP TABLE t1,t2,t3; + + +--echo End of 5.0 tests. diff --git a/sql/sql_select.cc b/sql/sql_select.cc index b670e6e3637..9d5e67c9532 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -1474,12 +1474,8 @@ JOIN::optimize() } } - /* - If this join belongs to an uncacheable subquery save - the original join - */ - if (select_lex->uncacheable && !is_top_level_join() && - init_save_join_tab()) + /* If this join belongs to an uncacheable query save the original join */ + if (select_lex->uncacheable && init_save_join_tab()) DBUG_RETURN(-1); /* purecov: inspected */ } From 540b2dc0041c292220d389bbb5b87a8410aef3f4 Mon Sep 17 00:00:00 2001 From: Ingo Struewing Date: Mon, 7 Sep 2009 18:35:37 +0200 Subject: [PATCH 02/13] Bug#17332 - changing key_buffer_size on a running server can crash under load Backport from 5.1. Does also include key cache fixes from: Bug 44068 (RESTORE can disable the MyISAM Key Cache) Bug 40944 (Backup: crash after myisampack) include/keycache.h: Bug#17332 - changing key_buffer_size on a running server can crash under load Added KEY_CACHE components in_resize and waiting_for_resize_cnt. myisam/mi_preload.c: Bug#17332 - changing key_buffer_size on a running server can crash under load Added code to allow LOAD INDEX to load indexes of different block size. mysys/mf_keycache.c: Bug#17332 - changing key_buffer_size on a running server can crash under load . Changed resize_key_cache() to not disable the key cache after the flush phase. Changed queue handling to use standard functions. Wake all threads waiting on resize_queue. We can now have read/write threads waiting there (see below). . Combined add_to_queue() and the wait loops that were always following it to the new function wait_on_queue(). Combined release_queue() and the condition that was always preceding it to the new function release_whole_queue(). . Added code to flag and respect the exceptional situation BLOCK_IN_EVICTION. . Rewrote the resize branch of find_key_block(). . Added code to the eviction handling in find_key_block() to catch more exceptional cases. . Changed key_cache_read(), key_cache_insert() and key_cache_write() so that they lock keycache->cache_lock whenever the key cache is initialized. Checking for a disabled cache and incrementing and decrementing the "resize counter" is always done within the lock. Locking and unlocking as well as counting the "resize counter" is now done once outside the loop. All three functions can now handle a NULL return from find_key_block. This happens in the flush phase of a resize and demands direct file I/O. Care is taken for secondary requests (PAGE_WAIT_TO_BE_READ) to wait in any case. Moved block status changes behind the copying of buffer data. key_cache_insert() does now read the block if the caller did supply less data than a full cache block. key_cache_write() does now take care of parallel running flushes (BLOCK_FOR_UPDATE, BLOCK_IN_FLUSHWRITE). . Changed free_block() to un-initialize block variables in the correct order and respect an exceptional BLOCK_IN_EVICTION state. . Changed flushing to take care for parallel running writes. Changed flushing to avoid freeing blocks in eviction. Changed flushing to consider that parallel writes can move blocks from the file_blocks hash to the changed_blocks hash. Changed flushing to take care for other parallel flushes. Changed flushing to assure that it ends with everything flushed. Optimized normal flush at end of statement (FLUSH_KEEP), but let other flush types be stringent. . Added some comments and debugging statements. mysys/my_static.c: Bug#17332 - changing key_buffer_size on a running server can crash under load Removed an unused global variable. sql/ha_myisam.cc: Bug#17332 - changing key_buffer_size on a running server can crash under load Moved an automatic (stack) variable to the scope where it is used. sql/sql_table.cc: Bug#17332 - changing key_buffer_size on a running server can crash under load Changed TL_READ to TL_READ_NO_INSERT in mysql_preload_keys. --- include/keycache.h | 6 + myisam/mi_preload.c | 13 +- mysys/mf_keycache.c | 2687 +++++++++++++++++++++++++++++++++++-------- mysys/my_static.c | 3 - sql/ha_myisam.cc | 2 +- sql/sql_table.cc | 7 +- 6 files changed, 2210 insertions(+), 508 deletions(-) diff --git a/include/keycache.h b/include/keycache.h index 424b4086cb4..b2e959955d0 100644 --- a/include/keycache.h +++ b/include/keycache.h @@ -44,6 +44,7 @@ typedef struct st_keycache_wqueue typedef struct st_key_cache { my_bool key_cache_inited; + my_bool in_resize; /* true during resize operation */ my_bool resize_in_flush; /* true during flush of resize operation */ my_bool can_be_used; /* usage of cache for read/write is allowed */ size_t key_cache_mem_size; /* specified size of the cache memory */ @@ -71,6 +72,11 @@ typedef struct st_key_cache BLOCK_LINK *used_ins; /* ptr to the insertion block in LRU chain */ pthread_mutex_t cache_lock; /* to lock access to the cache structure */ KEYCACHE_WQUEUE resize_queue; /* threads waiting during resize operation */ + /* + Waiting for a zero resize count. Using a queue for symmetry though + only one thread can wait here. + */ + KEYCACHE_WQUEUE waiting_for_resize_cnt; KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link */ KEYCACHE_WQUEUE waiting_for_block; /* requests waiting for a free block */ BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/ diff --git a/myisam/mi_preload.c b/myisam/mi_preload.c index 78729f18424..06c66c06bf4 100644 --- a/myisam/mi_preload.c +++ b/myisam/mi_preload.c @@ -55,12 +55,17 @@ int mi_preload(MI_INFO *info, ulonglong key_map, my_bool ignore_leaves) block_length= keyinfo[0].block_length; - /* Check whether all indexes use the same block size */ - for (i= 1 ; i < keys ; i++) + if (ignore_leaves) { - if (keyinfo[i].block_length != block_length) - DBUG_RETURN(my_errno= HA_ERR_NON_UNIQUE_BLOCK_SIZE); + /* Check whether all indexes use the same block size */ + for (i= 1 ; i < keys ; i++) + { + if (keyinfo[i].block_length != block_length) + DBUG_RETURN(my_errno= HA_ERR_NON_UNIQUE_BLOCK_SIZE); + } } + else + block_length= share->key_cache->key_cache_block_size; length= info->preload_buff_size/block_length * block_length; set_if_bigger(length, block_length); diff --git a/mysys/mf_keycache.c b/mysys/mf_keycache.c index 0720d172317..f9898e263aa 100644 --- a/mysys/mf_keycache.c +++ b/mysys/mf_keycache.c @@ -13,7 +13,8 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/* +/** + @file These functions handle keyblock cacheing for ISAM and MyISAM tables. One cache can handle many files. @@ -38,7 +39,73 @@ as such gives the maximum number of in-use blocks at any time. */ +/* + Key Cache Locking + ================= + + All key cache locking is done with a single mutex per key cache: + keycache->cache_lock. This mutex is locked almost all the time + when executing code in this file (mf_keycache.c). + However it is released for I/O and some copy operations. + + The cache_lock is also released when waiting for some event. Waiting + and signalling is done via condition variables. In most cases the + thread waits on its thread->suspend condition variable. Every thread + has a my_thread_var structure, which contains this variable and a + '*next' and '**prev' pointer. These pointers are used to insert the + thread into a wait queue. + + A thread can wait for one block and thus be in one wait queue at a + time only. + + Before starting to wait on its condition variable with + pthread_cond_wait(), the thread enters itself to a specific wait queue + with link_into_queue() (double linked with '*next' + '**prev') or + wait_on_queue() (single linked with '*next'). + + Another thread, when releasing a resource, looks up the waiting thread + in the related wait queue. It sends a signal with + pthread_cond_signal() to the waiting thread. + + NOTE: Depending on the particular wait situation, either the sending + thread removes the waiting thread from the wait queue with + unlink_from_queue() or release_whole_queue() respectively, or the waiting + thread removes itself. + + There is one exception from this locking scheme when one thread wants + to reuse a block for some other address. This works by first marking + the block reserved (status= BLOCK_IN_SWITCH) and then waiting for all + threads that are reading the block to finish. Each block has a + reference to a condition variable (condvar). It holds a reference to + the thread->suspend condition variable for the waiting thread (if such + a thread exists). When that thread is signaled, the reference is + cleared. The number of readers of a block is registered in + block->hash_link->requests. See wait_for_readers() / remove_reader() + for details. This is similar to the above, but it clearly means that + only one thread can wait for a particular block. There is no queue in + this case. Strangely enough block->convar is used for waiting for the + assigned hash_link only. More precisely it is used to wait for all + requests to be unregistered from the assigned hash_link. + + The resize_queue serves two purposes: + 1. Threads that want to do a resize wait there if in_resize is set. + This is not used in the server. The server refuses a second resize + request if one is already active. keycache->in_init is used for the + synchronization. See set_var.cc. + 2. Threads that want to access blocks during resize wait here during + the re-initialization phase. + When the resize is done, all threads on the queue are signalled. + Hypothetical resizers can compete for resizing, and read/write + requests will restart to request blocks from the freshly resized + cache. If the cache has been resized too small, it is disabled and + 'can_be_used' is false. In this case read/write requests bypass the + cache. Since they increment and decrement 'cnt_for_resize_op', the + next resizer can wait on the queue 'waiting_for_resize_cnt' until all + I/O finished. +*/ + #include "mysys_priv.h" +#include "mysys_err.h" #include #include "my_static.h" #include @@ -119,12 +186,16 @@ struct st_hash_link }; /* simple states of a block */ -#define BLOCK_ERROR 1 /* an error occured when performing disk i/o */ -#define BLOCK_READ 2 /* the is page in the block buffer */ -#define BLOCK_IN_SWITCH 4 /* block is preparing to read new page */ -#define BLOCK_REASSIGNED 8 /* block does not accept requests for old page */ -#define BLOCK_IN_FLUSH 16 /* block is in flush operation */ -#define BLOCK_CHANGED 32 /* block buffer contains a dirty page */ +#define BLOCK_ERROR 1 /* an error occured when performing file i/o */ +#define BLOCK_READ 2 /* file block is in the block buffer */ +#define BLOCK_IN_SWITCH 4 /* block is preparing to read new page */ +#define BLOCK_REASSIGNED 8 /* blk does not accept requests for old page */ +#define BLOCK_IN_FLUSH 16 /* block is selected for flush */ +#define BLOCK_CHANGED 32 /* block buffer contains a dirty page */ +#define BLOCK_IN_USE 64 /* block is not free */ +#define BLOCK_IN_EVICTION 128 /* block is selected for eviction */ +#define BLOCK_IN_FLUSHWRITE 256 /* block is in write to file */ +#define BLOCK_FOR_UPDATE 512 /* block is selected for buffer modification */ /* page status, returned by find_key_block */ #define PAGE_READ 0 @@ -161,13 +232,15 @@ KEY_CACHE *dflt_key_cache= &dflt_key_cache_var; static int flush_all_key_blocks(KEY_CACHE *keycache); #ifdef THREAD -static void link_into_queue(KEYCACHE_WQUEUE *wqueue, - struct st_my_thread_var *thread); -static void unlink_from_queue(KEYCACHE_WQUEUE *wqueue, - struct st_my_thread_var *thread); +static void wait_on_queue(KEYCACHE_WQUEUE *wqueue, + pthread_mutex_t *mutex); +static void release_whole_queue(KEYCACHE_WQUEUE *wqueue); +#else +#define wait_on_queue(wqueue, mutex) do {} while (0) +#define release_whole_queue(wqueue) do {} while (0) #endif static void free_block(KEY_CACHE *keycache, BLOCK_LINK *block); -#ifndef DBUG_OFF +#if !defined(DBUG_OFF) static void test_key_cache(KEY_CACHE *keycache, const char *where, my_bool lock); #endif @@ -263,6 +336,16 @@ static int keycache_pthread_cond_signal(pthread_cond_t *cond); #define keycache_pthread_cond_signal pthread_cond_signal #endif /* defined(KEYCACHE_DEBUG) */ +#if !defined(DBUG_OFF) +#if defined(inline) +#undef inline +#endif +#define inline /* disabled inline for easier debugging */ +static int fail_block(BLOCK_LINK *block); +static int fail_hlink(HASH_LINK *hlink); +static int cache_empty(KEY_CACHE *keycache); +#endif + static uint next_power(uint value) { uint old_value= 1; @@ -323,6 +406,14 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, if (! keycache->key_cache_inited) { keycache->key_cache_inited= 1; + /* + Initialize these variables once only. + Their value must survive re-initialization during resizing. + */ + keycache->in_resize= 0; + keycache->resize_in_flush= 0; + keycache->cnt_for_resize_op= 0; + keycache->waiting_for_resize_cnt.last_thread= NULL; keycache->in_init= 0; pthread_mutex_init(&keycache->cache_lock, MY_MUTEX_INIT_FAST); keycache->resize_queue.last_thread= NULL; @@ -336,7 +427,7 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, blocks= (ulong) (use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) + sizeof(HASH_LINK*) * 5/4 + key_cache_block_size)); /* It doesn't make sense to have too few blocks (less than 8) */ - if (blocks >= 8 && keycache->disk_blocks < 0) + if (blocks >= 8) { for ( ; ; ) { @@ -356,8 +447,8 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, blocks--; /* Allocate memory for cache page buffers */ if ((keycache->block_mem= - my_large_malloc((size_t) blocks * keycache->key_cache_block_size, - MYF(MY_WME)))) + my_large_malloc((size_t) blocks * keycache->key_cache_block_size, + MYF(0)))) { /* Allocate memory for blocks, hash_links and hash entries; @@ -372,6 +463,7 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, if (blocks < 8) { my_errno= ENOMEM; + my_error(EE_OUTOFMEMORY, MYF(0), blocks * keycache->key_cache_block_size); goto err; } blocks= blocks / 4*3; @@ -410,8 +502,6 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, blocks * age_threshold / 100 : blocks); - keycache->cnt_for_resize_op= 0; - keycache->resize_in_flush= 0; keycache->can_be_used= 1; keycache->waiting_for_hash_link.last_thread= NULL; @@ -427,6 +517,11 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, bzero((gptr) keycache->file_blocks, sizeof(keycache->file_blocks[0]) * CHANGED_BLOCKS_HASH); } + else + { + /* key_buffer_size is specified too small. Disable the cache. */ + keycache->can_be_used= 0; + } keycache->blocks= keycache->disk_blocks > 0 ? keycache->disk_blocks : 0; DBUG_RETURN((int) keycache->disk_blocks); @@ -485,8 +580,6 @@ int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, uint age_threshold) { int blocks; - struct st_my_thread_var *thread; - KEYCACHE_WQUEUE *wqueue; DBUG_ENTER("resize_key_cache"); if (!keycache->key_cache_inited) @@ -502,54 +595,86 @@ int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size, keycache_pthread_mutex_lock(&keycache->cache_lock); #ifdef THREAD - wqueue= &keycache->resize_queue; - thread= my_thread_var; - link_into_queue(wqueue, thread); - - while (wqueue->last_thread->next != thread) + /* + We may need to wait for another thread which is doing a resize + already. This cannot happen in the MySQL server though. It allows + one resizer only. In set_var.cc keycache->in_init is used to block + multiple attempts. + */ + while (keycache->in_resize) { - keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock); + /* purecov: begin inspected */ + wait_on_queue(&keycache->resize_queue, &keycache->cache_lock); + /* purecov: end */ } #endif - keycache->resize_in_flush= 1; - if (flush_all_key_blocks(keycache)) + /* + Mark the operation in progress. This blocks other threads from doing + a resize in parallel. It prohibits new blocks to enter the cache. + Read/write requests can bypass the cache during the flush phase. + */ + keycache->in_resize= 1; + + /* Need to flush only if keycache is enabled. */ + if (keycache->can_be_used) { - /* TODO: if this happens, we should write a warning in the log file ! */ + /* Start the flush phase. */ + keycache->resize_in_flush= 1; + + if (flush_all_key_blocks(keycache)) + { + /* TODO: if this happens, we should write a warning in the log file ! */ + keycache->resize_in_flush= 0; + blocks= 0; + keycache->can_be_used= 0; + goto finish; + } + DBUG_ASSERT(cache_empty(keycache)); + + /* End the flush phase. */ keycache->resize_in_flush= 0; - blocks= 0; - keycache->can_be_used= 0; - goto finish; } - keycache->resize_in_flush= 0; - keycache->can_be_used= 0; + #ifdef THREAD + /* + Some direct read/write operations (bypassing the cache) may still be + unfinished. Wait until they are done. If the key cache can be used, + direct I/O is done in increments of key_cache_block_size. That is, + every block is checked if it is in the cache. We need to wait for + pending I/O before re-initializing the cache, because we may change + the block size. Otherwise they could check for blocks at file + positions where the new block division has none. We do also want to + wait for I/O done when (if) the cache was disabled. It must not + run in parallel with normal cache operation. + */ while (keycache->cnt_for_resize_op) - { - KEYCACHE_DBUG_PRINT("resize_key_cache: wait", - ("suspend thread %ld", thread->id)); - keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock); - } + wait_on_queue(&keycache->waiting_for_resize_cnt, &keycache->cache_lock); #else KEYCACHE_DBUG_ASSERT(keycache->cnt_for_resize_op == 0); #endif + /* + Free old cache structures, allocate new structures, and initialize + them. Note that the cache_lock mutex and the resize_queue are left + untouched. We do not lose the cache_lock and will release it only at + the end of this function. + */ end_key_cache(keycache, 0); /* Don't free mutex */ /* The following will work even if use_mem is 0 */ blocks= init_key_cache(keycache, key_cache_block_size, use_mem, division_limit, age_threshold); finish: -#ifdef THREAD - unlink_from_queue(wqueue, thread); - /* Signal for the next resize request to proceeed if any */ - if (wqueue->last_thread) - { - KEYCACHE_DBUG_PRINT("resize_key_cache: signal", - ("thread %ld", wqueue->last_thread->next->id)); - keycache_pthread_cond_signal(&wqueue->last_thread->next->suspend); - } -#endif + /* + Mark the resize finished. This allows other threads to start a + resize or to request new cache blocks. + */ + keycache->in_resize= 0; + + /* Signal waiting threads. */ + release_whole_queue(&keycache->resize_queue); + keycache_pthread_mutex_unlock(&keycache->cache_lock); DBUG_RETURN(blocks); } @@ -570,18 +695,8 @@ static inline void inc_counter_for_resize_op(KEY_CACHE *keycache) */ static inline void dec_counter_for_resize_op(KEY_CACHE *keycache) { -#ifdef THREAD - struct st_my_thread_var *last_thread; - if (!--keycache->cnt_for_resize_op && - (last_thread= keycache->resize_queue.last_thread)) - { - KEYCACHE_DBUG_PRINT("dec_counter_for_resize_op: signal", - ("thread %ld", last_thread->next->id)); - keycache_pthread_cond_signal(&last_thread->next->suspend); - } -#else - keycache->cnt_for_resize_op--; -#endif + if (!--keycache->cnt_for_resize_op) + release_whole_queue(&keycache->waiting_for_resize_cnt); } /* @@ -661,6 +776,13 @@ void end_key_cache(KEY_CACHE *keycache, my_bool cleanup) (ulong) keycache->global_cache_r_requests, (ulong) keycache->global_cache_read)); + /* + Reset these values to be able to detect a disabled key cache. + See Bug#44068 (RESTORE can disable the MyISAM Key Cache). + */ + keycache->blocks_used= 0; + keycache->blocks_unused= 0; + if (cleanup) { pthread_mutex_destroy(&keycache->cache_lock); @@ -672,6 +794,7 @@ void end_key_cache(KEY_CACHE *keycache, my_bool cleanup) #ifdef THREAD + /* Link a thread into double-linked queue of waiting threads. @@ -693,6 +816,8 @@ static void link_into_queue(KEYCACHE_WQUEUE *wqueue, struct st_my_thread_var *thread) { struct st_my_thread_var *last; + + DBUG_ASSERT(!thread->next && !thread->prev); if (! (last= wqueue->last_thread)) { /* Queue is empty */ @@ -728,6 +853,7 @@ static void unlink_from_queue(KEYCACHE_WQUEUE *wqueue, struct st_my_thread_var *thread) { KEYCACHE_DBUG_PRINT("unlink_from_queue", ("thread %ld", thread->id)); + DBUG_ASSERT(thread->next && thread->prev); if (thread->next == thread) /* The queue contains only one member */ wqueue->last_thread= NULL; @@ -740,6 +866,13 @@ static void unlink_from_queue(KEYCACHE_WQUEUE *wqueue, thread->prev); } thread->next= NULL; +#if !defined(DBUG_OFF) + /* + This makes it easier to see it's not in a chain during debugging. + And some DBUG_ASSERT() rely on it. + */ + thread->prev= NULL; +#endif } @@ -747,9 +880,9 @@ static void unlink_from_queue(KEYCACHE_WQUEUE *wqueue, Add a thread to single-linked queue of waiting threads SYNOPSIS - add_to_queue() - wqueue pointer to the queue structure - thread pointer to the thread to be added to the queue + wait_on_queue() + wqueue Pointer to the queue structure. + mutex Cache_lock to acquire after awake. RETURN VALUE none @@ -758,12 +891,23 @@ static void unlink_from_queue(KEYCACHE_WQUEUE *wqueue, Queue is represented by a circular list of the thread structures The list is single-linked of the type (*next), accessed by a pointer to the last element. + + The function protects against stray signals by verifying that the + current thread is unlinked from the queue when awaking. However, + since several threads can wait for the same event, it might be + necessary for the caller of the function to check again if the + condition for awake is indeed matched. */ -static inline void add_to_queue(KEYCACHE_WQUEUE *wqueue, - struct st_my_thread_var *thread) +static void wait_on_queue(KEYCACHE_WQUEUE *wqueue, + pthread_mutex_t *mutex) { struct st_my_thread_var *last; + struct st_my_thread_var *thread= my_thread_var; + + /* Add to queue. */ + DBUG_ASSERT(!thread->next); + DBUG_ASSERT(!thread->prev); /* Not required, but must be true anyway. */ if (! (last= wqueue->last_thread)) thread->next= thread; else @@ -772,6 +916,17 @@ static inline void add_to_queue(KEYCACHE_WQUEUE *wqueue, last->next= thread; } wqueue->last_thread= thread; + + /* + Wait until thread is removed from queue by the signalling thread. + The loop protects against stray signals. + */ + do + { + KEYCACHE_DBUG_PRINT("wait", ("suspend thread %ld", thread->id)); + keycache_pthread_cond_wait(&thread->suspend, mutex); + } + while (thread->next); } @@ -779,36 +934,47 @@ static inline void add_to_queue(KEYCACHE_WQUEUE *wqueue, Remove all threads from queue signaling them to proceed SYNOPSIS - realease_queue() - wqueue pointer to the queue structure - thread pointer to the thread to be added to the queue + release_whole_queue() + wqueue pointer to the queue structure RETURN VALUE none NOTES. - See notes for add_to_queue + See notes for wait_on_queue(). When removed from the queue each thread is signaled via condition variable thread->suspend. */ -static void release_queue(KEYCACHE_WQUEUE *wqueue) +static void release_whole_queue(KEYCACHE_WQUEUE *wqueue) { - struct st_my_thread_var *last= wqueue->last_thread; - struct st_my_thread_var *next= last->next; + struct st_my_thread_var *last; + struct st_my_thread_var *next; struct st_my_thread_var *thread; + + /* Queue may be empty. */ + if (!(last= wqueue->last_thread)) + return; + + next= last->next; do { thread=next; - KEYCACHE_DBUG_PRINT("release_queue: signal", ("thread %ld", thread->id)); + KEYCACHE_DBUG_PRINT("release_whole_queue: signal", + ("thread %ld", thread->id)); + /* Signal the thread. */ keycache_pthread_cond_signal(&thread->suspend); + /* Take thread from queue. */ next=thread->next; thread->next= NULL; } while (thread != last); + + /* Now queue is definitely empty. */ wqueue->last_thread= NULL; } -#endif + +#endif /* THREAD */ /* @@ -817,9 +983,19 @@ static void release_queue(KEYCACHE_WQUEUE *wqueue) static inline void unlink_changed(BLOCK_LINK *block) { + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); if (block->next_changed) block->next_changed->prev_changed= block->prev_changed; *block->prev_changed= block->next_changed; + +#if !defined(DBUG_OFF) + /* + This makes it easier to see it's not in a chain during debugging. + And some DBUG_ASSERT() rely on it. + */ + block->next_changed= NULL; + block->prev_changed= NULL; +#endif } @@ -829,6 +1005,8 @@ static inline void unlink_changed(BLOCK_LINK *block) static inline void link_changed(BLOCK_LINK *block, BLOCK_LINK **phead) { + DBUG_ASSERT(!block->next_changed); + DBUG_ASSERT(!block->prev_changed); block->prev_changed= phead; if ((block->next_changed= *phead)) (*phead)->prev_changed= &block->next_changed; @@ -837,14 +1015,37 @@ static inline void link_changed(BLOCK_LINK *block, BLOCK_LINK **phead) /* - Unlink a block from the chain of dirty/clean blocks, if it's asked for, - and link it to the chain of clean blocks for the specified file + Link a block in a chain of clean blocks of a file. + + SYNOPSIS + link_to_file_list() + keycache Key cache handle + block Block to relink + file File to be linked to + unlink If to unlink first + + DESCRIPTION + Unlink a block from whichever chain it is linked in, if it's + asked for, and link it to the chain of clean blocks of the + specified file. + + NOTE + Please do never set/clear BLOCK_CHANGED outside of + link_to_file_list() or link_to_changed_list(). + You would risk to damage correct counting of changed blocks + and to find blocks in the wrong hash. + + RETURN + void */ static void link_to_file_list(KEY_CACHE *keycache, BLOCK_LINK *block, int file, my_bool unlink_block) { + DBUG_ASSERT(block->status & BLOCK_IN_USE); + DBUG_ASSERT(block->hash_link && block->hash_link->block == block); + DBUG_ASSERT(block->hash_link->file == file); if (unlink_block) unlink_changed(block); link_changed(block, &keycache->file_blocks[FILE_HASH(file)]); @@ -858,13 +1059,34 @@ static void link_to_file_list(KEY_CACHE *keycache, /* - Unlink a block from the chain of clean blocks for the specified - file and link it to the chain of dirty blocks for this file + Re-link a block from the clean chain to the dirty chain of a file. + + SYNOPSIS + link_to_changed_list() + keycache key cache handle + block block to relink + + DESCRIPTION + Unlink a block from the chain of clean blocks of a file + and link it to the chain of dirty blocks of the same file. + + NOTE + Please do never set/clear BLOCK_CHANGED outside of + link_to_file_list() or link_to_changed_list(). + You would risk to damage correct counting of changed blocks + and to find blocks in the wrong hash. + + RETURN + void */ -static inline void link_to_changed_list(KEY_CACHE *keycache, - BLOCK_LINK *block) +static void link_to_changed_list(KEY_CACHE *keycache, + BLOCK_LINK *block) { + DBUG_ASSERT(block->status & BLOCK_IN_USE); + DBUG_ASSERT(!(block->status & BLOCK_CHANGED)); + DBUG_ASSERT(block->hash_link && block->hash_link->block == block); + unlink_changed(block); link_changed(block, &keycache->changed_blocks[FILE_HASH(block->hash_link->file)]); @@ -889,13 +1111,13 @@ static inline void link_to_changed_list(KEY_CACHE *keycache, none NOTES. - The LRU chain is represented by a curcular list of block structures. + The LRU ring is represented by a circular list of block structures. The list is double-linked of the type (**prev,*next) type. - The LRU chain is divided into two parts - hot and warm. + The LRU ring is divided into two parts - hot and warm. There are two pointers to access the last blocks of these two parts. The beginning of the warm part follows right after the end of the hot part. - Only blocks of the warm part can be used for replacement. + Only blocks of the warm part can be used for eviction. The first block from the beginning of this subchain is always taken for eviction (keycache->last_used->next) @@ -908,6 +1130,9 @@ static inline void link_to_changed_list(KEY_CACHE *keycache, +----| beg |---->...----| end |----+ +------+ +------+ins first for eviction + + It is also possible that the block is selected for eviction and thus + not linked in the LRU ring. */ static void link_block(KEY_CACHE *keycache, BLOCK_LINK *block, my_bool hot, @@ -916,7 +1141,12 @@ static void link_block(KEY_CACHE *keycache, BLOCK_LINK *block, my_bool hot, BLOCK_LINK *ins; BLOCK_LINK **pins; - KEYCACHE_DBUG_ASSERT(! (block->hash_link && block->hash_link->requests)); + DBUG_ASSERT((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/ + DBUG_ASSERT(!block->requests); + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); + DBUG_ASSERT(!block->next_used); + DBUG_ASSERT(!block->prev_used); #ifdef THREAD if (!hot && keycache->waiting_for_block.last_thread) { @@ -945,6 +1175,29 @@ static void link_block(KEY_CACHE *keycache, BLOCK_LINK *block, my_bool hot, } while (thread != last_thread); hash_link->block= block; + /* + NOTE: We assigned the block to the hash_link and signalled the + requesting thread(s). But it is possible that other threads runs + first. These threads see the hash_link assigned to a block which + is assigned to another hash_link and not marked BLOCK_IN_SWITCH. + This can be a problem for functions that do not select the block + via its hash_link: flush and free. They do only see a block which + is in a "normal" state and don't know that it will be evicted soon. + + We cannot set BLOCK_IN_SWITCH here because only one of the + requesting threads must handle the eviction. All others must wait + for it to complete. If we set the flag here, the threads would not + know who is in charge of the eviction. Without the flag, the first + thread takes the stick and sets the flag. + + But we need to note in the block that is has been selected for + eviction. It must not be freed. The evicting thread will not + expect the block in the free list. Before freeing we could also + check if block->requests > 1. But I think including another flag + in the check of block->status is slightly more efficient and + probably easier to read. + */ + block->status|= BLOCK_IN_EVICTION; KEYCACHE_THREAD_TRACE("link_block: after signaling"); #if defined(KEYCACHE_DEBUG) KEYCACHE_DBUG_PRINT("link_block", @@ -971,7 +1224,7 @@ static void link_block(KEY_CACHE *keycache, BLOCK_LINK *block, my_bool hot, } else { - /* The LRU chain is empty */ + /* The LRU ring is empty. Let the block point to itself. */ keycache->used_last= keycache->used_ins= block->next_used= block; block->prev_used= &block->next_used; } @@ -1005,6 +1258,13 @@ static void link_block(KEY_CACHE *keycache, BLOCK_LINK *block, my_bool hot, static void unlink_block(KEY_CACHE *keycache, BLOCK_LINK *block) { + DBUG_ASSERT((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/ + DBUG_ASSERT(!block->requests); + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); + DBUG_ASSERT(block->next_used && block->prev_used && + (block->next_used->prev_used == &block->next_used) && + (*block->prev_used == block)); if (block->next_used == block) /* The list contains only one member */ keycache->used_last= keycache->used_ins= NULL; @@ -1018,26 +1278,48 @@ static void unlink_block(KEY_CACHE *keycache, BLOCK_LINK *block) keycache->used_ins=STRUCT_PTR(BLOCK_LINK, next_used, block->prev_used); } block->next_used= NULL; +#if !defined(DBUG_OFF) + /* + This makes it easier to see it's not in a chain during debugging. + And some DBUG_ASSERT() rely on it. + */ + block->prev_used= NULL; +#endif KEYCACHE_THREAD_TRACE("unlink_block"); #if defined(KEYCACHE_DEBUG) + KEYCACHE_DBUG_ASSERT(keycache->blocks_available != 0); keycache->blocks_available--; KEYCACHE_DBUG_PRINT("unlink_block", ("unlinked block %u status=%x #requests=%u #available=%u", BLOCK_NUMBER(block), block->status, block->requests, keycache->blocks_available)); - KEYCACHE_DBUG_ASSERT(keycache->blocks_available >= 0); #endif } /* - Register requests for a block + Register requests for a block. + + SYNOPSIS + reg_requests() + keycache Pointer to a key cache data structure. + block Pointer to the block to register a request on. + count Number of requests. Always 1. + + NOTE + The first request unlinks the block from the LRU ring. This means + that it is protected against eveiction. + + RETURN + void */ static void reg_requests(KEY_CACHE *keycache, BLOCK_LINK *block, int count) { - if (! block->requests) - /* First request for the block unlinks it */ + DBUG_ASSERT(block->status & BLOCK_IN_USE); + DBUG_ASSERT(block->hash_link); + + if (!block->requests) unlink_block(keycache, block); block->requests+=count; } @@ -1057,7 +1339,7 @@ static void reg_requests(KEY_CACHE *keycache, BLOCK_LINK *block, int count) none NOTES. - Every linking to the LRU chain decrements by one a special block + Every linking to the LRU ring decrements by one a special block counter (if it's positive). If the at_end parameter is TRUE the block is added either at the end of warm sub-chain or at the end of hot sub-chain. It is added to the hot subchain if its counter is zero and number of @@ -1070,12 +1352,25 @@ static void reg_requests(KEY_CACHE *keycache, BLOCK_LINK *block, int count) At the same time the block at the very beginning of the hot subchain might be moved to the beginning of the warm subchain if it stays untouched for a too long time (this time is determined by parameter age_threshold). + + It is also possible that the block is selected for eviction and thus + not linked in the LRU ring. */ static void unreg_request(KEY_CACHE *keycache, BLOCK_LINK *block, int at_end) { - if (! --block->requests) + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/ + DBUG_ASSERT(block->requests); + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); + DBUG_ASSERT(!block->next_used); + DBUG_ASSERT(!block->prev_used); + /* + Unregister the request, but do not link erroneous blocks into the + LRU ring. + */ + if (!--block->requests && !(block->status & BLOCK_ERROR)) { my_bool hot; if (block->hits_left) @@ -1093,9 +1388,22 @@ static void unreg_request(KEY_CACHE *keycache, link_block(keycache, block, hot, (my_bool)at_end); block->last_hit_time= keycache->keycache_time; keycache->keycache_time++; + /* + At this place, the block might be in the LRU ring or not. If an + evicter was waiting for a block, it was selected for eviction and + not linked in the LRU ring. + */ + /* + Check if we should link a hot block to the warm block sub-chain. + It is possible that we select the same block as above. But it can + also be another block. In any case a block from the LRU ring is + selected. In other words it works even if the above block was + selected for eviction and not linked in the LRU ring. Since this + happens only if the LRU ring is empty, the block selected below + would be NULL and the rest of the function skipped. + */ block= keycache->used_ins; - /* Check if we should link a hot block to the warm block */ if (block && keycache->keycache_time - block->last_hit_time > keycache->age_threshold) { @@ -1116,10 +1424,20 @@ static void unreg_request(KEY_CACHE *keycache, Remove a reader of the page in block */ -static inline void remove_reader(BLOCK_LINK *block) +static void remove_reader(BLOCK_LINK *block) { + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(block->hash_link && block->hash_link->block == block); + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); + DBUG_ASSERT(!block->next_used); + DBUG_ASSERT(!block->prev_used); + DBUG_ASSERT(block->hash_link->requests); +#ifdef THREAD if (! --block->hash_link->requests && block->condvar) keycache_pthread_cond_signal(block->condvar); +#else + --block->hash_link->requests; +#endif } @@ -1128,15 +1446,27 @@ static inline void remove_reader(BLOCK_LINK *block) signals on its termination */ -static inline void wait_for_readers(KEY_CACHE *keycache, BLOCK_LINK *block) +static void wait_for_readers(KEY_CACHE *keycache, + BLOCK_LINK *block) { #ifdef THREAD struct st_my_thread_var *thread= my_thread_var; + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(!(block->status & (BLOCK_IN_FLUSH | BLOCK_CHANGED))); + DBUG_ASSERT(block->hash_link); + DBUG_ASSERT(block->hash_link->block == block); + /* Linked in file_blocks or changed_blocks hash. */ + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); + /* Not linked in LRU ring. */ + DBUG_ASSERT(!block->next_used); + DBUG_ASSERT(!block->prev_used); while (block->hash_link->requests) { KEYCACHE_DBUG_PRINT("wait_for_readers: wait", ("suspend thread %ld block %u", thread->id, BLOCK_NUMBER(block))); + /* There must be no other waiter. We have no queue here. */ + DBUG_ASSERT(!block->condvar); block->condvar= &thread->suspend; keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock); block->condvar= NULL; @@ -1225,7 +1555,6 @@ static HASH_LINK *get_hash_link(KEY_CACHE *keycache, int file, my_off_t filepos) { reg1 HASH_LINK *hash_link, **start; - KEYCACHE_PAGE page; #if defined(KEYCACHE_DEBUG) int cnt; #endif @@ -1280,6 +1609,7 @@ restart: #ifdef THREAD /* Wait for a free hash link */ struct st_my_thread_var *thread= my_thread_var; + KEYCACHE_PAGE page; KEYCACHE_DBUG_PRINT("get_hash_link", ("waiting")); page.file= file; page.filepos= filepos; @@ -1365,77 +1695,308 @@ static BLOCK_LINK *find_key_block(KEY_CACHE *keycache, #endif restart: - /* Find the hash link for the requested page (file, filepos) */ + /* + If the flush phase of a resize operation fails, the cache is left + unusable. This will be detected only after "goto restart". + */ + if (!keycache->can_be_used) + DBUG_RETURN(0); + + /* + Find the hash_link for the requested file block (file, filepos). We + do always get a hash_link here. It has registered our request so + that no other thread can use it for another file block until we + release the request (which is done by remove_reader() usually). The + hash_link can have a block assigned to it or not. If there is a + block, it may be assigned to this hash_link or not. In cases where a + block is evicted from the cache, it is taken from the LRU ring and + referenced by the new hash_link. But the block can still be assigned + to its old hash_link for some time if it needs to be flushed first, + or if there are other threads still reading it. + + Summary: + hash_link is always returned. + hash_link->block can be: + - NULL or + - not assigned to this hash_link or + - assigned to this hash_link. If assigned, the block can have + - invalid data (when freshly assigned) or + - valid data. Valid data can be + - changed over the file contents (dirty) or + - not changed (clean). + */ hash_link= get_hash_link(keycache, file, filepos); + DBUG_ASSERT((hash_link->file == file) && (hash_link->diskpos == filepos)); page_status= -1; if ((block= hash_link->block) && block->hash_link == hash_link && (block->status & BLOCK_READ)) - page_status= PAGE_READ; - - if (wrmode && keycache->resize_in_flush) { - /* This is a write request during the flush phase of a resize operation */ + /* Assigned block with valid (changed or unchanged) contents. */ + page_status= PAGE_READ; + } + /* + else (page_status == -1) + - block == NULL or + - block not assigned to this hash_link or + - block assigned but not yet read from file (invalid data). + */ - if (page_status != PAGE_READ) + if (keycache->in_resize) + { + /* This is a request during a resize operation */ + + if (!block) { - /* We don't need the page in the cache: we are going to write on disk */ - hash_link->requests--; - unlink_hash(keycache, hash_link); - DBUG_RETURN(0); - } - if (!(block->status & BLOCK_IN_FLUSH)) - { - hash_link->requests--; + struct st_my_thread_var *thread; + /* - Remove block to invalidate the page in the block buffer - as we are going to write directly on disk. - Although we have an exlusive lock for the updated key part - the control can be yieded by the current thread as we might - have unfinished readers of other key parts in the block - buffer. Still we are guaranteed not to have any readers - of the key part we are writing into until the block is - removed from the cache as we set the BLOCL_REASSIGNED - flag (see the code below that handles reading requests). + The file block is not in the cache. We don't need it in the + cache: we are going to read or write directly to file. Cancel + the request. We can simply decrement hash_link->requests because + we did not release cache_lock since increasing it. So no other + thread can wait for our request to become released. */ - free_block(keycache, block); - DBUG_RETURN(0); - } - /* Wait intil the page is flushed on disk */ - hash_link->requests--; - { -#ifdef THREAD - struct st_my_thread_var *thread= my_thread_var; - add_to_queue(&block->wqueue[COND_FOR_SAVED], thread); + if (hash_link->requests == 1) + { + /* + We are the only one to request this hash_link (this file/pos). + Free the hash_link. + */ + hash_link->requests--; + unlink_hash(keycache, hash_link); + DBUG_RETURN(0); + } + + /* + More requests on the hash_link. Someone tries to evict a block + for this hash_link (could have started before resizing started). + This means that the LRU ring is empty. Otherwise a block could + be assigned immediately. Behave like a thread that wants to + evict a block for this file/pos. Add to the queue of threads + waiting for a block. Wait until there is one assigned. + + Refresh the request on the hash-link so that it cannot be reused + for another file/pos. + */ + thread= my_thread_var; + thread->opt_info= (void *) hash_link; + link_into_queue(&keycache->waiting_for_block, thread); do { KEYCACHE_DBUG_PRINT("find_key_block: wait", ("suspend thread %ld", thread->id)); keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock); - } - while(thread->next); -#else - KEYCACHE_DBUG_ASSERT(0); + } while (thread->next); + thread->opt_info= NULL; /* - Given the use of "resize_in_flush", it seems impossible - that this whole branch is ever entered in single-threaded case - because "(wrmode && keycache->resize_in_flush)" cannot be true. - TODO: Check this, and then put the whole branch into the - "#ifdef THREAD" guard. + A block should now be assigned to the hash_link. But it may + still need to be evicted. Anyway, we should re-check the + situation. page_status must be set correctly. */ -#endif + hash_link->requests--; + goto restart; + } /* end of if (!block) */ + + /* + There is a block for this file/pos in the cache. Register a + request on it. This unlinks it from the LRU ring (if it is there) + and hence protects it against eviction (if not already in + eviction). We need this for returning the block to the caller, for + calling remove_reader() (for debugging purposes), and for calling + free_block(). The only case where we don't need the request is if + the block is in eviction. In that case we have to unregister the + request later. + */ + reg_requests(keycache, block, 1); + + if (page_status != PAGE_READ) + { + /* + - block not assigned to this hash_link or + - block assigned but not yet read from file (invalid data). + + This must be a block in eviction. It will be read soon. We need + to wait here until this happened. Otherwise the caller could + access a wrong block or a block which is in read. While waiting + we cannot lose hash_link nor block. We have registered a request + on the hash_link. Everything can happen to the block but changes + in the hash_link -> block relationship. In other words: + everything can happen to the block but free or another completed + eviction. + + Note that we bahave like a secondary requestor here. We just + cannot return with PAGE_WAIT_TO_BE_READ. This would work for + read requests and writes on dirty blocks that are not in flush + only. Waiting here on COND_FOR_REQUESTED works in all + situations. + */ + DBUG_ASSERT(((block->hash_link != hash_link) && + (block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH))) || + ((block->hash_link == hash_link) && + !(block->status & BLOCK_READ))); + wait_on_queue(&block->wqueue[COND_FOR_REQUESTED], &keycache->cache_lock); + /* + Here we can trust that the block has been assigned to this + hash_link (block->hash_link == hash_link) and read into the + buffer (BLOCK_READ). The worst things possible here are that the + block is in free (BLOCK_REASSIGNED). But the block is still + assigned to the hash_link. The freeing thread waits until we + release our request on the hash_link. The block must not be + again in eviction because we registered an request on it before + starting to wait. + */ + DBUG_ASSERT(block->hash_link == hash_link); + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(!(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH))); } - /* Invalidate page in the block if it has not been done yet */ - if (block->status) + /* + The block is in the cache. Assigned to the hash_link. Valid data. + Note that in case of page_st == PAGE_READ, the block can be marked + for eviction. In any case it can be marked for freeing. + */ + + if (!wrmode) + { + /* A reader can just read the block. */ + *page_st= PAGE_READ; + DBUG_ASSERT((hash_link->file == file) && + (hash_link->diskpos == filepos) && + (block->hash_link == hash_link)); + DBUG_RETURN(block); + } + + /* + This is a writer. No two writers for the same block can exist. + This must be assured by locks outside of the key cache. + */ + DBUG_ASSERT(!(block->status & BLOCK_FOR_UPDATE) || fail_block(block)); + + while (block->status & BLOCK_IN_FLUSH) + { + /* + Wait until the block is flushed to file. Do not release the + request on the hash_link yet to prevent that the block is freed + or reassigned while we wait. While we wait, several things can + happen to the block, including another flush. But the block + cannot be reassigned to another hash_link until we release our + request on it. But it can be marked BLOCK_REASSIGNED from free + or eviction, while they wait for us to release the hash_link. + */ + wait_on_queue(&block->wqueue[COND_FOR_SAVED], &keycache->cache_lock); + /* + If the flush phase failed, the resize could have finished while + we waited here. + */ + if (!keycache->in_resize) + { + remove_reader(block); + unreg_request(keycache, block, 1); + goto restart; + } + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(!(block->status & BLOCK_FOR_UPDATE) || fail_block(block)); + DBUG_ASSERT(block->hash_link == hash_link); + } + + if (block->status & BLOCK_CHANGED) + { + /* + We want to write a block with changed contents. If the cache + block size is bigger than the callers block size (e.g. MyISAM), + the caller may replace part of the block only. Changes of the + other part of the block must be preserved. Since the block has + not yet been selected for flush, we can still add our changes. + */ + *page_st= PAGE_READ; + DBUG_ASSERT((hash_link->file == file) && + (hash_link->diskpos == filepos) && + (block->hash_link == hash_link)); + DBUG_RETURN(block); + } + + /* + This is a write request for a clean block. We do not want to have + new dirty blocks in the cache while resizing. We will free the + block and write directly to file. If the block is in eviction or + in free, we just let it go. + + Unregister from the hash_link. This must be done before freeing + the block. And it must be done if not freeing the block. Because + we could have waited above, we need to call remove_reader(). Other + threads could wait for us to release our request on the hash_link. + */ + remove_reader(block); + + /* If the block is not in eviction and not in free, we can free it. */ + if (!(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH | + BLOCK_REASSIGNED))) + { + /* + Free block as we are going to write directly to file. + Although we have an exlusive lock for the updated key part, + the control can be yielded by the current thread as we might + have unfinished readers of other key parts in the block + buffer. Still we are guaranteed not to have any readers + of the key part we are writing into until the block is + removed from the cache as we set the BLOCK_REASSIGNED + flag (see the code below that handles reading requests). + */ free_block(keycache, block); + } + else + { + /* + The block will be evicted/freed soon. Don't touch it in any way. + Unregister the request that we registered above. + */ + unreg_request(keycache, block, 1); + + /* + The block is still assigned to the hash_link (the file/pos that + we are going to write to). Wait until the eviction/free is + complete. Otherwise the direct write could complete before all + readers are done with the block. So they could read outdated + data. + + Since we released our request on the hash_link, it can be reused + for another file/pos. Hence we cannot just check for + block->hash_link == hash_link. As long as the resize is + proceeding the block cannot be reassigned to the same file/pos + again. So we can terminate the loop when the block is no longer + assigned to this file/pos. + */ + do + { + wait_on_queue(&block->wqueue[COND_FOR_SAVED], + &keycache->cache_lock); + /* + If the flush phase failed, the resize could have finished + while we waited here. + */ + if (!keycache->in_resize) + goto restart; + } while (block->hash_link && + (block->hash_link->file == file) && + (block->hash_link->diskpos == filepos)); + } DBUG_RETURN(0); } if (page_status == PAGE_READ && - (block->status & (BLOCK_IN_SWITCH | BLOCK_REASSIGNED))) + (block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH | + BLOCK_REASSIGNED))) { - /* This is a request for a page to be removed from cache */ + /* + This is a request for a block to be removed from cache. The block + is assigned to this hash_link and contains valid data, but is + marked for eviction or to be freed. Possible reasons why it has + not yet been evicted/freed can be a flush before reassignment + (BLOCK_IN_SWITCH), readers of the block have not finished yet + (BLOCK_REASSIGNED), or the evicting thread did not yet awake after + the block has been selected for it (BLOCK_IN_EVICTION). + */ KEYCACHE_DBUG_PRINT("find_key_block", ("request for old page in block %u " @@ -1446,43 +2007,58 @@ restart: all others are to be suspended, then resubmitted */ if (!wrmode && !(block->status & BLOCK_REASSIGNED)) + { + /* + This is a read request and the block not yet reassigned. We can + register our request and proceed. This unlinks the block from + the LRU ring and protects it against eviction. + */ reg_requests(keycache, block, 1); + } else { + /* + Either this is a write request for a block that is in eviction + or in free. We must not use it any more. Instead we must evict + another block. But we cannot do this before the eviction/free is + done. Otherwise we would find the same hash_link + block again + and again. + + Or this is a read request for a block in eviction/free that does + not require a flush, but waits for readers to finish with the + block. We do not read this block to let the eviction/free happen + as soon as possible. Again we must wait so that we don't find + the same hash_link + block again and again. + */ + DBUG_ASSERT(hash_link->requests); hash_link->requests--; KEYCACHE_DBUG_PRINT("find_key_block", ("request waiting for old page to be saved")); - { -#ifdef THREAD - struct st_my_thread_var *thread= my_thread_var; - /* Put the request into the queue of those waiting for the old page */ - add_to_queue(&block->wqueue[COND_FOR_SAVED], thread); - /* Wait until the request can be resubmitted */ - do - { - KEYCACHE_DBUG_PRINT("find_key_block: wait", - ("suspend thread %ld", thread->id)); - keycache_pthread_cond_wait(&thread->suspend, - &keycache->cache_lock); - } - while(thread->next); -#else - KEYCACHE_DBUG_ASSERT(0); - /* No parallel requests in single-threaded case */ -#endif - } + wait_on_queue(&block->wqueue[COND_FOR_SAVED], &keycache->cache_lock); KEYCACHE_DBUG_PRINT("find_key_block", ("request for old page resubmitted")); - /* Resubmit the request */ + /* + The block is no longer assigned to this hash_link. + Get another one. + */ goto restart; } } else { - /* This is a request for a new page or for a page not to be removed */ + /* + This is a request for a new block or for a block not to be removed. + Either + - block == NULL or + - block not assigned to this hash_link or + - block assigned but not yet read from file, + or + - block assigned with valid (changed or unchanged) data and + - it will not be reassigned/freed. + */ if (! block) { - /* No block is assigned for the page yet */ + /* No block is assigned to the hash_link yet. */ if (keycache->blocks_unused) { if (keycache->free_block_list) @@ -1494,25 +2070,36 @@ restart: } else { + size_t block_mem_offset; /* There are some never used blocks, take first of them */ + DBUG_ASSERT(keycache->blocks_used < + (ulong) keycache->disk_blocks); block= &keycache->block_root[keycache->blocks_used]; + block_mem_offset= + ((size_t) keycache->blocks_used) * keycache->key_cache_block_size; block->buffer= ADD_TO_PTR(keycache->block_mem, - ((ulong) keycache->blocks_used* - keycache->key_cache_block_size), + block_mem_offset, byte*); keycache->blocks_used++; + DBUG_ASSERT(!block->next_used); } + DBUG_ASSERT(!block->prev_used); + DBUG_ASSERT(!block->next_changed); + DBUG_ASSERT(!block->prev_changed); + DBUG_ASSERT(!block->hash_link); + DBUG_ASSERT(!block->status); + DBUG_ASSERT(!block->requests); keycache->blocks_unused--; - block->status= 0; + block->status= BLOCK_IN_USE; block->length= 0; block->offset= keycache->key_cache_block_size; block->requests= 1; block->temperature= BLOCK_COLD; block->hits_left= init_hits_left; block->last_hit_time= 0; - link_to_file_list(keycache, block, file, 0); block->hash_link= hash_link; hash_link->block= block; + link_to_file_list(keycache, block, file, 0); page_status= PAGE_TO_BE_READ; KEYCACHE_DBUG_PRINT("find_key_block", ("got free or never used block %u", @@ -1520,17 +2107,26 @@ restart: } else { - /* There are no never used blocks, use a block from the LRU chain */ - - /* - Wait until a new block is added to the LRU chain; - several threads might wait here for the same page, - all of them must get the same block + /* + There are no free blocks and no never used blocks, use a block + from the LRU ring. */ #ifdef THREAD if (! keycache->used_last) { + /* + The LRU ring is empty. Wait until a new block is added to + it. Several threads might wait here for the same hash_link, + all of them must get the same block. While waiting for a + block, after a block is selected for this hash_link, other + threads can run first before this one awakes. During this + time interval other threads find this hash_link pointing to + the block, which is still assigned to another hash_link. In + this case the block is not marked BLOCK_IN_SWITCH yet, but + it is marked BLOCK_IN_EVICTION. + */ + struct st_my_thread_var *thread= my_thread_var; thread->opt_info= (void *) hash_link; link_into_queue(&keycache->waiting_for_block, thread); @@ -1543,24 +2139,50 @@ restart: } while (thread->next); thread->opt_info= NULL; + /* Assert that block has a request registered. */ + DBUG_ASSERT(hash_link->block->requests); + /* Assert that block is not in LRU ring. */ + DBUG_ASSERT(!hash_link->block->next_used); + DBUG_ASSERT(!hash_link->block->prev_used); } #else KEYCACHE_DBUG_ASSERT(keycache->used_last); #endif + /* + If we waited above, hash_link->block has been assigned by + link_block(). Otherwise it is still NULL. In the latter case + we need to grab a block from the LRU ring ourselves. + */ block= hash_link->block; if (! block) { - /* - Take the first block from the LRU chain - unlinking it from the chain - */ + /* Select the last block from the LRU ring. */ block= keycache->used_last->next_used; block->hits_left= init_hits_left; block->last_hit_time= 0; - reg_requests(keycache, block,1); hash_link->block= block; + /* + Register a request on the block. This unlinks it from the + LRU ring and protects it against eviction. + */ + DBUG_ASSERT(!block->requests); + reg_requests(keycache, block,1); + /* + We do not need to set block->status|= BLOCK_IN_EVICTION here + because we will set block->status|= BLOCK_IN_SWITCH + immediately without releasing the lock in between. This does + also support debugging. When looking at the block, one can + see if the block has been selected by link_block() after the + LRU ring was empty, or if it was grabbed directly from the + LRU ring in this branch. + */ } + /* + If we had to wait above, there is a small chance that another + thread grabbed this block for the same file block already. But + in most cases the first condition is true. + */ if (block->hash_link != hash_link && ! (block->status & BLOCK_IN_SWITCH) ) { @@ -1575,44 +2197,117 @@ restart: /* The block contains a dirty page - push it out of the cache */ KEYCACHE_DBUG_PRINT("find_key_block", ("block is dirty")); + if (block->status & BLOCK_IN_FLUSH) + { + /* + The block is marked for flush. If we do not wait here, + it could happen that we write the block, reassign it to + another file block, then, before the new owner can read + the new file block, the flusher writes the cache block + (which still has the old contents) to the new file block! + */ + wait_on_queue(&block->wqueue[COND_FOR_SAVED], + &keycache->cache_lock); + /* + The block is marked BLOCK_IN_SWITCH. It should be left + alone except for reading. No free, no write. + */ + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + DBUG_ASSERT(!(block->status & (BLOCK_REASSIGNED | + BLOCK_CHANGED | + BLOCK_FOR_UPDATE))); + } + else + { + block->status|= BLOCK_IN_FLUSH | BLOCK_IN_FLUSHWRITE; + /* + BLOCK_IN_EVICTION may be true or not. Other flags must + have a fixed value. + */ + DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) == + (BLOCK_READ | BLOCK_IN_SWITCH | + BLOCK_IN_FLUSH | BLOCK_IN_FLUSHWRITE | + BLOCK_CHANGED | BLOCK_IN_USE)); + DBUG_ASSERT(block->hash_link); - keycache_pthread_mutex_unlock(&keycache->cache_lock); - /* - The call is thread safe because only the current - thread might change the block->hash_link value - */ - error= my_pwrite(block->hash_link->file, - block->buffer+block->offset, - block->length - block->offset, - block->hash_link->diskpos+ block->offset, - MYF(MY_NABP | MY_WAIT_IF_FULL)); - keycache_pthread_mutex_lock(&keycache->cache_lock); - keycache->global_cache_write++; + keycache_pthread_mutex_unlock(&keycache->cache_lock); + /* + The call is thread safe because only the current + thread might change the block->hash_link value + */ + error= my_pwrite(block->hash_link->file, + block->buffer + block->offset, + block->length - block->offset, + block->hash_link->diskpos + block->offset, + MYF(MY_NABP | MY_WAIT_IF_FULL)); + keycache_pthread_mutex_lock(&keycache->cache_lock); + + /* Block status must not have changed. */ + DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) == + (BLOCK_READ | BLOCK_IN_SWITCH | + BLOCK_IN_FLUSH | BLOCK_IN_FLUSHWRITE | + BLOCK_CHANGED | BLOCK_IN_USE) || fail_block(block)); + keycache->global_cache_write++; + } } block->status|= BLOCK_REASSIGNED; + /* + The block comes from the LRU ring. It must have a hash_link + assigned. + */ + DBUG_ASSERT(block->hash_link); if (block->hash_link) { /* + All pending requests for this page must be resubmitted. + This must be done before waiting for readers. They could + wait for the flush to complete. And we must also do it + after the wait. Flushers might try to free the block while + we wait. They would wait until the reassignment is + complete. Also the block status must reflect the correct + situation: The block is not changed nor in flush any more. + Note that we must not change the BLOCK_CHANGED flag + outside of link_to_file_list() so that it is always in the + correct queue and the *blocks_changed counters are + correct. + */ + block->status&= ~(BLOCK_IN_FLUSH | BLOCK_IN_FLUSHWRITE); + link_to_file_list(keycache, block, block->hash_link->file, 1); + release_whole_queue(&block->wqueue[COND_FOR_SAVED]); + /* + The block is still assigned to its old hash_link. Wait until all pending read requests for this page are executed (we could have avoided this waiting, if we had read a page in the cache in a sweep, without yielding control) */ wait_for_readers(keycache, block); + DBUG_ASSERT(block->hash_link && block->hash_link->block == block && + block->prev_changed); + /* The reader must not have been a writer. */ + DBUG_ASSERT(!(block->status & BLOCK_CHANGED)); - /* Remove the hash link for this page from the hash table */ + /* Wake flushers that might have found the block in between. */ + release_whole_queue(&block->wqueue[COND_FOR_SAVED]); + + /* Remove the hash link for the old file block from the hash. */ unlink_hash(keycache, block->hash_link); - /* All pending requests for this page must be resubmitted */ - if (block->wqueue[COND_FOR_SAVED].last_thread) - release_queue(&block->wqueue[COND_FOR_SAVED]); + + /* + For sanity checks link_to_file_list() asserts that block + and hash_link refer to each other. Hence we need to assign + the hash_link first, but then we would not know if it was + linked before. Hence we would not know if to unlink it. So + unlink it here and call link_to_file_list(..., FALSE). + */ + unlink_changed(block); } - link_to_file_list(keycache, block, file, - (my_bool)(block->hash_link ? 1 : 0)); - block->status= error? BLOCK_ERROR : 0; + block->status= error ? BLOCK_ERROR : BLOCK_IN_USE ; block->length= 0; block->offset= keycache->key_cache_block_size; block->hash_link= hash_link; + link_to_file_list(keycache, block, file, 0); page_status= PAGE_TO_BE_READ; KEYCACHE_DBUG_ASSERT(block->hash_link->block == block); @@ -1620,7 +2315,20 @@ restart: } else { - /* This is for secondary requests for a new page only */ + /* + Either (block->hash_link == hash_link), + or (block->status & BLOCK_IN_SWITCH). + + This is for secondary requests for a new file block only. + Either it is already assigned to the new hash_link meanwhile + (if we had to wait due to empty LRU), or it is already in + eviction by another thread. Since this block has been + grabbed from the LRU ring and attached to this hash_link, + another thread cannot grab the same block from the LRU ring + anymore. If the block is in eviction already, it must become + attached to the same hash_link and as such destined for the + same file block. + */ KEYCACHE_DBUG_PRINT("find_key_block", ("block->hash_link: %p hash_link: %p " "block->status: %u", block->hash_link, @@ -1630,10 +2338,35 @@ restart: PAGE_READ : PAGE_WAIT_TO_BE_READ); } } - keycache->global_cache_read++; } else { + /* + Block is not NULL. This hash_link points to a block. + Either + - block not assigned to this hash_link (yet) or + - block assigned but not yet read from file, + or + - block assigned with valid (changed or unchanged) data and + - it will not be reassigned/freed. + + The first condition means hash_link points to a block in + eviction. This is not necessarily marked by BLOCK_IN_SWITCH yet. + But then it is marked BLOCK_IN_EVICTION. See the NOTE in + link_block(). In both cases it is destined for this hash_link + and its file block address. When this hash_link got its block + address, the block was removed from the LRU ring and cannot be + selected for eviction (for another hash_link) again. + + Register a request on the block. This is another protection + against eviction. + */ + DBUG_ASSERT(((block->hash_link != hash_link) && + (block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH))) || + ((block->hash_link == hash_link) && + !(block->status & BLOCK_READ)) || + ((block->status & BLOCK_READ) && + !(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH)))); reg_requests(keycache, block, 1); KEYCACHE_DBUG_PRINT("find_key_block", ("block->hash_link: %p hash_link: %p " @@ -1646,11 +2379,21 @@ restart: } KEYCACHE_DBUG_ASSERT(page_status != -1); + /* Same assert basically, but be very sure. */ + KEYCACHE_DBUG_ASSERT(block); + /* Assert that block has a request and is not in LRU ring. */ + DBUG_ASSERT(block->requests); + DBUG_ASSERT(!block->next_used); + DBUG_ASSERT(!block->prev_used); + /* Assert that we return the correct block. */ + DBUG_ASSERT((page_status == PAGE_WAIT_TO_BE_READ) || + ((block->hash_link->file == file) && + (block->hash_link->diskpos == filepos))); *page_st=page_status; KEYCACHE_DBUG_PRINT("find_key_block", - ("fd: %d pos: %lu block->status: %u page_status: %u", + ("fd: %d pos: %lu block->status: %u page_status: %d", file, (ulong) filepos, block->status, - (uint) page_status)); + page_status)); #if !defined(DBUG_OFF) && defined(EXTRA_DEBUG) DBUG_EXECUTE("check_keycache2", @@ -1697,13 +2440,22 @@ static void read_block(KEY_CACHE *keycache, if (primary) { /* - This code is executed only by threads - that submitted primary requests + This code is executed only by threads that submitted primary + requests. Until block->status contains BLOCK_READ, all other + request for the block become secondary requests. For a primary + request the block must be properly initialized. */ + DBUG_ASSERT(((block->status & ~BLOCK_FOR_UPDATE) == BLOCK_IN_USE) || + fail_block(block)); + DBUG_ASSERT((block->length == 0) || fail_block(block)); + DBUG_ASSERT((block->offset == keycache->key_cache_block_size) || + fail_block(block)); + DBUG_ASSERT((block->requests > 0) || fail_block(block)); KEYCACHE_DBUG_PRINT("read_block", ("page to be read by primary request")); + keycache->global_cache_read++; /* Page is not in buffer yet, is to be read from disk */ keycache_pthread_mutex_unlock(&keycache->cache_lock); /* @@ -1713,45 +2465,50 @@ static void read_block(KEY_CACHE *keycache, got_length= my_pread(block->hash_link->file, block->buffer, read_length, block->hash_link->diskpos, MYF(0)); keycache_pthread_mutex_lock(&keycache->cache_lock); + /* + The block can now have been marked for free (in case of + FLUSH_RELEASE). Otherwise the state must be unchanged. + */ + DBUG_ASSERT(((block->status & ~(BLOCK_REASSIGNED | + BLOCK_FOR_UPDATE)) == BLOCK_IN_USE) || + fail_block(block)); + DBUG_ASSERT((block->length == 0) || fail_block(block)); + DBUG_ASSERT((block->offset == keycache->key_cache_block_size) || + fail_block(block)); + DBUG_ASSERT((block->requests > 0) || fail_block(block)); + if (got_length < min_length) block->status|= BLOCK_ERROR; else { - block->status= BLOCK_READ; + block->status|= BLOCK_READ; block->length= got_length; + /* + Do not set block->offset here. If this block is marked + BLOCK_CHANGED later, we want to flush only the modified part. So + only a writer may set block->offset down from + keycache->key_cache_block_size. + */ } KEYCACHE_DBUG_PRINT("read_block", ("primary request: new page in cache")); /* Signal that all pending requests for this page now can be processed */ - if (block->wqueue[COND_FOR_REQUESTED].last_thread) - release_queue(&block->wqueue[COND_FOR_REQUESTED]); + release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]); } else { /* - This code is executed only by threads - that submitted secondary requests + This code is executed only by threads that submitted secondary + requests. At this point it could happen that the cache block is + not yet assigned to the hash_link for the requested file block. + But at awake from the wait this should be the case. Unfortunately + we cannot assert this here because we do not know the hash_link + for the requested file block nor the file and position. So we have + to assert this in the caller. */ KEYCACHE_DBUG_PRINT("read_block", ("secondary request waiting for new page to be read")); - { -#ifdef THREAD - struct st_my_thread_var *thread= my_thread_var; - /* Put the request into a queue and wait until it can be processed */ - add_to_queue(&block->wqueue[COND_FOR_REQUESTED], thread); - do - { - KEYCACHE_DBUG_PRINT("read_block: wait", - ("suspend thread %ld", thread->id)); - keycache_pthread_cond_wait(&thread->suspend, - &keycache->cache_lock); - } - while (thread->next); -#else - KEYCACHE_DBUG_ASSERT(0); - /* No parallel requests in single-threaded case */ -#endif - } + wait_on_queue(&block->wqueue[COND_FOR_REQUESTED], &keycache->cache_lock); KEYCACHE_DBUG_PRINT("read_block", ("secondary request: new page in cache")); } @@ -1792,32 +2549,61 @@ byte *key_cache_read(KEY_CACHE *keycache, uint block_length __attribute__((unused)), int return_buffer __attribute__((unused))) { + my_bool locked_and_incremented= FALSE; int error=0; - uint offset= 0; byte *start= buff; DBUG_ENTER("key_cache_read"); DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u", (uint) file, (ulong) filepos, length)); - if (keycache->can_be_used) + if (keycache->key_cache_inited) { /* Key cache is used */ reg1 BLOCK_LINK *block; uint read_length; - uint status; + uint offset; int page_st; + /* + When the key cache is once initialized, we use the cache_lock to + reliably distinguish the cases of normal operation, resizing, and + disabled cache. We always increment and decrement + 'cnt_for_resize_op' so that a resizer can wait for pending I/O. + */ + keycache_pthread_mutex_lock(&keycache->cache_lock); + /* + Cache resizing has two phases: Flushing and re-initializing. In + the flush phase read requests are allowed to bypass the cache for + blocks not in the cache. find_key_block() returns NULL in this + case. + + After the flush phase new I/O requests must wait until the + re-initialization is done. The re-initialization can be done only + if no I/O request is in progress. The reason is that + key_cache_block_size can change. With enabled cache, I/O is done + in chunks of key_cache_block_size. Every chunk tries to use a + cache block first. If the block size changes in the middle, a + block could be missed and old data could be read. + */ + while (keycache->in_resize && !keycache->resize_in_flush) + wait_on_queue(&keycache->resize_queue, &keycache->cache_lock); + /* Register the I/O for the next resize. */ + inc_counter_for_resize_op(keycache); + locked_and_incremented= TRUE; + /* Requested data may not always be aligned to cache blocks. */ offset= (uint) (filepos % keycache->key_cache_block_size); /* Read data in key_cache_block_size increments */ do { - keycache_pthread_mutex_lock(&keycache->cache_lock); + /* Cache could be disabled in a later iteration. */ if (!keycache->can_be_used) { - keycache_pthread_mutex_unlock(&keycache->cache_lock); - goto no_key_cache; + KEYCACHE_DBUG_PRINT("key_cache_read", ("keycache cannot be used")); + goto no_key_cache; } + /* Start reading at the beginning of the cache block. */ filepos-= offset; + /* Do not read beyond the end of the cache block. */ read_length= length; set_if_smaller(read_length, keycache->key_cache_block_size-offset); KEYCACHE_DBUG_ASSERT(read_length > 0); @@ -1827,34 +2613,61 @@ byte *key_cache_read(KEY_CACHE *keycache, return_buffer=0; #endif - inc_counter_for_resize_op(keycache); + /* Request the cache block that matches file/pos. */ keycache->global_cache_r_requests++; block=find_key_block(keycache, file, filepos, level, 0, &page_st); - if (block->status != BLOCK_ERROR && page_st != PAGE_READ) - { - /* The requested page is to be read into the block buffer */ - read_block(keycache, block, - keycache->key_cache_block_size, read_length+offset, - (my_bool)(page_st == PAGE_TO_BE_READ)); - } - else if (! (block->status & BLOCK_ERROR) && - block->length < read_length + offset) + if (!block) { /* - Impossible if nothing goes wrong: - this could only happen if we are using a file with - small key blocks and are trying to read outside the file + This happens only for requests submitted during key cache + resize. The block is not in the cache and shall not go in. + Read directly from file. */ - my_errno= -1; - block->status|= BLOCK_ERROR; + keycache->global_cache_read++; + keycache_pthread_mutex_unlock(&keycache->cache_lock); + error= (my_pread(file, (byte*) buff, read_length, + filepos + offset, MYF(MY_NABP)) != 0); + keycache_pthread_mutex_lock(&keycache->cache_lock); + goto next_block; + } + if (!(block->status & BLOCK_ERROR)) + { + if (page_st != PAGE_READ) + { + /* The requested page is to be read into the block buffer */ + read_block(keycache, block, + keycache->key_cache_block_size, read_length+offset, + (my_bool)(page_st == PAGE_TO_BE_READ)); + /* + A secondary request must now have the block assigned to the + requested file block. It does not hurt to check it for + primary requests too. + */ + DBUG_ASSERT(keycache->can_be_used); + DBUG_ASSERT(block->hash_link->file == file); + DBUG_ASSERT(block->hash_link->diskpos == filepos); + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + } + else if (block->length < read_length + offset) + { + /* + Impossible if nothing goes wrong: + this could only happen if we are using a file with + small key blocks and are trying to read outside the file + */ + my_errno= -1; + block->status|= BLOCK_ERROR; + } } - if (! ((status= block->status) & BLOCK_ERROR)) + /* block status may have added BLOCK_ERROR in the above 'if'. */ + if (!(block->status & BLOCK_ERROR)) { #ifndef THREAD if (! return_buffer) #endif { + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); #if !defined(SERIALIZED_READ_FROM_CACHE) keycache_pthread_mutex_unlock(&keycache->cache_lock); #endif @@ -1867,44 +2680,68 @@ byte *key_cache_read(KEY_CACHE *keycache, #if !defined(SERIALIZED_READ_FROM_CACHE) keycache_pthread_mutex_lock(&keycache->cache_lock); + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); #endif } } remove_reader(block); - /* - Link the block into the LRU chain - if it's the last submitted request for the block - */ - unreg_request(keycache, block, 1); - dec_counter_for_resize_op(keycache); + /* Error injection for coverage testing. */ + DBUG_EXECUTE_IF("key_cache_read_block_error", + block->status|= BLOCK_ERROR;); - keycache_pthread_mutex_unlock(&keycache->cache_lock); - - if (status & BLOCK_ERROR) - DBUG_RETURN((byte *) 0); + /* Do not link erroneous blocks into the LRU ring, but free them. */ + if (!(block->status & BLOCK_ERROR)) + { + /* + Link the block into the LRU ring if it's the last submitted + request for the block. This enables eviction for the block. + */ + unreg_request(keycache, block, 1); + } + else + { + free_block(keycache, block); + error= 1; + break; + } #ifndef THREAD /* This is only true if we where able to read everything in one block */ if (return_buffer) DBUG_RETURN(block->buffer); #endif + next_block: buff+= read_length; filepos+= read_length+offset; offset= 0; } while ((length-= read_length)); - DBUG_RETURN(start); + goto end; } + KEYCACHE_DBUG_PRINT("key_cache_read", ("keycache not initialized")); -no_key_cache: /* Key cache is not used */ +no_key_cache: + /* Key cache is not used */ - /* We can't use mutex here as the key cache may not be initialized */ keycache->global_cache_r_requests++; keycache->global_cache_read++; - if (my_pread(file, (byte*) buff, length, filepos+offset, MYF(MY_NABP))) + + if (locked_and_incremented) + keycache_pthread_mutex_unlock(&keycache->cache_lock); + if (my_pread(file, (byte*) buff, length, filepos, MYF(MY_NABP))) error= 1; + if (locked_and_incremented) + keycache_pthread_mutex_lock(&keycache->cache_lock); + +end: + if (locked_and_incremented) + { + dec_counter_for_resize_op(keycache); + keycache_pthread_mutex_unlock(&keycache->cache_lock); + } + DBUG_PRINT("exit", ("error: %d", error )); DBUG_RETURN(error ? (byte*) 0 : start); } @@ -1933,90 +2770,220 @@ int key_cache_insert(KEY_CACHE *keycache, File file, my_off_t filepos, int level, byte *buff, uint length) { + int error= 0; DBUG_ENTER("key_cache_insert"); DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u", (uint) file,(ulong) filepos, length)); - if (keycache->can_be_used) + if (keycache->key_cache_inited) { /* Key cache is used */ reg1 BLOCK_LINK *block; uint read_length; - int page_st; - int error; uint offset; + int page_st; + my_bool locked_and_incremented= FALSE; + /* + When the keycache is once initialized, we use the cache_lock to + reliably distinguish the cases of normal operation, resizing, and + disabled cache. We always increment and decrement + 'cnt_for_resize_op' so that a resizer can wait for pending I/O. + */ + keycache_pthread_mutex_lock(&keycache->cache_lock); + /* + We do not load index data into a disabled cache nor into an + ongoing resize. + */ + if (!keycache->can_be_used || keycache->in_resize) + goto no_key_cache; + /* Register the pseudo I/O for the next resize. */ + inc_counter_for_resize_op(keycache); + locked_and_incremented= TRUE; + /* Loaded data may not always be aligned to cache blocks. */ offset= (uint) (filepos % keycache->key_cache_block_size); + /* Load data in key_cache_block_size increments. */ do { - keycache_pthread_mutex_lock(&keycache->cache_lock); - if (!keycache->can_be_used) - { - keycache_pthread_mutex_unlock(&keycache->cache_lock); - DBUG_RETURN(0); - } - /* Read data into key cache from buff in key_cache_block_size incr. */ + /* Cache could be disabled or resizing in a later iteration. */ + if (!keycache->can_be_used || keycache->in_resize) + goto no_key_cache; + /* Start loading at the beginning of the cache block. */ filepos-= offset; + /* Do not load beyond the end of the cache block. */ read_length= length; set_if_smaller(read_length, keycache->key_cache_block_size-offset); KEYCACHE_DBUG_ASSERT(read_length > 0); - inc_counter_for_resize_op(keycache); + /* The block has been read by the caller already. */ + keycache->global_cache_read++; + /* Request the cache block that matches file/pos. */ keycache->global_cache_r_requests++; block= find_key_block(keycache, file, filepos, level, 0, &page_st); - if (block->status != BLOCK_ERROR && page_st != PAGE_READ) + if (!block) { - /* The requested page is to be read into the block buffer */ -#if !defined(SERIALIZED_READ_FROM_CACHE) - keycache_pthread_mutex_unlock(&keycache->cache_lock); /* - Here other threads may step in and register as secondary readers. - They will register in block->wqueue[COND_FOR_REQUESTED]. + This happens only for requests submitted during key cache + resize. The block is not in the cache and shall not go in. + Stop loading index data. */ -#endif + goto no_key_cache; + } + if (!(block->status & BLOCK_ERROR)) + { + if ((page_st == PAGE_WAIT_TO_BE_READ) || + ((page_st == PAGE_TO_BE_READ) && + (offset || (read_length < keycache->key_cache_block_size)))) + { + /* + Either - /* Copy data from buff */ - if (!(read_length & 511)) - bmove512(block->buffer+offset, buff, read_length); - else - memcpy(block->buffer+offset, buff, (size_t) read_length); + this is a secondary request for a block to be read into the + cache. The block is in eviction. It is not yet assigned to + the requested file block (It does not point to the right + hash_link). So we cannot call remove_reader() on the block. + And we cannot access the hash_link directly here. We need to + wait until the assignment is complete. read_block() executes + the correct wait when called with primary == FALSE. + + Or + + this is a primary request for a block to be read into the + cache and the supplied data does not fill the whole block. + + This function is called on behalf of a LOAD INDEX INTO CACHE + statement, which is a read-only task and allows other + readers. It is possible that a parallel running reader tries + to access this block. If it needs more data than has been + supplied here, it would report an error. To be sure that we + have all data in the block that is available in the file, we + read the block ourselves. + + Though reading again what the caller did read already is an + expensive operation, we need to do this for correctness. + */ + read_block(keycache, block, keycache->key_cache_block_size, + read_length + offset, (page_st == PAGE_TO_BE_READ)); + /* + A secondary request must now have the block assigned to the + requested file block. It does not hurt to check it for + primary requests too. + */ + DBUG_ASSERT(keycache->can_be_used); + DBUG_ASSERT(block->hash_link->file == file); + DBUG_ASSERT(block->hash_link->diskpos == filepos); + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + } + else if (page_st == PAGE_TO_BE_READ) + { + /* + This is a new block in the cache. If we come here, we have + data for the whole block. + */ + DBUG_ASSERT(block->hash_link->requests); + DBUG_ASSERT(block->status & BLOCK_IN_USE); + DBUG_ASSERT((page_st == PAGE_TO_BE_READ) || + (block->status & BLOCK_READ)); #if !defined(SERIALIZED_READ_FROM_CACHE) - keycache_pthread_mutex_lock(&keycache->cache_lock); - /* Here we are alone again. */ + keycache_pthread_mutex_unlock(&keycache->cache_lock); + /* + Here other threads may step in and register as secondary readers. + They will register in block->wqueue[COND_FOR_REQUESTED]. + */ #endif - block->status= BLOCK_READ; - block->length= read_length+offset; - KEYCACHE_DBUG_PRINT("key_cache_insert", - ("primary request: new page in cache")); - /* Signal that all pending requests for this now can be processed. */ - if (block->wqueue[COND_FOR_REQUESTED].last_thread) - release_queue(&block->wqueue[COND_FOR_REQUESTED]); - } + + /* Copy data from buff */ + if (!(read_length & 511)) + bmove512(block->buffer+offset, buff, read_length); + else + memcpy(block->buffer+offset, buff, (size_t) read_length); + +#if !defined(SERIALIZED_READ_FROM_CACHE) + keycache_pthread_mutex_lock(&keycache->cache_lock); + DBUG_ASSERT(block->status & BLOCK_IN_USE); + DBUG_ASSERT((page_st == PAGE_TO_BE_READ) || + (block->status & BLOCK_READ)); +#endif + /* + After the data is in the buffer, we can declare the block + valid. Now other threads do not need to register as + secondary readers any more. They can immediately access the + block. + */ + block->status|= BLOCK_READ; + block->length= read_length+offset; + /* + Do not set block->offset here. If this block is marked + BLOCK_CHANGED later, we want to flush only the modified part. So + only a writer may set block->offset down from + keycache->key_cache_block_size. + */ + KEYCACHE_DBUG_PRINT("key_cache_insert", + ("primary request: new page in cache")); + /* Signal all pending requests. */ + release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]); + } + else + { + /* + page_st == PAGE_READ. The block is in the buffer. All data + must already be present. Blocks are always read with all + data available on file. Assert that the block does not have + less contents than the preloader supplies. If the caller has + data beyond block->length, it means that a file write has + been done while this block was in cache and not extended + with the new data. If the condition is met, we can simply + ignore the block. + */ + DBUG_ASSERT((page_st == PAGE_READ) && + (read_length + offset <= block->length)); + } + + /* + A secondary request must now have the block assigned to the + requested file block. It does not hurt to check it for primary + requests too. + */ + DBUG_ASSERT(block->hash_link->file == file); + DBUG_ASSERT(block->hash_link->diskpos == filepos); + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + } /* end of if (!(block->status & BLOCK_ERROR)) */ remove_reader(block); - /* - Link the block into the LRU chain - if it's the last submitted request for the block - */ - unreg_request(keycache, block, 1); - error= (block->status & BLOCK_ERROR); + /* Error injection for coverage testing. */ + DBUG_EXECUTE_IF("key_cache_insert_block_error", + block->status|= BLOCK_ERROR; errno=EIO;); - dec_counter_for_resize_op(keycache); - - keycache_pthread_mutex_unlock(&keycache->cache_lock); - - if (error) - DBUG_RETURN(1); + /* Do not link erroneous blocks into the LRU ring, but free them. */ + if (!(block->status & BLOCK_ERROR)) + { + /* + Link the block into the LRU ring if it's the last submitted + request for the block. This enables eviction for the block. + */ + unreg_request(keycache, block, 1); + } + else + { + free_block(keycache, block); + error= 1; + break; + } buff+= read_length; filepos+= read_length+offset; offset= 0; } while ((length-= read_length)); + + no_key_cache: + if (locked_and_incremented) + dec_counter_for_resize_op(keycache); + keycache_pthread_mutex_unlock(&keycache->cache_lock); } - DBUG_RETURN(0); + DBUG_RETURN(error); } @@ -2045,6 +3012,8 @@ int key_cache_insert(KEY_CACHE *keycache, It ensures that this data is flushed to the file if dont_write is FALSE. Filepos must be a multiple of 'block_length', but it doesn't have to be a multiple of key_cache_block_size; + + dont_write is always TRUE in the server (info->lock_type is never F_UNLCK). */ int key_cache_write(KEY_CACHE *keycache, @@ -2053,20 +3022,25 @@ int key_cache_write(KEY_CACHE *keycache, uint block_length __attribute__((unused)), int dont_write) { - reg1 BLOCK_LINK *block; + my_bool locked_and_incremented= FALSE; int error=0; DBUG_ENTER("key_cache_write"); DBUG_PRINT("enter", - ("fd: %u pos: %lu length: %u block_length: %u key_block_length: %u", - (uint) file, (ulong) filepos, length, block_length, - keycache ? keycache->key_cache_block_size : 0)); + ("fd: %u pos: %lu length: %u block_length: %u" + " key_block_length: %u", + (uint) file, (ulong) filepos, length, block_length, + keycache ? keycache->key_cache_block_size : 0)); if (!dont_write) { - /* Force writing from buff into disk */ + /* purecov: begin inspected */ + /* Not used in the server. */ + /* Force writing from buff into disk. */ + keycache->global_cache_w_requests++; keycache->global_cache_write++; if (my_pwrite(file, buff, length, filepos, MYF(MY_NABP | MY_WAIT_IF_FULL))) DBUG_RETURN(1); + /* purecov: end */ } #if !defined(DBUG_OFF) && defined(EXTRA_DEBUG) @@ -2074,92 +3048,231 @@ int key_cache_write(KEY_CACHE *keycache, test_key_cache(keycache, "start of key_cache_write", 1);); #endif - if (keycache->can_be_used) + if (keycache->key_cache_inited) { /* Key cache is used */ + reg1 BLOCK_LINK *block; uint read_length; - int page_st; uint offset; + int page_st; + /* + When the key cache is once initialized, we use the cache_lock to + reliably distinguish the cases of normal operation, resizing, and + disabled cache. We always increment and decrement + 'cnt_for_resize_op' so that a resizer can wait for pending I/O. + */ + keycache_pthread_mutex_lock(&keycache->cache_lock); + /* + Cache resizing has two phases: Flushing and re-initializing. In + the flush phase write requests can modify dirty blocks that are + not yet in flush. Otherwise they are allowed to bypass the cache. + find_key_block() returns NULL in both cases (clean blocks and + non-cached blocks). + + After the flush phase new I/O requests must wait until the + re-initialization is done. The re-initialization can be done only + if no I/O request is in progress. The reason is that + key_cache_block_size can change. With enabled cache I/O is done in + chunks of key_cache_block_size. Every chunk tries to use a cache + block first. If the block size changes in the middle, a block + could be missed and data could be written below a cached block. + */ + while (keycache->in_resize && !keycache->resize_in_flush) + wait_on_queue(&keycache->resize_queue, &keycache->cache_lock); + /* Register the I/O for the next resize. */ + inc_counter_for_resize_op(keycache); + locked_and_incremented= TRUE; + /* Requested data may not always be aligned to cache blocks. */ offset= (uint) (filepos % keycache->key_cache_block_size); + /* Write data in key_cache_block_size increments. */ do { - keycache_pthread_mutex_lock(&keycache->cache_lock); + /* Cache could be disabled in a later iteration. */ if (!keycache->can_be_used) - { - keycache_pthread_mutex_unlock(&keycache->cache_lock); goto no_key_cache; - } - /* Write data in key_cache_block_size increments */ + /* Start writing at the beginning of the cache block. */ filepos-= offset; + /* Do not write beyond the end of the cache block. */ read_length= length; set_if_smaller(read_length, keycache->key_cache_block_size-offset); KEYCACHE_DBUG_ASSERT(read_length > 0); - inc_counter_for_resize_op(keycache); + /* Request the cache block that matches file/pos. */ keycache->global_cache_w_requests++; block= find_key_block(keycache, file, filepos, level, 1, &page_st); if (!block) { - /* It happens only for requests submitted during resize operation */ - dec_counter_for_resize_op(keycache); - keycache_pthread_mutex_unlock(&keycache->cache_lock); - if (dont_write) + /* + This happens only for requests submitted during key cache + resize. The block is not in the cache and shall not go in. + Write directly to file. + */ + if (dont_write) { - keycache->global_cache_w_requests++; + /* Used in the server. */ keycache->global_cache_write++; - if (my_pwrite(file, (byte*) buff, length, filepos, - MYF(MY_NABP | MY_WAIT_IF_FULL))) + keycache_pthread_mutex_unlock(&keycache->cache_lock); + if (my_pwrite(file, (uchar*) buff, read_length, filepos + offset, + MYF(MY_NABP | MY_WAIT_IF_FULL))) error=1; - } + keycache_pthread_mutex_lock(&keycache->cache_lock); + } goto next_block; } + /* + Prevent block from flushing and from being selected for to be + freed. This must be set when we release the cache_lock. + However, we must not set the status of the block before it is + assigned to this file/pos. + */ + if (page_st != PAGE_WAIT_TO_BE_READ) + block->status|= BLOCK_FOR_UPDATE; + /* + We must read the file block first if it is not yet in the cache + and we do not replace all of its contents. - if (block->status != BLOCK_ERROR && page_st != PAGE_READ && - (offset || read_length < keycache->key_cache_block_size)) + In cases where the cache block is big enough to contain (parts + of) index blocks of different indexes, our request can be + secondary (PAGE_WAIT_TO_BE_READ). In this case another thread is + reading the file block. If the read completes after us, it + overwrites our new contents with the old contents. So we have to + wait for the other thread to complete the read of this block. + read_block() takes care for the wait. + */ + if (!(block->status & BLOCK_ERROR) && + ((page_st == PAGE_TO_BE_READ && + (offset || read_length < keycache->key_cache_block_size)) || + (page_st == PAGE_WAIT_TO_BE_READ))) + { read_block(keycache, block, offset + read_length >= keycache->key_cache_block_size? offset : keycache->key_cache_block_size, - offset,(my_bool)(page_st == PAGE_TO_BE_READ)); + offset, (page_st == PAGE_TO_BE_READ)); + DBUG_ASSERT(keycache->can_be_used); + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + /* + Prevent block from flushing and from being selected for to be + freed. This must be set when we release the cache_lock. + Here we set it in case we could not set it above. + */ + block->status|= BLOCK_FOR_UPDATE; + } + /* + The block should always be assigned to the requested file block + here. It need not be BLOCK_READ when overwriting the whole block. + */ + DBUG_ASSERT(block->hash_link->file == file); + DBUG_ASSERT(block->hash_link->diskpos == filepos); + DBUG_ASSERT(block->status & BLOCK_IN_USE); + DBUG_ASSERT((page_st == PAGE_TO_BE_READ) || (block->status & BLOCK_READ)); + /* + The block to be written must not be marked BLOCK_REASSIGNED. + Otherwise it could be freed in dirty state or reused without + another flush during eviction. It must also not be in flush. + Otherwise the old contens may have been flushed already and + the flusher could clear BLOCK_CHANGED without flushing the + new changes again. + */ + DBUG_ASSERT(!(block->status & BLOCK_REASSIGNED)); + + while (block->status & BLOCK_IN_FLUSHWRITE) + { + /* + Another thread is flushing the block. It was dirty already. + Wait until the block is flushed to file. Otherwise we could + modify the buffer contents just while it is written to file. + An unpredictable file block contents would be the result. + While we wait, several things can happen to the block, + including another flush. But the block cannot be reassigned to + another hash_link until we release our request on it. + */ + wait_on_queue(&block->wqueue[COND_FOR_SAVED], &keycache->cache_lock); + DBUG_ASSERT(keycache->can_be_used); + DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE)); + /* Still must not be marked for free. */ + DBUG_ASSERT(!(block->status & BLOCK_REASSIGNED)); + DBUG_ASSERT(block->hash_link && (block->hash_link->block == block)); + } + + /* + We could perhaps release the cache_lock during access of the + data like in the other functions. Locks outside of the key cache + assure that readers and a writer do not access the same range of + data. Parallel accesses should happen only if the cache block + contains multiple index block(fragment)s. So different parts of + the buffer would be read/written. An attempt to flush during + memcpy() is prevented with BLOCK_FOR_UPDATE. + */ + if (!(block->status & BLOCK_ERROR)) + { +#if !defined(SERIALIZED_READ_FROM_CACHE) + keycache_pthread_mutex_unlock(&keycache->cache_lock); +#endif + if (!(read_length & 511)) + bmove512(block->buffer+offset, buff, read_length); + else + memcpy(block->buffer+offset, buff, (size_t) read_length); + +#if !defined(SERIALIZED_READ_FROM_CACHE) + keycache_pthread_mutex_lock(&keycache->cache_lock); +#endif + } if (!dont_write) { - /* buff has been written to disk at start */ + /* Not used in the server. buff has been written to disk at start. */ if ((block->status & BLOCK_CHANGED) && (!offset && read_length >= keycache->key_cache_block_size)) link_to_file_list(keycache, block, block->hash_link->file, 1); } else if (! (block->status & BLOCK_CHANGED)) link_to_changed_list(keycache, block); - + block->status|=BLOCK_READ; + /* + Allow block to be selected for to be freed. Since it is marked + BLOCK_CHANGED too, it won't be selected for to be freed without + a flush. + */ + block->status&= ~BLOCK_FOR_UPDATE; set_if_smaller(block->offset, offset); set_if_bigger(block->length, read_length+offset); - if (! (block->status & BLOCK_ERROR)) + /* Threads may be waiting for the changes to be complete. */ + release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]); + + /* + If only a part of the cache block is to be replaced, and the + rest has been read from file, then the cache lock has been + released for I/O and it could be possible that another thread + wants to evict or free the block and waits for it to be + released. So we must not just decrement hash_link->requests, but + also wake a waiting thread. + */ + remove_reader(block); + + /* Error injection for coverage testing. */ + DBUG_EXECUTE_IF("key_cache_write_block_error", + block->status|= BLOCK_ERROR;); + + /* Do not link erroneous blocks into the LRU ring, but free them. */ + if (!(block->status & BLOCK_ERROR)) { - if (!(read_length & 511)) - bmove512(block->buffer+offset, buff, read_length); - else - memcpy(block->buffer+offset, buff, (size_t) read_length); + /* + Link the block into the LRU ring if it's the last submitted + request for the block. This enables eviction for the block. + */ + unreg_request(keycache, block, 1); } - - block->status|=BLOCK_READ; - - /* Unregister the request */ - block->hash_link->requests--; - unreg_request(keycache, block, 1); - - if (block->status & BLOCK_ERROR) + else { - keycache_pthread_mutex_unlock(&keycache->cache_lock); + /* Pretend a "clean" block to avoid complications. */ + block->status&= ~(BLOCK_CHANGED); + free_block(keycache, block); error= 1; break; } - dec_counter_for_resize_op(keycache); - - keycache_pthread_mutex_unlock(&keycache->cache_lock); - next_block: buff+= read_length; filepos+= read_length+offset; @@ -2173,14 +3286,24 @@ no_key_cache: /* Key cache is not used */ if (dont_write) { + /* Used in the server. */ keycache->global_cache_w_requests++; keycache->global_cache_write++; + if (locked_and_incremented) + keycache_pthread_mutex_unlock(&keycache->cache_lock); if (my_pwrite(file, (byte*) buff, length, filepos, MYF(MY_NABP | MY_WAIT_IF_FULL))) error=1; + if (locked_and_incremented) + keycache_pthread_mutex_lock(&keycache->cache_lock); } end: + if (locked_and_incremented) + { + dec_counter_for_resize_op(keycache); + keycache_pthread_mutex_unlock(&keycache->cache_lock); + } #if !defined(DBUG_OFF) && defined(EXTRA_DEBUG) DBUG_EXECUTE("exec", test_key_cache(keycache, "end of key_cache_write", 1);); @@ -2190,17 +3313,64 @@ end: /* - Free block: remove reference to it from hash table, - remove it from the chain file of dirty/clean blocks - and add it to the free list. + Free block. + + SYNOPSIS + free_block() + keycache Pointer to a key cache data structure + block Pointer to the block to free + + DESCRIPTION + Remove reference to block from hash table. + Remove block from the chain of clean blocks. + Add block to the free list. + + NOTE + Block must not be free (status == 0). + Block must not be in free_block_list. + Block must not be in the LRU ring. + Block must not be in eviction (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH). + Block must not be in free (BLOCK_REASSIGNED). + Block must not be in flush (BLOCK_IN_FLUSH). + Block must not be dirty (BLOCK_CHANGED). + Block must not be in changed_blocks (dirty) hash. + Block must be in file_blocks (clean) hash. + Block must refer to a hash_link. + Block must have a request registered on it. */ static void free_block(KEY_CACHE *keycache, BLOCK_LINK *block) { KEYCACHE_THREAD_TRACE("free block"); KEYCACHE_DBUG_PRINT("free_block", - ("block %u to be freed, hash_link %p", - BLOCK_NUMBER(block), block->hash_link)); + ("block %u to be freed, hash_link %p status: %u", + BLOCK_NUMBER(block), block->hash_link, + block->status)); + /* + Assert that the block is not free already. And that it is in a clean + state. Note that the block might just be assigned to a hash_link and + not yet read (BLOCK_READ may not be set here). In this case a reader + is registered in the hash_link and free_block() will wait for it + below. + */ + DBUG_ASSERT((block->status & BLOCK_IN_USE) && + !(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH | + BLOCK_REASSIGNED | BLOCK_IN_FLUSH | + BLOCK_CHANGED | BLOCK_FOR_UPDATE))); + /* Assert that the block is in a file_blocks chain. */ + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); + /* Assert that the block is not in the LRU ring. */ + DBUG_ASSERT(!block->next_used && !block->prev_used); + /* + IMHO the below condition (if()) makes no sense. I can't see how it + could be possible that free_block() is entered with a NULL hash_link + pointer. The only place where it can become NULL is in free_block() + (or before its first use ever, but for those blocks free_block() is + not called). I don't remove the conditional as it cannot harm, but + place an DBUG_ASSERT to confirm my hypothesis. Eventually the + condition (if()) can be removed. + */ + DBUG_ASSERT(block->hash_link && block->hash_link->block == block); if (block->hash_link) { /* @@ -2211,24 +3381,81 @@ static void free_block(KEY_CACHE *keycache, BLOCK_LINK *block) */ block->status|= BLOCK_REASSIGNED; wait_for_readers(keycache, block); - unlink_hash(keycache, block->hash_link); + /* + The block must not have been freed by another thread. Repeat some + checks. An additional requirement is that it must be read now + (BLOCK_READ). + */ + DBUG_ASSERT(block->hash_link && block->hash_link->block == block); + DBUG_ASSERT((block->status & (BLOCK_READ | BLOCK_IN_USE | + BLOCK_REASSIGNED)) && + !(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH | + BLOCK_IN_FLUSH | BLOCK_CHANGED | + BLOCK_FOR_UPDATE))); + DBUG_ASSERT(block->prev_changed && *block->prev_changed == block); + DBUG_ASSERT(!block->prev_used); + /* + Unset BLOCK_REASSIGNED again. If we hand the block to an evicting + thread (through unreg_request() below), other threads must not see + this flag. They could become confused. + */ + block->status&= ~BLOCK_REASSIGNED; + /* + Do not release the hash_link until the block is off all lists. + At least not if we hand it over for eviction in unreg_request(). + */ } + /* + Unregister the block request and link the block into the LRU ring. + This enables eviction for the block. If the LRU ring was empty and + threads are waiting for a block, then the block wil be handed over + for eviction immediately. Otherwise we will unlink it from the LRU + ring again, without releasing the lock in between. So decrementing + the request counter and updating statistics are the only relevant + operation in this case. Assert that there are no other requests + registered. + */ + DBUG_ASSERT(block->requests == 1); + unreg_request(keycache, block, 0); + /* + Note that even without releasing the cache lock it is possible that + the block is immediately selected for eviction by link_block() and + thus not added to the LRU ring. In this case we must not touch the + block any more. + */ + if (block->status & BLOCK_IN_EVICTION) + return; + + /* Error blocks are not put into the LRU ring. */ + if (!(block->status & BLOCK_ERROR)) + { + /* Here the block must be in the LRU ring. Unlink it again. */ + DBUG_ASSERT(block->next_used && block->prev_used && + *block->prev_used == block); + unlink_block(keycache, block); + } + if (block->temperature == BLOCK_WARM) + keycache->warm_blocks--; + block->temperature= BLOCK_COLD; + + /* Remove from file_blocks hash. */ unlink_changed(block); + + /* Remove reference to block from hash table. */ + unlink_hash(keycache, block->hash_link); + block->hash_link= NULL; + block->status= 0; block->length= 0; block->offset= keycache->key_cache_block_size; KEYCACHE_THREAD_TRACE("free block"); - KEYCACHE_DBUG_PRINT("free_block", - ("block is freed")); - unreg_request(keycache, block, 0); - block->hash_link= NULL; + KEYCACHE_DBUG_PRINT("free_block", ("block is freed")); - /* Remove the free block from the LRU ring. */ - unlink_block(keycache, block); - if (block->temperature == BLOCK_WARM) - keycache->warm_blocks--; - block->temperature= BLOCK_COLD; + /* Enforced by unlink_changed(), but just to be sure. */ + DBUG_ASSERT(!block->next_changed && !block->prev_changed); + /* Enforced by unlink_block(): not in LRU ring nor in free_block_list. */ + DBUG_ASSERT(!block->next_used && !block->prev_used); /* Insert the free block in the free list. */ block->next_used= keycache->free_block_list; keycache->free_block_list= block; @@ -2236,8 +3463,7 @@ static void free_block(KEY_CACHE *keycache, BLOCK_LINK *block) keycache->blocks_unused++; /* All pending requests for this page must be resubmitted. */ - if (block->wqueue[COND_FOR_SAVED].last_thread) - release_queue(&block->wqueue[COND_FOR_SAVED]); + release_whole_queue(&block->wqueue[COND_FOR_SAVED]); } @@ -2271,54 +3497,97 @@ static int flush_cached_blocks(KEY_CACHE *keycache, my_qsort((byte*) cache, count, sizeof(*cache), (qsort_cmp) cmp_sec_link); keycache_pthread_mutex_lock(&keycache->cache_lock); + /* + Note: Do not break the loop. We have registered a request on every + block in 'cache'. These must be unregistered by free_block() or + unreg_request(). + */ for ( ; cache != end ; cache++) { BLOCK_LINK *block= *cache; KEYCACHE_DBUG_PRINT("flush_cached_blocks", ("block %u to be flushed", BLOCK_NUMBER(block))); - keycache_pthread_mutex_unlock(&keycache->cache_lock); - error= my_pwrite(file, - block->buffer+block->offset, - block->length - block->offset, - block->hash_link->diskpos+ block->offset, - MYF(MY_NABP | MY_WAIT_IF_FULL)); - keycache_pthread_mutex_lock(&keycache->cache_lock); - keycache->global_cache_write++; - if (error) + /* + If the block contents is going to be changed, we abandon the flush + for this block. flush_key_blocks_int() will restart its search and + handle the block properly. + */ + if (!(block->status & BLOCK_FOR_UPDATE)) { - block->status|= BLOCK_ERROR; - if (!last_errno) - last_errno= errno ? errno : -1; + /* Blocks coming here must have a certain status. */ + DBUG_ASSERT(block->hash_link); + DBUG_ASSERT(block->hash_link->block == block); + DBUG_ASSERT(block->hash_link->file == file); + DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) == + (BLOCK_READ | BLOCK_IN_FLUSH | BLOCK_CHANGED | BLOCK_IN_USE)); + block->status|= BLOCK_IN_FLUSHWRITE; + keycache_pthread_mutex_unlock(&keycache->cache_lock); + error= my_pwrite(file, block->buffer+block->offset, + block->length - block->offset, + block->hash_link->diskpos+ block->offset, + MYF(MY_NABP | MY_WAIT_IF_FULL)); + keycache_pthread_mutex_lock(&keycache->cache_lock); + keycache->global_cache_write++; + if (error) + { + block->status|= BLOCK_ERROR; + if (!last_errno) + last_errno= errno ? errno : -1; + } + block->status&= ~BLOCK_IN_FLUSHWRITE; + /* Block must not have changed status except BLOCK_FOR_UPDATE. */ + DBUG_ASSERT(block->hash_link); + DBUG_ASSERT(block->hash_link->block == block); + DBUG_ASSERT(block->hash_link->file == file); + DBUG_ASSERT((block->status & ~(BLOCK_FOR_UPDATE | BLOCK_IN_EVICTION)) == + (BLOCK_READ | BLOCK_IN_FLUSH | BLOCK_CHANGED | BLOCK_IN_USE)); + /* + Set correct status and link in right queue for free or later use. + free_block() must not see BLOCK_CHANGED and it may need to wait + for readers of the block. These should not see the block in the + wrong hash. If not freeing the block, we need to have it in the + right queue anyway. + */ + link_to_file_list(keycache, block, file, 1); } + block->status&= ~BLOCK_IN_FLUSH; /* Let to proceed for possible waiting requests to write to the block page. It might happen only during an operation to resize the key cache. */ - if (block->wqueue[COND_FOR_SAVED].last_thread) - release_queue(&block->wqueue[COND_FOR_SAVED]); + release_whole_queue(&block->wqueue[COND_FOR_SAVED]); /* type will never be FLUSH_IGNORE_CHANGED here */ - if (! (type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE)) + if (!(type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE) && + !(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH | + BLOCK_FOR_UPDATE))) { - keycache->blocks_changed--; - keycache->global_blocks_changed--; + /* + Note that a request has been registered against the block in + flush_key_blocks_int(). + */ free_block(keycache, block); } else { - block->status&= ~BLOCK_IN_FLUSH; - link_to_file_list(keycache, block, file, 1); + /* + Link the block into the LRU ring if it's the last submitted + request for the block. This enables eviction for the block. + Note that a request has been registered against the block in + flush_key_blocks_int(). + */ unreg_request(keycache, block, 1); } - } + } /* end of for ( ; cache != end ; cache++) */ return last_errno; } /* - flush all key blocks for a file to disk, but don't do any mutex locks + Flush all key blocks for a file to disk, but don't do any mutex locks. + SYNOPSIS flush_key_blocks_int() keycache pointer to a key cache data structure file handler for the file to flush to @@ -2329,6 +3598,10 @@ static int flush_cached_blocks(KEY_CACHE *keycache, from flush_key_blocks and flush_all_key_blocks (the later one does the mutex lock in the resize_key_cache() function). + We do only care about changed blocks that exist when the function is + entered. We do not guarantee that all changed blocks of the file are + flushed if more blocks change while this function is running. + RETURN 0 ok 1 error @@ -2339,13 +3612,14 @@ static int flush_key_blocks_int(KEY_CACHE *keycache, { BLOCK_LINK *cache_buff[FLUSH_CACHE],**cache; int last_errno= 0; + int last_errcnt= 0; DBUG_ENTER("flush_key_blocks_int"); DBUG_PRINT("enter",("file: %d blocks_used: %lu blocks_changed: %lu", file, keycache->blocks_used, keycache->blocks_changed)); #if !defined(DBUG_OFF) && defined(EXTRA_DEBUG) - DBUG_EXECUTE("check_keycache", - test_key_cache(keycache, "start of flush_key_blocks", 0);); + DBUG_EXECUTE("check_keycache", + test_key_cache(keycache, "start of flush_key_blocks", 0);); #endif cache= cache_buff; @@ -2354,9 +3628,11 @@ static int flush_key_blocks_int(KEY_CACHE *keycache, { /* Key cache exists and flush is not disabled */ int error= 0; - uint count= 0; + uint count= FLUSH_CACHE; BLOCK_LINK **pos,**end; BLOCK_LINK *first_in_switch= NULL; + BLOCK_LINK *last_in_flush; + BLOCK_LINK *last_for_update; BLOCK_LINK *block, *next; #if defined(KEYCACHE_DEBUG) uint cnt=0; @@ -2368,28 +3644,39 @@ static int flush_key_blocks_int(KEY_CACHE *keycache, Count how many key blocks we have to cache to be able to flush all dirty pages with minimum seek moves */ + count= 0; for (block= keycache->changed_blocks[FILE_HASH(file)] ; block ; block= block->next_changed) { - if (block->hash_link->file == file) + if ((block->hash_link->file == file) && + !(block->status & BLOCK_IN_FLUSH)) { count++; KEYCACHE_DBUG_ASSERT(count<= keycache->blocks_used); } } - /* Allocate a new buffer only if its bigger than the one we have */ - if (count > FLUSH_CACHE && + /* + Allocate a new buffer only if its bigger than the one we have. + Assure that we always have some entries for the case that new + changed blocks appear while we need to wait for something. + */ + if ((count > FLUSH_CACHE) && !(cache= (BLOCK_LINK**) my_malloc(sizeof(BLOCK_LINK*)*count, MYF(0)))) - { cache= cache_buff; + /* + After a restart there could be more changed blocks than now. + So we should not let count become smaller than the fixed buffer. + */ + if (cache == cache_buff) count= FLUSH_CACHE; - } } /* Retrieve the blocks and write them to a buffer to be flushed */ restart: + last_in_flush= NULL; + last_for_update= NULL; end= (pos= cache)+count; for (block= keycache->changed_blocks[FILE_HASH(file)] ; block ; @@ -2402,121 +3689,350 @@ restart: next= block->next_changed; if (block->hash_link->file == file) { - /* - Mark the block with BLOCK_IN_FLUSH in order not to let - other threads to use it for new pages and interfere with - our sequence ot flushing dirty file pages - */ - block->status|= BLOCK_IN_FLUSH; - - if (! (block->status & BLOCK_IN_SWITCH)) + if (!(block->status & (BLOCK_IN_FLUSH | BLOCK_FOR_UPDATE))) { - /* - We care only for the blocks for which flushing was not - initiated by other threads as a result of page swapping + /* + Note: The special handling of BLOCK_IN_SWITCH is obsolete + since we set BLOCK_IN_FLUSH if the eviction includes a + flush. It can be removed in a later version. */ - reg_requests(keycache, block, 1); - if (type != FLUSH_IGNORE_CHANGED) + if (!(block->status & BLOCK_IN_SWITCH)) { - /* It's not a temporary file */ - if (pos == end) + /* + We care only for the blocks for which flushing was not + initiated by another thread and which are not in eviction. + Registering a request on the block unlinks it from the LRU + ring and protects against eviction. + */ + reg_requests(keycache, block, 1); + if (type != FLUSH_IGNORE_CHANGED) { - /* - This happens only if there is not enough - memory for the big block - */ - if ((error= flush_cached_blocks(keycache, file, cache, - end,type))) - last_errno=error; + /* It's not a temporary file */ + if (pos == end) + { + /* + This should happen relatively seldom. Remove the + request because we won't do anything with the block + but restart and pick it again in the next iteration. + */ + unreg_request(keycache, block, 0); + /* + This happens only if there is not enough + memory for the big block + */ + if ((error= flush_cached_blocks(keycache, file, cache, + end,type))) + { + /* Do not loop infinitely trying to flush in vain. */ + if ((last_errno == error) && (++last_errcnt > 5)) + goto err; + last_errno= error; + } + /* + Restart the scan as some other thread might have changed + the changed blocks chain: the blocks that were in switch + state before the flush started have to be excluded + */ + goto restart; + } /* - Restart the scan as some other thread might have changed - the changed blocks chain: the blocks that were in switch - state before the flush started have to be excluded + Mark the block with BLOCK_IN_FLUSH in order not to let + other threads to use it for new pages and interfere with + our sequence of flushing dirty file pages. We must not + set this flag before actually putting the block on the + write burst array called 'cache'. */ - goto restart; + block->status|= BLOCK_IN_FLUSH; + /* Add block to the array for a write burst. */ + *pos++= block; + } + else + { + /* It's a temporary file */ + DBUG_ASSERT(!(block->status & BLOCK_REASSIGNED)); + /* + free_block() must not be called with BLOCK_CHANGED. Note + that we must not change the BLOCK_CHANGED flag outside of + link_to_file_list() so that it is always in the correct + queue and the *blocks_changed counters are correct. + */ + link_to_file_list(keycache, block, file, 1); + if (!(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH))) + { + /* A request has been registered against the block above. */ + free_block(keycache, block); + } + else + { + /* + Link the block into the LRU ring if it's the last + submitted request for the block. This enables eviction + for the block. A request has been registered against + the block above. + */ + unreg_request(keycache, block, 1); + } } - *pos++= block; } else { - /* It's a temporary file */ - keycache->blocks_changed--; - keycache->global_blocks_changed--; - free_block(keycache, block); + /* + Link the block into a list of blocks 'in switch'. + + WARNING: Here we introduce a place where a changed block + is not in the changed_blocks hash! This is acceptable for + a BLOCK_IN_SWITCH. Never try this for another situation. + Other parts of the key cache code rely on changed blocks + being in the changed_blocks hash. + */ + unlink_changed(block); + link_changed(block, &first_in_switch); } } - else + else if (type != FLUSH_KEEP) { - /* Link the block into a list of blocks 'in switch' */ - unlink_changed(block); - link_changed(block, &first_in_switch); + /* + During the normal flush at end of statement (FLUSH_KEEP) we + do not need to ensure that blocks in flush or update by + other threads are flushed. They will be flushed by them + later. In all other cases we must assure that we do not have + any changed block of this file in the cache when this + function returns. + */ + if (block->status & BLOCK_IN_FLUSH) + { + /* Remember the last block found to be in flush. */ + last_in_flush= block; + } + else + { + /* Remember the last block found to be selected for update. */ + last_for_update= block; + } } } } if (pos != cache) { if ((error= flush_cached_blocks(keycache, file, cache, pos, type))) + { + /* Do not loop inifnitely trying to flush in vain. */ + if ((last_errno == error) && (++last_errcnt > 5)) + goto err; last_errno= error; + } + /* + Do not restart here during the normal flush at end of statement + (FLUSH_KEEP). We have now flushed at least all blocks that were + changed when entering this function. In all other cases we must + assure that we do not have any changed block of this file in the + cache when this function returns. + */ + if (type != FLUSH_KEEP) + goto restart; } - /* Wait until list of blocks in switch is empty */ + if (last_in_flush) + { + /* + There are no blocks to be flushed by this thread, but blocks in + flush by other threads. Wait until one of the blocks is flushed. + Re-check the condition for last_in_flush. We may have unlocked + the cache_lock in flush_cached_blocks(). The state of the block + could have changed. + */ + if (last_in_flush->status & BLOCK_IN_FLUSH) + wait_on_queue(&last_in_flush->wqueue[COND_FOR_SAVED], + &keycache->cache_lock); + /* Be sure not to lose a block. They may be flushed in random order. */ + goto restart; + } + if (last_for_update) + { + /* + There are no blocks to be flushed by this thread, but blocks for + update by other threads. Wait until one of the blocks is updated. + Re-check the condition for last_for_update. We may have unlocked + the cache_lock in flush_cached_blocks(). The state of the block + could have changed. + */ + if (last_for_update->status & BLOCK_FOR_UPDATE) + wait_on_queue(&last_for_update->wqueue[COND_FOR_REQUESTED], + &keycache->cache_lock); + /* The block is now changed. Flush it. */ + goto restart; + } + + /* + Wait until the list of blocks in switch is empty. The threads that + are switching these blocks will relink them to clean file chains + while we wait and thus empty the 'first_in_switch' chain. + */ while (first_in_switch) { #if defined(KEYCACHE_DEBUG) cnt= 0; #endif - block= first_in_switch; - { -#ifdef THREAD - struct st_my_thread_var *thread= my_thread_var; - add_to_queue(&block->wqueue[COND_FOR_SAVED], thread); - do - { - KEYCACHE_DBUG_PRINT("flush_key_blocks_int: wait", - ("suspend thread %ld", thread->id)); - keycache_pthread_cond_wait(&thread->suspend, - &keycache->cache_lock); - } - while (thread->next); -#else - KEYCACHE_DBUG_ASSERT(0); - /* No parallel requests in single-threaded case */ -#endif - } + wait_on_queue(&first_in_switch->wqueue[COND_FOR_SAVED], + &keycache->cache_lock); #if defined(KEYCACHE_DEBUG) cnt++; KEYCACHE_DBUG_ASSERT(cnt <= keycache->blocks_used); #endif + /* + Do not restart here. We have flushed all blocks that were + changed when entering this function and were not marked for + eviction. Other threads have now flushed all remaining blocks in + the course of their eviction. + */ } - /* The following happens very seldom */ + if (! (type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE)) { -#if defined(KEYCACHE_DEBUG) - cnt=0; -#endif - for (block= keycache->file_blocks[FILE_HASH(file)] ; - block ; - block= next) + BLOCK_LINK *last_for_update= NULL; + BLOCK_LINK *last_in_switch= NULL; + uint total_found= 0; + uint found; + + /* + Finally free all clean blocks for this file. + During resize this may be run by two threads in parallel. + */ + do { -#if defined(KEYCACHE_DEBUG) - cnt++; - KEYCACHE_DBUG_ASSERT(cnt <= keycache->blocks_used); -#endif - next= block->next_changed; - if (block->hash_link->file == file && - (! (block->status & BLOCK_CHANGED) - || type == FLUSH_IGNORE_CHANGED)) + found= 0; + for (block= keycache->file_blocks[FILE_HASH(file)] ; + block ; + block= next) { - reg_requests(keycache, block, 1); - free_block(keycache, block); - } + /* Remember the next block. After freeing we cannot get at it. */ + next= block->next_changed; + + /* Changed blocks cannot appear in the file_blocks hash. */ + DBUG_ASSERT(!(block->status & BLOCK_CHANGED)); + if (block->hash_link->file == file) + { + /* We must skip blocks that will be changed. */ + if (block->status & BLOCK_FOR_UPDATE) + { + last_for_update= block; + continue; + } + + /* + We must not free blocks in eviction (BLOCK_IN_EVICTION | + BLOCK_IN_SWITCH) or blocks intended to be freed + (BLOCK_REASSIGNED). + */ + if (!(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH | + BLOCK_REASSIGNED))) + { + struct st_hash_link *next_hash_link; + my_off_t next_diskpos; + File next_file; + uint next_status; + uint hash_requests; + + total_found++; + found++; + KEYCACHE_DBUG_ASSERT(found <= keycache->blocks_used); + + /* + Register a request. This unlinks the block from the LRU + ring and protects it against eviction. This is required + by free_block(). + */ + reg_requests(keycache, block, 1); + + /* + free_block() may need to wait for readers of the block. + This is the moment where the other thread can move the + 'next' block from the chain. free_block() needs to wait + if there are requests for the block pending. + */ + if (next && (hash_requests= block->hash_link->requests)) + { + /* Copy values from the 'next' block and its hash_link. */ + next_status= next->status; + next_hash_link= next->hash_link; + next_diskpos= next_hash_link->diskpos; + next_file= next_hash_link->file; + DBUG_ASSERT(next == next_hash_link->block); + } + + free_block(keycache, block); + /* + If we had to wait and the state of the 'next' block + changed, break the inner loop. 'next' may no longer be + part of the current chain. + + We do not want to break the loop after every free_block(), + not even only after waits. The chain might be quite long + and contain blocks for many files. Traversing it again and + again to find more blocks for this file could become quite + inefficient. + */ + if (next && hash_requests && + ((next_status != next->status) || + (next_hash_link != next->hash_link) || + (next_file != next_hash_link->file) || + (next_diskpos != next_hash_link->diskpos) || + (next != next_hash_link->block))) + break; + } + else + { + last_in_switch= block; + } + } + } /* end for block in file_blocks */ + } while (found); + + /* + If any clean block has been found, we may have waited for it to + become free. In this case it could be possible that another clean + block became dirty. This is possible if the write request existed + before the flush started (BLOCK_FOR_UPDATE). Re-check the hashes. + */ + if (total_found) + goto restart; + + /* + To avoid an infinite loop, wait until one of the blocks marked + for update is updated. + */ + if (last_for_update) + { + /* We did not wait. Block must not have changed status. */ + DBUG_ASSERT(last_for_update->status & BLOCK_FOR_UPDATE); + wait_on_queue(&last_for_update->wqueue[COND_FOR_REQUESTED], + &keycache->cache_lock); + goto restart; } - } - } + + /* + To avoid an infinite loop wait until one of the blocks marked + for eviction is switched. + */ + if (last_in_switch) + { + /* We did not wait. Block must not have changed status. */ + DBUG_ASSERT(last_in_switch->status & (BLOCK_IN_EVICTION | + BLOCK_IN_SWITCH | + BLOCK_REASSIGNED)); + wait_on_queue(&last_in_switch->wqueue[COND_FOR_SAVED], + &keycache->cache_lock); + goto restart; + } + + } /* if (! (type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE)) */ + + } /* if (keycache->disk_blocks > 0 */ #ifndef DBUG_OFF DBUG_EXECUTE("check_keycache", test_key_cache(keycache, "end of flush_key_blocks", 0);); #endif +err: if (cache != cache_buff) my_free((gptr) cache, MYF(0)); if (last_errno) @@ -2543,51 +4059,157 @@ restart: int flush_key_blocks(KEY_CACHE *keycache, File file, enum flush_type type) { - int res; + int res= 0; DBUG_ENTER("flush_key_blocks"); DBUG_PRINT("enter", ("keycache: 0x%lx", (long) keycache)); - if (keycache->disk_blocks <= 0) + if (!keycache->key_cache_inited) DBUG_RETURN(0); + keycache_pthread_mutex_lock(&keycache->cache_lock); - inc_counter_for_resize_op(keycache); - res= flush_key_blocks_int(keycache, file, type); - dec_counter_for_resize_op(keycache); + /* While waiting for lock, keycache could have been ended. */ + if (keycache->disk_blocks > 0) + { + inc_counter_for_resize_op(keycache); + res= flush_key_blocks_int(keycache, file, type); + dec_counter_for_resize_op(keycache); + } keycache_pthread_mutex_unlock(&keycache->cache_lock); DBUG_RETURN(res); } /* - Flush all blocks in the key cache to disk + Flush all blocks in the key cache to disk. + + SYNOPSIS + flush_all_key_blocks() + keycache pointer to key cache root structure + + DESCRIPTION + + Flushing of the whole key cache is done in two phases. + + 1. Flush all changed blocks, waiting for them if necessary. Loop + until there is no changed block left in the cache. + + 2. Free all clean blocks. Normally this means free all blocks. The + changed blocks were flushed in phase 1 and became clean. However we + may need to wait for blocks that are read by other threads. While we + wait, a clean block could become changed if that operation started + before the resize operation started. To be safe we must restart at + phase 1. + + When we can run through the changed_blocks and file_blocks hashes + without finding a block any more, then we are done. + + Note that we hold keycache->cache_lock all the time unless we need + to wait for something. + + RETURN + 0 OK + != 0 Error */ static int flush_all_key_blocks(KEY_CACHE *keycache) { -#if defined(KEYCACHE_DEBUG) - uint cnt=0; -#endif - while (keycache->blocks_changed > 0) + BLOCK_LINK *block; + uint total_found; + uint found; + uint idx; + DBUG_ENTER("flush_all_key_blocks"); + + do { - BLOCK_LINK *block; - for (block= keycache->used_last->next_used ; ; block=block->next_used) + safe_mutex_assert_owner(&keycache->cache_lock); + total_found= 0; + + /* + Phase1: Flush all changed blocks, waiting for them if necessary. + Loop until there is no changed block left in the cache. + */ + do { - if (block->hash_link) + found= 0; + /* Step over the whole changed_blocks hash array. */ + for (idx= 0; idx < CHANGED_BLOCKS_HASH; idx++) { -#if defined(KEYCACHE_DEBUG) - cnt++; - KEYCACHE_DBUG_ASSERT(cnt <= keycache->blocks_used); -#endif - if (flush_key_blocks_int(keycache, block->hash_link->file, - FLUSH_RELEASE)) - return 1; - break; + /* + If an array element is non-empty, use the first block from its + chain to find a file for flush. All changed blocks for this + file are flushed. So the same block will not appear at this + place again with the next iteration. New writes for blocks are + not accepted during the flush. If multiple files share the + same hash bucket, one of them will be flushed per iteration + of the outer loop of phase 1. + */ + if ((block= keycache->changed_blocks[idx])) + { + found++; + /* + Flush dirty blocks but do not free them yet. They can be used + for reading until all other blocks are flushed too. + */ + if (flush_key_blocks_int(keycache, block->hash_link->file, + FLUSH_FORCE_WRITE)) + DBUG_RETURN(1); + } } - if (block == keycache->used_last) - break; - } + + } while (found); + + /* + Phase 2: Free all clean blocks. Normally this means free all + blocks. The changed blocks were flushed in phase 1 and became + clean. However we may need to wait for blocks that are read by + other threads. While we wait, a clean block could become changed + if that operation started before the resize operation started. To + be safe we must restart at phase 1. + */ + do + { + found= 0; + /* Step over the whole file_blocks hash array. */ + for (idx= 0; idx < CHANGED_BLOCKS_HASH; idx++) + { + /* + If an array element is non-empty, use the first block from its + chain to find a file for flush. All blocks for this file are + freed. So the same block will not appear at this place again + with the next iteration. If multiple files share the + same hash bucket, one of them will be flushed per iteration + of the outer loop of phase 2. + */ + if ((block= keycache->file_blocks[idx])) + { + total_found++; + found++; + if (flush_key_blocks_int(keycache, block->hash_link->file, + FLUSH_RELEASE)) + DBUG_RETURN(1); + } + } + + } while (found); + + /* + If any clean block has been found, we may have waited for it to + become free. In this case it could be possible that another clean + block became dirty. This is possible if the write request existed + before the resize started (BLOCK_FOR_UPDATE). Re-check the hashes. + */ + } while (total_found); + +#ifndef DBUG_OFF + /* Now there should not exist any block any more. */ + for (idx= 0; idx < CHANGED_BLOCKS_HASH; idx++) + { + DBUG_ASSERT(!keycache->changed_blocks[idx]); + DBUG_ASSERT(!keycache->file_blocks[idx]); } - return 0; +#endif + + DBUG_RETURN(0); } @@ -2838,8 +4460,8 @@ static void keycache_debug_print(const char * fmt,...) va_start(args,fmt); if (keycache_debug_log) { - VOID(vfprintf(keycache_debug_log, fmt, args)); - VOID(fputc('\n',keycache_debug_log)); + (void) vfprintf(keycache_debug_log, fmt, args); + (void) fputc('\n',keycache_debug_log); } va_end(args); } @@ -2856,3 +4478,70 @@ void keycache_debug_log_close(void) #endif /* defined(KEYCACHE_DEBUG_LOG) */ #endif /* defined(KEYCACHE_DEBUG) */ + +#if !defined(DBUG_OFF) +#define F_B_PRT(_f_, _v_) DBUG_PRINT("assert_fail", (_f_, _v_)) + +static int fail_block(BLOCK_LINK *block) +{ + F_B_PRT("block->next_used: %lx\n", (ulong) block->next_used); + F_B_PRT("block->prev_used: %lx\n", (ulong) block->prev_used); + F_B_PRT("block->next_changed: %lx\n", (ulong) block->next_changed); + F_B_PRT("block->prev_changed: %lx\n", (ulong) block->prev_changed); + F_B_PRT("block->hash_link: %lx\n", (ulong) block->hash_link); + F_B_PRT("block->status: %u\n", block->status); + F_B_PRT("block->length: %u\n", block->length); + F_B_PRT("block->offset: %u\n", block->offset); + F_B_PRT("block->requests: %u\n", block->requests); + F_B_PRT("block->temperature: %u\n", block->temperature); + return 0; /* Let the assert fail. */ +} + +static int fail_hlink(HASH_LINK *hlink) +{ + F_B_PRT("hlink->next: %lx\n", (ulong) hlink->next); + F_B_PRT("hlink->prev: %lx\n", (ulong) hlink->prev); + F_B_PRT("hlink->block: %lx\n", (ulong) hlink->block); + F_B_PRT("hlink->diskpos: %lu\n", (ulong) hlink->diskpos); + F_B_PRT("hlink->file: %d\n", hlink->file); + return 0; /* Let the assert fail. */ +} + +static int cache_empty(KEY_CACHE *keycache) +{ + int errcnt= 0; + int idx; + if (keycache->disk_blocks <= 0) + return 1; + for (idx= 0; idx < keycache->disk_blocks; idx++) + { + BLOCK_LINK *block= keycache->block_root + idx; + if (block->status || block->requests || block->hash_link) + { + fprintf(stderr, "block index: %u\n", idx); + fail_block(block); + errcnt++; + } + } + for (idx= 0; idx < keycache->hash_links; idx++) + { + HASH_LINK *hash_link= keycache->hash_link_root + idx; + if (hash_link->requests || hash_link->block) + { + fprintf(stderr, "hash_link index: %u\n", idx); + fail_hlink(hash_link); + errcnt++; + } + } + if (errcnt) + { + fprintf(stderr, "blocks: %d used: %lu\n", + keycache->disk_blocks, keycache->blocks_used); + fprintf(stderr, "hash_links: %d used: %d\n", + keycache->hash_links, keycache->hash_links_used); + fprintf(stderr, "\n"); + } + return !errcnt; +} +#endif + diff --git a/mysys/my_static.c b/mysys/my_static.c index 1858d830f41..23e37c53f98 100644 --- a/mysys/my_static.c +++ b/mysys/my_static.c @@ -48,9 +48,6 @@ struct st_remember _my_sig_remember[MAX_SIGNALS]={{0,0}}; sigset_t my_signals; /* signals blocked by mf_brkhant */ #endif - /* from mf_keycache.c */ -my_bool key_cache_inited=0; - /* from mf_reccache.c */ ulong my_default_record_cache_size=RECORD_CACHE_SIZE; diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc index dfd739f6db8..a92e7bbb9fd 100644 --- a/sql/ha_myisam.cc +++ b/sql/ha_myisam.cc @@ -1189,6 +1189,7 @@ int ha_myisam::preload_keys(THD* thd, HA_CHECK_OPT *check_opt) ulonglong map= ~(ulonglong) 0; TABLE_LIST *table_list= table->pos_in_table_list; my_bool ignore_leaves= table_list->ignore_leaves; + char buf[ERRMSGSIZE+20]; DBUG_ENTER("ha_myisam::preload_keys"); @@ -1216,7 +1217,6 @@ int ha_myisam::preload_keys(THD* thd, HA_CHECK_OPT *check_opt) errmsg= "Failed to allocate buffer"; break; default: - char buf[ERRMSGSIZE+20]; my_snprintf(buf, ERRMSGSIZE, "Failed to read from index file (errno: %d)", my_errno); errmsg= buf; diff --git a/sql/sql_table.cc b/sql/sql_table.cc index 5a3100685e0..e32c17bc678 100644 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@ -2741,8 +2741,13 @@ int reassign_keycache_tables(THD *thd, KEY_CACHE *src_cache, bool mysql_preload_keys(THD* thd, TABLE_LIST* tables) { DBUG_ENTER("mysql_preload_keys"); + /* + We cannot allow concurrent inserts. The storage engine reads + directly from the index file, bypassing the cache. It could read + outdated information if parallel inserts into cache blocks happen. + */ DBUG_RETURN(mysql_admin_table(thd, tables, 0, - "preload_keys", TL_READ, 0, 0, 0, 0, + "preload_keys", TL_READ_NO_INSERT, 0, 0, 0, 0, &handler::preload_keys, 0)); } From bd1038fecbe8d7bab304bc5a4c1416be1e31bea0 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 8 Sep 2009 22:56:00 +0200 Subject: [PATCH 03/13] Raise version number after cloning 5.0.86 --- configure.in | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/configure.in b/configure.in index a70bb3ca27f..523ac01c6f3 100644 --- a/configure.in +++ b/configure.in @@ -7,7 +7,7 @@ AC_INIT(sql/mysqld.cc) AC_CANONICAL_SYSTEM # The Docs Makefile.am parses this line! # remember to also change ndb version below and update version.c in ndb -AM_INIT_AUTOMAKE(mysql, 5.0.86) +AM_INIT_AUTOMAKE(mysql, 5.0.87) AM_CONFIG_HEADER([include/config.h:config.h.in]) PROTOCOL_VERSION=10 @@ -23,7 +23,7 @@ NDB_SHARED_LIB_VERSION=$NDB_SHARED_LIB_MAJOR_VERSION:0:0 # ndb version NDB_VERSION_MAJOR=5 NDB_VERSION_MINOR=0 -NDB_VERSION_BUILD=86 +NDB_VERSION_BUILD=87 NDB_VERSION_STATUS="" # Set all version vars based on $VERSION. How do we do this more elegant ? From 24f103e39c100d0ca4fa4a4777fe82cd6d69034b Mon Sep 17 00:00:00 2001 From: Georgi Kodinov Date: Wed, 9 Sep 2009 12:06:15 +0300 Subject: [PATCH 04/13] Bug #45159 Part 1 : rejuvenate the jp test suite using normal run. Updates the results of all the out-dated test suites and adds the special mysqltest command to enable innodb for the tests that need it. --- mysql-test/suite/jp/r/jp_alter_sjis.result | 78 ++--- mysql-test/suite/jp/r/jp_alter_ucs2.result | 78 ++--- mysql-test/suite/jp/r/jp_alter_ujis.result | 78 ++--- mysql-test/suite/jp/r/jp_alter_utf8.result | 78 ++--- mysql-test/suite/jp/r/jp_convert_sjis.result | 12 + .../suite/jp/r/jp_create_db_sjis.result | 1 + .../suite/jp/r/jp_create_db_ucs2.result | 1 + .../suite/jp/r/jp_create_db_ujis.result | 1 + .../suite/jp/r/jp_create_db_utf8.result | 1 + .../suite/jp/r/jp_create_tbl_sjis.result | 78 ++++- .../suite/jp/r/jp_create_tbl_ucs2.result | 78 ++++- .../suite/jp/r/jp_create_tbl_ujis.result | 78 ++++- .../suite/jp/r/jp_create_tbl_utf8.result | 78 ++++- mysql-test/suite/jp/r/jp_enum_sjis.result | 60 ++-- mysql-test/suite/jp/r/jp_enum_ucs2.result | 6 +- mysql-test/suite/jp/r/jp_enum_ujis.result | 60 ++-- mysql-test/suite/jp/r/jp_enum_utf8.result | 60 ++-- mysql-test/suite/jp/r/jp_join_sjis.result | 288 +++++++++--------- mysql-test/suite/jp/r/jp_join_ucs2.result | 288 +++++++++--------- mysql-test/suite/jp/r/jp_join_ujis.result | 288 +++++++++--------- mysql-test/suite/jp/r/jp_join_utf8.result | 288 +++++++++--------- mysql-test/suite/jp/r/jp_select_sjis.result | 4 + mysql-test/suite/jp/t/jp_alter_sjis.test | 2 + mysql-test/suite/jp/t/jp_alter_ucs2.test | 2 + mysql-test/suite/jp/t/jp_alter_ujis.test | 2 + mysql-test/suite/jp/t/jp_alter_utf8.test | 2 + mysql-test/suite/jp/t/jp_charlength_sjis.test | 2 + mysql-test/suite/jp/t/jp_charlength_ucs2.test | 2 + mysql-test/suite/jp/t/jp_charlength_ujis.test | 2 + mysql-test/suite/jp/t/jp_charlength_utf8.test | 2 + mysql-test/suite/jp/t/jp_charset_sjis.test | 2 + mysql-test/suite/jp/t/jp_charset_ucs2.test | 2 + mysql-test/suite/jp/t/jp_charset_ujis.test | 2 + mysql-test/suite/jp/t/jp_charset_utf8.test | 2 + mysql-test/suite/jp/t/jp_convert_sjis.test | 2 + mysql-test/suite/jp/t/jp_convert_ucs2.test | 2 + mysql-test/suite/jp/t/jp_convert_ujis.test | 2 + mysql-test/suite/jp/t/jp_convert_utf8.test | 2 + mysql-test/suite/jp/t/jp_create_tbl_sjis.test | 2 + mysql-test/suite/jp/t/jp_create_tbl_ucs2.test | 2 + mysql-test/suite/jp/t/jp_create_tbl_ujis.test | 2 + mysql-test/suite/jp/t/jp_create_tbl_utf8.test | 2 + mysql-test/suite/jp/t/jp_enum_sjis.test | 2 + mysql-test/suite/jp/t/jp_enum_ucs2.test | 2 + mysql-test/suite/jp/t/jp_enum_ujis.test | 2 + mysql-test/suite/jp/t/jp_enum_utf8.test | 2 + mysql-test/suite/jp/t/jp_insert_sjis.test | 2 + mysql-test/suite/jp/t/jp_insert_ucs2.test | 2 + mysql-test/suite/jp/t/jp_insert_ujis.test | 2 + mysql-test/suite/jp/t/jp_insert_utf8.test | 2 + mysql-test/suite/jp/t/jp_instr_sjis.test | 2 + mysql-test/suite/jp/t/jp_instr_ucs2.test | 2 + mysql-test/suite/jp/t/jp_instr_ujis.test | 2 + mysql-test/suite/jp/t/jp_instr_utf8.test | 2 + mysql-test/suite/jp/t/jp_join_sjis.test | 1 + mysql-test/suite/jp/t/jp_join_ucs2.test | 1 + mysql-test/suite/jp/t/jp_join_ujis.test | 1 + mysql-test/suite/jp/t/jp_join_utf8.test | 1 + mysql-test/suite/jp/t/jp_left_sjis.test | 2 + mysql-test/suite/jp/t/jp_left_ucs2.test | 2 + mysql-test/suite/jp/t/jp_left_ujis.test | 2 + mysql-test/suite/jp/t/jp_left_utf8.test | 2 + mysql-test/suite/jp/t/jp_length_sjis.test | 2 + mysql-test/suite/jp/t/jp_length_ucs2.test | 2 + mysql-test/suite/jp/t/jp_length_ujis.test | 2 + mysql-test/suite/jp/t/jp_length_utf8.test | 2 + mysql-test/suite/jp/t/jp_like_sjis.test | 2 + mysql-test/suite/jp/t/jp_like_ucs2.test | 2 + mysql-test/suite/jp/t/jp_like_ujis.test | 2 + mysql-test/suite/jp/t/jp_like_utf8.test | 2 + mysql-test/suite/jp/t/jp_locate_sjis.test | 2 + mysql-test/suite/jp/t/jp_locate_ucs2.test | 2 + mysql-test/suite/jp/t/jp_locate_ujis.test | 2 + mysql-test/suite/jp/t/jp_locate_utf8.test | 2 + mysql-test/suite/jp/t/jp_lpad_sjis.test | 2 + mysql-test/suite/jp/t/jp_lpad_ucs2.test | 2 + mysql-test/suite/jp/t/jp_lpad_ujis.test | 2 + mysql-test/suite/jp/t/jp_lpad_utf8.test | 2 + mysql-test/suite/jp/t/jp_ltrim_sjis.test | 2 + mysql-test/suite/jp/t/jp_ltrim_ucs2.test | 2 + mysql-test/suite/jp/t/jp_ltrim_ujis.test | 2 + mysql-test/suite/jp/t/jp_ltrim_utf8.test | 2 + mysql-test/suite/jp/t/jp_ps_sjis.test | 2 + mysql-test/suite/jp/t/jp_ps_ujis.test | 2 + mysql-test/suite/jp/t/jp_replace_sjis.test | 2 + mysql-test/suite/jp/t/jp_replace_ucs2.test | 2 + mysql-test/suite/jp/t/jp_replace_ujis.test | 2 + mysql-test/suite/jp/t/jp_replace_utf8.test | 2 + mysql-test/suite/jp/t/jp_reverse_sjis.test | 2 + mysql-test/suite/jp/t/jp_reverse_ucs2.test | 2 + mysql-test/suite/jp/t/jp_reverse_ujis.test | 2 + mysql-test/suite/jp/t/jp_reverse_utf8.test | 2 + mysql-test/suite/jp/t/jp_right_sjis.test | 2 + mysql-test/suite/jp/t/jp_right_ucs2.test | 2 + mysql-test/suite/jp/t/jp_right_ujis.test | 2 + mysql-test/suite/jp/t/jp_right_utf8.test | 2 + mysql-test/suite/jp/t/jp_rpad_sjis.test | 2 + mysql-test/suite/jp/t/jp_rpad_ucs2.test | 2 + mysql-test/suite/jp/t/jp_rpad_ujis.test | 2 + mysql-test/suite/jp/t/jp_rpad_utf8.test | 2 + mysql-test/suite/jp/t/jp_rtrim_sjis.test | 2 + mysql-test/suite/jp/t/jp_rtrim_ucs2.test | 2 + mysql-test/suite/jp/t/jp_rtrim_ujis.test | 2 + mysql-test/suite/jp/t/jp_rtrim_utf8.test | 2 + mysql-test/suite/jp/t/jp_select_sjis.test | 2 + mysql-test/suite/jp/t/jp_select_ucs2.test | 2 + mysql-test/suite/jp/t/jp_select_ujis.test | 2 + mysql-test/suite/jp/t/jp_select_utf8.test | 2 + mysql-test/suite/jp/t/jp_subquery_sjis.test | 1 + mysql-test/suite/jp/t/jp_subquery_ucs2.test | 1 + mysql-test/suite/jp/t/jp_subquery_ujis.test | 1 + mysql-test/suite/jp/t/jp_subquery_utf8.test | 1 + mysql-test/suite/jp/t/jp_substring_sjis.test | 2 + mysql-test/suite/jp/t/jp_substring_ucs2.test | 2 + mysql-test/suite/jp/t/jp_substring_ujis.test | 2 + mysql-test/suite/jp/t/jp_substring_utf8.test | 2 + mysql-test/suite/jp/t/jp_trim_sjis.test | 2 + mysql-test/suite/jp/t/jp_trim_ucs2.test | 2 + mysql-test/suite/jp/t/jp_trim_ujis.test | 2 + mysql-test/suite/jp/t/jp_trim_utf8.test | 2 + mysql-test/suite/jp/t/jp_union_ujis.test | 2 + mysql-test/suite/jp/t/jp_update_sjis.test | 2 + mysql-test/suite/jp/t/jp_update_ucs2.test | 2 + mysql-test/suite/jp/t/jp_update_ujis.test | 2 + mysql-test/suite/jp/t/jp_update_utf8.test | 2 + mysql-test/suite/jp/t/jp_where_sjis.test | 2 + mysql-test/suite/jp/t/jp_where_ucs2.test | 2 + mysql-test/suite/jp/t/jp_where_ujis.test | 2 + mysql-test/suite/jp/t/jp_where_utf8.test | 2 + 129 files changed, 1303 insertions(+), 885 deletions(-) diff --git a/mysql-test/suite/jp/r/jp_alter_sjis.result b/mysql-test/suite/jp/r/jp_alter_sjis.result index f970508229a..32ae7d5729d 100644 --- a/mysql-test/suite/jp/r/jp_alter_sjis.result +++ b/mysql-test/suite/jp/r/jp_alter_sjis.result @@ -31,8 +31,8 @@ NULL DESC `北盽; Field Type Null Key Default Extra 抖 char(1) YES MUL NULL -贩 char(6) PRI -父 char(1) YES MUL NULL +贩 char(6) NO PRI +父 char(1) YES UNI NULL 构 char(1) YES NULL SHOW CREATE TABLE `北盽; Table Create Table @@ -58,7 +58,7 @@ SELECT * FROM ` 吵吵 DESC `北盽; Field Type Null Key Default Extra -贩 char(6) +贩 char(6) NO SHOW CREATE TABLE `北盽; Table Create Table 北 CREATE TABLE `北盽 ( @@ -80,8 +80,8 @@ NULL DESC `偁偁偁`; Field Type Null Key Default Extra 偐偐 char(1) YES MUL NULL -偒偒偒 char(6) PRI -偔偔偔 char(1) YES MUL NULL +偒偒偒 char(6) NO PRI +偔偔偔 char(1) YES UNI NULL 偗偗偗 char(1) YES NULL SHOW CREATE TABLE `偁偁偁`; Table Create Table @@ -107,7 +107,7 @@ SELECT * FROM ` 偆偆偆偆偆 DESC `偁偁偁`; Field Type Null Key Default Extra -偒偒偒 char(6) +偒偒偒 char(6) NO SHOW CREATE TABLE `偁偁偁`; Table Create Table 偁偁偁 CREATE TABLE `偁偁偁` ( @@ -129,8 +129,8 @@ NULL DESC `僜僜僜`; Field Type Null Key Default Extra 峔峔 char(1) YES MUL NULL -昞昞昞 char(6) PRI -擻擻擻 char(1) YES MUL NULL +昞昞昞 char(6) NO PRI +擻擻擻 char(1) YES UNI NULL 梊梊梊 char(1) YES NULL SHOW CREATE TABLE `僜僜僜`; Table Create Table @@ -156,7 +156,7 @@ SELECT * FROM ` 昞昞昞昞昞 DESC `僜僜僜`; Field Type Null Key Default Extra -昞昞昞 char(6) +昞昞昞 char(6) NO SHOW CREATE TABLE `僜僜僜`; Table Create Table 僜僜僜 CREATE TABLE `僜僜僜` ( @@ -193,8 +193,8 @@ NULL DESC `北盽; Field Type Null Key Default Extra 抖 char(1) YES MUL NULL -贩 char(6) PRI -父 char(1) YES MUL NULL +贩 char(6) NO PRI +父 char(1) YES UNI NULL 构 char(1) YES NULL SHOW CREATE TABLE `北盽; Table Create Table @@ -220,7 +220,7 @@ SELECT * FROM ` 吵吵 DESC `北盽; Field Type Null Key Default Extra -贩 char(6) +贩 char(6) NO SHOW CREATE TABLE `北盽; Table Create Table 北 CREATE TABLE `北盽 ( @@ -242,8 +242,8 @@ NULL DESC `偁偁偁`; Field Type Null Key Default Extra 偐偐 char(1) YES MUL NULL -偒偒偒 char(6) PRI -偔偔偔 char(1) YES MUL NULL +偒偒偒 char(6) NO PRI +偔偔偔 char(1) YES UNI NULL 偗偗偗 char(1) YES NULL SHOW CREATE TABLE `偁偁偁`; Table Create Table @@ -269,7 +269,7 @@ SELECT * FROM ` 偆偆偆偆偆 DESC `偁偁偁`; Field Type Null Key Default Extra -偒偒偒 char(6) +偒偒偒 char(6) NO SHOW CREATE TABLE `偁偁偁`; Table Create Table 偁偁偁 CREATE TABLE `偁偁偁` ( @@ -291,8 +291,8 @@ NULL DESC `僜僜僜`; Field Type Null Key Default Extra 峔峔 char(1) YES MUL NULL -昞昞昞 char(6) PRI -擻擻擻 char(1) YES MUL NULL +昞昞昞 char(6) NO PRI +擻擻擻 char(1) YES UNI NULL 梊梊梊 char(1) YES NULL SHOW CREATE TABLE `僜僜僜`; Table Create Table @@ -318,7 +318,7 @@ SELECT * FROM ` 擻擻擻擻擻 DESC `僜僜僜`; Field Type Null Key Default Extra -昞昞昞 char(6) +昞昞昞 char(6) NO SHOW CREATE TABLE `僜僜僜`; Table Create Table 僜僜僜 CREATE TABLE `僜僜僜` ( @@ -355,8 +355,8 @@ NULL DESC `北盽; Field Type Null Key Default Extra 抖 char(1) YES MUL NULL -贩 char(6) PRI -父 char(1) YES MUL NULL +贩 char(6) NO PRI +父 char(1) YES UNI NULL 构 char(1) YES NULL SHOW CREATE TABLE `北盽; Table Create Table @@ -368,7 +368,7 @@ Table Create Table PRIMARY KEY (`贩穈), UNIQUE KEY `父竊 (`父竊), KEY `抖禶 (`抖`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis ALTER TABLE `北盽 DROP INDEX `抖禶; ALTER TABLE `北盽 DROP PRIMARY KEY; ALTER TABLE `北盽 DROP INDEX `父竊; @@ -382,12 +382,12 @@ SELECT * FROM ` 吵吵 DESC `北盽; Field Type Null Key Default Extra -贩 char(6) +贩 char(6) NO SHOW CREATE TABLE `北盽; Table Create Table 北 CREATE TABLE `北盽 ( `贩穈 char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis ALTER TABLE `偁偁偁` ADD `偐偐偐` char(1) FIRST; ALTER TABLE `偁偁偁` ADD `偔偔偔` char(1) AFTER `偒偒偒`; ALTER TABLE `偁偁偁` ADD `偗偗偗` char(1); @@ -404,8 +404,8 @@ NULL DESC `偁偁偁`; Field Type Null Key Default Extra 偐偐 char(1) YES MUL NULL -偒偒偒 char(6) PRI -偔偔偔 char(1) YES MUL NULL +偒偒偒 char(6) NO PRI +偔偔偔 char(1) YES UNI NULL 偗偗偗 char(1) YES NULL SHOW CREATE TABLE `偁偁偁`; Table Create Table @@ -417,7 +417,7 @@ Table Create Table PRIMARY KEY (`偒偒偒`), UNIQUE KEY `偔偔偔` (`偔偔偔`), KEY `偐偐偐` (`偐偐`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis ALTER TABLE `偁偁偁` DROP INDEX `偐偐偐`; ALTER TABLE `偁偁偁` DROP PRIMARY KEY; ALTER TABLE `偁偁偁` DROP INDEX `偔偔偔`; @@ -431,12 +431,12 @@ SELECT * FROM ` 偆偆偆偆偆 DESC `偁偁偁`; Field Type Null Key Default Extra -偒偒偒 char(6) +偒偒偒 char(6) NO SHOW CREATE TABLE `偁偁偁`; Table Create Table 偁偁偁 CREATE TABLE `偁偁偁` ( `偒偒偒` char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis ALTER TABLE `僜僜僜` ADD `峔峔峔` char(1) FIRST; ALTER TABLE `僜僜僜` ADD `擻擻擻` char(1) AFTER `昞昞昞`; ALTER TABLE `僜僜僜` ADD `梊梊梊` char(1); @@ -453,8 +453,8 @@ NULL DESC `僜僜僜`; Field Type Null Key Default Extra 峔峔 char(1) YES MUL NULL -昞昞昞 char(6) PRI -擻擻擻 char(1) YES MUL NULL +昞昞昞 char(6) NO PRI +擻擻擻 char(1) YES UNI NULL 梊梊梊 char(1) YES NULL SHOW CREATE TABLE `僜僜僜`; Table Create Table @@ -466,7 +466,7 @@ Table Create Table PRIMARY KEY (`昞昞昞`), UNIQUE KEY `擻擻擻` (`擻擻擻`), KEY `峔峔峔` (`峔峔`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis ALTER TABLE `僜僜僜` DROP INDEX `峔峔峔`; ALTER TABLE `僜僜僜` DROP PRIMARY KEY; ALTER TABLE `僜僜僜` DROP INDEX `擻擻擻`; @@ -480,12 +480,12 @@ SELECT * FROM ` 擻擻擻擻擻 DESC `僜僜僜`; Field Type Null Key Default Extra -昞昞昞 char(6) +昞昞昞 char(6) NO SHOW CREATE TABLE `僜僜僜`; Table Create Table 僜僜僜 CREATE TABLE `僜僜僜` ( `昞昞昞` char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis DROP TABLE `北盽; DROP TABLE `膊瞏; DROP TABLE `偁偁偁`; @@ -516,7 +516,7 @@ NULL DESC `北盽; Field Type Null Key Default Extra 抖 char(1) YES MUL NULL -贩 char(6) PRI +贩 char(6) NO PRI 父 char(1) YES NULL 构 char(1) YES NULL SHOW CREATE TABLE `北盽; @@ -541,7 +541,7 @@ SELECT * FROM ` 吵吵 DESC `北盽; Field Type Null Key Default Extra -贩 char(6) +贩 char(6) NO SHOW CREATE TABLE `北盽; Table Create Table 北 CREATE TABLE `北盽 ( @@ -562,7 +562,7 @@ NULL DESC `偁偁偁`; Field Type Null Key Default Extra 偐偐 char(1) YES MUL NULL -偒偒偒 char(6) PRI +偒偒偒 char(6) NO PRI 偔偔偔 char(1) YES NULL 偗偗偗 char(1) YES NULL SHOW CREATE TABLE `偁偁偁`; @@ -587,7 +587,7 @@ SELECT * FROM ` 偆偆偆偆偆 DESC `偁偁偁`; Field Type Null Key Default Extra -偒偒偒 char(6) +偒偒偒 char(6) NO SHOW CREATE TABLE `偁偁偁`; Table Create Table 偁偁偁 CREATE TABLE `偁偁偁` ( @@ -608,7 +608,7 @@ NULL DESC `僜僜僜`; Field Type Null Key Default Extra 峔峔 char(1) YES MUL NULL -昞昞昞 char(6) PRI +昞昞昞 char(6) NO PRI 擻擻擻 char(1) YES NULL 梊梊梊 char(1) YES NULL SHOW CREATE TABLE `僜僜僜`; @@ -633,7 +633,7 @@ SELECT * FROM ` 昞昞昞昞昞 DESC `僜僜僜`; Field Type Null Key Default Extra -昞昞昞 char(6) +昞昞昞 char(6) NO SHOW CREATE TABLE `僜僜僜`; Table Create Table 僜僜僜 CREATE TABLE `僜僜僜` ( diff --git a/mysql-test/suite/jp/r/jp_alter_ucs2.result b/mysql-test/suite/jp/r/jp_alter_ucs2.result index 2756e5a758d..746dfdd62cc 100644 --- a/mysql-test/suite/jp/r/jp_alter_ucs2.result +++ b/mysql-test/suite/jp/r/jp_alter_ucs2.result @@ -32,8 +32,8 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI -幐幐幐 char(1) YES MUL NULL +幏幏幏 char(6) NO PRI +幐幐幐 char(1) YES UNI NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; Table Create Table @@ -59,7 +59,7 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( @@ -81,8 +81,8 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI -くくく char(1) YES MUL NULL +ききき char(6) NO PRI +くくく char(1) YES UNI NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; Table Create Table @@ -108,7 +108,7 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( @@ -130,8 +130,8 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI -彴埃彴 char(1) YES MUL NULL +彴啊彴 char(6) NO PRI +彴埃彴 char(1) YES UNI NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table @@ -157,7 +157,7 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( @@ -194,8 +194,8 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI -幐幐幐 char(1) YES MUL NULL +幏幏幏 char(6) NO PRI +幐幐幐 char(1) YES UNI NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; Table Create Table @@ -221,7 +221,7 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( @@ -243,8 +243,8 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI -くくく char(1) YES MUL NULL +ききき char(6) NO PRI +くくく char(1) YES UNI NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; Table Create Table @@ -270,7 +270,7 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( @@ -292,8 +292,8 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI -彴埃彴 char(1) YES MUL NULL +彴啊彴 char(6) NO PRI +彴埃彴 char(1) YES UNI NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table @@ -319,7 +319,7 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( @@ -356,8 +356,8 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI -幐幐幐 char(1) YES MUL NULL +幏幏幏 char(6) NO PRI +幐幐幐 char(1) YES UNI NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; Table Create Table @@ -369,7 +369,7 @@ Table Create Table PRIMARY KEY (`幏幏幏`), UNIQUE KEY `幐幐幐` (`幐幐幐`), KEY `幎幎幎` (`幎幎`) -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 ALTER TABLE `幈幈幈` DROP INDEX `幎幎幎`; ALTER TABLE `幈幈幈` DROP PRIMARY KEY; ALTER TABLE `幈幈幈` DROP INDEX `幐幐幐`; @@ -383,12 +383,12 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( `幏幏幏` char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 ALTER TABLE `あああ` ADD `かかか` char(1) FIRST; ALTER TABLE `あああ` ADD `くくく` char(1) AFTER `ききき`; ALTER TABLE `あああ` ADD `けけけ` char(1); @@ -405,8 +405,8 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI -くくく char(1) YES MUL NULL +ききき char(6) NO PRI +くくく char(1) YES UNI NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; Table Create Table @@ -418,7 +418,7 @@ Table Create Table PRIMARY KEY (`ききき`), UNIQUE KEY `くくく` (`くくく`), KEY `かかか` (`かか`) -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 ALTER TABLE `あああ` DROP INDEX `かかか`; ALTER TABLE `あああ` DROP PRIMARY KEY; ALTER TABLE `あああ` DROP INDEX `くくく`; @@ -432,12 +432,12 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( `ききき` char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 ALTER TABLE `忢輳磔忢輅 ADD `彴阿彴 char(1) FIRST; ALTER TABLE `忢輳磔忢輅 ADD `彴埃彴 char(1) AFTER `彴啊彴; ALTER TABLE `忢輳磔忢輅 ADD `彴磸按彴碻 char(1); @@ -454,8 +454,8 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI -彴埃彴 char(1) YES MUL NULL +彴啊彴 char(6) NO PRI +彴埃彴 char(1) YES UNI NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table @@ -467,7 +467,7 @@ Table Create Table PRIMARY KEY (`彴啊彴), UNIQUE KEY `彴埃彴 (`彴埃彴), KEY `彴阿彴 (`彴阿`) -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 ALTER TABLE `忢輳磔忢輅 DROP INDEX `彴阿彴; ALTER TABLE `忢輳磔忢輅 DROP PRIMARY KEY; ALTER TABLE `忢輳磔忢輅 DROP INDEX `彴埃彴; @@ -481,12 +481,12 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( `彴啊彴 char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 DROP TABLE `幈幈幈`; DROP TABLE `幉幉幉`; DROP TABLE `あああ`; @@ -517,7 +517,7 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI +幏幏幏 char(6) NO PRI 幐幐幐 char(1) YES NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; @@ -542,7 +542,7 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( @@ -563,7 +563,7 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI +ききき char(6) NO PRI くくく char(1) YES NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; @@ -588,7 +588,7 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( @@ -609,7 +609,7 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI +彴啊彴 char(6) NO PRI 彴埃彴 char(1) YES NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; @@ -634,7 +634,7 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( diff --git a/mysql-test/suite/jp/r/jp_alter_ujis.result b/mysql-test/suite/jp/r/jp_alter_ujis.result index afa3c79cbce..daea68caa3f 100644 --- a/mysql-test/suite/jp/r/jp_alter_ujis.result +++ b/mysql-test/suite/jp/r/jp_alter_ujis.result @@ -31,8 +31,8 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI -幐幐幐 char(1) YES MUL NULL +幏幏幏 char(6) NO PRI +幐幐幐 char(1) YES UNI NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; Table Create Table @@ -58,7 +58,7 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( @@ -80,8 +80,8 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI -くくく char(1) YES MUL NULL +ききき char(6) NO PRI +くくく char(1) YES UNI NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; Table Create Table @@ -107,7 +107,7 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( @@ -129,8 +129,8 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI -彴埃彴 char(1) YES MUL NULL +彴啊彴 char(6) NO PRI +彴埃彴 char(1) YES UNI NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table @@ -156,7 +156,7 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( @@ -193,8 +193,8 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI -幐幐幐 char(1) YES MUL NULL +幏幏幏 char(6) NO PRI +幐幐幐 char(1) YES UNI NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; Table Create Table @@ -220,7 +220,7 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( @@ -242,8 +242,8 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI -くくく char(1) YES MUL NULL +ききき char(6) NO PRI +くくく char(1) YES UNI NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; Table Create Table @@ -269,7 +269,7 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( @@ -291,8 +291,8 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI -彴埃彴 char(1) YES MUL NULL +彴啊彴 char(6) NO PRI +彴埃彴 char(1) YES UNI NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table @@ -318,7 +318,7 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( @@ -355,8 +355,8 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI -幐幐幐 char(1) YES MUL NULL +幏幏幏 char(6) NO PRI +幐幐幐 char(1) YES UNI NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; Table Create Table @@ -368,7 +368,7 @@ Table Create Table PRIMARY KEY (`幏幏幏`), UNIQUE KEY `幐幐幐` (`幐幐幐`), KEY `幎幎幎` (`幎幎`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis ALTER TABLE `幈幈幈` DROP INDEX `幎幎幎`; ALTER TABLE `幈幈幈` DROP PRIMARY KEY; ALTER TABLE `幈幈幈` DROP INDEX `幐幐幐`; @@ -382,12 +382,12 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( `幏幏幏` char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis ALTER TABLE `あああ` ADD `かかか` char(1) FIRST; ALTER TABLE `あああ` ADD `くくく` char(1) AFTER `ききき`; ALTER TABLE `あああ` ADD `けけけ` char(1); @@ -404,8 +404,8 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI -くくく char(1) YES MUL NULL +ききき char(6) NO PRI +くくく char(1) YES UNI NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; Table Create Table @@ -417,7 +417,7 @@ Table Create Table PRIMARY KEY (`ききき`), UNIQUE KEY `くくく` (`くくく`), KEY `かかか` (`かか`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis ALTER TABLE `あああ` DROP INDEX `かかか`; ALTER TABLE `あああ` DROP PRIMARY KEY; ALTER TABLE `あああ` DROP INDEX `くくく`; @@ -431,12 +431,12 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( `ききき` char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis ALTER TABLE `忢輳磔忢輅 ADD `彴阿彴 char(1) FIRST; ALTER TABLE `忢輳磔忢輅 ADD `彴埃彴 char(1) AFTER `彴啊彴; ALTER TABLE `忢輳磔忢輅 ADD `彴磸按彴碻 char(1); @@ -453,8 +453,8 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI -彴埃彴 char(1) YES MUL NULL +彴啊彴 char(6) NO PRI +彴埃彴 char(1) YES UNI NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table @@ -466,7 +466,7 @@ Table Create Table PRIMARY KEY (`彴啊彴), UNIQUE KEY `彴埃彴 (`彴埃彴), KEY `彴阿彴 (`彴阿`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis ALTER TABLE `忢輳磔忢輅 DROP INDEX `彴阿彴; ALTER TABLE `忢輳磔忢輅 DROP PRIMARY KEY; ALTER TABLE `忢輳磔忢輅 DROP INDEX `彴埃彴; @@ -480,12 +480,12 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( `彴啊彴 char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis DROP TABLE `幈幈幈`; DROP TABLE `幉幉幉`; DROP TABLE `あああ`; @@ -516,7 +516,7 @@ NULL DESC `幈幈幈`; Field Type Null Key Default Extra 幎幎 char(1) YES MUL NULL -幏幏幏 char(6) PRI +幏幏幏 char(6) NO PRI 幐幐幐 char(1) YES NULL 幑幑幑 char(1) YES NULL SHOW CREATE TABLE `幈幈幈`; @@ -541,7 +541,7 @@ SELECT * FROM ` 幊幊幊幊幊 DESC `幈幈幈`; Field Type Null Key Default Extra -幏幏幏 char(6) +幏幏幏 char(6) NO SHOW CREATE TABLE `幈幈幈`; Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( @@ -562,7 +562,7 @@ NULL DESC `あああ`; Field Type Null Key Default Extra かか char(1) YES MUL NULL -ききき char(6) PRI +ききき char(6) NO PRI くくく char(1) YES NULL けけけ char(1) YES NULL SHOW CREATE TABLE `あああ`; @@ -587,7 +587,7 @@ SELECT * FROM ` ううううう DESC `あああ`; Field Type Null Key Default Extra -ききき char(6) +ききき char(6) NO SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( @@ -608,7 +608,7 @@ NULL DESC `忢輳磔忢輅; Field Type Null Key Default Extra 彴阿 char(1) YES MUL NULL -彴啊彴 char(6) PRI +彴啊彴 char(6) NO PRI 彴埃彴 char(1) YES NULL 彴磸按彴 char(1) YES NULL SHOW CREATE TABLE `忢輳磔忢輅; @@ -633,7 +633,7 @@ SELECT * FROM ` 彴埃彴埃彴 DESC `忢輳磔忢輅; Field Type Null Key Default Extra -彴啊彴 char(6) +彴啊彴 char(6) NO SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( diff --git a/mysql-test/suite/jp/r/jp_alter_utf8.result b/mysql-test/suite/jp/r/jp_alter_utf8.result index 19475e06a87..f2f374eed87 100644 --- a/mysql-test/suite/jp/r/jp_alter_utf8.result +++ b/mysql-test/suite/jp/r/jp_alter_utf8.result @@ -31,8 +31,8 @@ NULL 锝筹匠锝筹匠锝 NULL NULL DESC `锝憋奖锝盽; Field Type Null Key Default Extra 锝讹蕉 char(1) YES MUL NULL -锝凤椒锝 char(6) PRI -锝革礁锝 char(1) YES MUL NULL +锝凤椒锝 char(6) NO PRI +锝革礁锝 char(1) YES UNI NULL 锝癸焦锝 char(1) YES NULL SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table @@ -58,7 +58,7 @@ SELECT * FROM `锝憋奖锝盽; 锝筹匠锝筹匠锝 DESC `锝憋奖锝盽; Field Type Null Key Default Extra -锝凤椒锝 char(6) +锝凤椒锝 char(6) NO SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table 锝憋奖锝 CREATE TABLE `锝憋奖锝盽 ( @@ -80,8 +80,8 @@ NULL 銇嗐亞銇嗐亞銇 NULL NULL DESC `銇傘亗銇俙; Field Type Null Key Default Extra 銇嬨亱 char(1) YES MUL NULL -銇嶃亶銇 char(6) PRI -銇忋亸銇 char(1) YES MUL NULL +銇嶃亶銇 char(6) NO PRI +銇忋亸銇 char(1) YES UNI NULL 銇戙亼銇 char(1) YES NULL SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table @@ -107,7 +107,7 @@ SELECT * FROM `銇傘亗銇俙; 銇嗐亞銇嗐亞銇 DESC `銇傘亗銇俙; Field Type Null Key Default Extra -銇嶃亶銇 char(6) +銇嶃亶銇 char(6) NO SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table 銇傘亗銇 CREATE TABLE `銇傘亗銇俙 ( @@ -129,8 +129,8 @@ NULL 涓呬竻涓呬竻涓 NULL NULL DESC `榫栭緰榫朻; Field Type Null Key Default Extra 涓勪竸 char(1) YES MUL NULL -涓備競涓 char(6) PRI -涓呬竻涓 char(1) YES MUL NULL +涓備競涓 char(6) NO PRI +涓呬竻涓 char(1) YES UNI NULL 涔氫箽涔 char(1) YES NULL SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table @@ -156,7 +156,7 @@ SELECT * FROM `榫栭緰榫朻; 涓呬竻涓呬竻涓 DESC `榫栭緰榫朻; Field Type Null Key Default Extra -涓備競涓 char(6) +涓備競涓 char(6) NO SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table 榫栭緰榫 CREATE TABLE `榫栭緰榫朻 ( @@ -193,8 +193,8 @@ NULL 锝筹匠锝筹匠锝 NULL NULL DESC `锝憋奖锝盽; Field Type Null Key Default Extra 锝讹蕉 char(1) YES MUL NULL -锝凤椒锝 char(6) PRI -锝革礁锝 char(1) YES MUL NULL +锝凤椒锝 char(6) NO PRI +锝革礁锝 char(1) YES UNI NULL 锝癸焦锝 char(1) YES NULL SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table @@ -220,7 +220,7 @@ SELECT * FROM `锝憋奖锝盽; 锝筹匠锝筹匠锝 DESC `锝憋奖锝盽; Field Type Null Key Default Extra -锝凤椒锝 char(6) +锝凤椒锝 char(6) NO SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table 锝憋奖锝 CREATE TABLE `锝憋奖锝盽 ( @@ -242,8 +242,8 @@ NULL 銇嗐亞銇嗐亞銇 NULL NULL DESC `銇傘亗銇俙; Field Type Null Key Default Extra 銇嬨亱 char(1) YES MUL NULL -銇嶃亶銇 char(6) PRI -銇忋亸銇 char(1) YES MUL NULL +銇嶃亶銇 char(6) NO PRI +銇忋亸銇 char(1) YES UNI NULL 銇戙亼銇 char(1) YES NULL SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table @@ -269,7 +269,7 @@ SELECT * FROM `銇傘亗銇俙; 銇嗐亞銇嗐亞銇 DESC `銇傘亗銇俙; Field Type Null Key Default Extra -銇嶃亶銇 char(6) +銇嶃亶銇 char(6) NO SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table 銇傘亗銇 CREATE TABLE `銇傘亗銇俙 ( @@ -291,8 +291,8 @@ NULL 涓呬竻涓呬竻涓 NULL NULL DESC `榫栭緰榫朻; Field Type Null Key Default Extra 涓勪竸 char(1) YES MUL NULL -涓備競涓 char(6) PRI -涓呬竻涓 char(1) YES MUL NULL +涓備競涓 char(6) NO PRI +涓呬竻涓 char(1) YES UNI NULL 涔氫箽涔 char(1) YES NULL SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table @@ -318,7 +318,7 @@ SELECT * FROM `榫栭緰榫朻; 涓呬竻涓呬竻涓 DESC `榫栭緰榫朻; Field Type Null Key Default Extra -涓備競涓 char(6) +涓備競涓 char(6) NO SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table 榫栭緰榫 CREATE TABLE `榫栭緰榫朻 ( @@ -355,8 +355,8 @@ NULL 锝筹匠锝筹匠锝 NULL NULL DESC `锝憋奖锝盽; Field Type Null Key Default Extra 锝讹蕉 char(1) YES MUL NULL -锝凤椒锝 char(6) PRI -锝革礁锝 char(1) YES MUL NULL +锝凤椒锝 char(6) NO PRI +锝革礁锝 char(1) YES UNI NULL 锝癸焦锝 char(1) YES NULL SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table @@ -368,7 +368,7 @@ Table Create Table PRIMARY KEY (`锝凤椒锝穈), UNIQUE KEY `锝革礁锝竊 (`锝革礁锝竊), KEY `锝讹蕉锝禶 (`锝讹蕉`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 ALTER TABLE `锝憋奖锝盽 DROP INDEX `锝讹蕉锝禶; ALTER TABLE `锝憋奖锝盽 DROP PRIMARY KEY; ALTER TABLE `锝憋奖锝盽 DROP INDEX `锝革礁锝竊; @@ -382,12 +382,12 @@ SELECT * FROM `锝憋奖锝盽; 锝筹匠锝筹匠锝 DESC `锝憋奖锝盽; Field Type Null Key Default Extra -锝凤椒锝 char(6) +锝凤椒锝 char(6) NO SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table 锝憋奖锝 CREATE TABLE `锝憋奖锝盽 ( `锝凤椒锝穈 char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 ALTER TABLE `銇傘亗銇俙 ADD `銇嬨亱銇媊 char(1) FIRST; ALTER TABLE `銇傘亗銇俙 ADD `銇忋亸銇廯 char(1) AFTER `銇嶃亶銇峘; ALTER TABLE `銇傘亗銇俙 ADD `銇戙亼銇慲 char(1); @@ -404,8 +404,8 @@ NULL 銇嗐亞銇嗐亞銇 NULL NULL DESC `銇傘亗銇俙; Field Type Null Key Default Extra 銇嬨亱 char(1) YES MUL NULL -銇嶃亶銇 char(6) PRI -銇忋亸銇 char(1) YES MUL NULL +銇嶃亶銇 char(6) NO PRI +銇忋亸銇 char(1) YES UNI NULL 銇戙亼銇 char(1) YES NULL SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table @@ -417,7 +417,7 @@ Table Create Table PRIMARY KEY (`銇嶃亶銇峘), UNIQUE KEY `銇忋亸銇廯 (`銇忋亸銇廯), KEY `銇嬨亱銇媊 (`銇嬨亱`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 ALTER TABLE `銇傘亗銇俙 DROP INDEX `銇嬨亱銇媊; ALTER TABLE `銇傘亗銇俙 DROP PRIMARY KEY; ALTER TABLE `銇傘亗銇俙 DROP INDEX `銇忋亸銇廯; @@ -431,12 +431,12 @@ SELECT * FROM `銇傘亗銇俙; 銇嗐亞銇嗐亞銇 DESC `銇傘亗銇俙; Field Type Null Key Default Extra -銇嶃亶銇 char(6) +銇嶃亶銇 char(6) NO SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table 銇傘亗銇 CREATE TABLE `銇傘亗銇俙 ( `銇嶃亶銇峘 char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 ALTER TABLE `榫栭緰榫朻 ADD `涓勪竸涓刞 char(1) FIRST; ALTER TABLE `榫栭緰榫朻 ADD `涓呬竻涓卄 char(1) AFTER `涓備競涓俙; ALTER TABLE `榫栭緰榫朻 ADD `涔氫箽涔歚 char(1); @@ -453,8 +453,8 @@ NULL 涓呬竻涓呬竻涓 NULL NULL DESC `榫栭緰榫朻; Field Type Null Key Default Extra 涓勪竸 char(1) YES MUL NULL -涓備競涓 char(6) PRI -涓呬竻涓 char(1) YES MUL NULL +涓備競涓 char(6) NO PRI +涓呬竻涓 char(1) YES UNI NULL 涔氫箽涔 char(1) YES NULL SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table @@ -466,7 +466,7 @@ Table Create Table PRIMARY KEY (`涓備競涓俙), UNIQUE KEY `涓呬竻涓卄 (`涓呬竻涓卄), KEY `涓勪竸涓刞 (`涓勪竸`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 ALTER TABLE `榫栭緰榫朻 DROP INDEX `涓勪竸涓刞; ALTER TABLE `榫栭緰榫朻 DROP PRIMARY KEY; ALTER TABLE `榫栭緰榫朻 DROP INDEX `涓呬竻涓卄; @@ -480,12 +480,12 @@ SELECT * FROM `榫栭緰榫朻; 涓呬竻涓呬竻涓 DESC `榫栭緰榫朻; Field Type Null Key Default Extra -涓備競涓 char(6) +涓備競涓 char(6) NO SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table 榫栭緰榫 CREATE TABLE `榫栭緰榫朻 ( `涓備競涓俙 char(6) NOT NULL default '' -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 DROP TABLE `锝憋奖锝盽; DROP TABLE `锝诧讲锝瞏; DROP TABLE `銇傘亗銇俙; @@ -516,7 +516,7 @@ NULL 锝筹匠锝筹匠锝 NULL NULL DESC `锝憋奖锝盽; Field Type Null Key Default Extra 锝讹蕉 char(1) YES MUL NULL -锝凤椒锝 char(6) PRI +锝凤椒锝 char(6) NO PRI 锝革礁锝 char(1) YES NULL 锝癸焦锝 char(1) YES NULL SHOW CREATE TABLE `锝憋奖锝盽; @@ -541,7 +541,7 @@ SELECT * FROM `锝憋奖锝盽; 锝筹匠锝筹匠锝 DESC `锝憋奖锝盽; Field Type Null Key Default Extra -锝凤椒锝 char(6) +锝凤椒锝 char(6) NO SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table 锝憋奖锝 CREATE TABLE `锝憋奖锝盽 ( @@ -562,7 +562,7 @@ NULL 銇嗐亞銇嗐亞銇 NULL NULL DESC `銇傘亗銇俙; Field Type Null Key Default Extra 銇嬨亱 char(1) YES MUL NULL -銇嶃亶銇 char(6) PRI +銇嶃亶銇 char(6) NO PRI 銇忋亸銇 char(1) YES NULL 銇戙亼銇 char(1) YES NULL SHOW CREATE TABLE `銇傘亗銇俙; @@ -587,7 +587,7 @@ SELECT * FROM `銇傘亗銇俙; 銇嗐亞銇嗐亞銇 DESC `銇傘亗銇俙; Field Type Null Key Default Extra -銇嶃亶銇 char(6) +銇嶃亶銇 char(6) NO SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table 銇傘亗銇 CREATE TABLE `銇傘亗銇俙 ( @@ -608,7 +608,7 @@ NULL 涓呬竻涓呬竻涓 NULL NULL DESC `榫栭緰榫朻; Field Type Null Key Default Extra 涓勪竸 char(1) YES MUL NULL -涓備競涓 char(6) PRI +涓備競涓 char(6) NO PRI 涓呬竻涓 char(1) YES NULL 涔氫箽涔 char(1) YES NULL SHOW CREATE TABLE `榫栭緰榫朻; @@ -633,7 +633,7 @@ SELECT * FROM `榫栭緰榫朻; 涓呬竻涓呬竻涓 DESC `榫栭緰榫朻; Field Type Null Key Default Extra -涓備競涓 char(6) +涓備競涓 char(6) NO SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table 榫栭緰榫 CREATE TABLE `榫栭緰榫朻 ( diff --git a/mysql-test/suite/jp/r/jp_convert_sjis.result b/mysql-test/suite/jp/r/jp_convert_sjis.result index 8c9df3606c8..ff8a3fb2cd9 100644 --- a/mysql-test/suite/jp/r/jp_convert_sjis.result +++ b/mysql-test/suite/jp/r/jp_convert_sjis.result @@ -278,12 +278,15 @@ SELECT ` 陳陸陹険陻陼陽陾陿隀隁隂隃隄隇丒丒丒丒丒 陳陸陹険陻陼陽陾陿隀隁隂隃隄隇丒丒丒丒丒 SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿俁`; 俠侾 CONVERT(`俠侾` using utf8) + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT `俠侾`, CONVERT(`俠侾` using ucs2) FROM `俿俁`; 俠侾 CONVERT(`俠侾` using ucs2) + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT `俠侾`, CONVERT(`俠侾` using ujis) FROM `俿俁`; 俠侾 CONVERT(`俠侾` using ujis) + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿係`; 俠侾 CONVERT(`俠侾` using utf8) @@ -527,12 +530,15 @@ SELECT ` 陳陸陹険陻陼陽陾陿隀隁隂隃隄隇丒丒丒丒丒 陳陸陹険陻陼陽陾陿隀隁隂隃隄隇丒丒丒丒丒 SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿俇`; 俠侾 CONVERT(`俠侾` using utf8) + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT `俠侾`, CONVERT(`俠侾` using ucs2) FROM `俿俇`; 俠侾 CONVERT(`俠侾` using ucs2) + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT `俠侾`, CONVERT(`俠侾` using ujis) FROM `俿俇`; 俠侾 CONVERT(`俠侾` using ujis) + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿俈`; 俠侾 CONVERT(`俠侾` using utf8) @@ -777,12 +783,15 @@ SELECT ` SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿俋`; 俠侾 CONVERT(`俠侾` using utf8) 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + SELECT `俠侾`, CONVERT(`俠侾` using ucs2) FROM `俿俋`; 俠侾 CONVERT(`俠侾` using ucs2) 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + SELECT `俠侾`, CONVERT(`俠侾` using ujis) FROM `俿俋`; 俠侾 CONVERT(`俠侾` using ujis) 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿侾侽`; 俠侾 CONVERT(`俠侾` using utf8) !"#$%&'()*+,-./ !"#$%&'()*+,-./ @@ -1026,12 +1035,15 @@ SELECT ` SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿侾俀`; 俠侾 CONVERT(`俠侾` using utf8) 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + SELECT `俠侾`, CONVERT(`俠侾` using ucs2) FROM `俿侾俀`; 俠侾 CONVERT(`俠侾` using ucs2) 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + SELECT `俠侾`, CONVERT(`俠侾` using ujis) FROM `俿侾俀`; 俠侾 CONVERT(`俠侾` using ujis) 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + drop table `俿侾`; drop table `俿俀`; drop table `俿俁`; diff --git a/mysql-test/suite/jp/r/jp_create_db_sjis.result b/mysql-test/suite/jp/r/jp_create_db_sjis.result index 1ce0b7228d5..5d13cf74a39 100644 --- a/mysql-test/suite/jp/r/jp_create_db_sjis.result +++ b/mysql-test/suite/jp/r/jp_create_db_sjis.result @@ -8,6 +8,7 @@ CREATE DATABASE ` CREATE DATABASE `僜廫昞`; SHOW DATABASES; Database +information_schema mysql test 僜廫昞 diff --git a/mysql-test/suite/jp/r/jp_create_db_ucs2.result b/mysql-test/suite/jp/r/jp_create_db_ucs2.result index 8fd921ea8e6..f03baadf707 100644 --- a/mysql-test/suite/jp/r/jp_create_db_ucs2.result +++ b/mysql-test/suite/jp/r/jp_create_db_ucs2.result @@ -9,6 +9,7 @@ CREATE DATABASE ` CREATE DATABASE `忢軓磔忢轥; SHOW DATABASES; Database +information_schema mysql test 泣塑胳 diff --git a/mysql-test/suite/jp/r/jp_create_db_ujis.result b/mysql-test/suite/jp/r/jp_create_db_ujis.result index 45fdb34717b..627381bbacb 100644 --- a/mysql-test/suite/jp/r/jp_create_db_ujis.result +++ b/mysql-test/suite/jp/r/jp_create_db_ujis.result @@ -8,6 +8,7 @@ CREATE DATABASE ` CREATE DATABASE `忢軓磔忢轥; SHOW DATABASES; Database +information_schema mysql test 泣塑胳 diff --git a/mysql-test/suite/jp/r/jp_create_db_utf8.result b/mysql-test/suite/jp/r/jp_create_db_utf8.result index c0e996040de..1813259bdc9 100644 --- a/mysql-test/suite/jp/r/jp_create_db_utf8.result +++ b/mysql-test/suite/jp/r/jp_create_db_utf8.result @@ -8,6 +8,7 @@ CREATE DATABASE `鏃ユ湰瑾瀈; CREATE DATABASE `榫旈緰榫梎; SHOW DATABASES; Database +information_schema mysql test 鏃ユ湰瑾 diff --git a/mysql-test/suite/jp/r/jp_create_tbl_sjis.result b/mysql-test/suite/jp/r/jp_create_tbl_sjis.result index ecc72f9d91b..763a25bc127 100644 --- a/mysql-test/suite/jp/r/jp_create_tbl_sjis.result +++ b/mysql-test/suite/jp/r/jp_create_tbl_sjis.result @@ -22,11 +22,23 @@ CREATE TABLE ` CREATE TABLE `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=INNODB; CREATE TABLE `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=INNODB; CREATE TABLE IF NOT EXISTS `北盽(`抖禶 char(1)) DEFAULT CHARSET = sjis engine=INNODB; +Warnings: +Note 1050 Table '北' already exists CREATE TABLE IF NOT EXISTS `膊瞏(`贩穈 char(1)) DEFAULT CHARSET = sjis engine=INNODB; +Warnings: +Note 1050 Table '膊' already exists CREATE TABLE IF NOT EXISTS `偁偁偁`(`偐偐偐` char(1)) DEFAULT CHARSET = sjis engine=INNODB; +Warnings: +Note 1050 Table '偁偁偁' already exists CREATE TABLE IF NOT EXISTS `偄偄偄`(`偒偒偒` char(1)) DEFAULT CHARSET = sjis engine=INNODB; +Warnings: +Note 1050 Table '偄偄偄' already exists CREATE TABLE IF NOT EXISTS `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=INNODB; +Warnings: +Note 1050 Table '僜僜僜' already exists CREATE TABLE IF NOT EXISTS `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=INNODB; +Warnings: +Note 1050 Table '廫廫廫' already exists CREATE TABLE IF NOT EXISTS `吵砢(`父竊 char(1)) DEFAULT CHARSET = sjis engine=INNODB; CREATE TABLE IF NOT EXISTS `偆偆偆`(`偔偔偔` char(1)) DEFAULT CHARSET = sjis engine=INNODB; CREATE TABLE IF NOT EXISTS `昞昞昞`(`怽怽怽`char(1)) DEFAULT CHARSET = sjis engine=INNODB; @@ -178,11 +190,23 @@ CREATE TABLE ` CREATE TABLE `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=MyISAM; CREATE TABLE `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=MyISAM; CREATE TABLE IF NOT EXISTS `北盽(`抖禶 char(1)) DEFAULT CHARSET = sjis engine=MyISAM; +Warnings: +Note 1050 Table '北' already exists CREATE TABLE IF NOT EXISTS `膊瞏(`贩穈 char(1)) DEFAULT CHARSET = sjis engine=MyISAM; +Warnings: +Note 1050 Table '膊' already exists CREATE TABLE IF NOT EXISTS `偁偁偁`(`偐偐偐` char(1)) DEFAULT CHARSET = sjis engine=MyISAM; +Warnings: +Note 1050 Table '偁偁偁' already exists CREATE TABLE IF NOT EXISTS `偄偄偄`(`偒偒偒` char(1)) DEFAULT CHARSET = sjis engine=MyISAM; +Warnings: +Note 1050 Table '偄偄偄' already exists CREATE TABLE IF NOT EXISTS `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=MyISAM; +Warnings: +Note 1050 Table '僜僜僜' already exists CREATE TABLE IF NOT EXISTS `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=MyISAM; +Warnings: +Note 1050 Table '廫廫廫' already exists CREATE TABLE IF NOT EXISTS `吵砢(`父竊 char(1)) DEFAULT CHARSET = sjis engine=MyISAM; CREATE TABLE IF NOT EXISTS `偆偆偆`(`偔偔偔` char(1)) DEFAULT CHARSET = sjis engine=MyISAM; CREATE TABLE IF NOT EXISTS `昞昞昞`(`怽怽怽`char(1)) DEFAULT CHARSET = sjis engine=MyISAM; @@ -334,11 +358,23 @@ CREATE TABLE ` CREATE TABLE `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=HEAP; CREATE TABLE `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=HEAP; CREATE TABLE IF NOT EXISTS `北盽(`抖禶 char(1)) DEFAULT CHARSET = sjis engine=HEAP; +Warnings: +Note 1050 Table '北' already exists CREATE TABLE IF NOT EXISTS `膊瞏(`贩穈 char(1)) DEFAULT CHARSET = sjis engine=HEAP; +Warnings: +Note 1050 Table '膊' already exists CREATE TABLE IF NOT EXISTS `偁偁偁`(`偐偐偐` char(1)) DEFAULT CHARSET = sjis engine=HEAP; +Warnings: +Note 1050 Table '偁偁偁' already exists CREATE TABLE IF NOT EXISTS `偄偄偄`(`偒偒偒` char(1)) DEFAULT CHARSET = sjis engine=HEAP; +Warnings: +Note 1050 Table '偄偄偄' already exists CREATE TABLE IF NOT EXISTS `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=HEAP; +Warnings: +Note 1050 Table '僜僜僜' already exists CREATE TABLE IF NOT EXISTS `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=HEAP; +Warnings: +Note 1050 Table '廫廫廫' already exists CREATE TABLE IF NOT EXISTS `吵砢(`父竊 char(1)) DEFAULT CHARSET = sjis engine=HEAP; CREATE TABLE IF NOT EXISTS `偆偆偆`(`偔偔偔` char(1)) DEFAULT CHARSET = sjis engine=HEAP; CREATE TABLE IF NOT EXISTS `昞昞昞`(`怽怽怽`char(1)) DEFAULT CHARSET = sjis engine=HEAP; @@ -397,77 +433,77 @@ SHOW CREATE TABLE ` Table Create Table 北 CREATE TABLE `北盽 ( `抖禶 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `膊瞏; Table Create Table 膊 CREATE TABLE `膊瞏 ( `贩穈 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `吵砢; Table Create Table 吵 CREATE TABLE `吵砢 ( `父竊 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `创碻; Table Create Table 创 CREATE TEMPORARY TABLE `创碻 ( `构筦 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `档礰; Table Create Table 档 CREATE TEMPORARY TABLE `档礰 ( `汉篳 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `偁偁偁`; Table Create Table 偁偁偁 CREATE TABLE `偁偁偁` ( `偐偐偐` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `偄偄偄`; Table Create Table 偄偄偄 CREATE TABLE `偄偄偄` ( `偒偒偒` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `偆偆偆`; Table Create Table 偆偆偆 CREATE TABLE `偆偆偆` ( `偔偔偔` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `偊偊偊`; Table Create Table 偊偊偊 CREATE TEMPORARY TABLE `偊偊偊` ( `偗偗偗` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `偍偍偍`; Table Create Table 偍偍偍 CREATE TEMPORARY TABLE `偍偍偍` ( `偙偙偙` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `僜僜僜`; Table Create Table 僜僜僜 CREATE TABLE `僜僜僜` ( `塡塡塡` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `廫廫廫`; Table Create Table 廫廫廫 CREATE TABLE `廫廫廫` ( `嶾嶾嶾` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `昞昞昞`; Table Create Table 昞昞昞 CREATE TABLE `昞昞昞` ( `怽怽怽` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `梊梊梊`; Table Create Table 梊梊梊 CREATE TEMPORARY TABLE `梊梊梊` ( `揬揬揬` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `峔峔峔`; Table Create Table 峔峔峔 CREATE TEMPORARY TABLE `峔峔峔` ( `擻擻擻` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis DROP TABLE `北盽; DROP TABLE `膊瞏; DROP TABLE `吵砢; @@ -490,11 +526,23 @@ CREATE TABLE ` CREATE TABLE `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=BDB; CREATE TABLE `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=BDB; CREATE TABLE IF NOT EXISTS `北盽(`抖禶 char(1)) DEFAULT CHARSET = sjis engine=BDB; +Warnings: +Note 1050 Table '北' already exists CREATE TABLE IF NOT EXISTS `膊瞏(`贩穈 char(1)) DEFAULT CHARSET = sjis engine=BDB; +Warnings: +Note 1050 Table '膊' already exists CREATE TABLE IF NOT EXISTS `偁偁偁`(`偐偐偐` char(1)) DEFAULT CHARSET = sjis engine=BDB; +Warnings: +Note 1050 Table '偁偁偁' already exists CREATE TABLE IF NOT EXISTS `偄偄偄`(`偒偒偒` char(1)) DEFAULT CHARSET = sjis engine=BDB; +Warnings: +Note 1050 Table '偄偄偄' already exists CREATE TABLE IF NOT EXISTS `僜僜僜`(`塡塡塡` char(1)) DEFAULT CHARSET = sjis engine=BDB; +Warnings: +Note 1050 Table '僜僜僜' already exists CREATE TABLE IF NOT EXISTS `廫廫廫`(`嶾嶾嶾` char(1)) DEFAULT CHARSET = sjis engine=BDB; +Warnings: +Note 1050 Table '廫廫廫' already exists CREATE TABLE IF NOT EXISTS `吵砢(`父竊 char(1)) DEFAULT CHARSET = sjis engine=BDB; CREATE TABLE IF NOT EXISTS `偆偆偆`(`偔偔偔` char(1)) DEFAULT CHARSET = sjis engine=BDB; CREATE TABLE IF NOT EXISTS `昞昞昞`(`怽怽怽`char(1)) DEFAULT CHARSET = sjis engine=BDB; diff --git a/mysql-test/suite/jp/r/jp_create_tbl_ucs2.result b/mysql-test/suite/jp/r/jp_create_tbl_ucs2.result index 0bf5a6891b0..d6616f66d9f 100644 --- a/mysql-test/suite/jp/r/jp_create_tbl_ucs2.result +++ b/mysql-test/suite/jp/r/jp_create_tbl_ucs2.result @@ -22,11 +22,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ucs2 engine=INNODB; @@ -178,11 +190,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ucs2 engine=MyISAM; @@ -334,11 +358,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ucs2 engine=HEAP; @@ -397,77 +433,77 @@ SHOW CREATE TABLE ` Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( `幎幎幎` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `幉幉幉`; Table Create Table 幉幉幉 CREATE TABLE `幉幉幉` ( `幏幏幏` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `幊幊幊`; Table Create Table 幊幊幊 CREATE TABLE `幊幊幊` ( `幐幐幐` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `幋幋幋`; Table Create Table 幋幋幋 CREATE TEMPORARY TABLE `幋幋幋` ( `幑幑幑` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `幍幍幍`; Table Create Table 幍幍幍 CREATE TEMPORARY TABLE `幍幍幍` ( `幒幒幒` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( `かかか` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `いいい`; Table Create Table いいい CREATE TABLE `いいい` ( `ききき` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `ううう`; Table Create Table ううう CREATE TABLE `ううう` ( `くくく` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `えええ`; Table Create Table えええ CREATE TEMPORARY TABLE `えええ` ( `けけけ` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `おおお`; Table Create Table おおお CREATE TEMPORARY TABLE `おおお` ( `こここ` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( `彴啊彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `忢迯磙忢轥; Table Create Table 忢迯磙忢 CREATE TABLE `忢迯磙忢轥 ( `彴阿彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `忢邚磉忢違; Table Create Table 忢邚磉忢 CREATE TABLE `忢邚磉忢違 ( `彴埃彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `忢鄰磬忢郹; Table Create Table 忢鄰磬忢 CREATE TEMPORARY TABLE `忢鄰磬忢郹 ( `彴挨彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `忢釓磲忢醏; Table Create Table 忢釓磲忢 CREATE TEMPORARY TABLE `忢釓磲忢醏 ( `彴哎彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 DROP TABLE `幈幈幈`; DROP TABLE `幉幉幉`; DROP TABLE `幊幊幊`; @@ -490,11 +526,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=BDB; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=BDB; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ucs2 engine=BDB; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ucs2 engine=BDB; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ucs2 engine=BDB; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ucs2 engine=BDB; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ucs2 engine=BDB; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ucs2 engine=BDB; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ucs2 engine=BDB; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ucs2 engine=BDB; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ucs2 engine=BDB; diff --git a/mysql-test/suite/jp/r/jp_create_tbl_ujis.result b/mysql-test/suite/jp/r/jp_create_tbl_ujis.result index ae555e5af15..f53e1e58793 100644 --- a/mysql-test/suite/jp/r/jp_create_tbl_ujis.result +++ b/mysql-test/suite/jp/r/jp_create_tbl_ujis.result @@ -22,11 +22,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=INNODB; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=INNODB; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ujis engine=INNODB; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ujis engine=INNODB; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ujis engine=INNODB; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ujis engine=INNODB; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=INNODB; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=INNODB; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ujis engine=INNODB; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ujis engine=INNODB; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ujis engine=INNODB; @@ -178,11 +190,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=MyISAM; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=MyISAM; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ujis engine=MyISAM; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ujis engine=MyISAM; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ujis engine=MyISAM; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ujis engine=MyISAM; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=MyISAM; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=MyISAM; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ujis engine=MyISAM; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ujis engine=MyISAM; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ujis engine=MyISAM; @@ -334,11 +358,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=HEAP; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=HEAP; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ujis engine=HEAP; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ujis engine=HEAP; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ujis engine=HEAP; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ujis engine=HEAP; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=HEAP; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=HEAP; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ujis engine=HEAP; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ujis engine=HEAP; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ujis engine=HEAP; @@ -397,77 +433,77 @@ SHOW CREATE TABLE ` Table Create Table 幈幈幈 CREATE TABLE `幈幈幈` ( `幎幎幎` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `幉幉幉`; Table Create Table 幉幉幉 CREATE TABLE `幉幉幉` ( `幏幏幏` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `幊幊幊`; Table Create Table 幊幊幊 CREATE TABLE `幊幊幊` ( `幐幐幐` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `幋幋幋`; Table Create Table 幋幋幋 CREATE TEMPORARY TABLE `幋幋幋` ( `幑幑幑` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `幍幍幍`; Table Create Table 幍幍幍 CREATE TEMPORARY TABLE `幍幍幍` ( `幒幒幒` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `あああ`; Table Create Table あああ CREATE TABLE `あああ` ( `かかか` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `いいい`; Table Create Table いいい CREATE TABLE `いいい` ( `ききき` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `ううう`; Table Create Table ううう CREATE TABLE `ううう` ( `くくく` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `えええ`; Table Create Table えええ CREATE TEMPORARY TABLE `えええ` ( `けけけ` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `おおお`; Table Create Table おおお CREATE TEMPORARY TABLE `おおお` ( `こここ` char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `忢輳磔忢輅; Table Create Table 忢輳磔忢 CREATE TABLE `忢輳磔忢輅 ( `彴啊彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `忢迯磙忢轥; Table Create Table 忢迯磙忢 CREATE TABLE `忢迯磙忢轥 ( `彴阿彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `忢邚磉忢違; Table Create Table 忢邚磉忢 CREATE TABLE `忢邚磉忢違 ( `彴埃彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `忢鄰磬忢郹; Table Create Table 忢鄰磬忢 CREATE TEMPORARY TABLE `忢鄰磬忢郹 ( `彴挨彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `忢釓磲忢醏; Table Create Table 忢釓磲忢 CREATE TEMPORARY TABLE `忢釓磲忢醏 ( `彴哎彴 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis DROP TABLE `幈幈幈`; DROP TABLE `幉幉幉`; DROP TABLE `幊幊幊`; @@ -490,11 +526,23 @@ CREATE TABLE ` CREATE TABLE `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=BDB; CREATE TABLE `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=BDB; CREATE TABLE IF NOT EXISTS `幈幈幈`(`幎幎幎` char(1)) DEFAULT CHARSET = ujis engine=BDB; +Warnings: +Note 1050 Table '幈幈幈' already exists CREATE TABLE IF NOT EXISTS `幉幉幉`(`幏幏幏` char(1)) DEFAULT CHARSET = ujis engine=BDB; +Warnings: +Note 1050 Table '幉幉幉' already exists CREATE TABLE IF NOT EXISTS `あああ`(`かかか` char(1)) DEFAULT CHARSET = ujis engine=BDB; +Warnings: +Note 1050 Table 'あああ' already exists CREATE TABLE IF NOT EXISTS `いいい`(`ききき` char(1)) DEFAULT CHARSET = ujis engine=BDB; +Warnings: +Note 1050 Table 'いいい' already exists CREATE TABLE IF NOT EXISTS `忢輳磔忢輅(`彴啊彴 char(1)) DEFAULT CHARSET = ujis engine=BDB; +Warnings: +Note 1050 Table '忢輳磔忢' already exists CREATE TABLE IF NOT EXISTS `忢迯磙忢轥(`彴阿彴 char(1)) DEFAULT CHARSET = ujis engine=BDB; +Warnings: +Note 1050 Table '忢迯磙忢' already exists CREATE TABLE IF NOT EXISTS `幊幊幊`(`幐幐幐` char(1)) DEFAULT CHARSET = ujis engine=BDB; CREATE TABLE IF NOT EXISTS `ううう`(`くくく` char(1)) DEFAULT CHARSET = ujis engine=BDB; CREATE TABLE IF NOT EXISTS `忢邚磉忢違(`彴埃彴char(1)) DEFAULT CHARSET = ujis engine=BDB; diff --git a/mysql-test/suite/jp/r/jp_create_tbl_utf8.result b/mysql-test/suite/jp/r/jp_create_tbl_utf8.result index d4873406c46..6df30acbd7f 100644 --- a/mysql-test/suite/jp/r/jp_create_tbl_utf8.result +++ b/mysql-test/suite/jp/r/jp_create_tbl_utf8.result @@ -22,11 +22,23 @@ CREATE TABLE `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=INNO CREATE TABLE `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; CREATE TABLE `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; CREATE TABLE IF NOT EXISTS `锝憋奖锝盽(`锝讹蕉锝禶 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; +Warnings: +Note 1050 Table '锝憋奖锝' already exists CREATE TABLE IF NOT EXISTS `锝诧讲锝瞏(`锝凤椒锝穈 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; +Warnings: +Note 1050 Table '锝诧讲锝' already exists CREATE TABLE IF NOT EXISTS `銇傘亗銇俙(`銇嬨亱銇媊 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; +Warnings: +Note 1050 Table '銇傘亗銇' already exists CREATE TABLE IF NOT EXISTS `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; +Warnings: +Note 1050 Table '銇勩亜銇' already exists CREATE TABLE IF NOT EXISTS `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; +Warnings: +Note 1050 Table '榫栭緰榫' already exists CREATE TABLE IF NOT EXISTS `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; +Warnings: +Note 1050 Table '榫楅緱榫' already exists CREATE TABLE IF NOT EXISTS `锝筹匠锝砢(`锝革礁锝竊 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; CREATE TABLE IF NOT EXISTS `銇嗐亞銇哷(`銇忋亸銇廯 char(1)) DEFAULT CHARSET = utf8 engine=INNODB; CREATE TABLE IF NOT EXISTS `榫為緸榫瀈(`涓呬竻涓卄char(1)) DEFAULT CHARSET = utf8 engine=INNODB; @@ -178,11 +190,23 @@ CREATE TABLE `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=MyIS CREATE TABLE `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; CREATE TABLE `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; CREATE TABLE IF NOT EXISTS `锝憋奖锝盽(`锝讹蕉锝禶 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; +Warnings: +Note 1050 Table '锝憋奖锝' already exists CREATE TABLE IF NOT EXISTS `锝诧讲锝瞏(`锝凤椒锝穈 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; +Warnings: +Note 1050 Table '锝诧讲锝' already exists CREATE TABLE IF NOT EXISTS `銇傘亗銇俙(`銇嬨亱銇媊 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; +Warnings: +Note 1050 Table '銇傘亗銇' already exists CREATE TABLE IF NOT EXISTS `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; +Warnings: +Note 1050 Table '銇勩亜銇' already exists CREATE TABLE IF NOT EXISTS `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; +Warnings: +Note 1050 Table '榫栭緰榫' already exists CREATE TABLE IF NOT EXISTS `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; +Warnings: +Note 1050 Table '榫楅緱榫' already exists CREATE TABLE IF NOT EXISTS `锝筹匠锝砢(`锝革礁锝竊 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; CREATE TABLE IF NOT EXISTS `銇嗐亞銇哷(`銇忋亸銇廯 char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; CREATE TABLE IF NOT EXISTS `榫為緸榫瀈(`涓呬竻涓卄char(1)) DEFAULT CHARSET = utf8 engine=MyISAM; @@ -334,11 +358,23 @@ CREATE TABLE `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=HEAP CREATE TABLE `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; CREATE TABLE `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; CREATE TABLE IF NOT EXISTS `锝憋奖锝盽(`锝讹蕉锝禶 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; +Warnings: +Note 1050 Table '锝憋奖锝' already exists CREATE TABLE IF NOT EXISTS `锝诧讲锝瞏(`锝凤椒锝穈 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; +Warnings: +Note 1050 Table '锝诧讲锝' already exists CREATE TABLE IF NOT EXISTS `銇傘亗銇俙(`銇嬨亱銇媊 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; +Warnings: +Note 1050 Table '銇傘亗銇' already exists CREATE TABLE IF NOT EXISTS `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; +Warnings: +Note 1050 Table '銇勩亜銇' already exists CREATE TABLE IF NOT EXISTS `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; +Warnings: +Note 1050 Table '榫栭緰榫' already exists CREATE TABLE IF NOT EXISTS `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; +Warnings: +Note 1050 Table '榫楅緱榫' already exists CREATE TABLE IF NOT EXISTS `锝筹匠锝砢(`锝革礁锝竊 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; CREATE TABLE IF NOT EXISTS `銇嗐亞銇哷(`銇忋亸銇廯 char(1)) DEFAULT CHARSET = utf8 engine=HEAP; CREATE TABLE IF NOT EXISTS `榫為緸榫瀈(`涓呬竻涓卄char(1)) DEFAULT CHARSET = utf8 engine=HEAP; @@ -397,77 +433,77 @@ SHOW CREATE TABLE `锝憋奖锝盽; Table Create Table 锝憋奖锝 CREATE TABLE `锝憋奖锝盽 ( `锝讹蕉锝禶 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锝诧讲锝瞏; Table Create Table 锝诧讲锝 CREATE TABLE `锝诧讲锝瞏 ( `锝凤椒锝穈 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锝筹匠锝砢; Table Create Table 锝筹匠锝 CREATE TABLE `锝筹匠锝砢 ( `锝革礁锝竊 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锝达酱锝碻; Table Create Table 锝达酱锝 CREATE TEMPORARY TABLE `锝达酱锝碻 ( `锝癸焦锝筦 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锝碉降锝礰; Table Create Table 锝碉降锝 CREATE TEMPORARY TABLE `锝碉降锝礰 ( `锝猴胶锝篳 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `銇傘亗銇俙; Table Create Table 銇傘亗銇 CREATE TABLE `銇傘亗銇俙 ( `銇嬨亱銇媊 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `銇勩亜銇刞; Table Create Table 銇勩亜銇 CREATE TABLE `銇勩亜銇刞 ( `銇嶃亶銇峘 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `銇嗐亞銇哷; Table Create Table 銇嗐亞銇 CREATE TABLE `銇嗐亞銇哷 ( `銇忋亸銇廯 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `銇堛亪銇坄; Table Create Table 銇堛亪銇 CREATE TEMPORARY TABLE `銇堛亪銇坄 ( `銇戙亼銇慲 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `銇娿亰銇奰; Table Create Table 銇娿亰銇 CREATE TEMPORARY TABLE `銇娿亰銇奰 ( `銇撱亾銇揱 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `榫栭緰榫朻; Table Create Table 榫栭緰榫 CREATE TABLE `榫栭緰榫朻 ( `涓備競涓俙 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `榫楅緱榫梎; Table Create Table 榫楅緱榫 CREATE TABLE `榫楅緱榫梎 ( `涓勪竸涓刞 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `榫為緸榫瀈; Table Create Table 榫為緸榫 CREATE TABLE `榫為緸榫瀈 ( `涓呬竻涓卄 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `榫￠尽榫; Table Create Table 榫￠尽榫 CREATE TEMPORARY TABLE `榫￠尽榫 ( `涓屼笇涓宍 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `榫㈤劲榫; Table Create Table 榫㈤劲榫 CREATE TEMPORARY TABLE `榫㈤劲榫 ( `涓掍笒涓抈 char(1) default NULL -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 DROP TABLE `锝憋奖锝盽; DROP TABLE `锝诧讲锝瞏; DROP TABLE `锝筹匠锝砢; @@ -490,11 +526,23 @@ CREATE TABLE `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=BDB; CREATE TABLE `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=BDB; CREATE TABLE `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=BDB; CREATE TABLE IF NOT EXISTS `锝憋奖锝盽(`锝讹蕉锝禶 char(1)) DEFAULT CHARSET = utf8 engine=BDB; +Warnings: +Note 1050 Table '锝憋奖锝' already exists CREATE TABLE IF NOT EXISTS `锝诧讲锝瞏(`锝凤椒锝穈 char(1)) DEFAULT CHARSET = utf8 engine=BDB; +Warnings: +Note 1050 Table '锝诧讲锝' already exists CREATE TABLE IF NOT EXISTS `銇傘亗銇俙(`銇嬨亱銇媊 char(1)) DEFAULT CHARSET = utf8 engine=BDB; +Warnings: +Note 1050 Table '銇傘亗銇' already exists CREATE TABLE IF NOT EXISTS `銇勩亜銇刞(`銇嶃亶銇峘 char(1)) DEFAULT CHARSET = utf8 engine=BDB; +Warnings: +Note 1050 Table '銇勩亜銇' already exists CREATE TABLE IF NOT EXISTS `榫栭緰榫朻(`涓備競涓俙 char(1)) DEFAULT CHARSET = utf8 engine=BDB; +Warnings: +Note 1050 Table '榫栭緰榫' already exists CREATE TABLE IF NOT EXISTS `榫楅緱榫梎(`涓勪竸涓刞 char(1)) DEFAULT CHARSET = utf8 engine=BDB; +Warnings: +Note 1050 Table '榫楅緱榫' already exists CREATE TABLE IF NOT EXISTS `锝筹匠锝砢(`锝革礁锝竊 char(1)) DEFAULT CHARSET = utf8 engine=BDB; CREATE TABLE IF NOT EXISTS `銇嗐亞銇哷(`銇忋亸銇廯 char(1)) DEFAULT CHARSET = utf8 engine=BDB; CREATE TABLE IF NOT EXISTS `榫為緸榫瀈(`涓呬竻涓卄char(1)) DEFAULT CHARSET = utf8 engine=BDB; diff --git a/mysql-test/suite/jp/r/jp_enum_sjis.result b/mysql-test/suite/jp/r/jp_enum_sjis.result index 1e46dbffbb1..43994123e3b 100644 --- a/mysql-test/suite/jp/r/jp_enum_sjis.result +++ b/mysql-test/suite/jp/r/jp_enum_sjis.result @@ -137,19 +137,19 @@ Table Create Table 俿俈 CREATE TABLE `俿俈` ( `俠侾` enum('','','') default NULL, KEY `俠侾` (`俠侾`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俉`; Table Create Table 俿俉 CREATE TABLE `俿俉` ( `俠侾` enum('偁','偄','偆') default NULL, KEY `俠侾` (`俠侾`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俋`; Table Create Table 俿俋 CREATE TABLE `俿俋` ( `俠侾` enum('僜','廫','昞') default NULL, KEY `俠侾` (`俠侾`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿侾侽`; Table Create Table 俿侾侽 CREATE TABLE `俿侾侽` ( @@ -219,134 +219,134 @@ ALTER TABLE ` SHOW CREATE TABLE `俿侾`; Table Create Table 俿侾 CREATE TABLE `俿侾` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('','','') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=InnoDB DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俀`; Table Create Table 俿俀 CREATE TABLE `俿俀` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('偁','偄','偆') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=InnoDB DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俁`; Table Create Table 俿俁 CREATE TABLE `俿俁` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('僜','廫','昞') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=InnoDB DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿係`; Table Create Table 俿係 CREATE TABLE `俿係` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('','','') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=MyISAM DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俆`; Table Create Table 俿俆 CREATE TABLE `俿俆` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('偁','偄','偆') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=MyISAM DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俇`; Table Create Table 俿俇 CREATE TABLE `俿俇` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('僜','廫','昞') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=MyISAM DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俈`; Table Create Table 俿俈 CREATE TABLE `俿俈` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('','','') default NULL, KEY `俠侾` (`俠侾`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俉`; Table Create Table 俿俉 CREATE TABLE `俿俉` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('偁','偄','偆') default NULL, KEY `俠侾` (`俠侾`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿俋`; Table Create Table 俿俋 CREATE TABLE `俿俋` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('僜','廫','昞') default NULL, KEY `俠侾` (`俠侾`) -) ENGINE=HEAP DEFAULT CHARSET=sjis +) ENGINE=MEMORY DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿侾侽`; Table Create Table 俿侾侽 CREATE TABLE `俿侾侽` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('','','') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿侾侾`; Table Create Table 俿侾侾 CREATE TABLE `俿侾侾` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('偁','偄','偆') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=sjis SHOW CREATE TABLE `俿侾俀`; Table Create Table 俿侾俀 CREATE TABLE `俿侾俀` ( - `俠俀` char(1) NOT NULL default '', + `俠俀` char(1) NOT NULL, `俠侾` enum('僜','廫','昞') default NULL, KEY `俠侾` (`俠侾`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=sjis DESC `俿侾`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('','','') YES MUL NULL DESC `俿俀`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('偁','偄','偆') YES MUL NULL DESC `俿俁`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('僜','廫','昞') YES MUL NULL DESC `俿係`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('','','') YES MUL NULL DESC `俿俆`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('偁','偄','偆') YES MUL NULL DESC `俿俇`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('僜','廫','昞') YES MUL NULL DESC `俿俈`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('','','') YES MUL NULL DESC `俿俉`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('偁','偄','偆') YES MUL NULL DESC `俿俋`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('僜','廫','昞') YES MUL NULL DESC `俿侾侽`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('','','') YES MUL NULL DESC `俿侾侾`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('偁','偄','偆') YES MUL NULL DESC `俿侾俀`; Field Type Null Key Default Extra -俠俀 char(1) +俠俀 char(1) NO NULL 俠侾 enum('僜','廫','昞') YES MUL NULL DROP TABLE `俿侾`; DROP TABLE `俿俀`; diff --git a/mysql-test/suite/jp/r/jp_enum_ucs2.result b/mysql-test/suite/jp/r/jp_enum_ucs2.result index a84cace35fe..c41e6c262eb 100644 --- a/mysql-test/suite/jp/r/jp_enum_ucs2.result +++ b/mysql-test/suite/jp/r/jp_enum_ucs2.result @@ -138,19 +138,19 @@ Table Create Table Ｔ７ CREATE TABLE `Ｔ７` ( `Ｃ１` enum('幈','幉','幊') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `Ｔ８`; Table Create Table Ｔ８ CREATE TABLE `Ｔ８` ( `Ｃ１` enum('あ','い','う') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `Ｔ９`; Table Create Table Ｔ９ CREATE TABLE `Ｔ９` ( `Ｃ１` enum('忢','忢','忢') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ucs2 +) ENGINE=MEMORY DEFAULT CHARSET=ucs2 SHOW CREATE TABLE `Ｔ１０`; Table Create Table Ｔ１０ CREATE TABLE `Ｔ１０` ( diff --git a/mysql-test/suite/jp/r/jp_enum_ujis.result b/mysql-test/suite/jp/r/jp_enum_ujis.result index dbc850b1368..9ba445eaba5 100644 --- a/mysql-test/suite/jp/r/jp_enum_ujis.result +++ b/mysql-test/suite/jp/r/jp_enum_ujis.result @@ -137,19 +137,19 @@ Table Create Table Ｔ７ CREATE TABLE `Ｔ７` ( `Ｃ１` enum('幈','幉','幊') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ８`; Table Create Table Ｔ８ CREATE TABLE `Ｔ８` ( `Ｃ１` enum('あ','い','う') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ９`; Table Create Table Ｔ９ CREATE TABLE `Ｔ９` ( `Ｃ１` enum('忢','忢','忢') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ１０`; Table Create Table Ｔ１０ CREATE TABLE `Ｔ１０` ( @@ -219,134 +219,134 @@ ALTER TABLE ` SHOW CREATE TABLE `Ｔ１`; Table Create Table Ｔ１ CREATE TABLE `Ｔ１` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('幈','幉','幊') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=InnoDB DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ２`; Table Create Table Ｔ２ CREATE TABLE `Ｔ２` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('あ','い','う') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=InnoDB DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ３`; Table Create Table Ｔ３ CREATE TABLE `Ｔ３` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('忢','忢','忢') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=InnoDB DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ４`; Table Create Table Ｔ４ CREATE TABLE `Ｔ４` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('幈','幉','幊') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=MyISAM DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ５`; Table Create Table Ｔ５ CREATE TABLE `Ｔ５` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('あ','い','う') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=MyISAM DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ６`; Table Create Table Ｔ６ CREATE TABLE `Ｔ６` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('忢','忢','忢') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=MyISAM DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ７`; Table Create Table Ｔ７ CREATE TABLE `Ｔ７` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('幈','幉','幊') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ８`; Table Create Table Ｔ８ CREATE TABLE `Ｔ８` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('あ','い','う') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ９`; Table Create Table Ｔ９ CREATE TABLE `Ｔ９` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('忢','忢','忢') default NULL, KEY `Ｃ１` (`Ｃ１`) -) ENGINE=HEAP DEFAULT CHARSET=ujis +) ENGINE=MEMORY DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ１０`; Table Create Table Ｔ１０ CREATE TABLE `Ｔ１０` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('幈','幉','幊') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ１１`; Table Create Table Ｔ１１ CREATE TABLE `Ｔ１１` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('あ','い','う') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=ujis SHOW CREATE TABLE `Ｔ１２`; Table Create Table Ｔ１２ CREATE TABLE `Ｔ１２` ( - `Ｃ２` char(1) NOT NULL default '', + `Ｃ２` char(1) NOT NULL, `Ｃ１` enum('忢','忢','忢') default NULL, KEY `Ｃ１` (`Ｃ１`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=ujis DESC `Ｔ１`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('幈','幉','幊') YES MUL NULL DESC `Ｔ２`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('あ','い','う') YES MUL NULL DESC `Ｔ３`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('忢','忢','忢') YES MUL NULL DESC `Ｔ４`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('幈','幉','幊') YES MUL NULL DESC `Ｔ５`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('あ','い','う') YES MUL NULL DESC `Ｔ６`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('忢','忢','忢') YES MUL NULL DESC `Ｔ７`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('幈','幉','幊') YES MUL NULL DESC `Ｔ８`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('あ','い','う') YES MUL NULL DESC `Ｔ９`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('忢','忢','忢') YES MUL NULL DESC `Ｔ１０`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('幈','幉','幊') YES MUL NULL DESC `Ｔ１１`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('あ','い','う') YES MUL NULL DESC `Ｔ１２`; Field Type Null Key Default Extra -Ｃ２ char(1) +Ｃ２ char(1) NO NULL Ｃ１ enum('忢','忢','忢') YES MUL NULL DROP TABLE `Ｔ１`; DROP TABLE `Ｔ２`; diff --git a/mysql-test/suite/jp/r/jp_enum_utf8.result b/mysql-test/suite/jp/r/jp_enum_utf8.result index f2515871ece..c4ff9193447 100644 --- a/mysql-test/suite/jp/r/jp_enum_utf8.result +++ b/mysql-test/suite/jp/r/jp_enum_utf8.result @@ -137,19 +137,19 @@ Table Create Table 锛达紬 CREATE TABLE `锛达紬` ( `锛ｏ紤` enum('锝','锝','锝') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紭`; Table Create Table 锛达紭 CREATE TABLE `锛达紭` ( `锛ｏ紤` enum('銇','銇','銇') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紮`; Table Create Table 锛达紮 CREATE TABLE `锛达紮` ( `锛ｏ紤` enum('榫','榫','榫') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紤锛恅; Table Create Table 锛达紤锛 CREATE TABLE `锛达紤锛恅 ( @@ -219,134 +219,134 @@ ALTER TABLE `锛达紤锛抈 ADD `锛ｏ紥` CHAR(1) NOT NULL FIRST; SHOW CREATE TABLE `锛达紤`; Table Create Table 锛达紤 CREATE TABLE `锛达紤` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('锝','锝','锝') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紥`; Table Create Table 锛达紥 CREATE TABLE `锛达紥` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('銇','銇','銇') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紦`; Table Create Table 锛达紦 CREATE TABLE `锛达紦` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('榫','榫','榫') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紨`; Table Create Table 锛达紨 CREATE TABLE `锛达紨` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('锝','锝','锝') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紩`; Table Create Table 锛达紩 CREATE TABLE `锛达紩` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('銇','銇','銇') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紪`; Table Create Table 锛达紪 CREATE TABLE `锛达紪` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('榫','榫','榫') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紬`; Table Create Table 锛达紬 CREATE TABLE `锛达紬` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('锝','锝','锝') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紭`; Table Create Table 锛达紭 CREATE TABLE `锛达紭` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('銇','銇','銇') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紮`; Table Create Table 锛达紮 CREATE TABLE `锛达紮` ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('榫','榫','榫') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) -) ENGINE=HEAP DEFAULT CHARSET=utf8 +) ENGINE=MEMORY DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紤锛恅; Table Create Table 锛达紤锛 CREATE TABLE `锛达紤锛恅 ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('锝','锝','锝') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紤锛慲; Table Create Table 锛达紤锛 CREATE TABLE `锛达紤锛慲 ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('銇','銇','銇') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=utf8 SHOW CREATE TABLE `锛达紤锛抈; Table Create Table 锛达紤锛 CREATE TABLE `锛达紤锛抈 ( - `锛ｏ紥` char(1) NOT NULL default '', + `锛ｏ紥` char(1) NOT NULL, `锛ｏ紤` enum('榫','榫','榫') default NULL, KEY `锛ｏ紤` (`锛ｏ紤`) ) ENGINE=BerkeleyDB DEFAULT CHARSET=utf8 DESC `锛达紤`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('锝','锝','锝') YES MUL NULL DESC `锛达紥`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('銇','銇','銇') YES MUL NULL DESC `锛达紦`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('榫','榫','榫') YES MUL NULL DESC `锛达紨`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('锝','锝','锝') YES MUL NULL DESC `锛达紩`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('銇','銇','銇') YES MUL NULL DESC `锛达紪`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('榫','榫','榫') YES MUL NULL DESC `锛达紬`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('锝','锝','锝') YES MUL NULL DESC `锛达紭`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('銇','銇','銇') YES MUL NULL DESC `锛达紮`; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('榫','榫','榫') YES MUL NULL DESC `锛达紤锛恅; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('锝','锝','锝') YES MUL NULL DESC `锛达紤锛慲; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('銇','銇','銇') YES MUL NULL DESC `锛达紤锛抈; Field Type Null Key Default Extra -锛ｏ紥 char(1) +锛ｏ紥 char(1) NO NULL 锛ｏ紤 enum('榫','榫','榫') YES MUL NULL DROP TABLE `锛达紤`; DROP TABLE `锛达紥`; diff --git a/mysql-test/suite/jp/r/jp_join_sjis.result b/mysql-test/suite/jp/r/jp_join_sjis.result index a5ccc58ae4c..95df2d5488e 100644 --- a/mysql-test/suite/jp/r/jp_join_sjis.result +++ b/mysql-test/suite/jp/r/jp_join_sjis.result @@ -71,31 +71,31 @@ SELECT * FROM ` SELECT * FROM `俿侾a` JOIN `俿侾b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿侾a` INNER JOIN `俿侾b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿侾a` CROSS JOIN `俿侾b`; 俠侾 俠侾 SELECT * FROM `俿侾a` LEFT JOIN `俿侾b` USING (`俠侾`); -俠侾 俠侾 - - NULL - NULL +俠侾 + + + SELECT * FROM `俿侾a` LEFT JOIN `俿侾b` ON (`俿侾a`.`俠侾` = `俿侾b`.`俠侾`); 俠侾 俠侾 NULL NULL SELECT * FROM `俿侾b` RIGHT JOIN `俿侾a` USING (`俠侾`); -俠侾 俠侾 - -NULL -NULL +俠侾 + + + SELECT * FROM `俿侾b` RIGHT JOIN `俿侾a` ON (`俿侾a`.`俠侾` = `俿侾b`.`俠侾`); 俠侾 俠侾 @@ -112,31 +112,31 @@ SELECT * FROM ` 偐 偁 偝 偁 SELECT * FROM `俿俀a` JOIN `俿俀b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿俀a` INNER JOIN `俿俀b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿俀a` CROSS JOIN `俿俀b`; 俠侾 俠侾 偁 偁 偐 偁 偝 偁 SELECT * FROM `俿俀a` LEFT JOIN `俿俀b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -偐 NULL -偝 NULL +俠侾 +偁 +偐 +偝 SELECT * FROM `俿俀a` LEFT JOIN `俿俀b` ON (`俿俀a`.`俠侾` = `俿俀b`.`俠侾`); 俠侾 俠侾 偁 偁 偐 NULL 偝 NULL SELECT * FROM `俿俀b` RIGHT JOIN `俿俀a` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -NULL 偐 -NULL 偝 +俠侾 +偁 +偐 +偝 SELECT * FROM `俿俀b` RIGHT JOIN `俿俀a` ON (`俿俀a`.`俠侾` = `俿俀b`.`俠侾`); 俠侾 俠侾 偁 偁 @@ -153,31 +153,31 @@ SELECT * FROM ` 廫 僜 昞 僜 SELECT * FROM `俿俁a` JOIN `俿俁b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿俁a` INNER JOIN `俿俁b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿俁a` CROSS JOIN `俿俁b`; 俠侾 俠侾 僜 僜 廫 僜 昞 僜 SELECT * FROM `俿俁a` LEFT JOIN `俿俁b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -廫 NULL -昞 NULL +俠侾 +僜 +廫 +昞 SELECT * FROM `俿俁a` LEFT JOIN `俿俁b` ON (`俿俁a`.`俠侾` = `俿俁b`.`俠侾`); 俠侾 俠侾 僜 僜 廫 NULL 昞 NULL SELECT * FROM `俿俁b` RIGHT JOIN `俿俁a` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -NULL 廫 -NULL 昞 +俠侾 +僜 +廫 +昞 SELECT * FROM `俿俁b` RIGHT JOIN `俿俁a` ON (`俿俁a`.`俠侾` = `俿俁b`.`俠侾`); 俠侾 俠侾 僜 僜 @@ -194,31 +194,31 @@ SELECT * FROM ` SELECT * FROM `俿係a` JOIN `俿係b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿係a` INNER JOIN `俿係b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿係a` CROSS JOIN `俿係b`; 俠侾 俠侾 SELECT * FROM `俿係a` LEFT JOIN `俿係b` USING (`俠侾`); -俠侾 俠侾 - - NULL - NULL +俠侾 + + + SELECT * FROM `俿係a` LEFT JOIN `俿係b` ON (`俿係a`.`俠侾` = `俿係b`.`俠侾`); 俠侾 俠侾 NULL NULL SELECT * FROM `俿係b` RIGHT JOIN `俿係a` USING (`俠侾`); -俠侾 俠侾 - -NULL -NULL +俠侾 + + + SELECT * FROM `俿係b` RIGHT JOIN `俿係a` ON (`俿係a`.`俠侾` = `俿係b`.`俠侾`); 俠侾 俠侾 @@ -235,31 +235,31 @@ SELECT * FROM ` 偐 偁 偝 偁 SELECT * FROM `俿俆a` JOIN `俿俆b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿俆a` INNER JOIN `俿俆b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿俆a` CROSS JOIN `俿俆b`; 俠侾 俠侾 偁 偁 偐 偁 偝 偁 SELECT * FROM `俿俆a` LEFT JOIN `俿俆b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -偐 NULL -偝 NULL +俠侾 +偁 +偐 +偝 SELECT * FROM `俿俆a` LEFT JOIN `俿俆b` ON (`俿俆a`.`俠侾` = `俿俆b`.`俠侾`); 俠侾 俠侾 偁 偁 偐 NULL 偝 NULL SELECT * FROM `俿俆b` RIGHT JOIN `俿俆a` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -NULL 偐 -NULL 偝 +俠侾 +偁 +偐 +偝 SELECT * FROM `俿俆b` RIGHT JOIN `俿俆a` ON (`俿俆a`.`俠侾` = `俿俆b`.`俠侾`); 俠侾 俠侾 偁 偁 @@ -276,31 +276,31 @@ SELECT * FROM ` 廫 僜 昞 僜 SELECT * FROM `俿俇a` JOIN `俿俇b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿俇a` INNER JOIN `俿俇b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿俇a` CROSS JOIN `俿俇b`; 俠侾 俠侾 僜 僜 廫 僜 昞 僜 SELECT * FROM `俿俇a` LEFT JOIN `俿俇b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -廫 NULL -昞 NULL +俠侾 +僜 +廫 +昞 SELECT * FROM `俿俇a` LEFT JOIN `俿俇b` ON (`俿俇a`.`俠侾` = `俿俇b`.`俠侾`); 俠侾 俠侾 僜 僜 廫 NULL 昞 NULL SELECT * FROM `俿俇b` RIGHT JOIN `俿俇a` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -NULL 廫 -NULL 昞 +俠侾 +僜 +廫 +昞 SELECT * FROM `俿俇b` RIGHT JOIN `俿俇a` ON (`俿俇a`.`俠侾` = `俿俇b`.`俠侾`); 俠侾 俠侾 僜 僜 @@ -317,31 +317,31 @@ SELECT * FROM ` SELECT * FROM `俿俈a` JOIN `俿俈b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿俈a` INNER JOIN `俿俈b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿俈a` CROSS JOIN `俿俈b`; 俠侾 俠侾 SELECT * FROM `俿俈a` LEFT JOIN `俿俈b` USING (`俠侾`); -俠侾 俠侾 - - NULL - NULL +俠侾 + + + SELECT * FROM `俿俈a` LEFT JOIN `俿俈b` ON (`俿俈a`.`俠侾` = `俿俈b`.`俠侾`); 俠侾 俠侾 NULL NULL SELECT * FROM `俿俈b` RIGHT JOIN `俿俈a` USING (`俠侾`); -俠侾 俠侾 - -NULL -NULL +俠侾 + + + SELECT * FROM `俿俈b` RIGHT JOIN `俿俈a` ON (`俿俈a`.`俠侾` = `俿俈b`.`俠侾`); 俠侾 俠侾 @@ -358,31 +358,31 @@ SELECT * FROM ` 偐 偁 偝 偁 SELECT * FROM `俿俉a` JOIN `俿俉b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿俉a` INNER JOIN `俿俉b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿俉a` CROSS JOIN `俿俉b`; 俠侾 俠侾 偁 偁 偐 偁 偝 偁 SELECT * FROM `俿俉a` LEFT JOIN `俿俉b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -偐 NULL -偝 NULL +俠侾 +偁 +偐 +偝 SELECT * FROM `俿俉a` LEFT JOIN `俿俉b` ON (`俿俉a`.`俠侾` = `俿俉b`.`俠侾`); 俠侾 俠侾 偁 偁 偐 NULL 偝 NULL SELECT * FROM `俿俉b` RIGHT JOIN `俿俉a` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -NULL 偐 -NULL 偝 +俠侾 +偁 +偐 +偝 SELECT * FROM `俿俉b` RIGHT JOIN `俿俉a` ON (`俿俉a`.`俠侾` = `俿俉b`.`俠侾`); 俠侾 俠侾 偁 偁 @@ -399,31 +399,31 @@ SELECT * FROM ` 廫 僜 昞 僜 SELECT * FROM `俿俋a` JOIN `俿俋b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿俋a` INNER JOIN `俿俋b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿俋a` CROSS JOIN `俿俋b`; 俠侾 俠侾 僜 僜 廫 僜 昞 僜 SELECT * FROM `俿俋a` LEFT JOIN `俿俋b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -廫 NULL -昞 NULL +俠侾 +僜 +廫 +昞 SELECT * FROM `俿俋a` LEFT JOIN `俿俋b` ON (`俿俋a`.`俠侾` = `俿俋b`.`俠侾`); 俠侾 俠侾 僜 僜 廫 NULL 昞 NULL SELECT * FROM `俿俋b` RIGHT JOIN `俿俋a` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -NULL 廫 -NULL 昞 +俠侾 +僜 +廫 +昞 SELECT * FROM `俿俋b` RIGHT JOIN `俿俋a` ON (`俿俋a`.`俠侾` = `俿俋b`.`俠侾`); 俠侾 俠侾 僜 僜 @@ -440,31 +440,31 @@ SELECT * FROM ` SELECT * FROM `俿侾侽a` JOIN `俿侾侽b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿侾侽a` INNER JOIN `俿侾侽b` USING (`俠侾`); -俠侾 俠侾 - +俠侾 + SELECT * FROM `俿侾侽a` CROSS JOIN `俿侾侽b`; 俠侾 俠侾 SELECT * FROM `俿侾侽a` LEFT JOIN `俿侾侽b` USING (`俠侾`); -俠侾 俠侾 - - NULL - NULL +俠侾 + + + SELECT * FROM `俿侾侽a` LEFT JOIN `俿侾侽b` ON (`俿侾侽a`.`俠侾` = `俿侾侽b`.`俠侾`); 俠侾 俠侾 NULL NULL SELECT * FROM `俿侾侽b` RIGHT JOIN `俿侾侽a` USING (`俠侾`); -俠侾 俠侾 - -NULL -NULL +俠侾 + + + SELECT * FROM `俿侾侽b` RIGHT JOIN `俿侾侽a` ON (`俿侾侽a`.`俠侾` = `俿侾侽b`.`俠侾`); 俠侾 俠侾 @@ -481,31 +481,31 @@ SELECT * FROM ` 偐 偁 偝 偁 SELECT * FROM `俿侾侾a` JOIN `俿侾侾b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿侾侾a` INNER JOIN `俿侾侾b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 +俠侾 +偁 SELECT * FROM `俿侾侾a` CROSS JOIN `俿侾侾b`; 俠侾 俠侾 偁 偁 偐 偁 偝 偁 SELECT * FROM `俿侾侾a` LEFT JOIN `俿侾侾b` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -偐 NULL -偝 NULL +俠侾 +偁 +偐 +偝 SELECT * FROM `俿侾侾a` LEFT JOIN `俿侾侾b` ON (`俿侾侾a`.`俠侾` = `俿侾侾b`.`俠侾`); 俠侾 俠侾 偁 偁 偐 NULL 偝 NULL SELECT * FROM `俿侾侾b` RIGHT JOIN `俿侾侾a` USING (`俠侾`); -俠侾 俠侾 -偁 偁 -NULL 偐 -NULL 偝 +俠侾 +偁 +偐 +偝 SELECT * FROM `俿侾侾b` RIGHT JOIN `俿侾侾a` ON (`俿侾侾a`.`俠侾` = `俿侾侾b`.`俠侾`); 俠侾 俠侾 偁 偁 @@ -522,31 +522,31 @@ SELECT * FROM ` 廫 僜 昞 僜 SELECT * FROM `俿侾俀a` JOIN `俿侾俀b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿侾俀a` INNER JOIN `俿侾俀b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 +俠侾 +僜 SELECT * FROM `俿侾俀a` CROSS JOIN `俿侾俀b`; 俠侾 俠侾 僜 僜 廫 僜 昞 僜 SELECT * FROM `俿侾俀a` LEFT JOIN `俿侾俀b` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -廫 NULL -昞 NULL +俠侾 +僜 +廫 +昞 SELECT * FROM `俿侾俀a` LEFT JOIN `俿侾俀b` ON (`俿侾俀a`.`俠侾` = `俿侾俀b`.`俠侾`); 俠侾 俠侾 僜 僜 廫 NULL 昞 NULL SELECT * FROM `俿侾俀b` RIGHT JOIN `俿侾俀a` USING (`俠侾`); -俠侾 俠侾 -僜 僜 -NULL 廫 -NULL 昞 +俠侾 +僜 +廫 +昞 SELECT * FROM `俿侾俀b` RIGHT JOIN `俿侾俀a` ON (`俿侾俀a`.`俠侾` = `俿侾俀b`.`俠侾`); 俠侾 俠侾 僜 僜 diff --git a/mysql-test/suite/jp/r/jp_join_ucs2.result b/mysql-test/suite/jp/r/jp_join_ucs2.result index 76988f15cc4..ac19554eb5a 100644 --- a/mysql-test/suite/jp/r/jp_join_ucs2.result +++ b/mysql-test/suite/jp/r/jp_join_ucs2.result @@ -72,31 +72,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ１a` JOIN `Ｔ１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１a` INNER JOIN `Ｔ１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１a` CROSS JOIN `Ｔ１b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ１a` LEFT JOIN `Ｔ１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１a` LEFT JOIN `Ｔ１b` ON (`Ｔ１a`.`Ｃ１` = `Ｔ１b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ１b` RIGHT JOIN `Ｔ１a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１b` RIGHT JOIN `Ｔ１a` ON (`Ｔ１a`.`Ｃ１` = `Ｔ１b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -113,31 +113,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ２a` JOIN `Ｔ２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ２a` INNER JOIN `Ｔ２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ２a` CROSS JOIN `Ｔ２b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ２a` LEFT JOIN `Ｔ２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ２a` LEFT JOIN `Ｔ２b` ON (`Ｔ２a`.`Ｃ１` = `Ｔ２b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ２b` RIGHT JOIN `Ｔ２a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ２b` RIGHT JOIN `Ｔ２a` ON (`Ｔ２a`.`Ｃ１` = `Ｔ２b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -154,31 +154,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ３a` JOIN `Ｔ３b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ３a` INNER JOIN `Ｔ３b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ３a` CROSS JOIN `Ｔ３b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ３a` LEFT JOIN `Ｔ３b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ３a` LEFT JOIN `Ｔ３b` ON (`Ｔ３a`.`Ｃ１` = `Ｔ３b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ３b` RIGHT JOIN `Ｔ３a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ３b` RIGHT JOIN `Ｔ３a` ON (`Ｔ３a`.`Ｃ１` = `Ｔ３b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 @@ -195,31 +195,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ４a` JOIN `Ｔ４b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ４a` INNER JOIN `Ｔ４b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ４a` CROSS JOIN `Ｔ４b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ４a` LEFT JOIN `Ｔ４b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ４a` LEFT JOIN `Ｔ４b` ON (`Ｔ４a`.`Ｃ１` = `Ｔ４b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ４b` RIGHT JOIN `Ｔ４a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ４b` RIGHT JOIN `Ｔ４a` ON (`Ｔ４a`.`Ｃ１` = `Ｔ４b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -236,31 +236,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ５a` JOIN `Ｔ５b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ５a` INNER JOIN `Ｔ５b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ５a` CROSS JOIN `Ｔ５b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ５a` LEFT JOIN `Ｔ５b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ５a` LEFT JOIN `Ｔ５b` ON (`Ｔ５a`.`Ｃ１` = `Ｔ５b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ５b` RIGHT JOIN `Ｔ５a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ５b` RIGHT JOIN `Ｔ５a` ON (`Ｔ５a`.`Ｃ１` = `Ｔ５b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -277,31 +277,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ６a` JOIN `Ｔ６b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ６a` INNER JOIN `Ｔ６b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ６a` CROSS JOIN `Ｔ６b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ６a` LEFT JOIN `Ｔ６b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ６a` LEFT JOIN `Ｔ６b` ON (`Ｔ６a`.`Ｃ１` = `Ｔ６b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ６b` RIGHT JOIN `Ｔ６a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ６b` RIGHT JOIN `Ｔ６a` ON (`Ｔ６a`.`Ｃ１` = `Ｔ６b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 @@ -318,31 +318,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ７a` JOIN `Ｔ７b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ７a` INNER JOIN `Ｔ７b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ７a` CROSS JOIN `Ｔ７b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ７a` LEFT JOIN `Ｔ７b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ７a` LEFT JOIN `Ｔ７b` ON (`Ｔ７a`.`Ｃ１` = `Ｔ７b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ７b` RIGHT JOIN `Ｔ７a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ７b` RIGHT JOIN `Ｔ７a` ON (`Ｔ７a`.`Ｃ１` = `Ｔ７b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -359,31 +359,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ８a` JOIN `Ｔ８b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ８a` INNER JOIN `Ｔ８b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ８a` CROSS JOIN `Ｔ８b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ８a` LEFT JOIN `Ｔ８b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ８a` LEFT JOIN `Ｔ８b` ON (`Ｔ８a`.`Ｃ１` = `Ｔ８b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ８b` RIGHT JOIN `Ｔ８a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ８b` RIGHT JOIN `Ｔ８a` ON (`Ｔ８a`.`Ｃ１` = `Ｔ８b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -400,31 +400,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ９a` JOIN `Ｔ９b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ９a` INNER JOIN `Ｔ９b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ９a` CROSS JOIN `Ｔ９b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ９a` LEFT JOIN `Ｔ９b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ９a` LEFT JOIN `Ｔ９b` ON (`Ｔ９a`.`Ｃ１` = `Ｔ９b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ９b` RIGHT JOIN `Ｔ９a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ９b` RIGHT JOIN `Ｔ９a` ON (`Ｔ９a`.`Ｃ１` = `Ｔ９b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 @@ -441,31 +441,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ１０a` JOIN `Ｔ１０b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１０a` INNER JOIN `Ｔ１０b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１０a` CROSS JOIN `Ｔ１０b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ１０a` LEFT JOIN `Ｔ１０b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１０a` LEFT JOIN `Ｔ１０b` ON (`Ｔ１０a`.`Ｃ１` = `Ｔ１０b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ１０b` RIGHT JOIN `Ｔ１０a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１０b` RIGHT JOIN `Ｔ１０a` ON (`Ｔ１０a`.`Ｃ１` = `Ｔ１０b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -482,31 +482,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ１１a` JOIN `Ｔ１１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ１１a` INNER JOIN `Ｔ１１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ１１a` CROSS JOIN `Ｔ１１b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ１１a` LEFT JOIN `Ｔ１１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ１１a` LEFT JOIN `Ｔ１１b` ON (`Ｔ１１a`.`Ｃ１` = `Ｔ１１b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ１１b` RIGHT JOIN `Ｔ１１a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ１１b` RIGHT JOIN `Ｔ１１a` ON (`Ｔ１１a`.`Ｃ１` = `Ｔ１１b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -523,31 +523,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ１２a` JOIN `Ｔ１２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ１２a` INNER JOIN `Ｔ１２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ１２a` CROSS JOIN `Ｔ１２b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ１２a` LEFT JOIN `Ｔ１２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ１２a` LEFT JOIN `Ｔ１２b` ON (`Ｔ１２a`.`Ｃ１` = `Ｔ１２b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ１２b` RIGHT JOIN `Ｔ１２a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ１２b` RIGHT JOIN `Ｔ１２a` ON (`Ｔ１２a`.`Ｃ１` = `Ｔ１２b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 diff --git a/mysql-test/suite/jp/r/jp_join_ujis.result b/mysql-test/suite/jp/r/jp_join_ujis.result index ac430cd9b5e..838d701cdcc 100644 --- a/mysql-test/suite/jp/r/jp_join_ujis.result +++ b/mysql-test/suite/jp/r/jp_join_ujis.result @@ -71,31 +71,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ１a` JOIN `Ｔ１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１a` INNER JOIN `Ｔ１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１a` CROSS JOIN `Ｔ１b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ１a` LEFT JOIN `Ｔ１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１a` LEFT JOIN `Ｔ１b` ON (`Ｔ１a`.`Ｃ１` = `Ｔ１b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ１b` RIGHT JOIN `Ｔ１a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１b` RIGHT JOIN `Ｔ１a` ON (`Ｔ１a`.`Ｃ１` = `Ｔ１b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -112,31 +112,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ２a` JOIN `Ｔ２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ２a` INNER JOIN `Ｔ２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ２a` CROSS JOIN `Ｔ２b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ２a` LEFT JOIN `Ｔ２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ２a` LEFT JOIN `Ｔ２b` ON (`Ｔ２a`.`Ｃ１` = `Ｔ２b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ２b` RIGHT JOIN `Ｔ２a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ２b` RIGHT JOIN `Ｔ２a` ON (`Ｔ２a`.`Ｃ１` = `Ｔ２b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -153,31 +153,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ３a` JOIN `Ｔ３b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ３a` INNER JOIN `Ｔ３b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ３a` CROSS JOIN `Ｔ３b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ３a` LEFT JOIN `Ｔ３b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ３a` LEFT JOIN `Ｔ３b` ON (`Ｔ３a`.`Ｃ１` = `Ｔ３b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ３b` RIGHT JOIN `Ｔ３a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ３b` RIGHT JOIN `Ｔ３a` ON (`Ｔ３a`.`Ｃ１` = `Ｔ３b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 @@ -194,31 +194,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ４a` JOIN `Ｔ４b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ４a` INNER JOIN `Ｔ４b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ４a` CROSS JOIN `Ｔ４b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ４a` LEFT JOIN `Ｔ４b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ４a` LEFT JOIN `Ｔ４b` ON (`Ｔ４a`.`Ｃ１` = `Ｔ４b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ４b` RIGHT JOIN `Ｔ４a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ４b` RIGHT JOIN `Ｔ４a` ON (`Ｔ４a`.`Ｃ１` = `Ｔ４b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -235,31 +235,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ５a` JOIN `Ｔ５b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ５a` INNER JOIN `Ｔ５b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ５a` CROSS JOIN `Ｔ５b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ５a` LEFT JOIN `Ｔ５b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ５a` LEFT JOIN `Ｔ５b` ON (`Ｔ５a`.`Ｃ１` = `Ｔ５b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ５b` RIGHT JOIN `Ｔ５a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ５b` RIGHT JOIN `Ｔ５a` ON (`Ｔ５a`.`Ｃ１` = `Ｔ５b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -276,31 +276,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ６a` JOIN `Ｔ６b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ６a` INNER JOIN `Ｔ６b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ６a` CROSS JOIN `Ｔ６b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ６a` LEFT JOIN `Ｔ６b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ６a` LEFT JOIN `Ｔ６b` ON (`Ｔ６a`.`Ｃ１` = `Ｔ６b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ６b` RIGHT JOIN `Ｔ６a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ６b` RIGHT JOIN `Ｔ６a` ON (`Ｔ６a`.`Ｃ１` = `Ｔ６b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 @@ -317,31 +317,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ７a` JOIN `Ｔ７b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ７a` INNER JOIN `Ｔ７b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ７a` CROSS JOIN `Ｔ７b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ７a` LEFT JOIN `Ｔ７b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ７a` LEFT JOIN `Ｔ７b` ON (`Ｔ７a`.`Ｃ１` = `Ｔ７b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ７b` RIGHT JOIN `Ｔ７a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ７b` RIGHT JOIN `Ｔ７a` ON (`Ｔ７a`.`Ｃ１` = `Ｔ７b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -358,31 +358,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ８a` JOIN `Ｔ８b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ８a` INNER JOIN `Ｔ８b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ８a` CROSS JOIN `Ｔ８b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ８a` LEFT JOIN `Ｔ８b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ８a` LEFT JOIN `Ｔ８b` ON (`Ｔ８a`.`Ｃ１` = `Ｔ８b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ８b` RIGHT JOIN `Ｔ８a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ８b` RIGHT JOIN `Ｔ８a` ON (`Ｔ８a`.`Ｃ１` = `Ｔ８b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -399,31 +399,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ９a` JOIN `Ｔ９b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ９a` INNER JOIN `Ｔ９b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ９a` CROSS JOIN `Ｔ９b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ９a` LEFT JOIN `Ｔ９b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ９a` LEFT JOIN `Ｔ９b` ON (`Ｔ９a`.`Ｃ１` = `Ｔ９b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ９b` RIGHT JOIN `Ｔ９a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ９b` RIGHT JOIN `Ｔ９a` ON (`Ｔ９a`.`Ｃ１` = `Ｔ９b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 @@ -440,31 +440,31 @@ SELECT * FROM ` 幎 幈 幓 幈 SELECT * FROM `Ｔ１０a` JOIN `Ｔ１０b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１０a` INNER JOIN `Ｔ１０b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 +Ｃ１ +幈 SELECT * FROM `Ｔ１０a` CROSS JOIN `Ｔ１０b`; Ｃ１ Ｃ１ 幈 幈 幎 幈 幓 幈 SELECT * FROM `Ｔ１０a` LEFT JOIN `Ｔ１０b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -幎 NULL -幓 NULL +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１０a` LEFT JOIN `Ｔ１０b` ON (`Ｔ１０a`.`Ｃ１` = `Ｔ１０b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 幎 NULL 幓 NULL SELECT * FROM `Ｔ１０b` RIGHT JOIN `Ｔ１０a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -幈 幈 -NULL 幎 -NULL 幓 +Ｃ１ +幈 +幎 +幓 SELECT * FROM `Ｔ１０b` RIGHT JOIN `Ｔ１０a` ON (`Ｔ１０a`.`Ｃ１` = `Ｔ１０b`.`Ｃ１`); Ｃ１ Ｃ１ 幈 幈 @@ -481,31 +481,31 @@ SELECT * FROM ` か あ さ あ SELECT * FROM `Ｔ１１a` JOIN `Ｔ１１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ１１a` INNER JOIN `Ｔ１１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ +Ｃ１ +あ SELECT * FROM `Ｔ１１a` CROSS JOIN `Ｔ１１b`; Ｃ１ Ｃ１ あ あ か あ さ あ SELECT * FROM `Ｔ１１a` LEFT JOIN `Ｔ１１b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -か NULL -さ NULL +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ１１a` LEFT JOIN `Ｔ１１b` ON (`Ｔ１１a`.`Ｃ１` = `Ｔ１１b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ か NULL さ NULL SELECT * FROM `Ｔ１１b` RIGHT JOIN `Ｔ１１a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -あ あ -NULL か -NULL さ +Ｃ１ +あ +か +さ SELECT * FROM `Ｔ１１b` RIGHT JOIN `Ｔ１１a` ON (`Ｔ１１a`.`Ｃ１` = `Ｔ１１b`.`Ｃ１`); Ｃ１ Ｃ１ あ あ @@ -522,31 +522,31 @@ SELECT * FROM ` 忢 忢 忢 忢 SELECT * FROM `Ｔ１２a` JOIN `Ｔ１２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ１２a` INNER JOIN `Ｔ１２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 +Ｃ１ +忢 SELECT * FROM `Ｔ１２a` CROSS JOIN `Ｔ１２b`; Ｃ１ Ｃ１ 忢 忢 忢 忢 忢 忢 SELECT * FROM `Ｔ１２a` LEFT JOIN `Ｔ１２b` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -忢 NULL -忢 NULL +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ１２a` LEFT JOIN `Ｔ１２b` ON (`Ｔ１２a`.`Ｃ１` = `Ｔ１２b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 忢 NULL 忢 NULL SELECT * FROM `Ｔ１２b` RIGHT JOIN `Ｔ１２a` USING (`Ｃ１`); -Ｃ１ Ｃ１ -忢 忢 -NULL 忢 -NULL 忢 +Ｃ１ +忢 +忢 +忢 SELECT * FROM `Ｔ１２b` RIGHT JOIN `Ｔ１２a` ON (`Ｔ１２a`.`Ｃ１` = `Ｔ１２b`.`Ｃ１`); Ｃ１ Ｃ１ 忢 忢 diff --git a/mysql-test/suite/jp/r/jp_join_utf8.result b/mysql-test/suite/jp/r/jp_join_utf8.result index 716e97a2bb3..8c222653c3e 100644 --- a/mysql-test/suite/jp/r/jp_join_utf8.result +++ b/mysql-test/suite/jp/r/jp_join_utf8.result @@ -71,31 +71,31 @@ SELECT * FROM `锛达紤a` INNER JOIN `锛达紤b`; 锝 锝 锝 锝 SELECT * FROM `锛达紤a` JOIN `锛达紤b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紤a` INNER JOIN `锛达紤b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紤a` CROSS JOIN `锛达紤b`; 锛ｏ紤 锛ｏ紤 锝 锝 锝 锝 锝 锝 SELECT * FROM `锛达紤a` LEFT JOIN `锛达紤b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -锝 NULL -锝 NULL +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紤a` LEFT JOIN `锛达紤b` ON (`锛达紤a`.`锛ｏ紤` = `锛达紤b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 锝 NULL 锝 NULL SELECT * FROM `锛达紤b` RIGHT JOIN `锛达紤a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -NULL 锝 -NULL 锝 +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紤b` RIGHT JOIN `锛达紤a` ON (`锛达紤a`.`锛ｏ紤` = `锛达紤b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 @@ -112,31 +112,31 @@ SELECT * FROM `锛达紥a` INNER JOIN `锛达紥b`; 銇 銇 銇 銇 SELECT * FROM `锛达紥a` JOIN `锛达紥b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紥a` INNER JOIN `锛达紥b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紥a` CROSS JOIN `锛达紥b`; 锛ｏ紤 锛ｏ紤 銇 銇 銇 銇 銇 銇 SELECT * FROM `锛达紥a` LEFT JOIN `锛达紥b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -銇 NULL -銇 NULL +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紥a` LEFT JOIN `锛达紥b` ON (`锛达紥a`.`锛ｏ紤` = `锛达紥b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 銇 NULL 銇 NULL SELECT * FROM `锛达紥b` RIGHT JOIN `锛达紥a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -NULL 銇 -NULL 銇 +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紥b` RIGHT JOIN `锛达紥a` ON (`锛达紥a`.`锛ｏ紤` = `锛达紥b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 @@ -153,31 +153,31 @@ SELECT * FROM `锛达紦a` INNER JOIN `锛达紦b`; 榫 榫 榫 榫 SELECT * FROM `锛达紦a` JOIN `锛达紦b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紦a` INNER JOIN `锛达紦b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紦a` CROSS JOIN `锛达紦b`; 锛ｏ紤 锛ｏ紤 榫 榫 榫 榫 榫 榫 SELECT * FROM `锛达紦a` LEFT JOIN `锛达紦b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -榫 NULL -榫 NULL +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紦a` LEFT JOIN `锛达紦b` ON (`锛达紦a`.`锛ｏ紤` = `锛达紦b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 榫 NULL 榫 NULL SELECT * FROM `锛达紦b` RIGHT JOIN `锛达紦a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -NULL 榫 -NULL 榫 +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紦b` RIGHT JOIN `锛达紦a` ON (`锛达紦a`.`锛ｏ紤` = `锛达紦b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 @@ -194,31 +194,31 @@ SELECT * FROM `锛达紨a` INNER JOIN `锛达紨b`; 锝 锝 锝 锝 SELECT * FROM `锛达紨a` JOIN `锛达紨b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紨a` INNER JOIN `锛达紨b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紨a` CROSS JOIN `锛达紨b`; 锛ｏ紤 锛ｏ紤 锝 锝 锝 锝 锝 锝 SELECT * FROM `锛达紨a` LEFT JOIN `锛达紨b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -锝 NULL -锝 NULL +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紨a` LEFT JOIN `锛达紨b` ON (`锛达紨a`.`锛ｏ紤` = `锛达紨b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 锝 NULL 锝 NULL SELECT * FROM `锛达紨b` RIGHT JOIN `锛达紨a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -NULL 锝 -NULL 锝 +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紨b` RIGHT JOIN `锛达紨a` ON (`锛达紨a`.`锛ｏ紤` = `锛达紨b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 @@ -235,31 +235,31 @@ SELECT * FROM `锛达紩a` INNER JOIN `锛达紩b`; 銇 銇 銇 銇 SELECT * FROM `锛达紩a` JOIN `锛达紩b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紩a` INNER JOIN `锛达紩b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紩a` CROSS JOIN `锛达紩b`; 锛ｏ紤 锛ｏ紤 銇 銇 銇 銇 銇 銇 SELECT * FROM `锛达紩a` LEFT JOIN `锛达紩b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -銇 NULL -銇 NULL +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紩a` LEFT JOIN `锛达紩b` ON (`锛达紩a`.`锛ｏ紤` = `锛达紩b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 銇 NULL 銇 NULL SELECT * FROM `锛达紩b` RIGHT JOIN `锛达紩a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -NULL 銇 -NULL 銇 +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紩b` RIGHT JOIN `锛达紩a` ON (`锛达紩a`.`锛ｏ紤` = `锛达紩b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 @@ -276,31 +276,31 @@ SELECT * FROM `锛达紪a` INNER JOIN `锛达紪b`; 榫 榫 榫 榫 SELECT * FROM `锛达紪a` JOIN `锛达紪b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紪a` INNER JOIN `锛达紪b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紪a` CROSS JOIN `锛达紪b`; 锛ｏ紤 锛ｏ紤 榫 榫 榫 榫 榫 榫 SELECT * FROM `锛达紪a` LEFT JOIN `锛达紪b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -榫 NULL -榫 NULL +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紪a` LEFT JOIN `锛达紪b` ON (`锛达紪a`.`锛ｏ紤` = `锛达紪b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 榫 NULL 榫 NULL SELECT * FROM `锛达紪b` RIGHT JOIN `锛达紪a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -NULL 榫 -NULL 榫 +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紪b` RIGHT JOIN `锛达紪a` ON (`锛达紪a`.`锛ｏ紤` = `锛达紪b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 @@ -317,31 +317,31 @@ SELECT * FROM `锛达紬a` INNER JOIN `锛达紬b`; 锝 锝 锝 锝 SELECT * FROM `锛达紬a` JOIN `锛达紬b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紬a` INNER JOIN `锛达紬b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紬a` CROSS JOIN `锛达紬b`; 锛ｏ紤 锛ｏ紤 锝 锝 锝 锝 锝 锝 SELECT * FROM `锛达紬a` LEFT JOIN `锛达紬b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -锝 NULL -锝 NULL +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紬a` LEFT JOIN `锛达紬b` ON (`锛达紬a`.`锛ｏ紤` = `锛达紬b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 锝 NULL 锝 NULL SELECT * FROM `锛达紬b` RIGHT JOIN `锛达紬a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -NULL 锝 -NULL 锝 +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紬b` RIGHT JOIN `锛达紬a` ON (`锛达紬a`.`锛ｏ紤` = `锛达紬b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 @@ -358,31 +358,31 @@ SELECT * FROM `锛达紭a` INNER JOIN `锛达紭b`; 銇 銇 銇 銇 SELECT * FROM `锛达紭a` JOIN `锛达紭b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紭a` INNER JOIN `锛达紭b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紭a` CROSS JOIN `锛达紭b`; 锛ｏ紤 锛ｏ紤 銇 銇 銇 銇 銇 銇 SELECT * FROM `锛达紭a` LEFT JOIN `锛达紭b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -銇 NULL -銇 NULL +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紭a` LEFT JOIN `锛达紭b` ON (`锛达紭a`.`锛ｏ紤` = `锛达紭b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 銇 NULL 銇 NULL SELECT * FROM `锛达紭b` RIGHT JOIN `锛达紭a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -NULL 銇 -NULL 銇 +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紭b` RIGHT JOIN `锛达紭a` ON (`锛达紭a`.`锛ｏ紤` = `锛达紭b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 @@ -399,31 +399,31 @@ SELECT * FROM `锛达紮a` INNER JOIN `锛达紮b`; 榫 榫 榫 榫 SELECT * FROM `锛达紮a` JOIN `锛达紮b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紮a` INNER JOIN `锛达紮b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紮a` CROSS JOIN `锛达紮b`; 锛ｏ紤 锛ｏ紤 榫 榫 榫 榫 榫 榫 SELECT * FROM `锛达紮a` LEFT JOIN `锛达紮b` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -榫 NULL -榫 NULL +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紮a` LEFT JOIN `锛达紮b` ON (`锛达紮a`.`锛ｏ紤` = `锛达紮b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 榫 NULL 榫 NULL SELECT * FROM `锛达紮b` RIGHT JOIN `锛达紮a` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -NULL 榫 -NULL 榫 +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紮b` RIGHT JOIN `锛达紮a` ON (`锛达紮a`.`锛ｏ紤` = `锛达紮b`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 @@ -440,31 +440,31 @@ SELECT * FROM `锛达紤锛恆` INNER JOIN `锛达紤锛恇`; 锝 锝 锝 锝 SELECT * FROM `锛达紤锛恆` JOIN `锛达紤锛恇` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紤锛恆` INNER JOIN `锛达紤锛恇` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 +锛ｏ紤 +锝 SELECT * FROM `锛达紤锛恆` CROSS JOIN `锛达紤锛恇`; 锛ｏ紤 锛ｏ紤 锝 锝 锝 锝 锝 锝 SELECT * FROM `锛达紤锛恆` LEFT JOIN `锛达紤锛恇` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -锝 NULL -锝 NULL +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紤锛恆` LEFT JOIN `锛达紤锛恇` ON (`锛达紤锛恆`.`锛ｏ紤` = `锛达紤锛恇`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 锝 NULL 锝 NULL SELECT * FROM `锛达紤锛恇` RIGHT JOIN `锛达紤锛恆` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -锝 锝 -NULL 锝 -NULL 锝 +锛ｏ紤 +锝 +锝 +锝 SELECT * FROM `锛达紤锛恇` RIGHT JOIN `锛达紤锛恆` ON (`锛达紤锛恆`.`锛ｏ紤` = `锛达紤锛恇`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 锝 锝 @@ -481,31 +481,31 @@ SELECT * FROM `锛达紤锛慳` INNER JOIN `锛达紤锛慴`; 銇 銇 銇 銇 SELECT * FROM `锛达紤锛慳` JOIN `锛达紤锛慴` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紤锛慳` INNER JOIN `锛达紤锛慴` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 +锛ｏ紤 +銇 SELECT * FROM `锛达紤锛慳` CROSS JOIN `锛达紤锛慴`; 锛ｏ紤 锛ｏ紤 銇 銇 銇 銇 銇 銇 SELECT * FROM `锛达紤锛慳` LEFT JOIN `锛达紤锛慴` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -銇 NULL -銇 NULL +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紤锛慳` LEFT JOIN `锛达紤锛慴` ON (`锛达紤锛慳`.`锛ｏ紤` = `锛达紤锛慴`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 銇 NULL 銇 NULL SELECT * FROM `锛达紤锛慴` RIGHT JOIN `锛达紤锛慳` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -銇 銇 -NULL 銇 -NULL 銇 +锛ｏ紤 +銇 +銇 +銇 SELECT * FROM `锛达紤锛慴` RIGHT JOIN `锛达紤锛慳` ON (`锛达紤锛慳`.`锛ｏ紤` = `锛达紤锛慴`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 銇 銇 @@ -522,31 +522,31 @@ SELECT * FROM `锛达紤锛抋` INNER JOIN `锛达紤锛抌`; 榫 榫 榫 榫 SELECT * FROM `锛达紤锛抋` JOIN `锛达紤锛抌` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紤锛抋` INNER JOIN `锛达紤锛抌` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 +锛ｏ紤 +榫 SELECT * FROM `锛达紤锛抋` CROSS JOIN `锛达紤锛抌`; 锛ｏ紤 锛ｏ紤 榫 榫 榫 榫 榫 榫 SELECT * FROM `锛达紤锛抋` LEFT JOIN `锛达紤锛抌` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -榫 NULL -榫 NULL +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紤锛抋` LEFT JOIN `锛达紤锛抌` ON (`锛达紤锛抋`.`锛ｏ紤` = `锛达紤锛抌`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 榫 NULL 榫 NULL SELECT * FROM `锛达紤锛抌` RIGHT JOIN `锛达紤锛抋` USING (`锛ｏ紤`); -锛ｏ紤 锛ｏ紤 -榫 榫 -NULL 榫 -NULL 榫 +锛ｏ紤 +榫 +榫 +榫 SELECT * FROM `锛达紤锛抌` RIGHT JOIN `锛达紤锛抋` ON (`锛达紤锛抋`.`锛ｏ紤` = `锛达紤锛抌`.`锛ｏ紤`); 锛ｏ紤 锛ｏ紤 榫 榫 diff --git a/mysql-test/suite/jp/r/jp_select_sjis.result b/mysql-test/suite/jp/r/jp_select_sjis.result index d48d08d745f..652b538fb88 100644 --- a/mysql-test/suite/jp/r/jp_select_sjis.result +++ b/mysql-test/suite/jp/r/jp_select_sjis.result @@ -118,6 +118,7 @@ SELECT * FROM ` 陳陸陹険陻陼陽陾陿隀隁隂隃隄隇丒丒丒丒丒 SELECT * FROM `俿俁`; 俠侾 + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT * FROM `俿係`; 俠侾 @@ -201,6 +202,7 @@ SELECT * FROM ` 陳陸陹険陻陼陽陾陿隀隁隂隃隄隇丒丒丒丒丒 SELECT * FROM `俿俇`; 俠侾 + 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 SELECT * FROM `俿俈`; 俠侾 @@ -285,6 +287,7 @@ SELECT * FROM ` SELECT * FROM `俿俋`; 俠侾 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + SELECT * FROM `俿侾侽`; 俠侾 !"#$%&'()*+,-./ @@ -368,6 +371,7 @@ SELECT * FROM ` SELECT * FROM `俿侾俀`; 俠侾 僜廫昞梊峔塡嶾怽揬擻朶榎慭抃橽歕沑淺漒瀄 + drop table `俿侾`; drop table `俿俀`; drop table `俿俁`; diff --git a/mysql-test/suite/jp/t/jp_alter_sjis.test b/mysql-test/suite/jp/t/jp_alter_sjis.test index b7b31862599..f250afcf5dd 100644 --- a/mysql-test/suite/jp/t/jp_alter_sjis.test +++ b/mysql-test/suite/jp/t/jp_alter_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis SET NAMES sjis; SET character_set_database = sjis; diff --git a/mysql-test/suite/jp/t/jp_alter_ucs2.test b/mysql-test/suite/jp/t/jp_alter_ucs2.test index 6c5b3132edf..27cf5b72839 100644 --- a/mysql-test/suite/jp/t/jp_alter_ucs2.test +++ b/mysql-test/suite/jp/t/jp_alter_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_alter_ujis.test b/mysql-test/suite/jp/t/jp_alter_ujis.test index d388d20c49b..b817f608446 100644 --- a/mysql-test/suite/jp/t/jp_alter_ujis.test +++ b/mysql-test/suite/jp/t/jp_alter_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_alter_utf8.test b/mysql-test/suite/jp/t/jp_alter_utf8.test index 6771343f38f..60a67485ba5 100644 --- a/mysql-test/suite/jp/t/jp_alter_utf8.test +++ b/mysql-test/suite/jp/t/jp_alter_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings DROP TABLE IF EXISTS `锝憋奖锝盽; DROP TABLE IF EXISTS `锝诧讲锝瞏; diff --git a/mysql-test/suite/jp/t/jp_charlength_sjis.test b/mysql-test/suite/jp/t/jp_charlength_sjis.test index 5f3543bb7a6..350605450da 100644 --- a/mysql-test/suite/jp/t/jp_charlength_sjis.test +++ b/mysql-test/suite/jp/t/jp_charlength_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_charlength_ucs2.test b/mysql-test/suite/jp/t/jp_charlength_ucs2.test index 2db9db7cfc6..714ced47ff8 100644 --- a/mysql-test/suite/jp/t/jp_charlength_ucs2.test +++ b/mysql-test/suite/jp/t/jp_charlength_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_charlength_ujis.test b/mysql-test/suite/jp/t/jp_charlength_ujis.test index 08973231f27..923bffef540 100644 --- a/mysql-test/suite/jp/t/jp_charlength_ujis.test +++ b/mysql-test/suite/jp/t/jp_charlength_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_charlength_utf8.test b/mysql-test/suite/jp/t/jp_charlength_utf8.test index a3f74db27ee..bc099caf74a 100644 --- a/mysql-test/suite/jp/t/jp_charlength_utf8.test +++ b/mysql-test/suite/jp/t/jp_charlength_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_charset_sjis.test b/mysql-test/suite/jp/t/jp_charset_sjis.test index 3a9f264bdfe..276be86cd9d 100644 --- a/mysql-test/suite/jp/t/jp_charset_sjis.test +++ b/mysql-test/suite/jp/t/jp_charset_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_charset_ucs2.test b/mysql-test/suite/jp/t/jp_charset_ucs2.test index 5183071033b..f7971095fa6 100644 --- a/mysql-test/suite/jp/t/jp_charset_ucs2.test +++ b/mysql-test/suite/jp/t/jp_charset_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_charset_ujis.test b/mysql-test/suite/jp/t/jp_charset_ujis.test index de9ef318530..a8a6544537a 100644 --- a/mysql-test/suite/jp/t/jp_charset_ujis.test +++ b/mysql-test/suite/jp/t/jp_charset_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_charset_utf8.test b/mysql-test/suite/jp/t/jp_charset_utf8.test index 2d73daba42a..7d8311c2f72 100644 --- a/mysql-test/suite/jp/t/jp_charset_utf8.test +++ b/mysql-test/suite/jp/t/jp_charset_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_convert_sjis.test b/mysql-test/suite/jp/t/jp_convert_sjis.test index 93fa33029bf..835328c92eb 100644 --- a/mysql-test/suite/jp/t/jp_convert_sjis.test +++ b/mysql-test/suite/jp/t/jp_convert_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis SET NAMES sjis; SET character_set_database = sjis; diff --git a/mysql-test/suite/jp/t/jp_convert_ucs2.test b/mysql-test/suite/jp/t/jp_convert_ucs2.test index 88b0d0c9cba..3ed4efe158d 100644 --- a/mysql-test/suite/jp/t/jp_convert_ucs2.test +++ b/mysql-test/suite/jp/t/jp_convert_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_convert_ujis.test b/mysql-test/suite/jp/t/jp_convert_ujis.test index d6303b66f34..4409b6cad90 100644 --- a/mysql-test/suite/jp/t/jp_convert_ujis.test +++ b/mysql-test/suite/jp/t/jp_convert_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_convert_utf8.test b/mysql-test/suite/jp/t/jp_convert_utf8.test index a687b0f06cb..e7c180e72fc 100644 --- a/mysql-test/suite/jp/t/jp_convert_utf8.test +++ b/mysql-test/suite/jp/t/jp_convert_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_create_tbl_sjis.test b/mysql-test/suite/jp/t/jp_create_tbl_sjis.test index 45c0b24388b..93f3ac3c4a3 100644 --- a/mysql-test/suite/jp/t/jp_create_tbl_sjis.test +++ b/mysql-test/suite/jp/t/jp_create_tbl_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis SET NAMES sjis; SET character_set_database = sjis; diff --git a/mysql-test/suite/jp/t/jp_create_tbl_ucs2.test b/mysql-test/suite/jp/t/jp_create_tbl_ucs2.test index 519697e3530..553ef8a4dad 100644 --- a/mysql-test/suite/jp/t/jp_create_tbl_ucs2.test +++ b/mysql-test/suite/jp/t/jp_create_tbl_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_create_tbl_ujis.test b/mysql-test/suite/jp/t/jp_create_tbl_ujis.test index ac70facdce9..1106ddc1417 100644 --- a/mysql-test/suite/jp/t/jp_create_tbl_ujis.test +++ b/mysql-test/suite/jp/t/jp_create_tbl_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_create_tbl_utf8.test b/mysql-test/suite/jp/t/jp_create_tbl_utf8.test index 5c816eb169a..9b0ece77e34 100644 --- a/mysql-test/suite/jp/t/jp_create_tbl_utf8.test +++ b/mysql-test/suite/jp/t/jp_create_tbl_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings DROP TABLE IF EXISTS `锝憋奖锝盽; DROP TABLE IF EXISTS `锝诧讲锝瞏; diff --git a/mysql-test/suite/jp/t/jp_enum_sjis.test b/mysql-test/suite/jp/t/jp_enum_sjis.test index 2ea1bf320e0..c433e0bcac4 100644 --- a/mysql-test/suite/jp/t/jp_enum_sjis.test +++ b/mysql-test/suite/jp/t/jp_enum_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_enum_ucs2.test b/mysql-test/suite/jp/t/jp_enum_ucs2.test index 2239ebab478..79f5952cf97 100644 --- a/mysql-test/suite/jp/t/jp_enum_ucs2.test +++ b/mysql-test/suite/jp/t/jp_enum_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc # half-with kana is not handled correctly in 4.1 diff --git a/mysql-test/suite/jp/t/jp_enum_ujis.test b/mysql-test/suite/jp/t/jp_enum_ujis.test index da41165aad0..f48d176ec6b 100644 --- a/mysql-test/suite/jp/t/jp_enum_ujis.test +++ b/mysql-test/suite/jp/t/jp_enum_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_enum_utf8.test b/mysql-test/suite/jp/t/jp_enum_utf8.test index 4ce3576b604..64fe2129164 100644 --- a/mysql-test/suite/jp/t/jp_enum_utf8.test +++ b/mysql-test/suite/jp/t/jp_enum_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_insert_sjis.test b/mysql-test/suite/jp/t/jp_insert_sjis.test index 0266ad1eaca..a940eeb5782 100644 --- a/mysql-test/suite/jp/t/jp_insert_sjis.test +++ b/mysql-test/suite/jp/t/jp_insert_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_insert_ucs2.test b/mysql-test/suite/jp/t/jp_insert_ucs2.test index 9b0a02e57d8..443f6f1107b 100644 --- a/mysql-test/suite/jp/t/jp_insert_ucs2.test +++ b/mysql-test/suite/jp/t/jp_insert_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_insert_ujis.test b/mysql-test/suite/jp/t/jp_insert_ujis.test index 7b6d2838386..ab82db59326 100644 --- a/mysql-test/suite/jp/t/jp_insert_ujis.test +++ b/mysql-test/suite/jp/t/jp_insert_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_insert_utf8.test b/mysql-test/suite/jp/t/jp_insert_utf8.test index ef6acb90063..e8c41bab4ea 100644 --- a/mysql-test/suite/jp/t/jp_insert_utf8.test +++ b/mysql-test/suite/jp/t/jp_insert_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_instr_sjis.test b/mysql-test/suite/jp/t/jp_instr_sjis.test index c19b5f2b14c..83480ea0267 100644 --- a/mysql-test/suite/jp/t/jp_instr_sjis.test +++ b/mysql-test/suite/jp/t/jp_instr_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_instr_ucs2.test b/mysql-test/suite/jp/t/jp_instr_ucs2.test index b8f83961e90..7b442d09a3d 100644 --- a/mysql-test/suite/jp/t/jp_instr_ucs2.test +++ b/mysql-test/suite/jp/t/jp_instr_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_instr_ujis.test b/mysql-test/suite/jp/t/jp_instr_ujis.test index 696e1147372..d0373ba73ce 100644 --- a/mysql-test/suite/jp/t/jp_instr_ujis.test +++ b/mysql-test/suite/jp/t/jp_instr_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_instr_utf8.test b/mysql-test/suite/jp/t/jp_instr_utf8.test index b25b72bc8d0..c7491101872 100644 --- a/mysql-test/suite/jp/t/jp_instr_utf8.test +++ b/mysql-test/suite/jp/t/jp_instr_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_join_sjis.test b/mysql-test/suite/jp/t/jp_join_sjis.test index 30b23913929..77d1dc15c5c 100644 --- a/mysql-test/suite/jp/t/jp_join_sjis.test +++ b/mysql-test/suite/jp/t/jp_join_sjis.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_join_ucs2.test b/mysql-test/suite/jp/t/jp_join_ucs2.test index 27e49203dd2..276af80f7af 100644 --- a/mysql-test/suite/jp/t/jp_join_ucs2.test +++ b/mysql-test/suite/jp/t/jp_join_ucs2.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_join_ujis.test b/mysql-test/suite/jp/t/jp_join_ujis.test index 079f260cc26..5716ee12e60 100644 --- a/mysql-test/suite/jp/t/jp_join_ujis.test +++ b/mysql-test/suite/jp/t/jp_join_ujis.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_join_utf8.test b/mysql-test/suite/jp/t/jp_join_utf8.test index 0b2f033f8bb..36f8e930bc3 100644 --- a/mysql-test/suite/jp/t/jp_join_utf8.test +++ b/mysql-test/suite/jp/t/jp_join_utf8.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_left_sjis.test b/mysql-test/suite/jp/t/jp_left_sjis.test index 5d69d9892e2..e93e92493a1 100644 --- a/mysql-test/suite/jp/t/jp_left_sjis.test +++ b/mysql-test/suite/jp/t/jp_left_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_left_ucs2.test b/mysql-test/suite/jp/t/jp_left_ucs2.test index 59d10b7d736..2c1be4a7e6a 100644 --- a/mysql-test/suite/jp/t/jp_left_ucs2.test +++ b/mysql-test/suite/jp/t/jp_left_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_left_ujis.test b/mysql-test/suite/jp/t/jp_left_ujis.test index 718639cd8a4..f639bf643df 100644 --- a/mysql-test/suite/jp/t/jp_left_ujis.test +++ b/mysql-test/suite/jp/t/jp_left_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_left_utf8.test b/mysql-test/suite/jp/t/jp_left_utf8.test index f9c99718e0f..63d9061a879 100644 --- a/mysql-test/suite/jp/t/jp_left_utf8.test +++ b/mysql-test/suite/jp/t/jp_left_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_length_sjis.test b/mysql-test/suite/jp/t/jp_length_sjis.test index 7023891b7f0..81121a4432e 100644 --- a/mysql-test/suite/jp/t/jp_length_sjis.test +++ b/mysql-test/suite/jp/t/jp_length_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_length_ucs2.test b/mysql-test/suite/jp/t/jp_length_ucs2.test index 9951c9b6cd1..1dcc975d868 100644 --- a/mysql-test/suite/jp/t/jp_length_ucs2.test +++ b/mysql-test/suite/jp/t/jp_length_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_length_ujis.test b/mysql-test/suite/jp/t/jp_length_ujis.test index ac3aef2c768..ad41c7a7113 100644 --- a/mysql-test/suite/jp/t/jp_length_ujis.test +++ b/mysql-test/suite/jp/t/jp_length_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_length_utf8.test b/mysql-test/suite/jp/t/jp_length_utf8.test index 5c5021f37be..7bfe1896034 100644 --- a/mysql-test/suite/jp/t/jp_length_utf8.test +++ b/mysql-test/suite/jp/t/jp_length_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_like_sjis.test b/mysql-test/suite/jp/t/jp_like_sjis.test index 5c41b9ff7ef..1cb7aadb876 100644 --- a/mysql-test/suite/jp/t/jp_like_sjis.test +++ b/mysql-test/suite/jp/t/jp_like_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_like_ucs2.test b/mysql-test/suite/jp/t/jp_like_ucs2.test index feae40de49e..1f9b7c09b9d 100644 --- a/mysql-test/suite/jp/t/jp_like_ucs2.test +++ b/mysql-test/suite/jp/t/jp_like_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_like_ujis.test b/mysql-test/suite/jp/t/jp_like_ujis.test index 29ef7c5d48b..56c4fa8a8b0 100644 --- a/mysql-test/suite/jp/t/jp_like_ujis.test +++ b/mysql-test/suite/jp/t/jp_like_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_like_utf8.test b/mysql-test/suite/jp/t/jp_like_utf8.test index 4247242029d..f6cc895d814 100644 --- a/mysql-test/suite/jp/t/jp_like_utf8.test +++ b/mysql-test/suite/jp/t/jp_like_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_locate_sjis.test b/mysql-test/suite/jp/t/jp_locate_sjis.test index 92c671199b6..a015109e2a3 100644 --- a/mysql-test/suite/jp/t/jp_locate_sjis.test +++ b/mysql-test/suite/jp/t/jp_locate_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_locate_ucs2.test b/mysql-test/suite/jp/t/jp_locate_ucs2.test index d00ad67235a..111caefb02e 100644 --- a/mysql-test/suite/jp/t/jp_locate_ucs2.test +++ b/mysql-test/suite/jp/t/jp_locate_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_locate_ujis.test b/mysql-test/suite/jp/t/jp_locate_ujis.test index 5375fad75db..872555a4532 100644 --- a/mysql-test/suite/jp/t/jp_locate_ujis.test +++ b/mysql-test/suite/jp/t/jp_locate_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_locate_utf8.test b/mysql-test/suite/jp/t/jp_locate_utf8.test index cbf6714e322..85d2e69fd60 100644 --- a/mysql-test/suite/jp/t/jp_locate_utf8.test +++ b/mysql-test/suite/jp/t/jp_locate_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_lpad_sjis.test b/mysql-test/suite/jp/t/jp_lpad_sjis.test index 7038112cbc8..4b18402473d 100644 --- a/mysql-test/suite/jp/t/jp_lpad_sjis.test +++ b/mysql-test/suite/jp/t/jp_lpad_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_lpad_ucs2.test b/mysql-test/suite/jp/t/jp_lpad_ucs2.test index e3bead0855a..95dd088abce 100644 --- a/mysql-test/suite/jp/t/jp_lpad_ucs2.test +++ b/mysql-test/suite/jp/t/jp_lpad_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_lpad_ujis.test b/mysql-test/suite/jp/t/jp_lpad_ujis.test index eea4877ec3a..c1149a67207 100644 --- a/mysql-test/suite/jp/t/jp_lpad_ujis.test +++ b/mysql-test/suite/jp/t/jp_lpad_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_lpad_utf8.test b/mysql-test/suite/jp/t/jp_lpad_utf8.test index 599bf5eba28..42aa2fd860b 100644 --- a/mysql-test/suite/jp/t/jp_lpad_utf8.test +++ b/mysql-test/suite/jp/t/jp_lpad_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_ltrim_sjis.test b/mysql-test/suite/jp/t/jp_ltrim_sjis.test index 864238df07c..7b5e20ec9a4 100644 --- a/mysql-test/suite/jp/t/jp_ltrim_sjis.test +++ b/mysql-test/suite/jp/t/jp_ltrim_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_ltrim_ucs2.test b/mysql-test/suite/jp/t/jp_ltrim_ucs2.test index 0ae647f5222..25a6eaabc60 100644 --- a/mysql-test/suite/jp/t/jp_ltrim_ucs2.test +++ b/mysql-test/suite/jp/t/jp_ltrim_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_ltrim_ujis.test b/mysql-test/suite/jp/t/jp_ltrim_ujis.test index 64363aa330b..fbba90a38b5 100644 --- a/mysql-test/suite/jp/t/jp_ltrim_ujis.test +++ b/mysql-test/suite/jp/t/jp_ltrim_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_ltrim_utf8.test b/mysql-test/suite/jp/t/jp_ltrim_utf8.test index 846ce11163b..b33d22e459d 100644 --- a/mysql-test/suite/jp/t/jp_ltrim_utf8.test +++ b/mysql-test/suite/jp/t/jp_ltrim_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_ps_sjis.test b/mysql-test/suite/jp/t/jp_ps_sjis.test index cc93dca2a79..2e09c51cf7a 100644 --- a/mysql-test/suite/jp/t/jp_ps_sjis.test +++ b/mysql-test/suite/jp/t/jp_ps_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings DROP TABLE IF EXISTS t1; diff --git a/mysql-test/suite/jp/t/jp_ps_ujis.test b/mysql-test/suite/jp/t/jp_ps_ujis.test index 7d61c12e496..ab64fcf5216 100644 --- a/mysql-test/suite/jp/t/jp_ps_ujis.test +++ b/mysql-test/suite/jp/t/jp_ps_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_replace_sjis.test b/mysql-test/suite/jp/t/jp_replace_sjis.test index 811d3350a34..91996ba83e9 100644 --- a/mysql-test/suite/jp/t/jp_replace_sjis.test +++ b/mysql-test/suite/jp/t/jp_replace_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_replace_ucs2.test b/mysql-test/suite/jp/t/jp_replace_ucs2.test index 7739a30cd9c..3043115ef62 100644 --- a/mysql-test/suite/jp/t/jp_replace_ucs2.test +++ b/mysql-test/suite/jp/t/jp_replace_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_replace_ujis.test b/mysql-test/suite/jp/t/jp_replace_ujis.test index 3d8724e63d5..1ba29426010 100644 --- a/mysql-test/suite/jp/t/jp_replace_ujis.test +++ b/mysql-test/suite/jp/t/jp_replace_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_replace_utf8.test b/mysql-test/suite/jp/t/jp_replace_utf8.test index 1d89a43648b..81b892a5df7 100644 --- a/mysql-test/suite/jp/t/jp_replace_utf8.test +++ b/mysql-test/suite/jp/t/jp_replace_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_reverse_sjis.test b/mysql-test/suite/jp/t/jp_reverse_sjis.test index c1e2b2a17ca..5d9014dc3a6 100644 --- a/mysql-test/suite/jp/t/jp_reverse_sjis.test +++ b/mysql-test/suite/jp/t/jp_reverse_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_reverse_ucs2.test b/mysql-test/suite/jp/t/jp_reverse_ucs2.test index d91ec7f70e8..95afeeda570 100644 --- a/mysql-test/suite/jp/t/jp_reverse_ucs2.test +++ b/mysql-test/suite/jp/t/jp_reverse_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_reverse_ujis.test b/mysql-test/suite/jp/t/jp_reverse_ujis.test index d37d363f59a..0d66201c367 100644 --- a/mysql-test/suite/jp/t/jp_reverse_ujis.test +++ b/mysql-test/suite/jp/t/jp_reverse_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_reverse_utf8.test b/mysql-test/suite/jp/t/jp_reverse_utf8.test index 4e53d4be049..ee323b64ada 100644 --- a/mysql-test/suite/jp/t/jp_reverse_utf8.test +++ b/mysql-test/suite/jp/t/jp_reverse_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_right_sjis.test b/mysql-test/suite/jp/t/jp_right_sjis.test index f481ec532ec..edf3795c510 100644 --- a/mysql-test/suite/jp/t/jp_right_sjis.test +++ b/mysql-test/suite/jp/t/jp_right_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_right_ucs2.test b/mysql-test/suite/jp/t/jp_right_ucs2.test index 23ca2fa4fae..d3132b3e11f 100644 --- a/mysql-test/suite/jp/t/jp_right_ucs2.test +++ b/mysql-test/suite/jp/t/jp_right_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_right_ujis.test b/mysql-test/suite/jp/t/jp_right_ujis.test index b5284489c7e..92cd7ed83dc 100644 --- a/mysql-test/suite/jp/t/jp_right_ujis.test +++ b/mysql-test/suite/jp/t/jp_right_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_right_utf8.test b/mysql-test/suite/jp/t/jp_right_utf8.test index 863755c1dcf..6d884e55771 100644 --- a/mysql-test/suite/jp/t/jp_right_utf8.test +++ b/mysql-test/suite/jp/t/jp_right_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_rpad_sjis.test b/mysql-test/suite/jp/t/jp_rpad_sjis.test index cc008631548..1bf752020bb 100644 --- a/mysql-test/suite/jp/t/jp_rpad_sjis.test +++ b/mysql-test/suite/jp/t/jp_rpad_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_rpad_ucs2.test b/mysql-test/suite/jp/t/jp_rpad_ucs2.test index ca5059497d3..f3876dafe2f 100644 --- a/mysql-test/suite/jp/t/jp_rpad_ucs2.test +++ b/mysql-test/suite/jp/t/jp_rpad_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_rpad_ujis.test b/mysql-test/suite/jp/t/jp_rpad_ujis.test index d7725b80af7..6ace7442b8d 100644 --- a/mysql-test/suite/jp/t/jp_rpad_ujis.test +++ b/mysql-test/suite/jp/t/jp_rpad_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_rpad_utf8.test b/mysql-test/suite/jp/t/jp_rpad_utf8.test index b5a335bc6ce..6c075e20cb9 100644 --- a/mysql-test/suite/jp/t/jp_rpad_utf8.test +++ b/mysql-test/suite/jp/t/jp_rpad_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_rtrim_sjis.test b/mysql-test/suite/jp/t/jp_rtrim_sjis.test index c80cf9410f9..1a9511698ce 100644 --- a/mysql-test/suite/jp/t/jp_rtrim_sjis.test +++ b/mysql-test/suite/jp/t/jp_rtrim_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_rtrim_ucs2.test b/mysql-test/suite/jp/t/jp_rtrim_ucs2.test index 0fac38d12d1..2132eaa5cbe 100644 --- a/mysql-test/suite/jp/t/jp_rtrim_ucs2.test +++ b/mysql-test/suite/jp/t/jp_rtrim_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_rtrim_ujis.test b/mysql-test/suite/jp/t/jp_rtrim_ujis.test index 46cda84dd55..07b42b96dfd 100644 --- a/mysql-test/suite/jp/t/jp_rtrim_ujis.test +++ b/mysql-test/suite/jp/t/jp_rtrim_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_rtrim_utf8.test b/mysql-test/suite/jp/t/jp_rtrim_utf8.test index 4880a42db3e..48f863d891c 100644 --- a/mysql-test/suite/jp/t/jp_rtrim_utf8.test +++ b/mysql-test/suite/jp/t/jp_rtrim_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_select_sjis.test b/mysql-test/suite/jp/t/jp_select_sjis.test index d84ed7a4b2c..fc80ce01471 100644 --- a/mysql-test/suite/jp/t/jp_select_sjis.test +++ b/mysql-test/suite/jp/t/jp_select_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_select_ucs2.test b/mysql-test/suite/jp/t/jp_select_ucs2.test index 2e4602e7ea4..6cebdb65db1 100644 --- a/mysql-test/suite/jp/t/jp_select_ucs2.test +++ b/mysql-test/suite/jp/t/jp_select_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_select_ujis.test b/mysql-test/suite/jp/t/jp_select_ujis.test index 4ad9e581a92..0e4d1ffc771 100644 --- a/mysql-test/suite/jp/t/jp_select_ujis.test +++ b/mysql-test/suite/jp/t/jp_select_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_select_utf8.test b/mysql-test/suite/jp/t/jp_select_utf8.test index e614b9ccfb0..88fd6677f7c 100644 --- a/mysql-test/suite/jp/t/jp_select_utf8.test +++ b/mysql-test/suite/jp/t/jp_select_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_subquery_sjis.test b/mysql-test/suite/jp/t/jp_subquery_sjis.test index 5292c7a2519..b6aa3e52f51 100644 --- a/mysql-test/suite/jp/t/jp_subquery_sjis.test +++ b/mysql-test/suite/jp/t/jp_subquery_sjis.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_subquery_ucs2.test b/mysql-test/suite/jp/t/jp_subquery_ucs2.test index 311433438f4..d2c1fd29358 100644 --- a/mysql-test/suite/jp/t/jp_subquery_ucs2.test +++ b/mysql-test/suite/jp/t/jp_subquery_ucs2.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_subquery_ujis.test b/mysql-test/suite/jp/t/jp_subquery_ujis.test index 67c9f00fd85..2fd0427481c 100644 --- a/mysql-test/suite/jp/t/jp_subquery_ujis.test +++ b/mysql-test/suite/jp/t/jp_subquery_ujis.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_subquery_utf8.test b/mysql-test/suite/jp/t/jp_subquery_utf8.test index 97c2df8ce30..460f1c1a903 100644 --- a/mysql-test/suite/jp/t/jp_subquery_utf8.test +++ b/mysql-test/suite/jp/t/jp_subquery_utf8.test @@ -1,3 +1,4 @@ +-- source include/have_innodb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_substring_sjis.test b/mysql-test/suite/jp/t/jp_substring_sjis.test index ac929114880..a6c9496a873 100644 --- a/mysql-test/suite/jp/t/jp_substring_sjis.test +++ b/mysql-test/suite/jp/t/jp_substring_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_substring_ucs2.test b/mysql-test/suite/jp/t/jp_substring_ucs2.test index f3cd5550072..71c0f903aa8 100644 --- a/mysql-test/suite/jp/t/jp_substring_ucs2.test +++ b/mysql-test/suite/jp/t/jp_substring_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_substring_ujis.test b/mysql-test/suite/jp/t/jp_substring_ujis.test index c201c7148da..c93ab761352 100644 --- a/mysql-test/suite/jp/t/jp_substring_ujis.test +++ b/mysql-test/suite/jp/t/jp_substring_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_substring_utf8.test b/mysql-test/suite/jp/t/jp_substring_utf8.test index 9f88115c899..3bd1bbbb491 100644 --- a/mysql-test/suite/jp/t/jp_substring_utf8.test +++ b/mysql-test/suite/jp/t/jp_substring_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_trim_sjis.test b/mysql-test/suite/jp/t/jp_trim_sjis.test index 0f6821605ed..04dc832d49f 100644 --- a/mysql-test/suite/jp/t/jp_trim_sjis.test +++ b/mysql-test/suite/jp/t/jp_trim_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_trim_ucs2.test b/mysql-test/suite/jp/t/jp_trim_ucs2.test index 1d8a12650e0..7c82c249dcc 100644 --- a/mysql-test/suite/jp/t/jp_trim_ucs2.test +++ b/mysql-test/suite/jp/t/jp_trim_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_trim_ujis.test b/mysql-test/suite/jp/t/jp_trim_ujis.test index de401217fcf..bcd9942f0ae 100644 --- a/mysql-test/suite/jp/t/jp_trim_ujis.test +++ b/mysql-test/suite/jp/t/jp_trim_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_trim_utf8.test b/mysql-test/suite/jp/t/jp_trim_utf8.test index 0777de15c36..f6f487254bc 100644 --- a/mysql-test/suite/jp/t/jp_trim_utf8.test +++ b/mysql-test/suite/jp/t/jp_trim_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_union_ujis.test b/mysql-test/suite/jp/t/jp_union_ujis.test index e36d18c85c0..c1252b9f5a2 100644 --- a/mysql-test/suite/jp/t/jp_union_ujis.test +++ b/mysql-test/suite/jp/t/jp_union_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_update_sjis.test b/mysql-test/suite/jp/t/jp_update_sjis.test index 0dc7372ae92..4b3733cff76 100644 --- a/mysql-test/suite/jp/t/jp_update_sjis.test +++ b/mysql-test/suite/jp/t/jp_update_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_update_ucs2.test b/mysql-test/suite/jp/t/jp_update_ucs2.test index 7a3c1233210..6ad7db9c5a0 100644 --- a/mysql-test/suite/jp/t/jp_update_ucs2.test +++ b/mysql-test/suite/jp/t/jp_update_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_update_ujis.test b/mysql-test/suite/jp/t/jp_update_ujis.test index 852e45b9eeb..14ca6580f04 100644 --- a/mysql-test/suite/jp/t/jp_update_ujis.test +++ b/mysql-test/suite/jp/t/jp_update_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_update_utf8.test b/mysql-test/suite/jp/t/jp_update_utf8.test index b4b3d18ecab..135f6e6981c 100644 --- a/mysql-test/suite/jp/t/jp_update_utf8.test +++ b/mysql-test/suite/jp/t/jp_update_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; diff --git a/mysql-test/suite/jp/t/jp_where_sjis.test b/mysql-test/suite/jp/t/jp_where_sjis.test index 452d137f643..890a4c28f3c 100644 --- a/mysql-test/suite/jp/t/jp_where_sjis.test +++ b/mysql-test/suite/jp/t/jp_where_sjis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --character_set sjis --disable_warnings drop table if exists `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_where_ucs2.test b/mysql-test/suite/jp/t/jp_where_ucs2.test index 3b82eacd615..7d90faaaa89 100644 --- a/mysql-test/suite/jp/t/jp_where_ucs2.test +++ b/mysql-test/suite/jp/t/jp_where_ucs2.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ucs2.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_where_ujis.test b/mysql-test/suite/jp/t/jp_where_ujis.test index e96404fbb17..2f0924e8c8e 100644 --- a/mysql-test/suite/jp/t/jp_where_ujis.test +++ b/mysql-test/suite/jp/t/jp_where_ujis.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --source include/have_ujis.inc --disable_warnings diff --git a/mysql-test/suite/jp/t/jp_where_utf8.test b/mysql-test/suite/jp/t/jp_where_utf8.test index 7280bc33f21..231553e8819 100644 --- a/mysql-test/suite/jp/t/jp_where_utf8.test +++ b/mysql-test/suite/jp/t/jp_where_utf8.test @@ -1,3 +1,5 @@ +-- source include/have_innodb.inc +-- source include/have_bdb.inc --disable_warnings drop table if exists `锛达紤`; drop table if exists `锛达紥`; From df1660986e207ed0e7bdd4516a147ac83d983d1e Mon Sep 17 00:00:00 2001 From: hery Date: Wed, 9 Sep 2009 20:52:17 +0200 Subject: [PATCH 05/13] change c++ comment to c comment --- client/mysqltest.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/mysqltest.c b/client/mysqltest.c index 79df511641d..4f8e6cdac99 100644 --- a/client/mysqltest.c +++ b/client/mysqltest.c @@ -1406,7 +1406,7 @@ void show_diff(DYNAMIC_STRING* ds, else diff_name = 0; #else - diff_name = "diff"; // Otherwise always assume it's called diff + diff_name = "diff"; /* Otherwise always assume it's called diff */ #endif if (diff_name) From 10406ae65871de074e807e626f9ede686e9321d4 Mon Sep 17 00:00:00 2001 From: Sergey Glukhov Date: Thu, 10 Sep 2009 15:24:07 +0500 Subject: [PATCH 06/13] Bug#46815 CONCAT_WS returning wrong data The problem is that argument buffer can be used as result buffer and it leads to argument value change. The fix is to use 'old buffer' as result buffer only if first argument is not constant item. mysql-test/r/func_str.result: test result mysql-test/t/func_str.test: test case sql/item_strfunc.cc: The problem is that argument buffer can be used as result buffer and it leads to argument value change. The fix is to use 'old buffer' as result buffer only if first argument is not constant item. --- mysql-test/r/func_str.result | 9 +++++++++ mysql-test/t/func_str.test | 13 +++++++++++++ sql/item_strfunc.cc | 7 ++++++- 3 files changed, 28 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/func_str.result b/mysql-test/r/func_str.result index 75f8983e838..bf2a9ca8901 100644 --- a/mysql-test/r/func_str.result +++ b/mysql-test/r/func_str.result @@ -2196,4 +2196,13 @@ SELECT LOAD_FILE(a) FROM t1; LOAD_FILE(a) NULL DROP TABLE t1; +CREATE TABLE t1 (f2 VARCHAR(20)); +CREATE TABLE t2 (f2 VARCHAR(20)); +INSERT INTO t1 VALUES ('MIN'),('MAX'); +INSERT INTO t2 VALUES ('LOAD'); +SELECT CONCAT_WS('_', (SELECT t2.f2 FROM t2), t1.f2) AS concat_name FROM t1; +concat_name +LOAD_MIN +LOAD_MAX +DROP TABLE t1, t2; End of 5.0 tests diff --git a/mysql-test/t/func_str.test b/mysql-test/t/func_str.test index 4b0f91e4408..e396fbcebd8 100644 --- a/mysql-test/t/func_str.test +++ b/mysql-test/t/func_str.test @@ -1177,5 +1177,18 @@ INSERT INTO t1 VALUES ('aaaaaaaa'); SELECT LOAD_FILE(a) FROM t1; DROP TABLE t1; +# +# Bug#46815 CONCAT_WS returning wrong data +# +CREATE TABLE t1 (f2 VARCHAR(20)); +CREATE TABLE t2 (f2 VARCHAR(20)); + +INSERT INTO t1 VALUES ('MIN'),('MAX'); +INSERT INTO t2 VALUES ('LOAD'); + +SELECT CONCAT_WS('_', (SELECT t2.f2 FROM t2), t1.f2) AS concat_name FROM t1; + +DROP TABLE t1, t2; + --echo End of 5.0 tests diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc index e3fe67f4324..6f697a1665a 100644 --- a/sql/item_strfunc.cc +++ b/sql/item_strfunc.cc @@ -600,6 +600,7 @@ String *Item_func_concat_ws::val_str(String *str) String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff),default_charset_info), *sep_str, *res, *res2,*use_as_buff; uint i; + bool is_const= 0; null_value=0; if (!(sep_str= args[0]->val_str(&tmp_sep_str))) @@ -613,7 +614,11 @@ String *Item_func_concat_ws::val_str(String *str) // If not, return the empty string for (i=1; i < arg_count; i++) if ((res= args[i]->val_str(str))) + { + is_const= args[i]->const_item() || !args[i]->used_tables(); break; + } + if (i == arg_count) return &my_empty_string; @@ -631,7 +636,7 @@ String *Item_func_concat_ws::val_str(String *str) current_thd->variables.max_allowed_packet); goto null; } - if (res->alloced_length() >= + if (!is_const && res->alloced_length() >= res->length() + sep_str->length() + res2->length()) { // Use old buffer res->append(*sep_str); // res->length() > 0 always From e5888b16afcef42e8127a815cc5a95abc283c6d9 Mon Sep 17 00:00:00 2001 From: Staale Smedseng Date: Thu, 17 Sep 2009 17:10:30 +0200 Subject: [PATCH 07/13] Bug #43414 Parenthesis (and other) warnings compiling MySQL with gcc 4.3.2 This is the fifth patch cleaning up more GCC warnings about variables used before initialized using the new macro UNINIT_VAR(). --- heap/hp_write.c | 7 ++----- include/my_global.h | 6 ------ myisam/mi_search.c | 6 ++---- myisam/mi_write.c | 6 ++---- mysys/hash.c | 7 ++----- sql-common/my_time.c | 3 +-- sql/item_func.cc | 6 ++---- sql/item_timefunc.cc | 11 +++-------- sql/sql_handler.cc | 7 ++----- sql/sql_lex.cc | 3 +-- sql/sql_select.cc | 3 +-- sql/udf_example.c | 4 ++-- 12 files changed, 20 insertions(+), 49 deletions(-) diff --git a/heap/hp_write.c b/heap/hp_write.c index 6aa34acf2c3..85551c1cc41 100644 --- a/heap/hp_write.c +++ b/heap/hp_write.c @@ -196,13 +196,10 @@ int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, HP_SHARE *share = info->s; int flag; ulong halfbuff,hashnr,first_index; - byte *ptr_to_rec,*ptr_to_rec2; - HASH_INFO *empty,*gpos,*gpos2,*pos; + byte *UNINIT_VAR(ptr_to_rec),*UNINIT_VAR(ptr_to_rec2); + HASH_INFO *empty,*UNINIT_VAR(gpos),*UNINIT_VAR(gpos2),*pos; DBUG_ENTER("hp_write_key"); - LINT_INIT(gpos); LINT_INIT(gpos2); - LINT_INIT(ptr_to_rec); LINT_INIT(ptr_to_rec2); - flag=0; if (!(empty= hp_find_free_hash(share,&keyinfo->block,share->records))) DBUG_RETURN(-1); /* No more memory */ diff --git a/include/my_global.h b/include/my_global.h index 0b5458215c6..6910ae092e1 100644 --- a/include/my_global.h +++ b/include/my_global.h @@ -458,12 +458,6 @@ int __void__; #define LINT_INIT(var) #endif -#if defined(_lint) || defined(FORCE_INIT_OF_VARS) || defined(HAVE_purify) -#define PURIFY_OR_LINT_INIT(var) var=0 -#else -#define PURIFY_OR_LINT_INIT(var) -#endif - /* Suppress uninitialized variable warning without generating code. diff --git a/myisam/mi_search.c b/myisam/mi_search.c index 3b1cd6158f2..21efaa03744 100644 --- a/myisam/mi_search.c +++ b/myisam/mi_search.c @@ -295,7 +295,8 @@ int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page, uchar *end, *kseg, *vseg; uchar *sort_order=keyinfo->seg->charset->sort_order; uchar tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2; - uchar *saved_from, *saved_to, *saved_vseg; + uchar *UNINIT_VAR(saved_from), *UNINIT_VAR(saved_to); + uchar *UNINIT_VAR(saved_vseg); uint saved_length=0, saved_prefix_len=0; uint length_pack; DBUG_ENTER("_mi_prefix_search"); @@ -303,9 +304,6 @@ int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page, LINT_INIT(length); LINT_INIT(prefix_len); LINT_INIT(seg_len_pack); - LINT_INIT(saved_from); - LINT_INIT(saved_to); - LINT_INIT(saved_vseg); t_buff[0]=0; /* Avoid bugs */ end= page+mi_getint(page); diff --git a/myisam/mi_write.c b/myisam/mi_write.c index b4843a748dd..61cea588562 100644 --- a/myisam/mi_write.c +++ b/myisam/mi_write.c @@ -700,8 +700,8 @@ static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page, uchar *key, uint *return_key_length, uchar **after_key) { - uint keys,length,last_length,key_ref_length; - uchar *end,*lastpos,*prevpos; + uint keys,length,UNINIT_VAR(last_length),key_ref_length; + uchar *end,*lastpos,*UNINIT_VAR(prevpos); uchar key_buff[MI_MAX_KEY_BUFF]; DBUG_ENTER("_mi_find_last_pos"); @@ -720,8 +720,6 @@ static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page, DBUG_RETURN(end); } - LINT_INIT(prevpos); - LINT_INIT(last_length); end=page+length-key_ref_length; *key='\0'; length=0; diff --git a/mysys/hash.c b/mysys/hash.c index 4aab75609f4..3e7851a886f 100644 --- a/mysys/hash.c +++ b/mysys/hash.c @@ -332,11 +332,8 @@ my_bool my_hash_insert(HASH *info,const byte *record) { int flag; uint halfbuff,hash_nr,first_index,idx; - byte *ptr_to_rec,*ptr_to_rec2; - HASH_LINK *data,*empty,*gpos,*gpos2,*pos; - - LINT_INIT(gpos); LINT_INIT(gpos2); - LINT_INIT(ptr_to_rec); LINT_INIT(ptr_to_rec2); + byte *UNINIT_VAR(ptr_to_rec),*UNINIT_VAR(ptr_to_rec2); + HASH_LINK *data,*empty,*UNINIT_VAR(gpos),*UNINIT_VAR(gpos2),*pos; flag=0; if (!(empty=(HASH_LINK*) alloc_dynamic(&info->array))) diff --git a/sql-common/my_time.c b/sql-common/my_time.c index d2ef9da25f5..ed1279f7afb 100644 --- a/sql-common/my_time.c +++ b/sql-common/my_time.c @@ -165,7 +165,7 @@ str_to_datetime(const char *str, uint length, MYSQL_TIME *l_time, uint add_hours= 0, start_loop; ulong not_zero_date, allow_space; my_bool is_internal_format; - const char *pos, *last_field_pos; + const char *pos, *UNINIT_VAR(last_field_pos); const char *end=str+length; const uchar *format_position; my_bool found_delimitier= 0, found_space= 0; @@ -174,7 +174,6 @@ str_to_datetime(const char *str, uint length, MYSQL_TIME *l_time, DBUG_PRINT("ENTER",("str: %.*s",length,str)); LINT_INIT(field_length); - LINT_INIT(last_field_pos); *was_cut= 0; diff --git a/sql/item_func.cc b/sql/item_func.cc index 3c1e2126008..c6dbdb1d9a7 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -428,8 +428,7 @@ bool Item_func::eq(const Item *item, bool binary_cmp) const Field *Item_func::tmp_table_field(TABLE *t_arg) { - Field *res; - LINT_INIT(res); + Field *res= NULL; switch (result_type()) { case INT_RESULT: @@ -4202,9 +4201,8 @@ void Item_func_set_user_var::save_item_result(Item *item) bool Item_func_set_user_var::update() { - bool res; + bool res= NULL; DBUG_ENTER("Item_func_set_user_var::update"); - LINT_INIT(res); switch (cached_result_type) { case REAL_RESULT: diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc index 39f869106b6..de76f821795 100644 --- a/sql/item_timefunc.cc +++ b/sql/item_timefunc.cc @@ -271,9 +271,9 @@ static bool extract_date_time(DATE_TIME_FORMAT *format, int strict_week_number_year= -1; int frac_part; bool usa_time= 0; - bool sunday_first_n_first_week_non_iso; - bool strict_week_number; - bool strict_week_number_year_type; + bool UNINIT_VAR(sunday_first_n_first_week_non_iso); + bool UNINIT_VAR(strict_week_number); + bool UNINIT_VAR(strict_week_number_year_type); const char *val_begin= val; const char *val_end= val + length; const char *ptr= format->format.str; @@ -281,11 +281,6 @@ static bool extract_date_time(DATE_TIME_FORMAT *format, CHARSET_INFO *cs= &my_charset_bin; DBUG_ENTER("extract_date_time"); - LINT_INIT(strict_week_number); - /* Remove valgrind varnings when using gcc 3.3 and -O1 */ - PURIFY_OR_LINT_INIT(strict_week_number_year_type); - PURIFY_OR_LINT_INIT(sunday_first_n_first_week_non_iso); - if (!sub_pattern_end) bzero((char*) l_time, sizeof(*l_time)); diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc index 721b365a7b9..5bd28add428 100644 --- a/sql/sql_handler.cc +++ b/sql/sql_handler.cc @@ -385,16 +385,13 @@ bool mysql_ha_read(THD *thd, TABLE_LIST *tables, String buffer(buff, sizeof(buff), system_charset_info); int error, keyno= -1; uint num_rows; - byte *key; - uint key_len; + byte *UNINIT_VAR(key); + uint UNINIT_VAR(key_len); bool need_reopen; DBUG_ENTER("mysql_ha_read"); DBUG_PRINT("enter",("'%s'.'%s' as '%s'", tables->db, tables->table_name, tables->alias)); - LINT_INIT(key); - LINT_INIT(key_len); - thd->lex->select_lex.context.resolve_in_table_list_only(tables); list.push_front(new Item_field(&thd->lex->select_lex.context, NULL, NULL, "*")); diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc index b0b4256184c..17ee53d446b 100644 --- a/sql/sql_lex.cc +++ b/sql/sql_lex.cc @@ -530,7 +530,7 @@ static inline uint int_token(const char *str,uint length) int MYSQLlex(void *arg, void *yythd) { - reg1 uchar c; + reg1 uchar UNINIT_VAR(c); bool comment_closed; int tokval, result_state; uint length; @@ -550,7 +550,6 @@ int MYSQLlex(void *arg, void *yythd) lip->tok_start=lip->tok_end=lip->ptr; state=lip->next_state; lip->next_state=MY_LEX_OPERATOR_OR_IDENT; - LINT_INIT(c); for (;;) { switch (state) { diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 9d5e67c9532..84b5b61c941 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -10480,9 +10480,8 @@ do_select(JOIN *join,List *fields,TABLE *table,Procedure *procedure) { int rc= 0; enum_nested_loop_state error= NESTED_LOOP_OK; - JOIN_TAB *join_tab; + JOIN_TAB *UNINIT_VAR(join_tab); DBUG_ENTER("do_select"); - LINT_INIT(join_tab); join->procedure=procedure; join->tmp_table= table; /* Save for easy recursion */ diff --git a/sql/udf_example.c b/sql/udf_example.c index db48984eed8..019d4d834dd 100644 --- a/sql/udf_example.c +++ b/sql/udf_example.c @@ -139,10 +139,10 @@ typedef long long longlong; #include #include -static pthread_mutex_t LOCK_hostname; - #ifdef HAVE_DLOPEN +static pthread_mutex_t LOCK_hostname; + /* These must be right or mysqld will not find the symbol! */ my_bool metaphon_init(UDF_INIT *initid, UDF_ARGS *args, char *message); From 31809edc24b2d6ee6b4a9932d5af0b2247ecf8dc Mon Sep 17 00:00:00 2001 From: Georgi Kodinov Date: Thu, 17 Sep 2009 14:25:07 +0300 Subject: [PATCH 08/13] Bug #46917: mysqd-nt installs wrong When parsing the service installation parameter in default_service_handling() make sure the value of the optional parameter doesn't overwrite it's name. --- sql/mysqld.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/mysqld.cc b/sql/mysqld.cc index afbbf753813..ce1d562d0ca 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -4022,7 +4022,7 @@ default_service_handling(char **argv, if (opt_delim= strchr(extra_opt, '=')) { size_t length= ++opt_delim - extra_opt; - strnmov(pos, extra_opt, length); + pos= strnmov(pos, extra_opt, length); } else opt_delim= extra_opt; From 45c70a2ec50e81d3eeb1699fae939e113bf69ba1 Mon Sep 17 00:00:00 2001 From: Georgi Kodinov Date: Thu, 24 Sep 2009 16:21:46 +0300 Subject: [PATCH 09/13] fixed compilation warnings --- mysys/mf_keycache.c | 2 +- sql/item_func.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mysys/mf_keycache.c b/mysys/mf_keycache.c index f9898e263aa..3c11e6731b7 100644 --- a/mysys/mf_keycache.c +++ b/mysys/mf_keycache.c @@ -3113,7 +3113,7 @@ int key_cache_write(KEY_CACHE *keycache, /* Used in the server. */ keycache->global_cache_write++; keycache_pthread_mutex_unlock(&keycache->cache_lock); - if (my_pwrite(file, (uchar*) buff, read_length, filepos + offset, + if (my_pwrite(file, (byte*) buff, read_length, filepos + offset, MYF(MY_NABP | MY_WAIT_IF_FULL))) error=1; keycache_pthread_mutex_lock(&keycache->cache_lock); diff --git a/sql/item_func.cc b/sql/item_func.cc index c6dbdb1d9a7..d6f315fda50 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -4201,7 +4201,7 @@ void Item_func_set_user_var::save_item_result(Item *item) bool Item_func_set_user_var::update() { - bool res= NULL; + bool res= 0; DBUG_ENTER("Item_func_set_user_var::update"); switch (cached_result_type) { From 19f02facb7e5b11055aa767bdbe50d56e2989666 Mon Sep 17 00:00:00 2001 From: Georgi Kodinov Date: Fri, 11 Sep 2009 15:52:08 +0300 Subject: [PATCH 10/13] Bug #45159 : some tests in suite "jp" fail in embedded server (use LOAD DATA) Initialize correctly client flags for the embedded client Test cases in jp updated to work correctly with embedded server. --- libmysqld/libmysqld.c | 1 + mysql-test/suite/jp/r/jp_charset_sjis.result | 12 --------- mysql-test/suite/jp/r/jp_charset_ujis.result | 12 --------- mysql-test/suite/jp/r/jp_charset_utf8.result | 12 --------- mysql-test/suite/jp/r/jp_convert_sjis.result | 12 --------- mysql-test/suite/jp/r/jp_convert_ujis.result | 12 --------- mysql-test/suite/jp/r/jp_convert_utf8.result | 12 --------- mysql-test/suite/jp/r/jp_like_sjis.result | 12 --------- mysql-test/suite/jp/r/jp_like_ujis.result | 12 --------- mysql-test/suite/jp/r/jp_like_utf8.result | 12 --------- mysql-test/suite/jp/r/jp_select_sjis.result | 12 --------- mysql-test/suite/jp/r/jp_select_ujis.result | 12 --------- mysql-test/suite/jp/r/jp_select_utf8.result | 12 --------- mysql-test/suite/jp/r/jp_where_sjis.result | 12 --------- mysql-test/suite/jp/r/jp_where_ujis.result | 12 --------- mysql-test/suite/jp/r/jp_where_utf8.result | 12 --------- mysql-test/suite/jp/t/jp_charset_sjis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_charset_ujis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_charset_utf8.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_convert_sjis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_convert_ujis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_convert_utf8.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_like_sjis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_like_ujis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_like_utf8.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_select_sjis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_select_ujis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_select_utf8.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_where_sjis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_where_ujis.test | 26 +++++++++++--------- mysql-test/suite/jp/t/jp_where_utf8.test | 26 +++++++++++--------- 31 files changed, 211 insertions(+), 360 deletions(-) diff --git a/libmysqld/libmysqld.c b/libmysqld/libmysqld.c index eb47a045669..969ea442622 100644 --- a/libmysqld/libmysqld.c +++ b/libmysqld/libmysqld.c @@ -164,6 +164,7 @@ mysql_real_connect(MYSQL *mysql,const char *host, const char *user, port=0; unix_socket=0; + client_flag|=mysql->options.client_flag; /* Send client information for access check */ client_flag|=CLIENT_CAPABILITIES; if (client_flag & CLIENT_MULTI_STATEMENTS) diff --git a/mysql-test/suite/jp/r/jp_charset_sjis.result b/mysql-test/suite/jp/r/jp_charset_sjis.result index 80ef24a7334..312033be719 100644 --- a/mysql-test/suite/jp/r/jp_charset_sjis.result +++ b/mysql-test/suite/jp/r/jp_charset_sjis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `俿侾侽` (`俠侾` char(20)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾侾` (`俠侾` char(20)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾俀` (`俠侾` char(20)) DEFAULT CHARSET = sjis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; SELECT DISTINCT CHARSET(`俠侾`) FROM `俿侾`; CHARSET(`俠侾`) sjis diff --git a/mysql-test/suite/jp/r/jp_charset_ujis.result b/mysql-test/suite/jp/r/jp_charset_ujis.result index 964477896bd..4f6e68ba137 100644 --- a/mysql-test/suite/jp/r/jp_charset_ujis.result +++ b/mysql-test/suite/jp/r/jp_charset_ujis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `Ｔ１０` (`Ｃ１` char(20)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１１` (`Ｃ１` char(20)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１２` (`Ｃ１` char(20)) DEFAULT CHARSET = ujis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; SELECT DISTINCT CHARSET(`Ｃ１`) FROM `Ｔ１`; CHARSET(`Ｃ１`) ujis diff --git a/mysql-test/suite/jp/r/jp_charset_utf8.result b/mysql-test/suite/jp/r/jp_charset_utf8.result index 2fdd3fb1a6b..04140828d14 100644 --- a/mysql-test/suite/jp/r/jp_charset_utf8.result +++ b/mysql-test/suite/jp/r/jp_charset_utf8.result @@ -24,18 +24,6 @@ CREATE TABLE `锛达紮` (`锛ｏ紤` char(20)) DEFAULT CHARSET = utf8 engine = heap; CREATE TABLE `锛达紤锛恅 (`锛ｏ紤` char(20)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛慲 (`锛ｏ紤` char(20)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20)) DEFAULT CHARSET = utf8 engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; SELECT DISTINCT CHARSET(`锛ｏ紤`) FROM `锛达紤`; CHARSET(`锛ｏ紤`) utf8 diff --git a/mysql-test/suite/jp/r/jp_convert_sjis.result b/mysql-test/suite/jp/r/jp_convert_sjis.result index ff8a3fb2cd9..bc581ca56b0 100644 --- a/mysql-test/suite/jp/r/jp_convert_sjis.result +++ b/mysql-test/suite/jp/r/jp_convert_sjis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `俿侾侽` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾侾` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾俀` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿侾`; 俠侾 CONVERT(`俠侾` using utf8) !"#$%&'()*+,-./ !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_convert_ujis.result b/mysql-test/suite/jp/r/jp_convert_ujis.result index 55f2ab0aea3..f256d8b08b4 100644 --- a/mysql-test/suite/jp/r/jp_convert_ujis.result +++ b/mysql-test/suite/jp/r/jp_convert_ujis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `Ｔ１０` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１１` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１２` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; SELECT `Ｃ１`, CONVERT(`Ｃ１` using utf8) FROM `Ｔ１`; Ｃ１ CONVERT(`Ｃ１` using utf8) !"#$%&'()*+,-./ !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_convert_utf8.result b/mysql-test/suite/jp/r/jp_convert_utf8.result index 505d6c1cebf..944f1c1068c 100644 --- a/mysql-test/suite/jp/r/jp_convert_utf8.result +++ b/mysql-test/suite/jp/r/jp_convert_utf8.result @@ -24,18 +24,6 @@ CREATE TABLE `锛达紮` (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf CREATE TABLE `锛达紤锛恅 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛慲 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; SELECT `锛ｏ紤`, CONVERT(`锛ｏ紤` using ujis) FROM `锛达紤`; 锛ｏ紤 CONVERT(`锛ｏ紤` using ujis) !"#$%&'()*+,-./ !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_like_sjis.result b/mysql-test/suite/jp/r/jp_like_sjis.result index a8145fb08f0..3e52781c7bd 100644 --- a/mysql-test/suite/jp/r/jp_like_sjis.result +++ b/mysql-test/suite/jp/r/jp_like_sjis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `俿侾侽` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾侾` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾俀` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; SELECT * FROM `俿侾` WHERE `俠侾` LIKE ' %'; 俠侾 !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_like_ujis.result b/mysql-test/suite/jp/r/jp_like_ujis.result index 5d623df0384..f685d185072 100644 --- a/mysql-test/suite/jp/r/jp_like_ujis.result +++ b/mysql-test/suite/jp/r/jp_like_ujis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `Ｔ１０` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１１` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１２` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; SELECT * FROM `Ｔ１` WHERE `Ｃ１` LIKE ' %'; Ｃ１ !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_like_utf8.result b/mysql-test/suite/jp/r/jp_like_utf8.result index bf48da79951..90b960ca3a7 100644 --- a/mysql-test/suite/jp/r/jp_like_utf8.result +++ b/mysql-test/suite/jp/r/jp_like_utf8.result @@ -24,18 +24,6 @@ CREATE TABLE `锛达紮` (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf CREATE TABLE `锛达紤锛恅 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛慲 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; SELECT * FROM `锛达紤` WHERE `锛ｏ紤` LIKE ' %'; 锛ｏ紤 !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_select_sjis.result b/mysql-test/suite/jp/r/jp_select_sjis.result index 652b538fb88..021b0d29f43 100644 --- a/mysql-test/suite/jp/r/jp_select_sjis.result +++ b/mysql-test/suite/jp/r/jp_select_sjis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `俿侾侽` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾侾` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾俀` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; SELECT * FROM `俿侾`; 俠侾 !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_select_ujis.result b/mysql-test/suite/jp/r/jp_select_ujis.result index 3eea73c8083..d70997b0a01 100644 --- a/mysql-test/suite/jp/r/jp_select_ujis.result +++ b/mysql-test/suite/jp/r/jp_select_ujis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `Ｔ１０` (c1 char(20), INDEX(c1)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１１` (c1 char(20), INDEX(c1)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１２` (c1 char(20), INDEX(c1)) DEFAULT CHARSET = ujis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; SELECT * FROM `Ｔ１`; c1 !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_select_utf8.result b/mysql-test/suite/jp/r/jp_select_utf8.result index 43704ad2f6e..8bc61b802be 100644 --- a/mysql-test/suite/jp/r/jp_select_utf8.result +++ b/mysql-test/suite/jp/r/jp_select_utf8.result @@ -24,18 +24,6 @@ CREATE TABLE `锛达紮` (c1 char(20), INDEX(c1)) DEFAULT CHARSET = utf8 engine = h CREATE TABLE `锛达紤锛恅 (c1 char(20), INDEX(c1)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛慲 (c1 char(20), INDEX(c1)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛抈 (c1 char(20), INDEX(c1)) DEFAULT CHARSET = utf8 engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; SELECT * FROM `锛达紤`; c1 !"#$%&'()*+,-./ diff --git a/mysql-test/suite/jp/r/jp_where_sjis.result b/mysql-test/suite/jp/r/jp_where_sjis.result index a3cbc24c113..e8be6e10850 100644 --- a/mysql-test/suite/jp/r/jp_where_sjis.result +++ b/mysql-test/suite/jp/r/jp_where_sjis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `俿侾侽` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾侾` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; CREATE TABLE `俿侾俀` (`俠侾` char(20), INDEX(`俠侾`)) DEFAULT CHARSET = sjis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; SELECT * FROM `俿侾` WHERE `俠侾` = '氨渤吹斗腹夯冀究'; 俠侾 氨渤吹斗腹夯冀究 diff --git a/mysql-test/suite/jp/r/jp_where_ujis.result b/mysql-test/suite/jp/r/jp_where_ujis.result index b13b8a10ef8..6b7dc4dde22 100644 --- a/mysql-test/suite/jp/r/jp_where_ujis.result +++ b/mysql-test/suite/jp/r/jp_where_ujis.result @@ -24,18 +24,6 @@ CREATE TABLE ` CREATE TABLE `Ｔ１０` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１１` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; CREATE TABLE `Ｔ１２` (`Ｃ１` char(20), INDEX(`Ｃ１`)) DEFAULT CHARSET = ujis engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; SELECT * FROM `Ｔ１` WHERE `Ｃ１` = '幇幈幉幊幋幍幎幏幐幑幒幓幖幗幘幙'; Ｃ１ 幇幈幉幊幋幍幎幏幐幑幒幓幖幗幘幙 diff --git a/mysql-test/suite/jp/r/jp_where_utf8.result b/mysql-test/suite/jp/r/jp_where_utf8.result index d69aaf8715d..cd7a4c0e500 100644 --- a/mysql-test/suite/jp/r/jp_where_utf8.result +++ b/mysql-test/suite/jp/r/jp_where_utf8.result @@ -24,18 +24,6 @@ CREATE TABLE `锛达紮` (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf CREATE TABLE `锛达紤锛恅 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛慲 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = utf8 engine = bdb; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; SELECT * FROM `锛达紤` WHERE `锛ｏ紤` = '锝帮奖锝诧匠锝达降锝讹椒锝革焦锝猴交锝硷浇锝撅娇'; 锛ｏ紤 锝帮奖锝诧匠锝达降锝讹椒锝革焦锝猴交锝硷浇锝撅娇 diff --git a/mysql-test/suite/jp/t/jp_charset_sjis.test b/mysql-test/suite/jp/t/jp_charset_sjis.test index 276be86cd9d..26a56fb61d6 100644 --- a/mysql-test/suite/jp/t/jp_charset_sjis.test +++ b/mysql-test/suite/jp/t/jp_charset_sjis.test @@ -40,18 +40,20 @@ CREATE TABLE ` # jisx0201 hankaku-katakana data # jisx0208 data - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--disable_query_log + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--enable_query_log #InnoDB SELECT DISTINCT CHARSET(`俠侾`) FROM `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_charset_ujis.test b/mysql-test/suite/jp/t/jp_charset_ujis.test index a8a6544537a..6308c7124ee 100644 --- a/mysql-test/suite/jp/t/jp_charset_ujis.test +++ b/mysql-test/suite/jp/t/jp_charset_ujis.test @@ -42,18 +42,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--disable_query_log + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--enable_query_log #InnoDB SELECT DISTINCT CHARSET(`Ｃ１`) FROM `Ｔ１`; diff --git a/mysql-test/suite/jp/t/jp_charset_utf8.test b/mysql-test/suite/jp/t/jp_charset_utf8.test index 7d8311c2f72..dcce0477204 100644 --- a/mysql-test/suite/jp/t/jp_charset_utf8.test +++ b/mysql-test/suite/jp/t/jp_charset_utf8.test @@ -40,18 +40,20 @@ CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20)) DEFAULT CHARSET = utf8 engine = bdb # jisx0208 data # jisx0212 supplemental character data - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--disable_query_log + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--enable_query_log #InnoDB SELECT DISTINCT CHARSET(`锛ｏ紤`) FROM `锛达紤`; diff --git a/mysql-test/suite/jp/t/jp_convert_sjis.test b/mysql-test/suite/jp/t/jp_convert_sjis.test index 835328c92eb..4e76b414442 100644 --- a/mysql-test/suite/jp/t/jp_convert_sjis.test +++ b/mysql-test/suite/jp/t/jp_convert_sjis.test @@ -41,18 +41,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--disable_query_log + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; + --eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--enable_query_log #InnoDB SELECT `俠侾`, CONVERT(`俠侾` using utf8) FROM `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_convert_ujis.test b/mysql-test/suite/jp/t/jp_convert_ujis.test index 4409b6cad90..7d53d1853d3 100644 --- a/mysql-test/suite/jp/t/jp_convert_ujis.test +++ b/mysql-test/suite/jp/t/jp_convert_ujis.test @@ -42,18 +42,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--enable_query_log #InnoDB SELECT `Ｃ１`, CONVERT(`Ｃ１` using utf8) FROM `Ｔ１`; diff --git a/mysql-test/suite/jp/t/jp_convert_utf8.test b/mysql-test/suite/jp/t/jp_convert_utf8.test index e7c180e72fc..3d81704e87c 100644 --- a/mysql-test/suite/jp/t/jp_convert_utf8.test +++ b/mysql-test/suite/jp/t/jp_convert_utf8.test @@ -40,18 +40,20 @@ CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = # jisx0208 data # jisx0212 supplemental character data - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; - LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--enable_query_log #InnoDB SELECT `锛ｏ紤`, CONVERT(`锛ｏ紤` using ujis) FROM `锛达紤`; diff --git a/mysql-test/suite/jp/t/jp_like_sjis.test b/mysql-test/suite/jp/t/jp_like_sjis.test index 1cb7aadb876..ad2c5f7b465 100644 --- a/mysql-test/suite/jp/t/jp_like_sjis.test +++ b/mysql-test/suite/jp/t/jp_like_sjis.test @@ -40,18 +40,20 @@ CREATE TABLE ` # jisx0201 hankaku-katakana data # jisx0208 data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--enable_query_log #InnoDB SELECT * FROM `俿侾` WHERE `俠侾` LIKE ' %'; diff --git a/mysql-test/suite/jp/t/jp_like_ujis.test b/mysql-test/suite/jp/t/jp_like_ujis.test index 56c4fa8a8b0..c3660e8f88f 100644 --- a/mysql-test/suite/jp/t/jp_like_ujis.test +++ b/mysql-test/suite/jp/t/jp_like_ujis.test @@ -42,18 +42,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--enable_query_log #InnoDB SELECT * FROM `Ｔ１` WHERE `Ｃ１` LIKE ' %'; diff --git a/mysql-test/suite/jp/t/jp_like_utf8.test b/mysql-test/suite/jp/t/jp_like_utf8.test index f6cc895d814..57fc1584471 100644 --- a/mysql-test/suite/jp/t/jp_like_utf8.test +++ b/mysql-test/suite/jp/t/jp_like_utf8.test @@ -40,18 +40,20 @@ CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--enable_query_log #InnoDB SELECT * FROM `锛达紤` WHERE `锛ｏ紤` LIKE ' %'; diff --git a/mysql-test/suite/jp/t/jp_select_sjis.test b/mysql-test/suite/jp/t/jp_select_sjis.test index fc80ce01471..698d87a6852 100644 --- a/mysql-test/suite/jp/t/jp_select_sjis.test +++ b/mysql-test/suite/jp/t/jp_select_sjis.test @@ -41,18 +41,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--enable_query_log #InnoDB SELECT * FROM `俿侾`; diff --git a/mysql-test/suite/jp/t/jp_select_ujis.test b/mysql-test/suite/jp/t/jp_select_ujis.test index 0e4d1ffc771..7c8ec46d06e 100644 --- a/mysql-test/suite/jp/t/jp_select_ujis.test +++ b/mysql-test/suite/jp/t/jp_select_ujis.test @@ -42,18 +42,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--enable_query_log #InnoDB SELECT * FROM `Ｔ１`; diff --git a/mysql-test/suite/jp/t/jp_select_utf8.test b/mysql-test/suite/jp/t/jp_select_utf8.test index 88fd6677f7c..f410333fcfa 100644 --- a/mysql-test/suite/jp/t/jp_select_utf8.test +++ b/mysql-test/suite/jp/t/jp_select_utf8.test @@ -40,18 +40,20 @@ CREATE TABLE `锛达紤锛抈 (c1 char(20), INDEX(c1)) DEFAULT CHARSET = utf8 engine # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--enable_query_log #InnoDB SELECT * FROM `锛达紤`; diff --git a/mysql-test/suite/jp/t/jp_where_sjis.test b/mysql-test/suite/jp/t/jp_where_sjis.test index 890a4c28f3c..6fda91a7b4b 100644 --- a/mysql-test/suite/jp/t/jp_where_sjis.test +++ b/mysql-test/suite/jp/t/jp_where_sjis.test @@ -41,18 +41,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俀`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俁`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿係`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俆`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俇`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿俈`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿俉`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿俋`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_sjis.dat' INTO TABLE `俿侾侽`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis.dat' INTO TABLE `俿侾侾`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_sjis2.dat' INTO TABLE `俿侾俀`; +--enable_query_log #InnoDB SELECT * FROM `俿侾` WHERE `俠侾` = '氨渤吹斗腹夯冀究'; diff --git a/mysql-test/suite/jp/t/jp_where_ujis.test b/mysql-test/suite/jp/t/jp_where_ujis.test index 2f0924e8c8e..6343610306e 100644 --- a/mysql-test/suite/jp/t/jp_where_ujis.test +++ b/mysql-test/suite/jp/t/jp_where_ujis.test @@ -42,18 +42,20 @@ CREATE TABLE ` # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ２`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ３`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ４`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ５`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ６`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ７`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ８`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ９`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_ujis.dat' INTO TABLE `Ｔ１０`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_ujis.dat' INTO TABLE `Ｔ１１`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_ujis.dat' INTO TABLE `Ｔ１２`; +--enable_query_log #InnoDB SELECT * FROM `Ｔ１` WHERE `Ｃ１` = '幇幈幉幊幋幍幎幏幐幑幒幓幖幗幘幙'; diff --git a/mysql-test/suite/jp/t/jp_where_utf8.test b/mysql-test/suite/jp/t/jp_where_utf8.test index 231553e8819..a37b6f1a41a 100644 --- a/mysql-test/suite/jp/t/jp_where_utf8.test +++ b/mysql-test/suite/jp/t/jp_where_utf8.test @@ -40,18 +40,20 @@ CREATE TABLE `锛达紤锛抈 (`锛ｏ紤` char(20), INDEX(`锛ｏ紤`)) DEFAULT CHARSET = # jisx0208 data # jisx0212 supplemental character data -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; -LOAD DATA LOCAL INFILE 'suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--disable_query_log +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紥`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紦`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紨`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紩`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紪`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紬`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紭`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紮`; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0201_utf8.dat' INTO TABLE `锛达紤锛恅; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0208_utf8.dat' INTO TABLE `锛达紤锛慲; +--eval LOAD DATA LOCAL INFILE '$MYSQL_TEST_DIR/suite/jp/std_data/jisx0212_utf8.dat' INTO TABLE `锛达紤锛抈; +--enable_query_log #InnoDB SELECT * FROM `锛达紤` WHERE `锛ｏ紤` = '锝帮奖锝诧匠锝达降锝讹椒锝革焦锝猴交锝硷浇锝撅娇'; From 9eab1cdb9ae94120dd35aeee13c13295ba59ee3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Magnus=20Bl=C3=A5udd?= Date: Thu, 24 Sep 2009 08:30:31 +0200 Subject: [PATCH 11/13] Bug#42850 race condition in my_thr_init.c - Create the "dummy" thread joinable and wait for it to exit before continuing in 'my_thread_global_init' - This way we know that the pthread library is initialized by one thread only --- mysys/my_thr_init.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/mysys/my_thr_init.c b/mysys/my_thr_init.c index c446808c7da..64fc99952e9 100644 --- a/mysys/my_thr_init.c +++ b/mysys/my_thr_init.c @@ -107,10 +107,11 @@ my_bool my_thread_global_init(void) pthread_attr_t dummy_thread_attr; pthread_attr_init(&dummy_thread_attr); - pthread_attr_setdetachstate(&dummy_thread_attr, PTHREAD_CREATE_DETACHED); + pthread_attr_setdetachstate(&dummy_thread_attr, PTHREAD_CREATE_JOINABLE); - pthread_create(&dummy_thread,&dummy_thread_attr, - nptl_pthread_exit_hack_handler, NULL); + if (pthread_create(&dummy_thread,&dummy_thread_attr, + nptl_pthread_exit_hack_handler, NULL) == 0) + (void)pthread_join(dummy_thread, NULL); } #endif /* TARGET_OS_LINUX */ From 5dda6c18cdb6b549681f76b6158baa3afd2816bb Mon Sep 17 00:00:00 2001 From: Georgi Kodinov Date: Fri, 18 Sep 2009 12:34:08 +0300 Subject: [PATCH 12/13] Bug #47106: Crash / segfault on adding EXPLAIN to a non-crashing query The fix for bug 46749 removed the check for OUTER_REF_TABLE_BIT and substituted it for a check on the presence of Item_ident::depended_from. Removing it altogether was wrong : OUTER_REF_TABLE_BIT should still be checked in addition to depended_from (because it's not set in all cases and doesn't contradict to the check of depended_from). Fixed by returning the old condition back as a compliment to the new one. --- mysql-test/r/subselect4.result | 31 +++++++++++++++++++++++++++++++ mysql-test/t/subselect4.test | 32 ++++++++++++++++++++++++++++++++ sql/sql_select.cc | 8 ++++---- 3 files changed, 67 insertions(+), 4 deletions(-) diff --git a/mysql-test/r/subselect4.result b/mysql-test/r/subselect4.result index 68577cb2a4c..e863cbfb7a8 100644 --- a/mysql-test/r/subselect4.result +++ b/mysql-test/r/subselect4.result @@ -27,4 +27,35 @@ SELECT 1; 1 1 DROP TABLE t1,t2,t3; +# +# Bug #47106: Crash / segfault on adding EXPLAIN to a non-crashing +# query +# +CREATE TABLE t1 ( +a INT, +b INT, +PRIMARY KEY (a), +KEY b (b) +); +INSERT INTO t1 VALUES (1, 1), (2, 1); +CREATE TABLE t2 LIKE t1; +INSERT INTO t2 SELECT * FROM t1; +CREATE TABLE t3 LIKE t1; +INSERT INTO t3 SELECT * FROM t1; +# Should not crash. +# Should have 1 impossible where and 2 dependent subqs. +EXPLAIN +SELECT +(SELECT 1 FROM t1,t2 WHERE t2.b > t3.b) +FROM t3 WHERE 1 = 0 GROUP BY 1; +id select_type table type possible_keys key key_len ref rows Extra +1 PRIMARY NULL NULL NULL NULL NULL NULL NULL Impossible WHERE +2 DEPENDENT SUBQUERY t1 index NULL PRIMARY 4 NULL 2 Using index +2 DEPENDENT SUBQUERY t2 index b b 5 NULL 2 Using where; Using index +# should return 0 rows +SELECT +(SELECT 1 FROM t1,t2 WHERE t2.b > t3.b) +FROM t3 WHERE 1 = 0 GROUP BY 1; +(SELECT 1 FROM t1,t2 WHERE t2.b > t3.b) +DROP TABLE t1,t2,t3; End of 5.0 tests. diff --git a/mysql-test/t/subselect4.test b/mysql-test/t/subselect4.test index ff4cdf3c439..440eca22828 100644 --- a/mysql-test/t/subselect4.test +++ b/mysql-test/t/subselect4.test @@ -28,5 +28,37 @@ SELECT 1; DROP TABLE t1,t2,t3; +--echo # +--echo # Bug #47106: Crash / segfault on adding EXPLAIN to a non-crashing +--echo # query +--echo # + +CREATE TABLE t1 ( + a INT, + b INT, + PRIMARY KEY (a), + KEY b (b) +); +INSERT INTO t1 VALUES (1, 1), (2, 1); + +CREATE TABLE t2 LIKE t1; +INSERT INTO t2 SELECT * FROM t1; + +CREATE TABLE t3 LIKE t1; +INSERT INTO t3 SELECT * FROM t1; + +--echo # Should not crash. +--echo # Should have 1 impossible where and 2 dependent subqs. +EXPLAIN +SELECT + (SELECT 1 FROM t1,t2 WHERE t2.b > t3.b) +FROM t3 WHERE 1 = 0 GROUP BY 1; + +--echo # should return 0 rows +SELECT + (SELECT 1 FROM t1,t2 WHERE t2.b > t3.b) +FROM t3 WHERE 1 = 0 GROUP BY 1; + +DROP TABLE t1,t2,t3; --echo End of 5.0 tests. diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 84b5b61c941..76d6833de5c 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -3216,12 +3216,12 @@ add_key_equal_fields(KEY_FIELD **key_fields, uint and_level, @retval FALSE it's something else */ -inline static bool +static bool is_local_field (Item *field) { - field= field->real_item(); - return field->type() == Item::FIELD_ITEM && - !((Item_field *)field)->depended_from; + return field->real_item()->type() == Item::FIELD_ITEM + && !(field->used_tables() & OUTER_REF_TABLE_BIT) + && !((Item_field *)field->real_item())->depended_from; } From ea295c233b92fb06c476f0b0a011493d4c827435 Mon Sep 17 00:00:00 2001 From: Jonathan Perkin Date: Mon, 28 Sep 2009 15:14:33 +0100 Subject: [PATCH 13/13] bug#30954: "configure" script in binary distributions considered harmfull Add --help option. --- support-files/binary-configure.sh | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/support-files/binary-configure.sh b/support-files/binary-configure.sh index 884a8363e22..5e6d62f69a0 100644 --- a/support-files/binary-configure.sh +++ b/support-files/binary-configure.sh @@ -1,4 +1,28 @@ #!/bin/sh + +SCRIPT_NAME="`basename $0`" + +usage() +{ + echo "Usage: ${SCRIPT_NAME} [--help|-h]" + echo "" + echo "This script creates the MySQL system tables and starts the server." +} + +for arg do + case "$arg" in + --help|-h) + usage + exit 0 + ;; + *) + echo "${SCRIPT_NAME}: unknown option $arg" + usage + exit 2 + ;; + esac +done + if test ! -x ./scripts/mysql_install_db then echo "I didn't find the script './scripts/mysql_install_db'."