/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.

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 */

/** @file handler.cc

@brief

Handler-calling-functions

*/

#ifdef USE_PRAGMA_IMPLEMENTATION

#pragma implementation // gcc: Class implementation

#endif

#include "sql_priv.h"

#include "unireg.h"

#include "rpl_handler.h"

#include "sql_cache.h" // query_cache, query_cache_*

#include "key.h" // key_copy, key_unpack, key_cmp_if_same, key_cmp

#include "sql_table.h" // build_table_filename

#include "sql_parse.h" // check_stack_overrun

#include "sql_acl.h" // SUPER_ACL

#include "sql_base.h" // free_io_cache

#include "discover.h" // writefrm

#include "log_event.h" // *_rows_log_event

#include "rpl_filter.h"

#include <myisampack.h>

#include "transaction.h"

#include <errno.h>

#include "probes_mysql.h"

#include "debug_sync.h" // DEBUG_SYNC

#ifdef WITH_PARTITION_STORAGE_ENGINE

#include "ha_partition.h"

#endif

/*

While we have legacy_db_type, we have this array to

check for dups and to find handlerton from legacy_db_type.

Remove when legacy_db_type is finally gone

*/

st_plugin_int *hton2plugin[MAX_HA];

static handlerton *installed_htons[128];

#define BITMAP_STACKBUF_SIZE (128/8)

KEY_CREATE_INFO default_key_create_info=

{ HA_KEY_ALG_UNDEF, 0, {NullS, 0}, {NullS, 0} };

/* number of entries in handlertons[] */

ulong total_ha= 0;

/* number of storage engines (from handlertons[]) that support 2pc */

ulong total_ha_2pc= 0;

/* size of savepoint storage area (see ha_init) */

ulong savepoint_alloc_size= 0;

static const LEX_STRING sys_table_aliases[]=

{

{ C_STRING_WITH_LEN("INNOBASE") }, { C_STRING_WITH_LEN("INNODB") },

{ C_STRING_WITH_LEN("NDB") }, { C_STRING_WITH_LEN("NDBCLUSTER") },

{ C_STRING_WITH_LEN("HEAP") }, { C_STRING_WITH_LEN("MEMORY") },

{ C_STRING_WITH_LEN("MERGE") }, { C_STRING_WITH_LEN("MRG_MYISAM") },

{NullS, 0}

};

const char *ha_row_type[] = {

"", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT",

/* Reserved to be "PAGE" in future versions */ "?",

"?","?","?"

};

const char *tx_isolation_names[] =

{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",

NullS};

TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",

tx_isolation_names, NULL};

static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};

uint known_extensions_id= 0;

static plugin_ref ha_default_plugin(THD *thd)

{

if (thd->variables.table_plugin)

return thd->variables.table_plugin;

return my_plugin_lock(thd, &global_system_variables.table_plugin);

}

/** @brief

Return the default storage engine handlerton for thread

SYNOPSIS

ha_default_handlerton(thd)

thd current thread

RETURN

pointer to handlerton

*/

handlerton *ha_default_handlerton(THD *thd)

{

plugin_ref plugin= ha_default_plugin(thd);

DBUG_ASSERT(plugin);

handlerton *hton= plugin_data(plugin, handlerton*);

DBUG_ASSERT(hton);

return hton;

}

/** @brief

Return the storage engine handlerton for the supplied name

SYNOPSIS

ha_resolve_by_name(thd, name)

thd current thread

name name of storage engine

RETURN

pointer to storage engine plugin handle

*/

plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name)

{

const LEX_STRING *table_alias;

plugin_ref plugin;

redo:

/* my_strnncoll is a macro and gcc doesn't do early expansion of macro */

if (thd && !my_charset_latin1.coll->strnncoll(&my_charset_latin1,

(const uchar *)name->str, name->length,

(const uchar *)STRING_WITH_LEN("DEFAULT"), 0))

return ha_default_plugin(thd);

if ((plugin= my_plugin_lock_by_name(thd, name, MYSQL_STORAGE_ENGINE_PLUGIN)))

{

handlerton *hton= plugin_data(plugin, handlerton *);

if (!(hton->flags & HTON_NOT_USER_SELECTABLE))

return plugin;

/*

unlocking plugin immediately after locking is relatively low cost.

*/

plugin_unlock(thd, plugin);

}

/*

We check for the historical aliases.

*/

for (table_alias= sys_table_aliases; table_alias->str; table_alias+= 2)

{

if (!my_strnncoll(&my_charset_latin1,

(const uchar *)name->str, name->length,

(const uchar *)table_alias->str, table_alias->length))

{

name= table_alias + 1;

goto redo;

}

}

return NULL;

}

