Encode column family id and flags in datadic

Summary:
Serialize column family id, is_reverse_cf, and is_auto_cf in datadic.
This way when we load RocksDB-SE initially, we can fully populate
RDBSE_KEYDEF entries without having to wait for an open table call.

Test Plan:
Ran "drop index" diff after this one; verified that dropped
indices persisted after shutdown.

Reviewers: spetrunia, maykov, hermanlee4, yoshinorim

Reviewed By: yoshinorim

Subscribers: jtolmer

Differential Revision: https://reviews.facebook.net/D32955

Author: Jonah Cohen

storage/rocksdb/ha_rocksdb.cc

@@ -713,7 +713,7 @@ class Primary_key_comparator : public rocksdb::Comparator
 
   /* The following is not needed by RocksDB, but conceptually should be here: */
   static ulong get_hashnr(const char *key, size_t key_len);
-  const char* Name() const { return "RocksDB_SE_v3.2"; }
+  const char* Name() const { return "RocksDB_SE_v3.3"; }
 
   //TODO: advanced funcs:
   // - FindShortestSeparator
@@ -730,7 +730,7 @@ class Reverse_comparator : public rocksdb::Comparator
   {
     return -bytewise_compare(a,b);
   }
-  const char* Name() const { return "rev:RocksDB_SE_v3.2"; }
+  const char* Name() const { return "rev:RocksDB_SE_v3.3"; }
   void FindShortestSeparator(std::string* start, const rocksdb::Slice& limit) const {}
   void FindShortSuccessor(std::string* key) const {}
 };
@@ -1330,12 +1330,12 @@ static int rocksdb_init_func(void *p)
     sql_print_error("RocksDB: Error opening instance: %s", err_text.c_str());
     DBUG_RETURN(1);
   }
-  cf_manager.init(&cf_names, &cf_handles);
+  cf_manager.init(&cf_handles);
 
   if (binlog_manager.init(rdb))
     DBUG_RETURN(1);
 
-  if (ddl_manager.init(rdb))
+  if (ddl_manager.init(rdb, &cf_manager))
     DBUG_RETURN(1);
 
   stop_background_thread = false;
@@ -1855,17 +1855,7 @@ int ha_rocksdb::open(const char *name, int mode, uint test_if_locked)
 
   uint key_len= table->key_info[table->s->primary_key].key_length;
 
-  const char *comment=  table->key_info[table->s->primary_key].comment.str;
-  const char *idx_name= table->key_info[table->s->primary_key].name;
-  rocksdb::ColumnFamilyHandle *cf_handle;
-  bool is_auto_cf;
-  if (!(cf_handle= cf_manager.get_cf(comment, fullname.c_ptr(), idx_name,
-                                     &is_auto_cf)))
-    DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
-
   pk_descr->setup(table);  // move this into get_share() ??
-  pk_descr->set_cf_handle(cf_handle, is_cf_name_reverse(comment),
-                          is_auto_cf);
 
   uint packed_key_len= pk_descr->max_storage_fmt_length();
 
@@ -1880,15 +1870,7 @@ int ha_rocksdb::open(const char *name, int mode, uint test_if_locked)
     if (i == table->s->primary_key) /* Primary key was processed above */
       continue;
 
-    comment= table->key_info[i].comment.str;
-    idx_name= table->key_info[i].name;
-    if (!(cf_handle= cf_manager.get_cf(comment, fullname.c_ptr(), idx_name,
-                                       &is_auto_cf)))
-      DBUG_RETURN(HA_ERR_INTERNAL_ERROR);
-
     key_descr[i]->setup(table);  // move this into get_share() ??
-    key_descr[i]->set_cf_handle(cf_handle, is_cf_name_reverse(comment),
-                                is_auto_cf);
 
     uint packed_len= key_descr[i]->max_storage_fmt_length();
     if (packed_len > max_packed_sec_key_len)

storage/rocksdb/rdb_cf_manager.cc

@@ -45,25 +45,23 @@ bool is_cf_name_reverse(const char *name)
 static PSI_mutex_key ex_key_cfm;
 #endif
 
