HA_ALTER_ERROR,

HA_ALTER_INPLACE_NOT_SUPPORTED,

HA_ALTER_INPLACE_EXCLUSIVE_LOCK,

HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE,

HA_ALTER_INPLACE_SHARED_LOCK,

HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE,

HA_ALTER_INPLACE_NO_LOCK

{

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

DB_TYPE_FIRST_DYNAMIC=42,

DB_TYPE_SEQUENCE_DB,

DB_TYPE_DEFAULT=127 // Must be last

ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,

ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT,

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

ROW_TYPE_PAGE,

ROW_TYPE_TOKU_UNCOMPRESSED, ROW_TYPE_TOKU_ZLIB,

ROW_TYPE_TOKU_QUICKLZ, ROW_TYPE_TOKU_LZMA,

COLUMN_FORMAT_TYPE_DEFAULT= 0, /* Not specified (use engine default) */

COLUMN_FORMAT_TYPE_FIXED= 1, /* FIXED format */

COLUMN_FORMAT_TYPE_DYNAMIC= 2, /* DYNAMIC format */

COLUMN_FORMAT_TYPE_COMPRESSED= 3 /* COMPRESSED format*/

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

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

SCH_STATISTICS,

SCH_STATUS,

SCH_TABLES,

SCH_TABLESPACES,

SCH_TABLE_CONSTRAINTS,

SCH_TABLE_NAMES,

SCH_TABLE_PRIVILEGES,

SCH_TRIGGERS,

SCH_USER_PRIVILEGES,

SCH_VARIABLES,

SCH_VIEWS,

SCH_THREAD_GROUP_STATUS

{

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

/**

bool (*savepoint_rollback_can_release_mdl)(handlerton *hton, THD *thd);

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

void (*force_drop_table)(handlerton *hton, char* name);

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

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

bool (*flush_logs)(handlerton *hton, unsigned long long target_lsn);

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

/*

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

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

const AQP::Join_plan* plan);

/**

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