plugin_ref ha_lock_engine(THD *thd, const handlerton *hton)

{

if (hton)

{

st_plugin_int **plugin= hton2plugin + hton->slot;

#ifdef DBUG_OFF

return my_plugin_lock(thd, plugin);

#else

return my_plugin_lock(thd, &plugin);

#endif

}

return NULL;

}

handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type)

{

plugin_ref plugin;

switch (db_type) {

case DB_TYPE_DEFAULT:

return ha_default_handlerton(thd);

default:

if (db_type > DB_TYPE_UNKNOWN && db_type < DB_TYPE_DEFAULT &&

(plugin= ha_lock_engine(thd, installed_htons[db_type])))

return plugin_data(plugin, handlerton*);

/* fall through */

case DB_TYPE_UNKNOWN:

return NULL;

}

}

/**

Use other database handler if databasehandler is not compiled in.

*/

handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,

bool no_substitute, bool report_error)

{

handlerton *hton= ha_resolve_by_legacy_type(thd, database_type);

if (ha_storage_engine_is_enabled(hton))

return hton;

if (no_substitute)

{

if (report_error)

{

const char *engine_name= ha_resolve_storage_engine_name(hton);

my_error(ER_FEATURE_DISABLED,MYF(0),engine_name,engine_name);

}

return NULL;

}

RUN_HOOK(transaction, after_rollback, (thd, FALSE));

switch (database_type) {

case DB_TYPE_MRG_ISAM:

return ha_resolve_by_legacy_type(thd, DB_TYPE_MRG_MYISAM);

default:

break;

}

return ha_default_handlerton(thd);

} /* ha_checktype */

handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,

handlerton *db_type)

{

handler *file;

DBUG_ENTER("get_new_handler");

DBUG_PRINT("enter", ("alloc: 0x%lx", (long) alloc));

if (db_type && db_type->state == SHOW_OPTION_YES && db_type->create)

{

if ((file= db_type->create(db_type, share, alloc)))

file->init();

DBUG_RETURN(file);

}

/*

Try the default table type

Here the call to current_thd() is ok as we call this function a lot of

times but we enter this branch very seldom.

*/

DBUG_RETURN(get_new_handler(share, alloc, ha_default_handlerton(current_thd)));

}

#ifdef WITH_PARTITION_STORAGE_ENGINE

handler *get_ha_partition(partition_info *part_info)

{

ha_partition *partition;

DBUG_ENTER("get_ha_partition");

if ((partition= new ha_partition(partition_hton, part_info)))

{

if (partition->initialize_partition(current_thd->mem_root))

{

delete partition;

partition= 0;

}

else

partition->init();

}

else

{

my_error(ER_OUTOFMEMORY, MYF(0), static_cast<int>(sizeof(ha_partition)));

}

DBUG_RETURN(((handler*) partition));

}

#endif

static const char **handler_errmsgs;

C_MODE_START

static const char **get_handler_errmsgs()

{

return handler_errmsgs;

}

C_MODE_END

/**

Register handler error messages for use with my_error().

@retval

0 OK

@retval

!=0 Error

*/

int ha_init_errors(void)