-void Column_family_manager::init(std::vector<std::string> *names,
-                                 std::vector<rocksdb::ColumnFamilyHandle*> *handles)
+void Column_family_manager::init(std::vector<rocksdb::ColumnFamilyHandle*> *handles)
 {
   mysql_mutex_init(ex_key_cfm, &cfm_mutex, MY_MUTEX_INIT_FAST);
-  DBUG_ASSERT(names->size() == handles->size());
-  DBUG_ASSERT(names->size() > 0);
+  DBUG_ASSERT(handles->size() > 0);
 
   default_cf= (*handles)[0];
-  for (size_t i = 0; i < names->size(); ++i)
-    cf_map[(*names)[i]]= (*handles)[i];
+  for (auto cfh : *handles) {
+    cf_name_map[cfh->GetName()] = cfh;
+    cf_id_map[cfh->GetID()] = cfh;
+  }
 }
 
 
 void Column_family_manager::cleanup()
 {
-  ColumnFamilyHandleMap::iterator it;
-  for (it= cf_map.begin(); it!=cf_map.end(); it++)
-  {
-    delete it->second;
+  for (auto it : cf_name_map) {
+    delete it.second;
   }
   mysql_mutex_destroy(&cfm_mutex);
 }
@@ -98,7 +96,6 @@ Column_family_manager::get_or_create_cf(rocksdb::DB *rdb, const char *cf_name,
                                         bool *is_automatic)
 {
   rocksdb::ColumnFamilyHandle* cf_handle;
-  ColumnFamilyHandleMap::iterator it;
 
   mysql_mutex_lock(&cfm_mutex);
   *is_automatic= false;
@@ -116,7 +113,8 @@ Column_family_manager::get_or_create_cf(rocksdb::DB *rdb, const char *cf_name,
       *is_automatic= true;
     }
 
-    if ((it= cf_map.find(cf_name)) != cf_map.end())
+    auto it = cf_name_map.find(cf_name);
+    if (it != cf_name_map.end())
       cf_handle= it->second;
     else
     {
@@ -131,10 +129,12 @@ Column_family_manager::get_or_create_cf(rocksdb::DB *rdb, const char *cf_name,
                             opts.target_file_size_base);
 
       rocksdb::Status s= rdb->CreateColumnFamily(opts, cf_name_str, &cf_handle);
-      if (s.ok())
-        cf_map[cf_name_str]= cf_handle;
-      else
+      if (s.ok()) {
+        cf_name_map[cf_handle->GetName()] = cf_handle;
+        cf_id_map[cf_handle->GetID()] = cf_handle;
+      } else {
         cf_handle= NULL;
+      }
     }
   }
   mysql_mutex_unlock(&cfm_mutex);
@@ -162,7 +162,6 @@ Column_family_manager::get_cf(const char *cf_name,
                               bool *is_automatic)
 {
   rocksdb::ColumnFamilyHandle* cf_handle;
-  ColumnFamilyHandleMap::iterator it;
 
   *is_automatic= false;
   mysql_mutex_lock(&cfm_mutex);
@@ -178,25 +177,35 @@ Column_family_manager::get_cf(const char *cf_name,
       *is_automatic= true;
     }
 
-    if ((it= cf_map.find(cf_name)) != cf_map.end())
-      cf_handle= it->second;
-    else
-      cf_handle= NULL;
+    auto it = cf_name_map.find(cf_name);
+    cf_handle = (it != cf_name_map.end()) ? it->second : nullptr;
   }
   mysql_mutex_unlock(&cfm_mutex);
 
   return cf_handle;
 }
 
