#4855 support hcadr in mysql 5.6 and merge to main refs[t:4855]

git-svn-id: file:///svn/mysql/tokudb-engine/tokudb-engine@43723 c7de825b-a66e-492c-adef-691d508d4ae1

storage/tokudb/ha_tokudb.h

@@ -3,10 +3,17 @@
 #endif
 
 #define TOKU_INCLUDE_CHECKPOINT_LOCK 1
-#if MYSQL_VERSION_ID < 50600
+
+#if 50600 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 50699
+#define TOKU_INCLUDE_ROW_TYPE_COMPRESSION 0
+#else
 #define TOKU_INCLUDE_ROW_TYPE_COMPRESSION 1
+#endif
+
+#if defined(HA_GENERAL_ONLINE) || (50600 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 50699)
+#define TOKU_INCLUDE_UPDATE_FUN 1
 #else
-#define TOKU_INCLUDE_ROW_TYPE_COMPRESSION 0
+#define TOKU_INCLUDE_UPDATE_FUN 0
 #endif
 
 #if !defined(HA_CLUSTERING)
@@ -556,42 +563,44 @@ class ha_tokudb : public handler {
     int cmp_ref(const uchar * ref1, const uchar * ref2);
     bool check_if_incompatible_data(HA_CREATE_INFO * info, uint table_changes);
 
-#if MYSQL_VERSION_ID >= 50606
-#elif MYSQL_VERSION_ID >= 50521
+#if 50600 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 50699
+ public:
+    enum_alter_inplace_result check_if_supported_inplace_alter(TABLE *altered_table, Alter_inplace_info *ha_alter_info);
+    bool prepare_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info);
+    bool inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info);
+    bool commit_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, bool commit);
+ private:
+    int alter_table_add_index(TABLE *altered_table, Alter_inplace_info *ha_alter_info);
+    int alter_table_drop_index(TABLE *altered_table, Alter_inplace_info *ha_alter_info);
+    int alter_table_add_or_drop_column(TABLE *altered_table, Alter_inplace_info *ha_alter_info);
+    void print_alter_info(TABLE *altered_table, Alter_inplace_info *ha_alter_info);
+ public:
+#elif 50500 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 50599
+ public:
     int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, handler_add_index **add);
     int final_add_index(handler_add_index *add, bool commit);
-#else
-    int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys);
-#endif
-
-    int tokudb_add_index(
-        TABLE *table_arg, 
-        KEY *key_info, 
-        uint num_of_keys, 
-        DB_TXN* txn, 
-        bool* inc_num_DBs,
-        bool* modified_DB
-        ); 
-    void restore_add_index(TABLE* table_arg, uint num_of_keys, bool incremented_numDBs, bool modified_DBs);
-    int drop_indexes(TABLE *table_arg, uint *key_num, uint num_of_keys, DB_TXN* txn);
     int prepare_drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys);
-    void restore_drop_indexes(TABLE *table_arg, uint *key_num, uint num_of_keys);
     int final_drop_index(TABLE *table_arg);
 
-#if MYSQL_VERSION_ID >= 50521
     bool is_alter_table_hot();
     void prepare_for_alter();
     int new_alter_table_frm_data(const uchar *frm_data, size_t frm_len);
+#else
+ public:
+    int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys);
+    int prepare_drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys);
+    int final_drop_index(TABLE *table_arg);
 #endif
 
-
 #if defined(HA_GENERAL_ONLINE)
+ private:
     void print_alter_info(
         TABLE *altered_table,
         HA_CREATE_INFO *create_info,
         HA_ALTER_FLAGS *alter_flags,
         uint table_changes
         );