{

#define SETMSG(nr, msg) handler_errmsgs[(nr) - HA_ERR_FIRST]= (msg)

/* Allocate a pointer array for the error message strings. */

/* Zerofill it to avoid uninitialized gaps. */

if (! (handler_errmsgs= (const char**) my_malloc(HA_ERR_ERRORS * sizeof(char*),

MYF(MY_WME | MY_ZEROFILL))))

return 1;

/* Set the dedicated error messages. */

SETMSG(HA_ERR_KEY_NOT_FOUND, ER_DEFAULT(ER_KEY_NOT_FOUND));

SETMSG(HA_ERR_FOUND_DUPP_KEY, ER_DEFAULT(ER_DUP_KEY));

SETMSG(HA_ERR_RECORD_CHANGED, "Update wich is recoverable");

SETMSG(HA_ERR_WRONG_INDEX, "Wrong index given to function");

SETMSG(HA_ERR_CRASHED, ER_DEFAULT(ER_NOT_KEYFILE));

SETMSG(HA_ERR_WRONG_IN_RECORD, ER_DEFAULT(ER_CRASHED_ON_USAGE));

SETMSG(HA_ERR_OUT_OF_MEM, "Table handler out of memory");

SETMSG(HA_ERR_NOT_A_TABLE, "Incorrect file format '%.64s'");

SETMSG(HA_ERR_WRONG_COMMAND, "Command not supported");

SETMSG(HA_ERR_OLD_FILE, ER_DEFAULT(ER_OLD_KEYFILE));

SETMSG(HA_ERR_NO_ACTIVE_RECORD, "No record read in update");

SETMSG(HA_ERR_RECORD_DELETED, "Intern record deleted");

SETMSG(HA_ERR_RECORD_FILE_FULL, ER_DEFAULT(ER_RECORD_FILE_FULL));

SETMSG(HA_ERR_INDEX_FILE_FULL, "No more room in index file '%.64s'");

SETMSG(HA_ERR_END_OF_FILE, "End in next/prev/first/last");

SETMSG(HA_ERR_UNSUPPORTED, ER_DEFAULT(ER_ILLEGAL_HA));

SETMSG(HA_ERR_TO_BIG_ROW, "Too big row");

SETMSG(HA_WRONG_CREATE_OPTION, "Wrong create option");

SETMSG(HA_ERR_FOUND_DUPP_UNIQUE, ER_DEFAULT(ER_DUP_UNIQUE));

SETMSG(HA_ERR_UNKNOWN_CHARSET, "Can't open charset");

SETMSG(HA_ERR_WRONG_MRG_TABLE_DEF, ER_DEFAULT(ER_WRONG_MRG_TABLE));

SETMSG(HA_ERR_CRASHED_ON_REPAIR, ER_DEFAULT(ER_CRASHED_ON_REPAIR));

SETMSG(HA_ERR_CRASHED_ON_USAGE, ER_DEFAULT(ER_CRASHED_ON_USAGE));

SETMSG(HA_ERR_LOCK_WAIT_TIMEOUT, ER_DEFAULT(ER_LOCK_WAIT_TIMEOUT));

SETMSG(HA_ERR_LOCK_TABLE_FULL, ER_DEFAULT(ER_LOCK_TABLE_FULL));

SETMSG(HA_ERR_READ_ONLY_TRANSACTION, ER_DEFAULT(ER_READ_ONLY_TRANSACTION));

SETMSG(HA_ERR_LOCK_DEADLOCK, ER_DEFAULT(ER_LOCK_DEADLOCK));

SETMSG(HA_ERR_CANNOT_ADD_FOREIGN, ER_DEFAULT(ER_CANNOT_ADD_FOREIGN));

SETMSG(HA_ERR_NO_REFERENCED_ROW, ER_DEFAULT(ER_NO_REFERENCED_ROW_2));

SETMSG(HA_ERR_ROW_IS_REFERENCED, ER_DEFAULT(ER_ROW_IS_REFERENCED_2));

SETMSG(HA_ERR_NO_SAVEPOINT, "No savepoint with that name");

SETMSG(HA_ERR_NON_UNIQUE_BLOCK_SIZE, "Non unique key block size");

SETMSG(HA_ERR_NO_SUCH_TABLE, "No such table: '%.64s'");

SETMSG(HA_ERR_TABLE_EXIST, ER_DEFAULT(ER_TABLE_EXISTS_ERROR));

SETMSG(HA_ERR_NO_CONNECTION, "Could not connect to storage engine");

SETMSG(HA_ERR_TABLE_DEF_CHANGED, ER_DEFAULT(ER_TABLE_DEF_CHANGED));

SETMSG(HA_ERR_FOREIGN_DUPLICATE_KEY, "FK constraint would lead to duplicate key");

SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE, ER_DEFAULT(ER_TABLE_NEEDS_UPGRADE));