+rocksdb::ColumnFamilyHandle* Column_family_manager::get_cf(uint32_t id)
+{
+  rocksdb::ColumnFamilyHandle* cf_handle = nullptr;
+
+  mysql_mutex_lock(&cfm_mutex);
+  auto it = cf_id_map.find(id);
+  if (it != cf_id_map.end())
+    cf_handle = it->second;
+  mysql_mutex_unlock(&cfm_mutex);
+
+  return cf_handle;
+}
+
 std::vector<std::string>
 Column_family_manager::get_cf_names(void)
 {
   std::vector<std::string> names;
-  ColumnFamilyHandleMap::iterator it;
 
   mysql_mutex_lock(&cfm_mutex);
-  for (it= cf_map.begin(); it != cf_map.end(); it++) {
-    names.push_back(it->first);
+  for (auto it : cf_name_map) {
+    names.push_back(it.first);
   }
   mysql_mutex_unlock(&cfm_mutex);
   return names;

storage/rocksdb/rdb_cf_manager.h

@@ -41,9 +41,8 @@ void get_per_index_cf_name(const char *db_table_name, const char *index_name,
 
 class Column_family_manager
 {
-  typedef std::map<std::string, rocksdb::ColumnFamilyHandle*> ColumnFamilyHandleMap;
-
-  ColumnFamilyHandleMap cf_map;
+  std::map<std::string, rocksdb::ColumnFamilyHandle*> cf_name_map;
+  std::map<uint32_t, rocksdb::ColumnFamilyHandle*> cf_id_map;
 
   rocksdb::ColumnFamilyHandle *default_cf;
 
@@ -53,8 +52,7 @@ class Column_family_manager
     This is called right after the DB::Open() call. The parameters describe column
     families that are present in the database. The first CF is the default CF.
   */
-  void init(std::vector<std::string> *names,
-            std::vector<rocksdb::ColumnFamilyHandle*> *handles);
+  void init(std::vector<rocksdb::ColumnFamilyHandle*> *handles);
   void cleanup();
 
   /*
@@ -74,6 +72,9 @@ class Column_family_manager
                                       const char *index_name,
                                       bool *is_automatic);
 
+  /* Look up cf by id; used by datadic */
+  rocksdb::ColumnFamilyHandle* get_cf(uint32_t);
+
   /* Used to iterate over column families for show status */
   std::vector<std::string> get_cf_names(void);
 

storage/rocksdb/rdb_datadic.cc

@@ -24,6 +24,7 @@
 #include "my_bit.h"
 
 #include "rdb_datadic.h"
+#include "rdb_cf_manager.h"
 
 
 void key_restore(uchar *to_record, uchar *from_key, KEY *key_info,
@@ -36,6 +37,10 @@ void write_int(String *out, uint32 val)
   out->append((char*)&buf, 4);
 }
 
+void write_byte(String *out, uchar val)
+{
+  out->append((char*)&val, 1);
+}
 
 uint32 read_int(char **data)
 {
@@ -45,6 +50,13 @@ uint32 read_int(char **data)
   return ntohl(buf);
 }
 
+uchar read_byte(char **data)
+{
+  uchar buf;
+  memcpy(&buf, *data, sizeof(uchar));
+  *data += sizeof(uchar);
+  return buf;
+}
 
 RDBSE_KEYDEF::~RDBSE_KEYDEF()
 {
@@ -886,16 +898,28 @@ void _rdbse_store_blob_length(uchar *pos,uint pack_length,uint length)
   Write table definition DDL entry.
 
   We write
-    dbname.tablename -> {index_nr, index_nr, index_nr, ... }
+    dbname.tablename -> {key_entry, key_entry, key_entry, ... }
+
+  Where key entries are a tuple of
+    ( index_nr, column_family_id, flags )
 */
 
 void RDBSE_TABLE_DEF::write_to(rocksdb::DB *rdb_dict, uchar *key, size_t keylen)
 {
-  StringBuffer<32> indexes;
+  StringBuffer<8 * RDBSE_KEYDEF::PACKED_SIZE> indexes;
+  indexes.alloc(n_keys * RDBSE_KEYDEF::PACKED_SIZE);
 
   for (uint i=0; i < n_keys; i++)
   {
-    write_int(&indexes, key_descr[i]->index_number);
+    RDBSE_KEYDEF* kd = key_descr[i];
+
+    uchar flags =
+      (kd->is_reverse_cf ? RDBSE_KEYDEF::REVERSE_CF_FLAG : 0) |
+      (kd->is_auto_cf ? RDBSE_KEYDEF::AUTO_CF_FLAG : 0);
+
+    write_int(&indexes, kd->index_number);
+    write_int(&indexes, kd->get_cf()->GetID());
+    write_byte(&indexes, flags);
   }
   rocksdb::Slice skey((char*)key, keylen);
   rocksdb::Slice svalue(indexes.c_ptr(), indexes.length());
@@ -921,7 +945,7 @@ void Table_ddl_manager::free_hash_elem(void* data)
 }
 
 
-bool Table_ddl_manager::init(rocksdb::DB *rdb_dict)
+bool Table_ddl_manager::init(rocksdb::DB *rdb_dict, Column_family_manager *cf_manager)
 {
   mysql_rwlock_init(0, &rwlock);
   (void) my_hash_init(&ddl_hash, /*system_charset_info*/&my_charset_bin, 32,0,0,
@@ -964,19 +988,13 @@ bool Table_ddl_manager::init(rocksdb::DB *rdb_dict)
 
     // Now, read the DDLs.
 
-    if (val.size() < RDBSE_KEYDEF::INDEX_NUMBER_SIZE)
-    {
-      sql_print_error("RocksDB: Table_store: no keys defined in %*s",
-                      (int)key.size(), key.data());
-      return true;
-    }
-    if (val.size() % RDBSE_KEYDEF::INDEX_NUMBER_SIZE)
+    if (val.size() % RDBSE_KEYDEF::PACKED_SIZE)
     {
       sql_print_error("RocksDB: Table_store: invalid keylist for table %s",
                       tdef->dbname_tablename.c_ptr_safe());
       return true;
     }
-    tdef->n_keys= val.size() / RDBSE_KEYDEF::INDEX_NUMBER_SIZE;
+    tdef->n_keys= val.size() / RDBSE_KEYDEF::PACKED_SIZE;
     if (!(tdef->key_descr= new RDBSE_KEYDEF*[tdef->n_keys]))
       return true;
 
@@ -987,14 +1005,20 @@ bool Table_ddl_manager::init(rocksdb::DB *rdb_dict)
     for (uint keyno=0; ptr < ptr_end; keyno++)
     {
       int index_number= read_int(&ptr);
+      int cf_id= read_int(&ptr);
+      uchar flags = read_byte(&ptr);
+
+      rocksdb::ColumnFamilyHandle* cfh = cf_manager->get_cf(cf_id);
+      DBUG_ASSERT(cfh != nullptr);
 
       /*
         We can't fully initialize RDBSE_KEYDEF object here, because full
         initialization requires that there is an open TABLE* where we could
         look at Field* objects and set max_length and other attributes
       */
-      tdef->key_descr[keyno]= new RDBSE_KEYDEF(index_number, keyno, NULL,
-                                               false, false);
+      tdef->key_descr[keyno]= new RDBSE_KEYDEF(index_number, keyno, cfh,
+                                               flags & RDBSE_KEYDEF::REVERSE_CF_FLAG,
+                                               flags & RDBSE_KEYDEF::AUTO_CF_FLAG);
 
       /* Keep track of what was the last index number we saw */
       if (max_number < index_number)

storage/rocksdb/rdb_datadic.h

@@ -16,6 +16,7 @@
 
 class RDBSE_KEYDEF;
 class Field_pack_info;
+class Column_family_manager;
 
 inline void store_index_number(uchar *dst, uint32 number)
 {
@@ -225,11 +226,19 @@ class RDBSE_KEYDEF
     maxlength(0) // means 'not intialized'
   {
     store_index_number(index_number_storage_form, indexnr_arg);
+    DBUG_ASSERT(cf_handle_arg != nullptr);
   }
   ~RDBSE_KEYDEF();
 
   enum {
-    INDEX_NUMBER_SIZE= 4
+    INDEX_NUMBER_SIZE= 4,
+    PACKED_SIZE = 9, // two ints + 1 uchar
+  };
+
+  // bit flags for combining bools when writing to disk
+  enum {
+    REVERSE_CF_FLAG = 1,
+    AUTO_CF_FLAG = 2,
   };
 
   enum {
@@ -239,14 +248,6 @@ class RDBSE_KEYDEF
   };
 
   void setup(TABLE *table);
-  void set_cf_handle(rocksdb::ColumnFamilyHandle* cf_handle_arg,
-                     bool is_reverse_cf_arg,
-                     bool is_auto_cf_arg)
-  {
-    cf_handle= cf_handle_arg;
-    is_reverse_cf= is_reverse_cf_arg;
-    is_auto_cf= is_auto_cf_arg;
-  }
 
   rocksdb::ColumnFamilyHandle *get_cf() { return cf_handle; }
 
@@ -457,7 +458,7 @@ class Table_ddl_manager
 
 public:
   /* Load the data dictionary from on-disk storage */
-  bool init(rocksdb::DB *rdb_dict);
+  bool init(rocksdb::DB *rdb_dict, Column_family_manager *cf_manager);
 
   void cleanup();