mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-19 05:22:25 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge bk-internal:/home/bk/mysql-5.1-new-maint

Browse source 
into  neptunus.(none):/home/msvensson/mysql/mysql-5.1-new-maint
This commit is contained in:
msvensson@neptunus.(none) 2006-10-23 15:59:00 +08:00
commit 4fbdbf1a4c
23 changed files with 117 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
mysql-test/include/mix1.inc
View file

@ -342,12 +342,6 @@ SELECT COUNT(*) FROM t2 LEFT JOIN t1 ON t2.fkey = t1.id
DROP TABLE t1,t2;
#
# Bug#17530: Incorrect key truncation on table creation caused server crash.
#
create table t1(f1 varchar(800) binary not null, key(f1)) engine = innodb
character set utf8 collate utf8_general_ci;
insert into t1 values('aaa');
drop table t1;
# Test of behaviour with CREATE ... SELECT
#

6
mysql-test/r/innodb_mysql.result
View file

@ -300,12 +300,6 @@ id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE t2 index NULL fkey 5 NULL 5 Using index
1 SIMPLE t1 eq_ref PRIMARY PRIMARY 4 test.t2.fkey 1 Using where
DROP TABLE t1,t2;
create table t1(f1 varchar(800) binary not null, key(f1)) engine = innodb
character set utf8 collate utf8_general_ci;
Warnings:
Warning 1071 Specified key was too long; max key length is 765 bytes
insert into t1 values('aaa');
drop table t1;
CREATE TABLE t1 (a int, b int);
insert into t1 values (1,1),(1,2);
CREATE TABLE t2 (primary key (a)) select * from t1;

2
sql/sql_trigger.cc
View file

@ -284,7 +284,7 @@ end:
thd->clear_error();
/* Such a statement can always go directly to binlog, no trans cache. */
thd->binlog_query(THD::MYSQL_QUERY_TYPE,
thd->binlog_query(THD::STMT_QUERY_TYPE,
stmt_query.ptr(), stmt_query.length(), FALSE, FALSE);
}
}

17
sql/sql_view.cc
View file

@ -577,7 +577,7 @@ bool mysql_create_view(THD *thd, TABLE_LIST *views,
List_iterator_fast<LEX_STRING> names(lex->view_list);
LEX_STRING *name;
int i;
for (i= 0; name= names++; i++)
{
buff.append(i ? ", " : "(");
@ -1417,6 +1417,7 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode)
query_cache_invalidate3(thd, view, 0);
sp_cache_invalidate();
}
if (mysql_bin_log.is_open())
{
thd->clear_error();
@ -1424,24 +1425,34 @@ bool mysql_drop_view(THD *thd, TABLE_LIST *views, enum_drop_mode drop_mode)
thd->query, thd->query_length, FALSE, FALSE);
}
VOID(pthread_mutex_unlock(&LOCK_open));
if (error)
{
VOID(pthread_mutex_unlock(&LOCK_open));
DBUG_RETURN(TRUE);
}
if (wrong_object_name)
{
VOID(pthread_mutex_unlock(&LOCK_open));
my_error(ER_WRONG_OBJECT, MYF(0), wrong_object_db, wrong_object_name,
"VIEW");
DBUG_RETURN(TRUE);
}
if (non_existant_views.length())
{
VOID(pthread_mutex_unlock(&LOCK_open));
my_error(ER_BAD_TABLE_ERROR, MYF(0), non_existant_views.c_ptr());
DBUG_RETURN(TRUE);
}
if (mysql_bin_log.is_open())
{
thd->clear_error();
thd->binlog_query(THD::STMT_QUERY_TYPE,
thd->query, thd->query_length, FALSE, FALSE);
}
send_ok(thd);
VOID(pthread_mutex_unlock(&LOCK_open));
DBUG_RETURN(FALSE);
}

2
sql/stacktrace.c
View file

@ -186,7 +186,7 @@ terribly wrong...\n");
#if defined(__alpha__) && defined(__GNUC__)
uchar** new_fp = find_prev_fp(pc, fp);
if (frame_count == SIGRETURN_FRAME_COUNT - 1)
if (frame_count == sigreturn_frame_count - 1)
{
new_fp += 90;
}

3
storage/innobase/btr/btr0btr.c
View file