SETMSG(HA_ERR_TABLE_READONLY, ER_DEFAULT(ER_OPEN_AS_READONLY));

SETMSG(HA_ERR_AUTOINC_READ_FAILED, ER_DEFAULT(ER_AUTOINC_READ_FAILED));

SETMSG(HA_ERR_AUTOINC_ERANGE, ER_DEFAULT(ER_WARN_DATA_OUT_OF_RANGE));

SETMSG(HA_ERR_TOO_MANY_CONCURRENT_TRXS, ER_DEFAULT(ER_TOO_MANY_CONCURRENT_TRXS));

SETMSG(HA_ERR_INDEX_COL_TOO_LONG, ER_DEFAULT(ER_INDEX_COLUMN_TOO_LONG));

SETMSG(HA_ERR_INDEX_CORRUPT, ER_DEFAULT(ER_INDEX_CORRUPT));

/* Register the error messages for use with my_error(). */

return my_error_register(get_handler_errmsgs, HA_ERR_FIRST, HA_ERR_LAST);

}

/**

Unregister handler error messages.

@retval

0 OK

@retval

!=0 Error

*/

static int ha_finish_errors(void)

{

const char **errmsgs;

/* Allocate a pointer array for the error message strings. */

if (! (errmsgs= my_error_unregister(HA_ERR_FIRST, HA_ERR_LAST)))

return 1;

my_free(errmsgs);

return 0;

}

int ha_finalize_handlerton(st_plugin_int *plugin)

{

handlerton *hton= (handlerton *)plugin->data;

DBUG_ENTER("ha_finalize_handlerton");

/* hton can be NULL here, if ha_initialize_handlerton() failed. */

if (!hton)

goto end;

switch (hton->state)

{

case SHOW_OPTION_NO:

case SHOW_OPTION_DISABLED:

break;

case SHOW_OPTION_YES:

if (installed_htons[hton->db_type] == hton)

installed_htons[hton->db_type]= NULL;

break;

};

if (hton->panic)

hton->panic(hton, HA_PANIC_CLOSE);

if (plugin->plugin->deinit)

{

/*

Today we have no defined/special behavior for uninstalling

engine plugins.

*/

DBUG_PRINT("info", ("Deinitializing plugin: '%s'", plugin->name.str));

if (plugin->plugin->deinit(NULL))

{

DBUG_PRINT("warning", ("Plugin '%s' deinit function returned error.",

plugin->name.str));

}

}

/*

In case a plugin is uninstalled and re-installed later, it should

reuse an array slot. Otherwise the number of uninstall/install

cycles would be limited.

*/

if (hton->slot != HA_SLOT_UNDEF)

{

/* Make sure we are not unpluging another plugin */

DBUG_ASSERT(hton2plugin[hton->slot] == plugin);

DBUG_ASSERT(hton->slot < MAX_HA);

hton2plugin[hton->slot]= NULL;

}

my_free(hton);

end:

DBUG_RETURN(0);

}

int ha_initialize_handlerton(st_plugin_int *plugin)

