/* Copyright (c) 2000, 2013, 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., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */

/** @file handler.cc

@brief

Handler-calling-functions

*/

#include "binlog.h"

#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 <mysql/psi/mysql_table.h>

#include "debug_sync.h" // DEBUG_SYNC

#include <my_bit.h>

#include <list>

#ifdef WITH_PARTITION_STORAGE_ENGINE

#include "ha_partition.h"

#endif

using std::min;

using std::max;

using std::list;

// This is a temporary backporting fix.

#ifndef HAVE_LOG2

/*

This will be slightly slower and perhaps a tiny bit less accurate than

doing it the IEEE754 way but log2() should be available on C99 systems.

*/

inline double log2(double x)

{

return (log(x) / M_LN2);

}

#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}, true };

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

#ifndef DBUG_OFF

const char *ha_legacy_type_name(legacy_db_type legacy_type)

{

switch (legacy_type)

{

case DB_TYPE_UNKNOWN:

return "DB_TYPE_UNKNOWN";

case DB_TYPE_DIAB_ISAM:

return "DB_TYPE_DIAB_ISAM";

case DB_TYPE_HASH:

return "DB_TYPE_HASH";

case DB_TYPE_MISAM:

return "DB_TYPE_MISAM";

case DB_TYPE_PISAM:

return "DB_TYPE_PISAM";

case DB_TYPE_RMS_ISAM:

return "DB_TYPE_RMS_ISAM";

case DB_TYPE_HEAP:

return "DB_TYPE_HEAP";

case DB_TYPE_ISAM:

return "DB_TYPE_ISAM";

case DB_TYPE_MRG_ISAM:

return "DB_TYPE_MRG_ISAM";

case DB_TYPE_MYISAM:

return "DB_TYPE_MYISAM";

case DB_TYPE_MRG_MYISAM:

return "DB_TYPE_MRG_MYISAM";

case DB_TYPE_BERKELEY_DB:

return "DB_TYPE_BERKELEY_DB";

case DB_TYPE_INNODB:

return "DB_TYPE_INNODB";

case DB_TYPE_GEMINI:

return "DB_TYPE_GEMINI";

case DB_TYPE_NDBCLUSTER:

return "DB_TYPE_NDBCLUSTER";

case DB_TYPE_EXAMPLE_DB:

return "DB_TYPE_EXAMPLE_DB";

case DB_TYPE_ARCHIVE_DB:

return "DB_TYPE_ARCHIVE_DB";

case DB_TYPE_CSV_DB:

return "DB_TYPE_CSV_DB";

case DB_TYPE_FEDERATED_DB:

return "DB_TYPE_FEDERATED_DB";

case DB_TYPE_BLACKHOLE_DB:

return "DB_TYPE_BLACKHOLE_DB";

case DB_TYPE_PARTITION_DB:

return "DB_TYPE_PARTITION_DB";

case DB_TYPE_BINLOG:

return "DB_TYPE_BINLOG";

case DB_TYPE_SOLID:

return "DB_TYPE_SOLID";

case DB_TYPE_PBXT:

return "DB_TYPE_PBXT";

case DB_TYPE_TABLE_FUNCTION:

return "DB_TYPE_TABLE_FUNCTION";

case DB_TYPE_MEMCACHE:

return "DB_TYPE_MEMCACHE";

case DB_TYPE_FALCON:

return "DB_TYPE_FALCON";

case DB_TYPE_MARIA:

return "DB_TYPE_MARIA";

case DB_TYPE_PERFORMANCE_SCHEMA:

return "DB_TYPE_PERFORMANCE_SCHEMA";

default:

return "DB_TYPE_DYNAMIC";

}

}

#endif

/**

Database name that hold most of mysqld system tables.

Current code assumes that, there exists only some

specific "database name" designated as system database.

*/

const char* mysqld_system_database= "mysql";

// System tables that belong to mysqld_system_database.

