{

DB_TYPE_UNKNOWN=0,DB_TYPE_DIAB_ISAM=1,

DB_TYPE_HASH,DB_TYPE_MISAM,DB_TYPE_PISAM,

DB_TYPE_RMS_ISAM, DB_TYPE_HEAP, DB_TYPE_ISAM,

DB_TYPE_MRG_ISAM, DB_TYPE_MYISAM, DB_TYPE_MRG_MYISAM,

DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB,

DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER,

DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB,

DB_TYPE_FEDERATED_DB,

DB_TYPE_BLACKHOLE_DB,

DB_TYPE_PARTITION_DB,

DB_TYPE_BINLOG,

DB_TYPE_SOLID,

DB_TYPE_PBXT,

DB_TYPE_TABLE_FUNCTION,

DB_TYPE_MEMCACHE,

DB_TYPE_FALCON,

DB_TYPE_MARIA,

/** Performance schema engine. */

DB_TYPE_PERFORMANCE_SCHEMA,

DB_TYPE_FIRST_DYNAMIC=42,

DB_TYPE_DEFAULT=127 // Must be last

ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,

ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT,

/** Unused. Reserved for future versions. */

BFN_RESET_LOGS= 1,

BFN_RESET_SLAVE= 2,

BFN_BINLOG_WAIT= 3,

BFN_BINLOG_END= 4,

BFN_BINLOG_PURGE_FILE= 5

LOGCOM_CREATE_TABLE,

LOGCOM_ALTER_TABLE,

LOGCOM_RENAME_TABLE,

LOGCOM_DROP_TABLE,

LOGCOM_CREATE_DB,

LOGCOM_ALTER_DB,

LOGCOM_DROP_DB

{

const char *db;

const char *tablename;

long formatID;

long gtrid_length;

long bqual_length;

char data[XIDDATASIZE]; // not \0-terminated !

xid_t() {} /* Remove gcc warning */

bool eq(struct xid_t *xid)

{ return eq(xid->gtrid_length, xid->bqual_length, xid->data); }

bool eq(long g, long b, const char *d)

{ return g == gtrid_length && b == bqual_length && !memcmp(d, data, g+b); }

void set(struct xid_t *xid)

{ memcpy(this, xid, xid->length()); }

void set(long f, const char *g, long gl, const char *b, long bl)

{

formatID= f;

memcpy(data, g, gtrid_length= gl);

memcpy(data+gl, b, bqual_length= bl);

}

void set(ulonglong xid)

{

my_xid tmp;

formatID= 1;

set(MYSQL_XID_PREFIX_LEN, 0, MYSQL_XID_PREFIX);

memcpy(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id));

tmp= xid;

memcpy(data+MYSQL_XID_OFFSET, &tmp, sizeof(tmp));

gtrid_length=MYSQL_XID_GTRID_LEN;

}

void set(long g, long b, const char *d)

{

formatID= 1;

gtrid_length= g;

bqual_length= b;

memcpy(data, d, g+b);

}

bool is_null() { return formatID == -1; }

void null() { formatID= -1; }

my_xid quick_get_my_xid()

{

my_xid tmp;

memcpy(&tmp, data+MYSQL_XID_OFFSET, sizeof(tmp));

return tmp;

}

my_xid get_my_xid()

{

return gtrid_length == MYSQL_XID_GTRID_LEN && bqual_length == 0 &&

!memcmp(data, MYSQL_XID_PREFIX, MYSQL_XID_PREFIX_LEN) ?

quick_get_my_xid() : 0;

}

uint length()

{

return sizeof(formatID)+sizeof(gtrid_length)+sizeof(bqual_length)+

gtrid_length+bqual_length;

}

uchar *key()

{

return (uchar *)&gtrid_length;

}

uint key_length()

{

return sizeof(gtrid_length)+sizeof(bqual_length)+gtrid_length+bqual_length;

}

{

TS_CMD_NOT_DEFINED = -1,

CREATE_TABLESPACE = 0,

ALTER_TABLESPACE = 1,

CREATE_LOGFILE_GROUP = 2,

ALTER_LOGFILE_GROUP = 3,

DROP_TABLESPACE = 4,

DROP_LOGFILE_GROUP = 5,

CHANGE_FILE_TABLESPACE = 6,

ALTER_ACCESS_MODE_TABLESPACE = 7

{

TS_ALTER_TABLESPACE_TYPE_NOT_DEFINED = -1,

ALTER_TABLESPACE_ADD_FILE = 1,

ALTER_TABLESPACE_DROP_FILE = 2

{

TS_NOT_DEFINED= -1,

TS_READ_ONLY = 0,

TS_READ_WRITE = 1,

TS_NOT_ACCESSIBLE = 2

{

public:

const char *tablespace_name;

const char *logfile_group_name;

enum ts_command_type ts_cmd_type;

enum ts_alter_tablespace_type ts_alter_tablespace_type;

const char *data_file_name;

const char *undo_file_name;

const char *redo_file_name;

ulonglong extent_size;

ulonglong undo_buffer_size;

ulonglong redo_buffer_size;

ulonglong initial_size;

ulonglong autoextend_size;

ulonglong max_size;

uint nodegroup_id;

handlerton *storage_engine;

bool wait_until_completed;

const char *ts_comment;

enum tablespace_access_mode ts_access_mode;

st_alter_tablespace()

{

tablespace_name= NULL;

logfile_group_name= "DEFAULT_LG"; //Default log file group

ts_cmd_type= TS_CMD_NOT_DEFINED;

data_file_name= NULL;

undo_file_name= NULL;

redo_file_name= NULL;

extent_size= 1024*1024; //Default 1 MByte

undo_buffer_size= 8*1024*1024; //Default 8 MByte

redo_buffer_size= 8*1024*1024; //Default 8 MByte

initial_size= 128*1024*1024; //Default 128 MByte

autoextend_size= 0; //No autoextension as default

max_size= 0; //Max size == initial size => no extension

storage_engine= NULL;

nodegroup_id= UNDEF_NODEGROUP;

wait_until_completed= TRUE;

ts_comment= NULL;

ts_access_mode= TS_NOT_DEFINED;

}

{

SCH_CHARSETS= 0,

SCH_COLLATIONS,

SCH_COLLATION_CHARACTER_SET_APPLICABILITY,

SCH_COLUMNS,

SCH_COLUMN_PRIVILEGES,

SCH_ENGINES,

SCH_EVENTS,

SCH_FILES,

SCH_GLOBAL_STATUS,

SCH_GLOBAL_VARIABLES,

SCH_KEY_COLUMN_USAGE,

SCH_OPEN_TABLES,

SCH_PARAMETERS,

SCH_PARTITIONS,

SCH_PLUGINS,

SCH_PROCESSLIST,

SCH_PROFILES,

SCH_REFERENTIAL_CONSTRAINTS,

SCH_PROCEDURES,

SCH_SCHEMATA,

SCH_SCHEMA_PRIVILEGES,

SCH_SESSION_STATUS,

SCH_SESSION_VARIABLES,

SCH_STATISTICS,

SCH_STATUS,

SCH_TABLES,

SCH_TABLESPACES,

SCH_TABLE_CONSTRAINTS,

SCH_TABLE_NAMES,

SCH_TABLE_PRIVILEGES,

SCH_TABLE_STATISTICS,

SCH_TRIGGERS,

SCH_USER_PRIVILEGES,

SCH_VARIABLES,

SCH_VIEWS

{

HA_LOG_STATUS_FREE= 0, /* log is free and can be deleted */

HA_LOG_STATUS_INUSE= 1, /* log can't be deleted because it is in use */

HA_LOG_STATUS_NOSUCHLOG= 2 /* no such log (can't be returned by

{

/* request of transaction log iterator */

HA_TRANSACTLOG_ITERATOR= 1

{

HA_ITERATOR_OK, /* iterator created */

HA_ITERATOR_UNSUPPORTED, /* such type of iterator is not supported */

HA_ITERATOR_ERROR /* error during iterator creation */

/*

int (*next)(struct handler_iterator *, void *iterator_object);

/*

void (*destroy)(struct handler_iterator *);

/*

void *buffer;

{

/*

SHOW_COMP_OPTION state;

/*

enum legacy_db_type db_type;

/*

uint slot;

/*

uint savepoint_offset;

/*

int (*close_connection)(handlerton *hton, THD *thd);

/*

int (*savepoint_set)(handlerton *hton, THD *thd, void *sv);

/*

int (*savepoint_rollback)(handlerton *hton, THD *thd, void *sv);

int (*savepoint_release)(handlerton *hton, THD *thd, void *sv);

/*

int (*commit)(handlerton *hton, THD *thd, bool all);

int (*rollback)(handlerton *hton, THD *thd, bool all);

int (*prepare)(handlerton *hton, THD *thd, bool all);

int (*recover)(handlerton *hton, XID *xid_list, uint len);

int (*commit_by_xid)(handlerton *hton, XID *xid);

int (*rollback_by_xid)(handlerton *hton, XID *xid);

void *(*create_cursor_read_view)(handlerton *hton, THD *thd);

void (*set_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);

void (*close_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);

handler *(*create)(handlerton *hton, TABLE_SHARE *table, MEM_ROOT *mem_root);

void (*drop_database)(handlerton *hton, char* path);

int (*panic)(handlerton *hton, enum ha_panic_function flag);

int (*start_consistent_snapshot)(handlerton *hton, THD *thd);

bool (*flush_logs)(handlerton *hton);

bool (*show_status)(handlerton *hton, THD *thd, stat_print_fn *print, enum ha_stat_type stat);

uint (*partition_flags)();

uint (*alter_table_flags)(uint flags);

int (*alter_tablespace)(handlerton *hton, THD *thd, st_alter_tablespace *ts_info);

int (*fill_is_table)(handlerton *hton, THD *thd, TABLE_LIST *tables,

class Item *cond,

enum enum_schema_tables);

uint32 flags; /* global handler flags */

/*

int (*binlog_func)(handlerton *hton, THD *thd, enum_binlog_func fn, void *arg);

void (*binlog_log_query)(handlerton *hton, THD *thd,

enum_binlog_command binlog_command,

const char *query, uint query_length,

const char *db, const char *table_name);

int (*release_temporary_latches)(handlerton *hton, THD *thd);

/*

enum log_status (*get_log_status)(handlerton *hton, char *log);

/* Control the storage engine. */

longlong (*control)(handlerton *hton, const char *cmd,

Item **args, uint arg_count);

/* Terminate connection/statement notification. */

void (*kill_connection)(handlerton *hton, THD *thd);

/*

enum handler_create_iterator_result

(*create_iterator)(handlerton *hton, enum handler_iterator_type type,

struct handler_iterator *fill_this_in);

int (*discover)(handlerton *hton, THD* thd, const char *db,

const char *name,

uchar **frmblob,

size_t *frmlen);

int (*find_files)(handlerton *hton, THD *thd,

const char *db,

const char *path,

const char *wild, bool dir, List<LEX_STRING> *files);

int (*table_exists_in_engine)(handlerton *hton, THD* thd, const char *db,

const char *name);

/**

const char* (*system_database)();

/**

bool (*is_supported_system_table)(const char *db,

const char *table_name,

bool is_sql_layer_system_table);

uint32 license; /* Flag for Engine License */

void *data; /* Location for engines to keep personal structures */

{

/* true is not all entries in the ht[] support 2pc */

bool no_2pc;

/* storage engines that registered in this transaction */

Ha_trx_info *ha_list;

/*

bool modified_non_trans_table;

void reset() { no_2pc= FALSE; modified_non_trans_table= FALSE; }

bool is_empty() const { return ha_list == NULL; }

{

/** Register this storage engine in the given transaction context. */

void register_ha(THD_TRANS *trans, handlerton *ht_arg)

{

DBUG_ASSERT(m_flags == 0);

DBUG_ASSERT(m_ht == NULL);

DBUG_ASSERT(m_next == NULL);

m_ht= ht_arg;

m_flags= (int) TRX_READ_ONLY; /* Assume read-only at start. */

m_next= trans->ha_list;

trans->ha_list= this;

}

/** Clear, prepare for reuse. */

void reset()

{

m_next= NULL;

m_ht= NULL;

m_flags= 0;

}

Ha_trx_info() { reset(); }

void set_trx_read_write()

{

DBUG_ASSERT(is_started());

m_flags|= (int) TRX_READ_WRITE;

}

bool is_trx_read_write() const

{

DBUG_ASSERT(is_started());

return m_flags & (int) TRX_READ_WRITE;

}

bool is_started() const { return m_ht != NULL; }

/** Mark this transaction read-write if the argument is read-write. */

void coalesce_trx_with(const Ha_trx_info *stmt_trx)

{

/*

DBUG_ASSERT(is_started());

if (stmt_trx->is_trx_read_write())

set_trx_read_write();

}

Ha_trx_info *next() const

{

DBUG_ASSERT(is_started());

return m_next;

}

handlerton *ht() const

{

DBUG_ASSERT(is_started());

return m_ht;

}