{

handlerton *hton;

DBUG_ENTER("ha_initialize_handlerton");

DBUG_PRINT("plugin", ("initialize plugin: '%s'", plugin->name.str));

hton= (handlerton *)my_malloc(sizeof(handlerton),

MYF(MY_WME | MY_ZEROFILL));

if (hton == NULL)

{

sql_print_error("Unable to allocate memory for plugin '%s' handlerton.",

plugin->name.str);

goto err_no_hton_memory;

}

hton->slot= HA_SLOT_UNDEF;

/* Historical Requirement */

plugin->data= hton; // shortcut for the future

if (plugin->plugin->init && plugin->plugin->init(hton))

{

sql_print_error("Plugin '%s' init function returned error.",

plugin->name.str);

goto err;

}

/*

the switch below and hton->state should be removed when

command-line options for plugins will be implemented

*/

switch (hton->state) {

case SHOW_OPTION_NO:

break;

case SHOW_OPTION_YES:

{

uint tmp;

ulong fslot;

/* now check the db_type for conflict */

if (hton->db_type <= DB_TYPE_UNKNOWN ||

hton->db_type >= DB_TYPE_DEFAULT ||

installed_htons[hton->db_type])

{

int idx= (int) DB_TYPE_FIRST_DYNAMIC;

while (idx < (int) DB_TYPE_DEFAULT && installed_htons[idx])

idx++;

if (idx == (int) DB_TYPE_DEFAULT)

{

sql_print_warning("Too many storage engines!");

goto err_deinit;

}

if (hton->db_type != DB_TYPE_UNKNOWN)

sql_print_warning("Storage engine '%s' has conflicting typecode. "

"Assigning value %d.", plugin->plugin->name, idx);

hton->db_type= (enum legacy_db_type) idx;

}

/*

In case a plugin is uninstalled and re-installed later, it should

reuse an array slot. Otherwise the number of uninstall/install

cycles would be limited. So look for a free slot.

*/

DBUG_PRINT("plugin", ("total_ha: %lu", total_ha));

for (fslot= 0; fslot < total_ha; fslot++)

{

if (!hton2plugin[fslot])

break;

}

if (fslot < total_ha)

hton->slot= fslot;

else

{

if (total_ha >= MAX_HA)

{

sql_print_error("Too many plugins loaded. Limit is %lu. "

"Failed on '%s'", (ulong) MAX_HA, plugin->name.str);

goto err_deinit;

}

hton->slot= total_ha++;

}

installed_htons[hton->db_type]= hton;

tmp= hton->savepoint_offset;

hton->savepoint_offset= savepoint_alloc_size;

savepoint_alloc_size+= tmp;

hton2plugin[hton->slot]=plugin;

if (hton->prepare)

total_ha_2pc++;

break;

}

/* fall through */

default:

hton->state= SHOW_OPTION_DISABLED;

break;

}

/*

This is entirely for legacy. We will create a new "disk based" hton and a

"memory" hton which will be configurable longterm. We should be able to

remove partition and myisammrg.

*/

switch (hton->db_type) {

case DB_TYPE_HEAP:

heap_hton= hton;

break;

case DB_TYPE_MYISAM:

myisam_hton= hton;

break;

case DB_TYPE_PARTITION_DB:

partition_hton= hton;

break;

default:

break;

};

DBUG_RETURN(0);

err_deinit:

/*

Let plugin do its inner deinitialization as plugin->init()

was successfully called before.

*/

if (plugin->plugin->deinit)

(void) plugin->plugin->deinit(NULL);

err:

my_free(hton);

err_no_hton_memory:

plugin->data= NULL;

DBUG_RETURN(1);

}

int ha_init()

{

int error= 0;

DBUG_ENTER("ha_init");

DBUG_ASSERT(total_ha < MAX_HA);

/*

Check if there is a transaction-capable storage engine besides the

binary log (which is considered a transaction-capable storage engine in

counting total_ha)

*/

opt_using_transactions= total_ha>(ulong)opt_bin_log;

savepoint_alloc_size+= sizeof(SAVEPOINT);

DBUG_RETURN(error);

}

int ha_end()

{

int error= 0;

DBUG_ENTER("ha_end");

/*

This should be eventualy based on the graceful shutdown flag.

So if flag is equal to HA_PANIC_CLOSE, the deallocate

the errors.

*/

if (ha_finish_errors())

error= 1;

DBUG_RETURN(error);

}

static my_bool dropdb_handlerton(THD *unused1, plugin_ref plugin,

void *path)

{

handlerton *hton= plugin_data(plugin, handlerton *);

if (hton->state == SHOW_OPTION_YES && hton->drop_database)

hton->drop_database(hton, (char *)path);

return FALSE;

}

void ha_drop_database(char* path)

{

plugin_foreach(NULL, dropdb_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, path);

}

static my_bool closecon_handlerton(THD *thd, plugin_ref plugin,

void *unused)

