ha_innodb.cc 322 KB
Newer Older
1
/*****************************************************************************
2

3
Copyright (c) 2000, 2010, MySQL AB & Innobase Oy. All Rights Reserved.
4
Copyright (c) 2008, 2009 Google Inc.
5
Copyright (c) 2009, Percona Inc.
osku's avatar
osku committed
6

7 8 9 10 11
Portions of this file contain modifications contributed and copyrighted by
Google, Inc. Those modifications are gratefully acknowledged and are described
briefly in the InnoDB documentation. The contributions by Google are
incorporated with their permission, and subject to the conditions contained in
the file COPYING.Google.
osku's avatar
osku committed
12

13 14 15 16 17 18 19
Portions of this file contain modifications contributed and copyrighted
by Percona Inc.. Those modifications are
gratefully acknowledged and are described briefly in the InnoDB
documentation. The contributions by Percona Inc. are incorporated with
their permission, and subject to the conditions contained in the file
COPYING.Percona.

20 21 22 23 24 25 26 27 28 29 30 31 32
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA

*****************************************************************************/
osku's avatar
osku committed
33 34

/* TODO list for the InnoDB handler in 5.0:
35
  - Remove the flag trx->active_trans and look at trx->conc_state
osku's avatar
osku committed
36 37 38 39 40 41 42 43 44 45
  - fix savepoint functions to use savepoint storage area
  - Find out what kind of problems the OS X case-insensitivity causes to
    table and database names; should we 'normalize' the names like we do
    in Windows?
*/

#ifdef USE_PRAGMA_IMPLEMENTATION
#pragma implementation				// gcc: Class implementation
#endif

46 47
#include <sql_table.h>	// explain_filename, nz2, EXPLAIN_PARTITIONS_AS_COMMENT,
			// EXPLAIN_FILENAME_MAX_EXTRA_LENGTH
48

49
#include <sql_acl.h>	// PROCESS_ACL
osku's avatar
osku committed
50 51
#include <m_ctype.h>
#include <mysys_err.h>
52
#include <mysql/plugin.h>
53
#include <mysql/innodb_priv.h>
54
#include <mysql/psi/psi.h>
55

56 57
/** @file ha_innodb.cc */

58 59
/* Include necessary InnoDB headers */
extern "C" {
60
#include "univ.i"
61
#include "buf0lru.h"
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
#include "btr0sea.h"
#include "os0file.h"
#include "os0thread.h"
#include "srv0start.h"
#include "srv0srv.h"
#include "trx0roll.h"
#include "trx0trx.h"
#include "trx0sys.h"
#include "mtr0mtr.h"
#include "row0ins.h"
#include "row0mysql.h"
#include "row0sel.h"
#include "row0upd.h"
#include "log0log.h"
#include "lock0lock.h"
#include "dict0crea.h"
#include "btr0cur.h"
#include "btr0btr.h"
#include "fsp0fsp.h"
#include "sync0sync.h"
#include "fil0fil.h"
#include "trx0xa.h"
#include "row0merge.h"
#include "thr0loc.h"
#include "dict0boot.h"
#include "ha_prototypes.h"
#include "ut0mem.h"
#include "ibuf0ibuf.h"
90 91
}

osku's avatar
osku committed
92
#include "ha_innodb.h"
93
#include "i_s.h"
94

95 96 97
# ifndef MYSQL_PLUGIN_IMPORT
#  define MYSQL_PLUGIN_IMPORT /* nothing */
# endif /* MYSQL_PLUGIN_IMPORT */
98

99
#if MYSQL_VERSION_ID < 50124
100 101 102
/* this is defined in mysql_priv.h inside #ifdef MYSQL_SERVER
but we need it here */
bool check_global_access(THD *thd, ulong want_access);
103
#endif /* MYSQL_VERSION_ID < 50124 */
104 105

/** to protect innobase_open_files */
106
static mysql_mutex_t innobase_share_mutex;
107
/** to force correct commit order in binlog */
108
static mysql_mutex_t prepare_commit_mutex;
109
static ulong commit_threads = 0;
110 111 112 113
static mysql_mutex_t commit_threads_m;
static mysql_cond_t commit_cond;
static mysql_mutex_t commit_cond_m;
static mysql_mutex_t analyze_mutex;
114
static bool innodb_inited = 0;
osku's avatar
osku committed
115

116 117
#define INSIDE_HA_INNOBASE_CC

118 119
/* In the Windows plugin, the return value of current_thd is
undefined.  Map it to NULL. */
120 121 122

#define EQ_CURRENT_THD(thd) ((thd) == current_thd)

123

124
static struct handlerton* innodb_hton_ptr;
125

126 127 128 129
static const long AUTOINC_OLD_STYLE_LOCKING = 0;
static const long AUTOINC_NEW_STYLE_LOCKING = 1;
static const long AUTOINC_NO_LOCKING = 2;

130
static long innobase_mirrored_log_groups, innobase_log_files_in_group,
131
	innobase_log_buffer_size,
132
	innobase_additional_mem_pool_size, innobase_file_io_threads,
133 134
	innobase_force_recovery, innobase_open_files,
	innobase_autoinc_lock_mode;
135
static ulong innobase_commit_concurrency = 0;
136 137
static ulong innobase_read_io_threads;
static ulong innobase_write_io_threads;
irana's avatar
irana committed
138
static long innobase_buffer_pool_instances = 1;
139

140
static long long innobase_buffer_pool_size, innobase_log_file_size;
osku's avatar
osku committed
141

142 143 144 145
/** Percentage of the buffer pool to reserve for 'old' blocks.
Connected to buf_LRU_old_ratio. */
static uint innobase_old_blocks_pct;

osku's avatar
osku committed
146 147
/* The default values for the following char* start-up parameters
are determined in innobase_init below: */
148

149 150 151
static char*	innobase_data_home_dir			= NULL;
static char*	innobase_data_file_path			= NULL;
static char*	innobase_log_group_home_dir		= NULL;
152
static char*	innobase_file_format_name		= NULL;
153
static char*	innobase_change_buffering		= NULL;
154 155 156 157 158 159

/* Note: This variable can be set to on/off and any of the supported
file formats in the configuration file, but can only be set to any
of the supported file formats during runtime. */
static char*	innobase_file_format_check		= NULL;

160
static char*	innobase_file_flush_method		= NULL;
osku's avatar
osku committed
161 162 163 164

/* Below we have boolean-valued start-up parameters, and their default
values */

165 166 167 168 169 170 171 172 173 174
static ulong	innobase_fast_shutdown			= 1;
#ifdef UNIV_LOG_ARCHIVE
static my_bool	innobase_log_archive			= FALSE;
static char*	innobase_log_arch_dir			= NULL;
#endif /* UNIV_LOG_ARCHIVE */
static my_bool	innobase_use_doublewrite		= TRUE;
static my_bool	innobase_use_checksums			= TRUE;
static my_bool	innobase_locks_unsafe_for_binlog	= FALSE;
static my_bool	innobase_rollback_on_timeout		= FALSE;
static my_bool	innobase_create_status_file		= FALSE;
175
static my_bool	innobase_stats_on_metadata		= TRUE;
osku's avatar
osku committed
176

177
static char*	internal_innobase_data_file_path	= NULL;
osku's avatar
osku committed
178

179 180
static char*	innodb_version_str = (char*) INNODB_VERSION_STR;

osku's avatar
osku committed
181 182 183 184 185 186
/* The following counter is used to convey information to InnoDB
about server activity: in selects it is not sensible to call
srv_active_wake_master_thread after each fetch or search, we only do
it every INNOBASE_WAKE_INTERVAL'th step. */

#define INNOBASE_WAKE_INTERVAL	32
187
static ulong	innobase_active_counter	= 0;
osku's avatar
osku committed
188

189
static hash_table_t*	innobase_open_tables;
osku's avatar
osku committed
190

191
#ifdef __NETWARE__	/* some special cleanup for NetWare */
osku's avatar
osku committed
192 193 194
bool nw_panic = FALSE;
#endif

195
/** Allowed values of innodb_change_buffering */
196
static const char* innobase_change_buffering_values[IBUF_USE_COUNT] = {
197 198 199 200 201 202 203 204
	"none",		/* IBUF_USE_NONE */
	"inserts",	/* IBUF_USE_INSERT */
	"deletes",	/* IBUF_USE_DELETE_MARK */
	"changes",	/* IBUF_USE_INSERT_DELETE_MARK */
	"purges",	/* IBUF_USE_DELETE */
	"all"		/* IBUF_USE_ALL */
};

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
#ifdef HAVE_PSI_INTERFACE
/* Keys to register pthread mutexes/cond in the current file with
performance schema */
static mysql_pfs_key_t	innobase_share_mutex_key;
static mysql_pfs_key_t	prepare_commit_mutex_key;
static mysql_pfs_key_t	commit_threads_m_key;
static mysql_pfs_key_t	analyze_mutex_key;
static mysql_pfs_key_t	commit_cond_mutex_key;
static mysql_pfs_key_t	commit_cond_key;

static PSI_mutex_info	all_pthread_mutexes[] = {
        {&analyze_mutex_key, "analyze_mutex", 0},
        {&commit_threads_m_key, "commit_threads_m", 0},
        {&commit_cond_mutex_key, "commit_cond_mutex", 0},
        {&innobase_share_mutex_key, "innobase_share_mutex", 0},
        {&prepare_commit_mutex_key, "prepare_commit_mutex", 0}
};

static PSI_cond_info	all_innodb_conds[] = {
	{&commit_cond_key, "commit_cond", 0}
};

# ifdef UNIV_PFS_MUTEX
/* all_innodb_mutexes array contains mutexes that are
performance schema instrumented if "UNIV_PFS_MUTEX"
is defined */
static PSI_mutex_info all_innodb_mutexes[] = {
	{&autoinc_mutex_key, "autoinc_mutex", 0},
	{&btr_search_enabled_mutex_key, "btr_search_enabled_mutex", 0},
234
#  ifndef PFS_SKIP_BUFFER_MUTEX_RWLOCK
235
	{&buffer_block_mutex_key, "buffer_block_mutex", 0},
236
#  endif /* !PFS_SKIP_BUFFER_MUTEX_RWLOCK */
237 238 239 240 241 242 243 244
	{&buf_pool_mutex_key, "buf_pool_mutex", 0},
	{&buf_pool_zip_mutex_key, "buf_pool_zip_mutex", 0},
	{&cache_last_read_mutex_key, "cache_last_read_mutex", 0},
	{&dict_foreign_err_mutex_key, "dict_foreign_err_mutex", 0},
	{&dict_sys_mutex_key, "dict_sys_mutex", 0},
	{&file_format_max_mutex_key, "file_format_max_mutex", 0},
	{&fil_system_mutex_key, "fil_system_mutex", 0},
	{&flush_list_mutex_key, "flush_list_mutex", 0},
irana's avatar
irana committed
245
	{&log_flush_order_mutex_key, "log_flush_order_mutex", 0},
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
	{&hash_table_mutex_key, "hash_table_mutex", 0},
	{&ibuf_bitmap_mutex_key, "ibuf_bitmap_mutex", 0},
	{&ibuf_mutex_key, "ibuf_mutex", 0},
	{&ibuf_pessimistic_insert_mutex_key,
		 "ibuf_pessimistic_insert_mutex", 0},
	{&ios_mutex_key, "ios_mutex", 0},
	{&kernel_mutex_key, "kernel_mutex", 0},
	{&log_sys_mutex_key, "log_sys_mutex", 0},
#  ifdef UNIV_MEM_DEBUG
	{&mem_hash_mutex_key, "mem_hash_mutex", 0},
#  endif /* UNIV_MEM_DEBUG */
	{&mem_pool_mutex_key, "mem_pool_mutex", 0},
	{&mutex_list_mutex_key, "mutex_list_mutex", 0},
	{&purge_sys_mutex_key, "purge_sys_mutex", 0},
	{&recv_sys_mutex_key, "recv_sys_mutex", 0},
	{&rseg_mutex_key, "rseg_mutex", 0},
#  ifdef UNIV_SYNC_DEBUG
	{&rw_lock_debug_mutex_key, "rw_lock_debug_mutex", 0},
#  endif /* UNIV_SYNC_DEBUG */
	{&rw_lock_list_mutex_key, "rw_lock_list_mutex", 0},
	{&rw_lock_mutex_key, "rw_lock_mutex", 0},
	{&srv_dict_tmpfile_mutex_key, "srv_dict_tmpfile_mutex", 0},
	{&srv_innodb_monitor_mutex_key, "srv_innodb_monitor_mutex", 0},
	{&srv_misc_tmpfile_mutex_key, "srv_misc_tmpfile_mutex", 0},
	{&srv_monitor_file_mutex_key, "srv_monitor_file_mutex", 0},
	{&syn_arr_mutex_key, "syn_arr_mutex", 0},
#  ifdef UNIV_SYNC_DEBUG
	{&sync_thread_mutex_key, "sync_thread_mutex", 0},
#  endif /* UNIV_SYNC_DEBUG */
	{&trx_doublewrite_mutex_key, "trx_doublewrite_mutex", 0},
	{&thr_local_mutex_key, "thr_local_mutex", 0},
277
	{&trx_undo_mutex_key, "trx_undo_mutex", 0}
278 279 280 281 282 283 284 285
};
# endif /* UNIV_PFS_MUTEX */

# ifdef UNIV_PFS_RWLOCK
/* all_innodb_rwlocks array contains rwlocks that are
performance schema instrumented if "UNIV_PFS_RWLOCK"
is defined */
static PSI_rwlock_info all_innodb_rwlocks[] = {
286 287 288
#  ifdef UNIV_LOG_ARCHIVE
	{&archive_lock_key, "archive_lock", 0},
#  endif /* UNIV_LOG_ARCHIVE */
289
	{&btr_search_latch_key, "btr_search_latch", 0},
290
#  ifndef PFS_SKIP_BUFFER_MUTEX_RWLOCK
291
	{&buf_block_lock_key, "buf_block_lock", 0},
292
#  endif /* !PFS_SKIP_BUFFER_MUTEX_RWLOCK */
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
#  ifdef UNIV_SYNC_DEBUG
	{&buf_block_debug_latch_key, "buf_block_debug_latch", 0},
#  endif /* UNIV_SYNC_DEBUG */
	{&dict_operation_lock_key, "dict_operation_lock", 0},
	{&fil_space_latch_key, "fil_space_latch", 0},
	{&checkpoint_lock_key, "checkpoint_lock", 0},
	{&trx_i_s_cache_lock_key, "trx_i_s_cache_lock", 0},
	{&trx_purge_latch_key, "trx_purge_latch", 0},
	{&index_tree_rw_lock_key, "index_tree_rw_lock", 0}
};
# endif /* UNIV_PFS_RWLOCK */

# ifdef UNIV_PFS_THREAD
/* all_innodb_threads array contains threads that are
performance schema instrumented if "UNIV_PFS_THREAD"
is defined */
static PSI_thread_info	all_innodb_threads[] = {
	{&trx_rollback_clean_thread_key, "trx_rollback_clean_thread", 0},
	{&io_handler_thread_key, "io_handler_thread", 0},
	{&srv_lock_timeout_thread_key, "srv_lock_timeout_thread", 0},
	{&srv_error_monitor_thread_key, "srv_error_monitor_thread", 0},
	{&srv_monitor_thread_key, "srv_monitor_thread", 0},
315 316
	{&srv_master_thread_key, "srv_master_thread", 0},
	{&srv_purge_thread_key, "srv_purge_thread", 0}
317 318 319 320 321 322 323 324 325 326 327 328 329 330
};
# endif /* UNIV_PFS_THREAD */

# ifdef UNIV_PFS_IO
/* all_innodb_files array contains the type of files that are
performance schema instrumented if "UNIV_PFS_IO" is defined */
static PSI_file_info	all_innodb_files[] = {
	{&innodb_file_data_key, "innodb_data_file", 0},
	{&innodb_file_log_key, "innodb_log_file", 0},
	{&innodb_file_temp_key, "innodb_temp_file", 0}
};
# endif /* UNIV_PFS_IO */
#endif /* HAVE_PSI_INTERFACE */

osku's avatar
osku committed
331 332
static INNOBASE_SHARE *get_share(const char *table_name);
static void free_share(INNOBASE_SHARE *share);
333 334 335
static int innobase_close_connection(handlerton *hton, THD* thd);
static int innobase_commit(handlerton *hton, THD* thd, bool all);
static int innobase_rollback(handlerton *hton, THD* thd, bool all);
336
static int innobase_rollback_to_savepoint(handlerton *hton, THD* thd,
337 338
           void *savepoint);
static int innobase_savepoint(handlerton *hton, THD* thd, void *savepoint);
339
static int innobase_release_savepoint(handlerton *hton, THD* thd,
340 341 342
           void *savepoint);
static handler *innobase_create_handler(handlerton *hton,
                                        TABLE_SHARE *table,
343
                                        MEM_ROOT *mem_root);
osku's avatar
osku committed
344

345 346 347 348
/* "GEN_CLUST_INDEX" is the name reserved for Innodb default
system primary index. */
static const char innobase_index_reserve_name[]= "GEN_CLUST_INDEX";

349 350 351 352 353 354 355 356 357 358 359 360 361 362
/** @brief Initialize the default value of innodb_commit_concurrency.

Once InnoDB is running, the innodb_commit_concurrency must not change
from zero to nonzero. (Bug #42101)

The initial default value is 0, and without this extra initialization,
SET GLOBAL innodb_commit_concurrency=DEFAULT would set the parameter
to 0, even if it was initially set to nonzero at the command line
or configuration file. */
static
void
innobase_commit_concurrency_init_default(void);
/*==========================================*/

363
/************************************************************//**
364 365
Validate the file format name and return its corresponding id.
@return	valid file format id */
366 367 368 369
static
uint
innobase_file_format_name_lookup(
/*=============================*/
370
	const char*	format_name);		/*!< in: pointer to file format
371
						name */
372
/************************************************************//**
373
Validate the file format check config parameters, as a side effect it
374 375
sets the srv_check_file_format_at_startup variable.
@return	true if one of  "on" or "off" */
376 377 378 379
static
bool
innobase_file_format_check_on_off(
/*==============================*/
380
	const char*	format_check);		/*!< in: parameter value */
381
/************************************************************//**
382
Validate the file format check config parameters, as a side effect it
383
sets the srv_check_file_format_at_startup variable.
384
@return	the format_id if valid config value, otherwise, return -1 */
385
static
386 387
int
innobase_file_format_validate_and_set(
388
/*================================*/
389
	const char*	format_check);		/*!< in: parameter value */
390
/****************************************************************//**
391 392 393 394 395 396 397
Return alter table flags supported in an InnoDB database. */
static
uint
innobase_alter_table_flags(
/*=======================*/
	uint	flags);

398
static const char innobase_hton_name[]= "InnoDB";
399

400
/*************************************************************//**
401 402
Check for a valid value of innobase_commit_concurrency.
@return	0 for valid innodb_commit_concurrency */
403 404 405 406
static
int
innobase_commit_concurrency_validate(
/*=================================*/
407 408
	THD*				thd,	/*!< in: thread handle */
	struct st_mysql_sys_var*	var,	/*!< in: pointer to system
409
						variable */
410
	void*				save,	/*!< out: immediate result
411
						for update function */
412
	struct st_mysql_value*		value)	/*!< in: incoming string */
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
{
	long long	intbuf;
	ulong		commit_concurrency;

	DBUG_ENTER("innobase_commit_concurrency_validate");

	if (value->val_int(value, &intbuf)) {
		/* The value is NULL. That is invalid. */
		DBUG_RETURN(1);
	}

	*reinterpret_cast<ulong*>(save) = commit_concurrency
		= static_cast<ulong>(intbuf);

	/* Allow the value to be updated, as long as it remains zero
	or nonzero. */
	DBUG_RETURN(!(!commit_concurrency == !innobase_commit_concurrency));
}

432 433 434 435 436 437 438 439 440 441
static MYSQL_THDVAR_BOOL(support_xa, PLUGIN_VAR_OPCMDARG,
  "Enable InnoDB support for the XA two-phase commit",
  /* check_func */ NULL, /* update_func */ NULL,
  /* default */ TRUE);

static MYSQL_THDVAR_BOOL(table_locks, PLUGIN_VAR_OPCMDARG,
  "Enable InnoDB locking in LOCK TABLES",
  /* check_func */ NULL, /* update_func */ NULL,
  /* default */ TRUE);

442
static MYSQL_THDVAR_BOOL(strict_mode, PLUGIN_VAR_OPCMDARG,
443 444 445
  "Use strict mode when evaluating create options.",
  NULL, NULL, FALSE);

446 447 448 449
static MYSQL_THDVAR_ULONG(lock_wait_timeout, PLUGIN_VAR_RQCMDARG,
  "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.",
  NULL, NULL, 50, 1, 1024 * 1024 * 1024, 0);

450

451
static handler *innobase_create_handler(handlerton *hton,
452
                                        TABLE_SHARE *table,
453
                                        MEM_ROOT *mem_root)
osku's avatar
osku committed
454
{
455
  return new (mem_root) ha_innobase(hton, table);
osku's avatar
osku committed
456 457
}

458 459
/*******************************************************************//**
This function is used to prepare an X/Open XA distributed transaction.
460
@return	0 or error number */
461 462 463 464
static
int
innobase_xa_prepare(
/*================*/
465 466 467 468 469 470 471 472 473
        handlerton*	hton,	/*!< in: InnoDB handlerton */
	THD*		thd,	/*!< in: handle to the MySQL thread of
				the user whose XA transaction should
				be prepared */
	bool		all);	/*!< in: TRUE - commit transaction
				FALSE - the current SQL statement
				ended */
/*******************************************************************//**
This function is used to recover X/Open XA distributed transactions.
474
@return	number of prepared transactions stored in xid_list */
475 476 477 478
static
int
innobase_xa_recover(
/*================*/
479 480 481 482
	handlerton*	hton,	/*!< in: InnoDB handlerton */
	XID*		xid_list,/*!< in/out: prepared transactions */
	uint		len);	/*!< in: number of slots in xid_list */
/*******************************************************************//**
483
This function is used to commit one X/Open XA distributed transaction
484 485
which is in the prepared state
@return	0 or error number */
486 487 488 489 490
static
int
innobase_commit_by_xid(
/*===================*/
	handlerton* hton,
491
	XID*	xid);	/*!< in: X/Open XA transaction identification */
492
/*******************************************************************//**
493
This function is used to rollback one X/Open XA distributed transaction
494 495
which is in the prepared state
@return	0 or error number */
496 497 498 499
static
int
innobase_rollback_by_xid(
/*=====================*/
500 501 502 503
	handlerton*	hton,	/*!< in: InnoDB handlerton */
	XID*		xid);	/*!< in: X/Open XA transaction
				identification */
/*******************************************************************//**
504 505 506
Create a consistent view for a cursor based on current transaction
which is created if the corresponding MySQL thread still lacks one.
This consistent view is then used inside of MySQL when accessing records
507 508
using a cursor.
@return	pointer to cursor view or NULL */
509 510 511 512
static
void*
innobase_create_cursor_view(
/*========================*/
513 514
	handlerton*	hton,	/*!< in: innobase hton */
	THD*		thd);	/*!< in: user thread handle */
515
/*******************************************************************//**
516 517 518 519 520 521 522 523 524
Set the given consistent cursor view to a transaction which is created
if the corresponding MySQL thread still lacks one. If the given
consistent cursor view is NULL global read view of a transaction is
restored to a transaction read view. */
static
void
innobase_set_cursor_view(
/*=====================*/
	handlerton* hton,
525 526
	THD*	thd,	/*!< in: user thread handle */
	void*	curview);/*!< in: Consistent cursor view to be set */
527
/*******************************************************************//**
528 529 530 531 532 533 534 535
Close the given consistent cursor view of a transaction and restore
global read view to a transaction read view. Transaction is created if the
corresponding MySQL thread still lacks one. */
static
void
innobase_close_cursor_view(
/*=======================*/
	handlerton* hton,
536 537
	THD*	thd,	/*!< in: user thread handle */
	void*	curview);/*!< in: Consistent read view to be closed */
538
/*****************************************************************//**
539 540 541 542 543
Removes all tables in the named database inside InnoDB. */
static
void
innobase_drop_database(
/*===================*/
544 545
	handlerton* hton, /*!< in: handlerton of Innodb */
	char*	path);	/*!< in: database path; inside InnoDB the name
546 547 548
			of the last directory in the path is used as
			the database name: for example, in 'mysql/data/test'
			the database name is 'test' */
549
/*******************************************************************//**
550 551 552 553 554
Closes an InnoDB database. */
static
int
innobase_end(handlerton *hton, ha_panic_function type);

555
/*****************************************************************//**
556 557 558
Creates an InnoDB transaction struct for the thd if it does not yet have one.
Starts a new InnoDB transaction if a transaction is not yet started. And
assigns a new snapshot for a consistent read if the transaction does not yet
559 560
have one.
@return	0 */
561 562 563 564
static
int
innobase_start_trx_and_assign_read_view(
/*====================================*/
565 566 567
			/* out: 0 */
	handlerton* hton, /* in: Innodb handlerton */
	THD*	thd);	/* in: MySQL thread handle of the user for whom
568
			the transaction should be committed */
569
/****************************************************************//**
570
Flushes InnoDB logs to disk and makes a checkpoint. Really, a commit flushes
571 572
the logs, and the name of this function should be innobase_checkpoint.
@return	TRUE if error */
573 574 575 576
static
bool
innobase_flush_logs(
/*================*/
577
	handlerton*	hton);	/*!< in: InnoDB handlerton */
578

579
/************************************************************************//**
580 581 582 583 584 585
Implements the SHOW INNODB STATUS command. Sends the output of the InnoDB
Monitor to the client. */
static
bool
innodb_show_status(
/*===============*/
586 587
	handlerton*	hton,	/*!< in: the innodb handlerton */
	THD*	thd,	/*!< in: the MySQL query thread of the caller */
588 589 590 591 592
	stat_print_fn *stat_print);
static
bool innobase_show_status(handlerton *hton, THD* thd, 
                          stat_print_fn* stat_print,
                          enum ha_stat_type stat_type);
osku's avatar
osku committed
593

594
/*****************************************************************//**
osku's avatar
osku committed
595
Commits a transaction in an InnoDB database. */
596
static
osku's avatar
osku committed
597 598 599
void
innobase_commit_low(
/*================*/
600
	trx_t*	trx);	/*!< in: transaction handle */
osku's avatar
osku committed
601

602
static SHOW_VAR innodb_status_variables[]= {
osku's avatar
osku committed
603
  {"buffer_pool_pages_data",
604
  (char*) &export_vars.innodb_buffer_pool_pages_data,	  SHOW_LONG},
osku's avatar
osku committed
605
  {"buffer_pool_pages_dirty",
606
  (char*) &export_vars.innodb_buffer_pool_pages_dirty,	  SHOW_LONG},
osku's avatar
osku committed
607 608 609
  {"buffer_pool_pages_flushed",
  (char*) &export_vars.innodb_buffer_pool_pages_flushed,  SHOW_LONG},
  {"buffer_pool_pages_free",
610
  (char*) &export_vars.innodb_buffer_pool_pages_free,	  SHOW_LONG},
611
#ifdef UNIV_DEBUG
osku's avatar
osku committed
612 613
  {"buffer_pool_pages_latched",
  (char*) &export_vars.innodb_buffer_pool_pages_latched,  SHOW_LONG},
614
#endif /* UNIV_DEBUG */
osku's avatar
osku committed
615
  {"buffer_pool_pages_misc",
616
  (char*) &export_vars.innodb_buffer_pool_pages_misc,	  SHOW_LONG},
osku's avatar
osku committed
617
  {"buffer_pool_pages_total",
618
  (char*) &export_vars.innodb_buffer_pool_pages_total,	  SHOW_LONG},
619 620 621 622
  {"buffer_pool_read_ahead",
  (char*) &export_vars.innodb_buffer_pool_read_ahead,	  SHOW_LONG},
  {"buffer_pool_read_ahead_evicted",
  (char*) &export_vars.innodb_buffer_pool_read_ahead_evicted, SHOW_LONG},
osku's avatar
osku committed
623 624 625
  {"buffer_pool_read_requests",
  (char*) &export_vars.innodb_buffer_pool_read_requests,  SHOW_LONG},
  {"buffer_pool_reads",
626
  (char*) &export_vars.innodb_buffer_pool_reads,	  SHOW_LONG},
osku's avatar
osku committed
627
  {"buffer_pool_wait_free",
628
  (char*) &export_vars.innodb_buffer_pool_wait_free,	  SHOW_LONG},
osku's avatar
osku committed
629 630 631
  {"buffer_pool_write_requests",
  (char*) &export_vars.innodb_buffer_pool_write_requests, SHOW_LONG},
  {"data_fsyncs",
632
  (char*) &export_vars.innodb_data_fsyncs,		  SHOW_LONG},
osku's avatar
osku committed
633
  {"data_pending_fsyncs",
634
  (char*) &export_vars.innodb_data_pending_fsyncs,	  SHOW_LONG},
osku's avatar
osku committed
635
  {"data_pending_reads",
636
  (char*) &export_vars.innodb_data_pending_reads,	  SHOW_LONG},
osku's avatar
osku committed
637
  {"data_pending_writes",
638
  (char*) &export_vars.innodb_data_pending_writes,	  SHOW_LONG},
osku's avatar
osku committed
639
  {"data_read",
640
  (char*) &export_vars.innodb_data_read,		  SHOW_LONG},
osku's avatar
osku committed
641
  {"data_reads",
642
  (char*) &export_vars.innodb_data_reads,		  SHOW_LONG},
osku's avatar
osku committed
643
  {"data_writes",
644
  (char*) &export_vars.innodb_data_writes,		  SHOW_LONG},
osku's avatar
osku committed
645
  {"data_written",
646
  (char*) &export_vars.innodb_data_written,		  SHOW_LONG},
osku's avatar
osku committed
647
  {"dblwr_pages_written",
648
  (char*) &export_vars.innodb_dblwr_pages_written,	  SHOW_LONG},
osku's avatar
osku committed
649
  {"dblwr_writes",
650
  (char*) &export_vars.innodb_dblwr_writes,		  SHOW_LONG},
651 652
  {"have_atomic_builtins",
  (char*) &export_vars.innodb_have_atomic_builtins,	  SHOW_BOOL},
osku's avatar
osku committed
653
  {"log_waits",
654
  (char*) &export_vars.innodb_log_waits,		  SHOW_LONG},
osku's avatar
osku committed
655
  {"log_write_requests",
656
  (char*) &export_vars.innodb_log_write_requests,	  SHOW_LONG},
osku's avatar
osku committed
657
  {"log_writes",
658
  (char*) &export_vars.innodb_log_writes,		  SHOW_LONG},
osku's avatar
osku committed
659
  {"os_log_fsyncs",
660
  (char*) &export_vars.innodb_os_log_fsyncs,		  SHOW_LONG},
osku's avatar
osku committed
661
  {"os_log_pending_fsyncs",
662
  (char*) &export_vars.innodb_os_log_pending_fsyncs,	  SHOW_LONG},
osku's avatar
osku committed
663
  {"os_log_pending_writes",
664
  (char*) &export_vars.innodb_os_log_pending_writes,	  SHOW_LONG},
osku's avatar
osku committed
665
  {"os_log_written",
666
  (char*) &export_vars.innodb_os_log_written,		  SHOW_LONG},
osku's avatar
osku committed
667
  {"page_size",
668
  (char*) &export_vars.innodb_page_size,		  SHOW_LONG},
osku's avatar
osku committed
669
  {"pages_created",
670
  (char*) &export_vars.innodb_pages_created,		  SHOW_LONG},
osku's avatar
osku committed
671
  {"pages_read",
672
  (char*) &export_vars.innodb_pages_read,		  SHOW_LONG},
osku's avatar
osku committed
673
  {"pages_written",
674
  (char*) &export_vars.innodb_pages_written,		  SHOW_LONG},
osku's avatar
osku committed
675
  {"row_lock_current_waits",
676
  (char*) &export_vars.innodb_row_lock_current_waits,	  SHOW_LONG},
osku's avatar
osku committed
677
  {"row_lock_time",
678
  (char*) &export_vars.innodb_row_lock_time,		  SHOW_LONGLONG},
osku's avatar
osku committed
679
  {"row_lock_time_avg",
680
  (char*) &export_vars.innodb_row_lock_time_avg,	  SHOW_LONG},
osku's avatar
osku committed
681
  {"row_lock_time_max",
682
  (char*) &export_vars.innodb_row_lock_time_max,	  SHOW_LONG},
osku's avatar
osku committed
683
  {"row_lock_waits",
684
  (char*) &export_vars.innodb_row_lock_waits,		  SHOW_LONG},
osku's avatar
osku committed
685
  {"rows_deleted",
686
  (char*) &export_vars.innodb_rows_deleted,		  SHOW_LONG},
osku's avatar
osku committed
687
  {"rows_inserted",
688
  (char*) &export_vars.innodb_rows_inserted,		  SHOW_LONG},
osku's avatar
osku committed
689
  {"rows_read",
690
  (char*) &export_vars.innodb_rows_read,		  SHOW_LONG},
osku's avatar
osku committed
691
  {"rows_updated",
692
  (char*) &export_vars.innodb_rows_updated,		  SHOW_LONG},
693 694
  {NullS, NullS, SHOW_LONG}
};
osku's avatar
osku committed
695 696 697

/* General functions */

698
/******************************************************************//**
699 700 701 702
Returns true if the thread is the replication thread on the slave
server. Used in srv_conc_enter_innodb() to determine if the thread
should be allowed to enter InnoDB - the replication thread is treated
differently than other threads. Also used in
703 704
srv_conc_force_exit_innodb().
@return	true if thd is the replication thread */
705
extern "C" UNIV_INTERN
706 707 708
ibool
thd_is_replication_slave_thread(
/*============================*/
709
	void*	thd)	/*!< in: thread handle (THD*) */
710 711 712 713
{
	return((ibool) thd_slave_thread((THD*) thd));
}

714
/******************************************************************//**
osku's avatar
osku committed
715 716
Save some CPU by testing the value of srv_thread_concurrency in inline
functions. */
717
static inline
osku's avatar
osku committed
718 719 720
void
innodb_srv_conc_enter_innodb(
/*=========================*/
721
	trx_t*	trx)	/*!< in: transaction handle */
osku's avatar
osku committed
722
{
723
	if (UNIV_LIKELY(!srv_thread_concurrency)) {
osku's avatar
osku committed
724 725 726 727 728 729 730

		return;
	}

	srv_conc_enter_innodb(trx);
}

731
/******************************************************************//**
osku's avatar
osku committed
732 733
Save some CPU by testing the value of srv_thread_concurrency in inline
functions. */
734
static inline
osku's avatar
osku committed
735 736 737
void
innodb_srv_conc_exit_innodb(
/*========================*/
738
	trx_t*	trx)	/*!< in: transaction handle */
osku's avatar
osku committed
739
{
740
	if (UNIV_LIKELY(!trx->declared_to_be_inside_innodb)) {
osku's avatar
osku committed
741 742 743 744 745 746 747

		return;
	}

	srv_conc_exit_innodb(trx);
}

748
/******************************************************************//**
osku's avatar
osku committed
749 750 751 752
Releases possible search latch and InnoDB thread FIFO ticket. These should
be released at each SQL statement end, and also when mysqld passes the
control to the client. It does no harm to release these also in the middle
of an SQL statement. */
753
static inline
osku's avatar
osku committed
754 755 756
void
innobase_release_stat_resources(
/*============================*/
757
	trx_t*	trx)	/*!< in: transaction object */
osku's avatar
osku committed
758 759 760 761 762 763 764 765 766 767 768 769
{
	if (trx->has_search_latch) {
		trx_search_latch_release_if_reserved(trx);
	}

	if (trx->declared_to_be_inside_innodb) {
		/* Release our possible ticket in the FIFO */

		srv_conc_force_exit_innodb(trx);
	}
}

770
/******************************************************************//**
771 772 773
Returns true if the transaction this thread is processing has edited
non-transactional tables. Used by the deadlock detector when deciding
which transaction to rollback in case of a deadlock - we try to avoid
774 775
rolling back transactions that have edited non-transactional tables.
@return	true if non-transactional tables have been edited */
776
extern "C" UNIV_INTERN
777 778 779
ibool
thd_has_edited_nontrans_tables(
/*===========================*/
780
	void*	thd)	/*!< in: thread handle (THD*) */
781 782 783 784
{
	return((ibool) thd_non_transactional_update((THD*) thd));
}

785
/******************************************************************//**
786 787
Returns true if the thread is executing a SELECT statement.
@return	true if thd is executing SELECT */
788 789 790 791
extern "C" UNIV_INTERN
ibool
thd_is_select(
/*==========*/
792
	const void*	thd)	/*!< in: thread handle (THD*) */
793 794 795 796
{
	return(thd_sql_command((const THD*) thd) == SQLCOM_SELECT);
}

797
/******************************************************************//**
798
Returns true if the thread supports XA,
799 800
global value of innodb_supports_xa if thd is NULL.
@return	true if thd has XA support */
801
extern "C" UNIV_INTERN
802
ibool
803 804
thd_supports_xa(
/*============*/
805
	void*	thd)	/*!< in: thread handle (THD*), or NULL to query
806
			the global innodb_supports_xa */
807
{
808
	return(THDVAR((THD*) thd, support_xa));
809 810
}

811
/******************************************************************//**
812 813
Returns the lock wait timeout for the current connection.
@return	the lock wait timeout, in seconds */
814 815 816 817
extern "C" UNIV_INTERN
ulong
thd_lock_wait_timeout(
/*==================*/
818
	void*	thd)	/*!< in: thread handle (THD*), or NULL to query
819 820 821 822 823 824 825
			the global innodb_lock_wait_timeout */
{
	/* According to <mysql/plugin.h>, passing thd == NULL
	returns the global value of the session variable. */
	return(THDVAR((THD*) thd, lock_wait_timeout));
}

826
/********************************************************************//**
827 828
Obtain the InnoDB transaction of a MySQL thread.
@return	reference to transaction pointer */
829
static inline
830 831 832
trx_t*&
thd_to_trx(
/*=======*/
833
	THD*	thd)	/*!< in: MySQL thread */
834
{
835
	return(*(trx_t**) thd_ha_data(thd, innodb_hton_ptr));
836 837
}

838
/********************************************************************//**
osku's avatar
osku committed
839 840
Call this function when mysqld passes control to the client. That is to
avoid deadlocks on the adaptive hash S-latch possibly held by thd. For more
841 842
documentation, see handler.cc.
@return	0 */
843
static
osku's avatar
osku committed
844
int
osku's avatar
osku committed
845 846
innobase_release_temporary_latches(
/*===============================*/
847 848
	handlerton*	hton,	/*!< in: handlerton */
	THD*		thd)	/*!< in: MySQL thread */
osku's avatar
osku committed
849 850 851
{
	trx_t*	trx;

852 853
	DBUG_ASSERT(hton == innodb_hton_ptr);

osku's avatar
osku committed
854
	if (!innodb_inited) {
855

856
		return(0);
osku's avatar
osku committed
857 858
	}

859
	trx = thd_to_trx(thd);
osku's avatar
osku committed
860 861

	if (trx) {
862
		innobase_release_stat_resources(trx);
osku's avatar
osku committed
863
	}
864
	return(0);
osku's avatar
osku committed
865 866
}

867
/********************************************************************//**
osku's avatar
osku committed
868 869 870 871
Increments innobase_active_counter and every INNOBASE_WAKE_INTERVALth
time calls srv_active_wake_master_thread. This function should be used
when a single database operation may introduce a small need for
server utility activity, like checkpointing. */
872
static inline
osku's avatar
osku committed
873 874 875 876 877 878 879 880 881 882 883
void
innobase_active_small(void)
/*=======================*/
{
	innobase_active_counter++;

	if ((innobase_active_counter % INNOBASE_WAKE_INTERVAL) == 0) {
		srv_active_wake_master_thread();
	}
}

884
/********************************************************************//**
osku's avatar
osku committed
885 886
Converts an InnoDB error code to a MySQL error code and also tells to MySQL
about a possible transaction rollback inside InnoDB caused by a lock wait
887 888
timeout or a deadlock.
@return	MySQL error code */
889
extern "C" UNIV_INTERN
osku's avatar
osku committed
890 891 892
int
convert_error_code_to_mysql(
/*========================*/
893 894 895
	int	error,	/*!< in: InnoDB error code */
	ulint	flags,	/*!< in: InnoDB table flags, or 0 */
	THD*	thd)	/*!< in: user thread handle or NULL */
osku's avatar
osku committed
896
{
897 898
	switch (error) {
	case DB_SUCCESS:
osku's avatar
osku committed
899 900
		return(0);

901 902 903
	case DB_INTERRUPTED:
		my_error(ER_QUERY_INTERRUPTED, MYF(0));
		/* fall through */
904 905 906
	case DB_ERROR:
	default:
		return(-1); /* unspecified error */
osku's avatar
osku committed
907

908
	case DB_DUPLICATE_KEY:
909 910 911 912 913 914
		/* Be cautious with returning this error, since
		mysql could re-enter the storage layer to get
		duplicated key info, the operation requires a
		valid table handle and/or transaction information,
		which might not always be available in the error
		handling stage. */
915
		return(HA_ERR_FOUND_DUPP_KEY);
osku's avatar
osku committed
916

917
	case DB_FOREIGN_DUPLICATE_KEY:
918 919
		return(HA_ERR_FOREIGN_DUPLICATE_KEY);

920 921 922
	case DB_MISSING_HISTORY:
		return(HA_ERR_TABLE_DEF_CHANGED);

923
	case DB_RECORD_NOT_FOUND:
924
		return(HA_ERR_NO_ACTIVE_RECORD);
osku's avatar
osku committed
925

926
	case DB_DEADLOCK:
927 928 929
		/* Since we rolled back the whole transaction, we must
		tell it also to MySQL so that MySQL knows to empty the
		cached binlog for this transaction */
osku's avatar
osku committed
930

931
		if (thd) {
932
			thd_mark_transaction_to_rollback(thd, TRUE);
933
		}
osku's avatar
osku committed
934

935
		return(HA_ERR_LOCK_DEADLOCK);
osku's avatar
osku committed
936

937
	case DB_LOCK_WAIT_TIMEOUT:
osku's avatar
osku committed
938 939 940 941
		/* Starting from 5.0.13, we let MySQL just roll back the
		latest SQL statement in a lock wait timeout. Previously, we
		rolled back the whole transaction. */

942 943 944
		if (thd) {
			thd_mark_transaction_to_rollback(
				thd, (bool)row_rollback_on_timeout);
945 946
		}

947
		return(HA_ERR_LOCK_WAIT_TIMEOUT);
osku's avatar
osku committed
948

949
	case DB_NO_REFERENCED_ROW:
950
		return(HA_ERR_NO_REFERENCED_ROW);
osku's avatar
osku committed
951

952
	case DB_ROW_IS_REFERENCED:
953
		return(HA_ERR_ROW_IS_REFERENCED);
osku's avatar
osku committed
954

955
	case DB_CANNOT_ADD_CONSTRAINT:
956
		return(HA_ERR_CANNOT_ADD_FOREIGN);
osku's avatar
osku committed
957

958
	case DB_CANNOT_DROP_CONSTRAINT:
osku's avatar
osku committed
959

960
		return(HA_ERR_ROW_IS_REFERENCED); /* TODO: This is a bit
osku's avatar
osku committed
961 962 963
						misleading, a new MySQL error
						code should be introduced */

964 965
	case DB_COL_APPEARS_TWICE_IN_INDEX:
	case DB_CORRUPTION:
966
		return(HA_ERR_CRASHED);
osku's avatar
osku committed
967

968
	case DB_OUT_OF_FILE_SPACE:
969
		return(HA_ERR_RECORD_FILE_FULL);
osku's avatar
osku committed
970

971
	case DB_TABLE_IS_BEING_USED:
972
		return(HA_ERR_WRONG_COMMAND);
osku's avatar
osku committed
973

974
	case DB_TABLE_NOT_FOUND:
975
		return(HA_ERR_NO_SUCH_TABLE);
osku's avatar
osku committed
976

977
	case DB_TOO_BIG_RECORD:
978 979 980
		my_error(ER_TOO_BIG_ROWSIZE, MYF(0),
			 page_get_free_space_of_empty(flags
						      & DICT_TF_COMPACT) / 2);
981
		return(HA_ERR_TO_BIG_ROW);
osku's avatar
osku committed
982

983
	case DB_NO_SAVEPOINT:
984
		return(HA_ERR_NO_SAVEPOINT);
985 986

	case DB_LOCK_TABLE_FULL:
987 988 989 990 991
		/* Since we rolled back the whole transaction, we must
		tell it also to MySQL so that MySQL knows to empty the
		cached binlog for this transaction */

		if (thd) {
992
			thd_mark_transaction_to_rollback(thd, TRUE);
993
		}
994

995
		return(HA_ERR_LOCK_TABLE_FULL);
996

997 998 999
	case DB_PRIMARY_KEY_IS_NULL:
		return(ER_PRIMARY_CANT_HAVE_NULL);

1000
	case DB_TOO_MANY_CONCURRENT_TRXS:
1001 1002 1003 1004 1005 1006
		/* New error code HA_ERR_TOO_MANY_CONCURRENT_TRXS is only
		available in 5.1.38 and later, but the plugin should still
		work with previous versions of MySQL. */
#ifdef HA_ERR_TOO_MANY_CONCURRENT_TRXS
		return(HA_ERR_TOO_MANY_CONCURRENT_TRXS);
#else /* HA_ERR_TOO_MANY_CONCURRENT_TRXS */
1007
		return(HA_ERR_RECORD_FILE_FULL);
1008
#endif /* HA_ERR_TOO_MANY_CONCURRENT_TRXS */
1009 1010
	case DB_UNSUPPORTED:
		return(HA_ERR_UNSUPPORTED);
1011
	}
osku's avatar
osku committed
1012 1013
}

1014
/*************************************************************//**
1015
Prints info of a THD object (== user session thread) to the given file. */
1016
extern "C" UNIV_INTERN
osku's avatar
osku committed
1017 1018 1019
void
innobase_mysql_print_thd(
/*=====================*/
1020 1021 1022
	FILE*	f,		/*!< in: output stream */
	void*	thd,		/*!< in: pointer to a MySQL THD object */
	uint	max_query_len)	/*!< in: max query length to print, or 0 to
osku's avatar
osku committed
1023 1024
				   use the default max length */
{
1025
	char	buffer[1024];
osku's avatar
osku committed
1026

1027
	fputs(thd_security_context((THD*) thd, buffer, sizeof buffer,
1028
				   max_query_len), f);
osku's avatar
osku committed
1029 1030 1031
	putc('\n', f);
}

1032
/******************************************************************//**
1033 1034
Get the variable length bounds of the given character set. */
extern "C" UNIV_INTERN
osku's avatar
osku committed
1035 1036 1037
void
innobase_get_cset_width(
/*====================*/
1038 1039 1040
	ulint	cset,		/*!< in: MySQL charset-collation code */
	ulint*	mbminlen,	/*!< out: minimum length of a char (in bytes) */
	ulint*	mbmaxlen)	/*!< out: maximum length of a char (in bytes) */
osku's avatar
osku committed
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
{
	CHARSET_INFO*	cs;
	ut_ad(cset < 256);
	ut_ad(mbminlen);
	ut_ad(mbmaxlen);

	cs = all_charsets[cset];
	if (cs) {
		*mbminlen = cs->mbminlen;
		*mbmaxlen = cs->mbmaxlen;
	} else {
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
		THD*	thd = current_thd;

		if (thd && thd_sql_command(thd) == SQLCOM_DROP_TABLE) {

			/* Fix bug#46256: allow tables to be dropped if the
			collation is not found, but issue a warning. */
			if ((global_system_variables.log_warnings)
			    && (cset != 0)){

				sql_print_warning(
					"Unknown collation #%lu.", cset);
			}
		} else {

			ut_a(cset == 0);
		}

osku's avatar
osku committed
1069 1070 1071 1072
		*mbminlen = *mbmaxlen = 0;
	}
}

1073
/******************************************************************//**
1074
Converts an identifier to a table name. */
1075
extern "C" UNIV_INTERN
1076 1077 1078
void
innobase_convert_from_table_id(
/*===========================*/
1079 1080 1081 1082
	struct charset_info_st*	cs,	/*!< in: the 'from' character set */
	char*			to,	/*!< out: converted identifier */
	const char*		from,	/*!< in: identifier to convert */
	ulint			len)	/*!< in: length of 'to', in bytes */
1083 1084 1085
{
	uint	errors;

1086
	strconvert(cs, from, &my_charset_filename, to, (uint) len, &errors);
1087 1088
}

1089
/******************************************************************//**
1090
Converts an identifier to UTF-8. */
1091
extern "C" UNIV_INTERN
1092 1093 1094
void
innobase_convert_from_id(
/*=====================*/
1095 1096 1097 1098
	struct charset_info_st*	cs,	/*!< in: the 'from' character set */
	char*			to,	/*!< out: converted identifier */
	const char*		from,	/*!< in: identifier to convert */
	ulint			len)	/*!< in: length of 'to', in bytes */
1099 1100 1101
{
	uint	errors;

1102
	strconvert(cs, from, system_charset_info, to, (uint) len, &errors);
1103 1104
}

1105
/******************************************************************//**
1106 1107
Compares NUL-terminated UTF-8 strings case insensitively.
@return	0 if a=b, <0 if a<b, >1 if a>b */
1108
extern "C" UNIV_INTERN
osku's avatar
osku committed
1109 1110 1111
int
innobase_strcasecmp(
/*================*/
1112 1113
	const char*	a,	/*!< in: first string to compare */
	const char*	b)	/*!< in: second string to compare */
osku's avatar
osku committed
1114 1115 1116 1117
{
	return(my_strcasecmp(system_charset_info, a, b));
}

1118
/******************************************************************//**
1119
Makes all characters in a NUL-terminated UTF-8 string lower case. */
1120
extern "C" UNIV_INTERN
osku's avatar
osku committed
1121 1122 1123
void
innobase_casedn_str(
/*================*/
1124
	char*	a)	/*!< in/out: string to put in lower case */
osku's avatar
osku committed
1125 1126 1127 1128
{
	my_casedn_str(system_charset_info, a);
}

1129
/**********************************************************************//**
1130 1131
Determines the connection character set.
@return	connection character set */
1132
extern "C" UNIV_INTERN
1133 1134 1135
struct charset_info_st*
innobase_get_charset(
/*=================*/
1136
	void*	mysql_thd)	/*!< in: MySQL thread handle */
1137
{
1138
	return(thd_charset((THD*) mysql_thd));
1139 1140
}

1141
#if defined (__WIN__) && defined (MYSQL_DYNAMIC_PLUGIN)
1142
extern MYSQL_PLUGIN_IMPORT MY_TMPDIR mysql_tmpdir_list;
1143
/*******************************************************************//**
1144 1145 1146 1147 1148
Map an OS error to an errno value. The OS error number is stored in
_doserrno and the mapped value is stored in errno) */
extern "C"
void __cdecl
_dosmaperr(
1149
	unsigned long);	/*!< in: OS error value */
1150

1151
/*********************************************************************//**
1152 1153
Creates a temporary file.
@return	temporary file descriptor, or < 0 on error */
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
extern "C" UNIV_INTERN
int
innobase_mysql_tmpfile(void)
/*========================*/
{
	int	fd;				/* handle of opened file */
	HANDLE	osfh;				/* OS handle of opened file */
	char*	tmpdir;				/* point to the directory
						where to create file */
	TCHAR	path_buf[MAX_PATH - 14];	/* buffer for tmp file path.
						The length cannot be longer
						than MAX_PATH - 14, or
						GetTempFileName will fail. */
	char	filename[MAX_PATH];		/* name of the tmpfile */
	DWORD	fileaccess = GENERIC_READ	/* OS file access */
			     | GENERIC_WRITE
			     | DELETE;
	DWORD	fileshare = FILE_SHARE_READ	/* OS file sharing mode */
			    | FILE_SHARE_WRITE
			    | FILE_SHARE_DELETE;
	DWORD	filecreate = CREATE_ALWAYS;	/* OS method of open/create */
	DWORD	fileattrib =			/* OS file attribute flags */
			     FILE_ATTRIBUTE_NORMAL
			     | FILE_FLAG_DELETE_ON_CLOSE
			     | FILE_ATTRIBUTE_TEMPORARY
			     | FILE_FLAG_SEQUENTIAL_SCAN;

	DBUG_ENTER("innobase_mysql_tmpfile");

	tmpdir = my_tmpdir(&mysql_tmpdir_list);

	/* The tmpdir parameter can not be NULL for GetTempFileName. */
	if (!tmpdir) {
		uint	ret;

		/* Use GetTempPath to determine path for temporary files. */
		ret = GetTempPath(sizeof(path_buf), path_buf);
		if (ret > sizeof(path_buf) || (ret == 0)) {

			_dosmaperr(GetLastError());	/* map error */
			DBUG_RETURN(-1);
		}

		tmpdir = path_buf;
	}

	/* Use GetTempFileName to generate a unique filename. */
	if (!GetTempFileName(tmpdir, "ib", 0, filename)) {

		_dosmaperr(GetLastError());	/* map error */
		DBUG_RETURN(-1);
	}

	DBUG_PRINT("info", ("filename: %s", filename));

	/* Open/Create the file. */
	osfh = CreateFile(filename, fileaccess, fileshare, NULL,
			  filecreate, fileattrib, NULL);
	if (osfh == INVALID_HANDLE_VALUE) {

		/* open/create file failed! */
		_dosmaperr(GetLastError());	/* map error */
		DBUG_RETURN(-1);
	}

	do {
		/* Associates a CRT file descriptor with the OS file handle. */
		fd = _open_osfhandle((intptr_t) osfh, 0);
	} while (fd == -1 && errno == EINTR);

	if (fd == -1) {
		/* Open failed, close the file handle. */

		_dosmaperr(GetLastError());	/* map error */
		CloseHandle(osfh);		/* no need to check if
						CloseHandle fails */
	}

	DBUG_RETURN(fd);
}
#else
1235
/*********************************************************************//**
1236 1237
Creates a temporary file.
@return	temporary file descriptor, or < 0 on error */
1238
extern "C" UNIV_INTERN
osku's avatar
osku committed
1239 1240 1241 1242
int
innobase_mysql_tmpfile(void)
/*========================*/
{
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
	int	fd2 = -1;
	File	fd = mysql_tmpfile("ib");
	if (fd >= 0) {
		/* Copy the file descriptor, so that the additional resources
		allocated by create_temp_file() can be freed by invoking
		my_close().

		Because the file descriptor returned by this function
		will be passed to fdopen(), it will be closed by invoking
		fclose(), which in turn will invoke close() instead of
		my_close(). */
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274

#ifdef _WIN32
		/* Note that on Windows, the integer returned by mysql_tmpfile 
		has no relation to C runtime file descriptor. Here, we need 
		to call my_get_osfhandle to get the HANDLE and then convert it 
		to C runtime filedescriptor. */
		{
			HANDLE hFile = my_get_osfhandle(fd);
			HANDLE hDup;
			BOOL bOK = 
				DuplicateHandle(GetCurrentProcess(), hFile, GetCurrentProcess(),
								&hDup, 0, FALSE, DUPLICATE_SAME_ACCESS);
			if(bOK) {
				fd2 = _open_osfhandle((intptr_t)hDup,0);
			}
			else {
				my_osmaperr(GetLastError());
				fd2 = -1;
			}	
		}
#else
1275
		fd2 = dup(fd);
1276
#endif
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
		if (fd2 < 0) {
			DBUG_PRINT("error",("Got error %d on dup",fd2));
			my_errno=errno;
			my_error(EE_OUT_OF_FILERESOURCES,
				 MYF(ME_BELL+ME_WAITTANG),
				 "ib*", my_errno);
		}
		my_close(fd, MYF(MY_WME));
	}
	return(fd2);
osku's avatar
osku committed
1287
}
1288
#endif /* defined (__WIN__) && defined (MYSQL_DYNAMIC_PLUGIN) */
osku's avatar
osku committed
1289

1290
/*********************************************************************//**
1291 1292
Wrapper around MySQL's copy_and_convert function.
@return	number of bytes copied to 'to' */
1293
extern "C" UNIV_INTERN
1294 1295 1296
ulint
innobase_convert_string(
/*====================*/
1297 1298
	void*		to,		/*!< out: converted string */
	ulint		to_length,	/*!< in: number of bytes reserved
1299
					for the converted string */
1300 1301 1302 1303 1304
	CHARSET_INFO*	to_cs,		/*!< in: character set to convert to */
	const void*	from,		/*!< in: string to convert */
	ulint		from_length,	/*!< in: number of bytes to convert */
	CHARSET_INFO*	from_cs,	/*!< in: character set to convert from */
	uint*		errors)		/*!< out: number of errors encountered
1305
					during the conversion */
1306
{
1307 1308 1309
  return(copy_and_convert((char*)to, (uint32) to_length, to_cs,
                          (const char*)from, (uint32) from_length, from_cs,
                          errors));
1310 1311
}

1312
/*******************************************************************//**
1313 1314 1315 1316
Formats the raw data in "data" (in InnoDB on-disk format) that is of
type DATA_(CHAR|VARCHAR|MYSQL|VARMYSQL) using "charset_coll" and writes
the result to "buf". The result is converted to "system_charset_info".
Not more than "buf_size" bytes are written to "buf".
1317
The result is always NUL-terminated (provided buf_size > 0) and the
1318
number of bytes that were written to "buf" is returned (including the
1319
terminating NUL).
1320
@return	number of bytes that were written */
1321 1322 1323 1324
extern "C" UNIV_INTERN
ulint
innobase_raw_format(
/*================*/
1325 1326
	const char*	data,		/*!< in: raw data */
	ulint		data_len,	/*!< in: raw data length
1327
					in bytes */
1328 1329 1330
	ulint		charset_coll,	/*!< in: charset collation */
	char*		buf,		/*!< out: output buffer */
	ulint		buf_size)	/*!< in: output buffer size
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
					in bytes */
{
	/* XXX we use a hard limit instead of allocating
	but_size bytes from the heap */
	CHARSET_INFO*	data_cs;
	char		buf_tmp[8192];
	ulint		buf_tmp_used;
	uint		num_errors;

	data_cs = all_charsets[charset_coll];

	buf_tmp_used = innobase_convert_string(buf_tmp, sizeof(buf_tmp),
					       system_charset_info,
					       data, data_len, data_cs,
					       &num_errors);

	return(ut_str_sql_format(buf_tmp, buf_tmp_used, buf, buf_size));
}

1350
/*********************************************************************//**
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
Compute the next autoinc value.

For MySQL replication the autoincrement values can be partitioned among
the nodes. The offset is the start or origin of the autoincrement value
for a particular node. For n nodes the increment will be n and the offset
will be in the interval [1, n]. The formula tries to allocate the next
value for a particular node.

Note: This function is also called with increment set to the number of
values we want to reserve for multi-value inserts e.g.,

	INSERT INTO T VALUES(), (), ();

innobase_next_autoinc() will be called with increment set to
n * 3 where autoinc_lock_mode != TRADITIONAL because we want
1366 1367
to reserve 3 values for the multi-value INSERT above.
@return	the next value */
1368 1369 1370 1371
static
ulonglong
innobase_next_autoinc(
/*==================*/
1372 1373 1374 1375
	ulonglong	current,	/*!< in: Current value */
	ulonglong	increment,	/*!< in: increment current by */
	ulonglong	offset,		/*!< in: AUTOINC offset */
	ulonglong	max_value)	/*!< in: max value for type */
1376 1377 1378 1379 1380 1381
{
	ulonglong	next_value;

	/* Should never be 0. */
	ut_a(increment > 0);

1382 1383 1384 1385 1386 1387
	/* According to MySQL documentation, if the offset is greater than
	the increment then the offset is ignored. */
	if (offset > increment) {
		offset = 0;
	}

1388 1389 1390
	if (max_value <= current) {
		next_value = max_value;
	} else if (offset <= 1) {
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
		/* Offset 0 and 1 are the same, because there must be at
		least one node in the system. */
		if (max_value - current <= increment) {
			next_value = max_value;
		} else {
			next_value = current + increment;
		}
	} else if (max_value > current) {
		if (current > offset) {
			next_value = ((current - offset) / increment) + 1;
		} else {
			next_value = ((offset - current) / increment) + 1;
		}

		ut_a(increment > 0);
		ut_a(next_value > 0);

		/* Check for multiplication overflow. */
		if (increment > (max_value / next_value)) {

			next_value = max_value;
		} else {
			next_value *= increment;

1415 1416
			ut_a(max_value >= next_value);

1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
			/* Check for overflow. */
			if (max_value - next_value <= offset) {
				next_value = max_value;
			} else {
				next_value += offset;
			}
		}
	} else {
		next_value = max_value;
	}

	ut_a(next_value <= max_value);

	return(next_value);
}

1433
/*********************************************************************//**
1434 1435 1436 1437 1438
Initializes some fields in an InnoDB transaction object. */
static
void
innobase_trx_init(
/*==============*/
1439 1440
	THD*	thd,	/*!< in: user thread handle */
	trx_t*	trx)	/*!< in/out: InnoDB transaction handle */
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
{
	DBUG_ENTER("innobase_trx_init");
	DBUG_ASSERT(EQ_CURRENT_THD(thd));
	DBUG_ASSERT(thd == trx->mysql_thd);

	trx->check_foreigns = !thd_test_options(
		thd, OPTION_NO_FOREIGN_KEY_CHECKS);

	trx->check_unique_secondary = !thd_test_options(
		thd, OPTION_RELAXED_UNIQUE_CHECKS);

	DBUG_VOID_RETURN;
}

1455
/*********************************************************************//**
1456 1457
Allocates an InnoDB transaction for a MySQL handler object.
@return	InnoDB transaction handle */
1458 1459 1460 1461
extern "C" UNIV_INTERN
trx_t*
innobase_trx_allocate(
/*==================*/
1462
	THD*	thd)	/*!< in: user thread handle */
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
{
	trx_t*	trx;

	DBUG_ENTER("innobase_trx_allocate");
	DBUG_ASSERT(thd != NULL);
	DBUG_ASSERT(EQ_CURRENT_THD(thd));

	trx = trx_allocate_for_mysql();

	trx->mysql_thd = thd;
	trx->mysql_query_str = thd_query(thd);

	innobase_trx_init(thd, trx);

	DBUG_RETURN(trx);
}

1480
/*********************************************************************//**
osku's avatar
osku committed
1481 1482
Gets the InnoDB transaction handle for a MySQL handler object, creates
an InnoDB transaction struct if the corresponding MySQL thread struct still
1483 1484
lacks one.
@return	InnoDB transaction handle */
marko's avatar
marko committed
1485
static
osku's avatar
osku committed
1486 1487 1488
trx_t*
check_trx_exists(
/*=============*/
1489
	THD*	thd)	/*!< in: user thread handle */
osku's avatar
osku committed
1490
{
1491
	trx_t*&	trx = thd_to_trx(thd);
osku's avatar
osku committed
1492

1493
	ut_ad(EQ_CURRENT_THD(thd));
osku's avatar
osku committed
1494 1495

	if (trx == NULL) {
1496 1497 1498 1499
		trx = innobase_trx_allocate(thd);
	} else if (UNIV_UNLIKELY(trx->magic_n != TRX_MAGIC_N)) {
		mem_analyze_corruption(trx);
		ut_error;
osku's avatar
osku committed
1500 1501
	}

1502
	innobase_trx_init(thd, trx);
osku's avatar
osku committed
1503 1504 1505 1506 1507

	return(trx);
}


1508
/*********************************************************************//**
osku's avatar
osku committed
1509
Construct ha_innobase handler. */
1510
UNIV_INTERN
1511 1512
ha_innobase::ha_innobase(handlerton *hton, TABLE_SHARE *table_arg)
  :handler(hton, table_arg),
osku's avatar
osku committed
1513
  int_table_flags(HA_REC_NOT_IN_SEQ |
1514 1515 1516
		  HA_NULL_IN_KEY |
		  HA_CAN_INDEX_BLOBS |
		  HA_CAN_SQL_HANDLER |
1517
		  HA_PRIMARY_KEY_REQUIRED_FOR_POSITION |
1518
		  HA_PRIMARY_KEY_IN_READ_INDEX |
1519
		  HA_BINLOG_ROW_CAPABLE |
1520
		  HA_CAN_GEOMETRY | HA_PARTIAL_COLUMN_READ |
1521
		  HA_TABLE_SCAN_ON_INDEX),
osku's avatar
osku committed
1522 1523 1524 1525
  start_of_scan(0),
  num_write_row(0)
{}

1526
/*********************************************************************//**
1527 1528 1529 1530 1531 1532
Destruct ha_innobase handler. */
UNIV_INTERN
ha_innobase::~ha_innobase()
{
}

1533
/*********************************************************************//**
osku's avatar
osku committed
1534 1535 1536
Updates the user_thd field in a handle and also allocates a new InnoDB
transaction handle if needed, and updates the transaction fields in the
prebuilt struct. */
1537
UNIV_INTERN inline
marko's avatar
marko committed
1538
void
osku's avatar
osku committed
1539 1540
ha_innobase::update_thd(
/*====================*/
1541
	THD*	thd)	/*!< in: thd to use the handle */
osku's avatar
osku committed
1542 1543 1544
{
	trx_t*		trx;

1545
	trx = check_trx_exists(thd);
osku's avatar
osku committed
1546 1547 1548 1549 1550 1551 1552

	if (prebuilt->trx != trx) {

		row_update_prebuilt_trx(prebuilt, trx);
	}

	user_thd = thd;
marko's avatar
marko committed
1553
}
osku's avatar
osku committed
1554

1555
/*********************************************************************//**
marko's avatar
marko committed
1556 1557 1558
Updates the user_thd field in a handle and also allocates a new InnoDB
transaction handle if needed, and updates the transaction fields in the
prebuilt struct. */
1559
UNIV_INTERN
marko's avatar
marko committed
1560 1561 1562 1563 1564
void
ha_innobase::update_thd()
/*=====================*/
{
	THD*	thd = ha_thd();
1565
	ut_ad(EQ_CURRENT_THD(thd));
marko's avatar
marko committed
1566
	update_thd(thd);
osku's avatar
osku committed
1567 1568
}

1569
/*********************************************************************//**
osku's avatar
osku committed
1570 1571 1572 1573
Registers that InnoDB takes part in an SQL statement, so that MySQL knows to
roll back the statement if the statement results in an error. This MUST be
called for every SQL statement that may be rolled back by MySQL. Calling this
several times to register the same statement is allowed, too. */
1574
static inline
osku's avatar
osku committed
1575 1576 1577
void
innobase_register_stmt(
/*===================*/
1578 1579
        handlerton*	hton,	/*!< in: Innobase hton */
	THD*	thd)	/*!< in: MySQL thd (connection) object */
osku's avatar
osku committed
1580
{
1581
	DBUG_ASSERT(hton == innodb_hton_ptr);
1582
	/* Register the statement */
1583
	trans_register_ha(thd, FALSE, hton);
osku's avatar
osku committed
1584 1585
}

1586
/*********************************************************************//**
osku's avatar
osku committed
1587 1588 1589 1590 1591 1592
Registers an InnoDB transaction in MySQL, so that the MySQL XA code knows
to call the InnoDB prepare and commit, or rollback for the transaction. This
MUST be called for every transaction for which the user may call commit or
rollback. Calling this several times to register the same transaction is
allowed, too.
This function also registers the current SQL statement. */
1593
static inline
osku's avatar
osku committed
1594 1595 1596
void
innobase_register_trx_and_stmt(
/*===========================*/
1597 1598
        handlerton *hton, /*!< in: Innobase handlerton */
	THD*	thd)	/*!< in: MySQL thd (connection) object */
osku's avatar
osku committed
1599 1600 1601 1602
{
	/* NOTE that actually innobase_register_stmt() registers also
	the transaction in the AUTOCOMMIT=1 mode. */

1603
	innobase_register_stmt(hton, thd);
osku's avatar
osku committed
1604

1605
	if (thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
osku's avatar
osku committed
1606

1607
		/* No autocommit mode, register for a transaction */
1608
		trans_register_ha(thd, TRUE, hton);
1609
	}
osku's avatar
osku committed
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
}

/*   BACKGROUND INFO: HOW THE MYSQL QUERY CACHE WORKS WITH INNODB
     ------------------------------------------------------------

1) The use of the query cache for TBL is disabled when there is an
uncommitted change to TBL.

2) When a change to TBL commits, InnoDB stores the current value of
its global trx id counter, let us denote it by INV_TRX_ID, to the table object
in the InnoDB data dictionary, and does only allow such transactions whose
id <= INV_TRX_ID to use the query cache.

3) When InnoDB does an INSERT/DELETE/UPDATE to a table TBL, or an implicit
modification because an ON DELETE CASCADE, we invalidate the MySQL query cache
of TBL immediately.

How this is implemented inside InnoDB:

1) Since every modification always sets an IX type table lock on the InnoDB
table, it is easy to check if there can be uncommitted modifications for a
table: just check if there are locks in the lock list of the table.

2) When a transaction inside InnoDB commits, it reads the global trx id
counter and stores the value INV_TRX_ID to the tables on which it had a lock.

3) If there is an implicit table change from ON DELETE CASCADE or SET NULL,
InnoDB calls an invalidate method for the MySQL query cache for that table.

How this is implemented inside sql_cache.cc:

1) The query cache for an InnoDB table TBL is invalidated immediately at an
INSERT/UPDATE/DELETE, just like in the case of MyISAM. No need to delay
invalidation to the transaction commit.

2) To store or retrieve a value from the query cache of an InnoDB table TBL,
any query must first ask InnoDB's permission. We must pass the thd as a
parameter because InnoDB will look at the trx id, if any, associated with
that thd.

3) Use of the query cache for InnoDB tables is now allowed also when
AUTOCOMMIT==0 or we are inside BEGIN ... COMMIT. Thus transactions no longer
put restrictions on the use of the query cache.
*/

1655
/******************************************************************//**
osku's avatar
osku committed
1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
The MySQL query cache uses this to check from InnoDB if the query cache at
the moment is allowed to operate on an InnoDB table. The SQL query must
be a non-locking SELECT.

The query cache is allowed to operate on certain query only if this function
returns TRUE for all tables in the query.

If thd is not in the autocommit state, this function also starts a new
transaction for thd if there is no active trx yet, and assigns a consistent
read view to it if there is no read view yet.

Why a deadlock of threads is not possible: the query cache calls this function
at the start of a SELECT processing. Then the calling thread cannot be
holding any InnoDB semaphores. The calling thread is holding the
query cache mutex, and this function will reserver the InnoDB kernel mutex.
Thus, the 'rank' in sync0sync.h of the MySQL query cache mutex is above
1672
the InnoDB kernel mutex.
1673 1674 1675
@return TRUE if permitted, FALSE if not; note that the value FALSE
does not mean we should invalidate the query cache: invalidation is
called explicitly */
1676
static
osku's avatar
osku committed
1677 1678 1679
my_bool
innobase_query_caching_of_table_permitted(
/*======================================*/
1680
	THD*	thd,		/*!< in: thd of the user who is trying to
osku's avatar
osku committed
1681 1682
				store a result to the query cache or
				retrieve it */
1683
	char*	full_name,	/*!< in: concatenation of database name,
1684
				the null character NUL, and the table
osku's avatar
osku committed
1685
				name */
1686
	uint	full_name_len,	/*!< in: length of the full name, i.e.
osku's avatar
osku committed
1687
				len(dbname) + len(tablename) + 1 */
1688
	ulonglong *unused)	/*!< unused for this engine */
osku's avatar
osku committed
1689 1690 1691 1692 1693 1694 1695
{
	ibool	is_autocommit;
	trx_t*	trx;
	char	norm_name[1000];

	ut_a(full_name_len < 999);

1696 1697 1698
	trx = check_trx_exists(thd);

	if (trx->isolation_level == TRX_ISO_SERIALIZABLE) {
osku's avatar
osku committed
1699 1700
		/* In the SERIALIZABLE mode we add LOCK IN SHARE MODE to every
		plain SELECT if AUTOCOMMIT is not on. */
1701

osku's avatar
osku committed
1702 1703 1704 1705 1706 1707 1708
		return((my_bool)FALSE);
	}

	if (trx->has_search_latch) {
		sql_print_error("The calling thread is holding the adaptive "
				"search, latch though calling "
				"innobase_query_caching_of_table_permitted.");
1709

1710
		mutex_enter(&kernel_mutex);
1711
		trx_print(stderr, trx, 1024);
1712
		mutex_exit(&kernel_mutex);
osku's avatar
osku committed
1713 1714 1715 1716
	}

	innobase_release_stat_resources(trx);

1717
	if (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
osku's avatar
osku committed
1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745

		is_autocommit = TRUE;
	} else {
		is_autocommit = FALSE;

	}

	if (is_autocommit && trx->n_mysql_tables_in_use == 0) {
		/* We are going to retrieve the query result from the query
		cache. This cannot be a store operation to the query cache
		because then MySQL would have locks on tables already.

		TODO: if the user has used LOCK TABLES to lock the table,
		then we open a transaction in the call of row_.. below.
		That trx can stay open until UNLOCK TABLES. The same problem
		exists even if we do not use the query cache. MySQL should be
		modified so that it ALWAYS calls some cleanup function when
		the processing of a query ends!

		We can imagine we instantaneously serialize this consistent
		read trx to the current trx id counter. If trx2 would have
		changed the tables of a query result stored in the cache, and
		trx2 would have already committed, making the result obsolete,
		then trx2 would have already invalidated the cache. Thus we
		can trust the result in the cache is ok for this query. */

		return((my_bool)TRUE);
	}
1746

osku's avatar
osku committed
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
	/* Normalize the table name to InnoDB format */

	memcpy(norm_name, full_name, full_name_len);

	norm_name[strlen(norm_name)] = '/'; /* InnoDB uses '/' as the
					    separator between db and table */
	norm_name[full_name_len] = '\0';
#ifdef __WIN__
	innobase_casedn_str(norm_name);
#endif
	/* The call of row_search_.. will start a new transaction if it is
	not yet started */

1760
	if (trx->active_trans == 0) {
osku's avatar
osku committed
1761

1762
		innobase_register_trx_and_stmt(innodb_hton_ptr, thd);
1763 1764
		trx->active_trans = 1;
	}
osku's avatar
osku committed
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777

	if (row_search_check_if_query_cache_permitted(trx, norm_name)) {

		/* printf("Query cache for %s permitted\n", norm_name); */

		return((my_bool)TRUE);
	}

	/* printf("Query cache for %s NOT permitted\n", norm_name); */

	return((my_bool)FALSE);
}

1778
/*****************************************************************//**
1779
Invalidates the MySQL query cache for the table. */
1780
extern "C" UNIV_INTERN
osku's avatar
osku committed
1781 1782 1783
void
innobase_invalidate_query_cache(
/*============================*/
1784
	trx_t*		trx,		/*!< in: transaction which
1785
					modifies the table */
1786
	const char*	full_name,	/*!< in: concatenation of
1787 1788
					database name, null char NUL,
					table name, null char NUL;
1789 1790
					NOTE that in Windows this is
					always in LOWER CASE! */
1791
	ulint		full_name_len)	/*!< in: full name length where
1792
					also the null chars count */
osku's avatar
osku committed
1793 1794 1795 1796 1797 1798 1799
{
	/* Note that the sync0sync.h rank of the query cache mutex is just
	above the InnoDB kernel mutex. The caller of this function must not
	have latches of a lower rank. */

	/* Argument TRUE below means we are using transactions */
#ifdef HAVE_QUERY_CACHE
1800
	mysql_query_cache_invalidate4((THD*) trx->mysql_thd,
1801
				      full_name,
1802 1803
				      (uint32) full_name_len,
				      TRUE);
osku's avatar
osku committed
1804 1805 1806
#endif
}

1807
/*****************************************************************//**
1808
Convert an SQL identifier to the MySQL system_charset_info (UTF-8)
1809 1810
and quote it if needed.
@return	pointer to the end of buf */
1811 1812 1813 1814
static
char*
innobase_convert_identifier(
/*========================*/
1815 1816 1817 1818 1819 1820
	char*		buf,	/*!< out: buffer for converted identifier */
	ulint		buflen,	/*!< in: length of buf, in bytes */
	const char*	id,	/*!< in: identifier to convert */
	ulint		idlen,	/*!< in: length of id, in bytes */
	void*		thd,	/*!< in: MySQL connection thread, or NULL */
	ibool		file_id)/*!< in: TRUE=id is a table or database name;
1821
				FALSE=id is an UTF-8 string */
osku's avatar
osku committed
1822
{
1823
	char nz[NAME_LEN + 1];
1824 1825 1826
#if MYSQL_VERSION_ID >= 50141
	char nz2[NAME_LEN + 1 + EXPLAIN_FILENAME_MAX_EXTRA_LENGTH];
#else /* MYSQL_VERSION_ID >= 50141 */
1827
	char nz2[NAME_LEN + 1 + sizeof srv_mysql50_table_name_prefix];
1828
#endif /* MYSQL_VERSION_ID >= 50141 */
1829 1830

	const char*	s	= id;
1831 1832
	int		q;

1833
	if (file_id) {
1834 1835 1836
		/* Decode the table name.  The MySQL function expects
		a NUL-terminated string.  The input and output strings
		buffers must not be shared. */
1837 1838 1839

		if (UNIV_UNLIKELY(idlen > (sizeof nz) - 1)) {
			idlen = (sizeof nz) - 1;
1840 1841
		}

1842 1843
		memcpy(nz, id, idlen);
		nz[idlen] = 0;
1844

1845
		s = nz2;
1846 1847 1848 1849 1850
#if MYSQL_VERSION_ID >= 50141
		idlen = explain_filename((THD*) thd, nz, nz2, sizeof nz2,
					 EXPLAIN_PARTITIONS_AS_COMMENT);
		goto no_quote;
#else /* MYSQL_VERSION_ID >= 50141 */
1851
		idlen = filename_to_tablename(nz, nz2, sizeof nz2);
1852
#endif /* MYSQL_VERSION_ID >= 50141 */
1853 1854 1855 1856
	}

	/* See if the identifier needs to be quoted. */
	if (UNIV_UNLIKELY(!thd)) {
1857 1858
		q = '"';
	} else {
1859
		q = get_quote_char_for_identifier((THD*) thd, s, (int) idlen);
osku's avatar
osku committed
1860
	}
1861 1862

	if (q == EOF) {
1863 1864 1865
#if MYSQL_VERSION_ID >= 50141
no_quote:
#endif /* MYSQL_VERSION_ID >= 50141 */
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
		if (UNIV_UNLIKELY(idlen > buflen)) {
			idlen = buflen;
		}
		memcpy(buf, s, idlen);
		return(buf + idlen);
	}

	/* Quote the identifier. */
	if (buflen < 2) {
		return(buf);
	}

	*buf++ = q;
	buflen--;

	for (; idlen; idlen--) {
		int	c = *s++;
		if (UNIV_UNLIKELY(c == q)) {
			if (UNIV_UNLIKELY(buflen < 3)) {
				break;
1886
			}
1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904

			*buf++ = c;
			*buf++ = c;
			buflen -= 2;
		} else {
			if (UNIV_UNLIKELY(buflen < 2)) {
				break;
			}

			*buf++ = c;
			buflen--;
		}
	}

	*buf++ = q;
	return(buf);
}

1905
/*****************************************************************//**
1906
Convert a table or index name to the MySQL system_charset_info (UTF-8)
1907 1908
and quote it if needed.
@return	pointer to the end of buf */
1909
extern "C" UNIV_INTERN
1910 1911 1912
char*
innobase_convert_name(
/*==================*/
1913 1914 1915 1916 1917 1918
	char*		buf,	/*!< out: buffer for converted identifier */
	ulint		buflen,	/*!< in: length of buf, in bytes */
	const char*	id,	/*!< in: identifier to convert */
	ulint		idlen,	/*!< in: length of id, in bytes */
	void*		thd,	/*!< in: MySQL connection thread, or NULL */
	ibool		table_id)/*!< in: TRUE=id is a table or database name;
1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
				FALSE=id is an index name */
{
	char*		s	= buf;
	const char*	bufend	= buf + buflen;

	if (table_id) {
		const char*	slash = (const char*) memchr(id, '/', idlen);
		if (!slash) {

			goto no_db_name;
1929
		}
1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955

		/* Print the database name and table name separately. */
		s = innobase_convert_identifier(s, bufend - s, id, slash - id,
						thd, TRUE);
		if (UNIV_LIKELY(s < bufend)) {
			*s++ = '.';
			s = innobase_convert_identifier(s, bufend - s,
							slash + 1, idlen
							- (slash - id) - 1,
							thd, TRUE);
		}
	} else if (UNIV_UNLIKELY(*id == TEMP_INDEX_PREFIX)) {
		/* Temporary index name (smart ALTER TABLE) */
		const char temp_index_suffix[]= "--temporary--";

		s = innobase_convert_identifier(buf, buflen, id + 1, idlen - 1,
						thd, FALSE);
		if (s - buf + (sizeof temp_index_suffix - 1) < buflen) {
			memcpy(s, temp_index_suffix,
			       sizeof temp_index_suffix - 1);
			s += sizeof temp_index_suffix - 1;
		}
	} else {
no_db_name:
		s = innobase_convert_identifier(buf, buflen, id, idlen,
						thd, table_id);
1956 1957
	}

1958 1959
	return(s);

osku's avatar
osku committed
1960 1961
}

1962
/**********************************************************************//**
1963 1964
Determines if the currently running transaction has been interrupted.
@return	TRUE if interrupted */
1965
extern "C" UNIV_INTERN
osku's avatar
osku committed
1966 1967 1968
ibool
trx_is_interrupted(
/*===============*/
1969
	trx_t*	trx)	/*!< in: transaction */
osku's avatar
osku committed
1970
{
1971
	return(trx && trx->mysql_thd && thd_killed((THD*) trx->mysql_thd));
osku's avatar
osku committed
1972 1973
}

1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986
/**********************************************************************//**
Determines if the currently running transaction is in strict mode.
@return	TRUE if strict */
extern "C" UNIV_INTERN
ibool
trx_is_strict(
/*==========*/
	trx_t*	trx)	/*!< in: transaction */
{
	return(trx && trx->mysql_thd
	       && THDVAR((THD*) trx->mysql_thd, strict_mode));
}

1987
/**************************************************************//**
1988 1989 1990 1991 1992 1993
Resets some fields of a prebuilt struct. The template is used in fast
retrieval of just those column values MySQL needs in its processing. */
static
void
reset_template(
/*===========*/
1994
	row_prebuilt_t*	prebuilt)	/*!< in/out: prebuilt struct */
1995 1996 1997 1998 1999
{
	prebuilt->keep_other_fields_on_keyread = 0;
	prebuilt->read_just_key = 0;
}

2000
/*****************************************************************//**
osku's avatar
osku committed
2001 2002 2003 2004 2005
Call this when you have opened a new table handle in HANDLER, before you
call index_read_idx() etc. Actually, we can let the cursor stay open even
over a transaction commit! Then you should call this before every operation,
fetch next etc. This function inits the necessary things even after a
transaction commit. */
2006
UNIV_INTERN
osku's avatar
osku committed
2007 2008 2009 2010
void
ha_innobase::init_table_handle_for_HANDLER(void)
/*============================================*/
{
2011 2012 2013 2014
	/* If current thd does not yet have a trx struct, create one.
	If the current handle does not yet have a prebuilt struct, create
	one. Update the trx pointers in the prebuilt struct. Normally
	this operation is done in external_lock. */
osku's avatar
osku committed
2015

2016
	update_thd(ha_thd());
osku's avatar
osku committed
2017

2018 2019
	/* Initialize the prebuilt struct much like it would be inited in
	external_lock */
osku's avatar
osku committed
2020 2021 2022

	innobase_release_stat_resources(prebuilt->trx);

2023
	/* If the transaction is not started yet, start it */
osku's avatar
osku committed
2024

2025
	trx_start_if_not_started(prebuilt->trx);
osku's avatar
osku committed
2026

2027
	/* Assign a read view if the transaction does not have it yet */
osku's avatar
osku committed
2028

2029
	trx_assign_read_view(prebuilt->trx);
osku's avatar
osku committed
2030 2031 2032

	/* Set the MySQL flag to mark that there is an active transaction */

2033
	if (prebuilt->trx->active_trans == 0) {
osku's avatar
osku committed
2034

2035
		innobase_register_trx_and_stmt(ht, user_thd);
osku's avatar
osku committed
2036

2037 2038
		prebuilt->trx->active_trans = 1;
	}
osku's avatar
osku committed
2039

2040 2041
	/* We did the necessary inits in this function, no need to repeat them
	in row_search_for_mysql */
osku's avatar
osku committed
2042

2043
	prebuilt->sql_stat_start = FALSE;
osku's avatar
osku committed
2044

2045 2046
	/* We let HANDLER always to do the reads as consistent reads, even
	if the trx isolation level would have been specified as SERIALIZABLE */
osku's avatar
osku committed
2047

2048 2049
	prebuilt->select_lock_type = LOCK_NONE;
	prebuilt->stored_select_lock_type = LOCK_NONE;
osku's avatar
osku committed
2050

2051
	/* Always fetch all columns in the index record */
osku's avatar
osku committed
2052

2053
	prebuilt->hint_need_to_fetch_extra_cols = ROW_RETRIEVE_ALL_COLS;
osku's avatar
osku committed
2054

2055
	/* We want always to fetch all columns in the whole row? Or do
osku's avatar
osku committed
2056 2057 2058
	we???? */

	prebuilt->used_in_HANDLER = TRUE;
2059
	reset_template(prebuilt);
osku's avatar
osku committed
2060 2061
}

2062
/*********************************************************************//**
2063 2064
Opens an InnoDB database.
@return	0 on success, error code on failure */
2065
static
2066
int
2067 2068
innobase_init(
/*==========*/
2069
	void	*p)	/*!< in: InnoDB handlerton */
osku's avatar
osku committed
2070
{
2071
	static char	current_dir[3];		/*!< Set if using current lib */
osku's avatar
osku committed
2072 2073
	int		err;
	bool		ret;
2074
	char		*default_path;
2075
	uint		format_id;
osku's avatar
osku committed
2076

2077
	DBUG_ENTER("innobase_init");
2078
        handlerton *innobase_hton= (handlerton *)p;
2079
        innodb_hton_ptr = innobase_hton;
2080

2081
        innobase_hton->state = SHOW_OPTION_YES;
2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
        innobase_hton->db_type= DB_TYPE_INNODB;
        innobase_hton->savepoint_offset=sizeof(trx_named_savept_t);
        innobase_hton->close_connection=innobase_close_connection;
        innobase_hton->savepoint_set=innobase_savepoint;
        innobase_hton->savepoint_rollback=innobase_rollback_to_savepoint;
        innobase_hton->savepoint_release=innobase_release_savepoint;
        innobase_hton->commit=innobase_commit;
        innobase_hton->rollback=innobase_rollback;
        innobase_hton->prepare=innobase_xa_prepare;
        innobase_hton->recover=innobase_xa_recover;
        innobase_hton->commit_by_xid=innobase_commit_by_xid;
        innobase_hton->rollback_by_xid=innobase_rollback_by_xid;
        innobase_hton->create_cursor_read_view=innobase_create_cursor_view;
        innobase_hton->set_cursor_read_view=innobase_set_cursor_view;
        innobase_hton->close_cursor_read_view=innobase_close_cursor_view;
        innobase_hton->create=innobase_create_handler;
        innobase_hton->drop_database=innobase_drop_database;
        innobase_hton->panic=innobase_end;
        innobase_hton->start_consistent_snapshot=innobase_start_trx_and_assign_read_view;
        innobase_hton->flush_logs=innobase_flush_logs;
        innobase_hton->show_status=innobase_show_status;
        innobase_hton->flags=HTON_NO_FLAGS;
        innobase_hton->release_temporary_latches=innobase_release_temporary_latches;
2105
	innobase_hton->alter_table_flags = innobase_alter_table_flags;
2106

osku's avatar
osku committed
2107 2108
	ut_a(DATA_MYSQL_TRUE_VARCHAR == (ulint)MYSQL_TYPE_VARCHAR);

2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
#ifdef UNIV_DEBUG
	static const char	test_filename[] = "-@";
	char			test_tablename[sizeof test_filename
				+ sizeof srv_mysql50_table_name_prefix];
	if ((sizeof test_tablename) - 1
			!= filename_to_tablename(test_filename, test_tablename,
			sizeof test_tablename)
			|| strncmp(test_tablename,
			srv_mysql50_table_name_prefix,
			sizeof srv_mysql50_table_name_prefix)
			|| strcmp(test_tablename
			+ sizeof srv_mysql50_table_name_prefix,
			test_filename)) {
		sql_print_error("tablename encoding has been changed");
		goto error;
	}
#endif /* UNIV_DEBUG */

2127 2128
	/* Check that values don't overflow on 32-bit systems. */
	if (sizeof(ulint) == 4) {
2129
		if (innobase_buffer_pool_size > UINT_MAX32) {
2130 2131 2132 2133
			sql_print_error(
				"innobase_buffer_pool_size can't be over 4GB"
				" on 32-bit systems");

2134
			goto error;
2135 2136 2137 2138 2139 2140 2141
		}

		if (innobase_log_file_size > UINT_MAX32) {
			sql_print_error(
				"innobase_log_file_size can't be over 4GB"
				" on 32-bit systems");

2142
			goto error;
2143 2144 2145
		}
	}

2146
	os_innodb_umask = (ulint)my_umask;
osku's avatar
osku committed
2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157

	/* First calculate the default path for innodb_data_home_dir etc.,
	in case the user has not given any value.

	Note that when using the embedded server, the datadirectory is not
	necessarily the current directory of this program. */

	if (mysqld_embedded) {
		default_path = mysql_real_data_home;
		fil_path_to_mysql_datadir = mysql_real_data_home;
	} else {
2158 2159 2160 2161 2162
		/* It's better to use current lib, to keep paths short */
		current_dir[0] = FN_CURLIB;
		current_dir[1] = FN_LIBCHAR;
		current_dir[2] = 0;
		default_path = current_dir;
osku's avatar
osku committed
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177
	}

	ut_a(default_path);

	/* Set InnoDB initialization parameters according to the values
	read from MySQL .cnf file */

	/*--------------- Data files -------------------------*/

	/* The default dir for data files is the datadir of MySQL */

	srv_data_home = (innobase_data_home_dir ? innobase_data_home_dir :
			 default_path);

	/* Set default InnoDB data file size to 10 MB and let it be
2178
	auto-extending. Thus users can use InnoDB in >= 4.0 without having
osku's avatar
osku committed
2179 2180 2181
	to specify any startup options. */

	if (!innobase_data_file_path) {
2182
		innobase_data_file_path = (char*) "ibdata1:10M:autoextend";
osku's avatar
osku committed
2183 2184 2185 2186 2187 2188 2189 2190 2191
	}

	/* Since InnoDB edits the argument in the next call, we make another
	copy of it: */

	internal_innobase_data_file_path = my_strdup(innobase_data_file_path,
						   MYF(MY_FAE));

	ret = (bool) srv_parse_data_file_paths_and_sizes(
2192
		internal_innobase_data_file_path);
osku's avatar
osku committed
2193
	if (ret == FALSE) {
2194
		sql_print_error(
osku's avatar
osku committed
2195
			"InnoDB: syntax error in innodb_data_file_path");
2196 2197
mem_free_and_error:
		srv_free_paths_and_sizes();
2198
		my_free(internal_innobase_data_file_path,
osku's avatar
osku committed
2199
						MYF(MY_ALLOW_ZERO_PTR));
2200
		goto error;
osku's avatar
osku committed
2201 2202 2203 2204 2205
	}

	/* -------------- Log files ---------------------------*/

	/* The default dir for log files is the datadir of MySQL */
2206

osku's avatar
osku committed
2207
	if (!innobase_log_group_home_dir) {
2208
		innobase_log_group_home_dir = default_path;
osku's avatar
osku committed
2209 2210
	}

2211
#ifdef UNIV_LOG_ARCHIVE
osku's avatar
osku committed
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
	/* Since innodb_log_arch_dir has no relevance under MySQL,
	starting from 4.0.6 we always set it the same as
	innodb_log_group_home_dir: */

	innobase_log_arch_dir = innobase_log_group_home_dir;

	srv_arch_dir = innobase_log_arch_dir;
#endif /* UNIG_LOG_ARCHIVE */

	ret = (bool)
2222
		srv_parse_log_group_home_dirs(innobase_log_group_home_dir);
osku's avatar
osku committed
2223 2224 2225 2226 2227

	if (ret == FALSE || innobase_mirrored_log_groups != 1) {
	  sql_print_error("syntax error in innodb_log_group_home_dir, or a "
			  "wrong number of mirrored log groups");

2228
		goto mem_free_and_error;
osku's avatar
osku committed
2229 2230
	}

2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
	/* Validate the file format by animal name */
	if (innobase_file_format_name != NULL) {

		format_id = innobase_file_format_name_lookup(
			innobase_file_format_name);

		if (format_id > DICT_TF_FORMAT_MAX) {

			sql_print_error("InnoDB: wrong innodb_file_format.");

2241
			goto mem_free_and_error;
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261
		}
	} else {
		/* Set it to the default file format id. Though this
		should never happen. */
		format_id = 0;
	}

	srv_file_format = format_id;

	/* Given the type of innobase_file_format_name we have little
	choice but to cast away the constness from the returned name.
	innobase_file_format_name is used in the MySQL set variable
	interface and so can't be const. */

	innobase_file_format_name = 
		(char*) trx_sys_file_format_id_to_name(format_id);

	/* Process innobase_file_format_check variable */
	ut_a(innobase_file_format_check != NULL);

2262
	/* As a side effect it will set srv_check_file_format_at_startup
2263 2264 2265 2266
	on valid input. First we check for "on"/"off". */
	if (!innobase_file_format_check_on_off(innobase_file_format_check)) {

		/* Did the user specify a format name that we support ?
2267 2268
		As a side effect it will update the variable
		srv_check_file_format_at_startup */
2269 2270
		if (innobase_file_format_validate_and_set(
				innobase_file_format_check) < 0) {
2271 2272 2273 2274 2275 2276 2277 2278 2279

			sql_print_error("InnoDB: invalid "
					"innodb_file_format_check value: "
					"should be either 'on' or 'off' or "
					"any value up to %s or its "
					"equivalent numeric id",
					trx_sys_file_format_id_to_name(
						DICT_TF_FORMAT_MAX));

2280
			goto mem_free_and_error;
2281 2282 2283
		}
	}

2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298
	if (innobase_change_buffering) {
		ulint	use;

		for (use = 0;
		     use < UT_ARR_SIZE(innobase_change_buffering_values);
		     use++) {
			if (!innobase_strcasecmp(
				    innobase_change_buffering,
				    innobase_change_buffering_values[use])) {
				ibuf_use = (ibuf_use_t) use;
				goto innobase_change_buffering_inited_ok;
			}
		}

		sql_print_error("InnoDB: invalid value "
2299
				"innodb_change_buffering=%s",
2300 2301 2302 2303 2304
				innobase_change_buffering);
		goto mem_free_and_error;
	}

innobase_change_buffering_inited_ok:
2305 2306 2307 2308
	ut_a((ulint) ibuf_use < UT_ARR_SIZE(innobase_change_buffering_values));
	innobase_change_buffering = (char*)
		innobase_change_buffering_values[ibuf_use];

osku's avatar
osku committed
2309 2310
	/* --------------------------------------------------*/

2311
	srv_file_flush_method_str = innobase_file_flush_method;
osku's avatar
osku committed
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321

	srv_n_log_groups = (ulint) innobase_mirrored_log_groups;
	srv_n_log_files = (ulint) innobase_log_files_in_group;
	srv_log_file_size = (ulint) innobase_log_file_size;

#ifdef UNIV_LOG_ARCHIVE
	srv_log_archive_on = (ulint) innobase_log_archive;
#endif /* UNIV_LOG_ARCHIVE */
	srv_log_buffer_size = (ulint) innobase_log_buffer_size;

2322
	srv_buf_pool_size = (ulint) innobase_buffer_pool_size;
irana's avatar
irana committed
2323
	srv_buf_pool_instances = (ulint) innobase_buffer_pool_instances;
2324

osku's avatar
osku committed
2325 2326 2327
	srv_mem_pool_size = (ulint) innobase_additional_mem_pool_size;

	srv_n_file_io_threads = (ulint) innobase_file_io_threads;
2328 2329
	srv_n_read_io_threads = (ulint) innobase_read_io_threads;
	srv_n_write_io_threads = (ulint) innobase_write_io_threads;
osku's avatar
osku committed
2330 2331 2332 2333 2334 2335

	srv_force_recovery = (ulint) innobase_force_recovery;

	srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;
	srv_use_checksums = (ibool) innobase_use_checksums;

2336 2337 2338 2339
#ifdef HAVE_LARGE_PAGES
        if ((os_use_large_pages = (ibool) my_use_large_pages))
		os_large_page_size = (ulint) opt_large_page_size;
#endif
2340

2341 2342
	row_rollback_on_timeout = (ibool) innobase_rollback_on_timeout;

2343
	srv_locks_unsafe_for_binlog = (ibool) innobase_locks_unsafe_for_binlog;
osku's avatar
osku committed
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356

	srv_max_n_open_files = (ulint) innobase_open_files;
	srv_innodb_status = (ibool) innobase_create_status_file;

	srv_print_verbose_log = mysqld_embedded ? 0 : 1;

	/* Store the default charset-collation number of this MySQL
	installation */

	data_mysql_default_charset_coll = (ulint)default_charset_info->number;

	ut_a(DATA_MYSQL_LATIN1_SWEDISH_CHARSET_COLL ==
					my_charset_latin1.number);
2357
	ut_a(DATA_MYSQL_BINARY_CHARSET_COLL == my_charset_bin.number);
osku's avatar
osku committed
2358 2359 2360 2361 2362 2363

	/* Store the latin1_swedish_ci character ordering table to InnoDB. For
	non-latin1_swedish_ci charsets we use the MySQL comparison functions,
	and consequently we do not need to know the ordering internally in
	InnoDB. */

2364 2365
	ut_a(0 == strcmp(my_charset_latin1.name, "latin1_swedish_ci"));
	srv_latin1_ordering = my_charset_latin1.sort_order;
osku's avatar
osku committed
2366

2367 2368
	innobase_commit_concurrency_init_default();

2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407
#ifdef HAVE_PSI_INTERFACE
	/* Register keys with MySQL performance schema */
	if (PSI_server) {
		int	count;

                count = array_elements(all_pthread_mutexes);
                PSI_server->register_mutex("innodb",
                                           all_pthread_mutexes, count);

# ifdef UNIV_PFS_MUTEX
		count = array_elements(all_innodb_mutexes);
		PSI_server->register_mutex("innodb",
					   all_innodb_mutexes, count);
# endif /* UNIV_PFS_MUTEX */

# ifdef UNIV_PFS_RWLOCK
		count = array_elements(all_innodb_rwlocks);
		PSI_server->register_rwlock("innodb",
					    all_innodb_rwlocks, count);
# endif /* UNIV_PFS_MUTEX */

# ifdef UNIV_PFS_THREAD
		count = array_elements(all_innodb_threads);
		PSI_server->register_thread("innodb",
					    all_innodb_threads, count);
# endif /* UNIV_PFS_THREAD */

# ifdef UNIV_PFS_IO
		count = array_elements(all_innodb_files);
		PSI_server->register_file("innodb",
					  all_innodb_files, count);
# endif /* UNIV_PFS_IO */

		count = array_elements(all_innodb_conds);
		PSI_server->register_cond("innodb",
					  all_innodb_conds, count);
	}
#endif /* HAVE_PSI_INTERFACE */

osku's avatar
osku committed
2408
	/* Since we in this module access directly the fields of a trx
2409
	struct, and due to different headers and flags it might happen that
osku's avatar
osku committed
2410 2411 2412 2413 2414 2415 2416
	mutex_t has a different size in this module and in InnoDB
	modules, we check at run time that the size is the same in
	these compilation modules. */

	err = innobase_start_or_create_for_mysql();

	if (err != DB_SUCCESS) {
2417
		goto mem_free_and_error;
osku's avatar
osku committed
2418 2419
	}

irana's avatar
irana committed
2420 2421 2422
	innobase_old_blocks_pct = buf_LRU_old_ratio_update(
		innobase_old_blocks_pct, TRUE);

2423
	innobase_open_tables = hash_create(200);
2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
	mysql_mutex_init(innobase_share_mutex_key,
			 &innobase_share_mutex,
			 MY_MUTEX_INIT_FAST);
	mysql_mutex_init(prepare_commit_mutex_key,
			 &prepare_commit_mutex, MY_MUTEX_INIT_FAST);
	mysql_mutex_init(commit_threads_m_key,
			 &commit_threads_m, MY_MUTEX_INIT_FAST);
	mysql_mutex_init(commit_cond_mutex_key,
			 &commit_cond_m, MY_MUTEX_INIT_FAST);
	mysql_mutex_init(analyze_mutex_key,
			  &analyze_mutex, MY_MUTEX_INIT_FAST);
	mysql_cond_init(commit_cond_key, &commit_cond, NULL);
osku's avatar
osku committed
2436
	innodb_inited= 1;
2437 2438 2439 2440 2441 2442
#ifdef MYSQL_DYNAMIC_PLUGIN
	if (innobase_hton != p) {
		innobase_hton = reinterpret_cast<handlerton*>(p);
		*innobase_hton = *innodb_hton_ptr;
	}
#endif /* MYSQL_DYNAMIC_PLUGIN */
osku's avatar
osku committed
2443

2444 2445 2446
	/* Get the current high water mark format. */
	innobase_file_format_check = (char*) trx_sys_file_format_max_get();

osku's avatar
osku committed
2447 2448
	DBUG_RETURN(FALSE);
error:
2449
	DBUG_RETURN(TRUE);
osku's avatar
osku committed
2450 2451
}

2452
/*******************************************************************//**
2453 2454
Closes an InnoDB database.
@return	TRUE if error */
2455
static
osku's avatar
osku committed
2456
int
2457 2458
innobase_end(
/*=========*/
2459
	handlerton*		hton,	/*!< in/out: InnoDB handlerton */
2460
	ha_panic_function	type __attribute__((unused)))
2461
					/*!< in: ha_panic() parameter */
osku's avatar
osku committed
2462 2463 2464 2465
{
	int	err= 0;

	DBUG_ENTER("innobase_end");
2466
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
2467

2468
#ifdef __NETWARE__	/* some special cleanup for NetWare */
osku's avatar
osku committed
2469 2470 2471 2472 2473 2474
	if (nw_panic) {
		set_panic_flag_for_netware();
	}
#endif
	if (innodb_inited) {

2475 2476
		srv_fast_shutdown = (ulint) innobase_fast_shutdown;
		innodb_inited = 0;
2477 2478
		hash_table_free(innobase_open_tables);
		innobase_open_tables = NULL;
2479 2480
		if (innobase_shutdown_for_mysql() != DB_SUCCESS) {
			err = 1;
osku's avatar
osku committed
2481
		}
2482
		srv_free_paths_and_sizes();
2483
		my_free(internal_innobase_data_file_path,
osku's avatar
osku committed
2484
						MYF(MY_ALLOW_ZERO_PTR));
2485 2486 2487 2488 2489 2490
		mysql_mutex_destroy(&innobase_share_mutex);
		mysql_mutex_destroy(&prepare_commit_mutex);
		mysql_mutex_destroy(&commit_threads_m);
		mysql_mutex_destroy(&commit_cond_m);
		mysql_mutex_destroy(&analyze_mutex);
		mysql_cond_destroy(&commit_cond);
osku's avatar
osku committed
2491 2492
	}

2493
	DBUG_RETURN(err);
osku's avatar
osku committed
2494 2495
}

2496
/****************************************************************//**
osku's avatar
osku committed
2497
Flushes InnoDB logs to disk and makes a checkpoint. Really, a commit flushes
2498 2499
the logs, and the name of this function should be innobase_checkpoint.
@return	TRUE if error */
2500
static
osku's avatar
osku committed
2501
bool
2502 2503
innobase_flush_logs(
/*================*/
2504
	handlerton*	hton)	/*!< in/out: InnoDB handlerton */
osku's avatar
osku committed
2505
{
2506
	bool	result = 0;
osku's avatar
osku committed
2507

2508
	DBUG_ENTER("innobase_flush_logs");
2509
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
2510 2511 2512

	log_buffer_flush_to_disk();

2513
	DBUG_RETURN(result);
osku's avatar
osku committed
2514 2515
}

2516
/****************************************************************//**
2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530
Return alter table flags supported in an InnoDB database. */
static
uint
innobase_alter_table_flags(
/*=======================*/
	uint	flags)
{
	return(HA_ONLINE_ADD_INDEX_NO_WRITES
		| HA_ONLINE_DROP_INDEX_NO_WRITES
		| HA_ONLINE_ADD_UNIQUE_INDEX_NO_WRITES
		| HA_ONLINE_DROP_UNIQUE_INDEX_NO_WRITES
		| HA_ONLINE_ADD_PK_INDEX_NO_WRITES);
}

2531
/*****************************************************************//**
osku's avatar
osku committed
2532
Commits a transaction in an InnoDB database. */
2533
static
osku's avatar
osku committed
2534 2535 2536
void
innobase_commit_low(
/*================*/
2537
	trx_t*	trx)	/*!< in: transaction handle */
osku's avatar
osku committed
2538
{
2539
	if (trx->conc_state == TRX_NOT_STARTED) {
osku's avatar
osku committed
2540

2541 2542
		return;
	}
osku's avatar
osku committed
2543 2544 2545 2546

	trx_commit_for_mysql(trx);
}

2547
/*****************************************************************//**
osku's avatar
osku committed
2548 2549 2550
Creates an InnoDB transaction struct for the thd if it does not yet have one.
Starts a new InnoDB transaction if a transaction is not yet started. And
assigns a new snapshot for a consistent read if the transaction does not yet
2551 2552
have one.
@return	0 */
2553
static
osku's avatar
osku committed
2554 2555 2556
int
innobase_start_trx_and_assign_read_view(
/*====================================*/
2557 2558
        handlerton *hton, /*!< in: Innodb handlerton */ 
	THD*	thd)	/*!< in: MySQL thread handle of the user for whom
osku's avatar
osku committed
2559 2560 2561 2562
			the transaction should be committed */
{
	trx_t*	trx;

2563
	DBUG_ENTER("innobase_start_trx_and_assign_read_view");
2564
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
2565 2566 2567

	/* Create a new trx struct for thd, if it does not yet have one */

2568
	trx = check_trx_exists(thd);
osku's avatar
osku committed
2569 2570 2571 2572 2573 2574 2575 2576 2577

	/* This is just to play safe: release a possible FIFO ticket and
	search latch. Since we will reserve the kernel mutex, we have to
	release the search system latch first to obey the latching order. */

	innobase_release_stat_resources(trx);

	/* If the transaction is not started yet, start it */

2578
	trx_start_if_not_started(trx);
osku's avatar
osku committed
2579 2580 2581 2582 2583 2584 2585

	/* Assign a read view if the transaction does not have it yet */

	trx_assign_read_view(trx);

	/* Set the MySQL flag to mark that there is an active transaction */

2586
	if (trx->active_trans == 0) {
2587
		innobase_register_trx_and_stmt(hton, thd);
2588 2589
		trx->active_trans = 1;
	}
osku's avatar
osku committed
2590 2591 2592 2593

	DBUG_RETURN(0);
}

2594
/*****************************************************************//**
osku's avatar
osku committed
2595
Commits a transaction in an InnoDB database or marks an SQL statement
2596 2597
ended.
@return	0 */
osku's avatar
osku committed
2598 2599 2600 2601
static
int
innobase_commit(
/*============*/
2602 2603
        handlerton *hton, /*!< in: Innodb handlerton */ 
	THD* 	thd,	/*!< in: MySQL thread handle of the user for whom
osku's avatar
osku committed
2604
			the transaction should be committed */
2605
	bool	all)	/*!< in:	TRUE - commit transaction
2606
				FALSE - the current SQL statement ended */
osku's avatar
osku committed
2607 2608 2609
{
	trx_t*		trx;

2610
	DBUG_ENTER("innobase_commit");
2611
	DBUG_ASSERT(hton == innodb_hton_ptr);
2612
	DBUG_PRINT("trans", ("ending transaction"));
osku's avatar
osku committed
2613

2614
	trx = check_trx_exists(thd);
osku's avatar
osku committed
2615

2616 2617
	/* Since we will reserve the kernel mutex, we have to release
	the search system latch first to obey the latching order. */
osku's avatar
osku committed
2618

2619
	if (trx->has_search_latch) {
2620
		trx_search_latch_release_if_reserved(trx);
2621 2622 2623
	}

	/* The flag trx->active_trans is set to 1 in
osku's avatar
osku committed
2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637

	1. ::external_lock(),
	2. ::start_stmt(),
	3. innobase_query_caching_of_table_permitted(),
	4. innobase_savepoint(),
	5. ::init_table_handle_for_HANDLER(),
	6. innobase_start_trx_and_assign_read_view(),
	7. ::transactional_table_lock()

	and it is only set to 0 in a commit or a rollback. If it is 0 we know
	there cannot be resources to be freed and we could return immediately.
	For the time being, we play safe and do the cleanup though there should
	be nothing to clean up. */

2638 2639 2640 2641 2642
	if (trx->active_trans == 0
		&& trx->conc_state != TRX_NOT_STARTED) {

		sql_print_error("trx->active_trans == 0, but"
			" trx->conc_state != TRX_NOT_STARTED");
osku's avatar
osku committed
2643
	}
2644
	if (all
2645
		|| (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {
2646 2647

		/* We were instructed to commit the whole transaction, or
osku's avatar
osku committed
2648 2649
		this is an SQL statement end and autocommit is on */

2650 2651 2652
		/* We need current binlog position for ibbackup to work.
		Note, the position is current because of
		prepare_commit_mutex */
osku's avatar
osku committed
2653
retry:
2654
		if (innobase_commit_concurrency > 0) {
2655
			mysql_mutex_lock(&commit_cond_m);
2656 2657
			commit_threads++;

2658
			if (commit_threads > innobase_commit_concurrency) {
2659
				commit_threads--;
2660
				mysql_cond_wait(&commit_cond,
2661
					&commit_cond_m);
2662
				mysql_mutex_unlock(&commit_cond_m);
2663 2664 2665
				goto retry;
			}
			else {
2666
				mysql_mutex_unlock(&commit_cond_m);
2667 2668 2669
			}
		}

2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682
		/* The following calls to read the MySQL binary log
		file name and the position return consistent results:
		1) Other InnoDB transactions cannot intervene between
		these calls as we are holding prepare_commit_mutex.
		2) Binary logging of other engines is not relevant
		to InnoDB as all InnoDB requires is that committing
		InnoDB transactions appear in the same order in the
		MySQL binary log as they appear in InnoDB logs.
		3) A MySQL log file rotation cannot happen because
		MySQL protects against this by having a counter of
		transactions in prepared state and it only allows
		a rotation when the counter drops to zero. See
		LOCK_prep_xids and COND_prep_xids in log.cc. */
2683
		trx->mysql_log_file_name = mysql_bin_log_file_name();
2684
		trx->mysql_log_offset = (ib_int64_t) mysql_bin_log_file_pos();
osku's avatar
osku committed
2685

inaam's avatar
inaam committed
2686 2687 2688 2689
		/* Don't do write + flush right now. For group commit
		to work we want to do the flush after releasing the
		prepare_commit_mutex. */
		trx->flush_log_later = TRUE;
osku's avatar
osku committed
2690
		innobase_commit_low(trx);
inaam's avatar
inaam committed
2691
		trx->flush_log_later = FALSE;
osku's avatar
osku committed
2692

2693
		if (innobase_commit_concurrency > 0) {
2694
			mysql_mutex_lock(&commit_cond_m);
2695
			commit_threads--;
2696 2697
			mysql_cond_signal(&commit_cond);
			mysql_mutex_unlock(&commit_cond_m);
2698 2699 2700 2701
		}

		if (trx->active_trans == 2) {

2702
			mysql_mutex_unlock(&prepare_commit_mutex);
2703 2704
		}

inaam's avatar
inaam committed
2705 2706
		/* Now do a write + flush of logs. */
		trx_commit_complete_for_mysql(trx);
2707 2708
		trx->active_trans = 0;

osku's avatar
osku committed
2709
	} else {
2710
		/* We just mark the SQL statement ended and do not do a
osku's avatar
osku committed
2711 2712
		transaction commit */

2713 2714 2715 2716
		/* If we had reserved the auto-inc lock for some
		table in this SQL statement we release it now */

		row_unlock_table_autoinc_for_mysql(trx);
2717

osku's avatar
osku committed
2718 2719 2720 2721 2722 2723 2724
		/* Store the current undo_no of the transaction so that we
		know where to roll back if we have to roll back the next
		SQL statement */

		trx_mark_sql_stat_end(trx);
	}

2725 2726
	trx->n_autoinc_rows = 0; /* Reset the number AUTO-INC rows required */

2727
	if (trx->declared_to_be_inside_innodb) {
2728
		/* Release our possible ticket in the FIFO */
osku's avatar
osku committed
2729

2730
		srv_conc_force_exit_innodb(trx);
2731
	}
2732 2733 2734

	/* Tell the InnoDB server that there might be work for utility
	threads: */
osku's avatar
osku committed
2735 2736 2737 2738 2739
	srv_active_wake_master_thread();

	DBUG_RETURN(0);
}

2740
/*****************************************************************//**
2741 2742
Rolls back a transaction or the latest SQL statement.
@return	0 or error number */
2743 2744
static
int
osku's avatar
osku committed
2745 2746
innobase_rollback(
/*==============*/
2747 2748
        handlerton *hton, /*!< in: Innodb handlerton */ 
	THD*	thd,	/*!< in: handle to the MySQL thread of the user
osku's avatar
osku committed
2749
			whose transaction should be rolled back */
2750
	bool	all)	/*!< in:	TRUE - commit transaction
2751
				FALSE - the current SQL statement ended */
osku's avatar
osku committed
2752 2753 2754 2755 2756
{
	int	error = 0;
	trx_t*	trx;

	DBUG_ENTER("innobase_rollback");
2757
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
2758 2759
	DBUG_PRINT("trans", ("aborting transaction"));

2760
	trx = check_trx_exists(thd);
osku's avatar
osku committed
2761 2762 2763 2764 2765 2766 2767

	/* Release a possible FIFO ticket and search latch. Since we will
	reserve the kernel mutex, we have to release the search system latch
	first to obey the latching order. */

	innobase_release_stat_resources(trx);

2768 2769
	trx->n_autoinc_rows = 0; /* Reset the number AUTO-INC rows required */

2770 2771 2772
	/* If we had reserved the auto-inc lock for some table (if
	we come here to roll back the latest SQL statement) we
	release it now before a possibly lengthy rollback */
2773

2774
	row_unlock_table_autoinc_for_mysql(trx);
osku's avatar
osku committed
2775

2776
	if (all
2777
		|| !thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
osku's avatar
osku committed
2778 2779

		error = trx_rollback_for_mysql(trx);
2780
		trx->active_trans = 0;
osku's avatar
osku committed
2781 2782 2783 2784
	} else {
		error = trx_rollback_last_sql_stat_for_mysql(trx);
	}

2785
	DBUG_RETURN(convert_error_code_to_mysql(error, 0, NULL));
osku's avatar
osku committed
2786 2787
}

2788
/*****************************************************************//**
2789 2790
Rolls back a transaction
@return	0 or error number */
2791
static
osku's avatar
osku committed
2792 2793 2794
int
innobase_rollback_trx(
/*==================*/
2795
	trx_t*	trx)	/*!< in: transaction */
osku's avatar
osku committed
2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807
{
	int	error = 0;

	DBUG_ENTER("innobase_rollback_trx");
	DBUG_PRINT("trans", ("aborting transaction"));

	/* Release a possible FIFO ticket and search latch. Since we will
	reserve the kernel mutex, we have to release the search system latch
	first to obey the latching order. */

	innobase_release_stat_resources(trx);

2808 2809 2810
	/* If we had reserved the auto-inc lock for some table (if
	we come here to roll back the latest SQL statement) we
	release it now before a possibly lengthy rollback */
2811

2812
	row_unlock_table_autoinc_for_mysql(trx);
osku's avatar
osku committed
2813 2814 2815

	error = trx_rollback_for_mysql(trx);

2816
	DBUG_RETURN(convert_error_code_to_mysql(error, 0, NULL));
osku's avatar
osku committed
2817 2818
}

2819
/*****************************************************************//**
2820
Rolls back a transaction to a savepoint.
2821 2822
@return 0 if success, HA_ERR_NO_SAVEPOINT if no savepoint with the
given name */
2823 2824
static
int
osku's avatar
osku committed
2825 2826
innobase_rollback_to_savepoint(
/*===========================*/
2827 2828
        handlerton *hton,       /*!< in: Innodb handlerton */ 
	THD*	thd,		/*!< in: handle to the MySQL thread of the user
osku's avatar
osku committed
2829
				whose transaction should be rolled back */
2830
	void*	savepoint)	/*!< in: savepoint data */
osku's avatar
osku committed
2831
{
2832
	ib_int64_t	mysql_binlog_cache_pos;
2833 2834 2835
	int		error = 0;
	trx_t*		trx;
	char		name[64];
osku's avatar
osku committed
2836 2837

	DBUG_ENTER("innobase_rollback_to_savepoint");
2838
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
2839

2840
	trx = check_trx_exists(thd);
osku's avatar
osku committed
2841 2842 2843 2844 2845 2846 2847

	/* Release a possible FIFO ticket and search latch. Since we will
	reserve the kernel mutex, we have to release the search system latch
	first to obey the latching order. */

	innobase_release_stat_resources(trx);

2848
	/* TODO: use provided savepoint data area to store savepoint data */
osku's avatar
osku committed
2849

2850
	longlong2str((ulint)savepoint, name, 36);
osku's avatar
osku committed
2851

2852
	error = (int) trx_rollback_to_savepoint_for_mysql(trx, name,
osku's avatar
osku committed
2853
						&mysql_binlog_cache_pos);
2854
	DBUG_RETURN(convert_error_code_to_mysql(error, 0, NULL));
osku's avatar
osku committed
2855 2856
}

2857
/*****************************************************************//**
2858
Release transaction savepoint name.
2859 2860
@return 0 if success, HA_ERR_NO_SAVEPOINT if no savepoint with the
given name */
osku's avatar
osku committed
2861 2862 2863 2864
static
int
innobase_release_savepoint(
/*=======================*/
2865 2866
        handlerton*	hton,	/*!< in: handlerton for Innodb */
	THD*	thd,		/*!< in: handle to the MySQL thread of the user
osku's avatar
osku committed
2867
				whose transaction should be rolled back */
2868
	void*	savepoint)	/*!< in: savepoint data */
osku's avatar
osku committed
2869
{
2870 2871 2872
	int		error = 0;
	trx_t*		trx;
	char		name[64];
osku's avatar
osku committed
2873 2874

	DBUG_ENTER("innobase_release_savepoint");
2875
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
2876

2877
	trx = check_trx_exists(thd);
osku's avatar
osku committed
2878

2879
	/* TODO: use provided savepoint data area to store savepoint data */
osku's avatar
osku committed
2880

2881
	longlong2str((ulint)savepoint, name, 36);
osku's avatar
osku committed
2882 2883 2884

	error = (int) trx_release_savepoint_for_mysql(trx, name);

2885
	DBUG_RETURN(convert_error_code_to_mysql(error, 0, NULL));
osku's avatar
osku committed
2886 2887
}

2888
/*****************************************************************//**
2889 2890
Sets a transaction savepoint.
@return	always 0, that is, always succeeds */
osku's avatar
osku committed
2891 2892 2893 2894
static
int
innobase_savepoint(
/*===============*/
2895 2896 2897
	handlerton*	hton,   /*!< in: handle to the Innodb handlerton */
	THD*	thd,		/*!< in: handle to the MySQL thread */
	void*	savepoint)	/*!< in: savepoint data */
osku's avatar
osku committed
2898 2899 2900 2901 2902
{
	int	error = 0;
	trx_t*	trx;

	DBUG_ENTER("innobase_savepoint");
2903
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
2904

2905 2906 2907 2908 2909
	/*
	  In the autocommit mode there is no sense to set a savepoint
	  (unless we are in sub-statement), so SQL layer ensures that
	  this method is never called in such situation.
	*/
2910 2911
#ifdef MYSQL_SERVER /* plugins cannot access thd->in_sub_stmt */
	DBUG_ASSERT(thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
2912
		thd->in_sub_stmt);
2913
#endif /* MYSQL_SERVER */
osku's avatar
osku committed
2914

2915
	trx = check_trx_exists(thd);
osku's avatar
osku committed
2916 2917 2918 2919 2920 2921 2922

	/* Release a possible FIFO ticket and search latch. Since we will
	reserve the kernel mutex, we have to release the search system latch
	first to obey the latching order. */

	innobase_release_stat_resources(trx);

2923 2924
	/* cannot happen outside of transaction */
	DBUG_ASSERT(trx->active_trans);
osku's avatar
osku committed
2925

2926 2927 2928
	/* TODO: use provided savepoint data area to store savepoint data */
	char name[64];
	longlong2str((ulint)savepoint,name,36);
osku's avatar
osku committed
2929

2930
	error = (int) trx_savepoint_for_mysql(trx, name, (ib_int64_t)0);
osku's avatar
osku committed
2931

2932
	DBUG_RETURN(convert_error_code_to_mysql(error, 0, NULL));
osku's avatar
osku committed
2933 2934
}

2935
/*****************************************************************//**
2936 2937
Frees a possible InnoDB trx object associated with the current THD.
@return	0 or error number */
osku's avatar
osku committed
2938 2939 2940 2941
static
int
innobase_close_connection(
/*======================*/
2942 2943
        handlerton*	hton,	/*!< in:  innobase handlerton */
	THD*	thd)	/*!< in: handle to the MySQL thread of the user
osku's avatar
osku committed
2944 2945 2946 2947
			whose resources should be free'd */
{
	trx_t*	trx;

2948 2949 2950
	DBUG_ENTER("innobase_close_connection");
	DBUG_ASSERT(hton == innodb_hton_ptr);
	trx = thd_to_trx(thd);
osku's avatar
osku committed
2951 2952 2953

	ut_a(trx);

2954 2955 2956 2957 2958
	if (trx->active_trans == 0
		&& trx->conc_state != TRX_NOT_STARTED) {

		sql_print_error("trx->active_trans == 0, but"
			" trx->conc_state != TRX_NOT_STARTED");
osku's avatar
osku committed
2959 2960 2961 2962
	}


	if (trx->conc_state != TRX_NOT_STARTED &&
2963 2964 2965 2966 2967 2968 2969
		global_system_variables.log_warnings) {
		sql_print_warning(
			"MySQL is closing a connection that has an active "
			"InnoDB transaction.  %lu row modifications will "
			"roll back.",
			(ulong) trx->undo_no.low);
	}
osku's avatar
osku committed
2970 2971 2972

	innobase_rollback_trx(trx);

2973
	thr_local_free(trx->mysql_thread_id);
2974
	trx_free_for_mysql(trx);
osku's avatar
osku committed
2975

2976
	DBUG_RETURN(0);
osku's avatar
osku committed
2977 2978 2979
}


2980
/*************************************************************************//**
osku's avatar
osku committed
2981 2982 2983
** InnoDB database tables
*****************************************************************************/

2984
/****************************************************************//**
2985
Get the record format from the data dictionary.
2986 2987
@return one of ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT,
ROW_TYPE_COMPRESSED, ROW_TYPE_DYNAMIC */
2988
UNIV_INTERN
osku's avatar
osku committed
2989 2990 2991 2992 2993
enum row_type
ha_innobase::get_row_type() const
/*=============================*/
{
	if (prebuilt && prebuilt->table) {
2994 2995 2996
		const ulint	flags = prebuilt->table->flags;

		if (UNIV_UNLIKELY(!flags)) {
osku's avatar
osku committed
2997 2998
			return(ROW_TYPE_REDUNDANT);
		}
2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014

		ut_ad(flags & DICT_TF_COMPACT);

		switch (flags & DICT_TF_FORMAT_MASK) {
		case DICT_TF_FORMAT_51 << DICT_TF_FORMAT_SHIFT:
			return(ROW_TYPE_COMPACT);
		case DICT_TF_FORMAT_ZIP << DICT_TF_FORMAT_SHIFT:
			if (flags & DICT_TF_ZSSIZE_MASK) {
				return(ROW_TYPE_COMPRESSED);
			} else {
				return(ROW_TYPE_DYNAMIC);
			}
#if DICT_TF_FORMAT_ZIP != DICT_TF_FORMAT_MAX
# error "DICT_TF_FORMAT_ZIP != DICT_TF_FORMAT_MAX"
#endif
		}
osku's avatar
osku committed
3015 3016 3017 3018 3019
	}
	ut_ad(0);
	return(ROW_TYPE_NOT_USED);
}

3020 3021


3022
/****************************************************************//**
3023 3024
Get the table flags to use for the statement.
@return	table flags */
3025
UNIV_INTERN
3026 3027
handler::Table_flags
ha_innobase::table_flags() const
3028
/*============================*/
3029 3030 3031
{
       /* Need to use tx_isolation here since table flags is (also)
          called before prebuilt is inited. */
3032
        ulong const tx_isolation = thd_tx_isolation(ha_thd());
3033 3034 3035 3036 3037
        if (tx_isolation <= ISO_READ_COMMITTED)
                return int_table_flags;
        return int_table_flags | HA_BINLOG_STMT_CAPABLE;
}

3038
/****************************************************************//**
osku's avatar
osku committed
3039 3040 3041 3042 3043 3044
Gives the file extension of an InnoDB single-table tablespace. */
static const char* ha_innobase_exts[] = {
  ".ibd",
  NullS
};

3045
/****************************************************************//**
3046 3047
Returns the table type (storage engine name).
@return	table type */
3048 3049 3050 3051 3052 3053 3054 3055
UNIV_INTERN
const char*
ha_innobase::table_type() const
/*===========================*/
{
	return(innobase_hton_name);
}

3056
/****************************************************************//**
3057
Returns the index type. */
3058 3059
UNIV_INTERN
const char*
3060 3061 3062
ha_innobase::index_type(
/*====================*/
	uint)
3063
				/*!< out: index type */
3064 3065 3066 3067
{
	return("BTREE");
}

3068
/****************************************************************//**
3069 3070
Returns the table file name extension.
@return	file extension string */
3071
UNIV_INTERN
osku's avatar
osku committed
3072 3073 3074 3075
const char**
ha_innobase::bas_ext() const
/*========================*/
{
3076
	return(ha_innobase_exts);
osku's avatar
osku committed
3077 3078
}

3079
/****************************************************************//**
3080 3081
Returns the operations supported for indexes.
@return	flags of supported operations */
3082 3083
UNIV_INTERN
ulong
3084 3085 3086 3087 3088 3089
ha_innobase::index_flags(
/*=====================*/
	uint,
	uint,
	bool)
const
3090 3091 3092 3093 3094
{
	return(HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER
	       | HA_READ_RANGE | HA_KEYREAD_ONLY);
}

3095
/****************************************************************//**
3096 3097
Returns the maximum number of keys.
@return	MAX_KEY */
3098 3099 3100
UNIV_INTERN
uint
ha_innobase::max_supported_keys() const
3101
/*===================================*/
3102 3103 3104 3105
{
	return(MAX_KEY);
}

3106
/****************************************************************//**
3107 3108
Returns the maximum key length.
@return	maximum supported key length, in bytes */
3109 3110 3111
UNIV_INTERN
uint
ha_innobase::max_supported_key_length() const
3112
/*=========================================*/
3113 3114 3115 3116 3117 3118 3119 3120 3121
{
	/* An InnoDB page must store >= 2 keys; a secondary key record
	must also contain the primary key value: max key length is
	therefore set to slightly less than 1 / 4 of page size which
	is 16 kB; but currently MySQL does not work with keys whose
	size is > MAX_KEY_LENGTH */
	return(3500);
}

3122
/****************************************************************//**
3123 3124
Returns the key map of keys that are usable for scanning.
@return	key_map_full */
3125 3126 3127 3128 3129 3130 3131
UNIV_INTERN
const key_map*
ha_innobase::keys_to_use_for_scanning()
{
	return(&key_map_full);
}

3132
/****************************************************************//**
3133 3134
Determines if table caching is supported.
@return	HA_CACHE_TBL_ASKTRANSACT */
3135 3136 3137 3138 3139 3140 3141
UNIV_INTERN
uint8
ha_innobase::table_cache_type()
{
	return(HA_CACHE_TBL_ASKTRANSACT);
}

3142
/****************************************************************//**
3143 3144
Determines if the primary key is clustered index.
@return	true */
3145 3146 3147 3148 3149 3150
UNIV_INTERN
bool
ha_innobase::primary_key_is_clustered()
{
	return(true);
}
osku's avatar
osku committed
3151

3152
/*****************************************************************//**
osku's avatar
osku committed
3153 3154 3155 3156 3157 3158 3159 3160
Normalizes a table name string. A normalized name consists of the
database name catenated to '/' and table name. An example:
test/mytable. On Windows normalization puts both the database name and the
table name always to lower case. */
static
void
normalize_table_name(
/*=================*/
3161
	char*		norm_name,	/*!< out: normalized name as a
osku's avatar
osku committed
3162
					null-terminated string */
3163
	const char*	name)		/*!< in: table name string */
osku's avatar
osku committed
3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197
{
	char*	name_ptr;
	char*	db_ptr;
	char*	ptr;

	/* Scan name from the end */

	ptr = strend(name)-1;

	while (ptr >= name && *ptr != '\\' && *ptr != '/') {
		ptr--;
	}

	name_ptr = ptr + 1;

	DBUG_ASSERT(ptr > name);

	ptr--;

	while (ptr >= name && *ptr != '\\' && *ptr != '/') {
		ptr--;
	}

	db_ptr = ptr + 1;

	memcpy(norm_name, db_ptr, strlen(name) + 1 - (db_ptr - name));

	norm_name[name_ptr - db_ptr - 1] = '/';

#ifdef __WIN__
	innobase_casedn_str(norm_name);
#endif
}

3198
/********************************************************************//**
3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259
Get the upper limit of the MySQL integral and floating-point type.
@return maximum allowed value for the field */
static
ulonglong
innobase_get_int_col_max_value(
/*===========================*/
	const Field*	field)	/*!< in: MySQL field */
{
	ulonglong	max_value = 0;

	switch(field->key_type()) {
	/* TINY */
	case HA_KEYTYPE_BINARY:
		max_value = 0xFFULL;
		break;
	case HA_KEYTYPE_INT8:
		max_value = 0x7FULL;
		break;
	/* SHORT */
	case HA_KEYTYPE_USHORT_INT:
		max_value = 0xFFFFULL;
		break;
	case HA_KEYTYPE_SHORT_INT:
		max_value = 0x7FFFULL;
		break;
	/* MEDIUM */
	case HA_KEYTYPE_UINT24:
		max_value = 0xFFFFFFULL;
		break;
	case HA_KEYTYPE_INT24:
		max_value = 0x7FFFFFULL;
		break;
	/* LONG */
	case HA_KEYTYPE_ULONG_INT:
		max_value = 0xFFFFFFFFULL;
		break;
	case HA_KEYTYPE_LONG_INT:
		max_value = 0x7FFFFFFFULL;
		break;
	/* BIG */
	case HA_KEYTYPE_ULONGLONG:
		max_value = 0xFFFFFFFFFFFFFFFFULL;
		break;
	case HA_KEYTYPE_LONGLONG:
		max_value = 0x7FFFFFFFFFFFFFFFULL;
		break;
	case HA_KEYTYPE_FLOAT:
		/* We use the maximum as per IEEE754-2008 standard, 2^24 */
		max_value = 0x1000000ULL;
		break;
	case HA_KEYTYPE_DOUBLE:
		/* We use the maximum as per IEEE754-2008 standard, 2^53 */
		max_value = 0x20000000000000ULL;
		break;
	default:
		ut_error;
	}

	return(max_value);
}

3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355
/*******************************************************************//**
This function checks whether the index column information
is consistent between KEY info from mysql and that from innodb index.
@return TRUE if all column types match. */
static
ibool
innobase_match_index_columns(
/*=========================*/
	const KEY*		key_info,	/*!< in: Index info
						from mysql */
	const dict_index_t*	index_info)	/*!< in: Index info
						from Innodb */
{
	const KEY_PART_INFO*	key_part;
	const KEY_PART_INFO*	key_end;
	const dict_field_t*	innodb_idx_fld;
	const dict_field_t*	innodb_idx_fld_end;

	DBUG_ENTER("innobase_match_index_columns");

	/* Check whether user defined index column count matches */
	if (key_info->key_parts != index_info->n_user_defined_cols) {
		DBUG_RETURN(FALSE);
	}

	key_part = key_info->key_part;
	key_end = key_part + key_info->key_parts;
	innodb_idx_fld = index_info->fields;
	innodb_idx_fld_end = index_info->fields + index_info->n_fields;

	/* Check each index column's datatype. We do not check
	column name because there exists case that index
	column name got modified in mysql but such change does not
	propagate to InnoDB.
	One hidden assumption here is that the index column sequences
	are matched up between those in mysql and Innodb. */
	for (; key_part != key_end; ++key_part) {
		ulint	col_type;
		ibool	is_unsigned;
		ulint	mtype = innodb_idx_fld->col->mtype;

		/* Need to translate to InnoDB column type before
		comparison. */
		col_type = get_innobase_type_from_mysql_type(&is_unsigned,
							     key_part->field);

		/* Ignore Innodb specific system columns. */
		while (mtype == DATA_SYS) {
			innodb_idx_fld++;

			if (innodb_idx_fld >= innodb_idx_fld_end) {
				DBUG_RETURN(FALSE);
			}
		}

		if (col_type != mtype) {
			/* Column Type mismatches */
			DBUG_RETURN(FALSE);
		}

		innodb_idx_fld++;
	}

	DBUG_RETURN(TRUE);
}

/*******************************************************************//**
This function builds a translation table in INNOBASE_SHARE
structure for fast index location with mysql array number from its
table->key_info structure. This also provides the necessary translation
between the key order in mysql key_info and Innodb ib_table->indexes if
they are not fully matched with each other.
Note we do not have any mutex protecting the translation table
building based on the assumption that there is no concurrent
index creation/drop and DMLs that requires index lookup. All table
handle will be closed before the index creation/drop.
@return TRUE if index translation table built successfully */
static
ibool
innobase_build_index_translation(
/*=============================*/
	const TABLE*		table,	  /*!< in: table in MySQL data
					  dictionary */
	dict_table_t*		ib_table, /*!< in: table in Innodb data
					  dictionary */
	INNOBASE_SHARE*		share)	  /*!< in/out: share structure
					  where index translation table
					  will be constructed in. */
{
	ulint		mysql_num_index;
	ulint		ib_num_index;
	dict_index_t**	index_mapping;
	ibool		ret = TRUE;

	DBUG_ENTER("innobase_build_index_translation");

irana's avatar
irana committed
3356 3357
	mutex_enter(&dict_sys->mutex);

3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
	mysql_num_index = table->s->keys;
	ib_num_index = UT_LIST_GET_LEN(ib_table->indexes);

	index_mapping = share->idx_trans_tbl.index_mapping;

	/* If there exists inconsistency between MySQL and InnoDB dictionary
	(metadata) information, the number of index defined in MySQL
	could exceed that in InnoDB, do not build index translation
	table in such case */
	if (UNIV_UNLIKELY(ib_num_index < mysql_num_index)) {
		ret = FALSE;
		goto func_exit;
	}

	/* If index entry count is non-zero, nothing has
	changed since last update, directly return TRUE */
	if (share->idx_trans_tbl.index_count) {
		/* Index entry count should still match mysql_num_index */
		ut_a(share->idx_trans_tbl.index_count == mysql_num_index);
		goto func_exit;
	}

	/* The number of index increased, rebuild the mapping table */
	if (mysql_num_index > share->idx_trans_tbl.array_size) {
		index_mapping = (dict_index_t**) my_realloc(index_mapping,
							mysql_num_index *
							sizeof(*index_mapping),
							MYF(MY_ALLOW_ZERO_PTR));

		if (!index_mapping) {
irana's avatar
irana committed
3388 3389 3390 3391 3392 3393 3394
			/* Report an error if index_mapping continues to be
			NULL and mysql_num_index is a non-zero value */
			sql_print_error("InnoDB: fail to allocate memory for "
					"index translation table. Number of "
					"Index:%lu, array size:%lu",
					mysql_num_index,
					share->idx_trans_tbl.array_size);
3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446
			ret = FALSE;
			goto func_exit;
		}

		share->idx_trans_tbl.array_size = mysql_num_index;
	}

	/* For each index in the mysql key_info array, fetch its
	corresponding InnoDB index pointer into index_mapping
	array. */
	for (ulint count = 0; count < mysql_num_index; count++) {

		/* Fetch index pointers into index_mapping according to mysql
		index sequence */
		index_mapping[count] = dict_table_get_index_on_name(
			ib_table, table->key_info[count].name);

		if (!index_mapping[count]) {
			sql_print_error("Cannot find index %s in InnoDB "
					"index dictionary.",
					table->key_info[count].name);
			ret = FALSE;
			goto func_exit;
		}

		/* Double check fetched index has the same
		column info as those in mysql key_info. */
		if (!innobase_match_index_columns(&table->key_info[count],
					          index_mapping[count])) {
			sql_print_error("Found index %s whose column info "
					"does not match that of MySQL.",
					table->key_info[count].name);
			ret = FALSE;
			goto func_exit;
		}
	}

	/* Successfully built the translation table */
	share->idx_trans_tbl.index_count = mysql_num_index;

func_exit:
	if (!ret) {
		/* Build translation table failed. */
		my_free(index_mapping, MYF(MY_ALLOW_ZERO_PTR));

		share->idx_trans_tbl.array_size = 0;
		share->idx_trans_tbl.index_count = 0;
		index_mapping = NULL;
	}

	share->idx_trans_tbl.index_mapping = index_mapping;

irana's avatar
irana committed
3447 3448
	mutex_exit(&dict_sys->mutex);

3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477
	DBUG_RETURN(ret);
}

/*******************************************************************//**
This function uses index translation table to quickly locate the
requested index structure.
Note we do not have mutex protection for the index translatoin table
access, it is based on the assumption that there is no concurrent
translation table rebuild (fter create/drop index) and DMLs that
require index lookup.
@return dict_index_t structure for requested index. NULL if
fail to locate the index structure. */
static
dict_index_t*
innobase_index_lookup(
/*==================*/
	INNOBASE_SHARE*	share,	/*!< in: share structure for index
				translation table. */
	uint		keynr)	/*!< in: index number for the requested
				index */
{
	if (!share->idx_trans_tbl.index_mapping
	    || keynr >= share->idx_trans_tbl.index_count) {
		return(NULL);
	}

	return(share->idx_trans_tbl.index_mapping[keynr]);
}

3478
/************************************************************************
3479
Set the autoinc column max value. This should only be called once from
3480
ha_innobase::open(). Therefore there's no need for a covering lock. */
3481
UNIV_INTERN
3482
void
3483 3484 3485 3486
ha_innobase::innobase_initialize_autoinc()
/*======================================*/
{
	ulonglong	auto_inc;
3487
	const Field*	field = table->found_next_number_field;
3488

3489 3490 3491 3492
	if (field != NULL) {
		auto_inc = innobase_get_int_col_max_value(field);
	} else {
		/* We have no idea what's been passed in to us as the
3493 3494 3495
		autoinc column. We set it to the 0, effectively disabling
		updates to the table. */
		auto_inc = 0;
3496 3497

		ut_print_timestamp(stderr);
3498 3499 3500
		fprintf(stderr, "  InnoDB: Unable to determine the AUTOINC "
				"column name\n");
	}
3501

3502 3503
	if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
		/* If the recovery level is set so high that writes
3504
		are disabled we force the AUTOINC counter to 0
3505 3506 3507 3508 3509 3510 3511 3512
		value effectively disabling writes to the table.
		Secondly, we avoid reading the table in case the read
		results in failure due to a corrupted table/index.

		We will not return an error to the client, so that the
		tables can be dumped with minimal hassle.  If an error
		were returned in this case, the first attempt to read
		the table would fail and subsequent SELECTs would succeed. */
3513
		auto_inc = 0;
3514
	} else if (field == NULL) {
3515 3516
		/* This is a far more serious error, best to avoid
		opening the table and return failure. */
3517 3518 3519 3520 3521 3522 3523 3524
		my_error(ER_AUTOINC_READ_FAILED, MYF(0));
	} else {
		dict_index_t*	index;
		const char*	col_name;
		ulonglong	read_auto_inc;
		ulint		err;

		update_thd(ha_thd());
3525 3526 3527

		ut_a(prebuilt->trx == thd_to_trx(user_thd));

3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547
		col_name = field->field_name;
		index = innobase_get_index(table->s->next_number_index);

		/* Execute SELECT MAX(col_name) FROM TABLE; */
		err = row_search_max_autoinc(index, col_name, &read_auto_inc);

		switch (err) {
		case DB_SUCCESS:
			/* At the this stage we do not know the increment
			or the offset, so use a default increment of 1. */
			auto_inc = read_auto_inc + 1;
			break;

		case DB_RECORD_NOT_FOUND:
			ut_print_timestamp(stderr);
			fprintf(stderr, "  InnoDB: MySQL and InnoDB data "
				"dictionaries are out of sync.\n"
				"InnoDB: Unable to find the AUTOINC column "
				"%s in the InnoDB table %s.\n"
				"InnoDB: We set the next AUTOINC column "
3548
				"value to 0,\n"
3549 3550 3551 3552 3553 3554 3555 3556
				"InnoDB: in effect disabling the AUTOINC "
				"next value generation.\n"
				"InnoDB: You can either set the next "
				"AUTOINC value explicitly using ALTER TABLE\n"
				"InnoDB: or fix the data dictionary by "
				"recreating the table.\n",
				col_name, index->table->name);

3557 3558 3559 3560 3561 3562 3563
			/* This will disable the AUTOINC generation. */
			auto_inc = 0;

			/* We want the open to succeed, so that the user can
			take corrective action. ie. reads should succeed but
			updates should fail. */
			err = DB_SUCCESS;
3564 3565 3566 3567 3568 3569
			break;
		default:
			/* row_search_max_autoinc() should only return
			one of DB_SUCCESS or DB_RECORD_NOT_FOUND. */
			ut_error;
		}
3570 3571
	}

3572
	dict_table_autoinc_initialize(prebuilt->table, auto_inc);
3573 3574
}

3575
/*****************************************************************//**
osku's avatar
osku committed
3576
Creates and opens a handle to a table which already exists in an InnoDB
3577 3578
database.
@return	1 if error, 0 if success */
3579
UNIV_INTERN
osku's avatar
osku committed
3580 3581 3582
int
ha_innobase::open(
/*==============*/
3583 3584 3585
	const char*	name,		/*!< in: table name */
	int		mode,		/*!< in: not used */
	uint		test_if_locked)	/*!< in: not used */
osku's avatar
osku committed
3586 3587
{
	dict_table_t*	ib_table;
3588
	char		norm_name[1000];
osku's avatar
osku committed
3589
	THD*		thd;
3590 3591
	ulint		retries = 0;
	char*		is_part = NULL;
osku's avatar
osku committed
3592 3593 3594 3595 3596 3597

	DBUG_ENTER("ha_innobase::open");

	UT_NOT_USED(mode);
	UT_NOT_USED(test_if_locked);

3598
	thd = ha_thd();
3599 3600 3601 3602 3603 3604 3605 3606

	/* Under some cases MySQL seems to call this function while
	holding btr_search_latch. This breaks the latching order as
	we acquire dict_sys->mutex below and leads to a deadlock. */
	if (thd != NULL) {
		innobase_release_temporary_latches(ht, thd);
	}

osku's avatar
osku committed
3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623
	normalize_table_name(norm_name, name);

	user_thd = NULL;

	if (!(share=get_share(name))) {

		DBUG_RETURN(1);
	}

	/* Create buffers for packing the fields of a record. Why
	table->reclength did not work here? Obviously, because char
	fields when packed actually became 1 byte longer, when we also
	stored the string length as the first byte. */

	upd_and_key_val_buff_len =
				table->s->reclength + table->s->max_key_length
							+ MAX_REF_PARTS * 3;
3624
	if (!(uchar*) my_multi_malloc(MYF(MY_WME),
3625 3626 3627 3628
			&upd_buff, upd_and_key_val_buff_len,
			&key_val_buff, upd_and_key_val_buff_len,
			NullS)) {
		free_share(share);
osku's avatar
osku committed
3629

3630 3631
		DBUG_RETURN(1);
	}
osku's avatar
osku committed
3632

3633 3634 3635 3636 3637 3638 3639
	/* We look for pattern #P# to see if the table is partitioned
	MySQL table. The retry logic for partitioned tables is a
	workaround for http://bugs.mysql.com/bug.php?id=33349. Look
	at support issue https://support.mysql.com/view.php?id=21080
	for more details. */
	is_part = strstr(norm_name, "#P#");
retry:
osku's avatar
osku committed
3640
	/* Get pointer to a table object in InnoDB dictionary cache */
3641
	ib_table = dict_table_get(norm_name, TRUE);
3642
	
3643
	if (NULL == ib_table) {
3644 3645 3646 3647 3648 3649 3650 3651
		if (is_part && retries < 10) {
			++retries;
			os_thread_sleep(100000);
			goto retry;
		}

		if (is_part) {
			sql_print_error("Failed to open table %s after "
3652
					"%lu attempts.\n", norm_name,
3653 3654 3655
					retries);
		}

3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667
		sql_print_error("Cannot find or open table %s from\n"
				"the internal data dictionary of InnoDB "
				"though the .frm file for the\n"
				"table exists. Maybe you have deleted and "
				"recreated InnoDB data\n"
				"files but have forgotten to delete the "
				"corresponding .frm files\n"
				"of InnoDB tables, or you have moved .frm "
				"files to another database?\n"
				"or, the table contains indexes that this "
				"version of the engine\n"
				"doesn't support.\n"
3668
				"See " REFMAN "innodb-troubleshooting.html\n"
osku's avatar
osku committed
3669 3670
				"how you can resolve the problem.\n",
				norm_name);
3671
		free_share(share);
3672
		my_free(upd_buff, MYF(0));
3673
		my_errno = ENOENT;
osku's avatar
osku committed
3674

3675 3676
		DBUG_RETURN(HA_ERR_NO_SUCH_TABLE);
	}
osku's avatar
osku committed
3677

3678
	if (ib_table->ibd_file_missing && !thd_tablespace_op(thd)) {
osku's avatar
osku committed
3679 3680 3681 3682 3683
		sql_print_error("MySQL is trying to open a table handle but "
				"the .ibd file for\ntable %s does not exist.\n"
				"Have you deleted the .ibd file from the "
				"database directory under\nthe MySQL datadir, "
				"or have you used DISCARD TABLESPACE?\n"
3684
				"See " REFMAN "innodb-troubleshooting.html\n"
osku's avatar
osku committed
3685 3686
				"how you can resolve the problem.\n",
				norm_name);
3687
		free_share(share);
3688
		my_free(upd_buff, MYF(0));
3689
		my_errno = ENOENT;
osku's avatar
osku committed
3690

3691
		dict_table_decrement_handle_count(ib_table, FALSE);
3692 3693
		DBUG_RETURN(HA_ERR_NO_SUCH_TABLE);
	}
osku's avatar
osku committed
3694

3695
	prebuilt = row_create_prebuilt(ib_table);
osku's avatar
osku committed
3696

3697
	prebuilt->mysql_row_len = table->s->reclength;
3698 3699
	prebuilt->default_rec = table->s->default_values;
	ut_ad(prebuilt->default_rec);
osku's avatar
osku committed
3700 3701 3702

	/* Looks like MySQL-3.23 sometimes has primary key number != 0 */

3703
	primary_key = table->s->primary_key;
osku's avatar
osku committed
3704 3705
	key_used_on_scan = primary_key;

3706 3707 3708 3709 3710
	if (!innobase_build_index_translation(table, ib_table, share)) {
		  sql_print_error("Build InnoDB index translation table for"
				  " Table %s failed", name);
	}

osku's avatar
osku committed
3711 3712
	/* Allocate a buffer for a 'row reference'. A row reference is
	a string of bytes of length ref_length which uniquely specifies
3713 3714 3715
	a row in our table. Note that MySQL may also compare two row
	references for equality by doing a simple memcmp on the strings
	of length ref_length! */
osku's avatar
osku committed
3716

3717
	if (!row_table_got_default_clust_index(ib_table)) {
osku's avatar
osku committed
3718

3719 3720
		prebuilt->clust_index_was_generated = FALSE;

3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771
		if (UNIV_UNLIKELY(primary_key >= MAX_KEY)) {
			sql_print_error("Table %s has a primary key in "
					"InnoDB data dictionary, but not "
					"in MySQL!", name);

			/* This mismatch could cause further problems
			if not attended, bring this to the user's attention
			by printing a warning in addition to log a message
			in the errorlog */
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
					    ER_NO_SUCH_INDEX,
					    "InnoDB: Table %s has a "
					    "primary key in InnoDB data "
					    "dictionary, but not in "
					    "MySQL!", name);

			/* If primary_key >= MAX_KEY, its (primary_key)
			value could be out of bound if continue to index
			into key_info[] array. Find InnoDB primary index,
			and assign its key_length to ref_length.
			In addition, since MySQL indexes are sorted starting
			with primary index, unique index etc., initialize
			ref_length to the first index key length in
			case we fail to find InnoDB cluster index.

			Please note, this will not resolve the primary
			index mismatch problem, other side effects are
			possible if users continue to use the table.
			However, we allow this table to be opened so
			that user can adopt necessary measures for the
			mismatch while still being accessible to the table
			date. */
			ref_length = table->key_info[0].key_length;

			/* Find correspoinding cluster index
			key length in MySQL's key_info[] array */
			for (ulint i = 0; i < table->s->keys; i++) {
				dict_index_t*	index;
				index = innobase_get_index(i);
				if (dict_index_is_clust(index)) {
					ref_length =
						 table->key_info[i].key_length;
				}
			}
		} else {
			/* MySQL allocates the buffer for ref.
			key_info->key_length includes space for all key
			columns + one byte for each column that may be
			NULL. ref_length must be as exact as possible to
			save space, because all row reference buffers are
			allocated based on ref_length. */
3772

3773 3774
			ref_length = table->key_info[primary_key].key_length;
		}
osku's avatar
osku committed
3775
	} else {
3776
		if (primary_key != MAX_KEY) {
3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797
			sql_print_error(
				"Table %s has no primary key in InnoDB data "
				"dictionary, but has one in MySQL! If you "
				"created the table with a MySQL version < "
				"3.23.54 and did not define a primary key, "
				"but defined a unique key with all non-NULL "
				"columns, then MySQL internally treats that "
				"key as the primary key. You can fix this "
				"error by dump + DROP + CREATE + reimport "
				"of the table.", name);

			/* This mismatch could cause further problems
			if not attended, bring this to the user attention
			by printing a warning in addition to log a message
			in the errorlog */
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
					    ER_NO_SUCH_INDEX,
					    "InnoDB: Table %s has no "
					    "primary key in InnoDB data "
					    "dictionary, but has one in "
					    "MySQL!", name);
osku's avatar
osku committed
3798 3799
		}

3800
		prebuilt->clust_index_was_generated = TRUE;
osku's avatar
osku committed
3801

3802
		ref_length = DATA_ROW_ID_LEN;
osku's avatar
osku committed
3803 3804 3805 3806 3807 3808 3809 3810

		/* If we automatically created the clustered index, then
		MySQL does not know about it, and MySQL must NOT be aware
		of the index used on scan, to make it avoid checking if we
		update the column of the index. That is why we assert below
		that key_used_on_scan is the undefined value MAX_KEY.
		The column is the row id in the automatical generation case,
		and it will never be updated anyway. */
3811

osku's avatar
osku committed
3812
		if (key_used_on_scan != MAX_KEY) {
3813 3814 3815 3816
			sql_print_warning(
				"Table %s key_used_on_scan is %lu even "
				"though there is no primary key inside "
				"InnoDB.", name, (ulong) key_used_on_scan);
osku's avatar
osku committed
3817 3818 3819
		}
	}

3820 3821
	/* Index block size in InnoDB: used by MySQL in query optimization */
	stats.block_size = 16 * 1024;
osku's avatar
osku committed
3822 3823 3824 3825

	/* Init table lock structure */
	thr_lock_data_init(&share->lock,&lock,(void*) 0);

3826 3827 3828 3829
	if (prebuilt->table) {
		/* We update the highest file format in the system table
		space, if this table has higher file format setting. */

3830 3831 3832
		trx_sys_file_format_max_upgrade(
			(const char**) &innobase_file_format_check,
			dict_table_get_format(prebuilt->table));
3833 3834
	}

3835
	info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
osku's avatar
osku committed
3836

3837 3838 3839 3840 3841 3842 3843 3844 3845 3846
	/* Only if the table has an AUTOINC column. */
	if (prebuilt->table != NULL && table->found_next_number_field != NULL) {
		dict_table_autoinc_lock(prebuilt->table);

		/* Since a table can already be "open" in InnoDB's internal
		data dictionary, we only init the autoinc counter once, the
		first time the table is loaded. We can safely reuse the
		autoinc value from a previous MySQL open. */
		if (dict_table_autoinc_read(prebuilt->table) == 0) {

3847
			innobase_initialize_autoinc();
3848 3849 3850 3851 3852
		}

		dict_table_autoinc_unlock(prebuilt->table);
	}

3853
	DBUG_RETURN(0);
osku's avatar
osku committed
3854 3855
}

3856
UNIV_INTERN
3857 3858 3859 3860 3861 3862
uint
ha_innobase::max_supported_key_part_length() const
{
	return(DICT_MAX_INDEX_COL_LEN - 1);
}

3863
/******************************************************************//**
3864 3865
Closes a handle to an InnoDB table.
@return	0 */
3866
UNIV_INTERN
osku's avatar
osku committed
3867 3868 3869 3870
int
ha_innobase::close(void)
/*====================*/
{
3871 3872
	THD*	thd;

3873
	DBUG_ENTER("ha_innobase::close");
osku's avatar
osku committed
3874

3875
	thd = ha_thd();
3876 3877 3878 3879
	if (thd != NULL) {
		innobase_release_temporary_latches(ht, thd);
	}

3880
	row_prebuilt_free(prebuilt, FALSE);
osku's avatar
osku committed
3881

3882
	my_free(upd_buff, MYF(0));
3883
	free_share(share);
osku's avatar
osku committed
3884 3885 3886 3887 3888 3889

	/* Tell InnoDB server that there might be work for
	utility threads: */

	srv_active_wake_master_thread();

3890
	DBUG_RETURN(0);
osku's avatar
osku committed
3891 3892 3893 3894
}

/* The following accessor functions should really be inside MySQL code! */

3895
/**************************************************************//**
3896 3897
Gets field offset for a field in a table.
@return	offset */
3898
static inline
osku's avatar
osku committed
3899 3900 3901
uint
get_field_offset(
/*=============*/
3902 3903
	TABLE*	table,	/*!< in: MySQL table object */
	Field*	field)	/*!< in: MySQL field object */
osku's avatar
osku committed
3904
{
3905
	return((uint) (field->ptr - table->record[0]));
osku's avatar
osku committed
3906 3907
}

3908
/**************************************************************//**
osku's avatar
osku committed
3909
Checks if a field in a record is SQL NULL. Uses the record format
3910 3911
information in table to track the null bit in record.
@return	1 if NULL, 0 otherwise */
3912
static inline
osku's avatar
osku committed
3913 3914 3915
uint
field_in_record_is_null(
/*====================*/
3916 3917 3918
	TABLE*	table,	/*!< in: MySQL table object */
	Field*	field,	/*!< in: MySQL field object */
	char*	record)	/*!< in: a row in MySQL format */
osku's avatar
osku committed
3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937
{
	int	null_offset;

	if (!field->null_ptr) {

		return(0);
	}

	null_offset = (uint) ((char*) field->null_ptr
					- (char*) table->record[0]);

	if (record[null_offset] & field->null_bit) {

		return(1);
	}

	return(0);
}

3938
/**************************************************************//**
osku's avatar
osku committed
3939 3940
Sets a field in a record to SQL NULL. Uses the record format
information in table to track the null bit in record. */
3941
static inline
osku's avatar
osku committed
3942 3943 3944
void
set_field_in_record_to_null(
/*========================*/
3945 3946 3947
	TABLE*	table,	/*!< in: MySQL table object */
	Field*	field,	/*!< in: MySQL field object */
	char*	record)	/*!< in: a row in MySQL format */
osku's avatar
osku committed
3948 3949 3950 3951 3952 3953 3954 3955 3956
{
	int	null_offset;

	null_offset = (uint) ((char*) field->null_ptr
					- (char*) table->record[0]);

	record[null_offset] = record[null_offset] | field->null_bit;
}

3957
/*************************************************************//**
osku's avatar
osku committed
3958 3959 3960
InnoDB uses this function to compare two data fields for which the data type
is such that we must use MySQL code to compare them. NOTE that the prototype
of this function is in rem0cmp.c in InnoDB source code! If you change this
3961 3962
function, remember to update the prototype there!
@return	1, 0, -1, if a is greater, equal, less than b, respectively */
3963
extern "C" UNIV_INTERN
osku's avatar
osku committed
3964 3965 3966
int
innobase_mysql_cmp(
/*===============*/
3967 3968 3969 3970
	int		mysql_type,	/*!< in: MySQL type */
	uint		charset_number,	/*!< in: number of the charset */
	const unsigned char* a,		/*!< in: data field */
	unsigned int	a_length,	/*!< in: data field length,
osku's avatar
osku committed
3971
					not UNIV_SQL_NULL */
3972 3973
	const unsigned char* b,		/*!< in: data field */
	unsigned int	b_length)	/*!< in: data field length,
osku's avatar
osku committed
3974 3975 3976 3977
					not UNIV_SQL_NULL */
{
	CHARSET_INFO*		charset;
	enum_field_types	mysql_tp;
3978
	int			ret;
osku's avatar
osku committed
3979 3980 3981 3982 3983 3984 3985 3986

	DBUG_ASSERT(a_length != UNIV_SQL_NULL);
	DBUG_ASSERT(b_length != UNIV_SQL_NULL);

	mysql_tp = (enum_field_types) mysql_type;

	switch (mysql_tp) {

3987
	case MYSQL_TYPE_BIT:
osku's avatar
osku committed
3988 3989
	case MYSQL_TYPE_STRING:
	case MYSQL_TYPE_VAR_STRING:
3990 3991 3992 3993
	case MYSQL_TYPE_TINY_BLOB:
	case MYSQL_TYPE_MEDIUM_BLOB:
	case MYSQL_TYPE_BLOB:
	case MYSQL_TYPE_LONG_BLOB:
3994
	case MYSQL_TYPE_VARCHAR:
osku's avatar
osku committed
3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015
		/* Use the charset number to pick the right charset struct for
		the comparison. Since the MySQL function get_charset may be
		slow before Bar removes the mutex operation there, we first
		look at 2 common charsets directly. */

		if (charset_number == default_charset_info->number) {
			charset = default_charset_info;
		} else if (charset_number == my_charset_latin1.number) {
			charset = &my_charset_latin1;
		} else {
			charset = get_charset(charset_number, MYF(MY_WME));

			if (charset == NULL) {
			  sql_print_error("InnoDB needs charset %lu for doing "
					  "a comparison, but MySQL cannot "
					  "find that charset.",
					  (ulong) charset_number);
				ut_a(0);
			}
		}

4016 4017 4018 4019
		/* Starting from 4.1.3, we use strnncollsp() in comparisons of
		non-latin1_swedish_ci strings. NOTE that the collation order
		changes then: 'b\0\0...' is ordered BEFORE 'b  ...'. Users
		having indexes on such data need to rebuild their tables! */
osku's avatar
osku committed
4020

4021 4022 4023
		ret = charset->coll->strnncollsp(charset,
				  a, a_length,
						 b, b_length, 0);
osku's avatar
osku committed
4024
		if (ret < 0) {
4025
			return(-1);
osku's avatar
osku committed
4026
		} else if (ret > 0) {
4027
			return(1);
osku's avatar
osku committed
4028
		} else {
4029 4030
			return(0);
		}
osku's avatar
osku committed
4031
	default:
4032
		ut_error;
osku's avatar
osku committed
4033 4034 4035 4036 4037
	}

	return(0);
}

4038
/**************************************************************//**
osku's avatar
osku committed
4039 4040
Converts a MySQL type to an InnoDB type. Note that this function returns
the 'mtype' of InnoDB. InnoDB differentiates between MySQL's old <= 4.1
4041 4042
VARCHAR and the new true VARCHAR in >= 5.0.3 by the 'prtype'.
@return	DATA_BINARY, DATA_VARCHAR, ... */
4043
extern "C" UNIV_INTERN
osku's avatar
osku committed
4044 4045 4046
ulint
get_innobase_type_from_mysql_type(
/*==============================*/
4047
	ulint*		unsigned_flag,	/*!< out: DATA_UNSIGNED if an
4048 4049 4050 4051
					'unsigned type';
					at least ENUM and SET,
					and unsigned integer
					types are 'unsigned types' */
4052
	const void*	f)		/*!< in: MySQL Field */
osku's avatar
osku committed
4053
{
4054 4055
	const class Field* field = reinterpret_cast<const class Field*>(f);

osku's avatar
osku committed
4056 4057 4058 4059
	/* The following asserts try to check that the MySQL type code fits in
	8 bits: this is used in ibuf and also when DATA_NOT_NULL is ORed to
	the type */

4060 4061 4062 4063 4064
	DBUG_ASSERT((ulint)MYSQL_TYPE_STRING < 256);
	DBUG_ASSERT((ulint)MYSQL_TYPE_VAR_STRING < 256);
	DBUG_ASSERT((ulint)MYSQL_TYPE_DOUBLE < 256);
	DBUG_ASSERT((ulint)MYSQL_TYPE_FLOAT < 256);
	DBUG_ASSERT((ulint)MYSQL_TYPE_DECIMAL < 256);
osku's avatar
osku committed
4065 4066 4067 4068 4069 4070 4071 4072

	if (field->flags & UNSIGNED_FLAG) {

		*unsigned_flag = DATA_UNSIGNED;
	} else {
		*unsigned_flag = 0;
	}

4073 4074
	if (field->real_type() == MYSQL_TYPE_ENUM
		|| field->real_type() == MYSQL_TYPE_SET) {
osku's avatar
osku committed
4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087

		/* MySQL has field->type() a string type for these, but the
		data is actually internally stored as an unsigned integer
		code! */

		*unsigned_flag = DATA_UNSIGNED; /* MySQL has its own unsigned
						flag set to zero, even though
						internally this is an unsigned
						integer type */
		return(DATA_INT);
	}

	switch (field->type()) {
4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111
		/* NOTE that we only allow string types in DATA_MYSQL and
		DATA_VARMYSQL */
	case MYSQL_TYPE_VAR_STRING: /* old <= 4.1 VARCHAR */
	case MYSQL_TYPE_VARCHAR:    /* new >= 5.0.3 true VARCHAR */
		if (field->binary()) {
			return(DATA_BINARY);
		} else if (strcmp(
				   field->charset()->name,
				   "latin1_swedish_ci") == 0) {
			return(DATA_VARCHAR);
		} else {
			return(DATA_VARMYSQL);
		}
	case MYSQL_TYPE_BIT:
	case MYSQL_TYPE_STRING: if (field->binary()) {

			return(DATA_FIXBINARY);
		} else if (strcmp(
				   field->charset()->name,
				   "latin1_swedish_ci") == 0) {
			return(DATA_CHAR);
		} else {
			return(DATA_MYSQL);
		}
4112
	case MYSQL_TYPE_NEWDECIMAL:
4113
		return(DATA_FIXBINARY);
4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124
	case MYSQL_TYPE_LONG:
	case MYSQL_TYPE_LONGLONG:
	case MYSQL_TYPE_TINY:
	case MYSQL_TYPE_SHORT:
	case MYSQL_TYPE_INT24:
	case MYSQL_TYPE_DATE:
	case MYSQL_TYPE_DATETIME:
	case MYSQL_TYPE_YEAR:
	case MYSQL_TYPE_NEWDATE:
	case MYSQL_TYPE_TIME:
	case MYSQL_TYPE_TIMESTAMP:
4125
		return(DATA_INT);
4126
	case MYSQL_TYPE_FLOAT:
4127
		return(DATA_FLOAT);
4128
	case MYSQL_TYPE_DOUBLE:
4129
		return(DATA_DOUBLE);
4130
	case MYSQL_TYPE_DECIMAL:
4131
		return(DATA_DECIMAL);
4132 4133 4134 4135 4136
	case MYSQL_TYPE_GEOMETRY:
	case MYSQL_TYPE_TINY_BLOB:
	case MYSQL_TYPE_MEDIUM_BLOB:
	case MYSQL_TYPE_BLOB:
	case MYSQL_TYPE_LONG_BLOB:
4137 4138
		return(DATA_BLOB);
	default:
4139
		ut_error;
osku's avatar
osku committed
4140 4141 4142 4143 4144
	}

	return(0);
}

4145
/*******************************************************************//**
osku's avatar
osku committed
4146 4147
Writes an unsigned integer value < 64k to 2 bytes, in the little-endian
storage format. */
4148
static inline
osku's avatar
osku committed
4149 4150 4151
void
innobase_write_to_2_little_endian(
/*==============================*/
4152 4153
	byte*	buf,	/*!< in: where to store */
	ulint	val)	/*!< in: value to write, must be < 64k */
osku's avatar
osku committed
4154 4155 4156 4157 4158 4159 4160
{
	ut_a(val < 256 * 256);

	buf[0] = (byte)(val & 0xFF);
	buf[1] = (byte)(val / 256);
}

4161
/*******************************************************************//**
osku's avatar
osku committed
4162
Reads an unsigned integer value < 64k from 2 bytes, in the little-endian
4163 4164
storage format.
@return	value */
4165
static inline
osku's avatar
osku committed
4166 4167 4168
uint
innobase_read_from_2_little_endian(
/*===============================*/
4169
	const uchar*	buf)	/*!< in: from where to read */
osku's avatar
osku committed
4170 4171 4172 4173
{
	return (uint) ((ulint)(buf[0]) + 256 * ((ulint)(buf[1])));
}

4174
/*******************************************************************//**
4175 4176
Stores a key value for a row to a buffer.
@return	key value length as stored in buff */
4177
UNIV_INTERN
osku's avatar
osku committed
4178 4179 4180
uint
ha_innobase::store_key_val_for_row(
/*===============================*/
4181 4182
	uint		keynr,	/*!< in: key number */
	char*		buff,	/*!< in/out: buffer for the key value (in MySQL
osku's avatar
osku committed
4183
				format) */
4184 4185
	uint		buff_len,/*!< in: buffer length */
	const uchar*	record)/*!< in: row in MySQL format */
osku's avatar
osku committed
4186
{
4187 4188 4189
	KEY*		key_info	= table->key_info + keynr;
	KEY_PART_INFO*	key_part	= key_info->key_part;
	KEY_PART_INFO*	end		= key_part + key_info->key_parts;
osku's avatar
osku committed
4190 4191 4192 4193 4194
	char*		buff_start	= buff;
	enum_field_types mysql_type;
	Field*		field;
	ibool		is_null;

4195
	DBUG_ENTER("store_key_val_for_row");
osku's avatar
osku committed
4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223

	/* The format for storing a key field in MySQL is the following:

	1. If the column can be NULL, then in the first byte we put 1 if the
	field value is NULL, 0 otherwise.

	2. If the column is of a BLOB type (it must be a column prefix field
	in this case), then we put the length of the data in the field to the
	next 2 bytes, in the little-endian format. If the field is SQL NULL,
	then these 2 bytes are set to 0. Note that the length of data in the
	field is <= column prefix length.

	3. In a column prefix field, prefix_len next bytes are reserved for
	data. In a normal field the max field length next bytes are reserved
	for data. For a VARCHAR(n) the max field length is n. If the stored
	value is the SQL NULL then these data bytes are set to 0.

	4. We always use a 2 byte length for a true >= 5.0.3 VARCHAR. Note that
	in the MySQL row format, the length is stored in 1 or 2 bytes,
	depending on the maximum allowed length. But in the MySQL key value
	format, the length always takes 2 bytes.

	We have to zero-fill the buffer so that MySQL is able to use a
	simple memcmp to compare two key values to determine if they are
	equal. MySQL does this to compare contents of two 'ref' values. */

	bzero(buff, buff_len);

4224 4225
	for (; key_part != end; key_part++) {
		is_null = FALSE;
osku's avatar
osku committed
4226

4227 4228
		if (key_part->null_bit) {
			if (record[key_part->null_offset]
osku's avatar
osku committed
4229 4230 4231
						& key_part->null_bit) {
				*buff = 1;
				is_null = TRUE;
4232
			} else {
osku's avatar
osku committed
4233 4234 4235
				*buff = 0;
			}
			buff++;
4236
		}
osku's avatar
osku committed
4237 4238 4239 4240 4241 4242

		field = key_part->field;
		mysql_type = field->type();

		if (mysql_type == MYSQL_TYPE_VARCHAR) {
						/* >= 5.0.3 true VARCHAR */
4243 4244 4245 4246 4247
			ulint		lenlen;
			ulint		len;
			const byte*	data;
			ulint		key_len;
			ulint		true_len;
osku's avatar
osku committed
4248
			CHARSET_INFO*	cs;
4249
			int		error=0;
osku's avatar
osku committed
4250

4251 4252
			key_len = key_part->length;

osku's avatar
osku committed
4253
			if (is_null) {
4254
				buff += key_len + 2;
4255

osku's avatar
osku committed
4256 4257
				continue;
			}
4258
			cs = field->charset();
osku's avatar
osku committed
4259 4260 4261 4262

			lenlen = (ulint)
				(((Field_varstring*)field)->length_bytes);

4263
			data = row_mysql_read_true_varchar(&len,
osku's avatar
osku committed
4264 4265 4266 4267
				(byte*) (record
				+ (ulint)get_field_offset(table, field)),
				lenlen);

4268 4269 4270 4271 4272 4273 4274 4275 4276
			true_len = len;

			/* For multi byte character sets we need to calculate
			the true length of the key */

			if (len > 0 && cs->mbmaxlen > 1) {
				true_len = (ulint) cs->cset->well_formed_len(cs,
						(const char *) data,
						(const char *) data + len,
4277 4278
                                                (uint) (key_len /
                                                        cs->mbmaxlen),
4279 4280 4281
						&error);
			}

osku's avatar
osku committed
4282 4283 4284
			/* In a column prefix index, we may need to truncate
			the stored value: */

4285 4286
			if (true_len > key_len) {
				true_len = key_len;
osku's avatar
osku committed
4287 4288 4289 4290 4291
			}

			/* The length in a key value is always stored in 2
			bytes */

4292
			row_mysql_store_true_var_len((byte*)buff, true_len, 2);
osku's avatar
osku committed
4293 4294
			buff += 2;

4295
			memcpy(buff, data, true_len);
osku's avatar
osku committed
4296 4297 4298 4299 4300 4301 4302

			/* Note that we always reserve the maximum possible
			length of the true VARCHAR in the key value, though
			only len first bytes after the 2 length bytes contain
			actual data. The rest of the space was reset to zero
			in the bzero() call above. */

4303
			buff += key_len;
osku's avatar
osku committed
4304

4305 4306 4307
		} else if (mysql_type == MYSQL_TYPE_TINY_BLOB
			|| mysql_type == MYSQL_TYPE_MEDIUM_BLOB
			|| mysql_type == MYSQL_TYPE_BLOB
4308 4309 4310 4311
			|| mysql_type == MYSQL_TYPE_LONG_BLOB
			/* MYSQL_TYPE_GEOMETRY data is treated
			as BLOB data in innodb. */
			|| mysql_type == MYSQL_TYPE_GEOMETRY) {
osku's avatar
osku committed
4312 4313 4314

			CHARSET_INFO*	cs;
			ulint		key_len;
4315
			ulint		true_len;
osku's avatar
osku committed
4316
			int		error=0;
4317
			ulint		blob_len;
4318
			const byte*	blob_data;
osku's avatar
osku committed
4319 4320 4321

			ut_a(key_part->key_part_flag & HA_PART_KEY_SEG);

4322 4323
			key_len = key_part->length;

4324
			if (is_null) {
4325
				buff += key_len + 2;
4326

osku's avatar
osku committed
4327 4328
				continue;
			}
4329

4330 4331
			cs = field->charset();

4332
			blob_data = row_mysql_read_blob_ref(&blob_len,
osku's avatar
osku committed
4333 4334 4335 4336
				(byte*) (record
				+ (ulint)get_field_offset(table, field)),
					(ulint) field->pack_length());

4337 4338
			true_len = blob_len;

osku's avatar
osku committed
4339
			ut_a(get_field_offset(table, field)
4340
				== key_part->offset);
osku's avatar
osku committed
4341

4342 4343
			/* For multi byte character sets we need to calculate
			the true length of the key */
4344

4345 4346 4347
			if (blob_len > 0 && cs->mbmaxlen > 1) {
				true_len = (ulint) cs->cset->well_formed_len(cs,
						(const char *) blob_data,
4348
						(const char *) blob_data
4349
							+ blob_len,
4350 4351
                                                (uint) (key_len /
                                                        cs->mbmaxlen),
4352 4353 4354
						&error);
			}

osku's avatar
osku committed
4355 4356 4357 4358
			/* All indexes on BLOB and TEXT are column prefix
			indexes, and we may need to truncate the data to be
			stored in the key value: */

4359 4360
			if (true_len > key_len) {
				true_len = key_len;
osku's avatar
osku committed
4361 4362 4363 4364 4365 4366
			}

			/* MySQL reserves 2 bytes for the length and the
			storage of the number is little-endian */

			innobase_write_to_2_little_endian(
4367
					(byte*)buff, true_len);
osku's avatar
osku committed
4368 4369
			buff += 2;

4370
			memcpy(buff, blob_data, true_len);
osku's avatar
osku committed
4371 4372 4373 4374

			/* Note that we always reserve the maximum possible
			length of the BLOB prefix in the key value. */

4375
			buff += key_len;
osku's avatar
osku committed
4376 4377 4378 4379 4380 4381 4382
		} else {
			/* Here we handle all other data types except the
			true VARCHAR, BLOB and TEXT. Note that the column
			value we store may be also in a column prefix
			index. */

			CHARSET_INFO*		cs;
4383 4384
			ulint			true_len;
			ulint			key_len;
4385
			const uchar*		src_start;
osku's avatar
osku committed
4386
			int			error=0;
4387 4388 4389
			enum_field_types	real_type;

			key_len = key_part->length;
osku's avatar
osku committed
4390

4391
			if (is_null) {
4392
				 buff += key_len;
4393

osku's avatar
osku committed
4394 4395 4396 4397
				 continue;
			}

			src_start = record + key_part->offset;
4398 4399
			real_type = field->real_type();
			true_len = key_len;
osku's avatar
osku committed
4400

4401 4402 4403 4404 4405
			/* Character set for the field is defined only
			to fields whose type is string and real field
			type is not enum or set. For these fields check
			if character set is multi byte. */

4406 4407
			if (real_type != MYSQL_TYPE_ENUM
				&& real_type != MYSQL_TYPE_SET
4408 4409 4410 4411 4412
				&& ( mysql_type == MYSQL_TYPE_VAR_STRING
					|| mysql_type == MYSQL_TYPE_STRING)) {

				cs = field->charset();

4413
				/* For multi byte character sets we need to
4414 4415 4416 4417
				calculate the true length of the key */

				if (key_len > 0 && cs->mbmaxlen > 1) {

4418
					true_len = (ulint)
4419 4420
						cs->cset->well_formed_len(cs,
							(const char *)src_start,
4421
							(const char *)src_start
4422
								+ key_len,
4423 4424
                                                        (uint) (key_len /
                                                                cs->mbmaxlen),
4425 4426
							&error);
				}
osku's avatar
osku committed
4427 4428
			}

4429 4430
			memcpy(buff, src_start, true_len);
			buff += true_len;
osku's avatar
osku committed
4431

4432 4433 4434
			/* Pad the unused space with spaces. Note that no
			padding is ever needed for UCS-2 because in MySQL,
			all UCS2 characters are 2 bytes, as MySQL does not
4435 4436
			support surrogate pairs, which are needed to represent
			characters in the range U+10000 to U+10FFFF. */
osku's avatar
osku committed
4437

4438 4439 4440 4441
			if (true_len < key_len) {
				ulint pad_len = key_len - true_len;
				memset(buff, ' ', pad_len);
				buff += pad_len;
osku's avatar
osku committed
4442 4443
			}
		}
4444
	}
osku's avatar
osku committed
4445 4446 4447 4448 4449 4450

	ut_a(buff <= buff_start + buff_len);

	DBUG_RETURN((uint)(buff - buff_start));
}

4451
/**************************************************************//**
osku's avatar
osku committed
4452 4453
Builds a 'template' to the prebuilt struct. The template is used in fast
retrieval of just those column values MySQL needs in its processing. */
4454
static
osku's avatar
osku committed
4455
void
4456
build_template(
osku's avatar
osku committed
4457
/*===========*/
4458 4459
	row_prebuilt_t*	prebuilt,	/*!< in/out: prebuilt struct */
	THD*		thd,		/*!< in: current user thread, used
osku's avatar
osku committed
4460 4461
					only if templ_type is
					ROW_MYSQL_REC_FIELDS */
4462 4463
	TABLE*		table,		/*!< in: MySQL table */
	uint		templ_type)	/*!< in: ROW_MYSQL_WHOLE_ROW or
osku's avatar
osku committed
4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482
					ROW_MYSQL_REC_FIELDS */
{
	dict_index_t*	index;
	dict_index_t*	clust_index;
	mysql_row_templ_t* templ;
	Field*		field;
	ulint		n_fields;
	ulint		n_requested_fields	= 0;
	ibool		fetch_all_in_key	= FALSE;
	ibool		fetch_primary_key_cols	= FALSE;
	ulint		i;
	/* byte offset of the end of last requested column */
	ulint		mysql_prefix_len	= 0;

	if (prebuilt->select_lock_type == LOCK_X) {
		/* We always retrieve the whole clustered index record if we
		use exclusive row level locks, for example, if the read is
		done in an UPDATE statement. */

4483
		templ_type = ROW_MYSQL_WHOLE_ROW;
osku's avatar
osku committed
4484 4485 4486
	}

	if (templ_type == ROW_MYSQL_REC_FIELDS) {
4487 4488
		if (prebuilt->hint_need_to_fetch_extra_cols
			== ROW_RETRIEVE_ALL_COLS) {
osku's avatar
osku committed
4489

4490 4491
			/* We know we must at least fetch all columns in the
			key, or all columns in the table */
osku's avatar
osku committed
4492

4493 4494 4495 4496 4497 4498 4499
			if (prebuilt->read_just_key) {
				/* MySQL has instructed us that it is enough
				to fetch the columns in the key; looks like
				MySQL can set this flag also when there is
				only a prefix of the column in the key: in
				that case we retrieve the whole column from
				the clustered index */
osku's avatar
osku committed
4500

4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514
				fetch_all_in_key = TRUE;
			} else {
				templ_type = ROW_MYSQL_WHOLE_ROW;
			}
		} else if (prebuilt->hint_need_to_fetch_extra_cols
			== ROW_RETRIEVE_PRIMARY_KEY) {
			/* We must at least fetch all primary key cols. Note
			   that if the clustered index was internally generated
			   by InnoDB on the row id (no primary key was
			   defined), then row_search_for_mysql() will always
			   retrieve the row id to a special buffer in the
			   prebuilt struct. */

			fetch_primary_key_cols = TRUE;
osku's avatar
osku committed
4515 4516 4517
		}
	}

4518
	clust_index = dict_table_get_first_index(prebuilt->table);
osku's avatar
osku committed
4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537

	if (templ_type == ROW_MYSQL_REC_FIELDS) {
		index = prebuilt->index;
	} else {
		index = clust_index;
	}

	if (index == clust_index) {
		prebuilt->need_to_access_clustered = TRUE;
	} else {
		prebuilt->need_to_access_clustered = FALSE;
		/* Below we check column by column if we need to access
		the clustered index */
	}

	n_fields = (ulint)table->s->fields; /* number of columns */

	if (!prebuilt->mysql_template) {
		prebuilt->mysql_template = (mysql_row_templ_t*)
4538
			mem_alloc(n_fields * sizeof(mysql_row_templ_t));
osku's avatar
osku committed
4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570
	}

	prebuilt->template_type = templ_type;
	prebuilt->null_bitmap_len = table->s->null_bytes;

	prebuilt->templ_contains_blob = FALSE;

	/* Note that in InnoDB, i is the column number. MySQL calls columns
	'fields'. */
	for (i = 0; i < n_fields; i++) {
		templ = prebuilt->mysql_template + n_requested_fields;
		field = table->field[i];

		if (UNIV_LIKELY(templ_type == ROW_MYSQL_REC_FIELDS)) {
			/* Decide which columns we should fetch
			and which we can skip. */
			register const ibool	index_contains_field =
				dict_index_contains_col_or_prefix(index, i);

			if (!index_contains_field && prebuilt->read_just_key) {
				/* If this is a 'key read', we do not need
				columns that are not in the key */

				goto skip_field;
			}

			if (index_contains_field && fetch_all_in_key) {
				/* This field is needed in the query */

				goto include_field;
			}

4571 4572
			if (bitmap_is_set(table->read_set, i) ||
			    bitmap_is_set(table->write_set, i)) {
osku's avatar
osku committed
4573 4574 4575 4576 4577 4578
				/* This field is needed in the query */

				goto include_field;
			}

			if (fetch_primary_key_cols
4579 4580
				&& dict_table_col_in_clustered_key(
					index->table, i)) {
osku's avatar
osku committed
4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595
				/* This field is needed in the query */

				goto include_field;
			}

			/* This field is not needed in the query, skip it */

			goto skip_field;
		}
include_field:
		n_requested_fields++;

		templ->col_no = i;

		if (index == clust_index) {
4596
			templ->rec_field_no = dict_col_get_clust_pos(
4597
				&index->table->cols[i], index);
osku's avatar
osku committed
4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625
		} else {
			templ->rec_field_no = dict_index_get_nth_col_pos(
								index, i);
		}

		if (templ->rec_field_no == ULINT_UNDEFINED) {
			prebuilt->need_to_access_clustered = TRUE;
		}

		if (field->null_ptr) {
			templ->mysql_null_byte_offset =
				(ulint) ((char*) field->null_ptr
					- (char*) table->record[0]);

			templ->mysql_null_bit_mask = (ulint) field->null_bit;
		} else {
			templ->mysql_null_bit_mask = 0;
		}

		templ->mysql_col_offset = (ulint)
					get_field_offset(table, field);

		templ->mysql_col_len = (ulint) field->pack_length();
		if (mysql_prefix_len < templ->mysql_col_offset
				+ templ->mysql_col_len) {
			mysql_prefix_len = templ->mysql_col_offset
				+ templ->mysql_col_len;
		}
4626
		templ->type = index->table->cols[i].mtype;
osku's avatar
osku committed
4627 4628 4629 4630
		templ->mysql_type = (ulint)field->type();

		if (templ->mysql_type == DATA_MYSQL_TRUE_VARCHAR) {
			templ->mysql_length_bytes = (ulint)
4631
				(((Field_varstring*)field)->length_bytes);
osku's avatar
osku committed
4632
		}
4633

4634 4635
		templ->charset = dtype_get_charset_coll(
			index->table->cols[i].prtype);
4636 4637 4638
		templ->mbminlen = index->table->cols[i].mbminlen;
		templ->mbmaxlen = index->table->cols[i].mbmaxlen;
		templ->is_unsigned = index->table->cols[i].prtype
osku's avatar
osku committed
4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655
							& DATA_UNSIGNED;
		if (templ->type == DATA_BLOB) {
			prebuilt->templ_contains_blob = TRUE;
		}
skip_field:
		;
	}

	prebuilt->n_template = n_requested_fields;
	prebuilt->mysql_prefix_len = mysql_prefix_len;

	if (index != clust_index && prebuilt->need_to_access_clustered) {
		/* Change rec_field_no's to correspond to the clustered index
		record */
		for (i = 0; i < n_requested_fields; i++) {
			templ = prebuilt->mysql_template + i;

4656
			templ->rec_field_no = dict_col_get_clust_pos(
4657 4658
				&index->table->cols[templ->col_no],
				clust_index);
osku's avatar
osku committed
4659 4660 4661 4662
		}
	}
}

4663
/********************************************************************//**
4664 4665 4666 4667
This special handling is really to overcome the limitations of MySQL's
binlogging. We need to eliminate the non-determinism that will arise in
INSERT ... SELECT type of statements, since MySQL binlog only stores the
min value of the autoinc interval. Once that is fixed we can get rid of
4668 4669
the special lock handling.
@return	DB_SUCCESS if all OK else error code */
4670
UNIV_INTERN
4671 4672
ulint
ha_innobase::innobase_lock_autoinc(void)
4673 4674 4675 4676
/*====================================*/
{
	ulint		error = DB_SUCCESS;

4677 4678 4679
	switch (innobase_autoinc_lock_mode) {
	case AUTOINC_NO_LOCKING:
		/* Acquire only the AUTOINC mutex. */
4680
		dict_table_autoinc_lock(prebuilt->table);
4681
		break;
4682

4683 4684 4685 4686 4687
	case AUTOINC_NEW_STYLE_LOCKING:
		/* For simple (single/multi) row INSERTs, we fallback to the
		old style only if another transaction has already acquired
		the AUTOINC lock on behalf of a LOAD FILE or INSERT ... SELECT
		etc. type of statement. */
4688 4689
		if (thd_sql_command(user_thd) == SQLCOM_INSERT
		    || thd_sql_command(user_thd) == SQLCOM_REPLACE) {
4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702
			dict_table_t*	table = prebuilt->table;

			/* Acquire the AUTOINC mutex. */
			dict_table_autoinc_lock(table);

			/* We need to check that another transaction isn't
			already holding the AUTOINC lock on the table. */
			if (table->n_waiting_or_granted_auto_inc_locks) {
				/* Release the mutex to avoid deadlocks. */
				dict_table_autoinc_unlock(table);
			} else {
				break;
			}
4703
		}
4704 4705 4706
		/* Fall through to old style locking. */

	case AUTOINC_OLD_STYLE_LOCKING:
4707 4708 4709
		error = row_lock_table_autoinc_for_mysql(prebuilt);

		if (error == DB_SUCCESS) {
4710 4711

			/* Acquire the AUTOINC mutex. */
4712 4713
			dict_table_autoinc_lock(prebuilt->table);
		}
4714 4715 4716 4717
		break;

	default:
		ut_error;
4718 4719 4720 4721 4722
	}

	return(ulong(error));
}

4723
/********************************************************************//**
4724 4725
Reset the autoinc value in the table.
@return	DB_SUCCESS if all went well else error code */
4726
UNIV_INTERN
4727
ulint
4728 4729
ha_innobase::innobase_reset_autoinc(
/*================================*/
4730
	ulonglong	autoinc)	/*!< in: value to store */
4731 4732 4733
{
	ulint		error;

4734
	error = innobase_lock_autoinc();
4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745

	if (error == DB_SUCCESS) {

		dict_table_autoinc_initialize(prebuilt->table, autoinc);

		dict_table_autoinc_unlock(prebuilt->table);
	}

	return(ulong(error));
}

4746
/********************************************************************//**
4747
Store the autoinc value in the table. The autoinc value is only set if
4748
it's greater than the existing autoinc value in the table.
4749
@return	DB_SUCCESS if all went well else error code */
4750
UNIV_INTERN
4751
ulint
4752 4753
ha_innobase::innobase_set_max_autoinc(
/*==================================*/
4754
	ulonglong	auto_inc)	/*!< in: value to store */
4755 4756 4757
{
	ulint		error;

4758
	error = innobase_lock_autoinc();
4759 4760 4761

	if (error == DB_SUCCESS) {

4762
		dict_table_autoinc_update_if_greater(prebuilt->table, auto_inc);
4763 4764 4765 4766 4767 4768 4769

		dict_table_autoinc_unlock(prebuilt->table);
	}

	return(ulong(error));
}

4770
/********************************************************************//**
osku's avatar
osku committed
4771
Stores a row in an InnoDB database, to the table specified in this
4772 4773
handle.
@return	error code */
4774
UNIV_INTERN
osku's avatar
osku committed
4775 4776 4777
int
ha_innobase::write_row(
/*===================*/
4778
	uchar*	record)	/*!< in: a row in MySQL format */
osku's avatar
osku committed
4779
{
4780 4781
	ulint		error = 0;
        int             error_result= 0;
4782
	ibool		auto_inc_used= FALSE;
4783 4784
	ulint		sql_command;
	trx_t*		trx = thd_to_trx(user_thd);
osku's avatar
osku committed
4785

4786
	DBUG_ENTER("ha_innobase::write_row");
osku's avatar
osku committed
4787

4788
	if (prebuilt->trx != trx) {
osku's avatar
osku committed
4789 4790
	  sql_print_error("The transaction object for the table handle is at "
			  "%p, but for the current thread it is at %p",
4791
			  (const void*) prebuilt->trx, (const void*) trx);
osku's avatar
osku committed
4792 4793 4794 4795

		fputs("InnoDB: Dump of 200 bytes around prebuilt: ", stderr);
		ut_print_buf(stderr, ((const byte*)prebuilt) - 100, 200);
		fputs("\n"
4796
			"InnoDB: Dump of 200 bytes around ha_data: ",
osku's avatar
osku committed
4797
			stderr);
4798
		ut_print_buf(stderr, ((const byte*) trx) - 100, 200);
osku's avatar
osku committed
4799 4800 4801 4802
		putc('\n', stderr);
		ut_error;
	}

4803
	ha_statistic_increment(&SSV::ha_write_count);
osku's avatar
osku committed
4804

4805 4806
	if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
		table->timestamp_field->set_time();
osku's avatar
osku committed
4807

4808 4809 4810 4811 4812 4813 4814
	sql_command = thd_sql_command(user_thd);

	if ((sql_command == SQLCOM_ALTER_TABLE
	     || sql_command == SQLCOM_OPTIMIZE
	     || sql_command == SQLCOM_CREATE_INDEX
	     || sql_command == SQLCOM_DROP_INDEX)
	    && num_write_row >= 10000) {
osku's avatar
osku committed
4815 4816 4817 4818 4819 4820 4821 4822 4823 4824
		/* ALTER TABLE is COMMITted at every 10000 copied rows.
		The IX table lock for the original table has to be re-issued.
		As this method will be called on a temporary table where the
		contents of the original table is being copied to, it is
		a bit tricky to determine the source table.  The cursor
		position in the source table need not be adjusted after the
		intermediate COMMIT, since writes by other transactions are
		being blocked by a MySQL table lock TL_WRITE_ALLOW_READ. */

		dict_table_t*	src_table;
4825
		enum lock_mode	mode;
osku's avatar
osku committed
4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841

		num_write_row = 0;

		/* Commit the transaction.  This will release the table
		locks, so they have to be acquired again. */

		/* Altering an InnoDB table */
		/* Get the source table. */
		src_table = lock_get_src_table(
				prebuilt->trx, prebuilt->table, &mode);
		if (!src_table) {
no_commit:
			/* Unknown situation: do not commit */
			/*
			ut_print_timestamp(stderr);
			fprintf(stderr,
4842
				"  InnoDB: ALTER TABLE is holding lock"
osku's avatar
osku committed
4843 4844 4845 4846 4847 4848 4849 4850 4851
				" on %lu tables!\n",
				prebuilt->trx->mysql_n_tables_locked);
			*/
			;
		} else if (src_table == prebuilt->table) {
			/* Source table is not in InnoDB format:
			no need to re-acquire locks on it. */

			/* Altering to InnoDB format */
4852
			innobase_commit(ht, user_thd, 1);
osku's avatar
osku committed
4853 4854 4855
			/* Note that this transaction is still active. */
			prebuilt->trx->active_trans = 1;
			/* We will need an IX lock on the destination table. */
4856
			prebuilt->sql_stat_start = TRUE;
osku's avatar
osku committed
4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867
		} else {
			/* Ensure that there are no other table locks than
			LOCK_IX and LOCK_AUTO_INC on the destination table. */

			if (!lock_is_table_exclusive(prebuilt->table,
							prebuilt->trx)) {
				goto no_commit;
			}

			/* Commit the transaction.  This will release the table
			locks, so they have to be acquired again. */
4868
			innobase_commit(ht, user_thd, 1);
osku's avatar
osku committed
4869 4870 4871 4872 4873
			/* Note that this transaction is still active. */
			prebuilt->trx->active_trans = 1;
			/* Re-acquire the table lock on the source table. */
			row_lock_table_for_mysql(prebuilt, src_table, mode);
			/* We will need an IX lock on the destination table. */
4874
			prebuilt->sql_stat_start = TRUE;
osku's avatar
osku committed
4875 4876 4877 4878 4879
		}
	}

	num_write_row++;

4880
	/* This is the case where the table has an auto-increment column */
4881
	if (table->next_number_field && record == table->record[0]) {
osku's avatar
osku committed
4882

4883 4884 4885 4886
		/* Reset the error code before calling
		innobase_get_auto_increment(). */
		prebuilt->autoinc_error = DB_SUCCESS;

4887
		if ((error = update_auto_increment())) {
4888 4889
			/* We don't want to mask autoinc overflow errors. */

4890 4891 4892 4893 4894 4895 4896 4897 4898
			/* Handle the case where the AUTOINC sub-system
			failed during initialization. */
			if (prebuilt->autoinc_error == DB_UNSUPPORTED) {
				error_result = ER_AUTOINC_READ_FAILED;
				/* Set the error message to report too. */
				my_error(ER_AUTOINC_READ_FAILED, MYF(0));
				goto func_exit;
			} else if (prebuilt->autoinc_error != DB_SUCCESS) {
				error = (int) prebuilt->autoinc_error;
4899 4900 4901 4902
				goto report_error;
			}

			/* MySQL errors are passed straight back. */
4903
			error_result = (int) error;
osku's avatar
osku committed
4904 4905 4906
			goto func_exit;
		}

4907
		auto_inc_used = TRUE;
osku's avatar
osku committed
4908 4909 4910
	}

	if (prebuilt->mysql_template == NULL
4911 4912
	    || prebuilt->template_type != ROW_MYSQL_WHOLE_ROW) {

osku's avatar
osku committed
4913 4914 4915 4916 4917 4918 4919 4920 4921 4922
		/* Build the template used in converting quickly between
		the two database formats */

		build_template(prebuilt, NULL, table, ROW_MYSQL_WHOLE_ROW);
	}

	innodb_srv_conc_enter_innodb(prebuilt->trx);

	error = row_insert_for_mysql((byte*) record, prebuilt);

4923 4924
	/* Handle duplicate key errors */
	if (auto_inc_used) {
4925
		ulint		err;
4926
		ulonglong	auto_inc;
4927
		ulonglong	col_max_value;
osku's avatar
osku committed
4928

4929 4930 4931 4932 4933 4934 4935
		/* Note the number of rows processed for this statement, used
		by get_auto_increment() to determine the number of AUTO-INC
		values to reserve. This is only useful for a mult-value INSERT
		and is a statement level counter.*/
		if (trx->n_autoinc_rows > 0) {
			--trx->n_autoinc_rows;
		}
osku's avatar
osku committed
4936

4937 4938 4939 4940 4941
		/* We need the upper limit of the col type to check for
		whether we update the table autoinc counter or not. */
		col_max_value = innobase_get_int_col_max_value(
			table->next_number_field);

4942
		/* Get the value that MySQL attempted to store in the table.*/
4943
		auto_inc = table->next_number_field->val_int();
osku's avatar
osku committed
4944

4945 4946
		switch (error) {
		case DB_DUPLICATE_KEY:
osku's avatar
osku committed
4947

4948 4949 4950 4951
			/* A REPLACE command and LOAD DATA INFILE REPLACE
			handle a duplicate key error themselves, but we
			must update the autoinc counter if we are performing
			those statements. */
osku's avatar
osku committed
4952

4953 4954 4955 4956
			switch (sql_command) {
			case SQLCOM_LOAD:
				if ((trx->duplicates
				    & (TRX_DUP_IGNORE | TRX_DUP_REPLACE))) {
osku's avatar
osku committed
4957

4958 4959 4960
					goto set_max_autoinc;
				}
				break;
osku's avatar
osku committed
4961

4962 4963 4964 4965
			case SQLCOM_REPLACE:
			case SQLCOM_INSERT_SELECT:
			case SQLCOM_REPLACE_SELECT:
				goto set_max_autoinc;
osku's avatar
osku committed
4966

4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978
			default:
				break;
			}

			break;

		case DB_SUCCESS:
			/* If the actual value inserted is greater than
			the upper limit of the interval, then we try and
			update the table upper limit. Note: last_value
			will be 0 if get_auto_increment() was not called.*/

4979
			if (auto_inc >= prebuilt->autoinc_last_value) {
4980
set_max_autoinc:
4981 4982 4983 4984
				/* This should filter out the negative
				values set explicitly by the user. */
				if (auto_inc <= col_max_value) {
					ut_a(prebuilt->autoinc_increment > 0);
4985

4986 4987
					ulonglong	need;
					ulonglong	offset;
4988

4989 4990
					offset = prebuilt->autoinc_offset;
					need = prebuilt->autoinc_increment;
4991

4992 4993 4994
					auto_inc = innobase_next_autoinc(
						auto_inc,
						need, offset, col_max_value);
4995

4996 4997
					err = innobase_set_max_autoinc(
						auto_inc);
4998

4999 5000 5001
					if (err != DB_SUCCESS) {
						error = err;
					}
5002
				}
5003 5004
			}
			break;
5005 5006
		}
	}
osku's avatar
osku committed
5007 5008 5009

	innodb_srv_conc_exit_innodb(prebuilt->trx);

5010
report_error:
5011 5012 5013
	error_result = convert_error_code_to_mysql((int) error,
						   prebuilt->table->flags,
						   user_thd);
osku's avatar
osku committed
5014 5015 5016 5017

func_exit:
	innobase_active_small();

5018
	DBUG_RETURN(error_result);
osku's avatar
osku committed
5019 5020
}

5021
/**********************************************************************//**
osku's avatar
osku committed
5022
Checks which fields have changed in a row and stores information
5023 5024
of them to an update vector.
@return	error number or 0 */
osku's avatar
osku committed
5025 5026 5027 5028
static
int
calc_row_difference(
/*================*/
5029 5030 5031
	upd_t*		uvect,		/*!< in/out: update vector */
	uchar*		old_row,	/*!< in: old row in MySQL format */
	uchar*		new_row,	/*!< in: new row in MySQL format */
5032
	TABLE*		table,		/*!< in: table in MySQL data
osku's avatar
osku committed
5033
					dictionary */
5034 5035 5036 5037
	uchar*		upd_buff,	/*!< in: buffer to use */
	ulint		buff_len,	/*!< in: buffer length */
	row_prebuilt_t*	prebuilt,	/*!< in: InnoDB prebuilt struct */
	THD*		thd)		/*!< in: user thread */
osku's avatar
osku committed
5038
{
5039
	uchar*		original_upd_buff = upd_buff;
osku's avatar
osku committed
5040 5041 5042 5043 5044 5045
	Field*		field;
	enum_field_types field_mysql_type;
	uint		n_fields;
	ulint		o_len;
	ulint		n_len;
	ulint		col_pack_len;
5046 5047 5048
	const byte*	new_mysql_row_col;
	const byte*	o_ptr;
	const byte*	n_ptr;
5049
	byte*		buf;
osku's avatar
osku committed
5050 5051 5052 5053
	upd_field_t*	ufield;
	ulint		col_type;
	ulint		n_changed = 0;
	dfield_t	dfield;
5054
	dict_index_t*	clust_index;
osku's avatar
osku committed
5055 5056 5057
	uint		i;

	n_fields = table->s->fields;
5058
	clust_index = dict_table_get_first_index(prebuilt->table);
osku's avatar
osku committed
5059 5060 5061 5062 5063 5064 5065

	/* We use upd_buff to convert changed fields */
	buf = (byte*) upd_buff;

	for (i = 0; i < n_fields; i++) {
		field = table->field[i];

5066 5067
		o_ptr = (const byte*) old_row + get_field_offset(table, field);
		n_ptr = (const byte*) new_row + get_field_offset(table, field);
5068

osku's avatar
osku committed
5069 5070 5071 5072 5073 5074 5075 5076 5077
		/* Use new_mysql_row_col and col_pack_len save the values */

		new_mysql_row_col = n_ptr;
		col_pack_len = field->pack_length();

		o_len = col_pack_len;
		n_len = col_pack_len;

		/* We use o_ptr and n_ptr to dig up the actual data for
5078
		comparison. */
osku's avatar
osku committed
5079 5080

		field_mysql_type = field->type();
5081

5082
		col_type = prebuilt->table->cols[i].mtype;
osku's avatar
osku committed
5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098

		switch (col_type) {

		case DATA_BLOB:
			o_ptr = row_mysql_read_blob_ref(&o_len, o_ptr, o_len);
			n_ptr = row_mysql_read_blob_ref(&n_len, n_ptr, n_len);

			break;

		case DATA_VARCHAR:
		case DATA_BINARY:
		case DATA_VARMYSQL:
			if (field_mysql_type == MYSQL_TYPE_VARCHAR) {
				/* This is a >= 5.0.3 type true VARCHAR where
				the real payload data length is stored in
				1 or 2 bytes */
5099

osku's avatar
osku committed
5100
				o_ptr = row_mysql_read_true_varchar(
5101 5102 5103 5104
					&o_len, o_ptr,
					(ulint)
					(((Field_varstring*)field)->length_bytes));

osku's avatar
osku committed
5105
				n_ptr = row_mysql_read_true_varchar(
5106 5107 5108
					&n_len, n_ptr,
					(ulint)
					(((Field_varstring*)field)->length_bytes));
osku's avatar
osku committed
5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132
			}

			break;
		default:
			;
		}

		if (field->null_ptr) {
			if (field_in_record_is_null(table, field,
							(char*) old_row)) {
				o_len = UNIV_SQL_NULL;
			}

			if (field_in_record_is_null(table, field,
							(char*) new_row)) {
				n_len = UNIV_SQL_NULL;
			}
		}

		if (o_len != n_len || (o_len != UNIV_SQL_NULL &&
					0 != memcmp(o_ptr, n_ptr, o_len))) {
			/* The field has changed */

			ufield = uvect->fields + n_changed;
5133

osku's avatar
osku committed
5134 5135 5136
			/* Let us use a dummy dfield to make the conversion
			from the MySQL column format to the InnoDB format */

5137
			dict_col_copy_type(prebuilt->table->cols + i,
5138
					   dfield_get_type(&dfield));
osku's avatar
osku committed
5139 5140 5141

			if (n_len != UNIV_SQL_NULL) {
				buf = row_mysql_store_col_in_innobase_format(
5142 5143 5144 5145 5146
					&dfield,
					(byte*)buf,
					TRUE,
					new_mysql_row_col,
					col_pack_len,
5147
					dict_table_is_comp(prebuilt->table));
5148
				dfield_copy_data(&ufield->new_val, &dfield);
osku's avatar
osku committed
5149
			} else {
5150
				dfield_set_null(&ufield->new_val);
osku's avatar
osku committed
5151 5152 5153
			}

			ufield->exp = NULL;
5154
			ufield->orig_len = 0;
5155
			ufield->field_no = dict_col_get_clust_pos(
5156
				&prebuilt->table->cols[i], clust_index);
osku's avatar
osku committed
5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168
			n_changed++;
		}
	}

	uvect->n_fields = n_changed;
	uvect->info_bits = 0;

	ut_a(buf <= (byte*)original_upd_buff + buff_len);

	return(0);
}

5169
/**********************************************************************//**
osku's avatar
osku committed
5170 5171 5172 5173 5174
Updates a row given as a parameter to a new value. Note that we are given
whole rows, not just the fields which are updated: this incurs some
overhead for CPU when we check which fields are actually updated.
TODO: currently InnoDB does not prevent the 'Halloween problem':
in a searched update a single row can get updated several times
5175 5176
if its index columns are updated!
@return	error number or 0 */
5177
UNIV_INTERN
osku's avatar
osku committed
5178 5179 5180
int
ha_innobase::update_row(
/*====================*/
5181 5182
	const uchar*	old_row,	/*!< in: old row in MySQL format */
	uchar*		new_row)	/*!< in: new row in MySQL format */
osku's avatar
osku committed
5183 5184 5185
{
	upd_t*		uvect;
	int		error = 0;
5186
	trx_t*		trx = thd_to_trx(user_thd);
osku's avatar
osku committed
5187 5188 5189

	DBUG_ENTER("ha_innobase::update_row");

5190
	ut_a(prebuilt->trx == trx);
osku's avatar
osku committed
5191

5192 5193
	ha_statistic_increment(&SSV::ha_update_count);

5194 5195
	if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
		table->timestamp_field->set_time();
osku's avatar
osku committed
5196 5197 5198 5199 5200 5201 5202 5203 5204 5205

	if (prebuilt->upd_node) {
		uvect = prebuilt->upd_node->update;
	} else {
		uvect = row_get_prebuilt_update_vector(prebuilt);
	}

	/* Build an update vector from the modified fields in the rows
	(uses upd_buff of the handle) */

5206
	calc_row_difference(uvect, (uchar*) old_row, new_row, table,
osku's avatar
osku committed
5207 5208 5209 5210 5211 5212
			upd_buff, (ulint)upd_and_key_val_buff_len,
			prebuilt, user_thd);

	/* This is not a delete */
	prebuilt->upd_node->is_delete = FALSE;

5213
	ut_a(prebuilt->template_type == ROW_MYSQL_WHOLE_ROW);
osku's avatar
osku committed
5214

5215
	innodb_srv_conc_enter_innodb(trx);
osku's avatar
osku committed
5216 5217 5218

	error = row_update_for_mysql((byte*) old_row, prebuilt);

5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233
	/* We need to do some special AUTOINC handling for the following case:

	INSERT INTO t (c1,c2) VALUES(x,y) ON DUPLICATE KEY UPDATE ...

	We need to use the AUTOINC counter that was actually used by
	MySQL in the UPDATE statement, which can be different from the
	value used in the INSERT statement.*/

	if (error == DB_SUCCESS
	    && table->next_number_field
	    && new_row == table->record[0]
	    && thd_sql_command(user_thd) == SQLCOM_INSERT
	    && (trx->duplicates & (TRX_DUP_IGNORE | TRX_DUP_REPLACE))
		== TRX_DUP_IGNORE)  {

5234 5235
		ulonglong	auto_inc;
		ulonglong	col_max_value;
5236 5237 5238

		auto_inc = table->next_number_field->val_int();

5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253
		/* We need the upper limit of the col type to check for
		whether we update the table autoinc counter or not. */
		col_max_value = innobase_get_int_col_max_value(
			table->next_number_field);

		if (auto_inc <= col_max_value && auto_inc != 0) {

			ulonglong	need;
			ulonglong	offset;

			offset = prebuilt->autoinc_offset;
			need = prebuilt->autoinc_increment;

			auto_inc = innobase_next_autoinc(
				auto_inc, need, offset, col_max_value);
5254

5255
			error = innobase_set_max_autoinc(auto_inc);
5256 5257 5258
		}
	}

5259
	innodb_srv_conc_exit_innodb(trx);
osku's avatar
osku committed
5260

5261 5262
	error = convert_error_code_to_mysql(error,
					    prebuilt->table->flags, user_thd);
osku's avatar
osku committed
5263

5264 5265 5266 5267 5268 5269 5270 5271 5272 5273
	if (error == 0 /* success */
	    && uvect->n_fields == 0 /* no columns were updated */) {

		/* This is the same as success, but instructs
		MySQL that the row is not really updated and it
		should not increase the count of updated rows.
		This is fix for http://bugs.mysql.com/29157 */
		error = HA_ERR_RECORD_IS_THE_SAME;
	}

osku's avatar
osku committed
5274 5275 5276 5277 5278 5279 5280 5281
	/* Tell InnoDB server that there might be work for
	utility threads: */

	innobase_active_small();

	DBUG_RETURN(error);
}

5282
/**********************************************************************//**
5283 5284
Deletes a row given as the parameter.
@return	error number or 0 */
5285
UNIV_INTERN
osku's avatar
osku committed
5286 5287 5288
int
ha_innobase::delete_row(
/*====================*/
5289
	const uchar*	record)	/*!< in: a row in MySQL format */
osku's avatar
osku committed
5290 5291
{
	int		error = 0;
5292
	trx_t*		trx = thd_to_trx(user_thd);
osku's avatar
osku committed
5293 5294 5295

	DBUG_ENTER("ha_innobase::delete_row");

5296
	ut_a(prebuilt->trx == trx);
osku's avatar
osku committed
5297

5298 5299
	ha_statistic_increment(&SSV::ha_delete_count);

osku's avatar
osku committed
5300 5301 5302 5303 5304 5305 5306 5307
	if (!prebuilt->upd_node) {
		row_get_prebuilt_update_vector(prebuilt);
	}

	/* This is a delete */

	prebuilt->upd_node->is_delete = TRUE;

5308
	innodb_srv_conc_enter_innodb(trx);
osku's avatar
osku committed
5309 5310 5311

	error = row_update_for_mysql((byte*) record, prebuilt);

5312
	innodb_srv_conc_exit_innodb(trx);
osku's avatar
osku committed
5313

5314 5315
	error = convert_error_code_to_mysql(
		error, prebuilt->table->flags, user_thd);
osku's avatar
osku committed
5316 5317 5318 5319 5320 5321 5322 5323 5324

	/* Tell the InnoDB server that there might be work for
	utility threads: */

	innobase_active_small();

	DBUG_RETURN(error);
}

5325
/**********************************************************************//**
5326
Removes a new lock set on a row, if it was not read optimistically. This can
5327 5328
be called after a row has been read in the processing of an UPDATE or a DELETE
query, if the option innodb_locks_unsafe_for_binlog is set. */
5329
UNIV_INTERN
osku's avatar
osku committed
5330 5331 5332 5333 5334 5335
void
ha_innobase::unlock_row(void)
/*=========================*/
{
	DBUG_ENTER("ha_innobase::unlock_row");

5336 5337 5338 5339 5340 5341 5342
	/* Consistent read does not take any locks, thus there is
	nothing to unlock. */

	if (prebuilt->select_lock_type == LOCK_NONE) {
		DBUG_VOID_RETURN;
	}

5343 5344
	switch (prebuilt->row_read_type) {
	case ROW_READ_WITH_LOCKS:
5345
		if (!srv_locks_unsafe_for_binlog
5346 5347
		    && prebuilt->trx->isolation_level
		    != TRX_ISO_READ_COMMITTED) {
5348 5349 5350 5351
			break;
		}
		/* fall through */
	case ROW_READ_TRY_SEMI_CONSISTENT:
osku's avatar
osku committed
5352
		row_unlock_for_mysql(prebuilt, FALSE);
5353 5354 5355 5356 5357 5358 5359 5360 5361 5362
		break;
	case ROW_READ_DID_SEMI_CONSISTENT:
		prebuilt->row_read_type = ROW_READ_TRY_SEMI_CONSISTENT;
		break;
	}

	DBUG_VOID_RETURN;
}

/* See handler.h and row0mysql.h for docs on this function. */
5363
UNIV_INTERN
5364 5365 5366 5367 5368 5369 5370 5371
bool
ha_innobase::was_semi_consistent_read(void)
/*=======================================*/
{
	return(prebuilt->row_read_type == ROW_READ_DID_SEMI_CONSISTENT);
}

/* See handler.h and row0mysql.h for docs on this function. */
5372
UNIV_INTERN
5373 5374 5375 5376
void
ha_innobase::try_semi_consistent_read(bool yes)
/*===========================================*/
{
5377
	ut_a(prebuilt->trx == thd_to_trx(ha_thd()));
5378

5379 5380 5381 5382 5383
	/* Row read type is set to semi consistent read if this was
	requested by the MySQL and either innodb_locks_unsafe_for_binlog
	option is used or this session is using READ COMMITTED isolation
	level. */

5384 5385
	if (yes
	    && (srv_locks_unsafe_for_binlog
5386
		|| prebuilt->trx->isolation_level == TRX_ISO_READ_COMMITTED)) {
5387 5388 5389
		prebuilt->row_read_type = ROW_READ_TRY_SEMI_CONSISTENT;
	} else {
		prebuilt->row_read_type = ROW_READ_WITH_LOCKS;
osku's avatar
osku committed
5390 5391 5392
	}
}

5393
/******************************************************************//**
5394 5395
Initializes a handle to use an index.
@return	0 or error number */
5396
UNIV_INTERN
osku's avatar
osku committed
5397 5398 5399
int
ha_innobase::index_init(
/*====================*/
5400 5401
	uint	keynr,	/*!< in: key (index) number */
	bool sorted)	/*!< in: 1 if result MUST be sorted according to index */
osku's avatar
osku committed
5402
{
5403
	DBUG_ENTER("index_init");
osku's avatar
osku committed
5404

5405
	DBUG_RETURN(change_active_index(keynr));
osku's avatar
osku committed
5406 5407
}

5408
/******************************************************************//**
5409 5410
Currently does nothing.
@return	0 */
5411
UNIV_INTERN
osku's avatar
osku committed
5412 5413 5414 5415
int
ha_innobase::index_end(void)
/*========================*/
{
5416 5417 5418 5419
	int	error	= 0;
	DBUG_ENTER("index_end");
	active_index=MAX_KEY;
	DBUG_RETURN(error);
osku's avatar
osku committed
5420 5421
}

5422
/*********************************************************************//**
osku's avatar
osku committed
5423 5424
Converts a search mode flag understood by MySQL to a flag understood
by InnoDB. */
5425
static inline
osku's avatar
osku committed
5426 5427 5428 5429 5430 5431
ulint
convert_search_mode_to_innobase(
/*============================*/
	enum ha_rkey_function	find_flag)
{
	switch (find_flag) {
5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475
	case HA_READ_KEY_EXACT:
		/* this does not require the index to be UNIQUE */
		return(PAGE_CUR_GE);
	case HA_READ_KEY_OR_NEXT:
		return(PAGE_CUR_GE);
	case HA_READ_KEY_OR_PREV:
		return(PAGE_CUR_LE);
	case HA_READ_AFTER_KEY:	
		return(PAGE_CUR_G);
	case HA_READ_BEFORE_KEY:
		return(PAGE_CUR_L);
	case HA_READ_PREFIX:
		return(PAGE_CUR_GE);
	case HA_READ_PREFIX_LAST:
		return(PAGE_CUR_LE);
	case HA_READ_PREFIX_LAST_OR_PREV:
		return(PAGE_CUR_LE);
		/* In MySQL-4.0 HA_READ_PREFIX and HA_READ_PREFIX_LAST always
		pass a complete-field prefix of a key value as the search
		tuple. I.e., it is not allowed that the last field would
		just contain n first bytes of the full field value.
		MySQL uses a 'padding' trick to convert LIKE 'abc%'
		type queries so that it can use as a search tuple
		a complete-field-prefix of a key value. Thus, the InnoDB
		search mode PAGE_CUR_LE_OR_EXTENDS is never used.
		TODO: when/if MySQL starts to use also partial-field
		prefixes, we have to deal with stripping of spaces
		and comparison of non-latin1 char type fields in
		innobase_mysql_cmp() to get PAGE_CUR_LE_OR_EXTENDS to
		work correctly. */
	case HA_READ_MBR_CONTAIN:
	case HA_READ_MBR_INTERSECT:
	case HA_READ_MBR_WITHIN:
	case HA_READ_MBR_DISJOINT:
	case HA_READ_MBR_EQUAL:
		return(PAGE_CUR_UNSUPP);
	/* do not use "default:" in order to produce a gcc warning:
	enumeration value '...' not handled in switch
	(if -Wswitch or -Wall is used) */
	}

	my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "this functionality");

	return(PAGE_CUR_UNSUPP);
osku's avatar
osku committed
5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526
}

/*
   BACKGROUND INFO: HOW A SELECT SQL QUERY IS EXECUTED
   ---------------------------------------------------
The following does not cover all the details, but explains how we determine
the start of a new SQL statement, and what is associated with it.

For each table in the database the MySQL interpreter may have several
table handle instances in use, also in a single SQL query. For each table
handle instance there is an InnoDB  'prebuilt' struct which contains most
of the InnoDB data associated with this table handle instance.

  A) if the user has not explicitly set any MySQL table level locks:

  1) MySQL calls ::external_lock to set an 'intention' table level lock on
the table of the handle instance. There we set
prebuilt->sql_stat_start = TRUE. The flag sql_stat_start should be set
true if we are taking this table handle instance to use in a new SQL
statement issued by the user. We also increment trx->n_mysql_tables_in_use.

  2) If prebuilt->sql_stat_start == TRUE we 'pre-compile' the MySQL search
instructions to prebuilt->template of the table handle instance in
::index_read. The template is used to save CPU time in large joins.

  3) In row_search_for_mysql, if prebuilt->sql_stat_start is true, we
allocate a new consistent read view for the trx if it does not yet have one,
or in the case of a locking read, set an InnoDB 'intention' table level
lock on the table.

  4) We do the SELECT. MySQL may repeatedly call ::index_read for the
same table handle instance, if it is a join.

  5) When the SELECT ends, MySQL removes its intention table level locks
in ::external_lock. When trx->n_mysql_tables_in_use drops to zero,
 (a) we execute a COMMIT there if the autocommit is on,
 (b) we also release possible 'SQL statement level resources' InnoDB may
have for this SQL statement. The MySQL interpreter does NOT execute
autocommit for pure read transactions, though it should. That is why the
table handler in that case has to execute the COMMIT in ::external_lock.

  B) If the user has explicitly set MySQL table level locks, then MySQL
does NOT call ::external_lock at the start of the statement. To determine
when we are at the start of a new SQL statement we at the start of
::index_read also compare the query id to the latest query id where the
table handle instance was used. If it has changed, we know we are at the
start of a new SQL statement. Since the query id can theoretically
overwrap, we use this test only as a secondary way of determining the
start of a new SQL statement. */


5527
/**********************************************************************//**
osku's avatar
osku committed
5528
Positions an index cursor to the index specified in the handle. Fetches the
5529 5530
row if any.
@return	0, HA_ERR_KEY_NOT_FOUND, or error number */
5531
UNIV_INTERN
osku's avatar
osku committed
5532 5533 5534
int
ha_innobase::index_read(
/*====================*/
5535
	uchar*		buf,		/*!< in/out: buffer for the returned
osku's avatar
osku committed
5536
					row */
5537
	const uchar*	key_ptr,	/*!< in: key value; if this is NULL
osku's avatar
osku committed
5538 5539 5540 5541 5542 5543 5544 5545
					we position the cursor at the
					start or end of index; this can
					also contain an InnoDB row id, in
					which case key_len is the InnoDB
					row id length; the key value can
					also be a prefix of a full key value,
					and the last column can be a prefix
					of a full column */
5546 5547
	uint			key_len,/*!< in: key value length */
	enum ha_rkey_function find_flag)/*!< in: search flags from my_base.h */
osku's avatar
osku committed
5548 5549 5550
{
	ulint		mode;
	dict_index_t*	index;
5551 5552
	ulint		match_mode	= 0;
	int		error;
osku's avatar
osku committed
5553 5554
	ulint		ret;

5555
	DBUG_ENTER("index_read");
osku's avatar
osku committed
5556

5557
	ut_a(prebuilt->trx == thd_to_trx(user_thd));
osku's avatar
osku committed
5558

5559
	ha_statistic_increment(&SSV::ha_read_key_count);
osku's avatar
osku committed
5560 5561 5562

	index = prebuilt->index;

5563 5564 5565 5566 5567
	if (UNIV_UNLIKELY(index == NULL)) {
		prebuilt->index_usable = FALSE;
		DBUG_RETURN(HA_ERR_CRASHED);
	}

osku's avatar
osku committed
5568
	/* Note that if the index for which the search template is built is not
5569
	necessarily prebuilt->index, but can also be the clustered index */
osku's avatar
osku committed
5570 5571

	if (prebuilt->sql_stat_start) {
5572
		build_template(prebuilt, user_thd, table, ROW_MYSQL_REC_FIELDS);
osku's avatar
osku committed
5573 5574 5575
	}

	if (key_ptr) {
5576
		/* Convert the search key value to InnoDB format into
osku's avatar
osku committed
5577 5578
		prebuilt->search_tuple */

5579 5580 5581 5582 5583 5584 5585 5586
		row_sel_convert_mysql_key_to_innobase(
			prebuilt->search_tuple,
			(byte*) key_val_buff,
			(ulint)upd_and_key_val_buff_len,
			index,
			(byte*) key_ptr,
			(ulint) key_len,
			prebuilt->trx);
osku's avatar
osku committed
5587 5588 5589 5590
	} else {
		/* We position the cursor to the last or the first entry
		in the index */

5591
		dtuple_set_n_fields(prebuilt->search_tuple, 0);
osku's avatar
osku committed
5592 5593 5594 5595 5596 5597 5598
	}

	mode = convert_search_mode_to_innobase(find_flag);

	match_mode = 0;

	if (find_flag == HA_READ_KEY_EXACT) {
5599

osku's avatar
osku committed
5600 5601 5602
		match_mode = ROW_SEL_EXACT;

	} else if (find_flag == HA_READ_PREFIX
5603 5604
		   || find_flag == HA_READ_PREFIX_LAST) {

osku's avatar
osku committed
5605 5606 5607 5608 5609
		match_mode = ROW_SEL_EXACT_PREFIX;
	}

	last_match_mode = (uint) match_mode;

5610
	if (mode != PAGE_CUR_UNSUPP) {
osku's avatar
osku committed
5611

5612
		innodb_srv_conc_enter_innodb(prebuilt->trx);
osku's avatar
osku committed
5613

5614 5615 5616 5617 5618 5619 5620 5621
		ret = row_search_for_mysql((byte*) buf, mode, prebuilt,
					   match_mode, 0);

		innodb_srv_conc_exit_innodb(prebuilt->trx);
	} else {

		ret = DB_UNSUPPORTED;
	}
osku's avatar
osku committed
5622

5623 5624
	switch (ret) {
	case DB_SUCCESS:
osku's avatar
osku committed
5625 5626
		error = 0;
		table->status = 0;
5627 5628
		break;
	case DB_RECORD_NOT_FOUND:
osku's avatar
osku committed
5629 5630
		error = HA_ERR_KEY_NOT_FOUND;
		table->status = STATUS_NOT_FOUND;
5631 5632
		break;
	case DB_END_OF_INDEX:
osku's avatar
osku committed
5633 5634
		error = HA_ERR_KEY_NOT_FOUND;
		table->status = STATUS_NOT_FOUND;
5635 5636 5637 5638 5639
		break;
	default:
		error = convert_error_code_to_mysql((int) ret,
						    prebuilt->table->flags,
						    user_thd);
osku's avatar
osku committed
5640
		table->status = STATUS_NOT_FOUND;
5641
		break;
osku's avatar
osku committed
5642 5643 5644 5645 5646
	}

	DBUG_RETURN(error);
}

5647
/*******************************************************************//**
osku's avatar
osku committed
5648
The following functions works like index_read, but it find the last
5649 5650
row with the current key value or prefix.
@return	0, HA_ERR_KEY_NOT_FOUND, or an error code */
5651
UNIV_INTERN
osku's avatar
osku committed
5652 5653 5654
int
ha_innobase::index_read_last(
/*=========================*/
5655 5656
	uchar*		buf,	/*!< out: fetched row */
	const uchar*	key_ptr,/*!< in: key value, or a prefix of a full
5657
				key value */
5658
	uint		key_len)/*!< in: length of the key val or prefix
5659
				in bytes */
osku's avatar
osku committed
5660
{
5661
	return(index_read(buf, key_ptr, key_len, HA_READ_PREFIX_LAST));
osku's avatar
osku committed
5662 5663
}

5664
/********************************************************************//**
5665 5666
Get the index for a handle. Does not change active index.
@return	NULL or index instance. */
5667
UNIV_INTERN
5668 5669 5670
dict_index_t*
ha_innobase::innobase_get_index(
/*============================*/
5671
	uint		keynr)	/*!< in: use this index; MAX_KEY means always
5672 5673
				clustered index, even if it was internally
				generated by InnoDB */
osku's avatar
osku committed
5674
{
5675
	KEY*		key = 0;
5676 5677 5678
	dict_index_t*	index = 0;

	DBUG_ENTER("innobase_get_index");
5679
	ha_statistic_increment(&SSV::ha_read_key_count);
osku's avatar
osku committed
5680 5681

	if (keynr != MAX_KEY && table->s->keys > 0) {
5682
		key = table->key_info + keynr;
osku's avatar
osku committed
5683

5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704
		index = innobase_index_lookup(share, keynr);

		if (index) {
			ut_a(ut_strcmp(index->name, key->name) == 0);
		} else {
			/* Can't find index with keynr in the translation
			table. Only print message if the index translation
			table exists */
			if (share->idx_trans_tbl.index_mapping) {
				sql_print_error("InnoDB could not find "
						"index %s key no %u for "
						"table %s through its "
						"index translation table",
						key ? key->name : "NULL",
						keynr,
						prebuilt->table->name);
			}

			index = dict_table_get_index_on_name(prebuilt->table,
							     key->name);
		}
5705
	} else {
5706
		index = dict_table_get_first_index(prebuilt->table);
osku's avatar
osku committed
5707 5708
	}

5709
	if (!index) {
5710 5711 5712 5713 5714
		sql_print_error(
			"Innodb could not find key n:o %u with name %s "
			"from dict cache for table %s",
			keynr, key ? key->name : "NULL",
			prebuilt->table->name);
5715 5716 5717 5718 5719
	}

	DBUG_RETURN(index);
}

5720
/********************************************************************//**
5721 5722
Changes the active index of a handle.
@return	0 or error code */
5723
UNIV_INTERN
5724 5725 5726
int
ha_innobase::change_active_index(
/*=============================*/
5727
	uint	keynr)	/*!< in: use this index; MAX_KEY means always clustered
5728 5729 5730 5731
			index, even if it was internally generated by
			InnoDB */
{
	DBUG_ENTER("change_active_index");
5732

5733 5734 5735 5736 5737 5738 5739
	ut_ad(user_thd == ha_thd());
	ut_a(prebuilt->trx == thd_to_trx(user_thd));

	active_index = keynr;

	prebuilt->index = innobase_get_index(keynr);

5740 5741 5742
	if (UNIV_UNLIKELY(!prebuilt->index)) {
		sql_print_warning("InnoDB: change_active_index(%u) failed",
				  keynr);
5743
		prebuilt->index_usable = FALSE;
5744
		DBUG_RETURN(1);
osku's avatar
osku committed
5745 5746
	}

5747 5748 5749 5750
	prebuilt->index_usable = row_merge_is_index_usable(prebuilt->trx,
							   prebuilt->index);

	if (UNIV_UNLIKELY(!prebuilt->index_usable)) {
5751 5752 5753 5754
		push_warning_printf(user_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
				    HA_ERR_TABLE_DEF_CHANGED,
				    "InnoDB: insufficient history for index %u",
				    keynr);
5755 5756 5757 5758 5759
		/* The caller seems to ignore this.  Thus, we must check
		this again in row_search_for_mysql(). */
		DBUG_RETURN(2);
	}

5760
	ut_a(prebuilt->search_tuple != 0);
osku's avatar
osku committed
5761 5762 5763 5764

	dtuple_set_n_fields(prebuilt->search_tuple, prebuilt->index->n_fields);

	dict_index_copy_types(prebuilt->search_tuple, prebuilt->index,
5765
			      prebuilt->index->n_fields);
osku's avatar
osku committed
5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777

	/* MySQL changes the active index for a handle also during some
	queries, for example SELECT MAX(a), SUM(a) first retrieves the MAX()
	and then calculates the sum. Previously we played safe and used
	the flag ROW_MYSQL_WHOLE_ROW below, but that caused unnecessary
	copying. Starting from MySQL-4.1 we use a more efficient flag here. */

	build_template(prebuilt, user_thd, table, ROW_MYSQL_REC_FIELDS);

	DBUG_RETURN(0);
}

5778
/**********************************************************************//**
osku's avatar
osku committed
5779
Positions an index cursor to the index specified in keynr. Fetches the
5780
row if any.
5781 5782
??? This is only used to read whole keys ???
@return	error number or 0 */
5783
UNIV_INTERN
osku's avatar
osku committed
5784 5785 5786
int
ha_innobase::index_read_idx(
/*========================*/
5787
	uchar*		buf,		/*!< in/out: buffer for the returned
osku's avatar
osku committed
5788
					row */
5789 5790
	uint		keynr,		/*!< in: use this index */
	const uchar*	key,		/*!< in: key value; if this is NULL
osku's avatar
osku committed
5791 5792
					we position the cursor at the
					start or end of index */
5793 5794
	uint		key_len,	/*!< in: key value length */
	enum ha_rkey_function find_flag)/*!< in: search flags from my_base.h */
osku's avatar
osku committed
5795 5796 5797 5798 5799 5800 5801 5802 5803
{
	if (change_active_index(keynr)) {

		return(1);
	}

	return(index_read(buf, key, key_len, find_flag));
}

5804
/***********************************************************************//**
osku's avatar
osku committed
5805
Reads the next or previous row from a cursor, which must have previously been
5806 5807
positioned using index_read.
@return	0, HA_ERR_END_OF_FILE, or error number */
5808
UNIV_INTERN
osku's avatar
osku committed
5809 5810 5811
int
ha_innobase::general_fetch(
/*=======================*/
5812
	uchar*	buf,		/*!< in/out: buffer for next row in MySQL
osku's avatar
osku committed
5813
				format */
5814 5815
	uint	direction,	/*!< in: ROW_SEL_NEXT or ROW_SEL_PREV */
	uint	match_mode)	/*!< in: 0, ROW_SEL_EXACT, or
osku's avatar
osku committed
5816 5817 5818 5819 5820 5821 5822
				ROW_SEL_EXACT_PREFIX */
{
	ulint		ret;
	int		error	= 0;

	DBUG_ENTER("general_fetch");

5823
	ut_a(prebuilt->trx == thd_to_trx(user_thd));
osku's avatar
osku committed
5824 5825 5826

	innodb_srv_conc_enter_innodb(prebuilt->trx);

5827 5828 5829
	ret = row_search_for_mysql(
		(byte*)buf, 0, prebuilt, match_mode, direction);

osku's avatar
osku committed
5830 5831
	innodb_srv_conc_exit_innodb(prebuilt->trx);

5832 5833
	switch (ret) {
	case DB_SUCCESS:
osku's avatar
osku committed
5834 5835
		error = 0;
		table->status = 0;
5836 5837
		break;
	case DB_RECORD_NOT_FOUND:
osku's avatar
osku committed
5838 5839
		error = HA_ERR_END_OF_FILE;
		table->status = STATUS_NOT_FOUND;
5840 5841
		break;
	case DB_END_OF_INDEX:
osku's avatar
osku committed
5842 5843
		error = HA_ERR_END_OF_FILE;
		table->status = STATUS_NOT_FOUND;
5844 5845 5846 5847
		break;
	default:
		error = convert_error_code_to_mysql(
			(int) ret, prebuilt->table->flags, user_thd);
osku's avatar
osku committed
5848
		table->status = STATUS_NOT_FOUND;
5849
		break;
osku's avatar
osku committed
5850 5851 5852 5853 5854
	}

	DBUG_RETURN(error);
}

5855
/***********************************************************************//**
osku's avatar
osku committed
5856
Reads the next row from a cursor, which must have previously been
5857 5858
positioned using index_read.
@return	0, HA_ERR_END_OF_FILE, or error number */
5859
UNIV_INTERN
osku's avatar
osku committed
5860 5861 5862
int
ha_innobase::index_next(
/*====================*/
5863
	uchar*		buf)	/*!< in/out: buffer for next row in MySQL
osku's avatar
osku committed
5864 5865
				format */
{
5866
	ha_statistic_increment(&SSV::ha_read_next_count);
osku's avatar
osku committed
5867 5868 5869 5870

	return(general_fetch(buf, ROW_SEL_NEXT, 0));
}

5871
/*******************************************************************//**
5872 5873
Reads the next row matching to the key value given as the parameter.
@return	0, HA_ERR_END_OF_FILE, or error number */
5874
UNIV_INTERN
osku's avatar
osku committed
5875 5876 5877
int
ha_innobase::index_next_same(
/*=========================*/
5878 5879 5880
	uchar*		buf,	/*!< in/out: buffer for the row */
	const uchar*	key,	/*!< in: key value */
	uint		keylen)	/*!< in: key value length */
osku's avatar
osku committed
5881
{
5882
	ha_statistic_increment(&SSV::ha_read_next_count);
osku's avatar
osku committed
5883 5884 5885 5886

	return(general_fetch(buf, ROW_SEL_NEXT, last_match_mode));
}

5887
/***********************************************************************//**
osku's avatar
osku committed
5888
Reads the previous row from a cursor, which must have previously been
5889 5890
positioned using index_read.
@return	0, HA_ERR_END_OF_FILE, or error number */
5891
UNIV_INTERN
osku's avatar
osku committed
5892 5893 5894
int
ha_innobase::index_prev(
/*====================*/
5895
	uchar*	buf)	/*!< in/out: buffer for previous row in MySQL format */
osku's avatar
osku committed
5896
{
5897
	ha_statistic_increment(&SSV::ha_read_prev_count);
5898

osku's avatar
osku committed
5899 5900 5901
	return(general_fetch(buf, ROW_SEL_PREV, 0));
}

5902
/********************************************************************//**
osku's avatar
osku committed
5903
Positions a cursor on the first record in an index and reads the
5904 5905
corresponding row to buf.
@return	0, HA_ERR_END_OF_FILE, or error code */
5906
UNIV_INTERN
osku's avatar
osku committed
5907 5908 5909
int
ha_innobase::index_first(
/*=====================*/
5910
	uchar*	buf)	/*!< in/out: buffer for the row */
osku's avatar
osku committed
5911 5912 5913
{
	int	error;

5914
	DBUG_ENTER("index_first");
5915
	ha_statistic_increment(&SSV::ha_read_first_count);
osku's avatar
osku committed
5916

5917
	error = index_read(buf, NULL, 0, HA_READ_AFTER_KEY);
osku's avatar
osku committed
5918

5919
	/* MySQL does not seem to allow this to return HA_ERR_KEY_NOT_FOUND */
osku's avatar
osku committed
5920

5921 5922 5923
	if (error == HA_ERR_KEY_NOT_FOUND) {
		error = HA_ERR_END_OF_FILE;
	}
osku's avatar
osku committed
5924

5925
	DBUG_RETURN(error);
osku's avatar
osku committed
5926 5927
}

5928
/********************************************************************//**
osku's avatar
osku committed
5929
Positions a cursor on the last record in an index and reads the
5930 5931
corresponding row to buf.
@return	0, HA_ERR_END_OF_FILE, or error code */
5932
UNIV_INTERN
osku's avatar
osku committed
5933 5934 5935
int
ha_innobase::index_last(
/*====================*/
5936
	uchar*	buf)	/*!< in/out: buffer for the row */
osku's avatar
osku committed
5937 5938 5939
{
	int	error;

5940
	DBUG_ENTER("index_last");
5941
	ha_statistic_increment(&SSV::ha_read_last_count);
osku's avatar
osku committed
5942

5943
	error = index_read(buf, NULL, 0, HA_READ_BEFORE_KEY);
osku's avatar
osku committed
5944

5945
	/* MySQL does not seem to allow this to return HA_ERR_KEY_NOT_FOUND */
osku's avatar
osku committed
5946

5947 5948 5949
	if (error == HA_ERR_KEY_NOT_FOUND) {
		error = HA_ERR_END_OF_FILE;
	}
osku's avatar
osku committed
5950

5951
	DBUG_RETURN(error);
osku's avatar
osku committed
5952 5953
}

5954
/****************************************************************//**
5955 5956
Initialize a table scan.
@return	0 or error number */
5957
UNIV_INTERN
osku's avatar
osku committed
5958 5959 5960
int
ha_innobase::rnd_init(
/*==================*/
5961
	bool	scan)	/*!< in: TRUE if table/index scan FALSE otherwise */
osku's avatar
osku committed
5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973
{
	int	err;

	/* Store the active index value so that we can restore the original
	value after a scan */

	if (prebuilt->clust_index_was_generated) {
		err = change_active_index(MAX_KEY);
	} else {
		err = change_active_index(primary_key);
	}

5974 5975 5976 5977 5978 5979 5980
	/* Don't use semi-consistent read in random row reads (by position).
	This means we must disable semi_consistent_read if scan is false */

	if (!scan) {
		try_semi_consistent_read(0);
	}

5981
	start_of_scan = 1;
osku's avatar
osku committed
5982

5983
	return(err);
osku's avatar
osku committed
5984 5985
}

5986
/*****************************************************************//**
5987 5988
Ends a table scan.
@return	0 or error number */
5989
UNIV_INTERN
osku's avatar
osku committed
5990 5991 5992 5993 5994 5995 5996
int
ha_innobase::rnd_end(void)
/*======================*/
{
	return(index_end());
}

5997
/*****************************************************************//**
osku's avatar
osku committed
5998
Reads the next row in a table scan (also used to read the FIRST row
5999 6000
in a table scan).
@return	0, HA_ERR_END_OF_FILE, or error number */
6001
UNIV_INTERN
osku's avatar
osku committed
6002 6003 6004
int
ha_innobase::rnd_next(
/*==================*/
6005
	uchar*	buf)	/*!< in/out: returns the row in this buffer,
osku's avatar
osku committed
6006 6007 6008 6009
			in MySQL format */
{
	int	error;

6010
	DBUG_ENTER("rnd_next");
6011
	ha_statistic_increment(&SSV::ha_read_rnd_next_count);
osku's avatar
osku committed
6012

6013
	if (start_of_scan) {
osku's avatar
osku committed
6014
		error = index_first(buf);
6015

osku's avatar
osku committed
6016 6017 6018
		if (error == HA_ERR_KEY_NOT_FOUND) {
			error = HA_ERR_END_OF_FILE;
		}
6019

osku's avatar
osku committed
6020 6021 6022 6023 6024
		start_of_scan = 0;
	} else {
		error = general_fetch(buf, ROW_SEL_NEXT, 0);
	}

6025
	DBUG_RETURN(error);
osku's avatar
osku committed
6026 6027
}

6028
/**********************************************************************//**
6029 6030
Fetches a row from the table based on a row reference.
@return	0, HA_ERR_KEY_NOT_FOUND, or error code */
6031
UNIV_INTERN
osku's avatar
osku committed
6032 6033 6034
int
ha_innobase::rnd_pos(
/*=================*/
6035 6036
	uchar*	buf,	/*!< in/out: buffer for the row */
	uchar*	pos)	/*!< in: primary key value of the row in the
6037 6038 6039
			MySQL format, or the row id if the clustered
			index was internally generated by InnoDB; the
			length of data in pos has to be ref_length */
osku's avatar
osku committed
6040 6041 6042 6043
{
	int		error;
	uint		keynr	= active_index;
	DBUG_ENTER("rnd_pos");
6044
	DBUG_DUMP("key", pos, ref_length);
osku's avatar
osku committed
6045

6046
	ha_statistic_increment(&SSV::ha_read_rnd_count);
osku's avatar
osku committed
6047

6048
	ut_a(prebuilt->trx == thd_to_trx(ha_thd()));
osku's avatar
osku committed
6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061

	if (prebuilt->clust_index_was_generated) {
		/* No primary key was defined for the table and we
		generated the clustered index from the row id: the
		row reference is the row id, not any key value
		that MySQL knows of */

		error = change_active_index(MAX_KEY);
	} else {
		error = change_active_index(primary_key);
	}

	if (error) {
6062
		DBUG_PRINT("error", ("Got error: %d", error));
osku's avatar
osku committed
6063 6064 6065 6066
		DBUG_RETURN(error);
	}

	/* Note that we assume the length of the row reference is fixed
6067
	for the table, and it is == ref_length */
osku's avatar
osku committed
6068 6069 6070 6071

	error = index_read(buf, pos, ref_length, HA_READ_KEY_EXACT);

	if (error) {
6072
		DBUG_PRINT("error", ("Got error: %d", error));
osku's avatar
osku committed
6073 6074 6075 6076
	}

	change_active_index(keynr);

6077
	DBUG_RETURN(error);
osku's avatar
osku committed
6078 6079
}

6080
/*********************************************************************//**
osku's avatar
osku committed
6081 6082 6083 6084 6085 6086 6087
Stores a reference to the current row to 'ref' field of the handle. Note
that in the case where we have generated the clustered index for the
table, the function parameter is illogical: we MUST ASSUME that 'record'
is the current 'position' of the handle, because if row ref is actually
the row id internally generated in InnoDB, then 'record' does not contain
it. We just guess that the row id must be for the record where the handle
was positioned the last time. */
6088
UNIV_INTERN
osku's avatar
osku committed
6089 6090 6091
void
ha_innobase::position(
/*==================*/
6092
	const uchar*	record)	/*!< in: row in MySQL format */
osku's avatar
osku committed
6093 6094 6095
{
	uint		len;

6096
	ut_a(prebuilt->trx == thd_to_trx(ha_thd()));
osku's avatar
osku committed
6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113

	if (prebuilt->clust_index_was_generated) {
		/* No primary key was defined for the table and we
		generated the clustered index from row id: the
		row reference will be the row id, not any key value
		that MySQL knows of */

		len = DATA_ROW_ID_LEN;

		memcpy(ref, prebuilt->row_id, len);
	} else {
		len = store_key_val_for_row(primary_key, (char*)ref,
							 ref_length, record);
	}

	/* We assume that the 'ref' value len is always fixed for the same
	table. */
6114

osku's avatar
osku committed
6115 6116
	if (len != ref_length) {
	  sql_print_error("Stored ref len is %lu, but table ref len is %lu",
6117
			  (ulong) len, (ulong) ref_length);
osku's avatar
osku committed
6118 6119 6120
	}
}

6121 6122 6123 6124 6125 6126
/* limit innodb monitor access to users with PROCESS privilege.
See http://bugs.mysql.com/32710 for expl. why we choose PROCESS. */
#define IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(table_name, thd) \
	(row_is_magic_monitor_table(table_name) \
	 && check_global_access(thd, PROCESS_ACL))

6127
/*****************************************************************//**
osku's avatar
osku committed
6128 6129 6130 6131 6132
Creates a table definition to an InnoDB database. */
static
int
create_table_def(
/*=============*/
6133 6134
	trx_t*		trx,		/*!< in: InnoDB transaction handle */
	TABLE*		form,		/*!< in: information on table
osku's avatar
osku committed
6135
					columns and indexes */
6136 6137
	const char*	table_name,	/*!< in: table name */
	const char*	path_of_temp_table,/*!< in: if this is a table explicitly
osku's avatar
osku committed
6138 6139 6140 6141 6142 6143 6144
					created by the user with the
					TEMPORARY keyword, then this
					parameter is the dir path where the
					table should be placed if we create
					an .ibd file for it (no .ibd extension
					in the path, though); otherwise this
					is NULL */
6145
	ulint		flags)		/*!< in: table flags */
osku's avatar
osku committed
6146 6147 6148 6149
{
	Field*		field;
	dict_table_t*	table;
	ulint		n_cols;
6150 6151
	int		error;
	ulint		col_type;
osku's avatar
osku committed
6152
	ulint		col_len;
6153
	ulint		nulls_allowed;
osku's avatar
osku committed
6154 6155 6156 6157
	ulint		unsigned_type;
	ulint		binary_type;
	ulint		long_true_varchar;
	ulint		charset_no;
6158
	ulint		i;
osku's avatar
osku committed
6159

6160 6161
	DBUG_ENTER("create_table_def");
	DBUG_PRINT("enter", ("table_name: %s", table_name));
osku's avatar
osku committed
6162

6163 6164 6165 6166 6167 6168
	ut_a(trx->mysql_thd != NULL);
	if (IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(table_name,
						  (THD*) trx->mysql_thd)) {
		DBUG_RETURN(HA_ERR_GENERIC);
	}

osku's avatar
osku committed
6169 6170 6171 6172 6173
	n_cols = form->s->fields;

	/* We pass 0 as the space id, and determine at a lower level the space
	id where to store the table */

6174
	table = dict_mem_table_create(table_name, 0, n_cols, flags);
osku's avatar
osku committed
6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197

	if (path_of_temp_table) {
		table->dir_path_of_temp_table =
			mem_heap_strdup(table->heap, path_of_temp_table);
	}

	for (i = 0; i < n_cols; i++) {
		field = form->field[i];

		col_type = get_innobase_type_from_mysql_type(&unsigned_type,
									field);
		if (field->null_ptr) {
			nulls_allowed = 0;
		} else {
			nulls_allowed = DATA_NOT_NULL;
		}

		if (field->binary()) {
			binary_type = DATA_BINARY_TYPE;
		} else {
			binary_type = 0;
		}

6198
		charset_no = 0;
osku's avatar
osku committed
6199 6200 6201 6202 6203

		if (dtype_is_string_type(col_type)) {

			charset_no = (ulint)field->charset()->number;

6204 6205 6206 6207 6208
			if (UNIV_UNLIKELY(charset_no >= 256)) {
				/* in data0type.h we assume that the
				number fits in one byte in prtype */
				push_warning_printf(
					(THD*) trx->mysql_thd,
6209
					MYSQL_ERROR::WARN_LEVEL_WARN,
6210 6211 6212 6213 6214 6215 6216
					ER_CANT_CREATE_TABLE,
					"In InnoDB, charset-collation codes"
					" must be below 256."
					" Unsupported code %lu.",
					(ulong) charset_no);
				DBUG_RETURN(ER_CANT_CREATE_TABLE);
			}
osku's avatar
osku committed
6217 6218 6219 6220 6221 6222 6223 6224 6225 6226
		}

		ut_a(field->type() < 256); /* we assume in dtype_form_prtype()
					   that this fits in one byte */
		col_len = field->pack_length();

		/* The MySQL pack length contains 1 or 2 bytes length field
		for a true VARCHAR. Let us subtract that, so that the InnoDB
		column length in the InnoDB data dictionary is the real
		maximum byte length of the actual data. */
6227

osku's avatar
osku committed
6228 6229 6230 6231 6232 6233 6234 6235 6236 6237
		long_true_varchar = 0;

		if (field->type() == MYSQL_TYPE_VARCHAR) {
			col_len -= ((Field_varstring*)field)->length_bytes;

			if (((Field_varstring*)field)->length_bytes == 2) {
				long_true_varchar = DATA_LONG_TRUE_VARCHAR;
			}
		}

6238 6239 6240
		/* First check whether the column to be added has a
		system reserved name. */
		if (dict_col_name_is_reserved(field->field_name)){
6241 6242
			my_error(ER_WRONG_COLUMN_NAME, MYF(0),
				 field->field_name);
6243 6244 6245 6246 6247 6248 6249 6250

			dict_mem_table_free(table);
			trx_commit_for_mysql(trx);

			error = DB_ERROR;
			goto error_ret;
		}

6251
		dict_mem_table_add_col(table, table->heap,
6252 6253 6254 6255 6256 6257 6258
			(char*) field->field_name,
			col_type,
			dtype_form_prtype(
				(ulint)field->type()
				| nulls_allowed | unsigned_type
				| binary_type | long_true_varchar,
				charset_no),
6259
			col_len);
osku's avatar
osku committed
6260 6261 6262 6263
	}

	error = row_create_table_for_mysql(table, trx);

6264 6265
	if (error == DB_DUPLICATE_KEY) {
		char buf[100];
6266 6267 6268 6269 6270
		char* buf_end = innobase_convert_identifier(
			buf, sizeof buf - 1, table_name, strlen(table_name),
			trx->mysql_thd, TRUE);

		*buf_end = '\0';
6271 6272 6273
		my_error(ER_TABLE_EXISTS_ERROR, MYF(0), buf);
	}

6274
error_ret:
6275
	error = convert_error_code_to_mysql(error, flags, NULL);
osku's avatar
osku committed
6276 6277 6278 6279

	DBUG_RETURN(error);
}

6280
/*****************************************************************//**
osku's avatar
osku committed
6281 6282 6283 6284 6285
Creates an index in an InnoDB database. */
static
int
create_index(
/*=========*/
6286 6287
	trx_t*		trx,		/*!< in: InnoDB transaction handle */
	TABLE*		form,		/*!< in: information on table
osku's avatar
osku committed
6288
					columns and indexes */
6289 6290 6291
	ulint		flags,		/*!< in: InnoDB table flags */
	const char*	table_name,	/*!< in: table name */
	uint		key_num)	/*!< in: index number */
osku's avatar
osku committed
6292 6293 6294
{
	Field*		field;
	dict_index_t*	index;
6295
	int		error;
osku's avatar
osku committed
6296 6297 6298 6299 6300 6301 6302
	ulint		n_fields;
	KEY*		key;
	KEY_PART_INFO*	key_part;
	ulint		ind_type;
	ulint		col_type;
	ulint		prefix_len;
	ulint		is_unsigned;
6303 6304
	ulint		i;
	ulint		j;
osku's avatar
osku committed
6305
	ulint*		field_lengths;
6306 6307

	DBUG_ENTER("create_index");
osku's avatar
osku committed
6308 6309 6310

	key = form->key_info + key_num;

6311
	n_fields = key->key_parts;
osku's avatar
osku committed
6312

6313 6314 6315
	/* Assert that "GEN_CLUST_INDEX" cannot be used as non-primary index */
	ut_a(innobase_strcasecmp(key->name, innobase_index_reserve_name) != 0);

6316
	ind_type = 0;
osku's avatar
osku committed
6317

6318
	if (key_num == form->s->primary_key) {
osku's avatar
osku committed
6319 6320 6321 6322 6323 6324 6325 6326 6327 6328
		ind_type = ind_type | DICT_CLUSTERED;
	}

	if (key->flags & HA_NOSAME ) {
		ind_type = ind_type | DICT_UNIQUE;
	}

	/* We pass 0 as the space id, and determine at a lower level the space
	id where to store the table */

6329 6330
	index = dict_mem_index_create(table_name, key->name, 0,
				      ind_type, n_fields);
osku's avatar
osku committed
6331 6332 6333

	field_lengths = (ulint*) my_malloc(sizeof(ulint) * n_fields,
		MYF(MY_FAE));
6334

osku's avatar
osku committed
6335 6336 6337 6338 6339 6340 6341 6342
	for (i = 0; i < n_fields; i++) {
		key_part = key->key_part + i;

		/* (The flag HA_PART_KEY_SEG denotes in MySQL a column prefix
		field in an index: we only store a specified number of first
		bytes of the column to the index field.) The flag does not
		seem to be properly set by MySQL. Let us fall back on testing
		the length of the key part versus the column. */
6343

osku's avatar
osku committed
6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363
		field = NULL;
		for (j = 0; j < form->s->fields; j++) {

			field = form->field[j];

			if (0 == innobase_strcasecmp(
					field->field_name,
					key_part->field->field_name)) {
				/* Found the corresponding column */

				break;
			}
		}

		ut_a(j < form->s->fields);

		col_type = get_innobase_type_from_mysql_type(
					&is_unsigned, key_part->field);

		if (DATA_BLOB == col_type
6364 6365 6366 6367 6368
			|| (key_part->length < field->pack_length()
				&& field->type() != MYSQL_TYPE_VARCHAR)
			|| (field->type() == MYSQL_TYPE_VARCHAR
				&& key_part->length < field->pack_length()
				- ((Field_varstring*)field)->length_bytes)) {
osku's avatar
osku committed
6369

6370
			prefix_len = key_part->length;
osku's avatar
osku committed
6371 6372

			if (col_type == DATA_INT
6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384
				|| col_type == DATA_FLOAT
				|| col_type == DATA_DOUBLE
				|| col_type == DATA_DECIMAL) {
				sql_print_error(
					"MySQL is trying to create a column "
					"prefix index field, on an "
					"inappropriate data type. Table "
					"name %s, column name %s.",
					table_name,
					key_part->field->field_name);

				prefix_len = 0;
osku's avatar
osku committed
6385 6386
			}
		} else {
6387
			prefix_len = 0;
osku's avatar
osku committed
6388 6389 6390 6391 6392
		}

		field_lengths[i] = key_part->length;

		dict_mem_index_add_field(index,
6393
			(char*) key_part->field->field_name, prefix_len);
osku's avatar
osku committed
6394 6395
	}

6396 6397 6398
	/* Even though we've defined max_supported_key_part_length, we
	still do our own checking using field_lengths to be absolutely
	sure we don't create too long indexes. */
osku's avatar
osku committed
6399 6400
	error = row_create_index_for_mysql(index, trx, field_lengths);

6401
	error = convert_error_code_to_mysql(error, flags, NULL);
osku's avatar
osku committed
6402

6403
	my_free(field_lengths, MYF(0));
6404

osku's avatar
osku committed
6405 6406 6407
	DBUG_RETURN(error);
}

6408
/*****************************************************************//**
osku's avatar
osku committed
6409 6410 6411 6412 6413 6414
Creates an index to an InnoDB table when the user has defined no
primary index. */
static
int
create_clustered_index_when_no_primary(
/*===================================*/
6415 6416 6417
	trx_t*		trx,		/*!< in: InnoDB transaction handle */
	ulint		flags,		/*!< in: InnoDB table flags */
	const char*	table_name)	/*!< in: table name */
osku's avatar
osku committed
6418 6419
{
	dict_index_t*	index;
6420
	int		error;
osku's avatar
osku committed
6421 6422 6423

	/* We pass 0 as the space id, and determine at a lower level the space
	id where to store the table */
6424 6425
	index = dict_mem_index_create(table_name,
				      innobase_index_reserve_name,
6426
				      0, DICT_CLUSTERED, 0);
6427

osku's avatar
osku committed
6428 6429
	error = row_create_index_for_mysql(index, trx, NULL);

6430
	error = convert_error_code_to_mysql(error, flags, NULL);
osku's avatar
osku committed
6431 6432 6433 6434

	return(error);
}

6435
/*****************************************************************//**
6436 6437 6438
Validates the create options. We may build on this function
in future. For now, it checks two specifiers:
KEY_BLOCK_SIZE and ROW_FORMAT
6439 6440
If innodb_strict_mode is not set then this function is a no-op
@return	TRUE if valid. */
6441 6442 6443 6444
static
ibool
create_options_are_valid(
/*=====================*/
6445 6446
	THD*		thd,		/*!< in: connection thread. */
	TABLE*		form,		/*!< in: information on table
6447
					columns and indexes */
6448
	HA_CREATE_INFO*	create_info)	/*!< in: create info. */
6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477
{
	ibool 	kbs_specified	= FALSE;
	ibool	ret		= TRUE;


	ut_ad(thd != NULL);

	/* If innodb_strict_mode is not set don't do any validation. */
	if (!(THDVAR(thd, strict_mode))) {
		return(TRUE);
	}

	ut_ad(form != NULL);
	ut_ad(create_info != NULL);

	/* First check if KEY_BLOCK_SIZE was specified. */
	if (create_info->key_block_size
	    || (create_info->used_fields & HA_CREATE_USED_KEY_BLOCK_SIZE)) {

		kbs_specified = TRUE;
		switch (create_info->key_block_size) {
		case 1:
		case 2:
		case 4:
		case 8:
		case 16:
			/* Valid value. */
			break;
		default:
6478
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491
					    ER_ILLEGAL_HA_CREATE_OPTION,
					    "InnoDB: invalid"
					    " KEY_BLOCK_SIZE = %lu."
					    " Valid values are"
					    " [1, 2, 4, 8, 16]",
					    create_info->key_block_size);
			ret = FALSE;
		}
	}
	
	/* If KEY_BLOCK_SIZE was specified, check for its
	dependencies. */
	if (kbs_specified && !srv_file_per_table) {
6492
		push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
6493 6494 6495 6496 6497 6498 6499
			     ER_ILLEGAL_HA_CREATE_OPTION,
			     "InnoDB: KEY_BLOCK_SIZE"
			     " requires innodb_file_per_table.");
		ret = FALSE;
	}

	if (kbs_specified && srv_file_format < DICT_TF_FORMAT_ZIP) {
6500
		push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523
			     ER_ILLEGAL_HA_CREATE_OPTION,
			     "InnoDB: KEY_BLOCK_SIZE"
			     " requires innodb_file_format >"
			     " Antelope.");
		ret = FALSE;
	}

	/* Now check for ROW_FORMAT specifier. */
	if (create_info->used_fields & HA_CREATE_USED_ROW_FORMAT) {
		switch (form->s->row_type) {
			const char* row_format_name;
		case ROW_TYPE_COMPRESSED:
		case ROW_TYPE_DYNAMIC:
			row_format_name
				= form->s->row_type == ROW_TYPE_COMPRESSED
				? "COMPRESSED"
				: "DYNAMIC";

			/* These two ROW_FORMATs require
			srv_file_per_table and srv_file_format */
			if (!srv_file_per_table) {
				push_warning_printf(
					thd,
6524
					MYSQL_ERROR::WARN_LEVEL_WARN,
6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535
					ER_ILLEGAL_HA_CREATE_OPTION,
					"InnoDB: ROW_FORMAT=%s"
					" requires innodb_file_per_table.",
					row_format_name);
					ret = FALSE;

			}

			if (srv_file_format < DICT_TF_FORMAT_ZIP) {
				push_warning_printf(
					thd,
6536
					MYSQL_ERROR::WARN_LEVEL_WARN,
6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552
					ER_ILLEGAL_HA_CREATE_OPTION,
					"InnoDB: ROW_FORMAT=%s"
					" requires innodb_file_format >"
					" Antelope.",
					row_format_name);
					ret = FALSE;
			}

			/* Cannot specify KEY_BLOCK_SIZE with
			ROW_FORMAT = DYNAMIC.
			However, we do allow COMPRESSED to be
			specified with KEY_BLOCK_SIZE. */
			if (kbs_specified
			    && form->s->row_type == ROW_TYPE_DYNAMIC) {
				push_warning_printf(
					thd,
6553
					MYSQL_ERROR::WARN_LEVEL_WARN,
6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576
					ER_ILLEGAL_HA_CREATE_OPTION,
					"InnoDB: cannot specify"
					" ROW_FORMAT = DYNAMIC with"
					" KEY_BLOCK_SIZE.");
					ret = FALSE;
			}

			break;

		case ROW_TYPE_REDUNDANT:
		case ROW_TYPE_COMPACT:
		case ROW_TYPE_DEFAULT:
			/* Default is COMPACT. */
			row_format_name
				= form->s->row_type == ROW_TYPE_REDUNDANT
				? "REDUNDANT"
				: "COMPACT";

			/* Cannot specify KEY_BLOCK_SIZE with these
			format specifiers. */
			if (kbs_specified) {
				push_warning_printf(
					thd,
6577
					MYSQL_ERROR::WARN_LEVEL_WARN,
6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589
					ER_ILLEGAL_HA_CREATE_OPTION,
					"InnoDB: cannot specify"
					" ROW_FORMAT = %s with"
					" KEY_BLOCK_SIZE.",
					row_format_name);
					ret = FALSE;
			}

			break;

		default:
			push_warning(thd,
6590
				     MYSQL_ERROR::WARN_LEVEL_WARN,
6591 6592 6593 6594 6595 6596 6597 6598 6599 6600
				     ER_ILLEGAL_HA_CREATE_OPTION,
				     "InnoDB: invalid ROW_FORMAT specifier.");
			ret = FALSE;

		}
	}

	return(ret);
}

6601
/*****************************************************************//**
6602
Update create_info.  Used in SHOW CREATE TABLE et al. */
6603
UNIV_INTERN
6604 6605 6606
void
ha_innobase::update_create_info(
/*============================*/
6607
	HA_CREATE_INFO* create_info)	/*!< in/out: create info */
6608 6609 6610 6611 6612 6613 6614
{
  if (!(create_info->used_fields & HA_CREATE_USED_AUTO)) {
    ha_innobase::info(HA_STATUS_AUTO);
    create_info->auto_increment_value = stats.auto_increment_value;
  }
}

6615
/*****************************************************************//**
6616 6617
Creates a new table to an InnoDB database.
@return	error number */
6618
UNIV_INTERN
osku's avatar
osku committed
6619 6620 6621
int
ha_innobase::create(
/*================*/
6622 6623
	const char*	name,		/*!< in: table name */
	TABLE*		form,		/*!< in: information on table
osku's avatar
osku committed
6624
					columns and indexes */
6625
	HA_CREATE_INFO*	create_info)	/*!< in: more information of the
osku's avatar
osku committed
6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636
					created table, contains also the
					create statement string */
{
	int		error;
	dict_table_t*	innobase_table;
	trx_t*		parent_trx;
	trx_t*		trx;
	int		primary_key_no;
	uint		i;
	char		name2[FN_REFLEN];
	char		norm_name[FN_REFLEN];
6637
	THD*		thd = ha_thd();
6638
	ib_int64_t	auto_inc_value;
6639
	ulint		flags;
6640 6641 6642
	/* Cache the value of innodb_file_format, in case it is
	modified by another thread while the table is being created. */
	const ulint	file_format = srv_file_format;
osku's avatar
osku committed
6643

6644
	DBUG_ENTER("ha_innobase::create");
osku's avatar
osku committed
6645 6646

	DBUG_ASSERT(thd != NULL);
6647 6648 6649 6650 6651 6652 6653
	DBUG_ASSERT(create_info != NULL);

#ifdef __WIN__
	/* Names passed in from server are in two formats:
	1. <database_name>/<table_name>: for normal table creation
	2. full path: for temp table creation, or sym link

6654 6655
	When srv_file_per_table is on and mysqld_embedded is off,
	check for full path pattern, i.e.
6656 6657 6658 6659 6660 6661
	X:\dir\...,		X is a driver letter, or
	\\dir1\dir2\...,	UNC path
	returns error if it is in full path format, but not creating a temp.
	table. Currently InnoDB does not support symbolic link on Windows. */

	if (srv_file_per_table
6662
	    && !mysqld_embedded
6663 6664 6665 6666 6667 6668 6669 6670 6671
	    && (!create_info->options & HA_LEX_CREATE_TMP_TABLE)) {

		if ((name[1] == ':')
		    || (name[0] == '\\' && name[1] == '\\')) {
			sql_print_error("Cannot create table %s\n", name);
			DBUG_RETURN(HA_ERR_GENERIC);
		}
	}
#endif
osku's avatar
osku committed
6672 6673 6674 6675 6676

	if (form->s->fields > 1000) {
		/* The limit probably should be REC_MAX_N_FIELDS - 3 = 1020,
		but we play safe here */

6677 6678
		DBUG_RETURN(HA_ERR_TO_BIG_ROW);
	}
osku's avatar
osku committed
6679 6680 6681

	/* Get the transaction associated with the current thd, or create one
	if not yet created */
6682

6683
	parent_trx = check_trx_exists(thd);
osku's avatar
osku committed
6684 6685 6686 6687

	/* In case MySQL calls this in the middle of a SELECT query, release
	possible adaptive hash latch to avoid deadlocks of threads */

6688 6689
	trx_search_latch_release_if_reserved(parent_trx);

6690
	trx = innobase_trx_allocate(thd);
osku's avatar
osku committed
6691 6692 6693 6694 6695 6696 6697

	if (lower_case_table_names) {
		srv_lower_case_table_names = TRUE;
	} else {
		srv_lower_case_table_names = FALSE;
	}

6698
	strcpy(name2, name);
osku's avatar
osku committed
6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709

	normalize_table_name(norm_name, name2);

	/* Latch the InnoDB data dictionary exclusively so that no deadlocks
	or lock waits can happen in it during a table create operation.
	Drop table etc. do this latching in row0mysql.c. */

	row_mysql_lock_data_dictionary(trx);

	/* Create the table definition in InnoDB */

6710 6711
	flags = 0;

6712 6713 6714 6715 6716
	/* Validate create options if innodb_strict_mode is set. */
	if (!create_options_are_valid(thd, form, create_info)) {
		error = ER_ILLEGAL_HA_CREATE_OPTION;
		goto cleanup;
	}
6717

6718 6719
	if (create_info->key_block_size
	    || (create_info->used_fields & HA_CREATE_USED_KEY_BLOCK_SIZE)) {
6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734
		/* Determine the page_zip.ssize corresponding to the
		requested page size (key_block_size) in kilobytes. */

		ulint	ssize, ksize;
		ulint	key_block_size = create_info->key_block_size;

		for (ssize = ksize = 1; ssize <= DICT_TF_ZSSIZE_MAX;
		     ssize++, ksize <<= 1) {
			if (key_block_size == ksize) {
				flags = ssize << DICT_TF_ZSSIZE_SHIFT
					| DICT_TF_COMPACT
					| DICT_TF_FORMAT_ZIP
					  << DICT_TF_FORMAT_SHIFT;
				break;
			}
6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785
		}

		if (!srv_file_per_table) {
			push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
				     ER_ILLEGAL_HA_CREATE_OPTION,
				     "InnoDB: KEY_BLOCK_SIZE"
				     " requires innodb_file_per_table.");
			flags = 0;
		}

		if (file_format < DICT_TF_FORMAT_ZIP) {
			push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
				     ER_ILLEGAL_HA_CREATE_OPTION,
				     "InnoDB: KEY_BLOCK_SIZE"
				     " requires innodb_file_format >"
				     " Antelope.");
			flags = 0;
		}

		if (!flags) {
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
					    ER_ILLEGAL_HA_CREATE_OPTION,
					    "InnoDB: ignoring"
					    " KEY_BLOCK_SIZE=%lu.",
					    create_info->key_block_size);
		}
	}

	if (create_info->used_fields & HA_CREATE_USED_ROW_FORMAT) {
		if (flags) {
			/* KEY_BLOCK_SIZE was specified. */
			if (form->s->row_type != ROW_TYPE_COMPRESSED) {
				/* ROW_FORMAT other than COMPRESSED
				ignores KEY_BLOCK_SIZE.  It does not
				make sense to reject conflicting
				KEY_BLOCK_SIZE and ROW_FORMAT, because
				such combinations can be obtained
				with ALTER TABLE anyway. */
				push_warning_printf(
					thd,
					MYSQL_ERROR::WARN_LEVEL_WARN,
					ER_ILLEGAL_HA_CREATE_OPTION,
					"InnoDB: ignoring KEY_BLOCK_SIZE=%lu"
					" unless ROW_FORMAT=COMPRESSED.",
					create_info->key_block_size);
				flags = 0;
			}
		} else {
			/* No KEY_BLOCK_SIZE */
			if (form->s->row_type == ROW_TYPE_COMPRESSED) {
				/* ROW_FORMAT=COMPRESSED without
6786 6787 6788 6789
				KEY_BLOCK_SIZE implies half the
				maximum KEY_BLOCK_SIZE. */
				flags = (DICT_TF_ZSSIZE_MAX - 1)
					<< DICT_TF_ZSSIZE_SHIFT
6790 6791
					| DICT_TF_COMPACT
					| DICT_TF_FORMAT_ZIP
6792 6793 6794 6795
					<< DICT_TF_FORMAT_SHIFT;
#if DICT_TF_ZSSIZE_MAX < 1
# error "DICT_TF_ZSSIZE_MAX < 1"
#endif
6796
			}
6797
		}
6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850

		switch (form->s->row_type) {
			const char* row_format_name;
		case ROW_TYPE_REDUNDANT:
			break;
		case ROW_TYPE_COMPRESSED:
		case ROW_TYPE_DYNAMIC:
			row_format_name
				= form->s->row_type == ROW_TYPE_COMPRESSED
				? "COMPRESSED"
				: "DYNAMIC";

			if (!srv_file_per_table) {
				push_warning_printf(
					thd,
					MYSQL_ERROR::WARN_LEVEL_WARN,
					ER_ILLEGAL_HA_CREATE_OPTION,
					"InnoDB: ROW_FORMAT=%s"
					" requires innodb_file_per_table.",
					row_format_name);
			} else if (file_format < DICT_TF_FORMAT_ZIP) {
				push_warning_printf(
					thd,
					MYSQL_ERROR::WARN_LEVEL_WARN,
					ER_ILLEGAL_HA_CREATE_OPTION,
					"InnoDB: ROW_FORMAT=%s"
					" requires innodb_file_format >"
					" Antelope.",
					row_format_name);
			} else {
				flags |= DICT_TF_COMPACT
					| (DICT_TF_FORMAT_ZIP
					   << DICT_TF_FORMAT_SHIFT);
				break;
			}

			/* fall through */
		case ROW_TYPE_NOT_USED:
		case ROW_TYPE_FIXED:
		default:
			push_warning(thd,
				     MYSQL_ERROR::WARN_LEVEL_WARN,
				     ER_ILLEGAL_HA_CREATE_OPTION,
				     "InnoDB: assuming ROW_FORMAT=COMPACT.");
		case ROW_TYPE_DEFAULT:
		case ROW_TYPE_COMPACT:
			flags = DICT_TF_COMPACT;
			break;
		}
	} else if (!flags) {
		/* No KEY_BLOCK_SIZE or ROW_FORMAT specified:
		use ROW_FORMAT=COMPACT by default. */
		flags = DICT_TF_COMPACT;
6851 6852
	}

osku's avatar
osku committed
6853 6854
	/* Look for a primary key */

6855
	primary_key_no= (form->s->primary_key != MAX_KEY ?
6856
			 (int) form->s->primary_key :
osku's avatar
osku committed
6857 6858 6859 6860 6861
			 -1);

	/* Our function row_get_mysql_key_number_for_index assumes
	the primary key is always number 0, if it exists */

6862
	ut_a(primary_key_no == -1 || primary_key_no == 0);
osku's avatar
osku committed
6863

6864 6865
	/* Check for name conflicts (with reserved name) for
	any user indices to be created. */
6866 6867
	if (innobase_index_name_is_reserved(trx, form->key_info,
					    form->s->keys)) {
6868 6869 6870 6871
		error = -1;
		goto cleanup;
	}

6872 6873 6874 6875
	if (create_info->options & HA_LEX_CREATE_TMP_TABLE) {
		flags |= DICT_TF2_TEMPORARY << DICT_TF2_SHIFT;
	}

6876 6877 6878 6879 6880 6881 6882 6883 6884
	error = create_table_def(trx, form, norm_name,
		create_info->options & HA_LEX_CREATE_TMP_TABLE ? name2 : NULL,
		flags);

	if (error) {
		goto cleanup;
	}


osku's avatar
osku committed
6885 6886 6887 6888 6889 6890 6891
	/* Create the keys */

	if (form->s->keys == 0 || primary_key_no == -1) {
		/* Create an index which is used as the clustered index;
		order the rows by their row id which is internally generated
		by InnoDB */

6892
		error = create_clustered_index_when_no_primary(
6893
			trx, flags, norm_name);
6894
		if (error) {
osku's avatar
osku committed
6895
			goto cleanup;
6896
		}
osku's avatar
osku committed
6897 6898 6899 6900 6901
	}

	if (primary_key_no != -1) {
		/* In InnoDB the clustered index must always be created
		first */
6902
		if ((error = create_index(trx, form, flags, norm_name,
osku's avatar
osku committed
6903 6904
					  (uint) primary_key_no))) {
			goto cleanup;
6905 6906
		}
	}
osku's avatar
osku committed
6907 6908 6909 6910 6911

	for (i = 0; i < form->s->keys; i++) {

		if (i != (uint) primary_key_no) {

6912 6913
			if ((error = create_index(trx, form, flags, norm_name,
						  i))) {
osku's avatar
osku committed
6914
				goto cleanup;
6915 6916 6917
			}
		}
	}
osku's avatar
osku committed
6918

6919
	if (*trx->mysql_query_str) {
osku's avatar
osku committed
6920
		error = row_table_add_foreign_constraints(trx,
6921
			*trx->mysql_query_str, norm_name,
osku's avatar
osku committed
6922 6923
			create_info->options & HA_LEX_CREATE_TMP_TABLE);

6924
		error = convert_error_code_to_mysql(error, flags, NULL);
osku's avatar
osku committed
6925 6926 6927 6928 6929 6930

		if (error) {
			goto cleanup;
		}
	}

6931
	innobase_commit_low(trx);
osku's avatar
osku committed
6932 6933 6934 6935 6936 6937 6938 6939 6940

	row_mysql_unlock_data_dictionary(trx);

	/* Flush the log to reduce probability that the .frm files and
	the InnoDB data dictionary get out-of-sync if the user runs
	with innodb_flush_log_at_trx_commit = 0 */

	log_buffer_flush_to_disk();

6941
	innobase_table = dict_table_get(norm_name, FALSE);
osku's avatar
osku committed
6942 6943 6944

	DBUG_ASSERT(innobase_table != 0);

6945 6946 6947
	if (innobase_table) {
		/* We update the highest file format in the system table
		space, if this table has higher file format setting. */
6948

6949 6950 6951 6952
		trx_sys_file_format_max_upgrade(
			(const char**) &innobase_file_format_check,
			dict_table_get_format(innobase_table));
	}
6953 6954 6955 6956 6957

	/* Note: We can't call update_thd() as prebuilt will not be
	setup at this stage and so we use thd. */

	/* We need to copy the AUTOINC value from the old table if
6958 6959
	this is an ALTER TABLE or CREATE INDEX because CREATE INDEX
	does a table copy too. */
6960 6961

	if (((create_info->used_fields & HA_CREATE_USED_AUTO)
6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973
	    || thd_sql_command(thd) == SQLCOM_ALTER_TABLE
	    || thd_sql_command(thd) == SQLCOM_CREATE_INDEX)
	    && create_info->auto_increment_value > 0) {

		/* Query was one of :
		CREATE TABLE ...AUTO_INCREMENT = x; or
		ALTER TABLE...AUTO_INCREMENT = x;   or
		CREATE INDEX x on t(...);
		Find out a table definition from the dictionary and get
		the current value of the auto increment field. Set a new
		value to the auto increment field if the value is greater
		than the maximum value in the column. */
osku's avatar
osku committed
6974 6975

		auto_inc_value = create_info->auto_increment_value;
6976 6977

		dict_table_autoinc_lock(innobase_table);
osku's avatar
osku committed
6978
		dict_table_autoinc_initialize(innobase_table, auto_inc_value);
6979
		dict_table_autoinc_unlock(innobase_table);
osku's avatar
osku committed
6980 6981 6982 6983 6984 6985 6986
	}

	/* Tell the InnoDB server that there might be work for
	utility threads: */

	srv_active_wake_master_thread();

6987
	trx_free_for_mysql(trx);
osku's avatar
osku committed
6988 6989 6990 6991 6992

	DBUG_RETURN(0);

cleanup:
	innobase_commit_low(trx);
6993

osku's avatar
osku committed
6994
	row_mysql_unlock_data_dictionary(trx);
6995

osku's avatar
osku committed
6996 6997 6998 6999 7000
	trx_free_for_mysql(trx);

	DBUG_RETURN(error);
}

7001
/*****************************************************************//**
7002 7003
Discards or imports an InnoDB tablespace.
@return	0 == success, -1 == error */
7004
UNIV_INTERN
osku's avatar
osku committed
7005 7006 7007
int
ha_innobase::discard_or_import_tablespace(
/*======================================*/
7008
	my_bool discard)	/*!< in: TRUE if discard, else import */
osku's avatar
osku committed
7009 7010 7011 7012 7013
{
	dict_table_t*	dict_table;
	trx_t*		trx;
	int		err;

7014
	DBUG_ENTER("ha_innobase::discard_or_import_tablespace");
osku's avatar
osku committed
7015

7016 7017
	ut_a(prebuilt->trx);
	ut_a(prebuilt->trx->magic_n == TRX_MAGIC_N);
7018
	ut_a(prebuilt->trx == thd_to_trx(ha_thd()));
osku's avatar
osku committed
7019 7020 7021 7022 7023 7024 7025 7026 7027 7028

	dict_table = prebuilt->table;
	trx = prebuilt->trx;

	if (discard) {
		err = row_discard_tablespace_for_mysql(dict_table->name, trx);
	} else {
		err = row_import_tablespace_for_mysql(dict_table->name, trx);
	}

7029
	err = convert_error_code_to_mysql(err, dict_table->flags, NULL);
osku's avatar
osku committed
7030 7031 7032 7033

	DBUG_RETURN(err);
}

7034
/*****************************************************************//**
7035 7036
Deletes all rows of an InnoDB table.
@return	error number */
7037
UNIV_INTERN
osku's avatar
osku committed
7038 7039 7040 7041 7042 7043 7044 7045
int
ha_innobase::delete_all_rows(void)
/*==============================*/
{
	int		error;

	DBUG_ENTER("ha_innobase::delete_all_rows");

7046 7047 7048 7049 7050 7051
	/* Get the transaction associated with the current thd, or create one
	if not yet created, and update prebuilt->trx */

	update_thd(ha_thd());

	if (thd_sql_command(user_thd) != SQLCOM_TRUNCATE) {
osku's avatar
osku committed
7052 7053
	fallback:
		/* We only handle TRUNCATE TABLE t as a special case.
7054 7055
		DELETE FROM t will have to use ha_innobase::delete_row(),
		because DELETE is transactional while TRUNCATE is not. */
osku's avatar
osku committed
7056 7057 7058 7059 7060
		DBUG_RETURN(my_errno=HA_ERR_WRONG_COMMAND);
	}

	/* Truncate the table in InnoDB */

7061
	error = row_truncate_table_for_mysql(prebuilt->table, prebuilt->trx);
osku's avatar
osku committed
7062 7063 7064 7065 7066
	if (error == DB_ERROR) {
		/* Cannot truncate; resort to ha_innobase::delete_row() */
		goto fallback;
	}

7067 7068
	error = convert_error_code_to_mysql(error, prebuilt->table->flags,
					    NULL);
osku's avatar
osku committed
7069 7070 7071 7072

	DBUG_RETURN(error);
}

7073
/*****************************************************************//**
osku's avatar
osku committed
7074 7075 7076 7077
Drops a table from an InnoDB database. Before calling this function,
MySQL calls innobase_commit to commit the transaction of the current user.
Then the current user cannot have locks set on the table. Drop table
operation inside InnoDB will remove all locks any user has on the table
7078 7079
inside InnoDB.
@return	error number */
7080
UNIV_INTERN
osku's avatar
osku committed
7081 7082 7083
int
ha_innobase::delete_table(
/*======================*/
7084
	const char*	name)	/*!< in: table name */
osku's avatar
osku committed
7085 7086 7087 7088 7089
{
	ulint	name_len;
	int	error;
	trx_t*	parent_trx;
	trx_t*	trx;
7090
	THD	*thd = ha_thd();
osku's avatar
osku committed
7091 7092
	char	norm_name[1000];

7093
	DBUG_ENTER("ha_innobase::delete_table");
osku's avatar
osku committed
7094

7095 7096 7097 7098 7099 7100 7101 7102
	/* Strangely, MySQL passes the table name without the '.frm'
	extension, in contrast to ::create */
	normalize_table_name(norm_name, name);

	if (IS_MAGIC_TABLE_AND_USER_DENIED_ACCESS(norm_name, thd)) {
		DBUG_RETURN(HA_ERR_GENERIC);
	}

osku's avatar
osku committed
7103 7104
	/* Get the transaction associated with the current thd, or create one
	if not yet created */
7105

7106
	parent_trx = check_trx_exists(thd);
osku's avatar
osku committed
7107 7108 7109 7110

	/* In case MySQL calls this in the middle of a SELECT query, release
	possible adaptive hash latch to avoid deadlocks of threads */

7111
	trx_search_latch_release_if_reserved(parent_trx);
osku's avatar
osku committed
7112

7113 7114
	trx = innobase_trx_allocate(thd);

osku's avatar
osku committed
7115 7116 7117 7118 7119 7120 7121 7122
	if (lower_case_table_names) {
		srv_lower_case_table_names = TRUE;
	} else {
		srv_lower_case_table_names = FALSE;
	}

	name_len = strlen(name);

7123
	ut_a(name_len < 1000);
osku's avatar
osku committed
7124

7125
	/* Drop the table in InnoDB */
osku's avatar
osku committed
7126 7127

	error = row_drop_table_for_mysql(norm_name, trx,
7128 7129
					 thd_sql_command(thd)
					 == SQLCOM_DROP_DB);
osku's avatar
osku committed
7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141

	/* Flush the log to reduce probability that the .frm files and
	the InnoDB data dictionary get out-of-sync if the user runs
	with innodb_flush_log_at_trx_commit = 0 */

	log_buffer_flush_to_disk();

	/* Tell the InnoDB server that there might be work for
	utility threads: */

	srv_active_wake_master_thread();

7142
	innobase_commit_low(trx);
osku's avatar
osku committed
7143

7144
	trx_free_for_mysql(trx);
osku's avatar
osku committed
7145

7146
	error = convert_error_code_to_mysql(error, 0, NULL);
osku's avatar
osku committed
7147 7148 7149 7150

	DBUG_RETURN(error);
}

7151
/*****************************************************************//**
osku's avatar
osku committed
7152
Removes all tables in the named database inside InnoDB. */
7153
static
osku's avatar
osku committed
7154
void
osku's avatar
osku committed
7155 7156
innobase_drop_database(
/*===================*/
7157 7158
	handlerton *hton, /*!< in: handlerton of Innodb */
	char*	path)	/*!< in: database path; inside InnoDB the name
osku's avatar
osku committed
7159 7160 7161 7162 7163 7164 7165 7166 7167
			of the last directory in the path is used as
			the database name: for example, in 'mysql/data/test'
			the database name is 'test' */
{
	ulint	len		= 0;
	trx_t*	trx;
	char*	ptr;
	int	error;
	char*	namebuf;
7168
	THD*	thd		= current_thd;
osku's avatar
osku committed
7169 7170 7171

	/* Get the transaction associated with the current thd, or create one
	if not yet created */
7172

7173 7174
	DBUG_ASSERT(hton == innodb_hton_ptr);

7175 7176 7177
	/* In the Windows plugin, thd = current_thd is always NULL */
	if (thd) {
		trx_t*	parent_trx = check_trx_exists(thd);
osku's avatar
osku committed
7178

7179 7180 7181
		/* In case MySQL calls this in the middle of a SELECT
		query, release possible adaptive hash latch to avoid
		deadlocks of threads */
osku's avatar
osku committed
7182

7183 7184
		trx_search_latch_release_if_reserved(parent_trx);
	}
osku's avatar
osku committed
7185 7186 7187 7188 7189 7190 7191 7192 7193

	ptr = strend(path) - 2;

	while (ptr >= path && *ptr != '\\' && *ptr != '/') {
		ptr--;
		len++;
	}

	ptr++;
7194
	namebuf = (char*) my_malloc((uint) len + 2, MYF(0));
osku's avatar
osku committed
7195 7196 7197 7198

	memcpy(namebuf, ptr, len);
	namebuf[len] = '/';
	namebuf[len + 1] = '\0';
7199
#ifdef	__WIN__
osku's avatar
osku committed
7200 7201
	innobase_casedn_str(namebuf);
#endif
7202 7203
#if defined __WIN__ && !defined MYSQL_SERVER
	/* In the Windows plugin, thd = current_thd is always NULL */
osku's avatar
osku committed
7204
	trx = trx_allocate_for_mysql();
7205 7206 7207 7208 7209
	trx->mysql_thd = NULL;
	trx->mysql_query_str = NULL;
#else
	trx = innobase_trx_allocate(thd);
#endif
7210
	error = row_drop_database_for_mysql(namebuf, trx);
osku's avatar
osku committed
7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223
	my_free(namebuf, MYF(0));

	/* Flush the log to reduce probability that the .frm files and
	the InnoDB data dictionary get out-of-sync if the user runs
	with innodb_flush_log_at_trx_commit = 0 */

	log_buffer_flush_to_disk();

	/* Tell the InnoDB server that there might be work for
	utility threads: */

	srv_active_wake_master_thread();

7224 7225
	innobase_commit_low(trx);
	trx_free_for_mysql(trx);
osku's avatar
osku committed
7226
}
7227
/*********************************************************************//**
7228 7229
Renames an InnoDB table.
@return	0 or error code */
7230 7231 7232 7233
static
int
innobase_rename_table(
/*==================*/
7234 7235 7236
	trx_t*		trx,	/*!< in: transaction */
	const char*	from,	/*!< in: old name of the table */
	const char*	to,	/*!< in: new name of the table */
7237
	ibool		lock_and_commit)
7238
				/*!< in: TRUE=lock data dictionary and commit */
7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253
{
	int	error;
	char*	norm_to;
	char*	norm_from;

	if (lower_case_table_names) {
		srv_lower_case_table_names = TRUE;
	} else {
		srv_lower_case_table_names = FALSE;
	}

	// Magic number 64 arbitrary
	norm_to = (char*) my_malloc(strlen(to) + 64, MYF(0));
	norm_from = (char*) my_malloc(strlen(from) + 64, MYF(0));

7254 7255
	normalize_table_name(norm_to, to);
	normalize_table_name(norm_from, from);
7256 7257 7258 7259

	/* Serialize data dictionary operations with dictionary mutex:
	no deadlocks can occur then in these operations */

7260 7261 7262
	if (lock_and_commit) {
		row_mysql_lock_data_dictionary(trx);
	}
7263 7264

	error = row_rename_table_for_mysql(
7265
		norm_from, norm_to, trx, lock_and_commit);
7266 7267 7268 7269

	if (error != DB_SUCCESS) {
		FILE* ef = dict_foreign_err_file;

7270 7271
		fputs("InnoDB: Renaming table ", ef);
		ut_print_name(ef, trx, TRUE, norm_from);
7272
		fputs(" to ", ef);
7273
		ut_print_name(ef, trx, TRUE, norm_to);
7274 7275 7276
		fputs(" failed!\n", ef);
	}

7277 7278
	if (lock_and_commit) {
		row_mysql_unlock_data_dictionary(trx);
7279

7280 7281 7282
		/* Flush the log to reduce probability that the .frm
		files and the InnoDB data dictionary get out-of-sync
		if the user runs with innodb_flush_log_at_trx_commit = 0 */
7283

7284 7285
		log_buffer_flush_to_disk();
	}
osku's avatar
osku committed
7286

7287 7288 7289 7290 7291
	my_free(norm_to, MYF(0));
	my_free(norm_from, MYF(0));

	return error;
}
7292
/*********************************************************************//**
7293 7294
Renames an InnoDB table.
@return	0 or error code */
7295
UNIV_INTERN
osku's avatar
osku committed
7296 7297 7298
int
ha_innobase::rename_table(
/*======================*/
7299 7300
	const char*	from,	/*!< in: old name of the table */
	const char*	to)	/*!< in: new name of the table */
osku's avatar
osku committed
7301
{
7302
	trx_t*	trx;
osku's avatar
osku committed
7303 7304
	int	error;
	trx_t*	parent_trx;
7305
	THD*	thd		= ha_thd();
osku's avatar
osku committed
7306

7307
	DBUG_ENTER("ha_innobase::rename_table");
osku's avatar
osku committed
7308 7309 7310

	/* Get the transaction associated with the current thd, or create one
	if not yet created */
7311

7312
	parent_trx = check_trx_exists(thd);
osku's avatar
osku committed
7313 7314 7315 7316

	/* In case MySQL calls this in the middle of a SELECT query, release
	possible adaptive hash latch to avoid deadlocks of threads */

7317
	trx_search_latch_release_if_reserved(parent_trx);
osku's avatar
osku committed
7318

7319
	trx = innobase_trx_allocate(thd);
osku's avatar
osku committed
7320

7321
	error = innobase_rename_table(trx, from, to, TRUE);
osku's avatar
osku committed
7322 7323 7324 7325 7326 7327

	/* Tell the InnoDB server that there might be work for
	utility threads: */

	srv_active_wake_master_thread();

7328 7329
	innobase_commit_low(trx);
	trx_free_for_mysql(trx);
osku's avatar
osku committed
7330

7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348
	/* Add a special case to handle the Duplicated Key error
	and return DB_ERROR instead.
	This is to avoid a possible SIGSEGV error from mysql error
	handling code. Currently, mysql handles the Duplicated Key
	error by re-entering the storage layer and getting dup key
	info by calling get_dup_key(). This operation requires a valid
	table handle ('row_prebuilt_t' structure) which could no
	longer be available in the error handling stage. The suggested
	solution is to report a 'table exists' error message (since
	the dup key error here is due to an existing table whose name
	is the one we are trying to rename to) and return the generic
	error code. */
	if (error == (int) DB_DUPLICATE_KEY) {
		my_error(ER_TABLE_EXISTS_ERROR, MYF(0), to);

		error = DB_ERROR;
	}

7349
	error = convert_error_code_to_mysql(error, 0, NULL);
osku's avatar
osku committed
7350 7351 7352 7353

	DBUG_RETURN(error);
}

7354
/*********************************************************************//**
7355 7356
Estimates the number of index records in a range.
@return	estimated number of rows */
7357
UNIV_INTERN
osku's avatar
osku committed
7358 7359 7360
ha_rows
ha_innobase::records_in_range(
/*==========================*/
7361 7362
	uint			keynr,		/*!< in: index number */
	key_range		*min_key,	/*!< in: start key value of the
7363
						   range, may also be 0 */
7364
	key_range		*max_key)	/*!< in: range end key val, may
7365
						   also be 0 */
osku's avatar
osku committed
7366 7367 7368
{
	KEY*		key;
	dict_index_t*	index;
7369
	uchar*		key_val_buff2	= (uchar*) my_malloc(
osku's avatar
osku committed
7370
						  table->s->reclength
7371
					+ table->s->max_key_length + 100,
osku's avatar
osku committed
7372 7373
								MYF(MY_FAE));
	ulint		buff2_len = table->s->reclength
7374
					+ table->s->max_key_length + 100;
osku's avatar
osku committed
7375 7376
	dtuple_t*	range_start;
	dtuple_t*	range_end;
7377
	ib_int64_t	n_rows;
osku's avatar
osku committed
7378 7379
	ulint		mode1;
	ulint		mode2;
7380
	mem_heap_t*	heap;
osku's avatar
osku committed
7381

7382
	DBUG_ENTER("records_in_range");
osku's avatar
osku committed
7383

7384
	ut_a(prebuilt->trx == thd_to_trx(ha_thd()));
7385

osku's avatar
osku committed
7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396
	prebuilt->trx->op_info = (char*)"estimating records in index range";

	/* In case MySQL calls this in the middle of a SELECT query, release
	possible adaptive hash latch to avoid deadlocks of threads */

	trx_search_latch_release_if_reserved(prebuilt->trx);

	active_index = keynr;

	key = table->key_info + active_index;

7397
	index = innobase_get_index(keynr);
7398

7399 7400 7401 7402 7403 7404 7405
	/* There exists possibility of not being able to find requested
	index due to inconsistency between MySQL and InoDB dictionary info.
	Necessary message should have been printed in innobase_get_index() */
	if (UNIV_UNLIKELY(!index)) {
		n_rows = HA_POS_ERROR;
		goto func_exit;
	}
osku's avatar
osku committed
7406

7407 7408 7409 7410
	heap = mem_heap_create(2 * (key->key_parts * sizeof(dfield_t)
				    + sizeof(dtuple_t)));

	range_start = dtuple_create(heap, key->key_parts);
7411
	dict_index_copy_types(range_start, index, key->key_parts);
osku's avatar
osku committed
7412

7413
	range_end = dtuple_create(heap, key->key_parts);
7414
	dict_index_copy_types(range_end, index, key->key_parts);
osku's avatar
osku committed
7415 7416 7417 7418 7419 7420

	row_sel_convert_mysql_key_to_innobase(
				range_start, (byte*) key_val_buff,
				(ulint)upd_and_key_val_buff_len,
				index,
				(byte*) (min_key ? min_key->key :
7421
					 (const uchar*) 0),
osku's avatar
osku committed
7422 7423 7424 7425 7426 7427 7428
				(ulint) (min_key ? min_key->length : 0),
				prebuilt->trx);

	row_sel_convert_mysql_key_to_innobase(
				range_end, (byte*) key_val_buff2,
				buff2_len, index,
				(byte*) (max_key ? max_key->key :
7429
					 (const uchar*) 0),
osku's avatar
osku committed
7430 7431 7432 7433
				(ulint) (max_key ? max_key->length : 0),
				prebuilt->trx);

	mode1 = convert_search_mode_to_innobase(min_key ? min_key->flag :
7434
						HA_READ_KEY_EXACT);
osku's avatar
osku committed
7435
	mode2 = convert_search_mode_to_innobase(max_key ? max_key->flag :
7436
						HA_READ_KEY_EXACT);
osku's avatar
osku committed
7437

7438 7439 7440 7441 7442 7443 7444
	if (mode1 != PAGE_CUR_UNSUPP && mode2 != PAGE_CUR_UNSUPP) {

		n_rows = btr_estimate_n_rows_in_range(index, range_start,
						      mode1, range_end,
						      mode2);
	} else {

7445
		n_rows = HA_POS_ERROR;
7446 7447
	}

7448
	mem_heap_free(heap);
osku's avatar
osku committed
7449

7450
func_exit:
7451
	my_free(key_val_buff2, MYF(0));
osku's avatar
osku committed
7452 7453 7454 7455 7456 7457 7458 7459 7460 7461

	prebuilt->trx->op_info = (char*)"";

	/* The MySQL optimizer seems to believe an estimate of 0 rows is
	always accurate and may return the result 'Empty set' based on that.
	The accuracy is not guaranteed, and even if it were, for a locking
	read we should anyway perform the search to set the next-key lock.
	Add 1 to the value to make sure MySQL does not make the assumption! */

	if (n_rows == 0) {
7462
		n_rows = 1;
osku's avatar
osku committed
7463 7464 7465 7466 7467
	}

	DBUG_RETURN((ha_rows) n_rows);
}

7468
/*********************************************************************//**
osku's avatar
osku committed
7469
Gives an UPPER BOUND to the number of rows in a table. This is used in
7470 7471
filesort.cc.
@return	upper bound of rows */
7472
UNIV_INTERN
osku's avatar
osku committed
7473 7474 7475 7476 7477 7478 7479 7480
ha_rows
ha_innobase::estimate_rows_upper_bound(void)
/*======================================*/
{
	dict_index_t*	index;
	ulonglong	estimate;
	ulonglong	local_data_file_length;

7481
	DBUG_ENTER("estimate_rows_upper_bound");
osku's avatar
osku committed
7482 7483 7484 7485 7486

	/* We do not know if MySQL can call this function before calling
	external_lock(). To be safe, update the thd of the current table
	handle. */

7487
	update_thd(ha_thd());
osku's avatar
osku committed
7488 7489

	prebuilt->trx->op_info = (char*)
7490
				 "calculating upper bound for table rows";
osku's avatar
osku committed
7491 7492 7493 7494 7495 7496

	/* In case MySQL calls this in the middle of a SELECT query, release
	possible adaptive hash latch to avoid deadlocks of threads */

	trx_search_latch_release_if_reserved(prebuilt->trx);

7497
	index = dict_table_get_first_index(prebuilt->table);
osku's avatar
osku committed
7498

7499 7500 7501 7502 7503
	ut_a(index->stat_n_leaf_pages > 0);

	local_data_file_length =
		((ulonglong) index->stat_n_leaf_pages) * UNIV_PAGE_SIZE;

osku's avatar
osku committed
7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517

	/* Calculate a minimum length for a clustered index record and from
	that an upper bound for the number of rows. Since we only calculate
	new statistics in row0mysql.c when a table has grown by a threshold
	factor, we must add a safety factor 2 in front of the formula below. */

	estimate = 2 * local_data_file_length /
					 dict_index_calc_min_rec_len(index);

	prebuilt->trx->op_info = (char*)"";

	DBUG_RETURN((ha_rows) estimate);
}

7518
/*********************************************************************//**
osku's avatar
osku committed
7519 7520
How many seeks it will take to read through the table. This is to be
comparable to the number returned by records_in_range so that we can
7521 7522
decide if we should scan the table or use keys.
@return	estimated time measured in disk seeks */
7523
UNIV_INTERN
osku's avatar
osku committed
7524 7525 7526 7527 7528 7529 7530 7531
double
ha_innobase::scan_time()
/*====================*/
{
	/* Since MySQL seems to favor table scans too much over index
	searches, we pretend that a sequential read takes the same time
	as a random disk read, that is, we do not divide the following
	by 10, which would be physically realistic. */
7532

osku's avatar
osku committed
7533 7534 7535
	return((double) (prebuilt->table->stat_clustered_index_size));
}

7536
/******************************************************************//**
osku's avatar
osku committed
7537
Calculate the time it takes to read a set of ranges through an index
7538 7539
This enables us to optimise reads for clustered indexes.
@return	estimated time measured in disk seeks */
7540
UNIV_INTERN
osku's avatar
osku committed
7541 7542 7543
double
ha_innobase::read_time(
/*===================*/
7544 7545 7546
	uint	index,	/*!< in: key number */
	uint	ranges,	/*!< in: how many ranges */
	ha_rows rows)	/*!< in: estimated number of rows in the ranges */
osku's avatar
osku committed
7547 7548
{
	ha_rows total_rows;
7549 7550
	double	time_for_scan;

osku's avatar
osku committed
7551
	if (index != table->s->primary_key) {
7552 7553
		/* Not clustered */
		return(handler::read_time(index, ranges, rows));
osku's avatar
osku committed
7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567
	}

	if (rows <= 2) {

		return((double) rows);
	}

	/* Assume that the read time is proportional to the scan time for all
	rows + at most one seek per range. */

	time_for_scan = scan_time();

	if ((total_rows = estimate_rows_upper_bound()) < rows) {

7568
		return(time_for_scan);
osku's avatar
osku committed
7569 7570 7571 7572 7573
	}

	return(ranges + (double) rows / (double) total_rows * time_for_scan);
}

7574
/*********************************************************************//**
osku's avatar
osku committed
7575 7576
Returns statistics information of the table to the MySQL interpreter,
in various fields of the handle object. */
7577
UNIV_INTERN
7578
int
osku's avatar
osku committed
7579 7580
ha_innobase::info(
/*==============*/
7581
	uint flag)	/*!< in: what information MySQL requests */
osku's avatar
osku committed
7582 7583 7584 7585
{
	dict_table_t*	ib_table;
	dict_index_t*	index;
	ha_rows		rec_per_key;
7586
	ib_int64_t	n_rows;
osku's avatar
osku committed
7587 7588 7589
	ulong		j;
	ulong		i;
	char		path[FN_REFLEN];
7590
	os_file_stat_t	stat_info;
osku's avatar
osku committed
7591

7592

7593
	DBUG_ENTER("info");
osku's avatar
osku committed
7594

7595
	/* If we are forcing recovery at a high level, we will suppress
osku's avatar
osku committed
7596 7597 7598
	statistics calculation on tables, because that may crash the
	server if an index is badly corrupted. */

7599
	if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
osku's avatar
osku committed
7600

7601 7602 7603 7604 7605 7606
		/* We return success (0) instead of HA_ERR_CRASHED,
		because we want MySQL to process this query and not
		stop, like it would do if it received the error code
		HA_ERR_CRASHED. */

		DBUG_RETURN(0);
7607
	}
osku's avatar
osku committed
7608 7609 7610 7611 7612

	/* We do not know if MySQL can call this function before calling
	external_lock(). To be safe, update the thd of the current table
	handle. */

7613
	update_thd(ha_thd());
osku's avatar
osku committed
7614 7615 7616 7617 7618 7619 7620 7621

	/* In case MySQL calls this in the middle of a SELECT query, release
	possible adaptive hash latch to avoid deadlocks of threads */

	prebuilt->trx->op_info = (char*)"returning various info to MySQL";

	trx_search_latch_release_if_reserved(prebuilt->trx);

7622
	ib_table = prebuilt->table;
osku's avatar
osku committed
7623

7624
	if (flag & HA_STATUS_TIME) {
7625
		if (innobase_stats_on_metadata) {
7626 7627
			/* In sql_show we call with this flag: update
			then statistics so that they are up-to-date */
osku's avatar
osku committed
7628

7629
			prebuilt->trx->op_info = "updating table statistics";
osku's avatar
osku committed
7630

7631
			dict_update_statistics(ib_table);
osku's avatar
osku committed
7632

7633
			prebuilt->trx->op_info = "returning various info to MySQL";
7634
		}
osku's avatar
osku committed
7635

7636
		my_snprintf(path, sizeof(path), "%s/%s%s",
7637 7638
				mysql_data_home, ib_table->name, reg_ext);

7639
		unpack_filename(path,path);
osku's avatar
osku committed
7640

7641
		/* Note that we do not know the access time of the table,
osku's avatar
osku committed
7642 7643 7644
		nor the CHECK TABLE time, nor the UPDATE or INSERT time. */

		if (os_file_get_status(path,&stat_info)) {
7645
			stats.create_time = (ulong) stat_info.ctime;
osku's avatar
osku committed
7646
		}
7647
	}
osku's avatar
osku committed
7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672

	if (flag & HA_STATUS_VARIABLE) {
		n_rows = ib_table->stat_n_rows;

		/* Because we do not protect stat_n_rows by any mutex in a
		delete, it is theoretically possible that the value can be
		smaller than zero! TODO: fix this race.

		The MySQL optimizer seems to assume in a left join that n_rows
		is an accurate estimate if it is zero. Of course, it is not,
		since we do not have any locks on the rows yet at this phase.
		Since SHOW TABLE STATUS seems to call this function with the
		HA_STATUS_TIME flag set, while the left join optimizer does not
		set that flag, we add one to a zero value if the flag is not
		set. That way SHOW TABLE STATUS will show the best estimate,
		while the optimizer never sees the table empty. */

		if (n_rows < 0) {
			n_rows = 0;
		}

		if (n_rows == 0 && !(flag & HA_STATUS_TIME)) {
			n_rows++;
		}

7673 7674 7675 7676
		/* Fix bug#40386: Not flushing query cache after truncate.
		n_rows can not be 0 unless the table is empty, set to 1
		instead. The original problem of bug#29507 is actually
		fixed in the server code. */
7677 7678
		if (thd_sql_command(user_thd) == SQLCOM_TRUNCATE) {

7679
			n_rows = 1;
7680 7681 7682 7683 7684 7685 7686

			/* We need to reset the prebuilt value too, otherwise
			checks for values greater than the last value written
			to the table will fail and the autoinc counter will
			not be updated. This will force write_row() into
			attempting an update of the table's AUTOINC counter. */

7687
			prebuilt->autoinc_last_value = 0;
7688 7689
		}

7690 7691 7692
		stats.records = (ha_rows)n_rows;
		stats.deleted = 0;
		stats.data_file_length = ((ulonglong)
osku's avatar
osku committed
7693
				ib_table->stat_clustered_index_size)
7694
					* UNIV_PAGE_SIZE;
7695
		stats.index_file_length = ((ulonglong)
osku's avatar
osku committed
7696
				ib_table->stat_sum_of_other_index_sizes)
7697
					* UNIV_PAGE_SIZE;
7698 7699 7700 7701 7702 7703 7704 7705 7706 7707

		/* Since fsp_get_available_space_in_free_extents() is
		acquiring latches inside InnoDB, we do not call it if we
		are asked by MySQL to avoid locking. Another reason to
		avoid the call is that it uses quite a lot of CPU.
		See Bug#38185.
		We do not update delete_length if no locking is requested
		so the "old" value can remain. delete_length is initialized
		to 0 in the ha_statistics' constructor. */
		if (!(flag & HA_STATUS_NO_LOCK)) {
7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721

			/* lock the data dictionary to avoid races with
			ibd_file_missing and tablespace_discarded */
			row_mysql_lock_data_dictionary(prebuilt->trx);

			/* ib_table->space must be an existent tablespace */
			if (!ib_table->ibd_file_missing
			    && !ib_table->tablespace_discarded) {

				stats.delete_length =
					fsp_get_available_space_in_free_extents(
						ib_table->space) * 1024;
			} else {

7722 7723 7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736
				THD*	thd;

				thd = ha_thd();

				push_warning_printf(
					thd,
					MYSQL_ERROR::WARN_LEVEL_WARN,
					ER_CANT_GET_STAT,
					"InnoDB: Trying to get the free "
					"space for table %s but its "
					"tablespace has been discarded or "
					"the .ibd file is missing. Setting "
					"the free space to zero.",
					ib_table->name);

7737 7738 7739 7740
				stats.delete_length = 0;
			}

			row_mysql_unlock_data_dictionary(prebuilt->trx);
7741 7742
		}

7743
		stats.check_time = 0;
osku's avatar
osku committed
7744

7745 7746
		if (stats.records == 0) {
			stats.mean_rec_length = 0;
7747
		} else {
7748
			stats.mean_rec_length = (ulong) (stats.data_file_length / stats.records);
7749 7750
		}
	}
osku's avatar
osku committed
7751 7752

	if (flag & HA_STATUS_CONST) {
7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765
		/* Verify the number of index in InnoDB and MySQL
		matches up. If prebuilt->clust_index_was_generated
		holds, InnoDB defines GEN_CLUST_INDEX internally */
		ulint	num_innodb_index = UT_LIST_GET_LEN(ib_table->indexes)
					- prebuilt->clust_index_was_generated;

		if (table->s->keys != num_innodb_index) {
			sql_print_error("Table %s contains %lu "
					"indexes inside InnoDB, which "
					"is different from the number of "
					"indexes %u defined in the MySQL ",
					ib_table->name, num_innodb_index,
					table->s->keys);
osku's avatar
osku committed
7766 7767 7768
		}

		for (i = 0; i < table->s->keys; i++) {
7769 7770 7771 7772 7773 7774 7775
			/* We could get index quickly through internal
			index mapping with the index translation table.
			The identity of index (match up index name with
			that of table->key_info[i]) is already verified in
			innobase_get_index().  */
			index = innobase_get_index(i);

osku's avatar
osku committed
7776
			if (index == NULL) {
7777
				sql_print_error("Table %s contains fewer "
osku's avatar
osku committed
7778 7779 7780 7781
						"indexes inside InnoDB than "
						"are defined in the MySQL "
						".frm file. Have you mixed up "
						".frm files from different "
7782
						"installations? See "
7783 7784
						REFMAN
						"innodb-troubleshooting.html\n",
osku's avatar
osku committed
7785 7786 7787 7788 7789 7790 7791
						ib_table->name);
				break;
			}

			for (j = 0; j < table->key_info[i].key_parts; j++) {

				if (j + 1 > index->n_uniq) {
7792 7793 7794 7795
					sql_print_error(
"Index %s of %s has %lu columns unique inside InnoDB, but MySQL is asking "
"statistics for %lu columns. Have you mixed up .frm files from different "
"installations? "
7796
"See " REFMAN "innodb-troubleshooting.html\n",
osku's avatar
osku committed
7797 7798 7799 7800
							index->name,
							ib_table->name,
							(unsigned long)
							index->n_uniq, j + 1);
7801
					break;
osku's avatar
osku committed
7802 7803 7804 7805
				}

				if (index->stat_n_diff_key_vals[j + 1] == 0) {

7806
					rec_per_key = stats.records;
osku's avatar
osku committed
7807
				} else {
7808
					rec_per_key = (ha_rows)(stats.records /
7809
					 index->stat_n_diff_key_vals[j + 1]);
osku's avatar
osku committed
7810 7811 7812 7813 7814 7815 7816 7817 7818 7819 7820 7821 7822
				}

				/* Since MySQL seems to favor table scans
				too much over index searches, we pretend
				index selectivity is 2 times better than
				our estimate: */

				rec_per_key = rec_per_key / 2;

				if (rec_per_key == 0) {
					rec_per_key = 1;
				}

7823
				table->key_info[i].rec_per_key[j]=
osku's avatar
osku committed
7824
				  rec_per_key >= ~(ulong) 0 ? ~(ulong) 0 :
7825
				  (ulong) rec_per_key;
osku's avatar
osku committed
7826 7827 7828 7829
			}
		}
	}

7830
	if (flag & HA_STATUS_ERRKEY) {
marko's avatar
marko committed
7831
		const dict_index_t*	err_index;
7832

7833 7834
		ut_a(prebuilt->trx);
		ut_a(prebuilt->trx->magic_n == TRX_MAGIC_N);
osku's avatar
osku committed
7835

marko's avatar
marko committed
7836
		err_index = trx_get_error_info(prebuilt->trx);
7837 7838 7839 7840 7841 7842 7843

		if (err_index) {
			errkey = (unsigned int)
				row_get_mysql_key_number_for_index(err_index);
		} else {
			errkey = (unsigned int) prebuilt->trx->error_key_num;
		}
7844
	}
osku's avatar
osku committed
7845

7846 7847
	if ((flag & HA_STATUS_AUTO) && table->found_next_number_field) {
		stats.auto_increment_value = innobase_peek_autoinc();
osku's avatar
osku committed
7848 7849 7850 7851
	}

	prebuilt->trx->op_info = (char*)"";

7852
	DBUG_RETURN(0);
osku's avatar
osku committed
7853 7854
}

7855
/**********************************************************************//**
osku's avatar
osku committed
7856
Updates index cardinalities of the table, based on 8 random dives into
7857 7858
each index tree. This does NOT calculate exact statistics on the table.
@return	returns always 0 (success) */
7859
UNIV_INTERN
osku's avatar
osku committed
7860 7861
int
ha_innobase::analyze(
7862
/*=================*/
7863 7864
	THD*		thd,		/*!< in: connection thread handle */
	HA_CHECK_OPT*	check_opt)	/*!< in: currently ignored */
osku's avatar
osku committed
7865
{
7866 7867
	/* Serialize ANALYZE TABLE inside InnoDB, see
	Bug#38996 Race condition in ANALYZE TABLE */
7868
	mysql_mutex_lock(&analyze_mutex);
7869

osku's avatar
osku committed
7870 7871 7872
	/* Simply call ::info() with all the flags */
	info(HA_STATUS_TIME | HA_STATUS_CONST | HA_STATUS_VARIABLE);

7873
	mysql_mutex_unlock(&analyze_mutex);
7874

osku's avatar
osku committed
7875 7876 7877
	return(0);
}

7878
/**********************************************************************//**
7879
This is mapped to "ALTER TABLE tablename ENGINE=InnoDB", which rebuilds
osku's avatar
osku committed
7880
the table in MySQL. */
7881
UNIV_INTERN
osku's avatar
osku committed
7882 7883 7884
int
ha_innobase::optimize(
/*==================*/
7885 7886
	THD*		thd,		/*!< in: connection thread handle */
	HA_CHECK_OPT*	check_opt)	/*!< in: currently ignored */
osku's avatar
osku committed
7887
{
7888
	return(HA_ADMIN_TRY_ALTER);
osku's avatar
osku committed
7889 7890
}

7891
/*******************************************************************//**
osku's avatar
osku committed
7892 7893
Tries to check that an InnoDB table is not corrupted. If corruption is
noticed, prints to stderr information about it. In case of corruption
7894 7895
may also assert a failure and crash the server.
@return	HA_ADMIN_CORRUPT or HA_ADMIN_OK */
7896
UNIV_INTERN
osku's avatar
osku committed
7897 7898 7899
int
ha_innobase::check(
/*===============*/
7900 7901
	THD*		thd,		/*!< in: user thread handle */
	HA_CHECK_OPT*	check_opt)	/*!< in: check options, currently
osku's avatar
osku committed
7902 7903
					ignored */
{
7904 7905 7906 7907 7908
	dict_index_t*	index;
	ulint		n_rows;
	ulint		n_rows_in_table	= ULINT_UNDEFINED;
	ibool		is_ok		= TRUE;
	ulint		old_isolation_level;
osku's avatar
osku committed
7909

7910
	DBUG_ENTER("ha_innobase::check");
7911
	DBUG_ASSERT(thd == ha_thd());
7912 7913
	ut_a(prebuilt->trx);
	ut_a(prebuilt->trx->magic_n == TRX_MAGIC_N);
7914
	ut_a(prebuilt->trx == thd_to_trx(thd));
osku's avatar
osku committed
7915 7916 7917 7918 7919 7920 7921 7922

	if (prebuilt->mysql_template == NULL) {
		/* Build the template; we will use a dummy template
		in index scans done in checking */

		build_template(prebuilt, NULL, table, ROW_MYSQL_WHOLE_ROW);
	}

7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939
	if (prebuilt->table->ibd_file_missing) {
		sql_print_error("InnoDB: Error:\n"
			"InnoDB: MySQL is trying to use a table handle"
			" but the .ibd file for\n"
			"InnoDB: table %s does not exist.\n"
			"InnoDB: Have you deleted the .ibd file"
			" from the database directory under\n"
			"InnoDB: the MySQL datadir, or have you"
			" used DISCARD TABLESPACE?\n"
			"InnoDB: Please refer to\n"
			"InnoDB: " REFMAN "innodb-troubleshooting.html\n"
			"InnoDB: how you can resolve the problem.\n",
			prebuilt->table->name);
		DBUG_RETURN(HA_ADMIN_CORRUPT);
	}

	prebuilt->trx->op_info = "checking table";
osku's avatar
osku committed
7940

7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052
	old_isolation_level = prebuilt->trx->isolation_level;

	/* We must run the index record counts at an isolation level
	>= READ COMMITTED, because a dirty read can see a wrong number
	of records in some index; to play safe, we use always
	REPEATABLE READ here */

	prebuilt->trx->isolation_level = TRX_ISO_REPEATABLE_READ;

	/* Enlarge the fatal lock wait timeout during CHECK TABLE. */
	mutex_enter(&kernel_mutex);
	srv_fatal_semaphore_wait_threshold += 7200; /* 2 hours */
	mutex_exit(&kernel_mutex);

	for (index = dict_table_get_first_index(prebuilt->table);
	     index != NULL;
	     index = dict_table_get_next_index(index)) {
#if 0
		fputs("Validating index ", stderr);
		ut_print_name(stderr, trx, FALSE, index->name);
		putc('\n', stderr);
#endif

		if (!btr_validate_index(index, prebuilt->trx)) {
			is_ok = FALSE;
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
					    ER_NOT_KEYFILE,
					    "InnoDB: The B-tree of"
					    " index '%-.200s' is corrupted.",
					    index->name);
			continue;
		}

		/* Instead of invoking change_active_index(), set up
		a dummy template for non-locking reads, disabling
		access to the clustered index. */
		prebuilt->index = index;

		prebuilt->index_usable = row_merge_is_index_usable(
			prebuilt->trx, prebuilt->index);

		if (UNIV_UNLIKELY(!prebuilt->index_usable)) {
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
					    HA_ERR_TABLE_DEF_CHANGED,
					    "InnoDB: Insufficient history for"
					    " index '%-.200s'",
					    index->name);
			continue;
		}

		prebuilt->sql_stat_start = TRUE;
		prebuilt->template_type = ROW_MYSQL_DUMMY_TEMPLATE;
		prebuilt->n_template = 0;
		prebuilt->need_to_access_clustered = FALSE;

		dtuple_set_n_fields(prebuilt->search_tuple, 0);

		prebuilt->select_lock_type = LOCK_NONE;

		if (!row_check_index_for_mysql(prebuilt, index, &n_rows)) {
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
					    ER_NOT_KEYFILE,
					    "InnoDB: The B-tree of"
					    " index '%-.200s' is corrupted.",
					    index->name);
			is_ok = FALSE;
		}

		if (thd_killed(user_thd)) {
			break;
		}

#if 0
		fprintf(stderr, "%lu entries in index %s\n", n_rows,
			index->name);
#endif

		if (index == dict_table_get_first_index(prebuilt->table)) {
			n_rows_in_table = n_rows;
		} else if (n_rows != n_rows_in_table) {
			push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
					    ER_NOT_KEYFILE,
					    "InnoDB: Index '%-.200s'"
					    " contains %lu entries,"
					    " should be %lu.",
					    index->name,
					    (ulong) n_rows,
					    (ulong) n_rows_in_table);
			is_ok = FALSE;
		}
	}

	/* Restore the original isolation level */
	prebuilt->trx->isolation_level = old_isolation_level;

	/* We validate also the whole adaptive hash index for all tables
	at every CHECK TABLE */

	if (!btr_search_validate()) {
		push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			     ER_NOT_KEYFILE,
			     "InnoDB: The adaptive hash index is corrupted.");
		is_ok = FALSE;
	}

	/* Restore the fatal lock wait timeout after CHECK TABLE. */
	mutex_enter(&kernel_mutex);
	srv_fatal_semaphore_wait_threshold -= 7200; /* 2 hours */
	mutex_exit(&kernel_mutex);

	prebuilt->trx->op_info = "";
	if (thd_killed(user_thd)) {
8053
		my_error(ER_QUERY_INTERRUPTED, MYF(0));
osku's avatar
osku committed
8054
	}
8055 8056

	DBUG_RETURN(is_ok ? HA_ADMIN_OK : HA_ADMIN_CORRUPT);
osku's avatar
osku committed
8057 8058
}

8059
/*************************************************************//**
osku's avatar
osku committed
8060 8061
Adds information about free space in the InnoDB tablespace to a table comment
which is printed out when a user calls SHOW TABLE STATUS. Adds also info on
8062 8063
foreign keys.
@return	table comment + InnoDB free space + info on foreign keys */
8064
UNIV_INTERN
osku's avatar
osku committed
8065 8066 8067
char*
ha_innobase::update_table_comment(
/*==============================*/
8068
	const char*	comment)/*!< in: table comment defined by user */
osku's avatar
osku committed
8069
{
8070 8071
	uint	length = (uint) strlen(comment);
	char*	str;
8072
	long	flen;
osku's avatar
osku committed
8073 8074 8075 8076 8077 8078 8079 8080 8081

	/* We do not know if MySQL can call this function before calling
	external_lock(). To be safe, update the thd of the current table
	handle. */

	if (length > 64000 - 3) {
		return((char*)comment); /* string too long */
	}

8082
	update_thd(ha_thd());
osku's avatar
osku committed
8083 8084 8085 8086 8087 8088 8089 8090 8091

	prebuilt->trx->op_info = (char*)"returning table comment";

	/* In case MySQL calls this in the middle of a SELECT query, release
	possible adaptive hash latch to avoid deadlocks of threads */

	trx_search_latch_release_if_reserved(prebuilt->trx);
	str = NULL;

8092
	/* output the data to a temporary file */
osku's avatar
osku committed
8093

8094
	mutex_enter(&srv_dict_tmpfile_mutex);
8095 8096
	rewind(srv_dict_tmpfile);

8097 8098 8099
	fprintf(srv_dict_tmpfile, "InnoDB free: %llu kB",
		fsp_get_available_space_in_free_extents(
			prebuilt->table->space));
osku's avatar
osku committed
8100

8101
	dict_print_info_on_foreign_keys(FALSE, srv_dict_tmpfile,
osku's avatar
osku committed
8102
				prebuilt->trx, prebuilt->table);
8103 8104 8105 8106 8107 8108
	flen = ftell(srv_dict_tmpfile);
	if (flen < 0) {
		flen = 0;
	} else if (length + flen + 3 > 64000) {
		flen = 64000 - 3 - length;
	}
osku's avatar
osku committed
8109

8110 8111
	/* allocate buffer for the full string, and
	read the contents of the temporary file */
osku's avatar
osku committed
8112

8113
	str = (char*) my_malloc(length + flen + 3, MYF(0));
osku's avatar
osku committed
8114

8115 8116 8117 8118 8119 8120
	if (str) {
		char* pos	= str + length;
		if (length) {
			memcpy(str, comment, length);
			*pos++ = ';';
			*pos++ = ' ';
osku's avatar
osku committed
8121
		}
8122 8123 8124
		rewind(srv_dict_tmpfile);
		flen = (uint) fread(pos, 1, flen, srv_dict_tmpfile);
		pos[flen] = 0;
osku's avatar
osku committed
8125 8126
	}

8127
	mutex_exit(&srv_dict_tmpfile_mutex);
8128

8129
	prebuilt->trx->op_info = (char*)"";
osku's avatar
osku committed
8130

8131
	return(str ? str : (char*) comment);
osku's avatar
osku committed
8132 8133
}

8134
/*******************************************************************//**
8135
Gets the foreign key create info for a table stored in InnoDB.
8136 8137 8138
@return own: character string in the form which can be inserted to the
CREATE TABLE statement, MUST be freed with
ha_innobase::free_foreign_key_create_info */
8139
UNIV_INTERN
osku's avatar
osku committed
8140 8141 8142 8143 8144
char*
ha_innobase::get_foreign_key_create_info(void)
/*==========================================*/
{
	char*	str	= 0;
8145
	long	flen;
osku's avatar
osku committed
8146 8147 8148 8149 8150 8151 8152

	ut_a(prebuilt != NULL);

	/* We do not know if MySQL can call this function before calling
	external_lock(). To be safe, update the thd of the current table
	handle. */

8153
	update_thd(ha_thd());
osku's avatar
osku committed
8154

8155
	prebuilt->trx->op_info = (char*)"getting info on foreign keys";
osku's avatar
osku committed
8156

8157 8158 8159
	/* In case MySQL calls this in the middle of a SELECT query,
	release possible adaptive hash latch to avoid
	deadlocks of threads */
osku's avatar
osku committed
8160

8161
	trx_search_latch_release_if_reserved(prebuilt->trx);
osku's avatar
osku committed
8162

8163
	mutex_enter(&srv_dict_tmpfile_mutex);
8164
	rewind(srv_dict_tmpfile);
osku's avatar
osku committed
8165

8166 8167
	/* output the data to a temporary file */
	dict_print_info_on_foreign_keys(TRUE, srv_dict_tmpfile,
osku's avatar
osku committed
8168
				prebuilt->trx, prebuilt->table);
8169
	prebuilt->trx->op_info = (char*)"";
osku's avatar
osku committed
8170

8171 8172 8173 8174 8175 8176
	flen = ftell(srv_dict_tmpfile);
	if (flen < 0) {
		flen = 0;
	} else if (flen > 64000 - 1) {
		flen = 64000 - 1;
	}
osku's avatar
osku committed
8177

8178 8179
	/* allocate buffer for the string, and
	read the contents of the temporary file */
osku's avatar
osku committed
8180

8181
	str = (char*) my_malloc(flen + 1, MYF(0));
osku's avatar
osku committed
8182

8183 8184 8185 8186
	if (str) {
		rewind(srv_dict_tmpfile);
		flen = (uint) fread(str, 1, flen, srv_dict_tmpfile);
		str[flen] = 0;
osku's avatar
osku committed
8187 8188
	}

8189
	mutex_exit(&srv_dict_tmpfile_mutex);
8190

8191
	return(str);
osku's avatar
osku committed
8192 8193 8194
}


8195
UNIV_INTERN
8196
int
osku's avatar
osku committed
8197 8198 8199 8200 8201 8202
ha_innobase::get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list)
{
  dict_foreign_t* foreign;

  DBUG_ENTER("get_foreign_key_list");
  ut_a(prebuilt != NULL);
8203
  update_thd(ha_thd());
osku's avatar
osku committed
8204 8205
  prebuilt->trx->op_info = (char*)"getting list of foreign keys";
  trx_search_latch_release_if_reserved(prebuilt->trx);
8206
  mutex_enter(&(dict_sys->mutex));
osku's avatar
osku committed
8207 8208
  foreign = UT_LIST_GET_FIRST(prebuilt->table->foreign_list);

8209 8210 8211 8212
  while (foreign != NULL) {
	  uint i;
	  FOREIGN_KEY_INFO f_key_info;
	  LEX_STRING *name= 0;
8213
          uint ulen;
8214 8215
          char uname[NAME_LEN+1];           /* Unencoded name */
          char db_name[NAME_LEN+1];
8216 8217 8218 8219 8220 8221 8222
	  const char *tmp_buff;

	  tmp_buff= foreign->id;
	  i= 0;
	  while (tmp_buff[i] != '/')
		  i++;
	  tmp_buff+= i + 1;
8223 8224
	  f_key_info.forein_id = thd_make_lex_string(thd, 0,
		  tmp_buff, (uint) strlen(tmp_buff), 1);
8225
	  tmp_buff= foreign->referenced_table_name;
8226 8227

          /* Database name */
8228 8229
	  i= 0;
	  while (tmp_buff[i] != '/')
8230 8231 8232 8233 8234 8235
          {
            db_name[i]= tmp_buff[i];
            i++;
          }
          db_name[i]= 0;
          ulen= filename_to_tablename(db_name, uname, sizeof(uname));
8236 8237
	  f_key_info.referenced_db = thd_make_lex_string(thd, 0,
		  uname, ulen, 1);
8238 8239

          /* Table name */
8240
	  tmp_buff+= i + 1;
8241
          ulen= filename_to_tablename(tmp_buff, uname, sizeof(uname));
8242 8243
	  f_key_info.referenced_table = thd_make_lex_string(thd, 0,
		  uname, ulen, 1);
8244 8245 8246

	  for (i= 0;;) {
		  tmp_buff= foreign->foreign_col_names[i];
8247 8248
		  name = thd_make_lex_string(thd, name,
			  tmp_buff, (uint) strlen(tmp_buff), 1);
8249 8250
		  f_key_info.foreign_fields.push_back(name);
		  tmp_buff= foreign->referenced_col_names[i];
8251 8252
		  name = thd_make_lex_string(thd, name,
			tmp_buff, (uint) strlen(tmp_buff), 1);
8253 8254 8255 8256 8257
		  f_key_info.referenced_fields.push_back(name);
		  if (++i >= foreign->n_fields)
			  break;
	  }

8258 8259 8260 8261 8262
          ulong length;
          if (foreign->type & DICT_FOREIGN_ON_DELETE_CASCADE)
          {
            length=7;
            tmp_buff= "CASCADE";
8263
          }
8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278
          else if (foreign->type & DICT_FOREIGN_ON_DELETE_SET_NULL)
          {
            length=8;
            tmp_buff= "SET NULL";
          }
          else if (foreign->type & DICT_FOREIGN_ON_DELETE_NO_ACTION)
          {
            length=9;
            tmp_buff= "NO ACTION";
          }
          else
          {
            length=8;
            tmp_buff= "RESTRICT";
          }
8279 8280
	  f_key_info.delete_method = thd_make_lex_string(
		  thd, f_key_info.delete_method, tmp_buff, length, 1);
8281 8282


8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302
          if (foreign->type & DICT_FOREIGN_ON_UPDATE_CASCADE)
          {
            length=7;
            tmp_buff= "CASCADE";
          }
          else if (foreign->type & DICT_FOREIGN_ON_UPDATE_SET_NULL)
          {
            length=8;
            tmp_buff= "SET NULL";
          }
          else if (foreign->type & DICT_FOREIGN_ON_UPDATE_NO_ACTION)
          {
            length=9;
            tmp_buff= "NO ACTION";
          }
          else
          {
            length=8;
            tmp_buff= "RESTRICT";
          }
8303 8304
	  f_key_info.update_method = thd_make_lex_string(
		  thd, f_key_info.update_method, tmp_buff, length, 1);
8305 8306 8307
          if (foreign->referenced_index &&
              foreign->referenced_index->name)
          {
8308 8309 8310
	    f_key_info.referenced_key_name = thd_make_lex_string(
		    thd, f_key_info.referenced_key_name,
		    foreign->referenced_index->name,
8311
		    (uint) strlen(foreign->referenced_index->name), 1);
8312
          }
8313 8314
          else
            f_key_info.referenced_key_name= 0;
8315

8316
	  FOREIGN_KEY_INFO *pf_key_info = (FOREIGN_KEY_INFO *)
8317
		  thd_memdup(thd, &f_key_info, sizeof(FOREIGN_KEY_INFO));
8318 8319
	  f_key_list->push_back(pf_key_info);
	  foreign = UT_LIST_GET_NEXT(foreign_list, foreign);
osku's avatar
osku committed
8320
  }
8321
  mutex_exit(&(dict_sys->mutex));
osku's avatar
osku committed
8322
  prebuilt->trx->op_info = (char*)"";
8323

osku's avatar
osku committed
8324 8325 8326
  DBUG_RETURN(0);
}

8327
/*****************************************************************//**
osku's avatar
osku committed
8328 8329
Checks if ALTER TABLE may change the storage engine of the table.
Changing storage engines is not allowed for tables for which there
8330 8331
are foreign key constraints (parent or child tables).
@return	TRUE if can switch engines */
8332
UNIV_INTERN
osku's avatar
osku committed
8333 8334 8335 8336 8337 8338
bool
ha_innobase::can_switch_engines(void)
/*=================================*/
{
	bool	can_switch;

8339
	DBUG_ENTER("ha_innobase::can_switch_engines");
8340

8341
	ut_a(prebuilt->trx == thd_to_trx(ha_thd()));
8342

osku's avatar
osku committed
8343 8344 8345 8346 8347 8348 8349 8350 8351 8352 8353 8354 8355
	prebuilt->trx->op_info =
			"determining if there are foreign key constraints";
	row_mysql_lock_data_dictionary(prebuilt->trx);

	can_switch = !UT_LIST_GET_FIRST(prebuilt->table->referenced_list)
			&& !UT_LIST_GET_FIRST(prebuilt->table->foreign_list);

	row_mysql_unlock_data_dictionary(prebuilt->trx);
	prebuilt->trx->op_info = "";

	DBUG_RETURN(can_switch);
}

8356
/*******************************************************************//**
osku's avatar
osku committed
8357 8358 8359
Checks if a table is referenced by a foreign key. The MySQL manual states that
a REPLACE is either equivalent to an INSERT, or DELETE(s) + INSERT. Only a
delete is then allowed internally to resolve a duplicate key conflict in
8360 8361
REPLACE, not an update.
@return	> 0 if referenced by a FOREIGN KEY */
8362
UNIV_INTERN
osku's avatar
osku committed
8363 8364 8365 8366
uint
ha_innobase::referenced_by_foreign_key(void)
/*========================================*/
{
8367
	if (dict_table_is_referenced_by_foreign_key(prebuilt->table)) {
osku's avatar
osku committed
8368 8369 8370 8371 8372 8373 8374

		return(1);
	}

	return(0);
}

8375
/*******************************************************************//**
osku's avatar
osku committed
8376 8377
Frees the foreign key create info for a table stored in InnoDB, if it is
non-NULL. */
8378
UNIV_INTERN
osku's avatar
osku committed
8379 8380 8381
void
ha_innobase::free_foreign_key_create_info(
/*======================================*/
8382
	char*	str)	/*!< in, own: create info string to free */
osku's avatar
osku committed
8383 8384 8385 8386 8387 8388
{
	if (str) {
		my_free(str, MYF(0));
	}
}

8389
/*******************************************************************//**
8390 8391
Tells something additional to the handler about how to do things.
@return	0 or error number */
8392
UNIV_INTERN
osku's avatar
osku committed
8393 8394 8395 8396
int
ha_innobase::extra(
/*===============*/
	enum ha_extra_function operation)
8397
			   /*!< in: HA_EXTRA_FLUSH or some other flag */
osku's avatar
osku committed
8398 8399 8400 8401 8402 8403
{
	/* Warning: since it is not sure that MySQL calls external_lock
	before calling this function, the trx field in prebuilt can be
	obsolete! */

	switch (operation) {
8404 8405 8406 8407 8408 8409
		case HA_EXTRA_FLUSH:
			if (prebuilt->blob_heap) {
				row_mysql_prebuilt_free_blob_heap(prebuilt);
			}
			break;
		case HA_EXTRA_RESET_STATE:
8410
			reset_template(prebuilt);
8411
			break;
osku's avatar
osku committed
8412
		case HA_EXTRA_NO_KEYREAD:
8413 8414 8415 8416 8417
			prebuilt->read_just_key = 0;
			break;
		case HA_EXTRA_KEYREAD:
			prebuilt->read_just_key = 1;
			break;
osku's avatar
osku committed
8418 8419 8420
		case HA_EXTRA_KEYREAD_PRESERVE_FIELDS:
			prebuilt->keep_other_fields_on_keyread = 1;
			break;
8421 8422 8423 8424 8425 8426 8427

			/* IMPORTANT: prebuilt->trx can be obsolete in
			this method, because it is not sure that MySQL
			calls external_lock before this method with the
			parameters below.  We must not invoke update_thd()
			either, because the calling threads may change.
			CAREFUL HERE, OR MEMORY CORRUPTION MAY OCCUR! */
8428
		case HA_EXTRA_IGNORE_DUP_KEY:
8429
			thd_to_trx(ha_thd())->duplicates |= TRX_DUP_IGNORE;
8430 8431
			break;
		case HA_EXTRA_WRITE_CAN_REPLACE:
8432
			thd_to_trx(ha_thd())->duplicates |= TRX_DUP_REPLACE;
8433 8434
			break;
		case HA_EXTRA_WRITE_CANNOT_REPLACE:
8435
			thd_to_trx(ha_thd())->duplicates &= ~TRX_DUP_REPLACE;
8436 8437
			break;
		case HA_EXTRA_NO_IGNORE_DUP_KEY:
8438
			thd_to_trx(ha_thd())->duplicates &=
8439 8440
				~(TRX_DUP_IGNORE | TRX_DUP_REPLACE);
			break;
osku's avatar
osku committed
8441 8442 8443 8444 8445 8446 8447
		default:/* Do nothing */
			;
	}

	return(0);
}

8448 8449 8450
UNIV_INTERN
int
ha_innobase::reset()
8451
{
8452 8453 8454 8455 8456
	if (prebuilt->blob_heap) {
		row_mysql_prebuilt_free_blob_heap(prebuilt);
	}

	reset_template(prebuilt);
8457

8458 8459 8460 8461
	/* TODO: This should really be reset in reset_template() but for now
	it's safer to do it explicitly here. */

	/* This is a statement level counter. */
8462
	prebuilt->autoinc_last_value = 0;
8463 8464 8465

	return(0);
}
8466

8467
/******************************************************************//**
osku's avatar
osku committed
8468 8469 8470 8471 8472 8473 8474 8475
MySQL calls this function at the start of each SQL statement inside LOCK
TABLES. Inside LOCK TABLES the ::external_lock method does not work to
mark SQL statement borders. Note also a special case: if a temporary table
is created inside LOCK TABLES, MySQL has not called external_lock() at all
on that table.
MySQL-5.0 also calls this before each statement in an execution of a stored
procedure. To make the execution more deterministic for binlogging, MySQL-5.0
locks all tables involved in a stored procedure with full explicit table
8476
locks (thd_in_lock_tables(thd) holds in store_lock()) before executing the
8477 8478
procedure.
@return	0 or error code */
8479
UNIV_INTERN
osku's avatar
osku committed
8480 8481 8482
int
ha_innobase::start_stmt(
/*====================*/
8483
	THD*		thd,	/*!< in: handle to the user thread */
8484
	thr_lock_type	lock_type)
osku's avatar
osku committed
8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500
{
	trx_t*		trx;

	update_thd(thd);

	trx = prebuilt->trx;

	/* Here we release the search latch and the InnoDB thread FIFO ticket
	if they were reserved. They should have been released already at the
	end of the previous statement, but because inside LOCK TABLES the
	lock count method does not work to mark the end of a SELECT statement,
	that may not be the case. We MUST release the search latch before an
	INSERT, for example. */

	innobase_release_stat_resources(trx);

8501 8502 8503
	/* Reset the AUTOINC statement level counter for multi-row INSERTs. */
	trx->n_autoinc_rows = 0;

osku's avatar
osku committed
8504 8505
	prebuilt->sql_stat_start = TRUE;
	prebuilt->hint_need_to_fetch_extra_cols = 0;
8506
	reset_template(prebuilt);
osku's avatar
osku committed
8507 8508

	if (!prebuilt->mysql_has_locked) {
8509 8510 8511 8512 8513 8514
		/* This handle is for a temporary table created inside
		this same LOCK TABLES; since MySQL does NOT call external_lock
		in this case, we must use x-row locks inside InnoDB to be
		prepared for an update of a row */

		prebuilt->select_lock_type = LOCK_X;
osku's avatar
osku committed
8515 8516
	} else {
		if (trx->isolation_level != TRX_ISO_SERIALIZABLE
8517
			&& thd_sql_command(thd) == SQLCOM_SELECT
8518 8519
			&& lock_type == TL_READ) {

osku's avatar
osku committed
8520 8521 8522 8523 8524 8525 8526 8527 8528
			/* For other than temporary tables, we obtain
			no lock for consistent read (plain SELECT). */

			prebuilt->select_lock_type = LOCK_NONE;
		} else {
			/* Not a consistent read: restore the
			select_lock_type value. The value of
			stored_select_lock_type was decided in:
			1) ::store_lock(),
8529 8530
			2) ::external_lock(),
			3) ::init_table_handle_for_HANDLER(), and
8531
			4) ::transactional_table_lock(). */
osku's avatar
osku committed
8532 8533 8534 8535 8536 8537 8538 8539 8540

			prebuilt->select_lock_type =
				prebuilt->stored_select_lock_type;
		}
	}

	trx->detailed_error[0] = '\0';

	/* Set the MySQL flag to mark that there is an active transaction */
8541
	if (trx->active_trans == 0) {
osku's avatar
osku committed
8542

8543
		innobase_register_trx_and_stmt(ht, thd);
8544 8545
		trx->active_trans = 1;
	} else {
8546
		innobase_register_stmt(ht, thd);
osku's avatar
osku committed
8547 8548 8549 8550 8551
	}

	return(0);
}

8552
/******************************************************************//**
8553 8554
Maps a MySQL trx isolation level code to the InnoDB isolation level code
@return	InnoDB isolation level */
8555
static inline
osku's avatar
osku committed
8556 8557 8558
ulint
innobase_map_isolation_level(
/*=========================*/
8559
	enum_tx_isolation	iso)	/*!< in: MySQL isolation level code */
osku's avatar
osku committed
8560 8561 8562 8563 8564 8565 8566
{
	switch(iso) {
		case ISO_REPEATABLE_READ: return(TRX_ISO_REPEATABLE_READ);
		case ISO_READ_COMMITTED: return(TRX_ISO_READ_COMMITTED);
		case ISO_SERIALIZABLE: return(TRX_ISO_SERIALIZABLE);
		case ISO_READ_UNCOMMITTED: return(TRX_ISO_READ_UNCOMMITTED);
		default: ut_a(0); return(0);
8567
	}
osku's avatar
osku committed
8568
}
8569

8570
/******************************************************************//**
osku's avatar
osku committed
8571 8572 8573 8574 8575 8576
As MySQL will execute an external lock for every new table it uses when it
starts to process an SQL statement (an exception is when MySQL calls
start_stmt for the handle) we can use this function to store the pointer to
the THD in the handle. We will also use this function to communicate
to InnoDB that a new SQL statement has started and that we must store a
savepoint to our transaction handle, so that we are able to roll back
8577 8578
the SQL statement in case of an error.
@return	0 */
8579
UNIV_INTERN
osku's avatar
osku committed
8580 8581 8582
int
ha_innobase::external_lock(
/*=======================*/
8583 8584
	THD*	thd,		/*!< in: handle to the user thread */
	int	lock_type)	/*!< in: lock type */
osku's avatar
osku committed
8585 8586 8587
{
	trx_t*		trx;

8588
	DBUG_ENTER("ha_innobase::external_lock");
osku's avatar
osku committed
8589 8590 8591 8592
	DBUG_PRINT("enter",("lock_type: %d", lock_type));

	update_thd(thd);

8593 8594 8595
	/* Statement based binlogging does not work in isolation level
	READ UNCOMMITTED and READ COMMITTED since the necessary
	locks cannot be taken. In this case, we print an
8596 8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610
	informative error message and return with an error.
	Note: decide_logging_format would give the same error message,
	except it cannot give the extra details. */
	if (lock_type == F_WRLCK
	    && !(table_flags() & HA_BINLOG_STMT_CAPABLE)
	    && thd_binlog_format(thd) == BINLOG_FORMAT_STMT
	    && thd_binlog_filter_ok(thd)) {
		int skip = 0;
		/* used by test case */
		DBUG_EXECUTE_IF("no_innodb_binlog_errors", skip = 1;);
		if (!skip) {
			my_error(ER_BINLOG_STMT_MODE_AND_ROW_ENGINE, MYF(0),
			         " InnoDB is limited to row-logging when "
			         "transaction isolation level is "
			         "READ COMMITTED or READ UNCOMMITTED.");
8611 8612 8613 8614 8615
			DBUG_RETURN(HA_ERR_LOGGING_IMPOSSIBLE);
		}
	}


osku's avatar
osku committed
8616 8617 8618 8619 8620
	trx = prebuilt->trx;

	prebuilt->sql_stat_start = TRUE;
	prebuilt->hint_need_to_fetch_extra_cols = 0;

8621
	reset_template(prebuilt);
osku's avatar
osku committed
8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634

	if (lock_type == F_WRLCK) {

		/* If this is a SELECT, then it is in UPDATE TABLE ...
		or SELECT ... FOR UPDATE */
		prebuilt->select_lock_type = LOCK_X;
		prebuilt->stored_select_lock_type = LOCK_X;
	}

	if (lock_type != F_UNLCK) {
		/* MySQL is setting a new table lock */

		trx->detailed_error[0] = '\0';
8635

osku's avatar
osku committed
8636 8637
		/* Set the MySQL flag to mark that there is an active
		transaction */
8638
		if (trx->active_trans == 0) {
osku's avatar
osku committed
8639

8640
			innobase_register_trx_and_stmt(ht, thd);
8641 8642
			trx->active_trans = 1;
		} else if (trx->n_mysql_tables_in_use == 0) {
8643
			innobase_register_stmt(ht, thd);
osku's avatar
osku committed
8644 8645 8646
		}

		if (trx->isolation_level == TRX_ISO_SERIALIZABLE
8647
			&& prebuilt->select_lock_type == LOCK_NONE
8648 8649
			&& thd_test_options(thd,
				OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
osku's avatar
osku committed
8650 8651 8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666

			/* To get serializable execution, we let InnoDB
			conceptually add 'LOCK IN SHARE MODE' to all SELECTs
			which otherwise would have been consistent reads. An
			exception is consistent reads in the AUTOCOMMIT=1 mode:
			we know that they are read-only transactions, and they
			can be serialized also if performed as consistent
			reads. */

			prebuilt->select_lock_type = LOCK_S;
			prebuilt->stored_select_lock_type = LOCK_S;
		}

		/* Starting from 4.1.9, no InnoDB table lock is taken in LOCK
		TABLES if AUTOCOMMIT=1. It does not make much sense to acquire
		an InnoDB table lock if it is released immediately at the end
		of LOCK TABLES, and InnoDB's table locks in that case cause
8667
		VERY easily deadlocks.
8668 8669

		We do not set InnoDB table locks if user has not explicitly
8670 8671
		requested a table lock. Note that thd_in_lock_tables(thd)
		can hold in some cases, e.g., at the start of a stored
8672
		procedure call (SQLCOM_CALL). */
osku's avatar
osku committed
8673 8674 8675

		if (prebuilt->select_lock_type != LOCK_NONE) {

8676 8677 8678
			if (thd_sql_command(thd) == SQLCOM_LOCK_TABLES
			    && THDVAR(thd, table_locks)
			    && thd_test_options(thd, OPTION_NOT_AUTOCOMMIT)
8679
			    && thd_in_lock_tables(thd)) {
osku's avatar
osku committed
8680

8681 8682
				ulint	error = row_lock_table_for_mysql(
					prebuilt, NULL, 0);
osku's avatar
osku committed
8683 8684 8685

				if (error != DB_SUCCESS) {
					error = convert_error_code_to_mysql(
8686
						(int) error, 0, thd);
osku's avatar
osku committed
8687 8688 8689 8690
					DBUG_RETURN((int) error);
				}
			}

8691
			trx->mysql_n_tables_locked++;
osku's avatar
osku committed
8692 8693
		}

8694 8695 8696
		trx->n_mysql_tables_in_use++;
		prebuilt->mysql_has_locked = TRUE;

osku's avatar
osku committed
8697 8698 8699 8700 8701 8702 8703 8704
		DBUG_RETURN(0);
	}

	/* MySQL is releasing a table lock */

	trx->n_mysql_tables_in_use--;
	prebuilt->mysql_has_locked = FALSE;

8705 8706 8707 8708 8709 8710
	/* Release a possible FIFO ticket and search latch. Since we
	may reserve the kernel mutex, we have to release the search
	system latch first to obey the latching order. */

	innobase_release_stat_resources(trx);

osku's avatar
osku committed
8711 8712 8713 8714 8715
	/* If the MySQL lock count drops to zero we know that the current SQL
	statement has ended */

	if (trx->n_mysql_tables_in_use == 0) {

8716
		trx->mysql_n_tables_locked = 0;
osku's avatar
osku committed
8717
		prebuilt->used_in_HANDLER = FALSE;
8718

8719
		if (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
8720
			if (trx->active_trans != 0) {
8721
				innobase_commit(ht, thd, TRUE);
osku's avatar
osku committed
8722 8723 8724
			}
		} else {
			if (trx->isolation_level <= TRX_ISO_READ_COMMITTED
8725
						&& trx->global_read_view) {
osku's avatar
osku committed
8726 8727 8728 8729 8730 8731 8732 8733 8734 8735 8736 8737

				/* At low transaction isolation levels we let
				each consistent read set its own snapshot */

				read_view_close_for_mysql(trx);
			}
		}
	}

	DBUG_RETURN(0);
}

8738
/******************************************************************//**
osku's avatar
osku committed
8739
With this function MySQL request a transactional lock to a table when
8740 8741
user issued query LOCK TABLES..WHERE ENGINE = InnoDB.
@return	error code */
8742
UNIV_INTERN
osku's avatar
osku committed
8743 8744 8745
int
ha_innobase::transactional_table_lock(
/*==================================*/
8746 8747
	THD*	thd,		/*!< in: handle to the user thread */
	int	lock_type)	/*!< in: lock type */
osku's avatar
osku committed
8748 8749 8750
{
	trx_t*		trx;

8751
	DBUG_ENTER("ha_innobase::transactional_table_lock");
osku's avatar
osku committed
8752 8753 8754 8755 8756 8757 8758 8759
	DBUG_PRINT("enter",("lock_type: %d", lock_type));

	/* We do not know if MySQL can call this function before calling
	external_lock(). To be safe, update the thd of the current table
	handle. */

	update_thd(thd);

8760
	if (prebuilt->table->ibd_file_missing && !thd_tablespace_op(thd)) {
8761
		ut_print_timestamp(stderr);
8762 8763 8764 8765 8766 8767 8768
		fprintf(stderr,
			"  InnoDB: MySQL is trying to use a table handle"
			" but the .ibd file for\n"
			"InnoDB: table %s does not exist.\n"
			"InnoDB: Have you deleted the .ibd file"
			" from the database directory under\n"
			"InnoDB: the MySQL datadir?"
8769 8770
			"InnoDB: See " REFMAN
			"innodb-troubleshooting.html\n"
8771 8772
			"InnoDB: how you can resolve the problem.\n",
			prebuilt->table->name);
osku's avatar
osku committed
8773 8774 8775 8776 8777 8778 8779 8780
		DBUG_RETURN(HA_ERR_CRASHED);
	}

	trx = prebuilt->trx;

	prebuilt->sql_stat_start = TRUE;
	prebuilt->hint_need_to_fetch_extra_cols = 0;

8781
	reset_template(prebuilt);
osku's avatar
osku committed
8782 8783 8784 8785 8786 8787 8788 8789

	if (lock_type == F_WRLCK) {
		prebuilt->select_lock_type = LOCK_X;
		prebuilt->stored_select_lock_type = LOCK_X;
	} else if (lock_type == F_RDLCK) {
		prebuilt->select_lock_type = LOCK_S;
		prebuilt->stored_select_lock_type = LOCK_S;
	} else {
8790 8791
		ut_print_timestamp(stderr);
		fprintf(stderr, "  InnoDB error:\n"
osku's avatar
osku committed
8792 8793 8794 8795 8796 8797 8798 8799 8800
"MySQL is trying to set transactional table lock with corrupted lock type\n"
"to table %s, lock type %d does not exist.\n",
				prebuilt->table->name, lock_type);
		DBUG_RETURN(HA_ERR_CRASHED);
	}

	/* MySQL is setting a new transactional table lock */

	/* Set the MySQL flag to mark that there is an active transaction */
8801
	if (trx->active_trans == 0) {
osku's avatar
osku committed
8802

8803
		innobase_register_trx_and_stmt(ht, thd);
8804 8805
		trx->active_trans = 1;
	}
osku's avatar
osku committed
8806

8807
	if (THDVAR(thd, table_locks) && thd_in_lock_tables(thd)) {
osku's avatar
osku committed
8808 8809 8810 8811 8812
		ulint	error = DB_SUCCESS;

		error = row_lock_table_for_mysql(prebuilt, NULL, 0);

		if (error != DB_SUCCESS) {
8813 8814
			error = convert_error_code_to_mysql(
				(int) error, prebuilt->table->flags, thd);
osku's avatar
osku committed
8815 8816 8817
			DBUG_RETURN((int) error);
		}

8818
		if (thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
osku's avatar
osku committed
8819

8820 8821
			/* Store the current undo_no of the transaction
			so that we know where to roll back if we have
osku's avatar
osku committed
8822 8823 8824 8825 8826 8827 8828 8829 8830
			to roll back the next SQL statement */

			trx_mark_sql_stat_end(trx);
		}
	}

	DBUG_RETURN(0);
}

8831
/************************************************************************//**
8832
Here we export InnoDB status variables to MySQL. */
8833
static
8834 8835 8836
void
innodb_export_status(void)
/*======================*/
osku's avatar
osku committed
8837
{
8838 8839 8840
	if (innodb_inited) {
		srv_export_innodb_status();
	}
osku's avatar
osku committed
8841 8842
}

8843
/************************************************************************//**
osku's avatar
osku committed
8844 8845
Implements the SHOW INNODB STATUS command. Sends the output of the InnoDB
Monitor to the client. */
8846
static
osku's avatar
osku committed
8847 8848 8849
bool
innodb_show_status(
/*===============*/
8850 8851
	handlerton*	hton,	/*!< in: the innodb handlerton */
	THD*	thd,	/*!< in: the MySQL query thread of the caller */
osku's avatar
osku committed
8852
	stat_print_fn *stat_print)
osku's avatar
osku committed
8853 8854 8855 8856 8857 8858 8859
{
	trx_t*			trx;
	static const char	truncated_msg[] = "... truncated...\n";
	const long		MAX_STATUS_SIZE = 64000;
	ulint			trx_list_start = ULINT_UNDEFINED;
	ulint			trx_list_end = ULINT_UNDEFINED;

8860
	DBUG_ENTER("innodb_show_status");
8861
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
8862

8863
	trx = check_trx_exists(thd);
osku's avatar
osku committed
8864 8865 8866 8867 8868 8869 8870 8871 8872

	innobase_release_stat_resources(trx);

	/* We let the InnoDB Monitor to output at most MAX_STATUS_SIZE
	bytes of text. */

	long	flen, usable_len;
	char*	str;

8873
	mutex_enter(&srv_monitor_file_mutex);
osku's avatar
osku committed
8874
	rewind(srv_monitor_file);
8875 8876
	srv_printf_innodb_monitor(srv_monitor_file, FALSE,
				  &trx_list_start, &trx_list_end);
osku's avatar
osku committed
8877 8878 8879 8880 8881 8882 8883 8884 8885 8886 8887 8888 8889 8890 8891 8892
	flen = ftell(srv_monitor_file);
	os_file_set_eof(srv_monitor_file);

	if (flen < 0) {
		flen = 0;
	}

	if (flen > MAX_STATUS_SIZE) {
		usable_len = MAX_STATUS_SIZE;
	} else {
		usable_len = flen;
	}

	/* allocate buffer for the string, and
	read the contents of the temporary file */

8893
	if (!(str = (char*) my_malloc(usable_len + 1, MYF(0)))) {
8894 8895
		mutex_exit(&srv_monitor_file_mutex);
		DBUG_RETURN(TRUE);
8896
	}
osku's avatar
osku committed
8897 8898 8899 8900 8901 8902 8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918

	rewind(srv_monitor_file);
	if (flen < MAX_STATUS_SIZE) {
		/* Display the entire output. */
		flen = (long) fread(str, 1, flen, srv_monitor_file);
	} else if (trx_list_end < (ulint) flen
			&& trx_list_start < trx_list_end
			&& trx_list_start + (flen - trx_list_end)
			< MAX_STATUS_SIZE - sizeof truncated_msg - 1) {
		/* Omit the beginning of the list of active transactions. */
		long len = (long) fread(str, 1, trx_list_start, srv_monitor_file);
		memcpy(str + len, truncated_msg, sizeof truncated_msg - 1);
		len += sizeof truncated_msg - 1;
		usable_len = (MAX_STATUS_SIZE - 1) - len;
		fseek(srv_monitor_file, flen - usable_len, SEEK_SET);
		len += (long) fread(str + len, 1, usable_len, srv_monitor_file);
		flen = len;
	} else {
		/* Omit the end of the output. */
		flen = (long) fread(str, 1, MAX_STATUS_SIZE - 1, srv_monitor_file);
	}

8919
	mutex_exit(&srv_monitor_file_mutex);
osku's avatar
osku committed
8920

osku's avatar
osku committed
8921
	bool result = FALSE;
osku's avatar
osku committed
8922

8923
	if (stat_print(thd, innobase_hton_name, (uint) strlen(innobase_hton_name),
8924
			STRING_WITH_LEN(""), str, flen)) {
osku's avatar
osku committed
8925
		result= TRUE;
osku's avatar
osku committed
8926
	}
osku's avatar
osku committed
8927
	my_free(str, MYF(0));
osku's avatar
osku committed
8928

osku's avatar
osku committed
8929
	DBUG_RETURN(FALSE);
osku's avatar
osku committed
8930 8931
}

8932
/************************************************************************//**
8933 8934
Implements the SHOW MUTEX STATUS command.
@return TRUE on failure, FALSE on success. */
8935
static
osku's avatar
osku committed
8936 8937
bool
innodb_mutex_show_status(
8938
/*=====================*/
8939
	handlerton*	hton,		/*!< in: the innodb handlerton */
8940
	THD*		thd,		/*!< in: the MySQL query thread of the
8941
					caller */
8942 8943
	stat_print_fn*	stat_print)	/*!< in: function for printing
					statistics */
8944 8945
{
	char buf1[IO_SIZE], buf2[IO_SIZE];
8946 8947
	mutex_t*	mutex;
	rw_lock_t*	lock;
8948 8949 8950 8951
	ulint		block_mutex_oswait_count = 0;
	ulint		block_lock_oswait_count = 0;
	mutex_t*	block_mutex = NULL;
	rw_lock_t*	block_lock = NULL;
8952
#ifdef UNIV_DEBUG
8953 8954 8955 8956 8957 8958
	ulint	  rw_lock_count= 0;
	ulint	  rw_lock_count_spin_loop= 0;
	ulint	  rw_lock_count_spin_rounds= 0;
	ulint	  rw_lock_count_os_wait= 0;
	ulint	  rw_lock_count_os_yield= 0;
	ulonglong rw_lock_wait_time= 0;
8959
#endif /* UNIV_DEBUG */
8960
	uint	  hton_name_len= (uint) strlen(innobase_hton_name), buf1len, buf2len;
8961
	DBUG_ENTER("innodb_mutex_show_status");
8962
	DBUG_ASSERT(hton == innodb_hton_ptr);
osku's avatar
osku committed
8963

8964
	mutex_enter(&mutex_list_mutex);
osku's avatar
osku committed
8965

8966 8967 8968 8969 8970
	for (mutex = UT_LIST_GET_FIRST(mutex_list); mutex != NULL;
	     mutex = UT_LIST_GET_NEXT(list, mutex)) {
		if (mutex->count_os_wait == 0) {
			continue;
		}
8971

8972 8973 8974 8975
		if (buf_pool_is_block_mutex(mutex)) {
			block_mutex = mutex;
			block_mutex_oswait_count += mutex->count_os_wait;
			continue;
8976
		}
8977
#ifdef UNIV_DEBUG
8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992
		if (mutex->mutex_type != 1) {
			if (mutex->count_using > 0) {
				buf1len= my_snprintf(buf1, sizeof(buf1),
					"%s:%s",
					mutex->cmutex_name, mutex->cfile_name);
				buf2len= my_snprintf(buf2, sizeof(buf2),
					"count=%lu, spin_waits=%lu,"
					" spin_rounds=%lu, "
					"os_waits=%lu, os_yields=%lu,"
					" os_wait_times=%lu",
					mutex->count_using,
					mutex->count_spin_loop,
					mutex->count_spin_rounds,
					mutex->count_os_wait,
					mutex->count_os_yield,
8993
					(ulong) (mutex->lspent_time/1000));
8994

8995
				if (stat_print(thd, innobase_hton_name,
8996 8997
						hton_name_len, buf1, buf1len,
						buf2, buf2len)) {
8998
					mutex_exit(&mutex_list_mutex);
8999 9000 9001
					DBUG_RETURN(1);
				}
			}
9002
		} else {
9003 9004 9005 9006 9007 9008 9009
			rw_lock_count += mutex->count_using;
			rw_lock_count_spin_loop += mutex->count_spin_loop;
			rw_lock_count_spin_rounds += mutex->count_spin_rounds;
			rw_lock_count_os_wait += mutex->count_os_wait;
			rw_lock_count_os_yield += mutex->count_os_yield;
			rw_lock_wait_time += mutex->lspent_time;
		}
9010
#else /* UNIV_DEBUG */
9011
		buf1len= (uint) my_snprintf(buf1, sizeof(buf1), "%s:%lu",
9012
				     mutex->cfile_name, (ulong) mutex->cline);
9013
		buf2len= (uint) my_snprintf(buf2, sizeof(buf2), "os_waits=%lu",
9014
				     (ulong) mutex->count_os_wait);
9015 9016 9017 9018

		if (stat_print(thd, innobase_hton_name,
			       hton_name_len, buf1, buf1len,
			       buf2, buf2len)) {
9019
			mutex_exit(&mutex_list_mutex);
9020 9021 9022
			DBUG_RETURN(1);
		}
#endif /* UNIV_DEBUG */
9023 9024 9025 9026 9027 9028 9029 9030 9031 9032
	}

	if (block_mutex) {
		buf1len = (uint) my_snprintf(buf1, sizeof buf1,
					     "combined %s:%lu",
					     block_mutex->cfile_name,
					     (ulong) block_mutex->cline);
		buf2len = (uint) my_snprintf(buf2, sizeof buf2,
					     "os_waits=%lu",
					     (ulong) block_mutex_oswait_count);
osku's avatar
osku committed
9033

9034 9035 9036 9037 9038 9039
		if (stat_print(thd, innobase_hton_name,
			       hton_name_len, buf1, buf1len,
			       buf2, buf2len)) {
			mutex_exit(&mutex_list_mutex);
			DBUG_RETURN(1);
		}
9040 9041
	}

9042
	mutex_exit(&mutex_list_mutex);
9043

9044 9045
	mutex_enter(&rw_lock_list_mutex);

9046 9047
	for (lock = UT_LIST_GET_FIRST(rw_lock_list); lock != NULL;
	     lock = UT_LIST_GET_NEXT(list, lock)) {
9048
		if (lock->count_os_wait == 0) {
9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064 9065 9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084
			continue;
		}

		if (buf_pool_is_block_lock(lock)) {
			block_lock = lock;
			block_lock_oswait_count += lock->count_os_wait;
			continue;
		}

		buf1len = my_snprintf(buf1, sizeof buf1, "%s:%lu",
				     lock->cfile_name, (ulong) lock->cline);
		buf2len = my_snprintf(buf2, sizeof buf2, "os_waits=%lu",
				      (ulong) lock->count_os_wait);

		if (stat_print(thd, innobase_hton_name,
			       hton_name_len, buf1, buf1len,
			       buf2, buf2len)) {
			mutex_exit(&rw_lock_list_mutex);
			DBUG_RETURN(1);
		}
	}

	if (block_lock) {
		buf1len = (uint) my_snprintf(buf1, sizeof buf1,
					     "combined %s:%lu",
					     block_lock->cfile_name,
					     (ulong) block_lock->cline);
		buf2len = (uint) my_snprintf(buf2, sizeof buf2,
					     "os_waits=%lu",
					     (ulong) block_lock_oswait_count);

		if (stat_print(thd, innobase_hton_name,
			       hton_name_len, buf1, buf1len,
			       buf2, buf2len)) {
			mutex_exit(&rw_lock_list_mutex);
			DBUG_RETURN(1);
9085 9086 9087 9088 9089
		}
	}

	mutex_exit(&rw_lock_list_mutex);

9090
#ifdef UNIV_DEBUG
9091 9092 9093 9094 9095 9096 9097 9098 9099
	buf2len = my_snprintf(buf2, sizeof buf2,
			     "count=%lu, spin_waits=%lu, spin_rounds=%lu, "
			     "os_waits=%lu, os_yields=%lu, os_wait_times=%lu",
			      (ulong) rw_lock_count,
			      (ulong) rw_lock_count_spin_loop,
			      (ulong) rw_lock_count_spin_rounds,
			      (ulong) rw_lock_count_os_wait,
			      (ulong) rw_lock_count_os_yield,
			      (ulong) (rw_lock_wait_time / 1000));
9100

9101
	if (stat_print(thd, innobase_hton_name, hton_name_len,
9102 9103 9104
			STRING_WITH_LEN("rw_lock_mutexes"), buf2, buf2len)) {
		DBUG_RETURN(1);
	}
9105
#endif /* UNIV_DEBUG */
9106 9107

	DBUG_RETURN(FALSE);
osku's avatar
osku committed
9108 9109
}

9110
static
9111 9112 9113
bool innobase_show_status(handlerton *hton, THD* thd, 
                          stat_print_fn* stat_print,
                          enum ha_stat_type stat_type)
9114
{
9115 9116
	DBUG_ASSERT(hton == innodb_hton_ptr);

9117 9118
	switch (stat_type) {
	case HA_ENGINE_STATUS:
9119
		return innodb_show_status(hton, thd, stat_print);
9120
	case HA_ENGINE_MUTEX:
9121
		return innodb_mutex_show_status(hton, thd, stat_print);
9122
	default:
9123
		return(FALSE);
9124
	}
osku's avatar
osku committed
9125 9126
}

9127
/************************************************************************//**
osku's avatar
osku committed
9128 9129 9130 9131
 Handling the shared INNOBASE_SHARE structure that is needed to provide table
 locking.
****************************************************************************/

9132
static INNOBASE_SHARE* get_share(const char* table_name)
osku's avatar
osku committed
9133
{
9134
	INNOBASE_SHARE *share;
9135
	mysql_mutex_lock(&innobase_share_mutex);
9136

9137
	ulint	fold = ut_fold_string(table_name);
9138 9139 9140

	HASH_SEARCH(table_name_hash, innobase_open_tables, fold,
		    INNOBASE_SHARE*, share,
9141
		    ut_ad(share->use_count > 0),
9142
		    !strcmp(share->table_name, table_name));
9143 9144 9145

	if (!share) {

9146 9147
		uint length = (uint) strlen(table_name);

9148 9149
		/* TODO: invoke HASH_MIGRATE if innobase_open_tables
		grows too big */
9150 9151 9152 9153

		share = (INNOBASE_SHARE *) my_malloc(sizeof(*share)+length+1,
			MYF(MY_FAE | MY_ZEROFILL));

9154 9155
		share->table_name = (char*) memcpy(share + 1,
						   table_name, length + 1);
9156

9157 9158
		HASH_INSERT(INNOBASE_SHARE, table_name_hash,
			    innobase_open_tables, fold, share);
9159 9160

		thr_lock_init(&share->lock);
9161 9162 9163 9164 9165

		/* Index translation table initialization */
		share->idx_trans_tbl.index_mapping = NULL;
		share->idx_trans_tbl.index_count = 0;
		share->idx_trans_tbl.array_size = 0;
9166 9167 9168
	}

	share->use_count++;
9169
	mysql_mutex_unlock(&innobase_share_mutex);
9170

9171
	return(share);
9172 9173 9174 9175
}

static void free_share(INNOBASE_SHARE* share)
{
9176
	mysql_mutex_lock(&innobase_share_mutex);
9177

9178 9179
#ifdef UNIV_DEBUG
	INNOBASE_SHARE* share2;
9180
	ulint	fold = ut_fold_string(share->table_name);
9181 9182 9183

	HASH_SEARCH(table_name_hash, innobase_open_tables, fold,
		    INNOBASE_SHARE*, share2,
9184
		    ut_ad(share->use_count > 0),
9185
		    !strcmp(share->table_name, share2->table_name));
9186 9187 9188 9189

	ut_a(share2 == share);
#endif /* UNIV_DEBUG */

9190
	if (!--share->use_count) {
9191
		ulint	fold = ut_fold_string(share->table_name);
9192 9193 9194

		HASH_DELETE(INNOBASE_SHARE, table_name_hash,
			    innobase_open_tables, fold, share);
9195
		thr_lock_delete(&share->lock);
9196 9197 9198 9199 9200

		/* Free any memory from index translation table */
		my_free(share->idx_trans_tbl.index_mapping,
			MYF(MY_ALLOW_ZERO_PTR));

9201
		my_free(share, MYF(0));
9202 9203 9204

		/* TODO: invoke HASH_MIGRATE if innobase_open_tables
		shrinks too much */
9205 9206
	}

9207
	mysql_mutex_unlock(&innobase_share_mutex);
osku's avatar
osku committed
9208 9209
}

9210
/*****************************************************************//**
osku's avatar
osku committed
9211 9212 9213 9214 9215 9216
Converts a MySQL table lock stored in the 'lock' field of the handle to
a proper type before storing pointer to the lock into an array of pointers.
MySQL also calls this if it wants to reset some table locks to a not-locked
state during the processing of an SQL query. An example is that during a
SELECT the read lock is released early on the 'const' tables where we only
fetch one row. MySQL does not call this when it releases all locks at the
9217 9218
end of an SQL statement.
@return	pointer to the next element in the 'to' array */
9219
UNIV_INTERN
osku's avatar
osku committed
9220 9221 9222
THR_LOCK_DATA**
ha_innobase::store_lock(
/*====================*/
9223 9224
	THD*			thd,		/*!< in: user thread handle */
	THR_LOCK_DATA**		to,		/*!< in: pointer to an array
osku's avatar
osku committed
9225 9226 9227 9228
						of pointers to lock structs;
						pointer to the 'lock' field
						of current handle is stored
						next to this array */
9229
	enum thr_lock_type	lock_type)	/*!< in: lock type to store in
osku's avatar
osku committed
9230 9231 9232
						'lock'; this may also be
						TL_IGNORE */
{
9233 9234
	trx_t*		trx;

9235 9236 9237
	/* Note that trx in this function is NOT necessarily prebuilt->trx
	because we call update_thd() later, in ::external_lock()! Failure to
	understand this caused a serious memory corruption bug in 5.1.11. */
9238

9239
	trx = check_trx_exists(thd);
osku's avatar
osku committed
9240

9241
	/* NOTE: MySQL can call this function with lock 'type' TL_IGNORE!
osku's avatar
osku committed
9242 9243 9244
	Be careful to ignore TL_IGNORE if we are going to do something with
	only 'real' locks! */

9245
	/* If no MySQL table is in use, we need to set the isolation level
9246 9247 9248
	of the transaction. */

	if (lock_type != TL_IGNORE
9249
	    && trx->n_mysql_tables_in_use == 0) {
9250
		trx->isolation_level = innobase_map_isolation_level(
9251
			(enum_tx_isolation) thd_tx_isolation(thd));
9252 9253 9254 9255 9256 9257 9258 9259 9260

		if (trx->isolation_level <= TRX_ISO_READ_COMMITTED
		    && trx->global_read_view) {

			/* At low transaction isolation levels we let
			each consistent read set its own snapshot */

			read_view_close_for_mysql(trx);
		}
9261 9262
	}

9263
	DBUG_ASSERT(EQ_CURRENT_THD(thd));
9264
	const bool in_lock_tables = thd_in_lock_tables(thd);
9265
	const uint sql_command = thd_sql_command(thd);
9266

9267
	if (sql_command == SQLCOM_DROP_TABLE) {
9268 9269 9270 9271 9272

		/* MySQL calls this function in DROP TABLE though this table
		handle may belong to another thd that is running a query. Let
		us in that case skip any changes to the prebuilt struct. */ 

9273 9274 9275 9276 9277 9278
	} else if ((lock_type == TL_READ && in_lock_tables)
		   || (lock_type == TL_READ_HIGH_PRIORITY && in_lock_tables)
		   || lock_type == TL_READ_WITH_SHARED_LOCKS
		   || lock_type == TL_READ_NO_INSERT
		   || (lock_type != TL_IGNORE
		       && sql_command != SQLCOM_SELECT)) {
osku's avatar
osku committed
9279 9280

		/* The OR cases above are in this order:
9281 9282
		1) MySQL is doing LOCK TABLES ... READ LOCAL, or we
		are processing a stored procedure or function, or
osku's avatar
osku committed
9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297
		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
		INSERT INTO ... SELECT ... and the logical logging (MySQL
		binlog) requires the use of a locking read, or
		MySQL is doing LOCK TABLES ... READ.
		5) we let InnoDB do locking reads for all SQL statements that
		are not simple SELECTs; note that select_lock_type in this
		case may get strengthened in ::external_lock() to LOCK_X.
		Note that we MUST use a locking read in all data modifying
		SQL statements, because otherwise the execution would not be
		serializable, and also the results from the update could be
		unexpected if an obsolete consistent read view would be
		used. */

9298
		ulint	isolation_level;
osku's avatar
osku committed
9299

9300 9301 9302
		isolation_level = trx->isolation_level;

		if ((srv_locks_unsafe_for_binlog
9303 9304 9305 9306
		     || isolation_level == TRX_ISO_READ_COMMITTED)
		    && isolation_level != TRX_ISO_SERIALIZABLE
		    && (lock_type == TL_READ || lock_type == TL_READ_NO_INSERT)
		    && (sql_command == SQLCOM_INSERT_SELECT
9307
			|| sql_command == SQLCOM_REPLACE_SELECT
9308 9309
			|| sql_command == SQLCOM_UPDATE
			|| sql_command == SQLCOM_CREATE_TABLE)) {
9310 9311 9312 9313

			/* If we either have innobase_locks_unsafe_for_binlog
			option set or this session is using READ COMMITTED
			isolation level and isolation level of the transaction
osku's avatar
osku committed
9314
			is not set to serializable and MySQL is doing
9315 9316 9317 9318 9319
			INSERT INTO...SELECT or REPLACE INTO...SELECT
			or UPDATE ... = (SELECT ...) or CREATE  ...
			SELECT... without FOR UPDATE or IN SHARE
			MODE in select, then we use consistent read
			for select. */
osku's avatar
osku committed
9320 9321 9322

			prebuilt->select_lock_type = LOCK_NONE;
			prebuilt->stored_select_lock_type = LOCK_NONE;
9323
		} else if (sql_command == SQLCOM_CHECKSUM) {
osku's avatar
osku committed
9324 9325 9326 9327 9328 9329 9330 9331 9332 9333 9334
			/* Use consistent read for checksum table */

			prebuilt->select_lock_type = LOCK_NONE;
			prebuilt->stored_select_lock_type = LOCK_NONE;
		} else {
			prebuilt->select_lock_type = LOCK_S;
			prebuilt->stored_select_lock_type = LOCK_S;
		}

	} else if (lock_type != TL_IGNORE) {

9335
		/* We set possible LOCK_X value in external_lock, not yet
osku's avatar
osku committed
9336 9337 9338 9339 9340 9341 9342 9343
		here even if this would be SELECT ... FOR UPDATE */

		prebuilt->select_lock_type = LOCK_NONE;
		prebuilt->stored_select_lock_type = LOCK_NONE;
	}

	if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK) {

9344
		/* Starting from 5.0.7, we weaken also the table locks
osku's avatar
osku committed
9345 9346
		set at the start of a MySQL stored procedure call, just like
		we weaken the locks set at the start of an SQL statement.
9347
		MySQL does set in_lock_tables TRUE there, but in reality
osku's avatar
osku committed
9348 9349 9350 9351
		we do not need table locks to make the execution of a
		single transaction stored procedure call deterministic
		(if it does not use a consistent read). */

9352
		if (lock_type == TL_READ
9353
		    && sql_command == SQLCOM_LOCK_TABLES) {
osku's avatar
osku committed
9354 9355 9356 9357 9358 9359 9360 9361 9362 9363 9364 9365 9366 9367
			/* 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
			granted (new inserts are allowed, but not seen by the
			reader). To get a similar effect on an InnoDB table,
			we must use LOCK TABLES ... READ. We convert the lock
			type here, so that for InnoDB, READ LOCAL is
			equivalent to READ. This will change the InnoDB
			behavior in mysqldump, so that dumps of InnoDB tables
			are consistent with dumps of MyISAM tables. */

			lock_type = TL_READ_NO_INSERT;
		}

9368
		/* If we are not doing a LOCK TABLE, DISCARD/IMPORT
9369
		TABLESPACE or TRUNCATE TABLE then allow multiple
9370 9371
		writers. Note that ALTER TABLE uses a TL_WRITE_ALLOW_READ
		< TL_WRITE_CONCURRENT_INSERT.
osku's avatar
osku committed
9372

9373
		We especially allow multiple writers if MySQL is at the
9374
		start of a stored procedure call (SQLCOM_CALL) or a
9375
		stored function call (MySQL does have in_lock_tables
9376
		TRUE there). */
9377

9378
		if ((lock_type >= TL_WRITE_CONCURRENT_INSERT
9379 9380 9381 9382 9383 9384 9385
		     && lock_type <= TL_WRITE)
		    && !(in_lock_tables
			 && sql_command == SQLCOM_LOCK_TABLES)
		    && !thd_tablespace_op(thd)
		    && sql_command != SQLCOM_TRUNCATE
		    && sql_command != SQLCOM_OPTIMIZE
		    && sql_command != SQLCOM_CREATE_TABLE) {
osku's avatar
osku committed
9386

9387
			lock_type = TL_WRITE_ALLOW_WRITE;
9388
		}
osku's avatar
osku committed
9389 9390 9391 9392 9393

		/* In queries of type INSERT INTO t1 SELECT ... FROM t2 ...
		MySQL would use the lock TL_READ_NO_INSERT on t2, and that
		would conflict with TL_WRITE_ALLOW_WRITE, blocking all inserts
		to t2. Convert the lock to a normal read lock to allow
9394
		concurrent inserts to t2.
9395

9396 9397
		We especially allow concurrent inserts if MySQL is at the
		start of a stored procedure call (SQLCOM_CALL)
9398
		(MySQL does have thd_in_lock_tables() TRUE there). */
9399

osku's avatar
osku committed
9400
		if (lock_type == TL_READ_NO_INSERT
9401
		    && sql_command != SQLCOM_LOCK_TABLES) {
osku's avatar
osku committed
9402 9403 9404

			lock_type = TL_READ;
		}
9405

9406 9407
		lock.type = lock_type;
	}
osku's avatar
osku committed
9408

9409
	*to++= &lock;
osku's avatar
osku committed
9410 9411 9412 9413

	return(to);
}

9414
/*********************************************************************//**
9415 9416
Read the next autoinc value. Acquire the relevant locks before reading
the AUTOINC value. If SUCCESS then the table AUTOINC mutex will be locked
9417 9418
on return and all relevant locks acquired.
@return	DB_SUCCESS or error code */
9419
UNIV_INTERN
9420 9421 9422
ulint
ha_innobase::innobase_get_autoinc(
/*==============================*/
9423
	ulonglong*	value)		/*!< out: autoinc value */
osku's avatar
osku committed
9424
{
9425 9426
 	*value = 0;
 
9427
	prebuilt->autoinc_error = innobase_lock_autoinc();
osku's avatar
osku committed
9428

9429
	if (prebuilt->autoinc_error == DB_SUCCESS) {
osku's avatar
osku committed
9430

9431 9432 9433 9434
		/* Determine the first value of the interval */
		*value = dict_table_autoinc_read(prebuilt->table);

		/* It should have been initialized during open. */
9435 9436 9437 9438
		if (*value == 0) {
			prebuilt->autoinc_error = DB_UNSUPPORTED;
			dict_table_autoinc_unlock(prebuilt->table);
		}
osku's avatar
osku committed
9439
	}
9440 9441

	return(prebuilt->autoinc_error);
9442
}
9443

9444
/*******************************************************************//**
9445
This function reads the global auto-inc counter. It doesn't use the 
9446 9447
AUTOINC lock even if the lock mode is set to TRADITIONAL.
@return	the autoinc value */
9448
UNIV_INTERN
9449 9450 9451
ulonglong
ha_innobase::innobase_peek_autoinc(void)
/*====================================*/
9452
{
9453 9454
	ulonglong	auto_inc;
	dict_table_t*	innodb_table;
9455

9456 9457
	ut_a(prebuilt != NULL);
	ut_a(prebuilt->table != NULL);
9458

9459
	innodb_table = prebuilt->table;
9460

9461
	dict_table_autoinc_lock(innodb_table);
9462

9463
	auto_inc = dict_table_autoinc_read(innodb_table);
9464

9465
	ut_a(auto_inc > 0);
9466

9467
	dict_table_autoinc_unlock(innodb_table);
9468

9469
	return(auto_inc);
osku's avatar
osku committed
9470
}
9471 9472

/*********************************************************************//**
osku's avatar
osku committed
9473 9474 9475
This function initializes the auto-inc counter if it has not been
initialized yet. This function does not change the value of the auto-inc
counter if it already has been initialized. Returns the value of the
9476 9477
auto-inc counter in *first_value, and ULONGLONG_MAX in *nb_reserved_values (as
we have a table-level lock). offset, increment, nb_desired_values are ignored.
9478 9479
*first_value is set to -1 if error (deadlock or lock wait timeout) */
UNIV_INTERN
9480 9481
void
ha_innobase::get_auto_increment(
9482
/*============================*/
9483
        ulonglong	offset,              /*!< in: table autoinc offset */
9484 9485 9486 9487
        ulonglong	increment,           /*!< in: table autoinc increment */
        ulonglong	nb_desired_values,   /*!< in: number of values reqd */
        ulonglong	*first_value,        /*!< out: the autoinc value */
        ulonglong	*nb_reserved_values) /*!< out: count of reserved values */
osku's avatar
osku committed
9488
{
9489
	trx_t*		trx;
9490 9491
	ulint		error;
	ulonglong	autoinc = 0;
9492

9493
	/* Prepare prebuilt->trx in the table handle */
9494
	update_thd(ha_thd());
9495

9496
	error = innobase_get_autoinc(&autoinc);
osku's avatar
osku committed
9497

9498 9499
	if (error != DB_SUCCESS) {
		*first_value = (~(ulonglong) 0);
9500
		return;
osku's avatar
osku committed
9501 9502
	}

9503 9504 9505 9506 9507 9508
	/* This is a hack, since nb_desired_values seems to be accurate only
	for the first call to get_auto_increment() for multi-row INSERT and
	meaningless for other statements e.g, LOAD etc. Subsequent calls to
	this method for the same statement results in different values which
	don't make sense. Therefore we store the value the first time we are
	called and count down from that as rows are written (see write_row()).
9509
	*/
9510

9511
	trx = prebuilt->trx;
9512

9513 9514 9515 9516
	/* Note: We can't rely on *first_value since some MySQL engines,
	in particular the partition engine, don't initialize it to 0 when
	invoking this method. So we are not sure if it's guaranteed to
	be 0 or not. */
9517

9518 9519 9520 9521 9522
	/* We need the upper limit of the col type to check for
	whether we update the table autoinc counter or not. */
	ulonglong	col_max_value = innobase_get_int_col_max_value(
		table->next_number_field);

9523 9524
	/* Called for the first time ? */
	if (trx->n_autoinc_rows == 0) {
9525

9526
		trx->n_autoinc_rows = (ulint) nb_desired_values;
9527

9528 9529 9530 9531 9532
		/* It's possible for nb_desired_values to be 0:
		e.g., INSERT INTO T1(C) SELECT C FROM T2; */
		if (nb_desired_values == 0) {

			trx->n_autoinc_rows = 1;
9533 9534
		}

9535
		set_if_bigger(*first_value, autoinc);
9536
	/* Not in the middle of a mult-row INSERT. */
9537
	} else if (prebuilt->autoinc_last_value == 0) {
9538
		set_if_bigger(*first_value, autoinc);
9539 9540 9541 9542 9543
	/* Check for -ve values. */
	} else if (*first_value > col_max_value && trx->n_autoinc_rows > 0) {
		/* Set to next logical value. */
		ut_a(autoinc > trx->n_autoinc_rows);
		*first_value = (autoinc - trx->n_autoinc_rows) - 1;
9544 9545
	}

9546
	*nb_reserved_values = trx->n_autoinc_rows;
9547

9548 9549 9550
	/* With old style AUTOINC locking we only update the table's
	AUTOINC counter after attempting to insert the row. */
	if (innobase_autoinc_lock_mode != AUTOINC_OLD_STYLE_LOCKING) {
9551
		ulonglong	need;
9552
		ulonglong	current;
9553
		ulonglong	next_value;
9554

9555
		current = *first_value > col_max_value ? autoinc : *first_value;
9556
		need = *nb_reserved_values * increment;
9557

9558
		/* Compute the last value in the interval */
9559
		next_value = innobase_next_autoinc(
9560
			current, need, offset, col_max_value);
9561

9562 9563
		prebuilt->autoinc_last_value = next_value;

9564 9565 9566 9567 9568 9569 9570
		if (prebuilt->autoinc_last_value < *first_value) {
			*first_value = (~(ulonglong) 0);
		} else {
			/* Update the table autoinc variable */
			dict_table_autoinc_update_if_greater(
				prebuilt->table, prebuilt->autoinc_last_value);
		}
9571 9572 9573
	} else {
		/* This will force write_row() into attempting an update
		of the table's AUTOINC counter. */
9574
		prebuilt->autoinc_last_value = 0;
9575
	}
9576 9577 9578

	/* The increment to be used to increase the AUTOINC value, we use
	this in write_row() and update_row() to increase the autoinc counter
9579 9580 9581 9582
	for columns that are filled by the user. We need the offset and
	the increment. */
	prebuilt->autoinc_offset = offset;
	prebuilt->autoinc_increment = increment;
9583 9584

	dict_table_autoinc_unlock(prebuilt->table);
osku's avatar
osku committed
9585 9586
}

9587
/*******************************************************************//**
9588 9589 9590
Reset the auto-increment counter to the given value, i.e. the next row
inserted will get the given value. This is called e.g. after TRUNCATE
is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
9591 9592
returned by storage engines that don't support this operation.
@return	0 or error code */
9593
UNIV_INTERN
osku's avatar
osku committed
9594
int
9595 9596
ha_innobase::reset_auto_increment(
/*==============================*/
9597
	ulonglong	value)		/*!< in: new value for table autoinc */
osku's avatar
osku committed
9598 9599 9600
{
	DBUG_ENTER("ha_innobase::reset_auto_increment");

9601
	int	error;
osku's avatar
osku committed
9602

9603
	update_thd(ha_thd());
9604

osku's avatar
osku committed
9605 9606 9607
	error = row_lock_table_autoinc_for_mysql(prebuilt);

	if (error != DB_SUCCESS) {
9608 9609 9610
		error = convert_error_code_to_mysql(error,
						    prebuilt->table->flags,
						    user_thd);
osku's avatar
osku committed
9611 9612

		DBUG_RETURN(error);
9613
	}
osku's avatar
osku committed
9614

9615 9616 9617 9618 9619
	/* The next value can never be 0. */
	if (value == 0) {
		value = 1;
	}

9620
	innobase_reset_autoinc(value);
osku's avatar
osku committed
9621 9622 9623 9624 9625

	DBUG_RETURN(0);
}

/* See comment in handler.cc */
9626
UNIV_INTERN
osku's avatar
osku committed
9627 9628 9629
bool
ha_innobase::get_error_message(int error, String *buf)
{
9630
	trx_t*	trx = check_trx_exists(ha_thd());
osku's avatar
osku committed
9631

9632
	buf->copy(trx->detailed_error, (uint) strlen(trx->detailed_error),
osku's avatar
osku committed
9633 9634
		system_charset_info);

9635
	return(FALSE);
osku's avatar
osku committed
9636 9637
}

9638
/*******************************************************************//**
osku's avatar
osku committed
9639 9640
Compares two 'refs'. A 'ref' is the (internal) primary key value of the row.
If there is no explicitly declared non-null unique key or a primary key, then
9641 9642
InnoDB internally uses the row id as the primary key.
@return	< 0 if ref1 < ref2, 0 if equal, else > 0 */
9643
UNIV_INTERN
osku's avatar
osku committed
9644 9645 9646
int
ha_innobase::cmp_ref(
/*=================*/
9647
	const uchar*	ref1,	/*!< in: an (internal) primary key value in the
osku's avatar
osku committed
9648
				MySQL key value format */
9649
	const uchar*	ref2)	/*!< in: an (internal) primary key value in the
osku's avatar
osku committed
9650 9651 9652 9653 9654 9655 9656 9657
				MySQL key value format */
{
	enum_field_types mysql_type;
	Field*		field;
	KEY_PART_INFO*	key_part;
	KEY_PART_INFO*	key_part_end;
	uint		len1;
	uint		len2;
9658
	int		result;
osku's avatar
osku committed
9659 9660 9661 9662 9663 9664 9665 9666 9667 9668 9669 9670 9671 9672 9673 9674 9675 9676 9677

	if (prebuilt->clust_index_was_generated) {
		/* The 'ref' is an InnoDB row id */

		return(memcmp(ref1, ref2, DATA_ROW_ID_LEN));
	}

	/* Do a type-aware comparison of primary key fields. PK fields
	are always NOT NULL, so no checks for NULL are performed. */

	key_part = table->key_info[table->s->primary_key].key_part;

	key_part_end = key_part
			+ table->key_info[table->s->primary_key].key_parts;

	for (; key_part != key_part_end; ++key_part) {
		field = key_part->field;
		mysql_type = field->type();

9678 9679 9680 9681
		if (mysql_type == MYSQL_TYPE_TINY_BLOB
			|| mysql_type == MYSQL_TYPE_MEDIUM_BLOB
			|| mysql_type == MYSQL_TYPE_BLOB
			|| mysql_type == MYSQL_TYPE_LONG_BLOB) {
9682

osku's avatar
osku committed
9683 9684 9685 9686 9687 9688 9689 9690
			/* In the MySQL key value format, a column prefix of
			a BLOB is preceded by a 2-byte length field */

			len1 = innobase_read_from_2_little_endian(ref1);
			len2 = innobase_read_from_2_little_endian(ref2);

			ref1 += 2;
			ref2 += 2;
9691 9692
			result = ((Field_blob*)field)->cmp( ref1, len1,
                                                            ref2, len2);
osku's avatar
osku committed
9693 9694 9695 9696 9697 9698 9699 9700 9701 9702 9703 9704 9705 9706 9707 9708
		} else {
			result = field->key_cmp(ref1, ref2);
		}

		if (result) {

			return(result);
		}

		ref1 += key_part->store_length;
		ref2 += key_part->store_length;
	}

	return(0);
}

9709
/*******************************************************************//**
9710 9711
Ask InnoDB if a query to a table can be cached.
@return	TRUE if query caching of the table is permitted */
9712
UNIV_INTERN
9713 9714 9715
my_bool
ha_innobase::register_query_cache_table(
/*====================================*/
9716 9717
	THD*		thd,		/*!< in: user thread handle */
	char*		table_key,	/*!< in: concatenation of database name,
9718
					the null character NUL,
9719
					and the table name */
9720
	uint		key_length,	/*!< in: length of the full name, i.e.
9721 9722
					len(dbname) + len(tablename) + 1 */
	qc_engine_callback*
9723
			call_back,	/*!< out: pointer to function for
9724 9725
					checking if query caching
					is permitted */
9726
	ulonglong	*engine_data)	/*!< in/out: data to call_back */
9727 9728 9729 9730 9731 9732 9733 9734
{
	*call_back = innobase_query_caching_of_table_permitted;
	*engine_data = 0;
	return(innobase_query_caching_of_table_permitted(thd, table_key,
							 key_length,
							 engine_data));
}

9735
UNIV_INTERN
osku's avatar
osku committed
9736 9737 9738 9739 9740 9741
char*
ha_innobase::get_mysql_bin_log_name()
{
	return(trx_sys_mysql_bin_log_name);
}

9742
UNIV_INTERN
osku's avatar
osku committed
9743 9744 9745
ulonglong
ha_innobase::get_mysql_bin_log_pos()
{
9746
	/* trx... is ib_int64_t, which is a typedef for a 64-bit integer
osku's avatar
osku committed
9747 9748
	(__int64 or longlong) so it's ok to cast it to ulonglong. */

9749
	return(trx_sys_mysql_bin_log_pos);
osku's avatar
osku committed
9750 9751
}

9752
/******************************************************************//**
osku's avatar
osku committed
9753 9754 9755
This function is used to find the storage length in bytes of the first n
characters for prefix indexes using a multibyte character set. The function
finds charset information and returns length of prefix_len characters in the
9756 9757
index field in bytes.
@return	number of bytes occupied by the first n characters */
9758
extern "C" UNIV_INTERN
osku's avatar
osku committed
9759 9760 9761
ulint
innobase_get_at_most_n_mbchars(
/*===========================*/
9762 9763
	ulint charset_id,	/*!< in: character set id */
	ulint prefix_len,	/*!< in: prefix length in bytes of the index
osku's avatar
osku committed
9764 9765
				(this has to be divided by mbmaxlen to get the
				number of CHARACTERS n in the prefix) */
9766 9767
	ulint data_len,		/*!< in: length of the string in bytes */
	const char* str)	/*!< in: character string */
osku's avatar
osku committed
9768
{
9769 9770 9771
	ulint char_length;	/*!< character length in bytes */
	ulint n_chars;		/*!< number of characters in prefix */
	CHARSET_INFO* charset;	/*!< charset used in the field */
osku's avatar
osku committed
9772 9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809

	charset = get_charset((uint) charset_id, MYF(MY_WME));

	ut_ad(charset);
	ut_ad(charset->mbmaxlen);

	/* Calculate how many characters at most the prefix index contains */

	n_chars = prefix_len / charset->mbmaxlen;

	/* If the charset is multi-byte, then we must find the length of the
	first at most n chars in the string. If the string contains less
	characters than n, then we return the length to the end of the last
	character. */

	if (charset->mbmaxlen > 1) {
		/* my_charpos() returns the byte length of the first n_chars
		characters, or a value bigger than the length of str, if
		there were not enough full characters in str.

		Why does the code below work:
		Suppose that we are looking for n UTF-8 characters.

		1) If the string is long enough, then the prefix contains at
		least n complete UTF-8 characters + maybe some extra
		characters + an incomplete UTF-8 character. No problem in
		this case. The function returns the pointer to the
		end of the nth character.

		2) If the string is not long enough, then the string contains
		the complete value of a column, that is, only complete UTF-8
		characters, and we can store in the column prefix index the
		whole string. */

		char_length = my_charpos(charset, str,
						str + data_len, (int) n_chars);
		if (char_length > data_len) {
			char_length = data_len;
9810
		}
osku's avatar
osku committed
9811 9812 9813 9814 9815 9816 9817 9818 9819 9820 9821
	} else {
		if (data_len < prefix_len) {
			char_length = data_len;
		} else {
			char_length = prefix_len;
		}
	}

	return(char_length);
}

9822 9823
/*******************************************************************//**
This function is used to prepare an X/Open XA distributed transaction.
9824
@return	0 or error number */
9825
static
9826
int
osku's avatar
osku committed
9827 9828
innobase_xa_prepare(
/*================*/
9829 9830 9831 9832 9833 9834 9835
        handlerton*	hton,	/*!< in: InnoDB handlerton */
	THD*		thd,	/*!< in: handle to the MySQL thread of
				the user whose XA transaction should
				be prepared */
	bool		all)	/*!< in: TRUE - commit transaction
				FALSE - the current SQL statement
				ended */
osku's avatar
osku committed
9836 9837
{
	int error = 0;
9838
	trx_t* trx = check_trx_exists(thd);
osku's avatar
osku committed
9839

9840 9841
	DBUG_ASSERT(hton == innodb_hton_ptr);

9842 9843 9844 9845
	/* we use support_xa value as it was seen at transaction start
	time, not the current session variable value. Any possible changes
	to the session variable take effect only in the next transaction */
	if (!trx->support_xa) {
osku's avatar
osku committed
9846 9847 9848 9849

		return(0);
	}

9850
	thd_get_xid(thd, (MYSQL_XID*) &trx->xid);
osku's avatar
osku committed
9851 9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863 9864

	/* Release a possible FIFO ticket and search latch. Since we will
	reserve the kernel mutex, we have to release the search system latch
	first to obey the latching order. */

	innobase_release_stat_resources(trx);

	if (trx->active_trans == 0 && trx->conc_state != TRX_NOT_STARTED) {

	  sql_print_error("trx->active_trans == 0, but trx->conc_state != "
			  "TRX_NOT_STARTED");
	}

	if (all
9865
		|| (!thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {
osku's avatar
osku committed
9866

9867 9868
		/* We were instructed to prepare the whole transaction, or
		this is an SQL statement end and autocommit is on */
osku's avatar
osku committed
9869

9870
		ut_ad(trx->active_trans);
osku's avatar
osku committed
9871 9872 9873

		error = (int) trx_prepare_for_mysql(trx);
	} else {
9874
		/* We just mark the SQL statement ended and do not do a
osku's avatar
osku committed
9875 9876
		transaction prepare */

9877 9878
		/* If we had reserved the auto-inc lock for some
		table in this SQL statement we release it now */
osku's avatar
osku committed
9879

9880
		row_unlock_table_autoinc_for_mysql(trx);
9881

osku's avatar
osku committed
9882 9883 9884 9885 9886 9887 9888 9889 9890 9891 9892 9893
		/* Store the current undo_no of the transaction so that we
		know where to roll back if we have to roll back the next
		SQL statement */

		trx_mark_sql_stat_end(trx);
	}

	/* Tell the InnoDB server that there might be work for utility
	threads: */

	srv_active_wake_master_thread();

inaam's avatar
inaam committed
9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908 9909 9910 9911 9912 9913 9914
	if (thd_sql_command(thd) != SQLCOM_XA_PREPARE &&
	    (all || !thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
	{

		/* For ibbackup to work the order of transactions in binlog
		and InnoDB must be the same. Consider the situation

		  thread1> prepare; write to binlog; ...
			  <context switch>
		  thread2> prepare; write to binlog; commit
		  thread1>			     ... commit

		To ensure this will not happen we're taking the mutex on
		prepare, and releasing it on commit.

		Note: only do it for normal commits, done via ha_commit_trans.
		If 2pc protocol is executed by external transaction
		coordinator, it will be just a regular MySQL client
		executing XA PREPARE and XA COMMIT commands.
		In this case we cannot know how many minutes or hours
		will be between XA PREPARE and XA COMMIT, and we don't want
9915
		to block for undefined period of time. */
9916
		mysql_mutex_lock(&prepare_commit_mutex);
inaam's avatar
inaam committed
9917 9918 9919
		trx->active_trans = 2;
	}

9920
	return(error);
osku's avatar
osku committed
9921 9922
}

9923 9924
/*******************************************************************//**
This function is used to recover X/Open XA distributed transactions.
9925
@return	number of prepared transactions stored in xid_list */
9926
static
9927
int
osku's avatar
osku committed
9928 9929
innobase_xa_recover(
/*================*/
9930 9931 9932
	handlerton*	hton,	/*!< in: InnoDB handlerton */
	XID*		xid_list,/*!< in/out: prepared transactions */
	uint		len)	/*!< in: number of slots in xid_list */
osku's avatar
osku committed
9933
{
9934 9935
	DBUG_ASSERT(hton == innodb_hton_ptr);

osku's avatar
osku committed
9936 9937 9938 9939 9940 9941 9942 9943
	if (len == 0 || xid_list == NULL) {

		return(0);
	}

	return(trx_recover_for_mysql(xid_list, len));
}

9944
/*******************************************************************//**
osku's avatar
osku committed
9945
This function is used to commit one X/Open XA distributed transaction
9946 9947
which is in the prepared state
@return	0 or error number */
9948
static
9949
int
osku's avatar
osku committed
9950 9951
innobase_commit_by_xid(
/*===================*/
9952
        handlerton *hton,
9953
	XID*	xid)	/*!< in: X/Open XA transaction identification */
osku's avatar
osku committed
9954 9955 9956
{
	trx_t*	trx;

9957 9958
	DBUG_ASSERT(hton == innodb_hton_ptr);

osku's avatar
osku committed
9959 9960 9961 9962
	trx = trx_get_trx_by_xid(xid);

	if (trx) {
		innobase_commit_low(trx);
9963

osku's avatar
osku committed
9964 9965 9966 9967 9968 9969
		return(XA_OK);
	} else {
		return(XAER_NOTA);
	}
}

9970
/*******************************************************************//**
osku's avatar
osku committed
9971
This function is used to rollback one X/Open XA distributed transaction
9972 9973
which is in the prepared state
@return	0 or error number */
9974
static
9975
int
osku's avatar
osku committed
9976 9977
innobase_rollback_by_xid(
/*=====================*/
9978 9979 9980
	handlerton*	hton,	/*!< in: InnoDB handlerton */
	XID*		xid)	/*!< in: X/Open XA transaction
				identification */
osku's avatar
osku committed
9981 9982 9983
{
	trx_t*	trx;

9984 9985
	DBUG_ASSERT(hton == innodb_hton_ptr);

osku's avatar
osku committed
9986 9987 9988 9989 9990 9991 9992 9993 9994
	trx = trx_get_trx_by_xid(xid);

	if (trx) {
		return(innobase_rollback_trx(trx));
	} else {
		return(XAER_NOTA);
	}
}

9995
/*******************************************************************//**
osku's avatar
osku committed
9996 9997
Create a consistent view for a cursor based on current transaction
which is created if the corresponding MySQL thread still lacks one.
9998
This consistent view is then used inside of MySQL when accessing records
9999 10000
using a cursor.
@return	pointer to cursor view or NULL */
10001
static
osku's avatar
osku committed
10002
void*
10003
innobase_create_cursor_view(
10004
/*========================*/
10005 10006
        handlerton *hton, /*!< in: innobase hton */
	THD* thd)	  /*!< in: user thread handle */
osku's avatar
osku committed
10007
{
10008 10009
	DBUG_ASSERT(hton == innodb_hton_ptr);

10010
	return(read_cursor_view_create_for_mysql(check_trx_exists(thd)));
osku's avatar
osku committed
10011 10012
}

10013
/*******************************************************************//**
osku's avatar
osku committed
10014
Close the given consistent cursor view of a transaction and restore
10015
global read view to a transaction read view. Transaction is created if the
osku's avatar
osku committed
10016
corresponding MySQL thread still lacks one. */
10017
static
osku's avatar
osku committed
10018 10019
void
innobase_close_cursor_view(
10020
/*=======================*/
10021
        handlerton *hton,
10022 10023
	THD*	thd,	/*!< in: user thread handle */
	void*	curview)/*!< in: Consistent read view to be closed */
osku's avatar
osku committed
10024
{
10025 10026
	DBUG_ASSERT(hton == innodb_hton_ptr);

10027 10028
	read_cursor_view_close_for_mysql(check_trx_exists(thd),
					 (cursor_view_t*) curview);
osku's avatar
osku committed
10029 10030
}

10031
/*******************************************************************//**
10032 10033
Set the given consistent cursor view to a transaction which is created
if the corresponding MySQL thread still lacks one. If the given
osku's avatar
osku committed
10034 10035
consistent cursor view is NULL global read view of a transaction is
restored to a transaction read view. */
10036
static
osku's avatar
osku committed
10037 10038 10039
void
innobase_set_cursor_view(
/*=====================*/
10040
        handlerton *hton,
10041 10042
	THD*	thd,	/*!< in: user thread handle */
	void*	curview)/*!< in: Consistent cursor view to be set */
osku's avatar
osku committed
10043
{
10044 10045
	DBUG_ASSERT(hton == innodb_hton_ptr);

10046 10047
	read_cursor_set_for_mysql(check_trx_exists(thd),
				  (cursor_view_t*) curview);
osku's avatar
osku committed
10048 10049
}

10050 10051 10052 10053 10054 10055 10056 10057 10058 10059 10060 10061 10062 10063 10064 10065 10066
/*******************************************************************//**
If col_name is not NULL, check whether the named column is being
renamed in the table. If col_name is not provided, check
whether any one of columns in the table is being renamed.
@return true if the column is being renamed */
static
bool
check_column_being_renamed(
/*=======================*/
	const TABLE*	table,		/*!< in: MySQL table */
	const char*	col_name)	/*!< in: name of the column */
{
	uint		k;
	Field*		field;

	for (k = 0; k < table->s->fields; k++) {
		field = table->field[k];
osku's avatar
osku committed
10067

10068 10069 10070 10071 10072 10073 10074 10075 10076 10077 10078 10079 10080 10081 10082 10083 10084 10085 10086 10087 10088 10089 10090
		if (field->flags & FIELD_IS_RENAMED) {

			/* If col_name is not provided, return
			if the field is marked as being renamed. */
			if (!col_name) {
				return(true);
			}

			/* If col_name is provided, return only
			if names match */
			if (innobase_strcasecmp(field->field_name,
						col_name) == 0) {
				return(true);
			}
		}
	}

	return(false);
}

/*******************************************************************//**
Check whether any of the given columns is being renamed in the table.
@return true if any of col_names is being renamed in table */
10091 10092 10093 10094
static
bool
column_is_being_renamed(
/*====================*/
10095 10096 10097
	TABLE*		table,		/*!< in: MySQL table */
	uint		n_cols,		/*!< in: number of columns */
	const char**	col_names)	/*!< in: names of the columns */
10098 10099 10100 10101
{
	uint		j;

	for (j = 0; j < n_cols; j++) {
10102 10103
		if (check_column_being_renamed(table, col_names[j])) {
			return(true);
10104 10105 10106 10107 10108 10109 10110 10111 10112 10113 10114 10115 10116 10117 10118 10119 10120 10121 10122 10123 10124 10125 10126 10127 10128 10129 10130 10131 10132 10133 10134 10135 10136 10137 10138 10139 10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156 10157 10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168
		}
	}

	return(false);
}

/***********************************************************************
Check whether a column in table "table" is being renamed and if this column
is part of a foreign key, either part of another table, referencing this
table or part of this table, referencing another table. */
static
bool
foreign_key_column_is_being_renamed(
/*================================*/
					/* out: true if a column that
					participates in a foreign key definition
					is being renamed */
	row_prebuilt_t*	prebuilt,	/* in: InnoDB prebuilt struct */
	TABLE*		table)		/* in: MySQL table */
{
	dict_foreign_t*	foreign;

	/* check whether there are foreign keys at all */
	if (UT_LIST_GET_LEN(prebuilt->table->foreign_list) == 0
	    && UT_LIST_GET_LEN(prebuilt->table->referenced_list) == 0) {
		/* no foreign keys involved with prebuilt->table */

		return(false);
	}

	row_mysql_lock_data_dictionary(prebuilt->trx);

	/* Check whether any column in the foreign key constraints which refer
	to this table is being renamed. */
	for (foreign = UT_LIST_GET_FIRST(prebuilt->table->referenced_list);
	     foreign != NULL;
	     foreign = UT_LIST_GET_NEXT(referenced_list, foreign)) {

		if (column_is_being_renamed(table, foreign->n_fields,
					    foreign->referenced_col_names)) {

			row_mysql_unlock_data_dictionary(prebuilt->trx);
			return(true);
		}
	}

	/* Check whether any column in the foreign key constraints in the
	table is being renamed. */
	for (foreign = UT_LIST_GET_FIRST(prebuilt->table->foreign_list);
	     foreign != NULL;
	     foreign = UT_LIST_GET_NEXT(foreign_list, foreign)) {

		if (column_is_being_renamed(table, foreign->n_fields,
					    foreign->foreign_col_names)) {

			row_mysql_unlock_data_dictionary(prebuilt->trx);
			return(true);
		}
	}

	row_mysql_unlock_data_dictionary(prebuilt->trx);

	return(false);
}

10169 10170 10171
UNIV_INTERN
bool
ha_innobase::check_if_incompatible_data(
10172 10173
	HA_CREATE_INFO*	info,
	uint		table_changes)
osku's avatar
osku committed
10174
{
10175
	if (table_changes != IS_EQUAL_YES) {
osku's avatar
osku committed
10176

10177
		return(COMPATIBLE_DATA_NO);
10178 10179 10180 10181 10182 10183
	}

	/* Check that auto_increment value was not changed */
	if ((info->used_fields & HA_CREATE_USED_AUTO) &&
		info->auto_increment_value != 0) {

10184
		return(COMPATIBLE_DATA_NO);
10185 10186
	}

10187 10188 10189 10190 10191 10192 10193 10194 10195
	/* For column rename operation, MySQL does not supply enough
	information (new column name etc.) for InnoDB to make appropriate
	system metadata change. To avoid system metadata inconsistency,
	currently we can just request a table rebuild/copy by returning
	COMPATIBLE_DATA_NO */
	if (check_column_being_renamed(table, NULL)) {
		return COMPATIBLE_DATA_NO;
	}

10196 10197 10198 10199 10200 10201 10202
	/* Check if a column participating in a foreign key is being renamed.
	There is no mechanism for updating InnoDB foreign key definitions. */
	if (foreign_key_column_is_being_renamed(prebuilt, table)) {

		return COMPATIBLE_DATA_NO;
	}

10203
	/* Check that row format didn't change */
10204 10205 10206
	if ((info->used_fields & HA_CREATE_USED_ROW_FORMAT)
	    && info->row_type != ROW_TYPE_DEFAULT
	    && info->row_type != get_row_type()) {
10207 10208 10209

		return(COMPATIBLE_DATA_NO);
	}
osku's avatar
osku committed
10210

10211 10212
	/* Specifying KEY_BLOCK_SIZE requests a rebuild of the table. */
	if (info->used_fields & HA_CREATE_USED_KEY_BLOCK_SIZE) {
10213
		return(COMPATIBLE_DATA_NO);
10214 10215
	}

10216
	return(COMPATIBLE_DATA_YES);
10217
}
10218

10219
/************************************************************//**
10220 10221
Validate the file format name and return its corresponding id.
@return	valid file format id */
10222 10223 10224 10225
static
uint
innobase_file_format_name_lookup(
/*=============================*/
10226
	const char*	format_name)	/*!< in: pointer to file format name */
10227 10228 10229 10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240 10241 10242 10243 10244 10245 10246 10247 10248 10249 10250 10251 10252 10253 10254 10255 10256 10257 10258 10259 10260 10261
{
	char*	endp;
	uint	format_id;

	ut_a(format_name != NULL);

	/* The format name can contain the format id itself instead of
	the name and we check for that. */
	format_id = (uint) strtoul(format_name, &endp, 10);

	/* Check for valid parse. */
	if (*endp == '\0' && *format_name != '\0') {

		if (format_id <= DICT_TF_FORMAT_MAX) {

			return(format_id);
		}
	} else {

		for (format_id = 0; format_id <= DICT_TF_FORMAT_MAX;
		     format_id++) {
			const char*	name;

			name = trx_sys_file_format_id_to_name(format_id);

			if (!innobase_strcasecmp(format_name, name)) {

				return(format_id);
			}
		}
	}

	return(DICT_TF_FORMAT_MAX + 1);
}

10262
/************************************************************//**
10263
Validate the file format check value, is it one of "on" or "off",
10264 10265
as a side effect it sets the srv_check_file_format_at_startup variable.
@return	true if config value one of "on" or  "off" */
10266 10267 10268 10269
static
bool
innobase_file_format_check_on_off(
/*==============================*/
10270
	const char*	format_check)	/*!< in: parameter value */
10271 10272 10273 10274 10275 10276 10277 10278 10279 10280 10281 10282 10283 10284 10285 10286 10287 10288 10289
{
	bool		ret = true;

	if (!innobase_strcasecmp(format_check, "off")) {

		/* Set the value to disable checking. */
		srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX + 1;

	} else if (!innobase_strcasecmp(format_check, "on")) {

		/* Set the value to the lowest supported format. */
		srv_check_file_format_at_startup = DICT_TF_FORMAT_51;
	} else {
		ret = FALSE;
	}

	return(ret);
}

10290
/************************************************************//**
10291
Validate the file format check config parameters, as a side effect it
10292
sets the srv_check_file_format_at_startup variable.
10293
@return the format_id if valid config value, otherwise, return -1 */
10294
static
10295 10296
int
innobase_file_format_validate_and_set(
10297
/*================================*/
10298
	const char*	format_check)	/*!< in: parameter value */
10299 10300
{
	uint		format_id;
10301

10302 10303 10304 10305
	format_id = innobase_file_format_name_lookup(format_check);

	if (format_id < DICT_TF_FORMAT_MAX + 1) {
		srv_check_file_format_at_startup = format_id;
10306 10307

		return((int) format_id);
10308
	} else {
10309
		return(-1);
10310 10311 10312
	}
}

10313
/*************************************************************//**
10314
Check if it is a valid file format. This function is registered as
10315 10316
a callback with MySQL.
@return	0 for valid file format */
10317 10318 10319 10320
static
int
innodb_file_format_name_validate(
/*=============================*/
10321 10322
	THD*				thd,	/*!< in: thread handle */
	struct st_mysql_sys_var*	var,	/*!< in: pointer to system
10323
						variable */
10324
	void*				save,	/*!< out: immediate result
10325
						for update function */
10326
	struct st_mysql_value*		value)	/*!< in: incoming string */
10327 10328 10329 10330 10331 10332 10333 10334 10335 10336 10337 10338 10339 10340 10341 10342 10343 10344
{
	const char*	file_format_input;
	char		buff[STRING_BUFFER_USUAL_SIZE];
	int		len = sizeof(buff);

	ut_a(save != NULL);
	ut_a(value != NULL);

	file_format_input = value->val_str(value, buff, &len);

	if (file_format_input != NULL) {
		uint	format_id;

		format_id = innobase_file_format_name_lookup(
			file_format_input);

		if (format_id <= DICT_TF_FORMAT_MAX) {

10345 10346 10347 10348 10349
			/* Save a pointer to the name in the
			'file_format_name_map' constant array. */
			*static_cast<const char**>(save) =
			    trx_sys_file_format_id_to_name(format_id);

10350 10351 10352 10353
			return(0);
		}
	}

10354
	*static_cast<const char**>(save) = NULL;
10355 10356 10357
	return(1);
}

10358
/****************************************************************//**
10359 10360 10361
Update the system variable innodb_file_format using the "saved"
value. This function is registered as a callback with MySQL. */
static
10362
void
10363 10364
innodb_file_format_name_update(
/*===========================*/
10365 10366
	THD*				thd,		/*!< in: thread handle */
	struct st_mysql_sys_var*	var,		/*!< in: pointer to
10367
							system variable */
10368
	void*				var_ptr,	/*!< out: where the
10369
							formal string goes */
10370
	const void*			save)		/*!< in: immediate result
10371 10372
							from check function */
{
10373 10374
	const char* format_name;

10375 10376 10377
	ut_a(var_ptr != NULL);
	ut_a(save != NULL);

10378 10379 10380 10381 10382 10383 10384 10385 10386 10387 10388
	format_name = *static_cast<const char*const*>(save);

	if (format_name) {
		uint	format_id;

		format_id = innobase_file_format_name_lookup(format_name);

		if (format_id <= DICT_TF_FORMAT_MAX) {
			srv_file_format = format_id;
		}
	}
10389

10390
	*static_cast<const char**>(var_ptr)
10391
		= trx_sys_file_format_id_to_name(srv_file_format);
10392 10393
}

10394
/*************************************************************//**
10395
Check if valid argument to innodb_file_format_check. This
10396 10397
function is registered as a callback with MySQL.
@return	0 for valid file format */
10398 10399 10400 10401
static
int
innodb_file_format_check_validate(
/*==============================*/
10402 10403
	THD*				thd,	/*!< in: thread handle */
	struct st_mysql_sys_var*	var,	/*!< in: pointer to system
10404
						variable */
10405
	void*				save,	/*!< out: immediate result
10406
						for update function */
10407
	struct st_mysql_value*		value)	/*!< in: incoming string */
10408 10409 10410 10411
{
	const char*	file_format_input;
	char		buff[STRING_BUFFER_USUAL_SIZE];
	int		len = sizeof(buff);
10412
	int		format_id;
10413 10414 10415 10416 10417 10418 10419 10420 10421 10422 10423 10424

	ut_a(save != NULL);
	ut_a(value != NULL);

	file_format_input = value->val_str(value, buff, &len);

	if (file_format_input != NULL) {

		/* Check if user set on/off, we want to print a suitable
		message if they did so. */

		if (innobase_file_format_check_on_off(file_format_input)) {
10425 10426 10427
			push_warning_printf(thd,
				MYSQL_ERROR::WARN_LEVEL_WARN,
				ER_WRONG_ARGUMENTS,
10428
				"InnoDB: invalid innodb_file_format_check "
10429 10430
				"value; on/off can only be set at startup or "
				"in the configuration file");
10431 10432 10433
		} else {
			format_id = innobase_file_format_validate_and_set(
							file_format_input);
10434

10435 10436 10437 10438 10439 10440
			if (format_id >= 0) {
				/* Save a pointer to the name in the
				'file_format_name_map' constant array. */
				*static_cast<const char**>(save) =
				    trx_sys_file_format_id_to_name(
							(uint)format_id);
10441

10442
				return(0);
10443

10444 10445 10446 10447 10448 10449 10450 10451 10452 10453
			} else {
				push_warning_printf(thd,
				  MYSQL_ERROR::WARN_LEVEL_WARN,
				  ER_WRONG_ARGUMENTS,
				  "InnoDB: invalid innodb_file_format_check "
				  "value; can be any format up to %s "
				  "or its equivalent numeric id",
				  trx_sys_file_format_id_to_name(
						DICT_TF_FORMAT_MAX));
			}
10454 10455 10456
		}
	}

10457
	*static_cast<const char**>(save) = NULL;
10458 10459 10460
	return(1);
}

10461
/****************************************************************//**
10462 10463 10464
Update the system variable innodb_file_format_check using the "saved"
value. This function is registered as a callback with MySQL. */
static
10465
void
10466 10467
innodb_file_format_check_update(
/*============================*/
10468 10469
	THD*				thd,		/*!< in: thread handle */
	struct st_mysql_sys_var*	var,		/*!< in: pointer to
10470
							system variable */
10471
	void*				var_ptr,	/*!< out: where the
10472
							formal string goes */
10473
	const void*			save)		/*!< in: immediate result
10474 10475
							from check function */
{
10476 10477 10478
	const char*	format_name_in;
	const char**	format_name_out;
	uint		format_id;
10479 10480 10481 10482

	ut_a(save != NULL);
	ut_a(var_ptr != NULL);

10483 10484 10485 10486 10487 10488 10489 10490 10491 10492 10493 10494 10495 10496 10497 10498 10499 10500 10501
	format_name_in = *static_cast<const char*const*>(save);

	if (!format_name_in) {

		return;
	}

	format_id = innobase_file_format_name_lookup(format_name_in);

	if (format_id > DICT_TF_FORMAT_MAX) {
		/* DEFAULT is "on", which is invalid at runtime. */
		push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
				    ER_WRONG_ARGUMENTS,
				    "Ignoring SET innodb_file_format=%s",
				    format_name_in);
		return;
	}

	format_name_out = static_cast<const char**>(var_ptr);
10502 10503

	/* Update the max format id in the system tablespace. */
10504
	if (trx_sys_file_format_max_set(format_id, format_name_out)) {
10505 10506 10507
		ut_print_timestamp(stderr);
		fprintf(stderr,
			" [Info] InnoDB: the file format in the system "
10508
			"tablespace is now set to %s.\n", *format_name_out);
10509 10510 10511
	}
}

10512
/****************************************************************//**
10513 10514 10515 10516 10517 10518
Update the system variable innodb_adaptive_hash_index using the "saved"
value. This function is registered as a callback with MySQL. */
static
void
innodb_adaptive_hash_index_update(
/*==============================*/
10519 10520
	THD*				thd,		/*!< in: thread handle */
	struct st_mysql_sys_var*	var,		/*!< in: pointer to
10521
							system variable */
10522
	void*				var_ptr,	/*!< out: where the
10523
							formal string goes */
10524
	const void*			save)		/*!< in: immediate result
10525 10526 10527 10528 10529 10530 10531 10532 10533
							from check function */
{
	if (*(my_bool*) save) {
		btr_search_enable();
	} else {
		btr_search_disable();
	}
}

10534 10535 10536 10537 10538 10539 10540 10541 10542 10543 10544 10545 10546 10547 10548 10549 10550 10551 10552
/****************************************************************//**
Update the system variable innodb_old_blocks_pct using the "saved"
value. This function is registered as a callback with MySQL. */
static
void
innodb_old_blocks_pct_update(
/*=========================*/
	THD*				thd,	/*!< in: thread handle */
	struct st_mysql_sys_var*	var,	/*!< in: pointer to
						system variable */
	void*				var_ptr,/*!< out: where the
						formal string goes */
	const void*			save)	/*!< in: immediate result
						from check function */
{
	innobase_old_blocks_pct = buf_LRU_old_ratio_update(
		*static_cast<const uint*>(save), TRUE);
}

10553
/*************************************************************//**
10554
Check if it is a valid value of innodb_change_buffering.  This function is
10555 10556
registered as a callback with MySQL.
@return	0 for valid innodb_change_buffering */
10557 10558 10559
static
int
innodb_change_buffering_validate(
10560
/*=============================*/
10561 10562
	THD*				thd,	/*!< in: thread handle */
	struct st_mysql_sys_var*	var,	/*!< in: pointer to system
10563
						variable */
10564
	void*				save,	/*!< out: immediate result
10565
						for update function */
10566
	struct st_mysql_value*		value)	/*!< in: incoming string */
10567 10568 10569 10570 10571 10572 10573 10574 10575 10576 10577 10578 10579 10580 10581 10582 10583 10584 10585 10586 10587 10588 10589 10590 10591 10592 10593
{
	const char*	change_buffering_input;
	char		buff[STRING_BUFFER_USUAL_SIZE];
	int		len = sizeof(buff);

	ut_a(save != NULL);
	ut_a(value != NULL);

	change_buffering_input = value->val_str(value, buff, &len);

	if (change_buffering_input != NULL) {
		ulint	use;

		for (use = 0; use < UT_ARR_SIZE(innobase_change_buffering_values);
		     use++) {
			if (!innobase_strcasecmp(
				    change_buffering_input,
				    innobase_change_buffering_values[use])) {
				*(ibuf_use_t*) save = (ibuf_use_t) use;
				return(0);
			}
		}
	}

	return(1);
}

10594
/****************************************************************//**
10595 10596 10597 10598 10599
Update the system variable innodb_change_buffering using the "saved"
value. This function is registered as a callback with MySQL. */
static
void
innodb_change_buffering_update(
10600
/*===========================*/
10601 10602
	THD*				thd,		/*!< in: thread handle */
	struct st_mysql_sys_var*	var,		/*!< in: pointer to
10603
							system variable */
10604
	void*				var_ptr,	/*!< out: where the
10605
							formal string goes */
10606
	const void*			save)		/*!< in: immediate result
10607 10608 10609 10610
							from check function */
{
	ut_a(var_ptr != NULL);
	ut_a(save != NULL);
10611
	ut_a((*(ibuf_use_t*) save) < IBUF_USE_COUNT);
10612 10613 10614 10615 10616 10617

	ibuf_use = *(const ibuf_use_t*) save;

	*(const char**) var_ptr = innobase_change_buffering_values[ibuf_use];
}

10618 10619 10620 10621 10622 10623 10624 10625
static int show_innodb_vars(THD *thd, SHOW_VAR *var, char *buff)
{
  innodb_export_status();
  var->type= SHOW_ARRAY;
  var->value= (char *) &innodb_status_variables;
  return 0;
}

10626 10627 10628
/***********************************************************************
This function checks each index name for a table against reserved
system default primary index name 'GEN_CLUST_INDEX'. If a name matches,
10629 10630
this function pushes an warning message to the client, and returns true. */
extern "C" UNIV_INTERN
10631 10632 10633 10634 10635 10636
bool
innobase_index_name_is_reserved(
/*============================*/
					/* out: true if an index name
					matches the reserved name */
	const trx_t*	trx,		/* in: InnoDB transaction handle */
10637 10638 10639
	const KEY*	key_info,	/* in: Indexes to be created */
	ulint		num_of_keys)	/* in: Number of indexes to
					be created. */
10640
{
10641
	const KEY*	key;
10642 10643
	uint		key_num;	/* index number */

10644 10645
	for (key_num = 0; key_num < num_of_keys; key_num++) {
		key = &key_info[key_num];
10646 10647 10648 10649 10650

		if (innobase_strcasecmp(key->name,
					innobase_index_reserve_name) == 0) {
			/* Push warning to mysql */
			push_warning_printf((THD*) trx->mysql_thd,
10651 10652
					    MYSQL_ERROR::WARN_LEVEL_WARN,
					    ER_WRONG_NAME_FOR_INDEX,
10653 10654 10655 10656 10657 10658
					    "Cannot Create Index with name "
					    "'%s'. The name is reserved "
					    "for the system default primary "
					    "index.",
					    innobase_index_reserve_name);

10659 10660 10661
			my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0),
				 innobase_index_reserve_name);

10662 10663 10664 10665 10666 10667 10668
			return(true);
		}
	}

	return(false);
}

10669
static SHOW_VAR innodb_status_variables_export[]= {
10670 10671 10672 10673
  {"Innodb",                   (char*) &show_innodb_vars, SHOW_FUNC},
  {NullS, NullS, SHOW_LONG}
};

10674
static struct st_mysql_storage_engine innobase_storage_engine=
10675
{ MYSQL_HANDLERTON_INTERFACE_VERSION };
10676

10677 10678 10679 10680 10681 10682 10683 10684 10685 10686 10687 10688 10689 10690 10691 10692 10693 10694
/* plugin options */
static MYSQL_SYSVAR_BOOL(checksums, innobase_use_checksums,
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
  "Enable InnoDB checksums validation (enabled by default). "
  "Disable with --skip-innodb-checksums.",
  NULL, NULL, TRUE);

static MYSQL_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
  PLUGIN_VAR_READONLY,
  "The common part for InnoDB table spaces.",
  NULL, NULL, NULL);

static MYSQL_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
  "Enable InnoDB doublewrite buffer (enabled by default). "
  "Disable with --skip-innodb-doublewrite.",
  NULL, NULL, TRUE);

10695 10696 10697 10698 10699
static MYSQL_SYSVAR_ULONG(io_capacity, srv_io_capacity,
  PLUGIN_VAR_RQCMDARG,
  "Number of IOPs the server can do. Tunes the background IO rate",
  NULL, NULL, 200, 100, ~0L, 0);

10700 10701 10702 10703 10704 10705 10706 10707 10708 10709 10710 10711 10712 10713 10714 10715 10716
static MYSQL_SYSVAR_ULONG(purge_batch_size, srv_purge_batch_size,
  PLUGIN_VAR_OPCMDARG,
  "Number of UNDO logs to purge in one batch from the history list. "
  "Default is 20",
  NULL, NULL,
  20,			/* Default setting */
  1,			/* Minimum value */
  5000, 0);		/* Maximum value */

static MYSQL_SYSVAR_ULONG(purge_threads, srv_n_purge_threads,
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
  "Purge threads can be either 0 or 1. Default is 0.",
  NULL, NULL,
  0,			/* Default setting */
  0,			/* Minimum value */
  1, 0);		/* Maximum value */

10717 10718 10719 10720 10721 10722 10723 10724 10725 10726 10727 10728
static MYSQL_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
  PLUGIN_VAR_OPCMDARG,
  "Speeds up the shutdown process of the InnoDB storage engine. Possible "
  "values are 0, 1 (faster)"
  /*
    NetWare can't close unclosed files, can't automatically kill remaining
    threads, etc, so on this OS we disable the crash-like InnoDB shutdown.
  */
  IF_NETWARE("", " or 2 (fastest - crash-like)")
  ".",
  NULL, NULL, 1, 0, IF_NETWARE(1,2), 0);

10729 10730
static MYSQL_SYSVAR_BOOL(file_per_table, srv_file_per_table,
  PLUGIN_VAR_NOCMDARG,
10731 10732 10733
  "Stores each InnoDB table to an .ibd file in the database dir.",
  NULL, NULL, FALSE);

10734 10735 10736
static MYSQL_SYSVAR_STR(file_format, innobase_file_format_name,
  PLUGIN_VAR_RQCMDARG,
  "File format to use for new tables in .ibd files.",
10737 10738
  innodb_file_format_name_validate,
  innodb_file_format_name_update, "Antelope");
10739

10740 10741 10742 10743
/* If a new file format is introduced, the file format
name needs to be updated accordingly. Please refer to
file_format_name_map[] defined in trx0sys.c for the next
file format name. */
10744 10745 10746
static MYSQL_SYSVAR_STR(file_format_check, innobase_file_format_check,
  PLUGIN_VAR_OPCMDARG,
  "The highest file format in the tablespace.",
10747
  innodb_file_format_check_validate,
10748
  innodb_file_format_check_update, "Barracuda");
10749

10750 10751 10752 10753 10754 10755 10756
static MYSQL_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
  PLUGIN_VAR_OPCMDARG,
  "Set to 0 (write and flush once per second),"
  " 1 (write and flush at each commit)"
  " or 2 (write at commit, flush once per second).",
  NULL, NULL, 1, 0, 2, 0);

10757
static MYSQL_SYSVAR_STR(flush_method, innobase_file_flush_method,
10758 10759 10760 10761 10762 10763 10764 10765 10766 10767 10768 10769 10770 10771 10772 10773 10774 10775 10776 10777 10778 10779 10780 10781 10782
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "With which method to flush data.", NULL, NULL, NULL);

static MYSQL_SYSVAR_BOOL(locks_unsafe_for_binlog, innobase_locks_unsafe_for_binlog,
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
  "Force InnoDB to not use next-key locking, to use only row-level locking.",
  NULL, NULL, FALSE);

#ifdef UNIV_LOG_ARCHIVE
static MYSQL_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Where full logs should be archived.", NULL, NULL, NULL);

static MYSQL_SYSVAR_BOOL(log_archive, innobase_log_archive,
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
  "Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
#endif /* UNIV_LOG_ARCHIVE */

static MYSQL_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Path to InnoDB log files.", NULL, NULL, NULL);

static MYSQL_SYSVAR_ULONG(max_dirty_pages_pct, srv_max_buf_pool_modified_pct,
  PLUGIN_VAR_RQCMDARG,
  "Percentage of dirty pages allowed in bufferpool.",
10783 10784 10785 10786 10787 10788
  NULL, NULL, 75, 0, 99, 0);

static MYSQL_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
  PLUGIN_VAR_NOCMDARG,
  "Attempt flushing dirty pages to avoid IO bursts at checkpoints.",
  NULL, NULL, TRUE);
10789 10790 10791 10792 10793 10794 10795 10796 10797 10798 10799 10800 10801 10802 10803 10804 10805

static MYSQL_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
  PLUGIN_VAR_RQCMDARG,
  "Desired maximum length of the purge queue (0 = no limit)",
  NULL, NULL, 0, 0, ~0L, 0);

static MYSQL_SYSVAR_BOOL(rollback_on_timeout, innobase_rollback_on_timeout,
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
  "Roll back the complete transaction on lock wait timeout, for 4.x compatibility (disabled by default)",
  NULL, NULL, FALSE);

static MYSQL_SYSVAR_BOOL(status_file, innobase_create_status_file,
  PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_NOSYSVAR,
  "Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
  NULL, NULL, FALSE);

static MYSQL_SYSVAR_BOOL(stats_on_metadata, innobase_stats_on_metadata,
10806
  PLUGIN_VAR_OPCMDARG,
10807 10808 10809
  "Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)",
  NULL, NULL, TRUE);

10810 10811 10812 10813 10814
static MYSQL_SYSVAR_ULONGLONG(stats_sample_pages, srv_stats_sample_pages,
  PLUGIN_VAR_RQCMDARG,
  "The number of index pages to sample when calculating statistics (default 8)",
  NULL, NULL, 8, 1, ~0ULL, 0);

10815 10816
static MYSQL_SYSVAR_BOOL(adaptive_hash_index, btr_search_enabled,
  PLUGIN_VAR_OPCMDARG,
10817 10818
  "Enable InnoDB adaptive hash index (enabled by default).  "
  "Disable with --skip-innodb-adaptive-hash-index.",
10819
  NULL, innodb_adaptive_hash_index_update, TRUE);
10820 10821 10822 10823 10824 10825 10826

static MYSQL_SYSVAR_ULONG(replication_delay, srv_replication_delay,
  PLUGIN_VAR_RQCMDARG,
  "Replication thread delay (ms) on the slave server if "
  "innodb_thread_concurrency is reached (0 by default)",
  NULL, NULL, 0, 0, ~0UL, 0);

10827 10828 10829
static MYSQL_SYSVAR_LONG(additional_mem_pool_size, innobase_additional_mem_pool_size,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
10830
  NULL, NULL, 8*1024*1024L, 512*1024L, LONG_MAX, 1024);
10831 10832 10833 10834 10835 10836 10837 10838 10839

static MYSQL_SYSVAR_ULONG(autoextend_increment, srv_auto_extend_increment,
  PLUGIN_VAR_RQCMDARG,
  "Data file autoextend increment in megabytes",
  NULL, NULL, 8L, 1L, 1000L, 0);

static MYSQL_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
10840
  NULL, NULL, 128*1024*1024L, 5*1024*1024L, LONGLONG_MAX, 1024*1024L);
10841

irana's avatar
irana committed
10842 10843 10844 10845 10846
static MYSQL_SYSVAR_LONG(buffer_pool_instances, innobase_buffer_pool_instances,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Number of buffer pool instances, set to higher value on high-end machines to increase scalability",
  NULL, NULL, 1L, 1L, MAX_BUFFER_POOLS, 1L);

10847
static MYSQL_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
10848 10849
  PLUGIN_VAR_RQCMDARG,
  "Helps in performance tuning in heavily concurrent environments.",
10850
  innobase_commit_concurrency_validate, NULL, 0, 0, 1000, 0);
10851 10852 10853 10854 10855 10856 10857

static MYSQL_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
  PLUGIN_VAR_RQCMDARG,
  "Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
  NULL, NULL, 500L, 1L, ~0L, 0);

static MYSQL_SYSVAR_LONG(file_io_threads, innobase_file_io_threads,
10858
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY | PLUGIN_VAR_NOSYSVAR,
10859 10860 10861
  "Number of file I/O threads in InnoDB.",
  NULL, NULL, 4, 4, 64, 0);

10862 10863 10864 10865 10866 10867 10868 10869 10870 10871
static MYSQL_SYSVAR_ULONG(read_io_threads, innobase_read_io_threads,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Number of background read I/O threads in InnoDB.",
  NULL, NULL, 4, 1, 64, 0);

static MYSQL_SYSVAR_ULONG(write_io_threads, innobase_write_io_threads,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Number of background write I/O threads in InnoDB.",
  NULL, NULL, 4, 1, 64, 0);

10872 10873 10874 10875 10876 10877 10878 10879
static MYSQL_SYSVAR_LONG(force_recovery, innobase_force_recovery,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Helps to save your data in case the disk image of the database becomes corrupt.",
  NULL, NULL, 0, 0, 6, 0);

static MYSQL_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "The size of the buffer which InnoDB uses to write log to the log files on disk.",
10880
  NULL, NULL, 8*1024*1024L, 256*1024L, LONG_MAX, 1024);
10881 10882 10883 10884 10885 10886 10887 10888 10889 10890 10891 10892 10893 10894 10895 10896

static MYSQL_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Size of each log file in a log group.",
  NULL, NULL, 5*1024*1024L, 1*1024*1024L, LONGLONG_MAX, 1024*1024L);

static MYSQL_SYSVAR_LONG(log_files_in_group, innobase_log_files_in_group,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
  NULL, NULL, 2, 2, 100, 0);

static MYSQL_SYSVAR_LONG(mirrored_log_groups, innobase_mirrored_log_groups,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
  NULL, NULL, 1, 1, 10, 0);

10897 10898 10899 10900 10901 10902 10903 10904 10905 10906 10907 10908
static MYSQL_SYSVAR_UINT(old_blocks_pct, innobase_old_blocks_pct,
  PLUGIN_VAR_RQCMDARG,
  "Percentage of the buffer pool to reserve for 'old' blocks.",
  NULL, innodb_old_blocks_pct_update, 100 * 3 / 8, 5, 95, 0);

static MYSQL_SYSVAR_UINT(old_blocks_time, buf_LRU_old_threshold_ms,
  PLUGIN_VAR_RQCMDARG,
  "Move blocks to the 'new' end of the buffer pool if the first access"
  " was at least this many milliseconds ago."
  " The timeout is disabled if 0 (the default).",
  NULL, NULL, 0, 0, UINT_MAX32, 0);

10909 10910 10911
static MYSQL_SYSVAR_LONG(open_files, innobase_open_files,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "How many files at the maximum InnoDB keeps open at the same time.",
10912
  NULL, NULL, 300L, 10L, LONG_MAX, 0);
10913 10914 10915

static MYSQL_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
  PLUGIN_VAR_RQCMDARG,
10916 10917
  "Count of spin-loop rounds in InnoDB mutexes (30 by default)",
  NULL, NULL, 30L, 0L, ~0L, 0);
10918

10919 10920
static MYSQL_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
  PLUGIN_VAR_OPCMDARG,
10921 10922
  "Maximum delay between polling for a spin lock (6 by default)",
  NULL, NULL, 6L, 0L, ~0L, 0);
10923

10924 10925 10926
static MYSQL_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
  PLUGIN_VAR_RQCMDARG,
  "Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.",
10927
  NULL, NULL, 0, 0, 1000, 0);
10928 10929 10930 10931 10932 10933 10934 10935 10936 10937 10938

static MYSQL_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
  PLUGIN_VAR_RQCMDARG,
  "Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
  NULL, NULL, 10000L, 0L, ~0L, 0);

static MYSQL_SYSVAR_STR(data_file_path, innobase_data_file_path,
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
  "Path to individual files and their sizes.",
  NULL, NULL, NULL);

10939
static MYSQL_SYSVAR_LONG(autoinc_lock_mode, innobase_autoinc_lock_mode,
10940
  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
10941 10942 10943 10944 10945
  "The AUTOINC lock modes supported by InnoDB:               "
  "0 => Old style AUTOINC locking (for backward"
  " compatibility)                                           "
  "1 => New style AUTOINC locking                            "
  "2 => No AUTOINC locking (unsafe for SBR)",
10946 10947 10948 10949 10950
  NULL, NULL,
  AUTOINC_NEW_STYLE_LOCKING,	/* Default setting */
  AUTOINC_OLD_STYLE_LOCKING,	/* Minimum value */
  AUTOINC_NO_LOCKING, 0);	/* Maximum value */

10951 10952 10953 10954
static MYSQL_SYSVAR_STR(version, innodb_version_str,
  PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
  "InnoDB version", NULL, NULL, INNODB_VERSION_STR);

10955 10956 10957
static MYSQL_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
  "Use OS memory allocator instead of InnoDB's internal memory allocator",
10958
  NULL, NULL, TRUE);
10959

inaam's avatar
inaam committed
10960 10961 10962 10963 10964
static MYSQL_SYSVAR_BOOL(use_native_aio, srv_use_native_aio,
  PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
  "Use native AIO if supported on this platform.",
  NULL, NULL, TRUE);

10965 10966 10967 10968 10969 10970 10971
static MYSQL_SYSVAR_STR(change_buffering, innobase_change_buffering,
  PLUGIN_VAR_RQCMDARG,
  "Buffer changes to reduce random access: "
  "OFF, ON, inserting, deleting, changing, or purging.",
  innodb_change_buffering_validate,
  innodb_change_buffering_update, NULL);

10972 10973
static MYSQL_SYSVAR_ULONG(read_ahead_threshold, srv_read_ahead_threshold,
  PLUGIN_VAR_RQCMDARG,
10974
  "Number of pages that must be accessed sequentially for InnoDB to "
10975 10976 10977
  "trigger a readahead.",
  NULL, NULL, 56, 0, 64, 0);

10978 10979 10980 10981
static struct st_mysql_sys_var* innobase_system_variables[]= {
  MYSQL_SYSVAR(additional_mem_pool_size),
  MYSQL_SYSVAR(autoextend_increment),
  MYSQL_SYSVAR(buffer_pool_size),
irana's avatar
irana committed
10982
  MYSQL_SYSVAR(buffer_pool_instances),
10983 10984 10985 10986 10987 10988 10989 10990
  MYSQL_SYSVAR(checksums),
  MYSQL_SYSVAR(commit_concurrency),
  MYSQL_SYSVAR(concurrency_tickets),
  MYSQL_SYSVAR(data_file_path),
  MYSQL_SYSVAR(data_home_dir),
  MYSQL_SYSVAR(doublewrite),
  MYSQL_SYSVAR(fast_shutdown),
  MYSQL_SYSVAR(file_io_threads),
10991 10992
  MYSQL_SYSVAR(read_io_threads),
  MYSQL_SYSVAR(write_io_threads),
10993
  MYSQL_SYSVAR(file_per_table),
10994 10995
  MYSQL_SYSVAR(file_format),
  MYSQL_SYSVAR(file_format_check),
10996 10997 10998 10999 11000 11001 11002 11003 11004 11005 11006 11007 11008 11009
  MYSQL_SYSVAR(flush_log_at_trx_commit),
  MYSQL_SYSVAR(flush_method),
  MYSQL_SYSVAR(force_recovery),
  MYSQL_SYSVAR(locks_unsafe_for_binlog),
  MYSQL_SYSVAR(lock_wait_timeout),
#ifdef UNIV_LOG_ARCHIVE
  MYSQL_SYSVAR(log_arch_dir),
  MYSQL_SYSVAR(log_archive),
#endif /* UNIV_LOG_ARCHIVE */
  MYSQL_SYSVAR(log_buffer_size),
  MYSQL_SYSVAR(log_file_size),
  MYSQL_SYSVAR(log_files_in_group),
  MYSQL_SYSVAR(log_group_home_dir),
  MYSQL_SYSVAR(max_dirty_pages_pct),
11010
  MYSQL_SYSVAR(adaptive_flushing),
11011 11012
  MYSQL_SYSVAR(max_purge_lag),
  MYSQL_SYSVAR(mirrored_log_groups),
11013 11014
  MYSQL_SYSVAR(old_blocks_pct),
  MYSQL_SYSVAR(old_blocks_time),
11015 11016 11017
  MYSQL_SYSVAR(open_files),
  MYSQL_SYSVAR(rollback_on_timeout),
  MYSQL_SYSVAR(stats_on_metadata),
11018
  MYSQL_SYSVAR(stats_sample_pages),
11019
  MYSQL_SYSVAR(adaptive_hash_index),
11020
  MYSQL_SYSVAR(replication_delay),
11021
  MYSQL_SYSVAR(status_file),
11022
  MYSQL_SYSVAR(strict_mode),
11023 11024
  MYSQL_SYSVAR(support_xa),
  MYSQL_SYSVAR(sync_spin_loops),
11025
  MYSQL_SYSVAR(spin_wait_delay),
11026 11027 11028
  MYSQL_SYSVAR(table_locks),
  MYSQL_SYSVAR(thread_concurrency),
  MYSQL_SYSVAR(thread_sleep_delay),
11029
  MYSQL_SYSVAR(autoinc_lock_mode),
11030
  MYSQL_SYSVAR(version),
11031
  MYSQL_SYSVAR(use_sys_malloc),
inaam's avatar
inaam committed
11032
  MYSQL_SYSVAR(use_native_aio),
11033
  MYSQL_SYSVAR(change_buffering),
11034 11035
  MYSQL_SYSVAR(read_ahead_threshold),
  MYSQL_SYSVAR(io_capacity),
11036 11037
  MYSQL_SYSVAR(purge_threads),
  MYSQL_SYSVAR(purge_batch_size),
11038 11039 11040
  NULL
};

11041 11042 11043
mysql_declare_plugin(innobase)
{
  MYSQL_STORAGE_ENGINE_PLUGIN,
11044
  &innobase_storage_engine,
11045
  innobase_hton_name,
11046
  "Innobase Oy",
11047
  "Supports transactions, row-level locking, and foreign keys",
11048
  PLUGIN_LICENSE_GPL,
11049
  innobase_init, /* Plugin Init */
11050
  NULL, /* Plugin Deinit */
11051
  INNODB_VERSION_SHORT,
11052
  innodb_status_variables_export,/* status variables             */
11053 11054
  innobase_system_variables, /* system variables */
  NULL /* reserved */
11055
},
11056 11057
i_s_innodb_trx,
i_s_innodb_locks,
11058
i_s_innodb_lock_waits,
11059 11060 11061 11062
i_s_innodb_cmp,
i_s_innodb_cmp_reset,
i_s_innodb_cmpmem,
i_s_innodb_cmpmem_reset
11063
mysql_declare_plugin_end;
vasil's avatar
vasil committed
11064

11065 11066 11067 11068 11069 11070 11071 11072 11073 11074 11075 11076 11077 11078 11079 11080 11081 11082
/** @brief Initialize the default value of innodb_commit_concurrency.

Once InnoDB is running, the innodb_commit_concurrency must not change
from zero to nonzero. (Bug #42101)

The initial default value is 0, and without this extra initialization,
SET GLOBAL innodb_commit_concurrency=DEFAULT would set the parameter
to 0, even if it was initially set to nonzero at the command line
or configuration file. */
static
void
innobase_commit_concurrency_init_default(void)
/*==========================================*/
{
	MYSQL_SYSVAR_NAME(commit_concurrency).def_val
		= innobase_commit_concurrency;
}

vasil's avatar
vasil committed
11083 11084 11085 11086 11087 11088 11089 11090 11091 11092 11093 11094 11095 11096 11097 11098 11099 11100 11101 11102 11103 11104 11105 11106 11107 11108 11109 11110 11111 11112 11113 11114 11115 11116 11117 11118 11119 11120 11121 11122 11123 11124 11125 11126 11127 11128 11129 11130 11131 11132 11133 11134 11135 11136 11137 11138 11139 11140 11141 11142 11143 11144 11145 11146 11147 11148 11149 11150 11151 11152 11153 11154 11155 11156 11157 11158 11159 11160 11161 11162 11163 11164 11165 11166 11167 11168 11169 11170 11171 11172 11173 11174 11175 11176 11177 11178 11179 11180 11181 11182 11183 11184 11185 11186 11187 11188 11189 11190 11191 11192 11193 11194 11195 11196 11197 11198 11199 11200 11201 11202 11203
#ifdef UNIV_COMPILE_TEST_FUNCS

typedef struct innobase_convert_name_test_struct {
	char*		buf;
	ulint		buflen;
	const char*	id;
	ulint		idlen;
	void*		thd;
	ibool		file_id;

	const char*	expected;
} innobase_convert_name_test_t;

void
test_innobase_convert_name()
{
	char	buf[1024];
	ulint	i;

	innobase_convert_name_test_t test_input[] = {
		{buf, sizeof(buf), "abcd", 4, NULL, TRUE, "\"abcd\""},
		{buf, 7, "abcd", 4, NULL, TRUE, "\"abcd\""},
		{buf, 6, "abcd", 4, NULL, TRUE, "\"abcd\""},
		{buf, 5, "abcd", 4, NULL, TRUE, "\"abc\""},
		{buf, 4, "abcd", 4, NULL, TRUE, "\"ab\""},

		{buf, sizeof(buf), "ab@0060cd", 9, NULL, TRUE, "\"ab`cd\""},
		{buf, 9, "ab@0060cd", 9, NULL, TRUE, "\"ab`cd\""},
		{buf, 8, "ab@0060cd", 9, NULL, TRUE, "\"ab`cd\""},
		{buf, 7, "ab@0060cd", 9, NULL, TRUE, "\"ab`cd\""},
		{buf, 6, "ab@0060cd", 9, NULL, TRUE, "\"ab`c\""},
		{buf, 5, "ab@0060cd", 9, NULL, TRUE, "\"ab`\""},
		{buf, 4, "ab@0060cd", 9, NULL, TRUE, "\"ab\""},

		{buf, sizeof(buf), "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#ab\"\"cd\""},
		{buf, 17, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#ab\"\"cd\""},
		{buf, 16, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#ab\"\"c\""},
		{buf, 15, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#ab\"\"\""},
		{buf, 14, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#ab\""},
		{buf, 13, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#ab\""},
		{buf, 12, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#a\""},
		{buf, 11, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50#\""},
		{buf, 10, "ab\"cd", 5, NULL, TRUE,
			"\"#mysql50\""},

		{buf, sizeof(buf), "ab/cd", 5, NULL, TRUE, "\"ab\".\"cd\""},
		{buf, 9, "ab/cd", 5, NULL, TRUE, "\"ab\".\"cd\""},
		{buf, 8, "ab/cd", 5, NULL, TRUE, "\"ab\".\"c\""},
		{buf, 7, "ab/cd", 5, NULL, TRUE, "\"ab\".\"\""},
		{buf, 6, "ab/cd", 5, NULL, TRUE, "\"ab\"."},
		{buf, 5, "ab/cd", 5, NULL, TRUE, "\"ab\"."},
		{buf, 4, "ab/cd", 5, NULL, TRUE, "\"ab\""},
		{buf, 3, "ab/cd", 5, NULL, TRUE, "\"a\""},
		{buf, 2, "ab/cd", 5, NULL, TRUE, "\"\""},
		/* XXX probably "" is a better result in this case
		{buf, 1, "ab/cd", 5, NULL, TRUE, "."},
		*/
		{buf, 0, "ab/cd", 5, NULL, TRUE, ""},
	};

	for (i = 0; i < sizeof(test_input) / sizeof(test_input[0]); i++) {

		char*	end;
		ibool	ok = TRUE;
		size_t	res_len;

		fprintf(stderr, "TESTING %lu, %s, %lu, %s\n",
			test_input[i].buflen,
			test_input[i].id,
			test_input[i].idlen,
			test_input[i].expected);

		end = innobase_convert_name(
			test_input[i].buf,
			test_input[i].buflen,
			test_input[i].id,
			test_input[i].idlen,
			test_input[i].thd,
			test_input[i].file_id);

		res_len = (size_t) (end - test_input[i].buf);

		if (res_len != strlen(test_input[i].expected)) {

			fprintf(stderr, "unexpected len of the result: %u, "
				"expected: %u\n", (unsigned) res_len,
				(unsigned) strlen(test_input[i].expected));
			ok = FALSE;
		}

		if (memcmp(test_input[i].buf,
			   test_input[i].expected,
			   strlen(test_input[i].expected)) != 0
		    || !ok) {

			fprintf(stderr, "unexpected result: %.*s, "
				"expected: %s\n", (int) res_len,
				test_input[i].buf,
				test_input[i].expected);
			ok = FALSE;
		}

		if (ok) {
			fprintf(stderr, "OK: res: %.*s\n\n", (int) res_len,
				buf);
		} else {
			fprintf(stderr, "FAILED\n\n");
			return;
		}
	}
}

#endif /* UNIV_COMPILE_TEST_FUNCS */