{

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,

/*

KNOWN_SYSTEM_TABLE,

/*

SUPPORTED_SYSTEM_TABLE

} status; // OUT param

{

if (thd->variables.table_plugin)

return thd->variables.table_plugin;

return my_plugin_lock(thd, &global_system_variables.table_plugin);

{

if (thd->variables.temp_table_plugin)

return thd->variables.temp_table_plugin;

return my_plugin_lock(thd, &global_system_variables.temp_table_plugin);

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;

/*

plugin_unlock(thd, plugin);

}

/*

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;

{

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;

{

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

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

return my_error_register(get_handler_errmsgs, HA_ERR_FIRST, HA_ERR_LAST);

{

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;

{

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)

{

/*

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

}

}

/*

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

{

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;

}

/*

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;

}

/*

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;

}

/*

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:

/*

if (plugin->plugin->deinit)

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

err:

my_free(hton);

err_no_hton_memory:

plugin->data= NULL;

DBUG_RETURN(1);

{

int error= 0;

DBUG_ENTER("ha_init");

DBUG_ASSERT(total_ha < MAX_HA);

/*

opt_using_transactions= total_ha>(ulong)opt_bin_log;

savepoint_alloc_size+= sizeof(SAVEPOINT);

/*

known_system_databases= ha_known_system_databases();

DBUG_RETURN(error);

{

int error= 0;

DBUG_ENTER("ha_end");

/*

if (ha_finish_errors())

error= 1;

DBUG_RETURN(error);

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 *unused)

{

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

/*

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;