{

handlerton *hton= plugin_data(plugin, handlerton *);

/*

there's no need to rollback here as all transactions must

be rolled back already

*/

if (hton->state == SHOW_OPTION_YES && thd_get_ha_data(thd, hton))

{

if (hton->close_connection)

hton->close_connection(hton, thd);

/* make sure ha_data is reset and ha_data_lock is released */

thd_set_ha_data(thd, hton, NULL);

}

return FALSE;

}

/**

@note

don't bother to rollback here, it's done already

*/

void ha_close_connection(THD* thd)

{

plugin_foreach(thd, closecon_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, 0);

}

static my_bool kill_handlerton(THD *thd, plugin_ref plugin, void *)

{

handlerton *hton= plugin_data(plugin, handlerton *);

if (hton->state == SHOW_OPTION_YES && hton->kill_connection)

{

if (thd_get_ha_data(thd, hton))

hton->kill_connection(hton, thd);

}

return FALSE;

}

void ha_kill_connection(THD *thd)

{

plugin_foreach(thd, kill_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, 0);

}

/* ========================================================================

======================= TRANSACTIONS ===================================*/

/**

Transaction handling in the server

==================================

In each client connection, MySQL maintains two transactional

states:

- a statement transaction,

- a standard, also called normal transaction.

Historical note

---------------

"Statement transaction" is a non-standard term that comes

from the times when MySQL supported BerkeleyDB storage engine.

First of all, it should be said that in BerkeleyDB auto-commit

mode auto-commits operations that are atomic to the storage

engine itself, such as a write of a record, and are too

high-granular to be atomic from the application perspective

(MySQL). One SQL statement could involve many BerkeleyDB

auto-committed operations and thus BerkeleyDB auto-commit was of

little use to MySQL.

Secondly, instead of SQL standard savepoints, BerkeleyDB

provided the concept of "nested transactions". In a nutshell,

transactions could be arbitrarily nested, but when the parent

transaction was committed or aborted, all its child (nested)

transactions were handled committed or aborted as well.

Commit of a nested transaction, in turn, made its changes

visible, but not durable: it destroyed the nested transaction,

all its changes would become available to the parent and

currently active nested transactions of this parent.

So the mechanism of nested transactions was employed to

provide "all or nothing" guarantee of SQL statements

required by the standard.

A nested transaction would be created at start of each SQL

statement, and destroyed (committed or aborted) at statement

end. Such nested transaction was internally referred to as

a "statement transaction" and gave birth to the term.

<Historical note ends>

Since then a statement transaction is started for each statement

that accesses transactional tables or uses the binary log. If

the statement succeeds, the statement transaction is committed.

If the statement fails, the transaction is rolled back. Commits

of statement transactions are not durable -- each such

transaction is nested in the normal transaction, and if the

normal transaction is rolled back, the effects of all enclosed

statement transactions are undone as well. Technically,

a statement transaction can be viewed as a savepoint which is

maintained automatically in order to make effects of one

statement atomic.

The normal transaction is started by the user and is ended

usually upon a user request as well. The normal transaction

encloses transactions of all statements issued between

its beginning and its end.

In autocommit mode, the normal transaction is equivalent

to the statement transaction.

Since MySQL supports PSEA (pluggable storage engine

architecture), more than one transactional engine can be

active at a time. Hence transactions, from the server

point of view, are always distributed. In particular,

transactional state is maintained independently for each

engine. In order to commit a transaction the two phase

commit protocol is employed.

Not all statements are executed in context of a transaction.

Administrative and status information statements do not modify

engine data, and thus do not start a statement transaction and

also have no effect on the normal transaction. Examples of such

statements are SHOW STATUS and RESET SLAVE.

Similarly DDL statements are not transactional,

and therefore a transaction is [almost] never started for a DDL

statement. The difference between a DDL statement and a purely

administrative statement though is that a DDL statement always

commits the current transaction before proceeding, if there is

any.

At last, SQL statements that work with non-transactional

engines also have no effect on the transaction state of the

connection. Even though they are written to the binary log,

and the binary log is, overall, transactional, the writes

are done in "write-through" mode, directly to the binlog

file, followed with a OS cache sync, in other words,

bypassing the binlog undo log (translog).

They do not commit the current normal transaction.

A failure of a statement that uses non-transactional tables

would cause a rollback of the statement transaction, but

in case there no non-transactional tables are used,

no statement transaction is started.

Data layout

-----------

The server stores its transaction-related data in

thd->transaction. This structure has two members of type

THD_TRANS. These members correspond to the statement and

normal transactions respectively:

- thd->transaction.stmt contains a list of engines

that are participating in the given statement

- thd->transaction.all contains a list of engines that

have participated in any of the statement transactions started

within the context of the normal transaction.

Each element of the list contains a pointer to the storage

engine, engine-specific transactional data, and engine-specific

transaction flags.

In autocommit mode thd->transaction.all is empty.

Instead, data of thd->transaction.stmt is

used to commit/rollback the normal transaction.

The list of registered engines has a few important properties:

- no engine is registered in the list twice

- engines are present in the list a reverse temporal order --

new participants are always added to the beginning of the list.

Transaction life cycle

----------------------

When a new connection is established, thd->transaction

members are initialized to an empty state.

If a statement uses any tables, all affected engines

are registered in the statement engine list. In

non-autocommit mode, the same engines are registered in

the normal transaction list.

At the end of the statement, the server issues a commit

or a roll back for all engines in the statement list.

At this point transaction flags of an engine, if any, are

propagated from the statement list to the list of the normal

transaction.

When commit/rollback is finished, the statement list is

cleared. It will be filled in again by the next statement,

and emptied again at the next statement's end.

The normal transaction is committed in a similar way

(by going over all engines in thd->transaction.all list)

but at different times:

- upon COMMIT SQL statement is issued by the user

- implicitly, by the server, at the beginning of a DDL statement

or SET AUTOCOMMIT={0|1} statement.

The normal transaction can be rolled back as well:

- if the user has requested so, by issuing ROLLBACK SQL

statement

- if one of the storage engines requested a rollback

by setting thd->transaction_rollback_request. This may

happen in case, e.g., when the transaction in the engine was

chosen a victim of the internal deadlock resolution algorithm

and rolled back internally. When such a situation happens, there

is little the server can do and the only option is to rollback

transactions in all other participating engines. In this case

the rollback is accompanied by an error sent to the user.

As follows from the use cases above, the normal transaction

is never committed when there is an outstanding statement

transaction. In most cases there is no conflict, since

commits of the normal transaction are issued by a stand-alone

administrative or DDL statement, thus no outstanding statement

transaction of the previous statement exists. Besides,

all statements that manipulate with the normal transaction

are prohibited in stored functions and triggers, therefore

no conflicting situation can occur in a sub-statement either.

The remaining rare cases when the server explicitly has

to commit the statement transaction prior to committing the normal

one cover error-handling scenarios (see for example

SQLCOM_LOCK_TABLES).

When committing a statement or a normal transaction, the server

either uses the two-phase commit protocol, or issues a commit

in each engine independently. The two-phase commit protocol

is used only if:

- all participating engines support two-phase commit (provide

handlerton::prepare PSEA API call) and

- transactions in at least two engines modify data (i.e. are

not read-only).

Note that the two phase commit is used for

statement transactions, even though they are not durable anyway.

This is done to ensure logical consistency of data in a multiple-

engine transaction.

For example, imagine that some day MySQL supports unique

constraint checks deferred till the end of statement. In such

case a commit in one of the engines may yield ER_DUP_KEY,

and MySQL should be able to gracefully abort statement

transactions of other participants.

After the normal transaction has been committed,

thd->transaction.all list is cleared.

When a connection is closed, the current normal transaction, if

any, is rolled back.

Roles and responsibilities

--------------------------

The server has no way to know that an engine participates in

the statement and a transaction has been started

in it unless the engine says so. Thus, in order to be

a part of a transaction, the engine must "register" itself.

This is done by invoking trans_register_ha() server call.

Normally the engine registers itself whenever handler::external_lock()

is called. trans_register_ha() can be invoked many times: if

an engine is already registered, the call does nothing.

In case autocommit is not set, the engine must register itself

twice -- both in the statement list and in the normal transaction

list.

In which list to register is a parameter of trans_register_ha().

Note, that although the registration interface in itself is

fairly clear, the current usage practice often leads to undesired

effects. E.g. since a call to trans_register_ha() in most engines

is embedded into implementation of handler::external_lock(), some

DDL statements start a transaction (at least from the server

point of view) even though they are not expected to. E.g.

CREATE TABLE does not start a transaction, since

handler::external_lock() is never called during CREATE TABLE. But

CREATE TABLE ... SELECT does, since handler::external_lock() is

called for the table that is being selected from. This has no

practical effects currently, but must be kept in mind

nevertheless.

Once an engine is registered, the server will do the rest

of the work.

During statement execution, whenever any of data-modifying

PSEA API methods is used, e.g. handler::write_row() or

handler::update_row(), the read-write flag is raised in the

statement transaction for the involved engine.

Currently All PSEA calls are "traced", and the data can not be

changed in a way other than issuing a PSEA call. Important:

unless this invariant is preserved the server will not know that

a transaction in a given engine is read-write and will not

involve the two-phase commit protocol!

At the end of a statement, server call trans_commit_stmt is

invoked. This call in turn invokes handlerton::prepare()

for every involved engine. Prepare is followed by a call

to handlerton::commit_one_phase() If a one-phase commit

will suffice, handlerton::prepare() is not invoked and

the server only calls handlerton::commit_one_phase().

At statement commit, the statement-related read-write

engine flag is propagated to the corresponding flag in the

normal transaction. When the commit is complete, the list

of registered engines is cleared.

Rollback is handled in a similar fashion.

Additional notes on DDL and the normal transaction.

---------------------------------------------------

DDLs and operations with non-transactional engines

do not "register" in thd->transaction lists, and thus do not

modify the transaction state. Besides, each DDL in

MySQL is prefixed with an implicit normal transaction commit

(a call to trans_commit_implicit()), and thus leaves nothing

to modify.

However, as it has been pointed out with CREATE TABLE .. SELECT,

some DDL statements can start a *new* transaction.

Behaviour of the server in this case is currently badly

defined.

DDL statements use a form of "semantic" logging

to maintain atomicity: if CREATE TABLE .. SELECT failed,

the newly created table is deleted.

In addition, some DDL statements issue interim transaction

commits: e.g. ALTER TABLE issues a commit after data is copied

from the original table to the internal temporary table. Other

statements, e.g. CREATE TABLE ... SELECT do not always commit

after itself.

And finally there is a group of DDL statements such as

RENAME/DROP TABLE that doesn't start a new transaction

and doesn't commit.

This diversity makes it hard to say what will happen if

by chance a stored function is invoked during a DDL --

whether any modifications it makes will be committed or not

is not clear. Fortunately, SQL grammar of few DDLs allows

invocation of a stored function.

A consistent behaviour is perhaps to always commit the normal

transaction after all DDLs, just like the statement transaction

is always committed at the end of all statements.

*/

/**

Register a storage engine for a transaction.

Every storage engine MUST call this function when it starts

a transaction or a statement (that is it must be called both for the

"beginning of transaction" and "beginning of statement").

Only storage engines registered for the transaction/statement

will know when to commit/rollback it.

@note

trans_register_ha is idempotent - storage engine may register many

times per transaction.

*/

void trans_register_ha(THD *thd, bool all, handlerton *ht_arg)

{

THD_TRANS *trans;

Ha_trx_info *ha_info;

DBUG_ENTER("trans_register_ha");

DBUG_PRINT("enter",("%s", all ? "all" : "stmt"));

if (all)

{

trans= &thd->transaction.all;

thd->server_status|= SERVER_STATUS_IN_TRANS;

}

else

trans= &thd->transaction.stmt;

ha_info= thd->ha_data[ht_arg->slot].ha_info + static_cast<unsigned>(all);

if (ha_info->is_started())

DBUG_VOID_RETURN; /* already registered, return */

ha_info->register_ha(trans, ht_arg);

trans->no_2pc|=(ht_arg->prepare==0);