st_system_tablename mysqld_system_tables[]= {

{mysqld_system_database, "db"},

{mysqld_system_database, "user"},

{mysqld_system_database, "host"},

{mysqld_system_database, "func"},

{mysqld_system_database, "proc"},

{mysqld_system_database, "event"},

{mysqld_system_database, "plugin"},

{mysqld_system_database, "servers"},

{mysqld_system_database, "procs_priv"},

{mysqld_system_database, "tables_priv"},

{mysqld_system_database, "proxies_priv"},

{mysqld_system_database, "columns_priv"},

{mysqld_system_database, "time_zone"},

{mysqld_system_database, "time_zone_name"},

{mysqld_system_database, "time_zone_leap_second"},

{mysqld_system_database, "time_zone_transition"},

{mysqld_system_database, "time_zone_transition_type"},

{mysqld_system_database, "help_category"},

{mysqld_system_database, "help_keyword"},

{mysqld_system_database, "help_relation"},

{mysqld_system_database, "help_topic"},

{(const char *)NULL, (const char *)NULL} /* This must be at the end */

};

/**

This static pointer holds list of system databases from SQL layer and

various SE's. The required memory is allocated once, and never freed.

*/

static const char **known_system_databases= NULL;

static const char **ha_known_system_databases();

// Called for each SE to get SE specific system database.

static my_bool system_databases_handlerton(THD *unused, plugin_ref plugin,

void *arg);

// Called for each SE to check if given db.table_name is a system table.

static my_bool check_engine_system_table_handlerton(THD *unused,

plugin_ref plugin,

void *arg);

/**

Structure used by SE during check for system table.

This structure is passed to each SE handlerton and the status (OUT param)

is collected.

*/

struct st_sys_tbl_chk_params

{

const char *db; // IN param

const char *table_name; // IN param

bool is_sql_layer_system_table; // IN param

legacy_db_type db_type; // IN param

enum enum_sys_tbl_chk_status

{

// db.table_name is not a supported system table.

NOT_KNOWN_SYSTEM_TABLE,

/*

db.table_name is a system table,

but may not be supported by SE.

*/

KNOWN_SYSTEM_TABLE,

/*

db.table_name is a system table,

and is supported by SE.

*/

SUPPORTED_SYSTEM_TABLE

} status; // OUT param

};

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 used for non-temp tables

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;

}

static plugin_ref ha_default_temp_plugin(THD *thd)

{

if (thd->variables.temp_table_plugin)

return thd->variables.temp_table_plugin;

return my_plugin_lock(thd, &global_system_variables.temp_table_plugin);

}

/** @brief

Return the default storage engine handlerton used for explicitly

created temp tables for a thread

SYNOPSIS

ha_default_temp_handlerton(thd)

thd current thread

RETURN

pointer to handlerton

*/

handlerton *ha_default_temp_handlerton(THD *thd)

{

plugin_ref plugin= ha_default_temp_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,

bool is_temp_table)

{

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 is_temp_table ?

ha_default_plugin(thd) : ha_default_temp_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;

}

(void) 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(ME_FATALERROR),

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));

SETMSG(HA_FTS_INVALID_DOCID, "Invalid InnoDB FTS Doc ID");

SETMSG(HA_ERR_TABLE_IN_FK_CHECK, ER_DEFAULT(ER_TABLE_IN_FK_CHECK));

SETMSG(HA_ERR_TABLESPACE_EXISTS, "Tablespace already exists");

SETMSG(HA_ERR_FTS_EXCEED_RESULT_CACHE_LIMIT, "FTS query exceeds result cache limit");

SETMSG(HA_ERR_TEMP_FILE_WRITE_FAILURE, ER_DEFAULT(ER_TEMP_FILE_WRITE_FAILURE));

SETMSG(HA_ERR_INNODB_FORCED_RECOVERY, ER_DEFAULT(ER_INNODB_FORCED_RECOVERY));

SETMSG(HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE, "Too many words in a FTS phrase or proximity search");

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

*/

DBUG_PRINT("info", ("hton->state=%d", hton->state));

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);

/*

Initialize system database name cache.

This cache is used to do a quick check if a given

db.tablename is a system table.

*/

known_system_databases= ha_known_system_databases();

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);

}

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

======================= 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,