+ public:
     int check_if_supported_alter(TABLE *altered_table,
          HA_CREATE_INFO *create_info,
          HA_ALTER_FLAGS *alter_flags,
@@ -617,6 +626,20 @@ class ha_tokudb : public handler {
     }
 #endif
 
+ private:
+    int tokudb_add_index(
+        TABLE *table_arg, 
+        KEY *key_info, 
+        uint num_of_keys, 
+        DB_TXN* txn, 
+        bool* inc_num_DBs,
+        bool* modified_DB
+        ); 
+    void restore_add_index(TABLE* table_arg, uint num_of_keys, bool incremented_numDBs, bool modified_DBs);
+    int drop_indexes(TABLE *table_arg, uint *key_num, uint num_of_keys, DB_TXN* txn);
+    void restore_drop_indexes(TABLE *table_arg, uint *key_num, uint num_of_keys);
+
+ public:
     // delete all rows from the table
     // effect: all dictionaries, including the main and indexes, should be empty
     int discard_or_import_tablespace(my_bool discard);

storage/tokudb/ha_tokudb_alter_55.cc

+#if 50500 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 50599
+
+class ha_tokudb_add_index : public handler_add_index {
+public:
+    DB_TXN *txn;
+    bool incremented_numDBs;
+    bool modified_DBs;
+	ha_tokudb_add_index(TABLE* table, KEY* key_info, uint num_of_keys, DB_TXN *txn, bool incremented_numDBs, bool modified_DBs) :
+		handler_add_index(table, key_info, num_of_keys), txn(txn), incremented_numDBs(incremented_numDBs), modified_DBs(modified_DBs) {
+    }
+	~ha_tokudb_add_index() {
+    }
+};
+
+volatile int ha_tokudb_add_index_wait = 0;
+
+int 
+ha_tokudb::add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, handler_add_index **add) {
+    TOKUDB_DBUG_ENTER("ha_tokudb::add_index");
+    while (ha_tokudb_add_index_wait) sleep(1); // debug
+
+    int error;
+    bool incremented_numDBs = false;
+    bool modified_DBs = false;
+
+    // transaction is created in prepare_for_alter
+    DB_TXN* txn = transaction;
+
+    error = tokudb_add_index(
+        table_arg,
+        key_info,
+        num_of_keys,
+        txn,
+        &incremented_numDBs,
+        &modified_DBs
+        );
+    if (error) { goto cleanup; }
+    
+cleanup:
+    DBUG_EXECUTE_IF("add_index_fail", {
+        error = 1;
+    });
+    if (error) {
+        if (txn) {
+            restore_add_index(table_arg, num_of_keys, incremented_numDBs, modified_DBs);
+        }
+    } else {
+        *add = new ha_tokudb_add_index(table_arg, key_info, num_of_keys, txn, incremented_numDBs, modified_DBs);
+    }
+    TOKUDB_DBUG_RETURN(error);
+}
+
+volatile int ha_tokudb_final_add_index_wait = 0;
+
+int 
+ha_tokudb::final_add_index(handler_add_index *add_arg, bool commit) {
+    TOKUDB_DBUG_ENTER("ha_tokudb::final_add_index");
+    while (ha_tokudb_final_add_index_wait) sleep(1); // debug
+
+    // extract the saved state variables
+    ha_tokudb_add_index *add = static_cast<class ha_tokudb_add_index*>(add_arg);
+    bool incremented_numDBs = add->incremented_numDBs;
+    bool modified_DBs = add->modified_DBs;
+    TABLE *table = add->table;
+    uint num_of_keys = add->num_of_keys;
+    delete add;
+
+    int error = 0;
+
+    DBUG_EXECUTE_IF("final_add_index_fail", {
+        error = 1;
+    });
+    // at this point, the metadata lock ensures that the
+    // newly created indexes cannot be modified,
+    // regardless of whether the add index was hot.
+    // Because a subsequent drop index may cause an
+    // error requireing us to abort the transaction,
+    // we prematurely close the added indexes, regardless
+    // of whether we are committing or aborting.
+    restore_add_index(table, num_of_keys, incremented_numDBs, modified_DBs);
+    // transaction does not need to be committed,
+    // we depend on MySQL to rollback the transaction
+    // by calling tokudb_rollback
+
+    TOKUDB_DBUG_RETURN(error);
+}
+
+volatile int ha_tokudb_prepare_drop_index_wait = 0; //debug
+
+//
+// Prepares to drop indexes to the table. For each value, i, in the array key_num,
+// table->key_info[i] is a key that is to be dropped.
+//  ***********NOTE*******************
+// Although prepare_drop_index is supposed to just get the DB's ready for removal,
+// and not actually do the removal, we are doing it here and not in final_drop_index
+// For the flags we expose in alter_table_flags, namely xxx_NO_WRITES, this is allowed
+// Changes for "future-proofing" this so that it works when we have the equivalent flags
+// that are not NO_WRITES are not worth it at the moments
+// Parameters:
+//      [in]    table_arg - table that is being modified, seems to be identical to this->table
+//      [in]    key_num - array of indexes that specify which keys of the array table->key_info
+//                  are to be dropped
+//              num_of_keys - size of array, key_num
+//  Returns:
+//      0 on success, error otherwise
+//
+int 
+ha_tokudb::prepare_drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys) {
+    TOKUDB_DBUG_ENTER("ha_tokudb::prepare_drop_index");
+    while (ha_tokudb_prepare_drop_index_wait) sleep(1); // debug
+
+    DB_TXN *txn = transaction;
+    assert(txn);
+    int error = drop_indexes(table_arg, key_num, num_of_keys, txn);
+    DBUG_EXECUTE_IF("prepare_drop_index_fail", {
+        error = 1;
+    });
+
+    TOKUDB_DBUG_RETURN(error);
+}
+
+volatile int ha_tokudb_final_drop_index_wait = 0; // debug
+
+//  ***********NOTE*******************
+// Although prepare_drop_index is supposed to just get the DB's ready for removal,
+// and not actually do the removal, we are doing it here and not in final_drop_index
+// For the flags we expose in alter_table_flags, namely xxx_NO_WRITES, this is allowed
+// Changes for "future-proofing" this so that it works when we have the equivalent flags
+// that are not NO_WRITES are not worth it at the moments, therefore, we can make
+// this function just return
+int 
+ha_tokudb::final_drop_index(TABLE *table_arg) {
+    TOKUDB_DBUG_ENTER("ha_tokudb::final_drop_index");
+    while (ha_tokudb_final_drop_index_wait) sleep(1); // debug
+
+    int error = 0;
+    DBUG_EXECUTE_IF("final_drop_index_fail", {
+        error = 1;
+    });
+    TOKUDB_DBUG_RETURN(error);
+}
+
+bool
+ha_tokudb::is_alter_table_hot() {
+    TOKUDB_DBUG_ENTER("is_alter_table_hot");
+    bool is_hot = false;
+    THD *thd = ha_thd();
+    if (get_create_index_online(thd) && thd_sql_command(thd)== SQLCOM_CREATE_INDEX) {
+        // this code must match the logic in ::store_lock for hot indexing
+        rw_rdlock(&share->num_DBs_lock);
+        if (share->num_DBs == (table->s->keys + test(hidden_primary_key))) {
+            is_hot = true;
+        }
+        rw_unlock(&share->num_DBs_lock);
+    } 
+    TOKUDB_DBUG_RETURN(is_hot);
+}
+
+// write the new frm data to the status dictionary using the alter table transaction
+int 
+ha_tokudb::new_alter_table_frm_data(const uchar *frm_data, size_t frm_len) {
+    TOKUDB_DBUG_ENTER("new_alter_table_path");
+
+    int error = 0;
+    if (table->part_info == NULL) {
+        // write frmdata to status
+        DB_TXN *txn = transaction; // use alter table transaction
+        assert(txn);
+        error = write_to_status(share->status_block, hatoku_frm_data, (void *)frm_data, (uint)frm_len, txn);
+    }
+   
+    TOKUDB_DBUG_RETURN(error);
+}
+
+void
+ha_tokudb::prepare_for_alter() {
+    TOKUDB_DBUG_ENTER("prepare_for_alter");
+
+    // this is here because mysql commits the transaction before prepare_for_alter is called.
+    // we need a transaction to add indexes, drop indexes, and write the new frm data, so we
+    // create one.  this transaction will be retired by mysql alter table when it commits
+    //
+    // if we remove the commit before prepare_for_alter, then this is not needed.
+    transaction = NULL;
+    THD *thd = ha_thd();
+    tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);
+    assert(trx);
+    // for partitioned tables, a transaction may already exist, 
+    // as we call prepare_for_alter on all partitions
+    if (!trx->sub_sp_level) {
+        int error = create_txn(thd, trx);
+        assert(error == 0);
+        assert(thd->in_sub_stmt == 0);
+    }
+    transaction = trx->sub_sp_level;
+    DBUG_VOID_RETURN;
+}
+
+#endif