@ -571,9 +571,6 @@ btr_page_get_father_for_rec(
tuple = dict_index_build_node_ptr(index, user_rec, 0, heap,
btr_page_get_level(page, mtr));
/* In the following, we choose just any index from the tree as the
first parameter for btr_cur_search_to_nth_level. */
btr_cur_search_to_nth_level(index,
btr_page_get_level(page, mtr) + 1,
tuple, PAGE_CUR_LE,

34
storage/innobase/dict/dict0dict.c
View file

@ -3547,6 +3547,7 @@ syntax_error:
/*==================== END OF FOREIGN KEY PROCESSING ====================*/
#ifdef UNIV_DEBUG
/**************************************************************************
Returns an index object if it is found in the dictionary cache. */
@ -3556,7 +3557,6 @@ dict_index_get_if_in_cache(
/* out: index, NULL if not found */
dulint index_id) /* in: index id */
{
dict_table_t* table;
dict_index_t* index;
if (dict_sys == NULL) {
@ -3565,29 +3565,13 @@ dict_index_get_if_in_cache(
mutex_enter(&(dict_sys->mutex));
table = UT_LIST_GET_FIRST(dict_sys->table_LRU);
index = dict_index_find_on_id_low(index_id);
while (table) {
index = UT_LIST_GET_FIRST(table->indexes);
while (index) {
if (0 == ut_dulint_cmp(index->id, index_id)) {
goto found;
}
index = UT_LIST_GET_NEXT(indexes, index);
}
table = UT_LIST_GET_NEXT(table_LRU, table);
}
index = NULL;
found:
mutex_exit(&(dict_sys->mutex));
return(index);
}
#endif /* UNIV_DEBUG */
#ifdef UNIV_DEBUG
/**************************************************************************
@ -4162,18 +4146,8 @@ dict_print_info_on_foreign_key_in_create_format(
dict_remove_db_name(
foreign->referenced_table_name));
} else {
/* Look for the '/' in the table name */
i = 0;
while (foreign->referenced_table_name[i] != '/') {
i++;
}
ut_print_namel(file, trx, TRUE,
foreign->referenced_table_name, i);
putc('.', file);
ut_print_name(file, trx, TRUE,
foreign->referenced_table_name + i + 1);
foreign->referenced_table_name);
}
putc(' ', file);

13
storage/innobase/handler/ha_innodb.cc
View file

@ -6630,7 +6630,7 @@ innodb_mutex_show_status(
mutex->count_spin_rounds,
mutex->count_os_wait,
mutex->count_os_yield,
mutex->lspent_time/1000);
(ulong) mutex->lspent_time/1000);
if (stat_print(thd, innobase_hton_name,
hton_name_len, buf1, buf1len,
@ -6660,7 +6660,7 @@ innodb_mutex_show_status(
rw_lock_count, rw_lock_count_spin_loop,
rw_lock_count_spin_rounds,
rw_lock_count_os_wait, rw_lock_count_os_yield,
rw_lock_wait_time/1000);
(ulong) rw_lock_wait_time/1000);
if (stat_print(thd, innobase_hton_name, hton_name_len,
STRING_WITH_LEN("rw_lock_mutexes"), buf2, buf2len)) {
@ -6812,7 +6812,8 @@ ha_innobase::store_lock(
&& lock_type != TL_IGNORE)) {
/* The OR cases above are in this order:
1) MySQL is doing LOCK TABLES ... READ LOCAL, or
1) MySQL is doing LOCK TABLES ... READ LOCAL, or we
are processing a stored procedure or function, or
2) (we do not know when TL_READ_HIGH_PRIORITY is used), or
3) this is a SELECT ... IN SHARE MODE, or
4) we are doing a complex SQL statement like
@ -6880,7 +6881,8 @@ ha_innobase::store_lock(
single transaction stored procedure call deterministic
(if it does not use a consistent read). */
if (lock_type == TL_READ && thd->in_lock_tables) {
if (lock_type == TL_READ
&& thd->lex->sql_command == SQLCOM_LOCK_TABLES) {
/* We come here if MySQL is processing LOCK TABLES
... READ LOCAL. MyISAM under that table lock type
reads the table as it was at the time the lock was
@ -6939,8 +6941,7 @@ ha_innobase::store_lock(
(MySQL does have thd->in_lock_tables TRUE there). */
if (lock_type == TL_READ_NO_INSERT
&& (!thd->in_lock_tables
|| thd->lex->sql_command == SQLCOM_CALL)) {
&& thd->lex->sql_command != SQLCOM_LOCK_TABLES) {
lock_type = TL_READ;
}

4
storage/innobase/include/dict0dict.h
View file

@ -778,9 +778,8 @@ const dict_col_t*
dict_field_get_col(
/*===============*/
const dict_field_t* field);
/**************************************************************************
In an index tree, finds the index corresponding to a record in the tree. */
#ifdef UNIV_DEBUG
/**************************************************************************
Returns an index object if it is found in the dictionary cache. */
@ -789,7 +788,6 @@ dict_index_get_if_in_cache(
/*=======================*/
/* out: index, NULL if not found */
dulint index_id); /* in: index id */
#ifdef UNIV_DEBUG
/**************************************************************************
Checks that a tuple has n_fields_cmp value in a sensible range, so that
no comparison can occur with the page number field in a node pointer. */

13
storage/innobase/include/mem0dbg.h
View file

@ -30,6 +30,7 @@ check fields at the both ends of the field. */
#define MEM_SPACE_NEEDED(N) ut_calc_align((N), UNIV_MEM_ALIGNMENT)
#endif
#if defined UNIV_MEM_DEBUG || defined UNIV_DEBUG
/*******************************************************************
Checks a memory heap for consistency and prints the contents if requested.
Outputs the sum of sizes of buffers given to the user (only in
@ -59,15 +60,8 @@ mem_heap_validate_or_print(
ulint* n_blocks); /* out: number of blocks in the heap,
if a NULL pointer is passed as this
argument, it is ignored */
#ifdef UNIV_MEM_DEBUG
/******************************************************************
Prints the contents of a memory heap. */
void
mem_heap_print(
/*===========*/
mem_heap_t* heap); /* in: memory heap */
#endif /* UNIV_MEM_DEBUG */
#endif /* UNIV_MEM_DEBUG || UNIV_DEBUG */
#ifdef UNIV_DEBUG
/******************************************************************
Checks that an object is a memory heap (or a block of it) */
@ -76,6 +70,7 @@ mem_heap_check(
/*===========*/
/* out: TRUE if ok */
mem_heap_t* heap); /* in: memory heap */
#endif /* UNIV_DEBUG */
/******************************************************************
Validates the contents of a memory heap. */

2
storage/innobase/include/mtr0mtr.h
View file

@ -265,6 +265,7 @@ mtr_memo_release(
mtr_t* mtr, /* in: mtr */
void* object, /* in: object */
ulint type); /* in: object type: MTR_MEMO_S_LOCK, ... */
#ifdef UNIV_DEBUG
/**************************************************************
Checks if memo contains the given item. */
UNIV_INLINE
@ -282,6 +283,7 @@ void
mtr_print(
/*======*/
mtr_t* mtr); /* in: mtr */
#endif /* UNIV_DEBUG */
/*######################################################################*/
#define MTR_BUF_MEMO_SIZE 200 /* number of slots in memo */

2
storage/innobase/include/mtr0mtr.ic
View file

@ -113,6 +113,7 @@ mtr_release_s_latch_at_savepoint(
slot->object = NULL;
}
#ifdef UNIV_DEBUG
/**************************************************************
Checks if memo contains the given item. */
UNIV_INLINE
@ -148,6 +149,7 @@ mtr_memo_contains(
return(FALSE);
}
#endif /* UNIV_DEBUG */
/*******************************************************************
Returns the log object of a mini-transaction buffer. */

5
storage/innobase/include/sync0rw.h
View file

@ -358,8 +358,9 @@ rw_lock_print(
Prints debug info of currently locked rw-locks. */
void
rw_lock_list_print_info(void);
/*=========================*/
rw_lock_list_print_info(
/*====================*/
FILE* file); /* in: file where to print */
/*******************************************************************
Returns the number of currently locked rw-locks.
Works only in the debug version. */

6
storage/innobase/include/sync0sync.h
View file

@ -224,12 +224,6 @@ Counts currently reserved mutexes. Works only in the debug version. */
ulint
mutex_n_reserved(void);
/*==================*/
/**********************************************************************
Prints debug info of currently reserved mutexes. */
void
mutex_list_print_info(void);
/*========================*/
#endif /* UNIV_SYNC_DEBUG */
/**********************************************************************
NOT to be used outside this module except in debugging! Gets the value

59
storage/innobase/include/univ.i
View file

@ -10,18 +10,18 @@ Created 1/20/1994 Heikki Tuuri
#define univ_i
#if (defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)) && !defined(MYSQL_SERVER) && !defined(__WIN__)
#undef __WIN__
#define __WIN__
# undef __WIN__
# define __WIN__
#include <windows.h>
# include <windows.h>
#if !defined(WIN64) && !defined(_WIN64)
#define UNIV_CAN_USE_X86_ASSEMBLER
#endif
# if !defined(WIN64) && !defined(_WIN64)
# define UNIV_CAN_USE_X86_ASSEMBLER
# endif
#ifdef _NT_
#define __NT__
#endif
# ifdef _NT_
# define __NT__
# endif
#else
/* The defines used with MySQL */
@ -30,42 +30,33 @@ Created 1/20/1994 Heikki Tuuri
in compiling more Posix-compatible. These headers also define __WIN__
if we are compiling on Windows. */
#include <my_global.h>
#include <my_pthread.h>
# include <my_global.h>
# include <my_pthread.h>
/* Include <sys/stat.h> to get S_I... macros defined for os0file.c */
#include <sys/stat.h>
# include <sys/stat.h>
#undef PACKAGE
#undef VERSION
# undef PACKAGE
# undef VERSION
/* Include the header file generated by GNU autoconf */
#ifndef __WIN__
#include "config.h"
#endif
# include "config.h"
#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
/* When compiling for Itanium IA64, undefine the flag below to prevent use
of the 32-bit x86 assembler in mutex operations. */
#if defined(__WIN__) && !defined(WIN64) && !defined(_WIN64)
#define UNIV_CAN_USE_X86_ASSEMBLER
#endif
# ifdef HAVE_SCHED_H
# include <sched.h>
# endif
/* We only try to do explicit inlining of functions with gcc and
Microsoft Visual C++ */
#if !defined(__GNUC__) && !defined(__WIN__)
#undef UNIV_MUST_NOT_INLINE /* Remove compiler warning */
#define UNIV_MUST_NOT_INLINE
#endif
# if !defined(__GNUC__)
# undef UNIV_MUST_NOT_INLINE /* Remove compiler warning */
# define UNIV_MUST_NOT_INLINE
# endif
#ifdef HAVE_PREAD
#define HAVE_PWRITE
#endif
# ifdef HAVE_PREAD
# define HAVE_PWRITE
# endif
#endif /* #if (defined(WIN32) || ... */

10
storage/innobase/include/ut0ut.h
View file

@ -218,7 +218,10 @@ ut_print_filename(
struct trx_struct;
/**************************************************************************
Outputs a NUL-terminated string, quoted as an SQL identifier. */
Outputs a fixed-length string, quoted as an SQL identifier.
If the string contains a slash '/', the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier. */
void
ut_print_name(
@ -230,7 +233,10 @@ ut_print_name(
const char* name); /* in: name to print */
/**************************************************************************
Outputs a fixed-length string, quoted as an SQL identifier. */
Outputs a fixed-length string, quoted as an SQL identifier.
If the string contains a slash '/', the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier. */
void
ut_print_namel(

14
storage/innobase/mem/mem0dbg.c
View file

@ -66,7 +66,6 @@ mem_hash_get_nth_cell(ulint i)
return(&(mem_hash_table[i]));
}
#endif /* UNIV_MEM_DEBUG */
/* Accessor functions for a memory field in the debug version */
@ -106,6 +105,7 @@ mem_field_trailer_get_check(byte* field)
return(mach_read_from_4(field
+ mem_field_header_get_len(field)));
}
#endif /* UNIV_MEM_DEBUG */
/**********************************************************************
Initializes the memory system. */
@ -136,6 +136,7 @@ mem_init(
mem_comm_pool = mem_pool_create(size);
}
#ifdef UNIV_MEM_DEBUG
/**********************************************************************
Initializes an allocated memory field in the debug version. */
@ -163,7 +164,6 @@ mem_field_init(
mem_field_header_set_check(usr_buf, rnd);
mem_field_trailer_set_check(usr_buf, rnd);
#ifdef UNIV_MEM_DEBUG
/* Update the memory allocation information */
mutex_enter(&mem_hash_mutex);
@ -182,7 +182,6 @@ mem_field_init(
combination of 0xBA and 0xBE */
mem_init_buf(usr_buf, n);
#endif /* UNIV_MEM_DEBUG */
}
/**********************************************************************
@ -199,7 +198,6 @@ mem_field_erase(
usr_buf = buf + MEM_FIELD_HEADER_SIZE;
#ifdef UNIV_MEM_DEBUG
mutex_enter(&mem_hash_mutex);
mem_current_allocated_memory -= n;
mutex_exit(&mem_hash_mutex);
@ -211,10 +209,8 @@ mem_field_erase(
combination of 0xDE and 0xAD */
mem_erase_buf(buf, MEM_SPACE_NEEDED(n));
#endif /* UNIV_MEM_DEBUG */
}
#ifdef UNIV_MEM_DEBUG
/*******************************************************************
Initializes a buffer to a random combination of hex BA and BE.
Used to initialize allocated memory. */
@ -376,6 +372,7 @@ mem_hash_remove(
}
#endif /* UNIV_MEM_DEBUG */
#if defined UNIV_MEM_DEBUG || defined UNIV_DEBUG
/*******************************************************************
Checks a memory heap for consistency and prints the contents if requested.
Outputs the sum of sizes of buffers given to the user (only in
@ -549,10 +546,12 @@ completed:
}
*error = FALSE;
}
#endif /* UNIV_MEM_DEBUG || UNIV_DEBUG */
#ifdef UNIV_DEBUG
/******************************************************************
Prints the contents of a memory heap. */
static
void
mem_heap_print(
/*===========*/
@ -615,6 +614,7 @@ mem_heap_validate(
return(TRUE);
}
#endif /* UNIV_DEBUG */
#ifdef UNIV_MEM_DEBUG
/*********************************************************************

17
storage/innobase/mem/mem0pool.c
View file

@ -35,7 +35,7 @@ The main components of the memory consumption are:
8. session for each user, and
9. stack for each OS thread.
Items 1-3 are managed by an LRU algorithm. Items 5 and 6 can potentially
Items 1 and 2 are managed by an LRU algorithm. Items 5 and 6 can potentially
consume very much memory. Items 7 and 8 should consume quite little memory,
and the OS should take care of item 9, which too should consume little memory.
@ -54,16 +54,15 @@ common pool and the buffers in the buffer pool into a single LRU list and
manage it uniformly, but this approach does not take into account the parsing
and other costs unique to SQL statements.
So, let the SQL statements and the data dictionary entries form one single
LRU list, let us call it the dictionary LRU list. The locks for a transaction
can be seen as a part of the state of the transaction. Hence, they should be
stored in the common pool. We still have the problem of a very big update
transaction, for example, which will set very many x-locks on rows, and the
locks will consume a lot of memory, say, half of the buffer pool size.
The locks for a transaction can be seen as a part of the state of the
transaction. Hence, they should be stored in the common pool. We still
have the problem of a very big update transaction, for example, which
will set very many x-locks on rows, and the locks will consume a lot
of memory, say, half of the buffer pool size.
Another problem is what to do if we are not able to malloc a requested
block of memory from the common pool. Then we can truncate the LRU list of
the dictionary cache. If it does not help, a system error results.
block of memory from the common pool. Then we can request memory from
the operating system. If it does not help, a system error results.
Because 5 and 6 may potentially consume very much memory, we let them grow
into the buffer pool. We may let the locks of a transaction take frames

2
storage/innobase/mtr/mtr0mtr.c
View file

@ -318,6 +318,7 @@ mtr_read_dulint(
return(mach_read_from_8(ptr));
}
#ifdef UNIV_DEBUG
/*************************************************************
Prints info of an mtr handle. */
@ -332,3 +333,4 @@ mtr_print(
(ulong) dyn_array_get_data_size(&(mtr->memo)),
(ulong) dyn_array_get_data_size(&(mtr->log)));
}
#endif /* UNIV_DEBUG */

2
storage/innobase/row/row0purge.c
View file

@ -563,7 +563,7 @@ row_purge_parse_undo_rec(
/* Read to the partial row the fields that occur in indexes */
if (!cmpl_info & UPD_NODE_NO_ORD_CHANGE) {
if (!(cmpl_info & UPD_NODE_NO_ORD_CHANGE)) {
ptr = trx_undo_rec_get_partial_row(ptr, clust_index,
&(node->row), node->heap);
}

15
storage/innobase/sync/sync0rw.c
View file

@ -758,8 +758,9 @@ rw_lock_is_locked(
Prints debug info of currently locked rw-locks. */
void
rw_lock_list_print_info(void)
/*=========================*/
rw_lock_list_print_info(
/*====================*/
FILE* file) /* in: file where to print */
{
rw_lock_t* lock;
ulint count = 0;
@ -769,7 +770,7 @@ rw_lock_list_print_info(void)
fputs("-------------\n"
"RW-LATCH INFO\n"
"-------------\n", stderr);
"-------------\n", file);
lock = UT_LIST_GET_FIRST(rw_lock_list);
@ -783,12 +784,12 @@ rw_lock_list_print_info(void)
|| (rw_lock_get_reader_count(lock) != 0)
|| (rw_lock_get_waiters(lock) != 0)) {
fprintf(stderr, "RW-LOCK: %p ", (void*) lock);
fprintf(file, "RW-LOCK: %p ", (void*) lock);
if (rw_lock_get_waiters(lock)) {
fputs(" Waiters for the lock exist\n", stderr);
fputs(" Waiters for the lock exist\n", file);
} else {
putc('\n', stderr);
putc('\n', file);
}
info = UT_LIST_GET_FIRST(lock->debug_list);
@ -802,7 +803,7 @@ rw_lock_list_print_info(void)
lock = UT_LIST_GET_NEXT(list, lock);
}
fprintf(stderr, "Total number of rw-locks %ld\n", count);
fprintf(file, "Total number of rw-locks %ld\n", count);
mutex_exit(&rw_lock_list_mutex);
}

19
storage/innobase/sync/sync0sync.c
View file

@ -628,10 +628,11 @@ mutex_own(
/**********************************************************************
Prints debug info of currently reserved mutexes. */
static
void
mutex_list_print_info(void)
/*=======================*/
mutex_list_print_info(
/*==================*/
FILE* file) /* in: file where to print */
{
mutex_t* mutex;
const char* file_name;
@ -641,7 +642,7 @@ mutex_list_print_info(void)
fputs("----------\n"
"MUTEX INFO\n"
"----------\n", stderr);
"----------\n", file);
mutex_enter(&mutex_list_mutex);
@ -653,7 +654,7 @@ mutex_list_print_info(void)
if (mutex_get_lock_word(mutex) != 0) {
mutex_get_debug_info(mutex, &file_name, &line,
&thread_id);
fprintf(stderr,
fprintf(file,
"Locked mutex: addr %p thread %ld"
" file %s line %ld\n",
(void*) mutex, os_thread_pf(thread_id),
@ -663,7 +664,7 @@ mutex_list_print_info(void)
mutex = UT_LIST_GET_NEXT(list, mutex);
}
fprintf(stderr, "Total number of mutexes %ld\n", count);
fprintf(file, "Total number of mutexes %ld\n", count);
mutex_exit(&mutex_list_mutex);
}
@ -1343,7 +1344,7 @@ sync_print_wait_info(
FILE* file) /* in: file where to print */
{
#ifdef UNIV_SYNC_DEBUG
fprintf(stderr, "Mutex exits %lu, rws exits %lu, rwx exits %lu\n",
fprintf(file, "Mutex exits %lu, rws exits %lu, rwx exits %lu\n",
mutex_exit_count, rw_s_exit_count, rw_x_exit_count);
#endif
@ -1369,9 +1370,9 @@ sync_print(
FILE* file) /* in: file where to print */
{
#ifdef UNIV_SYNC_DEBUG
mutex_list_print_info();
mutex_list_print_info(file);
rw_lock_list_print_info();
rw_lock_list_print_info(file);
#endif /* UNIV_SYNC_DEBUG */
sync_array_print_info(file, sync_primary_wait_array);

12
storage/innobase/ut/ut0ut.c
View file

@ -394,7 +394,10 @@ done:
}
/**************************************************************************
Outputs a NUL-terminated string, quoted as an SQL identifier. */
Outputs a fixed-length string, quoted as an SQL identifier.
If the string contains a slash '/', the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier. */
void
ut_print_name(
@ -409,7 +412,10 @@ ut_print_name(
}
/**************************************************************************
Outputs a fixed-length string, quoted as an SQL identifier. */
Outputs a fixed-length string, quoted as an SQL identifier.
If the string contains a slash '/', the string will be
output as two identifiers separated by a period (.),
as in SQL database_name.identifier. */
void
ut_print_namel(
@ -424,7 +430,7 @@ ut_print_namel(
#ifdef UNIV_HOTBACKUP
fwrite(name, 1, namelen, f);
#else
char* slash = strchr(name, '/');
char* slash = memchr(name, '/', namelen);
if (UNIV_LIKELY_NULL(slash)) {
/* Print the database name and table name separately. */