storage/tokudb/hatoku_defines.h

@@ -110,14 +110,14 @@ typedef struct st_tokudb_trx_data {
 extern char *tokudb_data_dir;
 extern const char *ha_tokudb_ext;
 
-static void reset_stmt_progress (tokudb_stmt_progress* val) {
+static inline void reset_stmt_progress (tokudb_stmt_progress* val) {
     val->deleted = 0;
     val->inserted = 0;
     val->updated = 0;
     val->queried = 0;
 }
 
-static int get_name_length(const char *name) {
+static inline int get_name_length(const char *name) {
     int n = 0;
     const char *newname = name;
     n += strlen(newname);
@@ -128,7 +128,7 @@ static int get_name_length(const char *name) {
 //
 // returns maximum length of path to a dictionary
 //
-static int get_max_dict_name_path_length(const char *tablename) {
+static inline int get_max_dict_name_path_length(const char *tablename) {
     int n = 0;
     n += get_name_length(tablename);
     n += 1; //for the '-'
@@ -136,7 +136,7 @@ static int get_max_dict_name_path_length(const char *tablename) {
     return n;
 }
 
-static void make_name(char *newname, const char *tablename, const char *dictname) {
+static inline void make_name(char *newname, const char *tablename, const char *dictname) {
     const char *newtablename = tablename;
     char *nn = newname;
     assert(tablename);

storage/tokudb/hatoku_hton.cc

@@ -504,7 +504,7 @@ static int tokudb_init_func(void *p) {
     assert(!r);
     r = db_env->set_generate_row_callback_for_del(db_env,generate_row_for_del);
     assert(!r);
-#if defined(HA_GENERAL_ONLINE)
+#if TOKU_INCLUDE_UPDATE_FUN
     db_env->set_update(db_env, tokudb_update_fun);
 #endif
     r = db_env->open(db_env, tokudb_home, tokudb_init_flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);