Merge from merge-myrocks:

commit 445e518bc7
Author: Sergei Petrunia <psergey@askmonty.org>
Date:   Sat Jan 27 10:18:20 2018 +0000

    Copy of
    commit f8f364b47f2784f16b401f27658f1c16eaf348ec
    Author: Jay Edgar <jkedgar@fb.com>
    Date:   Tue Oct 17 15:19:31 2017 -0700

        Add a hashed, hierarchical, wheel timer implementation

        Summary:
        In order to implement idle timeouts on detached sessions we need something inside MySQL that is lightweight and can handle calling events in the future wi

        By default the timers are grouped into 10ms buckets (the 'hashed' part), though the size of the buckets is configurable at the creation of the timer.  Eac

        Reviewed By: djwatson

        Differential Revision: D6199806

        fbshipit-source-id: 5e1590f

storage/rocksdb/CMakeLists.txt

@@ -178,9 +178,9 @@ IF(HAVE_SCHED_GETCPU)
   ADD_DEFINITIONS(-DHAVE_SCHED_GETCPU=1)
 ENDIF()
 
-IF (NOT "$ENV{WITH_TBB}" STREQUAL "")
+IF (WITH_TBB)
   SET(rocksdb_static_libs ${rocksdb_static_libs}
-  $ENV{WITH_TBB}/libtbb${PIC_EXT}.a)
+  ${WITH_TBB}/lib/libtbb${PIC_EXT}.a)
   ADD_DEFINITIONS(-DTBB)
 ENDIF()
 

storage/rocksdb/build_rocksdb.cmake

@@ -245,6 +245,7 @@ set(ROCKSDB_SOURCES
         table/block_based_table_factory.cc
         table/block_based_table_reader.cc
         table/block_builder.cc
+        table/block_fetcher.cc
         table/block_prefix_index.cc
         table/bloom_block.cc
         table/cuckoo_table_builder.cc
@@ -340,15 +341,16 @@ set(ROCKSDB_SOURCES
         utilities/transactions/optimistic_transaction_db_impl.cc
         utilities/transactions/pessimistic_transaction.cc
         utilities/transactions/pessimistic_transaction_db.cc
+        utilities/transactions/snapshot_checker.cc
         utilities/transactions/transaction_base.cc
         utilities/transactions/transaction_db_mutex_impl.cc
         utilities/transactions/transaction_lock_mgr.cc
         utilities/transactions/transaction_util.cc
         utilities/transactions/write_prepared_txn.cc
+        utilities/transactions/write_prepared_txn_db.cc
         utilities/ttl/db_ttl_impl.cc
         utilities/write_batch_with_index/write_batch_with_index.cc
         utilities/write_batch_with_index/write_batch_with_index_internal.cc
-
 )
 
 if(WIN32)

storage/rocksdb/event_listener.cc

@@ -83,4 +83,14 @@ void Rdb_event_listener::OnExternalFileIngested(
   DBUG_ASSERT(db != nullptr);
   update_index_stats(info.table_properties);
 }
+
+void Rdb_event_listener::OnBackgroundError(
+    rocksdb::BackgroundErrorReason reason, rocksdb::Status *status) {
+  rdb_log_status_error(*status, "Error detected in background");
+  sql_print_error("RocksDB: BackgroundErrorReason: %d", (int)reason);
+  if (status->IsCorruption()) {
+    rdb_persist_corruption_marker();
+    abort();
+  }
+}
 } // namespace myrocks

storage/rocksdb/event_listener.h

@@ -37,6 +37,9 @@ public:
       rocksdb::DB *db,
       const rocksdb::ExternalFileIngestionInfo &ingestion_info) override;
 
+  void OnBackgroundError(rocksdb::BackgroundErrorReason reason,
+                         rocksdb::Status *status) override;
+
 private:
   Rdb_ddl_manager *m_ddl_manager;
 

storage/rocksdb/ha_rocksdb.h

@@ -41,6 +41,7 @@
 
 /* RocksDB header files */
 #include "rocksdb/cache.h"
+#include "rocksdb/merge_operator.h"
 #include "rocksdb/perf_context.h"
 #include "rocksdb/sst_file_manager.h"
 #include "rocksdb/statistics.h"
@@ -92,6 +93,25 @@ struct Rdb_trx_info {
 
 std::vector<Rdb_trx_info> rdb_get_all_trx_info();
 
+/*
+ * class for exporting deadlock transaction information for
+ * information_schema.rocksdb_deadlock
+ */
+struct Rdb_deadlock_info {
+  struct Rdb_dl_trx_info {
+    ulonglong trx_id;
+    std::string cf_name;
+    std::string waiting_key;
+    bool exclusive_lock;
+    std::string index_name;
+    std::string table_name;
+  };
+  std::vector <Rdb_dl_trx_info> path;
+  ulonglong victim_trx_id;
+};
+
+std::vector<Rdb_deadlock_info> rdb_get_deadlock_info();
+
 /*
   This is
   - the name of the default Column Family (the CF which stores indexes which
@@ -250,6 +270,8 @@ enum collations_used {
 */
 #define ROCKSDB_SIZEOF_TTL_RECORD sizeof(longlong)
 
+#define ROCKSDB_SIZEOF_AUTOINC_VALUE sizeof(longlong)
+
 /*
   Maximum index prefix length in bytes.
 */
@@ -367,6 +389,7 @@ enum operation_type : int {
   ROWS_UPDATED,
   ROWS_DELETED_BLIND,
   ROWS_EXPIRED,
+  ROWS_FILTERED,
   ROWS_HIDDEN_NO_SNAPSHOT,
   ROWS_MAX
 };
@@ -400,6 +423,7 @@ struct st_export_stats {
   ulonglong rows_updated;
   ulonglong rows_deleted_blind;
   ulonglong rows_expired;
+  ulonglong rows_filtered;
   ulonglong rows_hidden_no_snapshot;
 
   ulonglong system_rows_deleted;
@@ -538,6 +562,12 @@ class ha_rocksdb : public my_core::handler {
   uchar *m_dup_sk_packed_tuple;
   uchar *m_dup_sk_packed_tuple_old;
 
+  /* Buffers used for passing upper/bound eq conditions. */
+  uchar *m_eq_cond_lower_bound;
+  uchar *m_eq_cond_upper_bound;
+  rocksdb::Slice m_eq_cond_lower_bound_slice;
+  rocksdb::Slice m_eq_cond_upper_bound_slice;
+
   /*
     Temporary space for packing VARCHARs (we provide it to
     pack_record()/pack_index_tuple() calls).
@@ -567,7 +597,7 @@ class ha_rocksdb : public my_core::handler {
     This is used only when we get the record with rocksdb's Get() call (The
     other option is when we get a rocksdb::Slice from an iterator)
   */
-  std::string m_retrieved_record;
+  rocksdb::PinnableSlice m_retrieved_record;
 
   /* Type of locking to apply to rows */
   enum { RDB_LOCK_NONE, RDB_LOCK_READ, RDB_LOCK_WRITE } m_lock_rows;
@@ -600,12 +630,7 @@ class ha_rocksdb : public my_core::handler {
   bool m_update_scope_is_valid;
 
   /* SST information used for bulk loading the primary key */
-  std::unique_ptr<Rdb_sst_info> m_sst_info;
+  std::shared_ptr<Rdb_sst_info> m_sst_info;
-  /* External merge sorts for bulk load: key ID -> merge sort instance */
-  std::unordered_map<GL_INDEX_ID, Rdb_index_merge> m_key_merge;
-  Rdb_transaction *m_bulk_load_tx;
-  /* Mutex to protect finalizing bulk load */
-  mysql_mutex_t m_bulk_load_mutex;
 
   /*
     MySQL index number for duplicate key error
@@ -620,13 +645,17 @@ class ha_rocksdb : public my_core::handler {
   int secondary_index_read(const int keyno, uchar *const buf)
       MY_ATTRIBUTE((__nonnull__, __warn_unused_result__));
   void setup_iterator_for_rnd_scan();
-  void setup_scan_iterator(const Rdb_key_def &kd, rocksdb::Slice *const slice)
-      MY_ATTRIBUTE((__nonnull__)) {
-    setup_scan_iterator(kd, slice, false, 0);
-  }
   bool is_ascending(const Rdb_key_def &keydef,
                     enum ha_rkey_function find_flag) const
       MY_ATTRIBUTE((__nonnull__, __warn_unused_result__));
+  void setup_iterator_bounds(const Rdb_key_def &kd,
+                             const rocksdb::Slice &eq_cond);
+  bool can_use_bloom_filter(THD *thd, const Rdb_key_def &kd,
+                            const rocksdb::Slice &eq_cond,
+                            const bool use_all_keys);
+  bool check_bloom_and_set_bounds(THD *thd, const Rdb_key_def &kd,
+                                  const rocksdb::Slice &eq_cond,
+                                  const bool use_all_keys);
   void setup_scan_iterator(const Rdb_key_def &kd, rocksdb::Slice *slice,
                            const bool use_all_keys, const uint eq_cond_len)
       MY_ATTRIBUTE((__nonnull__));
@@ -635,7 +664,8 @@ class ha_rocksdb : public my_core::handler {
   rocksdb::Status
   get_for_update(Rdb_transaction *const tx,
                  rocksdb::ColumnFamilyHandle *const column_family,
-                 const rocksdb::Slice &key, std::string *const value) const;
+                 const rocksdb::Slice &key,
+                 rocksdb::PinnableSlice *value) const;
 
   int get_row_by_rowid(uchar *const buf, const char *const rowid,
                        const uint rowid_size, const bool skip_lookup = false,
@@ -649,8 +679,13 @@ class ha_rocksdb : public my_core::handler {
                             rowid_size, skip_lookup, skip_ttl_check);
   }
 
-  void update_auto_incr_val();
   void load_auto_incr_value();
+  ulonglong load_auto_incr_value_from_index();
+  void update_auto_incr_val(ulonglong val);
+  void update_auto_incr_val_from_field();
+  rocksdb::Status get_datadic_auto_incr(Rdb_transaction *const tx,
+                                        const GL_INDEX_ID &gl_index_id,
+                                        ulonglong *new_val) const;
   longlong update_hidden_pk_val();
   int load_hidden_pk_value() MY_ATTRIBUTE((__warn_unused_result__));
   int read_hidden_pk_id_from_rowkey(longlong *const hidden_pk_id)
@@ -696,6 +731,12 @@ class ha_rocksdb : public my_core::handler {
   */
   std::vector<READ_FIELD> m_decoders_vect;
 
+  /*
+    This tells if any field which is part of the key needs to be unpacked and
+    decoded.
+   */
+  bool m_key_requested = false;
+
   /* Setup field_decoders based on type of scan and table->read_set */
   void setup_read_decoders();
 
@@ -766,9 +807,12 @@ public:
              my_core::TABLE_SHARE *const table_arg);
   ~ha_rocksdb() {
     int err MY_ATTRIBUTE((__unused__));
-    err = finalize_bulk_load();
+    err = finalize_bulk_load(false);
-    DBUG_ASSERT(err == 0);
+    if (err != 0) {
-    mysql_mutex_destroy(&m_bulk_load_mutex);
+      sql_print_error("RocksDB: Error %d finalizing bulk load while closing "
+                      "handler.",
+                      err);
+    }
   }
 
   /** @brief
@@ -794,10 +838,9 @@ public:
   */
 
   /*
-    See if this is the same base table - this should only be true for different
+    Returns the name of the table's base name
-    partitions of the same table.
   */
-  bool same_table(const ha_rocksdb &other) const;
+  const std::string &get_table_basename() const;
 
   /** @brief
     This is a list of flags that indicate what functionality the storage engine
@@ -1210,8 +1253,6 @@ private:
   Rdb_tbl_def *get_table_if_exists(const char *const tablename)
       MY_ATTRIBUTE((__nonnull__, __warn_unused_result__));
   void read_thd_vars(THD *const thd) MY_ATTRIBUTE((__nonnull__));
-  const char *thd_rocksdb_tmpdir()
-      MY_ATTRIBUTE((__nonnull__, __warn_unused_result__));
 
   bool contains_foreign_key(THD *const thd)
       MY_ATTRIBUTE((__nonnull__, __warn_unused_result__));
@@ -1221,6 +1262,9 @@ private:
       const std::unordered_set<std::shared_ptr<Rdb_key_def>> &indexes)
       MY_ATTRIBUTE((__nonnull__, __warn_unused_result__));
 
+  int finalize_bulk_load(bool print_client_error = true)
+      MY_ATTRIBUTE((__warn_unused_result__));
+
 public:
   int index_init(uint idx, bool sorted) override
       MY_ATTRIBUTE((__warn_unused_result__));
@@ -1264,7 +1308,7 @@ public:
     DBUG_ENTER_FUNC();
 
     /* Free blob data */
-    m_retrieved_record.clear();
+    m_retrieved_record.Reset();
 
     DBUG_RETURN(HA_EXIT_SUCCESS);
   }
@@ -1335,8 +1379,6 @@ public:
                              my_core::Alter_inplace_info *const ha_alter_info,
                              bool commit) override;
 
-  int finalize_bulk_load() MY_ATTRIBUTE((__warn_unused_result__));
-
 #ifdef MARIAROCKS_NOT_YET // MDEV-10976
   void set_use_read_free_rpl(const char *const whitelist);
 #endif
@@ -1391,18 +1433,22 @@ struct Rdb_inplace_alter_ctx : public my_core::inplace_alter_handler_ctx {
   /* Stores number of keys to drop */
   const uint m_n_dropped_keys;
 
+  /* Stores the largest current auto increment value in the index */
+  const ulonglong m_max_auto_incr;
+
   Rdb_inplace_alter_ctx(
       Rdb_tbl_def *new_tdef, std::shared_ptr<Rdb_key_def> *old_key_descr,
       std::shared_ptr<Rdb_key_def> *new_key_descr, uint old_n_keys,
       uint new_n_keys,
       std::unordered_set<std::shared_ptr<Rdb_key_def>> added_indexes,
       std::unordered_set<GL_INDEX_ID> dropped_index_ids, uint n_added_keys,
-      uint n_dropped_keys)
+      uint n_dropped_keys, ulonglong max_auto_incr)
       : my_core::inplace_alter_handler_ctx(), m_new_tdef(new_tdef),
         m_old_key_descr(old_key_descr), m_new_key_descr(new_key_descr),
         m_old_n_keys(old_n_keys), m_new_n_keys(new_n_keys),
         m_added_indexes(added_indexes), m_dropped_index_ids(dropped_index_ids),
-        m_n_added_keys(n_added_keys), m_n_dropped_keys(n_dropped_keys) {}
+        m_n_added_keys(n_added_keys), m_n_dropped_keys(n_dropped_keys),
+        m_max_auto_incr(max_auto_incr) {}
 
   ~Rdb_inplace_alter_ctx() {}
 
@@ -1412,6 +1458,10 @@ private:
   Rdb_inplace_alter_ctx &operator=(const Rdb_inplace_alter_ctx &);
 };
 
+// file name indicating RocksDB data corruption
+std::string rdb_corruption_marker_file_name();
+
 const int MYROCKS_MARIADB_PLUGIN_MATURITY_LEVEL= MariaDB_PLUGIN_MATURITY_BETA;
 
+
 } // namespace myrocks

storage/rocksdb/myrocks_hotbackup

@@ -0,0 +1,686 @@
+#!/usr/bin/env python
+
+from __future__ import division
+from optparse import OptionParser
+import collections
+import signal
+import os
+import stat
+import sys
+import re
+import commands
+import subprocess
+import logging
+import logging.handlers
+import time
+import datetime
+import shutil
+import traceback
+import tempfile
+
+import MySQLdb
+import MySQLdb.connections
+from MySQLdb import OperationalError, ProgrammingError
+
+logger = None
+opts = None
+rocksdb_files = ['MANIFEST', 'CURRENT', 'OPTIONS']
+rocksdb_data_suffix = '.sst'
+rocksdb_wal_suffix = '.log'
+exclude_files = ['master.info', 'relay-log.info', 'worker-relay-log.info',
+                 'auto.cnf', 'gaplock.log', 'ibdata', 'ib_logfile', '.trash']
+wdt_bin = 'wdt'
+
+def is_manifest(fname):
+  for m in rocksdb_files:
+    if fname.startswith(m):
+      return True
+  return False
+
+class Writer(object):
+  a = None
+  def __init__(self):
+    a = None
+
+class StreamWriter(Writer):
+  stream_cmd= ''
+
+  def __init__(self, stream_option):
+    super(StreamWriter, self).__init__()
+    if stream_option == 'tar':
+      self.stream_cmd= 'tar chf -'
+    elif stream_option == 'xbstream':
+      self.stream_cmd= 'xbstream -c'
+    else:
+      raise Exception("Only tar or xbstream is supported as streaming option.")
+
+  def write(self, file_name):
+    rc= os.system(self.stream_cmd + " " + file_name)
+    if (rc != 0):
+      raise Exception("Got error on stream write: " + str(rc) + " " + file_name)
+
+
+class MiscFilesProcessor():
+  datadir = None
+  wildcard = r'.*\.[frm|MYD|MYI|MAD|MAI|MRG|TRG|TRN|ARM|ARZ|CSM|CSV|opt|par]'
+  regex = None
+  start_backup_time = None
+  skip_check_frm_timestamp = None
+
+  def __init__(self, datadir, skip_check_frm_timestamp, start_backup_time):
+    self.datadir = datadir
+    self.regex = re.compile(self.wildcard)
+    self.skip_check_frm_timestamp = skip_check_frm_timestamp
+    self.start_backup_time = start_backup_time
+
+  def process_db(self, db):
+    # do nothing
+    pass
+
+  def process_file(self, path):
+    # do nothing
+    pass
+
+  def check_frm_timestamp(self, fname, path):
+    if not self.skip_check_frm_timestamp and fname.endswith('.frm'):
+      if os.path.getmtime(path) > self.start_backup_time:
+        logger.error('FRM file %s was updated after starting backups. '
+                     'Schema could have changed and the resulting copy may '
+                     'not be valid. Aborting. '
+                     '(backup time: %s, file modifled time: %s)',
+                     path, datetime.datetime.fromtimestamp(self.start_backup_time).strftime('%Y-%m-%d %H:%M:%S'),
+                     datetime.datetime.fromtimestamp(os.path.getmtime(path)).strftime('%Y-%m-%d %H:%M:%S'))
+        raise Exception("Inconsistent frm file timestamp");
+
+  def process(self):
+    os.chdir(self.datadir)
+    for db in self.get_databases():
+      logger.info("Starting MySQL misc file traversal from database %s..", db)
+      self.process_db(db)
+      for f in self.get_files(db):
+        if self.match(f):
+          rel_path = os.path.join(db, f)
+          self.check_frm_timestamp(f, rel_path)
+          self.process_file(rel_path)
+    logger.info("Traversing misc files from data directory..")
+    for f in self.get_files(""):
+      should_skip = False
+      for e in exclude_files:
+        if f.startswith(e) or f.endswith(e):
+          logger.info("Skipping %s", f)
+          should_skip = True
+          break
+      if not should_skip:
+        self.process_file(f)
+
+  def match(self, filename):
+    if self.regex.match(filename):
+      return True
+    else:
+      return False
+
+  def get_databases(self):
+    dbs = []
+    dirs = [ d for d in os.listdir(self.datadir) \
+            if not os.path.isfile(os.path.join(self.datadir,d))]
+    for db in dirs:
+      if not db.startswith('.') and not self._is_socket(db):
+        dbs.append(db)
+    return dbs
+
+  def get_files(self, db):
+    dbdir = self.datadir + "/" + db
+    return [ f for f in os.listdir(dbdir) \
+            if os.path.isfile(os.path.join(dbdir,f))]
+
+  def _is_socket(self, item):
+      mode = os.stat(os.path.join(self.datadir, item)).st_mode
+      if stat.S_ISSOCK(mode):
+        return True
+      return False
+
+
+class MySQLBackup(MiscFilesProcessor):
+  writer = None
+
+  def __init__(self, datadir, writer, skip_check_frm_timestamp, start_backup_time):
+    MiscFilesProcessor.__init__(self, datadir, skip_check_frm_timestamp, start_backup_time)
+    self.writer = writer
+
+  def process_file(self, fname):    # overriding base class
+    self.writer.write(fname)
+
+
+class MiscFilesLinkCreator(MiscFilesProcessor):
+  snapshot_dir = None
+
+  def __init__(self, datadir, snapshot_dir, skip_check_frm_timestamp, start_backup_time):
+    MiscFilesProcessor.__init__(self, datadir, skip_check_frm_timestamp, start_backup_time)
+    self.snapshot_dir = snapshot_dir
+
+  def process_db(self, db):
+    snapshot_sub_dir = os.path.join(self.snapshot_dir, db)
+    os.makedirs(snapshot_sub_dir)
+
+  def process_file(self, path):
+    dst_path = os.path.join(self.snapshot_dir, path)
+    os.link(path, dst_path)
+
+
+# RocksDB backup
+class RocksDBBackup():
+  source_dir = None
+  writer = None
+  # sst files sent in this backup round
+  sent_sst = {}
+  # target sst files in this backup round
+  target_sst = {}
+  # sst files sent in all backup rounds
+  total_sent_sst= {}
+  # sum of sst file size sent in this backup round
+  sent_sst_size = 0
+  # sum of target sst file size in this backup round
+  # if sent_sst_size becomes equal to target_sst_size,
+  # it means the backup round finished backing up all sst files
+  target_sst_size = 0
+  # sum of all sst file size sent all backup rounds
+  total_sent_sst_size= 0
+  # sum of all target sst file size from all backup rounds
+  total_target_sst_size = 0
+  show_progress_size_interval= 1073741824 # 1GB
+  wal_files= []
+  manifest_files= []
+  finished= False
+
+  def __init__(self, source_dir, writer, prev):
+    self.source_dir = source_dir
+    self.writer = writer
+    os.chdir(self.source_dir)
+    self.init_target_files(prev)
+
+  def init_target_files(self, prev):
+    sst = {}
+    self.sent_sst = {}
+    self.target_sst= {}
+    self.total_sent_sst = {}
+    self.sent_sst_size = 0
+    self.target_sst_size = 0
+    self.total_sent_sst_size= 0
+    self.total_target_sst_size= 0
+    self.wal_files= []
+    self.manifest_files= []
+
+    for f in os.listdir(self.source_dir):
+      if f.endswith(rocksdb_data_suffix):
+        # exactly the same file (same size) was sent in previous backup rounds
+        if prev is not None and f in prev.total_sent_sst and int(os.stat(f).st_size) == prev.total_sent_sst[f]:
+          continue
+        sst[f]= int(os.stat(f).st_size)
+        self.target_sst_size = self.target_sst_size + os.stat(f).st_size
+      elif is_manifest(f):
+        self.manifest_files.append(f)
+      elif f.endswith(rocksdb_wal_suffix):
+        self.wal_files.append(f)
+    self.target_sst= collections.OrderedDict(sorted(sst.items()))
+
+    if prev is not None:
+      self.total_sent_sst = prev.total_sent_sst
+      self.total_sent_sst_size = prev.total_sent_sst_size
+      self.total_target_sst_size = self.target_sst_size + prev.total_sent_sst_size
+    else:
+      self.total_target_sst_size = self.target_sst_size
+
+  def do_backup_single(self, fname):
+    self.writer.write(fname)
+    os.remove(fname)
+
+  def do_backup_sst(self, fname, size):
+    self.do_backup_single(fname)
+    self.sent_sst[fname]= size
+    self.total_sent_sst[fname]= size
+    self.sent_sst_size = self.sent_sst_size + size
+    self.total_sent_sst_size = self.total_sent_sst_size + size
+
+  def do_backup_manifest(self):
+    for f in self.manifest_files:
+      self.do_backup_single(f)
+
+  def do_backup_wal(self):
+    for f in self.wal_files:
+      self.do_backup_single(f)
+
+  # this is the last snapshot round. backing up all the rest files
+  def do_backup_final(self):
+    logger.info("Backup WAL..")
+    self.do_backup_wal()
+    logger.info("Backup Manifest..")
+    self.do_backup_manifest()
+    self.do_cleanup()
+    self.finished= True
+
+  def do_cleanup(self):
+    shutil.rmtree(self.source_dir)
+    logger.info("Cleaned up checkpoint from %s", self.source_dir)
+
+  def do_backup_until(self, time_limit):
+    logger.info("Starting backup from snapshot: target files %d", len(self.target_sst))
+    start_time= time.time()
+    last_progress_time= start_time
+    progress_size= 0
+    for fname, size in self.target_sst.iteritems():
+      self.do_backup_sst(fname, size)
+      progress_size= progress_size + size
+      elapsed_seconds = time.time() - start_time
+      progress_seconds = time.time() - last_progress_time
+
+      if self.should_show_progress(size):
+        self.show_progress(progress_size, progress_seconds)
+        progress_size=0
+        last_progress_time= time.time()
+
+      if elapsed_seconds > time_limit and self.has_sent_all_sst() is False:
+        logger.info("Snapshot round finished. Elapsed Time: %5.2f.  Remaining sst files: %d",
+                    elapsed_seconds, len(self.target_sst) - len(self.sent_sst))
+        self.do_cleanup()
+        break;
+    if self.has_sent_all_sst():
+      self.do_backup_final()
+
+    return self
+
+  def should_show_progress(self, size):
+    if int(self.total_sent_sst_size/self.show_progress_size_interval) > int((self.total_sent_sst_size-size)/self.show_progress_size_interval):
+      return True
+    else:
+      return False
+
+  def show_progress(self, size, seconds):
+    logger.info("Backup Progress: %5.2f%%   Sent %6.2f GB of %6.2f GB data, Transfer Speed: %6.2f MB/s",
+                self.total_sent_sst_size*100/self.total_target_sst_size,
+                self.total_sent_sst_size/1024/1024/1024,
+                self.total_target_sst_size/1024/1024/1024,
+                size/seconds/1024/1024)
+
+  def print_backup_report(self):
+    logger.info("Sent %6.2f GB of sst files, %d files in total.",
+                self.total_sent_sst_size/1024/1024/1024,
+                len(self.total_sent_sst))
+
+  def has_sent_all_sst(self):
+    if self.sent_sst_size == self.target_sst_size:
+      return True
+    return False
+
+
+class MySQLUtil:
+  @staticmethod
+  def connect(user, password, port, socket=None):
+    if socket:
+      dbh = MySQLdb.Connect(user=user,
+                            passwd=password,
+                            unix_socket=socket)
+    else:
+      dbh = MySQLdb.Connect(user=user,
+                            passwd=password,
+                            port=port,
+                            host="127.0.0.1")
+    return dbh
+
+  @staticmethod
+  def create_checkpoint(dbh, checkpoint_dir):
+    sql = ("SET GLOBAL rocksdb_create_checkpoint='{0}'"
+           .format(checkpoint_dir))
+    cur= dbh.cursor()
+    cur.execute(sql)
+    cur.close()
+
+  @staticmethod
+  def get_datadir(dbh):
+    sql = "SELECT @@datadir"
+    cur = dbh.cursor()
+    cur.execute(sql)
+    row = cur.fetchone()
+    return row[0]
+
+
+class BackupRunner:
+  datadir = None
+  start_backup_time = None
+
+  def __init__(self, datadir):
+    self.datadir = datadir
+    self.start_backup_time = time.time()
+
+  def start_backup_round(self, backup_round, prev_backup):
+    def signal_handler(*args):
+      logger.info("Got signal. Exit")
+      if b is not None:
+        logger.info("Cleaning up snapshot directory..")
+        b.do_cleanup()
+      sys.exit(1)
+
+    b = None
+    try:
+      signal.signal(signal.SIGINT, signal_handler)
+      w = None
+      if opts.output_stream:
+        w = StreamWriter(opts.output_stream)
+      else:
+        raise Exception("Currently only streaming backup is supported.")
+
+      snapshot_dir = opts.checkpoint_directory + '/' + str(backup_round)
+      dbh = MySQLUtil.connect(opts.mysql_user,
+                              opts.mysql_password,
+                              opts.mysql_port,
+                              opts.mysql_socket)
+      if not self.datadir:
+        self.datadir = MySQLUtil.get_datadir(dbh)
+        logger.info("Set datadir: %s", self.datadir)
+      logger.info("Creating checkpoint at %s", snapshot_dir)
+      MySQLUtil.create_checkpoint(dbh, snapshot_dir)
+      logger.info("Created checkpoint at %s", snapshot_dir)
+      b = RocksDBBackup(snapshot_dir, w, prev_backup)
+      return b.do_backup_until(opts.checkpoint_interval)
+    except Exception as e:
+      logger.error(e)
+      logger.error(traceback.format_exc())
+      if b is not None:
+        logger.info("Cleaning up snapshot directory.")
+        b.do_cleanup()
+      sys.exit(1)
+
+  def backup_mysql(self):
+    try:
+      w = None
+      if opts.output_stream:
+        w = StreamWriter(opts.output_stream)
+      else:
+        raise Exception("Currently only streaming backup is supported.")
+      b = MySQLBackup(self.datadir, w, opts.skip_check_frm_timestamp,
+                      self.start_backup_time)
+      logger.info("Taking MySQL misc backups..")
+      b.process()
+      logger.info("MySQL misc backups done.")
+    except Exception as e:
+      logger.error(e)
+      logger.error(traceback.format_exc())
+      sys.exit(1)
+
+
+class WDTBackup:
+  datadir = None
+  start_backup_time = None
+
+  def __init__(self, datadir):
+    self.datadir = datadir
+    self.start_backup_time = time.time()
+
+  def cleanup(self, snapshot_dir, server_log):
+    if server_log:
+      server_log.seek(0)
+      logger.info("WDT server log:")
+      logger.info(server_log.read())
+      server_log.close()
+    if snapshot_dir:
+      logger.info("Cleaning up snapshot dir %s", snapshot_dir)
+      shutil.rmtree(snapshot_dir)
+
+  def backup_with_timeout(self, backup_round):
+    def signal_handler(*args):
+      logger.info("Got signal. Exit")
+      self.cleanup(snapshot_dir, server_log)
+      sys.exit(1)
+
+    logger.info("Starting backup round %d", backup_round)
+    snapshot_dir = None
+    server_log = None
+    try:
+      signal.signal(signal.SIGINT, signal_handler)
+      # create rocksdb snapshot
+      snapshot_dir = os.path.join(opts.checkpoint_directory, str(backup_round))
+      dbh = MySQLUtil.connect(opts.mysql_user,
+                              opts.mysql_password,
+                              opts.mysql_port,
+                              opts.mysql_socket)
+      logger.info("Creating checkpoint at %s", snapshot_dir)
+      MySQLUtil.create_checkpoint(dbh, snapshot_dir)
+      logger.info("Created checkpoint at %s", snapshot_dir)
+
+      # get datadir if not provided
+      if not self.datadir:
+        self.datadir = MySQLUtil.get_datadir(dbh)
+        logger.info("Set datadir: %s", self.datadir)
+
+      # create links for misc files
+      link_creator = MiscFilesLinkCreator(self.datadir, snapshot_dir,
+                                          opts.skip_check_frm_timestamp,
+                                          self.start_backup_time)
+      link_creator.process()
+
+      current_path = os.path.join(opts.backupdir, "CURRENT")
+
+      # construct receiver cmd, using the data directory as recovery-id.
+      # we delete the current file because it is not append-only, therefore not
+      # resumable.
+      remote_cmd = (
+                "ssh {0} rm -f {1}; "
+                "{2} -directory {3} -enable_download_resumption "
+                "-recovery_id {4} -start_port 0 -abort_after_seconds {5} {6}"
+          ).format(opts.destination,
+                   current_path,
+                   wdt_bin,
+                   opts.backupdir,
+                   self.datadir,
+                   opts.checkpoint_interval,
+                   opts.extra_wdt_receiver_options)
+      logger.info("WDT remote cmd %s", remote_cmd)
+      server_log = tempfile.TemporaryFile()
+      remote_process = subprocess.Popen(remote_cmd.split(),
+                                        stdout=subprocess.PIPE,
+                                        stderr=server_log)
+      wdt_url = remote_process.stdout.readline().strip()
+      if not wdt_url:
+        raise Exception("Unable to get connection url from wdt receiver")
+      sender_cmd = (
+                "{0} -connection_url \'{1}\' -directory {2} -app_name=myrocks "
+                "-avg_mbytes_per_sec {3} "
+                "-enable_download_resumption -abort_after_seconds {4} {5}"
+          ).format(wdt_bin,
+                   wdt_url,
+                   snapshot_dir,
+                   opts.avg_mbytes_per_sec,
+                   opts.checkpoint_interval,
+                   opts.extra_wdt_sender_options)
+      sender_status = os.system(sender_cmd) >> 8
+      remote_status = remote_process.wait()
+      self.cleanup(snapshot_dir, server_log)
+      # TODO: handle retryable and non-retyable errors differently
+      return (sender_status == 0 and remote_status == 0)
+
+    except Exception as e:
+      logger.error(e)
+      logger.error(traceback.format_exc())
+      self.cleanup(snapshot_dir, server_log)
+      sys.exit(1)
+
+
+def backup_using_wdt():
+  if not opts.destination:
+    logger.error("Must provide remote destination when using WDT")
+    sys.exit(1)
+
+  # TODO: detect whether WDT is installed
+  logger.info("Backing up myrocks to %s using WDT", opts.destination)
+  wdt_backup = WDTBackup(opts.datadir)
+  finished = False
+  backup_round = 1
+  while not finished:
+    start_time = time.time()
+    finished = wdt_backup.backup_with_timeout(backup_round)
+    end_time = time.time()
+    duration_seconds = end_time - start_time
+    if (not finished) and (duration_seconds < opts.checkpoint_interval):
+      # round finished before timeout
+      sleep_duration = (opts.checkpoint_interval - duration_seconds)
+      logger.info("Sleeping for %f seconds", sleep_duration)
+      time.sleep(sleep_duration)
+
+    backup_round = backup_round + 1
+  logger.info("Finished myrocks backup using WDT")
+
+
+def init_logger():
+  global logger
+  logger = logging.getLogger('myrocks_hotbackup')
+  logger.setLevel(logging.INFO)
+  h1= logging.StreamHandler(sys.stderr)
+  f = logging.Formatter("%(asctime)s.%(msecs)03d %(levelname)s %(message)s",
+                        "%Y-%m-%d %H:%M:%S")
+  h1.setFormatter(f)
+  logger.addHandler(h1)
+
+backup_wdt_usage = ("Backup using WDT: myrocks_hotbackup "
+                "--user=root --password=pw --stream=wdt "
+                "--checkpoint_dir=<directory where temporary backup hard links "
+                "are created> --destination=<remote host name> --backup_dir="
+                "<remote directory name>. This has to be executed at the src "
+                "host.")
+backup_usage= "Backup: set -o pipefail; myrocks_hotbackup --user=root --password=pw --port=3306 --checkpoint_dir=<directory where temporary backup hard links are created> | ssh -o NoneEnabled=yes remote_server 'tar -xi -C <directory on remote server where backups will be sent>' . You need to execute backup command on a server where you take backups."
+move_back_usage= "Move-Back: myrocks_hotbackup --move_back --datadir=<dest mysql datadir> --rocksdb_datadir=<dest rocksdb datadir> --rocksdb_waldir=<dest rocksdb wal dir> --backup_dir=<where backup files are stored> . You need to execute move-back command on a server where backup files are sent."
+
+
+def parse_options():
+  global opts
+  parser = OptionParser(usage = "\n\n" + backup_usage + "\n\n" + \
+          backup_wdt_usage + "\n\n" + move_back_usage)
+  parser.add_option('-i', '--interval', type='int', dest='checkpoint_interval',
+                    default=300,
+                    help='Number of seconds to renew checkpoint')
+  parser.add_option('-c', '--checkpoint_dir', type='string', dest='checkpoint_directory',
+                    default='/data/mysql/backup/snapshot',
+                    help='Local directory name where checkpoints will be created.')
+  parser.add_option('-d', '--datadir', type='string', dest='datadir',
+                    default=None,
+                    help='backup mode: src MySQL datadir. move_back mode: dest MySQL datadir')
+  parser.add_option('-s', '--stream', type='string', dest='output_stream',
+                    default='tar',
+                    help='Setting streaming backup options. Currently tar, WDT '
+                    'and xbstream are supported. Default is tar')
+  parser.add_option('--destination', type='string', dest='destination',
+                    default='',
+                    help='Remote server name. Only used for WDT mode so far.')
+  parser.add_option('--avg_mbytes_per_sec', type='int',
+                    dest='avg_mbytes_per_sec',
+                    default=500,
+                    help='Average backup rate in MBytes/sec. WDT only.')
+  parser.add_option('--extra_wdt_sender_options', type='string',
+                    dest='extra_wdt_sender_options',
+                    default='',
+                    help='Extra options for WDT sender')
+  parser.add_option('--extra_wdt_receiver_options', type='string',
+                    dest='extra_wdt_receiver_options',
+                    default='',
+                    help='Extra options for WDT receiver')
+  parser.add_option('-u', '--user', type='string', dest='mysql_user',
+                    default='root',
+                    help='MySQL user name')
+  parser.add_option('-p', '--password', type='string', dest='mysql_password',
+                    default='',
+                    help='MySQL password name')
+  parser.add_option('-P', '--port', type='int', dest='mysql_port',
+                    default=3306,
+                    help='MySQL port number')
+  parser.add_option('-S', '--socket', type='string', dest='mysql_socket',
+                    default=None,
+                    help='MySQL socket path. Takes precedence over --port.')
+  parser.add_option('-m', '--move_back', action='store_true', dest='move_back',
+                    default=False,
+                    help='Moving MyRocks backup files to proper locations.')
+  parser.add_option('-r', '--rocksdb_datadir', type='string', dest='rocksdb_datadir',
+                    default=None,
+                    help='RocksDB target data directory where backup data files will be moved. Must be empty.')
+  parser.add_option('-w', '--rocksdb_waldir', type='string', dest='rocksdb_waldir',
+                    default=None,
+                    help='RocksDB target data directory where backup wal files will be moved. Must be empty.')
+  parser.add_option('-b', '--backup_dir', type='string', dest='backupdir',
+                    default=None,
+                    help='backup mode for WDT: Remote directory to store '
+                    'backup. move_back mode: Locations where backup '
+                    'files are stored.')
+  parser.add_option('-f', '--skip_check_frm_timestamp',
+                    dest='skip_check_frm_timestamp',
+                    action='store_true', default=False,
+                    help='skipping to check if frm files are updated after starting backup.')
+  parser.add_option('-D', '--debug_signal_file', type='string', dest='debug_signal_file',
+                    default=None,
+                    help='debugging purpose: waiting until the specified file is created')
+
+  opts, args = parser.parse_args()
+
+
+def create_moveback_dir(directory):
+  if not os.path.exists(directory):
+    os.makedirs(directory)
+  else:
+    for f in os.listdir(directory):
+      logger.error("Directory %s has file or directory %s!", directory, f)
+      raise
+
+def print_move_back_usage():
+  logger.warning(move_back_usage)
+
+def move_back():
+  if opts.rocksdb_datadir is None or opts.rocksdb_waldir is None or opts.backupdir is None or opts.datadir is None:
+    print_move_back_usage()
+    sys.exit()
+  create_moveback_dir(opts.datadir)
+  create_moveback_dir(opts.rocksdb_datadir)
+  create_moveback_dir(opts.rocksdb_waldir)
+
+  os.chdir(opts.backupdir)
+  for f in os.listdir(opts.backupdir):
+    if os.path.isfile(os.path.join(opts.backupdir,f)):
+      if f.endswith(rocksdb_wal_suffix):
+        shutil.move(f, opts.rocksdb_waldir)
+      elif f.endswith(rocksdb_data_suffix) or is_manifest(f):
+        shutil.move(f, opts.rocksdb_datadir)
+      else:
+        shutil.move(f, opts.datadir)
+    else: #directory
+      if f.endswith('.rocksdb'):
+        continue
+      shutil.move(f, opts.datadir)
+
+def start_backup():
+  logger.info("Starting backup.")
+  runner = BackupRunner(opts.datadir)
+  b = None
+  backup_round= 1
+  while True:
+    b = runner.start_backup_round(backup_round, b)
+    backup_round = backup_round + 1
+    if b.finished is True:
+      b.print_backup_report()
+      logger.info("RocksDB Backup Done.")
+      break
+  if opts.debug_signal_file:
+    while not os.path.exists(opts.debug_signal_file):
+      logger.info("Waiting until %s is created..", opts.debug_signal_file)
+      time.sleep(1)
+  runner.backup_mysql()
+  logger.info("All Backups Done.")
+
+
+def main():
+  parse_options()
+  init_logger()
+
+  if opts.move_back is True:
+    move_back()
+  elif opts.output_stream == 'wdt':
+    backup_using_wdt()
+  else:
+    start_backup()
+
+if __name__ == "__main__":
+  main()

storage/rocksdb/mysql-test/rocksdb/include/autoinc_crash_safe.inc

@@ -0,0 +1,150 @@
+--echo #
+--echo # Testing concurrent transactions.
+--echo #
+
+--source include/count_sessions.inc
+connect (con1,localhost,root,,);
+connect (con2,localhost,root,,);
+connect (con3,localhost,root,,);
+
+connection con1;
+begin;
+insert into t values (); # 1
+
+connection con2;
+begin;
+insert into t values (); # 2
+
+connection con3;
+begin;
+insert into t values (); # 3
+
+connection con1;
+insert into t values (); # 4
+
+connection con2;
+insert into t values (); # 5
+
+connection con3;
+insert into t values (); # 6
+
+connection con2;
+commit;
+
+connection con3;
+rollback;
+
+connection con1;
+commit;
+
+delete from t;
+
+--echo # Master value before restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--echo # Slave value before restart
+sync_slave_with_master;
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+connection slave;
+--source include/stop_slave.inc
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+
+connection default;
+--echo # Master value after restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--let $rpl_server_number = 2
+--source include/rpl_restart_server.inc
+
+connection slave;
+--source include/start_slave.inc
+--echo # Slave value after restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+disconnect con1;
+disconnect con2;
+disconnect con3;
+--source include/wait_until_count_sessions.inc
+
+--echo #
+--echo # Testing interaction of merge markers with various DDL statements.
+--echo #
+connection slave;
+--source include/stop_slave.inc
+
+connection default;
+
+--echo # Drop and add primary key.
+alter table t modify i int;
+alter table t drop primary key;
+alter table t add primary key (i);
+alter table t modify i int auto_increment;
+
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--echo # Remove auto_increment property.
+alter table t modify i int;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--echo # Add auto_increment property.
+insert into t values (123);
+alter table t modify i int auto_increment;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--echo # Add column j.
+alter table t add column j int;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--echo # Rename tables.
+rename table t to t2;
+rename table t2 to t;
+
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--echo # Change auto_increment property
+alter table t auto_increment = 1000;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+alter table t auto_increment = 1;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+alter table t drop primary key, add key (i), auto_increment = 1;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+alter table t add key (j), auto_increment = 1;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+alter table t modify i int;
+alter table t add column (k int auto_increment), add key(k), auto_increment=15;
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+
+--echo # Drop table.
+drop table t;
+
+--let $rpl_server_number = 1
+--source include/rpl_restart_server.inc
+
+connection slave;
+--source include/start_slave.inc

storage/rocksdb/mysql-test/rocksdb/include/bulk_load.inc

@@ -1,6 +1,4 @@
---disable_warnings
+--source include/count_sessions.inc
-DROP TABLE IF EXISTS t1, t2, t3;
---enable_warnings
 
 if ($data_order_desc)
 {
@@ -20,7 +18,7 @@ eval CREATE TABLE t1(
   b CHAR(30),
   PRIMARY KEY(pk) COMMENT "$pk_cf",
   KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 
 # Create a second identical table to validate that bulk loading different
 # tables in the same session works
@@ -30,7 +28,7 @@ eval CREATE TABLE t2(
   b CHAR(30),
   PRIMARY KEY(pk) COMMENT "$pk_cf",
   KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 
 # Create a third table using partitions to validate that bulk loading works
 # across a partitioned table
@@ -40,7 +38,7 @@ eval CREATE TABLE t3(
   b CHAR(30),
   PRIMARY KEY(pk) COMMENT "$pk_cf",
   KEY(a)
-) COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
+) ENGINE=ROCKSDB COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
 
 --let $file = `SELECT CONCAT(@@datadir, "test_loadfile.txt")`
 
@@ -154,3 +152,5 @@ EOF
 # Cleanup
 disconnect other;
 DROP TABLE t1, t2, t3;
+
+--source include/wait_until_count_sessions.inc

storage/rocksdb/mysql-test/rocksdb/include/bulk_load_unsorted.inc

@@ -0,0 +1,143 @@
+--source include/count_sessions.inc
+
+SET rocksdb_bulk_load_size=3;
+SET rocksdb_bulk_load_allow_unsorted=1;
+
+### Test individual INSERTs ###
+
+# A table with only a PK won't have rows until the bulk load is finished
+eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf")
+     ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+--disable_query_log
+let $sign = 1;
+let $max = 5;
+let $i = 1;
+while ($i <= $max) {
+  let $a = 1 + $sign * $i;
+  let $b = 1 - $sign * $i;
+  let $sign = -$sign;
+  let $insert = INSERT INTO t1 VALUES ($a, $b);
+  eval $insert;
+  inc $i;
+}
+--enable_query_log
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+SET rocksdb_bulk_load=0;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+DROP TABLE t1;
+
+# A table with a PK and a SK shows rows immediately
+eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf", KEY(b))
+     ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+--disable_query_log
+let $sign = 1;
+let $max = 5;
+let $i = 1;
+while ($i <= $max) {
+  let $a = 1 + $sign * $i;
+  let $b = 1 - $sign * $i;
+  let $sign = -$sign;
+  let $insert = INSERT INTO t1 VALUES ($a, $b);
+  eval $insert;
+  inc $i;
+}
+--enable_query_log
+
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+SET rocksdb_bulk_load=0;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+DROP TABLE t1;
+
+# Inserting into another table finishes bulk load to the previous table
+eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf")
+     ENGINE=ROCKSDB;
+eval CREATE TABLE t2(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf")
+     ENGINE=ROCKSDB;
+
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t2 VALUES (1,1);
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+INSERT INTO t1 VALUES (2,2);
+SELECT * FROM t2 FORCE INDEX (PRIMARY);
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+SET rocksdb_bulk_load=0;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+DROP TABLE t1, t2;
+
+### Test bulk load from a file ###
+eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf")
+     ENGINE=ROCKSDB;
+eval CREATE TABLE t2(a INT, b INT, PRIMARY KEY(b) COMMENT "$pk_cf")
+     ENGINE=ROCKSDB;
+eval CREATE TABLE t3(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf")
+     ENGINE=ROCKSDB PARTITION BY KEY() PARTITIONS 4;
+
+--let $file = `SELECT CONCAT(@@datadir, "test_loadfile.txt")`
+# Create a text file with data to import into the table.
+# PK and SK are not in any order
+--let ROCKSDB_INFILE = $file
+perl;
+my $fn = $ENV{'ROCKSDB_INFILE'};
+open(my $fh, '>', $fn) || die "perl open($fn): $!";
+my $max = 5000000;
+my $sign = 1;
+for (my $ii = 0; $ii < $max; $ii++)
+{
+  my $a = 1 + $sign * $ii;
+  my $b = 1 - $sign * $ii;
+  $sign = -$sign;
+  print $fh "$a\t$b\n";
+}
+close($fh);
+EOF
+--file_exists $file
+
+# Make sure a snapshot held by another user doesn't block the bulk load
+connect (other,localhost,root,,);
+set session transaction isolation level repeatable read;
+select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';
+start transaction with consistent snapshot;
+select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';
+
+connection default;
+set rocksdb_bulk_load=1;
+set rocksdb_bulk_load_size=100000;
+--disable_query_log
+--echo LOAD DATA INFILE <input_file> INTO TABLE t1;
+eval LOAD DATA INFILE '$file' INTO TABLE t1;
+--echo LOAD DATA INFILE <input_file> INTO TABLE t2;
+eval LOAD DATA INFILE '$file' INTO TABLE t2;
+--echo LOAD DATA INFILE <input_file> INTO TABLE t3;
+eval LOAD DATA INFILE '$file' INTO TABLE t3;
+--enable_query_log
+set rocksdb_bulk_load=0;
+
+--remove_file $file
+
+# Make sure row count index stats are correct
+--replace_column 6 # 7 # 8 # 9 #
+SHOW TABLE STATUS WHERE name LIKE 't%';
+
+ANALYZE TABLE t1, t2, t3;
+
+--replace_column 6 # 7 # 8 # 9 #
+SHOW TABLE STATUS WHERE name LIKE 't%';
+
+# Make sure all the data is there.
+select count(a) from t1;
+select count(b) from t1;
+select count(a) from t2;
+select count(b) from t2;
+select count(a) from t3;
+select count(b) from t3;
+
+SELECT * FROM t1 FORCE INDEX (PRIMARY) LIMIT 3;
+SELECT * FROM t2 FORCE INDEX (PRIMARY) LIMIT 3;
+
+disconnect other;
+DROP TABLE t1, t2, t3;
+
+--source include/wait_until_count_sessions.inc

storage/rocksdb/mysql-test/rocksdb/r/add_index_inplace_sstfilewriter.result

@@ -15,6 +15,10 @@ count(b)
 300000
 ALTER TABLE t1 ADD INDEX kb(b), ALGORITHM=INPLACE;
 ALTER TABLE t1 ADD INDEX kb_copy(b), ALGORITHM=COPY;
+ERROR HY000: Status error 10 received from RocksDB: Operation aborted: Failed to acquire lock due to max_num_locks limit
+set session rocksdb_bulk_load=1;
+ALTER TABLE t1 ADD INDEX kb_copy(b), ALGORITHM=COPY;
+set session rocksdb_bulk_load=0;
 SELECT COUNT(*) as c FROM
 (SELECT COALESCE(LOWER(CONV(BIT_XOR(CAST(CRC32(CONCAT_WS('#', `b`, CONCAT(ISNULL(`b`)))) AS UNSIGNED)), 10, 16)), 0) AS crc FROM `t1` FORCE INDEX(`kb`)
 UNION DISTINCT

storage/rocksdb/mysql-test/rocksdb/r/allow_no_primary_key_with_sk.result

@@ -778,3 +778,20 @@ set global rocksdb_force_flush_memtable_now = true;
 select * from t1;
 col1	col2	extra
 DROP TABLE t1;
+create table t1 (i int auto_increment, key(i)) engine=rocksdb;
+insert into t1 values();
+insert into t1 values();
+insert into t1 values();
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `i` int(11) NOT NULL AUTO_INCREMENT,
+  KEY `i` (`i`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=4 DEFAULT CHARSET=latin1
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `i` int(11) NOT NULL AUTO_INCREMENT,
+  KEY `i` (`i`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=4 DEFAULT CHARSET=latin1
+drop table t1;

storage/rocksdb/mysql-test/rocksdb/r/allow_to_start_after_corruption.result

@@ -0,0 +1,35 @@
+#
+#  Test how MyRocks behaves when RocksDB reports corrupted data.
+#
+#
+#  Test server crashes on corrupted data and restarts
+#
+create table t1 (
+pk int not null primary key,
+col1 varchar(10)
+) engine=rocksdb;
+insert into t1 values (1,1),(2,2),(3,3);
+select * from t1 where pk=1;
+pk	col1
+1	1
+set session debug= "+d,rocksdb_return_status_corrupted";
+select * from t1 where pk=1;
+ERROR HY000: Lost connection to MySQL server during query
+#
+#  The same for scan queries
+#
+select * from t1;
+pk	col1
+1	1
+2	2
+3	3
+set session debug= "+d,rocksdb_return_status_corrupted";
+select * from t1;
+ERROR HY000: Lost connection to MySQL server during query
+#
+#  Test restart failure. The server is shutdown at this point.
+#
+#
+#  Remove corruption file and restart cleanly
+#
+drop table t1;

storage/rocksdb/mysql-test/rocksdb/r/autoinc_crash_safe.result

@@ -0,0 +1,113 @@
+include/master-slave.inc
+Warnings:
+Note	####	Sending passwords in plain text without SSL/TLS is extremely insecure.
+Note	####	Storing MySQL user name or password information in the master info repository is not secure and is therefore not recommended. Please consider using the USER and PASSWORD connection options for START SLAVE; see the 'START SLAVE Syntax' in the MySQL Manual for more information.
+[connection master]
+create table t (i int primary key auto_increment) engine=rocksdb;
+#
+# Testing concurrent transactions.
+#
+begin;
+insert into t values ();
+begin;
+insert into t values ();
+begin;
+insert into t values ();
+insert into t values ();
+insert into t values ();
+insert into t values ();
+commit;
+rollback;
+commit;
+delete from t;
+# Master value before restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	7
+# Slave value before restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+include/stop_slave.inc
+include/rpl_restart_server.inc [server_number=1]
+# Master value after restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+include/rpl_restart_server.inc [server_number=2]
+include/start_slave.inc
+# Slave value after restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+#
+# Testing interaction of merge markers with various DDL statements.
+#
+include/stop_slave.inc
+# Drop and add primary key.
+alter table t modify i int;
+alter table t drop primary key;
+alter table t add primary key (i);
+alter table t modify i int auto_increment;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+# Remove auto_increment property.
+alter table t modify i int;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	NULL
+# Add auto_increment property.
+insert into t values (123);
+alter table t modify i int auto_increment;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+# Add column j.
+alter table t add column j int;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+# Rename tables.
+rename table t to t2;
+rename table t2 to t;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+# Change auto_increment property
+alter table t auto_increment = 1000;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	1000
+alter table t auto_increment = 1;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+alter table t drop primary key, add key (i), auto_increment = 1;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+alter table t add key (j), auto_increment = 1;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+alter table t modify i int;
+alter table t add column (k int auto_increment), add key(k), auto_increment=15;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	16
+# Drop table.
+drop table t;
+include/rpl_restart_server.inc [server_number=1]
+include/start_slave.inc
+include/rpl_end.inc

storage/rocksdb/mysql-test/rocksdb/r/autoinc_crash_safe_partition.result

@@ -0,0 +1,113 @@
+include/master-slave.inc
+Warnings:
+Note	####	Sending passwords in plain text without SSL/TLS is extremely insecure.
+Note	####	Storing MySQL user name or password information in the master info repository is not secure and is therefore not recommended. Please consider using the USER and PASSWORD connection options for START SLAVE; see the 'START SLAVE Syntax' in the MySQL Manual for more information.
+[connection master]
+create table t (i int primary key auto_increment) engine=rocksdb partition by key (i) partitions 3;
+#
+# Testing concurrent transactions.
+#
+begin;
+insert into t values ();
+begin;
+insert into t values ();
+begin;
+insert into t values ();
+insert into t values ();
+insert into t values ();
+insert into t values ();
+commit;
+rollback;
+commit;
+delete from t;
+# Master value before restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	7
+# Slave value before restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+include/stop_slave.inc
+include/rpl_restart_server.inc [server_number=1]
+# Master value after restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+include/rpl_restart_server.inc [server_number=2]
+include/start_slave.inc
+# Slave value after restart
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+#
+# Testing interaction of merge markers with various DDL statements.
+#
+include/stop_slave.inc
+# Drop and add primary key.
+alter table t modify i int;
+alter table t drop primary key;
+alter table t add primary key (i);
+alter table t modify i int auto_increment;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	1
+# Remove auto_increment property.
+alter table t modify i int;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	NULL
+# Add auto_increment property.
+insert into t values (123);
+alter table t modify i int auto_increment;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+# Add column j.
+alter table t add column j int;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+# Rename tables.
+rename table t to t2;
+rename table t2 to t;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+# Change auto_increment property
+alter table t auto_increment = 1000;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	1000
+alter table t auto_increment = 1;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+alter table t drop primary key, add key (i), auto_increment = 1;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+alter table t add key (j), auto_increment = 1;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	124
+alter table t modify i int;
+alter table t add column (k int auto_increment), add key(k), auto_increment=15;
+include/rpl_restart_server.inc [server_number=1]
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	16
+# Drop table.
+drop table t;
+include/rpl_restart_server.inc [server_number=1]
+include/start_slave.inc
+include/rpl_end.inc

storage/rocksdb/mysql-test/rocksdb/r/autoinc_debug.result

@@ -0,0 +1,107 @@
+#
+# Testing upgrading from server without merges for auto_increment
+# to new server with such support.
+#
+set debug='+d,myrocks_autoinc_upgrade';
+create table t (i int primary key auto_increment);
+insert into t values ();
+insert into t values ();
+insert into t values ();
+select * from t;
+i
+1
+2
+3
+delete from t where i > 1;
+select * from t;
+i
+1
+select table_name, index_name, auto_increment
+from information_schema.rocksdb_ddl where table_name = 't';
+table_name	index_name	auto_increment
+t	PRIMARY	NULL
+set debug='-d,myrocks_autoinc_upgrade';
+insert into t values ();
+insert into t values ();
+insert into t values ();
+select * from t;
+i
+1
+2
+3
+4
+select table_name, index_name, auto_increment
+from information_schema.rocksdb_ddl where table_name = 't';
+table_name	index_name	auto_increment
+t	PRIMARY	5
+delete from t where i > 1;
+insert into t values ();
+insert into t values ();
+insert into t values ();
+select * from t;
+i
+1
+5
+6
+7
+drop table t;
+#
+# Testing crash safety of transactions.
+#
+create table t (i int primary key auto_increment);
+insert into t values ();
+insert into t values ();
+insert into t values ();
+# Before anything
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_before";
+commit;
+ERROR HY000: Lost connection to MySQL server during query
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	4
+select max(i) from t;
+max(i)
+3
+# After engine prepare
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_after_prepare";
+commit;
+ERROR HY000: Lost connection to MySQL server during query
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	4
+select max(i) from t;
+max(i)
+3
+# After binlog
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_after_log";
+commit;
+ERROR HY000: Lost connection to MySQL server during query
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	6
+select max(i) from t;
+max(i)
+5
+# After everything
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_after";
+commit;
+ERROR HY000: Lost connection to MySQL server during query
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+table_schema	table_name	auto_increment
+test	t	8
+select max(i) from t;
+max(i)
+7
+drop table t;

storage/rocksdb/mysql-test/rocksdb/r/autoinc_vars.result

@@ -61,3 +61,82 @@ LAST_INSERT_ID()
 SELECT a FROM t1 ORDER BY a;
 a
 DROP TABLE t1;
+#---------------------------
+# test large autoincrement values
+#---------------------------
+SET auto_increment_increment = 1;
+SET auto_increment_offset = 1;
+CREATE TABLE t1 (a BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, b CHAR(8)) ENGINE=rocksdb;
+INSERT INTO t1 VALUES (18446744073709551613, 'a');
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+  `b` char(8) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=18446744073709551614 DEFAULT CHARSET=latin1
+INSERT INTO t1 VALUES (NULL, 'b');
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+  `b` char(8) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=18446744073709551615 DEFAULT CHARSET=latin1
+INSERT INTO t1 VALUES (NULL, 'c');
+ERROR HY000: Failed to read auto-increment value from storage engine
+SELECT * FROM t1;
+a	b
+18446744073709551613	a
+18446744073709551614	b
+DROP TABLE t1;
+SET auto_increment_increment = 300;
+CREATE TABLE t1 (a BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, b CHAR(8)) ENGINE=rocksdb;
+INSERT INTO t1 VALUES (18446744073709551613, 'a');
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+  `b` char(8) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=18446744073709551614 DEFAULT CHARSET=latin1
+INSERT INTO t1 VALUES (NULL, 'b');
+ERROR HY000: Failed to read auto-increment value from storage engine
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+  `b` char(8) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=18446744073709551615 DEFAULT CHARSET=latin1
+INSERT INTO t1 VALUES (NULL, 'c');
+ERROR HY000: Failed to read auto-increment value from storage engine
+SELECT * FROM t1;
+a	b
+18446744073709551613	a
+DROP TABLE t1;
+SET auto_increment_offset = 200;
+CREATE TABLE t1 (a BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, b CHAR(8)) ENGINE=rocksdb;
+INSERT INTO t1 VALUES (18446744073709551613, 'a');
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+  `b` char(8) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=18446744073709551614 DEFAULT CHARSET=latin1
+INSERT INTO t1 VALUES (NULL, 'b');
+ERROR HY000: Failed to read auto-increment value from storage engine
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+  `b` char(8) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=ROCKSDB AUTO_INCREMENT=18446744073709551615 DEFAULT CHARSET=latin1
+INSERT INTO t1 VALUES (NULL, 'c');
+ERROR HY000: Failed to read auto-increment value from storage engine
+SELECT * FROM t1;
+a	b
+18446744073709551613	a
+DROP TABLE t1;

storage/rocksdb/mysql-test/rocksdb/r/autoincrement.result

@@ -1 +0,0 @@
-# The test checks AUTO_INCREMENT capabilities that are not supported by RocksDB-SE.

storage/rocksdb/mysql-test/rocksdb/r/bulk_load.result

@@ -1,4 +1,3 @@
-DROP TABLE IF EXISTS t1, t2, t3;
 Data will be ordered in ascending order
 CREATE TABLE t1(
 pk CHAR(5),
@@ -6,21 +5,21 @@ a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t2(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t3(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "cf1",
 KEY(a)
-) COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
+) ENGINE=ROCKSDB COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
 connect  other,localhost,root,,;
 set session transaction isolation level repeatable read;
 select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';

storage/rocksdb/mysql-test/rocksdb/r/bulk_load_drop_table.result

@@ -0,0 +1,8 @@
+CREATE TABLE t1 (pk INT, PRIMARY KEY (pk)) ENGINE=ROCKSDB;
+SET rocksdb_bulk_load_allow_unsorted=1;
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES (1);
+DROP TABLE t1;
+SET rocksdb_bulk_load=0;
+SELECT * FROM t1;
+ERROR 42S02: Table 'test.t1' doesn't exist

storage/rocksdb/mysql-test/rocksdb/r/bulk_load_errors.result

@@ -1,4 +1,4 @@
-CREATE TABLE t1(pk INT, PRIMARY KEY(pk));
+CREATE TABLE t1(pk INT, PRIMARY KEY(pk)) ENGINE=ROCKSDB;
 SET rocksdb_bulk_load=1;
 INSERT INTO t1 VALUES(10);
 INSERT INTO t1 VALUES(11);
@@ -26,6 +26,15 @@ select @@rocksdb_bulk_load;
 @@rocksdb_bulk_load
 0
 call mtr.add_suppression('finalizing last SST file while setting bulk loading variable');
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES(1);
+INSERT INTO t1 VALUES(2);
+INSERT INTO t1 VALUES(20);
+INSERT INTO t1 VALUES(21);
+SELECT * FROM t1;
+pk
+10
+11
 TRUNCATE TABLE t1;
 SET rocksdb_bulk_load_allow_unsorted=1;
 SET rocksdb_bulk_load=1;
@@ -53,3 +62,34 @@ pk
 202
 SET rocksdb_bulk_load_allow_unsorted=DEFAULT;
 DROP TABLE t1;
+CREATE TABLE t1(c1 INT KEY) ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES (),(),();
+ERROR HY000: Rows must be inserted in primary key order during bulk load operation
+SET rocksdb_bulk_load=0;
+DROP TABLE t1;
+SET @orig_table_open_cache=@@global.table_open_cache;
+CREATE TABLE t1(a INT AUTO_INCREMENT, b INT, PRIMARY KEY (a)) ENGINE=ROCKSDB DEFAULT CHARSET=latin1;
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES(13, 0);
+INSERT INTO t1 VALUES(2, 'test 2');
+Warnings:
+Warning	1366	Incorrect integer value: 'test 2' for column 'b' at row 1
+INSERT INTO t1 VALUES(@id, @arg04);
+SET @@global.table_open_cache=FALSE;
+Warnings:
+Warning	1292	Truncated incorrect table_open_cache value: '0'
+INSERT INTO t1 VALUES(51479+0.333333333,1);
+DROP TABLE t1;
+SET @@global.table_open_cache=@orig_table_open_cache;
+CREATE TABLE t1 (pk INT, PRIMARY KEY (pk)) ENGINE=ROCKSDB;
+CREATE TABLE t2 (pk INT, PRIMARY KEY (pk)) ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES (1), (2);
+INSERT INTO t2 VALUES (1), (2);
+INSERT INTO t1 VALUES (1);
+INSERT INTO t2 VALUES (3);
+ERROR HY000: Rows inserted during bulk load must not overlap existing rows
+SET rocksdb_bulk_load=0;
+DROP TABLE t1;
+DROP TABLE t2;

storage/rocksdb/mysql-test/rocksdb/r/bulk_load_rev_cf.result

@@ -1,4 +1,3 @@
-DROP TABLE IF EXISTS t1, t2, t3;
 Data will be ordered in ascending order
 CREATE TABLE t1(
 pk CHAR(5),
@@ -6,21 +5,21 @@ a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "rev:cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t2(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "rev:cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t3(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "rev:cf1",
 KEY(a)
-) COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
+) ENGINE=ROCKSDB COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
 connect  other,localhost,root,,;
 set session transaction isolation level repeatable read;
 select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';

storage/rocksdb/mysql-test/rocksdb/r/bulk_load_rev_cf_and_data.result

@@ -1,4 +1,3 @@
-DROP TABLE IF EXISTS t1, t2, t3;
 Data will be ordered in descending order
 CREATE TABLE t1(
 pk CHAR(5),
@@ -6,21 +5,21 @@ a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "rev:cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t2(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "rev:cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t3(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "rev:cf1",
 KEY(a)
-) COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
+) ENGINE=ROCKSDB COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
 connect  other,localhost,root,,;
 set session transaction isolation level repeatable read;
 select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';

storage/rocksdb/mysql-test/rocksdb/r/bulk_load_rev_data.result

@@ -1,4 +1,3 @@
-DROP TABLE IF EXISTS t1, t2, t3;
 Data will be ordered in descending order
 CREATE TABLE t1(
 pk CHAR(5),
@@ -6,21 +5,21 @@ a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t2(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "cf1",
 KEY(a)
-) COLLATE 'latin1_bin';
+) ENGINE=ROCKSDB COLLATE 'latin1_bin';
 CREATE TABLE t3(
 pk CHAR(5),
 a CHAR(30),
 b CHAR(30),
 PRIMARY KEY(pk) COMMENT "cf1",
 KEY(a)
-) COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
+) ENGINE=ROCKSDB COLLATE 'latin1_bin' PARTITION BY KEY() PARTITIONS 4;
 connect  other,localhost,root,,;
 set session transaction isolation level repeatable read;
 select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';

storage/rocksdb/mysql-test/rocksdb/r/bulk_load_unsorted.result

@@ -1,12 +1,12 @@
-DROP TABLE IF EXISTS t1;
 SET rocksdb_bulk_load_size=3;
 SET rocksdb_bulk_load_allow_unsorted=1;
-CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1");
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1")
+ENGINE=ROCKSDB;
 SET rocksdb_bulk_load=1;
-SELECT * FROM t1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
 a	b
 SET rocksdb_bulk_load=0;
-SELECT * FROM t1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
 a	b
 -3	5
 -1	3
@@ -14,42 +14,49 @@ a	b
 4	-2
 6	-4
 DROP TABLE t1;
-CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1", KEY(b));
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1", KEY(b))
+ENGINE=ROCKSDB;
 SET rocksdb_bulk_load=1;
-SELECT * FROM t1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
 a	b
-6	-4
-4	-2
-2	0
--1	3
--3	5
 SET rocksdb_bulk_load=0;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+-3	5
+-1	3
+2	0
+4	-2
+6	-4
 DROP TABLE t1;
-CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1");
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1")
-CREATE TABLE t2(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1");
+ENGINE=ROCKSDB;
+CREATE TABLE t2(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1")
+ENGINE=ROCKSDB;
 SET rocksdb_bulk_load=1;
 INSERT INTO t1 VALUES (1,1);
 INSERT INTO t2 VALUES (1,1);
-SELECT * FROM t1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
 a	b
 1	1
 INSERT INTO t1 VALUES (2,2);
-SELECT * FROM t2;
+SELECT * FROM t2 FORCE INDEX (PRIMARY);
 a	b
 1	1
-SELECT * FROM t1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
 a	b
 1	1
 SET rocksdb_bulk_load=0;
-SELECT * FROM t1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
 a	b
 1	1
 2	2
 DROP TABLE t1, t2;
-CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1");
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1")
-CREATE TABLE t2(a INT, b INT, PRIMARY KEY(b) COMMENT "cf1");
+ENGINE=ROCKSDB;
+CREATE TABLE t2(a INT, b INT, PRIMARY KEY(b) COMMENT "cf1")
+ENGINE=ROCKSDB;
 CREATE TABLE t3(a INT, b INT, PRIMARY KEY(a) COMMENT "cf1")
-PARTITION BY KEY() PARTITIONS 4;
+ENGINE=ROCKSDB PARTITION BY KEY() PARTITIONS 4;
 connect  other,localhost,root,,;
 set session transaction isolation level repeatable read;
 select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';
@@ -99,5 +106,14 @@ count(a)
 select count(b) from t3;
 count(b)
 5000000
+SELECT * FROM t1 FORCE INDEX (PRIMARY) LIMIT 3;
+a	b
+-4999998	5000000
+-4999996	4999998
+-4999994	4999996
+SELECT * FROM t2 FORCE INDEX (PRIMARY) LIMIT 3;
+a	b
+4999999	-4999997
+4999997	-4999995
+4999995	-4999993
 DROP TABLE t1, t2, t3;
-SET rocksdb_bulk_load_allow_unsorted=0;

storage/rocksdb/mysql-test/rocksdb/r/bulk_load_unsorted_rev.result

@@ -0,0 +1,117 @@
+SET rocksdb_bulk_load_size=3;
+SET rocksdb_bulk_load_allow_unsorted=1;
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "rev:cf1")
+ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+SET rocksdb_bulk_load=0;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+6	-4
+4	-2
+2	0
+-1	3
+-3	5
+DROP TABLE t1;
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "rev:cf1", KEY(b))
+ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+SET rocksdb_bulk_load=0;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+6	-4
+4	-2
+2	0
+-1	3
+-3	5
+DROP TABLE t1;
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "rev:cf1")
+ENGINE=ROCKSDB;
+CREATE TABLE t2(a INT, b INT, PRIMARY KEY(a) COMMENT "rev:cf1")
+ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES (1,1);
+INSERT INTO t2 VALUES (1,1);
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+1	1
+INSERT INTO t1 VALUES (2,2);
+SELECT * FROM t2 FORCE INDEX (PRIMARY);
+a	b
+1	1
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+1	1
+SET rocksdb_bulk_load=0;
+SELECT * FROM t1 FORCE INDEX (PRIMARY);
+a	b
+2	2
+1	1
+DROP TABLE t1, t2;
+CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "rev:cf1")
+ENGINE=ROCKSDB;
+CREATE TABLE t2(a INT, b INT, PRIMARY KEY(b) COMMENT "rev:cf1")
+ENGINE=ROCKSDB;
+CREATE TABLE t3(a INT, b INT, PRIMARY KEY(a) COMMENT "rev:cf1")
+ENGINE=ROCKSDB PARTITION BY KEY() PARTITIONS 4;
+set session transaction isolation level repeatable read;
+select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';
+STAT_TYPE	VALUE
+DB_NUM_SNAPSHOTS	0
+start transaction with consistent snapshot;
+select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';
+STAT_TYPE	VALUE
+DB_NUM_SNAPSHOTS	1
+set rocksdb_bulk_load=1;
+set rocksdb_bulk_load_size=100000;
+LOAD DATA INFILE <input_file> INTO TABLE t1;
+LOAD DATA INFILE <input_file> INTO TABLE t2;
+LOAD DATA INFILE <input_file> INTO TABLE t3;
+set rocksdb_bulk_load=0;
+SHOW TABLE STATUS WHERE name LIKE 't%';
+Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
+t1	ROCKSDB	10	Fixed	5000000	#	#	#	#	0	NULL	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+t2	ROCKSDB	10	Fixed	5000000	#	#	#	#	0	NULL	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+t3	ROCKSDB	10	Fixed	5000000	#	#	#	#	0	NULL	NULL	NULL	NULL	latin1_swedish_ci	NULL	partitioned	
+ANALYZE TABLE t1, t2, t3;
+Table	Op	Msg_type	Msg_text
+test.t1	analyze	status	OK
+test.t2	analyze	status	OK
+test.t3	analyze	status	OK
+SHOW TABLE STATUS WHERE name LIKE 't%';
+Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
+t1	ROCKSDB	10	Fixed	5000000	#	#	#	#	0	NULL	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+t2	ROCKSDB	10	Fixed	5000000	#	#	#	#	0	NULL	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+t3	ROCKSDB	10	Fixed	5000000	#	#	#	#	0	NULL	NULL	NULL	NULL	latin1_swedish_ci	NULL	partitioned	
+select count(a) from t1;
+count(a)
+5000000
+select count(b) from t1;
+count(b)
+5000000
+select count(a) from t2;
+count(a)
+5000000
+select count(b) from t2;
+count(b)
+5000000
+select count(a) from t3;
+count(a)
+5000000
+select count(b) from t3;
+count(b)
+5000000
+SELECT * FROM t1 FORCE INDEX (PRIMARY) LIMIT 3;
+a	b
+4999999	-4999997
+4999997	-4999995
+4999995	-4999993
+SELECT * FROM t2 FORCE INDEX (PRIMARY) LIMIT 3;
+a	b
+-4999998	5000000
+-4999996	4999998
+-4999994	4999996
+DROP TABLE t1, t2, t3;

storage/rocksdb/mysql-test/rocksdb/r/cardinality.result

@@ -1,4 +1,38 @@
-DROP TABLE IF EXISTS t1,t10,t11;
+CREATE TABLE t0 (id int PRIMARY KEY, a int, INDEX ix_a (a))  engine=rocksdb;
+insert into t0 values (0, 0),(1, 1),(2, 2),(3, 3),(4, 4),
+(5, 4),(6, 4),(7, 4),(8, 4),(9, 4);
+SELECT cardinality FROM information_schema.statistics where table_name="t0" and
+column_name="id";
+cardinality
+NULL
+SELECT cardinality FROM information_schema.statistics where table_name="t0" and
+column_name="a";
+cardinality
+NULL
+ANALYZE TABLE t0;
+SELECT table_rows into @N FROM information_schema.tables
+WHERE table_name = "t0";
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="id";
+FLOOR(@N/cardinality)
+1
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="a";
+FLOOR(@N/cardinality)
+2
+SET GLOBAL rocksdb_force_flush_memtable_now = 1;
+ANALYZE TABLE t0;
+SELECT table_rows into @N FROM information_schema.tables
+WHERE table_name = "t0";
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="id";
+FLOOR(@N/cardinality)
+1
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="a";
+FLOOR(@N/cardinality)
+2
+drop table t0;
 create table t1(
 id bigint not null primary key, 
 i1 bigint, #unique

storage/rocksdb/mysql-test/rocksdb/r/check_ignore_unknown_options.result

@@ -0,0 +1,6 @@
+select variable_name, variable_value from information_schema.global_variables where variable_name="rocksdb_ignore_unknown_options";
+variable_name	variable_value
+ROCKSDB_IGNORE_UNKNOWN_OPTIONS	ON
+select variable_name, variable_value from information_schema.global_variables where variable_name="rocksdb_ignore_unknown_options";
+variable_name	variable_value
+ROCKSDB_IGNORE_UNKNOWN_OPTIONS	ON

storage/rocksdb/mysql-test/rocksdb/r/deadlock_tracking.result

@@ -66,13 +66,6 @@ KEY
 LOCK TYPE: EXCLUSIVE
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 -----------------------------------------
@@ -122,13 +115,6 @@ KEY
 LOCK TYPE: EXCLUSIVE
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 
@@ -147,13 +133,6 @@ KEY
 LOCK TYPE: EXCLUSIVE
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 -----------------------------------------
@@ -204,13 +183,6 @@ KEY
 LOCK TYPE: EXCLUSIVE
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 
@@ -229,13 +201,6 @@ KEY
 LOCK TYPE: EXCLUSIVE
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 
@@ -254,13 +219,6 @@ KEY
 LOCK TYPE: EXCLUSIVE
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 -----------------------------------------
@@ -295,13 +253,6 @@ KEY
 LOCK TYPE: EXCLUSIVE
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 -----------------------------------------
@@ -324,8 +275,12 @@ i
 3
 select * from t where i=2 for update;
 select * from t where i=3 for update;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_row_lock_deadlocks';
 select * from t where i=1 for update;
 ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+select case when variable_value-@a = 1 then 'true' else 'false' end as deadlocks from information_schema.global_status where variable_name='rocksdb_row_lock_deadlocks';
+deadlocks
+true
 rollback;
 i
 3
@@ -410,13 +365,6 @@ KEY
 LOCK TYPE: SHARED
 INDEX NAME: PRIMARY
 TABLE NAME: test.t
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: PRIMARY
-TABLE NAME: test.t
 
 --------TXN_ID GOT DEADLOCK---------
 
@@ -455,13 +403,6 @@ KEY
 LOCK TYPE: SHARED
 INDEX NAME: NOT FOUND; IDX_ID
 TABLE NAME: NOT FOUND; IDX_ID
----------------WAITING FOR---------------
-TXN_ID
-COLUMN FAMILY NAME: default
-KEY
-LOCK TYPE: EXCLUSIVE
-INDEX NAME: NOT FOUND; IDX_ID
-TABLE NAME: NOT FOUND; IDX_ID
 
 --------TXN_ID GOT DEADLOCK---------
 

storage/rocksdb/mysql-test/rocksdb/r/i_s_ddl.result

@@ -1,17 +1,22 @@
 DROP TABLE IF EXISTS is_ddl_t1;
 DROP TABLE IF EXISTS is_ddl_t2;
+DROP TABLE IF EXISTS is_ddl_t3;
 CREATE TABLE is_ddl_t1 (i INT, j INT, k INT, l INT,
 PRIMARY KEY (i), KEY (j), KEY (k, l) COMMENT 'kl_cf')
 ENGINE = ROCKSDB;
 CREATE TABLE is_ddl_t2 (x INT, y INT, z INT,
 PRIMARY KEY (z, y) COMMENT 'zy_cf',
 KEY (x)) ENGINE = ROCKSDB;
-SELECT TABLE_SCHEMA,TABLE_NAME,PARTITION_NAME,INDEX_NAME,INDEX_TYPE,KV_FORMAT_VERSION,CF FROM INFORMATION_SCHEMA.ROCKSDB_DDL WHERE TABLE_NAME like 'is_ddl_t%';
+CREATE TABLE is_ddl_t3 (a INT, b INT, c INT, PRIMARY KEY (a)) ENGINE = ROCKSDB
-TABLE_SCHEMA	TABLE_NAME	PARTITION_NAME	INDEX_NAME	INDEX_TYPE	KV_FORMAT_VERSION	CF
+COMMENT "ttl_duration=3600;";
-test	is_ddl_t1	NULL	PRIMARY	1	13	default
+SELECT TABLE_SCHEMA,TABLE_NAME,PARTITION_NAME,INDEX_NAME,INDEX_TYPE,KV_FORMAT_VERSION,CF,TTL_DURATION,INDEX_FLAGS FROM INFORMATION_SCHEMA.ROCKSDB_DDL WHERE TABLE_NAME like 'is_ddl_t%';
-test	is_ddl_t1	NULL	j	2	13	default
+TABLE_SCHEMA	TABLE_NAME	PARTITION_NAME	INDEX_NAME	INDEX_TYPE	KV_FORMAT_VERSION	CF	TTL_DURATION	INDEX_FLAGS
-test	is_ddl_t1	NULL	k	2	13	kl_cf
+test	is_ddl_t3	NULL	PRIMARY	1	13	default	3600	1
-test	is_ddl_t2	NULL	PRIMARY	1	13	zy_cf
+test	is_ddl_t2	NULL	PRIMARY	1	13	zy_cf	0	0
-test	is_ddl_t2	NULL	x	2	13	default
+test	is_ddl_t2	NULL	x	2	13	default	0	0
+test	is_ddl_t1	NULL	PRIMARY	1	13	default	0	0
+test	is_ddl_t1	NULL	j	2	13	default	0	0
+test	is_ddl_t1	NULL	k	2	13	kl_cf	0	0
 DROP TABLE is_ddl_t1;
 DROP TABLE is_ddl_t2;
+DROP TABLE is_ddl_t3;

storage/rocksdb/mysql-test/rocksdb/r/i_s_deadlock.result

@@ -0,0 +1,172 @@
+set @prior_lock_wait_timeout = @@rocksdb_lock_wait_timeout;
+set @prior_deadlock_detect = @@rocksdb_deadlock_detect;
+set @prior_max_latest_deadlocks = @@rocksdb_max_latest_deadlocks;
+set global rocksdb_deadlock_detect = on;
+set global rocksdb_lock_wait_timeout = 10000;
+# Clears deadlock buffer of any prior deadlocks.
+set global rocksdb_max_latest_deadlocks = 0;
+set global rocksdb_max_latest_deadlocks = @prior_max_latest_deadlocks;
+show create table information_schema.rocksdb_deadlock;
+Table	Create Table
+ROCKSDB_DEADLOCK	CREATE TEMPORARY TABLE `ROCKSDB_DEADLOCK` (
+  `DEADLOCK_ID` bigint(8) NOT NULL DEFAULT '0',
+  `TRANSACTION_ID` bigint(8) NOT NULL DEFAULT '0',
+  `CF_NAME` varchar(193) NOT NULL DEFAULT '',
+  `WAITING_KEY` varchar(513) NOT NULL DEFAULT '',
+  `LOCK_TYPE` varchar(193) NOT NULL DEFAULT '',
+  `INDEX_NAME` varchar(193) NOT NULL DEFAULT '',
+  `TABLE_NAME` varchar(193) NOT NULL DEFAULT '',
+  `ROLLED_BACK` bigint(8) NOT NULL DEFAULT '0'
+) ENGINE=MEMORY DEFAULT CHARSET=utf8
+create table t (i int primary key) engine=rocksdb;
+insert into t values (1), (2), (3);
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+Deadlock #1
+begin;
+select * from t where i=1 for update;
+i
+1
+begin;
+select * from t where i=2 for update;
+i
+2
+select * from t where i=2 for update;
+select * from t where i=1 for update;
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+rollback;
+i
+2
+rollback;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	1
+Deadlock #2
+begin;
+select * from t where i=1 for update;
+i
+1
+begin;
+select * from t where i=2 for update;
+i
+2
+select * from t where i=2 for update;
+select * from t where i=1 for update;
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+rollback;
+i
+2
+rollback;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	1
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	1
+set global rocksdb_max_latest_deadlocks = 10;
+Deadlock #3
+begin;
+select * from t where i=1 for update;
+i
+1
+begin;
+select * from t where i=2 for update;
+i
+2
+select * from t where i=2 for update;
+select * from t where i=1 for update;
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+rollback;
+i
+2
+rollback;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	1
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	1
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	1
+set global rocksdb_max_latest_deadlocks = 1;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	1
+set rocksdb_deadlock_detect_depth = 2;
+Deadlock #4
+begin;
+select * from t where i=1 for update;
+i
+1
+begin;
+select * from t where i=2 for update;
+i
+2
+begin;
+select * from t where i=3 for update;
+i
+3
+select * from t where i=2 for update;
+select * from t where i=3 for update;
+select * from t where i=1 for update;
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+rollback;
+i
+3
+rollback;
+i
+2
+rollback;
+set global rocksdb_max_latest_deadlocks = 5;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+Deadlock #5
+begin;
+select * from t where i=1 for update;
+i
+1
+begin;
+select * from t where i=2 for update;
+i
+2
+begin;
+select * from t where i=3 lock in share mode;
+i
+3
+select * from t where i=100 for update;
+i
+select * from t where i=101 for update;
+i
+select * from t where i=2 for update;
+select * from t where i=3 lock in share mode;
+i
+3
+select * from t where i=200 for update;
+i
+select * from t where i=201 for update;
+i
+select * from t where i=1 lock in share mode;
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+rollback;
+i
+2
+rollback;
+rollback;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	PRIMARY	test.t	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	SHARED	PRIMARY	test.t	1
+set global rocksdb_lock_wait_timeout = @prior_lock_wait_timeout;
+set global rocksdb_deadlock_detect = @prior_deadlock_detect;
+drop table t;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	EXCLUSIVE	INDEX_NAME	TABLE_NAME	0
+DEADLOCK_ID	TRANSACTION_ID	default	WAITING_KEY	SHARED	INDEX_NAME	TABLE_NAME	1
+set global rocksdb_max_latest_deadlocks = 0;
+# Clears deadlock buffer of any existent deadlocks.
+set global rocksdb_max_latest_deadlocks = @prior_max_latest_deadlocks;
+select * from information_schema.rocksdb_deadlock;
+DEADLOCK_ID	TRANSACTION_ID	CF_NAME	WAITING_KEY	LOCK_TYPE	INDEX_NAME	TABLE_NAME	ROLLED_BACK

storage/rocksdb/mysql-test/rocksdb/r/index_merge_rocksdb.result

@@ -25,10 +25,10 @@ UPDATE t1 SET filler1='to be deleted' WHERE key1=100 and key2=100;
 DROP TABLE t0, t1;
 create table t1 (key1 int, key2 int, key3 int, key (key1), key (key2), key(key3)) engine=rocksdb;
 insert into t1 values (1, 100, 100), (1, 200, 200), (1, 300, 300);
+set global rocksdb_force_flush_memtable_now=1;
 analyze table t1;
 Table	Op	Msg_type	Msg_text
 test.t1	analyze	status	OK
-set global rocksdb_force_flush_memtable_now=1;
 explain select * from t1 where key1 = 1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t1	ref	key1	key1	5	const	#	

storage/rocksdb/mysql-test/rocksdb/r/issue255.result

@@ -6,6 +6,19 @@ t1	ROCKSDB	#	Fixed	1	#	#	#	#	#	6	NULL	NULL	NULL	latin1_swedish_ci	NULL
 INSERT INTO t1 VALUES ('538647864786478647864');
 Warnings:
 Warning	1264	Out of range value for column 'pk' at row 1
+SELECT * FROM t1;
+pk
+5
+9223372036854775807
+SHOW TABLE STATUS LIKE 't1';
+Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
+t1	ROCKSDB	10	Fixed	2	22	44	0	0	0	9223372036854775807	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+INSERT INTO t1 VALUES ();
+ERROR 23000: Duplicate entry '9223372036854775807' for key 'PRIMARY'
+SELECT * FROM t1;
+pk
+5
+9223372036854775807
 SHOW TABLE STATUS LIKE 't1';
 Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
 t1	ROCKSDB	#	Fixed	2	#	#	#	#	#	9223372036854775807	NULL	NULL	NULL	latin1_swedish_ci	NULL		
@@ -19,3 +32,37 @@ SHOW TABLE STATUS LIKE 't1';
 Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
 t1	ROCKSDB	#	Fixed	2	#	#	#	#	#	9223372036854775807	NULL	NULL	NULL	latin1_swedish_ci	NULL		
 DROP TABLE t1;
+CREATE TABLE t1 (pk TINYINT NOT NULL PRIMARY KEY AUTO_INCREMENT);
+INSERT INTO t1 VALUES (5);
+SHOW TABLE STATUS LIKE 't1';
+Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
+t1	ROCKSDB	#	Fixed	1	#	#	#	#	#	6	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+INSERT INTO t1 VALUES (1000);
+Warnings:
+Warning	1264	Out of range value for column 'pk' at row 1
+SELECT * FROM t1;
+pk
+5
+127
+SHOW TABLE STATUS LIKE 't1';
+Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
+t1	ROCKSDB	10	Fixed	2	15	30	0	0	0	127	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+INSERT INTO t1 VALUES ();
+ERROR 23000: Duplicate entry '127' for key 'PRIMARY'
+SELECT * FROM t1;
+pk
+5
+127
+SHOW TABLE STATUS LIKE 't1';
+Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
+t1	ROCKSDB	#	Fixed	2	#	#	#	#	#	127	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+INSERT INTO t1 VALUES ();
+ERROR 23000: Duplicate entry '127' for key 'PRIMARY'
+SELECT * FROM t1;
+pk
+5
+127
+SHOW TABLE STATUS LIKE 't1';
+Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
+t1	ROCKSDB	#	Fixed	2	#	#	#	#	#	127	NULL	NULL	NULL	latin1_swedish_ci	NULL		
+DROP TABLE t1;

storage/rocksdb/mysql-test/rocksdb/r/lock_wait_timeout_stats.result

@@ -8,6 +8,7 @@ ROW_LOCK_WAIT_TIMEOUTS
 begin;
 set @@rocksdb_lock_wait_timeout=1;
 begin;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
 insert into t values(0);
 ERROR HY000: Lock wait timeout exceeded; try restarting transaction: Timeout on index: test.t.PRIMARY
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
@@ -16,6 +17,10 @@ ROW_LOCK_WAIT_TIMEOUTS
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
 ROW_LOCK_WAIT_TIMEOUTS
 1
+select case when variable_value-@a = 1 then 'true' else 'false' end as waits from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
+waits
+true
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
 insert into t values(0);
 ERROR HY000: Lock wait timeout exceeded; try restarting transaction: Timeout on index: test.t.PRIMARY
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
@@ -24,4 +29,7 @@ ROW_LOCK_WAIT_TIMEOUTS
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
 ROW_LOCK_WAIT_TIMEOUTS
 2
+select case when variable_value-@a = 1 then 'true' else 'false' end as waits from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
+waits
+true
 drop table t;

storage/rocksdb/mysql-test/rocksdb/r/max_open_files.result

@@ -0,0 +1,20 @@
+CALL mtr.add_suppression("RocksDB: rocksdb_max_open_files should not be greater than the open_files_limit*");
+SELECT FLOOR(@@global.open_files_limit / 2) = @@global.rocksdb_max_open_files;
+FLOOR(@@global.open_files_limit / 2) = @@global.rocksdb_max_open_files
+1
+SELECT @@global.open_files_limit - 1 = @@global.rocksdb_max_open_files;
+@@global.open_files_limit - 1 = @@global.rocksdb_max_open_files
+1
+SELECT @@global.rocksdb_max_open_files;
+@@global.rocksdb_max_open_files
+0
+CREATE TABLE t1(a INT) ENGINE=ROCKSDB;
+INSERT INTO t1 VALUES(0),(1),(2),(3),(4);
+SET GLOBAL rocksdb_force_flush_memtable_and_lzero_now=1;
+DROP TABLE t1;
+SELECT @@global.rocksdb_max_open_files;
+@@global.rocksdb_max_open_files
+-1
+SELECT FLOOR(@@global.open_files_limit / 2) = @@global.rocksdb_max_open_files;
+FLOOR(@@global.open_files_limit / 2) = @@global.rocksdb_max_open_files
+1

storage/rocksdb/mysql-test/rocksdb/r/optimizer_loose_index_scans.result

@@ -36,7 +36,7 @@ explain select b, d from t where d > 4;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	b	8	NULL	#	Using where; Using index for skip scan
 rows_read
-1509
+1505
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -44,7 +44,7 @@ explain select a, b, c, d from t where a = 5 and d <= 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY	PRIMARY	4	const	#	Using where; Using index
 rows_read
-251
+250
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a, b, c, d from t where a = 5 and d <= 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
@@ -58,13 +58,13 @@ explain select e from t where a = 5 and d <= 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY	PRIMARY	4	const	#	Using where
 rows_read
-251
+250
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select e from t where a = 5 and d <= 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY,b	PRIMARY	4	const	#	Using where
 rows_read
-251
+250
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -72,13 +72,13 @@ explain select a, b, c, d from t where a = 5 and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY	PRIMARY	4	const	#	Using where; Using index
 rows_read
-251
+250
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a, b, c, d from t where a = 5 and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	16	NULL	#	Using where; Using index for skip scan
 rows_read
-51
+26
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -86,13 +86,13 @@ explain select e from t where a = 5 and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY	PRIMARY	4	const	#	Using where
 rows_read
-251
+250
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select e from t where a = 5 and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY,b	PRIMARY	4	const	#	Using where
 rows_read
-251
+250
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -100,13 +100,13 @@ explain select a, b, c, d from t where a in (1, 5) and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY	PRIMARY	4	NULL	#	Using where; Using index
 rows_read
-502
+500
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a, b, c, d from t where a in (1, 5) and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	16	NULL	#	Using where; Using index for skip scan
 rows_read
-102
+52
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -114,13 +114,13 @@ explain select a, b, c, d from t where a in (1, 3, 5) and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY	PRIMARY	4	NULL	#	Using where; Using index
 rows_read
-753
+750
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a, b, c, d from t where a in (1, 3, 5) and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	16	NULL	#	Using where; Using index for skip scan
 rows_read
-153
+78
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -128,13 +128,13 @@ explain select a, b, c, d from t where a in (1, 5) and b in (1, 2) and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	8	NULL	#	Using where; Using index
 rows_read
-204
+200
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a, b, c, d from t where a in (1, 5) and b in (1, 2) and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	16	NULL	#	Using where; Using index for skip scan
 rows_read
-44
+24
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -142,13 +142,13 @@ explain select a, b, c, d from t where a in (1, 2, 3, 4, 5) and b in (1, 2, 3) a
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	8	NULL	#	Using where; Using index
 rows_read
-765
+750
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a, b, c, d from t where a in (1, 2, 3, 4, 5) and b in (1, 2, 3) and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	16	NULL	#	Using where; Using index for skip scan
 rows_read
-165
+90
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -156,13 +156,13 @@ explain select a, b, c, d from t where a = 5 and b = 2 and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY,b	PRIMARY	8	const,const	#	Using where; Using index
 rows_read
-51
+50
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a, b, c, d from t where a = 5 and b = 2 and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	PRIMARY	16	NULL	#	Using where; Using index for skip scan
 rows_read
-11
+6
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=off';
@@ -170,7 +170,7 @@ explain select a+1, b, c, d from t where a = 5 and d < 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY	PRIMARY	4	const	#	Using where; Using index
 rows_read
-251
+250
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select a+1, b, c, d from t where a = 5 and d < 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
@@ -184,7 +184,7 @@ explain select b, c, d from t where a = 5 and d < 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	ref	PRIMARY	PRIMARY	4	const	#	Using where; Using index
 rows_read
-251
+250
 set optimizer_switch = 'skip_scan=on,skip_scan_cost_based=off';
 explain select b, c, d from t where a = 5 and d < 3;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
@@ -204,7 +204,7 @@ explain select a, b, c, d from t where a = b and d >= 98;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t	range	PRIMARY,b	b	8	NULL	#	Using where; Using index for skip scan
 rows_read
-9
+5
 include/diff_tables.inc [temp_orig, temp_skip]
 set optimizer_switch = 'skip_scan=off,skip_scan_cost_based=on';
 set optimizer_switch = 'skip_scan=on';

storage/rocksdb/mysql-test/rocksdb/r/perf_context.result

@@ -14,8 +14,13 @@ test	t1	NULL	BLOCK_READ_BYTE	#
 test	t1	NULL	BLOCK_READ_TIME	#
 test	t1	NULL	BLOCK_CHECKSUM_TIME	#
 test	t1	NULL	BLOCK_DECOMPRESS_TIME	#
+test	t1	NULL	GET_READ_BYTES	#
+test	t1	NULL	MULTIGET_READ_BYTES	#
+test	t1	NULL	ITER_READ_BYTES	#
 test	t1	NULL	INTERNAL_KEY_SKIPPED_COUNT	#
 test	t1	NULL	INTERNAL_DELETE_SKIPPED_COUNT	#
+test	t1	NULL	INTERNAL_RECENT_SKIPPED_COUNT	#
+test	t1	NULL	INTERNAL_MERGE_COUNT	#
 test	t1	NULL	GET_SNAPSHOT_TIME	#
 test	t1	NULL	GET_FROM_MEMTABLE_TIME	#
 test	t1	NULL	GET_FROM_MEMTABLE_COUNT	#
@@ -23,9 +28,12 @@ test	t1	NULL	GET_POST_PROCESS_TIME	#
 test	t1	NULL	GET_FROM_OUTPUT_FILES_TIME	#
 test	t1	NULL	SEEK_ON_MEMTABLE_TIME	#
 test	t1	NULL	SEEK_ON_MEMTABLE_COUNT	#
+test	t1	NULL	NEXT_ON_MEMTABLE_COUNT	#
+test	t1	NULL	PREV_ON_MEMTABLE_COUNT	#
 test	t1	NULL	SEEK_CHILD_SEEK_TIME	#
 test	t1	NULL	SEEK_CHILD_SEEK_COUNT	#
-test	t1	NULL	SEEK_IN_HEAP_TIME	#
+test	t1	NULL	SEEK_MIN_HEAP_TIME	#
+test	t1	NULL	SEEK_MAX_HEAP_TIME	#
 test	t1	NULL	SEEK_INTERNAL_SEEK_TIME	#
 test	t1	NULL	FIND_NEXT_USER_ENTRY_TIME	#
 test	t1	NULL	WRITE_WAL_TIME	#
@@ -41,6 +49,12 @@ test	t1	NULL	NEW_TABLE_BLOCK_ITER_NANOS	#
 test	t1	NULL	NEW_TABLE_ITERATOR_NANOS	#
 test	t1	NULL	BLOCK_SEEK_NANOS	#
 test	t1	NULL	FIND_TABLE_NANOS	#
+test	t1	NULL	BLOOM_MEMTABLE_HIT_COUNT	#
+test	t1	NULL	BLOOM_MEMTABLE_MISS_COUNT	#
+test	t1	NULL	BLOOM_SST_HIT_COUNT	#
+test	t1	NULL	BLOOM_SST_MISS_COUNT	#
+test	t1	NULL	KEY_LOCK_WAIT_TIME	#
+test	t1	NULL	KEY_LOCK_WAIT_COUNT	#
 test	t1	NULL	IO_THREAD_POOL_ID	#
 test	t1	NULL	IO_BYTES_WRITTEN	#
 test	t1	NULL	IO_BYTES_READ	#
@@ -59,8 +73,13 @@ BLOCK_READ_BYTE	#
 BLOCK_READ_TIME	#
 BLOCK_CHECKSUM_TIME	#
 BLOCK_DECOMPRESS_TIME	#
+GET_READ_BYTES	#
+MULTIGET_READ_BYTES	#
+ITER_READ_BYTES	#
 INTERNAL_KEY_SKIPPED_COUNT	#
 INTERNAL_DELETE_SKIPPED_COUNT	#
+INTERNAL_RECENT_SKIPPED_COUNT	#
+INTERNAL_MERGE_COUNT	#
 GET_SNAPSHOT_TIME	#
 GET_FROM_MEMTABLE_TIME	#
 GET_FROM_MEMTABLE_COUNT	#
@@ -68,9 +87,12 @@ GET_POST_PROCESS_TIME	#
 GET_FROM_OUTPUT_FILES_TIME	#
 SEEK_ON_MEMTABLE_TIME	#
 SEEK_ON_MEMTABLE_COUNT	#
+NEXT_ON_MEMTABLE_COUNT	#
+PREV_ON_MEMTABLE_COUNT	#
 SEEK_CHILD_SEEK_TIME	#
 SEEK_CHILD_SEEK_COUNT	#
-SEEK_IN_HEAP_TIME	#
+SEEK_MIN_HEAP_TIME	#
+SEEK_MAX_HEAP_TIME	#
 SEEK_INTERNAL_SEEK_TIME	#
 FIND_NEXT_USER_ENTRY_TIME	#
 WRITE_WAL_TIME	#
@@ -86,6 +108,12 @@ NEW_TABLE_BLOCK_ITER_NANOS	#
 NEW_TABLE_ITERATOR_NANOS	#
 BLOCK_SEEK_NANOS	#
 FIND_TABLE_NANOS	#
+BLOOM_MEMTABLE_HIT_COUNT	#
+BLOOM_MEMTABLE_MISS_COUNT	#
+BLOOM_SST_HIT_COUNT	#
+BLOOM_SST_MISS_COUNT	#
+KEY_LOCK_WAIT_TIME	#
+KEY_LOCK_WAIT_COUNT	#
 IO_THREAD_POOL_ID	#
 IO_BYTES_WRITTEN	#
 IO_BYTES_READ	#

storage/rocksdb/mysql-test/rocksdb/r/rocksdb.result

@@ -573,9 +573,6 @@ insert into t30 values
 ('row3', 'row3-key', 'row3-data'),
 ('row4', 'row4-key', 'row4-data'),
 ('row5', 'row5-key', 'row5-data');
-analyze table t30;
-Table	Op	Msg_type	Msg_text
-test.t30	analyze	status	OK
 explain 
 select * from t30 where key1 <='row3-key';
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
@@ -865,7 +862,7 @@ ERROR 42S02: Unknown table 'test.t45'
 # Now it fails if there is data overlap with what
 # already exists
 #
-show variables 
+show variables where variable_name like 'rocksdb%' and variable_name not like 'rocksdb_max_open_files';
 where 
 variable_name like 'rocksdb%' and 
 variable_name not like 'rocksdb_supported_compression_types';
@@ -875,6 +872,7 @@ rocksdb_advise_random_on_open	ON
 rocksdb_allow_concurrent_memtable_write	OFF
 rocksdb_allow_mmap_reads	OFF
 rocksdb_allow_mmap_writes	OFF
+rocksdb_allow_to_start_after_corruption	OFF
 rocksdb_blind_delete_primary_key	OFF
 rocksdb_block_cache_size	536870912
 rocksdb_block_restart_interval	16
@@ -894,7 +892,6 @@ rocksdb_compaction_sequential_deletes	0
 rocksdb_compaction_sequential_deletes_count_sd	OFF
 rocksdb_compaction_sequential_deletes_file_size	0
 rocksdb_compaction_sequential_deletes_window	0
-rocksdb_concurrent_prepare	ON
 rocksdb_create_checkpoint	
 rocksdb_create_if_missing	ON
 rocksdb_create_missing_column_families	OFF
@@ -918,7 +915,6 @@ rocksdb_enable_ttl_read_filtering	ON
 rocksdb_enable_write_thread_adaptive_yield	OFF
 rocksdb_error_if_exists	OFF
 rocksdb_flush_log_at_trx_commit	0
-rocksdb_flush_memtable_on_analyze	ON
 rocksdb_force_compute_memtable_stats	ON
 rocksdb_force_compute_memtable_stats_cachetime	0
 rocksdb_force_flush_memtable_and_lzero_now	OFF
@@ -926,6 +922,7 @@ rocksdb_force_flush_memtable_now	OFF
 rocksdb_force_index_records_in_range	0
 rocksdb_git_hash	#
 rocksdb_hash_index_allow_collision	ON
+rocksdb_ignore_unknown_options	ON
 rocksdb_index_type	kBinarySearch
 rocksdb_info_log_level	error_level
 rocksdb_io_write_timeout	0
@@ -942,8 +939,7 @@ rocksdb_max_background_jobs	2
 rocksdb_max_latest_deadlocks	5
 rocksdb_max_log_file_size	0
 rocksdb_max_manifest_file_size	18446744073709551615
-rocksdb_max_open_files	-1
+rocksdb_max_row_locks	1048576
-rocksdb_max_row_locks	1073741824
 rocksdb_max_subcompactions	1
 rocksdb_max_total_wal_size	0
 rocksdb_merge_buf_size	67108864
@@ -978,6 +974,7 @@ rocksdb_table_cache_numshardbits	6
 rocksdb_table_stats_sampling_pct	10
 rocksdb_tmpdir	
 rocksdb_trace_sst_api	OFF
+rocksdb_two_write_queues	ON
 rocksdb_unsafe_for_binlog	OFF
 rocksdb_update_cf_options	
 rocksdb_use_adaptive_mutex	OFF
@@ -1464,6 +1461,7 @@ Rocksdb_rows_read	#
 Rocksdb_rows_updated	#
 Rocksdb_rows_deleted_blind	#
 Rocksdb_rows_expired	#
+rocksdb_rows_filtered	#
 Rocksdb_system_rows_deleted	#
 Rocksdb_system_rows_inserted	#
 Rocksdb_system_rows_read	#
@@ -1475,6 +1473,11 @@ Rocksdb_queries_range	#
 Rocksdb_covered_secondary_key_lookups	#
 Rocksdb_block_cache_add	#
 Rocksdb_block_cache_data_hit	#
+rocksdb_block_cache_add_failures	#
+rocksdb_block_cache_bytes_read	#
+rocksdb_block_cache_bytes_write	#
+rocksdb_block_cache_data_add	#
+rocksdb_block_cache_data_bytes_insert	#
 Rocksdb_block_cache_data_miss	#
 Rocksdb_block_cache_filter_hit	#
 Rocksdb_block_cache_filter_miss	#
@@ -1482,12 +1485,18 @@ Rocksdb_block_cache_hit	#
 Rocksdb_block_cache_index_hit	#
 Rocksdb_block_cache_index_miss	#
 Rocksdb_block_cache_miss	#
+rocksdb_block_cache_filter_add	#
+rocksdb_block_cache_filter_bytes_evict	#
+rocksdb_block_cache_filter_bytes_insert	#
 Rocksdb_block_cachecompressed_hit	#
 Rocksdb_block_cachecompressed_miss	#
 Rocksdb_bloom_filter_prefix_checked	#
 Rocksdb_bloom_filter_prefix_useful	#
 Rocksdb_bloom_filter_useful	#
 Rocksdb_bytes_read	#
+rocksdb_block_cache_index_add	#
+rocksdb_block_cache_index_bytes_evict	#
+rocksdb_block_cache_index_bytes_insert	#
 Rocksdb_bytes_written	#
 Rocksdb_compact_read_bytes	#
 Rocksdb_compact_write_bytes	#
@@ -1507,12 +1516,16 @@ Rocksdb_number_deletes_filtered	#
 Rocksdb_number_keys_read	#
 Rocksdb_number_keys_updated	#
 Rocksdb_number_keys_written	#
+rocksdb_get_hit_l0	#
+rocksdb_get_hit_l1	#
+rocksdb_get_hit_l2_and_up	#
 Rocksdb_number_merge_failures	#
 Rocksdb_number_multiget_bytes_read	#
 Rocksdb_number_multiget_get	#
 Rocksdb_number_multiget_keys_read	#
 Rocksdb_number_reseeks_iteration	#
 Rocksdb_number_sst_entry_delete	#
+rocksdb_iter_bytes_read	#
 Rocksdb_number_sst_entry_merge	#
 Rocksdb_number_sst_entry_other	#
 Rocksdb_number_sst_entry_put	#
@@ -1521,6 +1534,12 @@ Rocksdb_number_stat_computes	#
 Rocksdb_number_superversion_acquires	#
 Rocksdb_number_superversion_cleanups	#
 Rocksdb_number_superversion_releases	#
+rocksdb_number_db_next	#
+rocksdb_number_db_next_found	#
+rocksdb_number_db_prev	#
+rocksdb_number_db_prev_found	#
+rocksdb_number_db_seek	#
+rocksdb_number_db_seek_found	#
 Rocksdb_rate_limit_delay_millis	#
 Rocksdb_snapshot_conflict_errors	#
 Rocksdb_stall_l0_file_count_limit_slowdowns	#
@@ -1541,6 +1560,8 @@ Rocksdb_write_other	#
 Rocksdb_write_self	#
 Rocksdb_write_timedout	#
 Rocksdb_write_wal	#
+rocksdb_row_lock_deadlocks	#
+rocksdb_row_lock_wait_timeouts	#
 select VARIABLE_NAME from INFORMATION_SCHEMA.global_status where VARIABLE_NAME LIKE 'rocksdb%';
 VARIABLE_NAME
 ROCKSDB_ROWS_DELETED
@@ -1549,6 +1570,7 @@ ROCKSDB_ROWS_READ
 ROCKSDB_ROWS_UPDATED
 ROCKSDB_ROWS_DELETED_BLIND
 ROCKSDB_ROWS_EXPIRED
+ROCKSDB_ROWS_FILTERED
 ROCKSDB_SYSTEM_ROWS_DELETED
 ROCKSDB_SYSTEM_ROWS_INSERTED
 ROCKSDB_SYSTEM_ROWS_READ
@@ -1559,11 +1581,22 @@ ROCKSDB_QUERIES_POINT
 ROCKSDB_QUERIES_RANGE
 ROCKSDB_COVERED_SECONDARY_KEY_LOOKUPS
 ROCKSDB_BLOCK_CACHE_ADD
+ROCKSDB_BLOCK_CACHE_ADD_FAILURES
+ROCKSDB_BLOCK_CACHE_BYTES_READ
+ROCKSDB_BLOCK_CACHE_BYTES_WRITE
+ROCKSDB_BLOCK_CACHE_DATA_ADD
+ROCKSDB_BLOCK_CACHE_DATA_BYTES_INSERT
 ROCKSDB_BLOCK_CACHE_DATA_HIT
 ROCKSDB_BLOCK_CACHE_DATA_MISS
+ROCKSDB_BLOCK_CACHE_FILTER_ADD
+ROCKSDB_BLOCK_CACHE_FILTER_BYTES_EVICT
+ROCKSDB_BLOCK_CACHE_FILTER_BYTES_INSERT
 ROCKSDB_BLOCK_CACHE_FILTER_HIT
 ROCKSDB_BLOCK_CACHE_FILTER_MISS
 ROCKSDB_BLOCK_CACHE_HIT
+ROCKSDB_BLOCK_CACHE_INDEX_ADD
+ROCKSDB_BLOCK_CACHE_INDEX_BYTES_EVICT
+ROCKSDB_BLOCK_CACHE_INDEX_BYTES_INSERT
 ROCKSDB_BLOCK_CACHE_INDEX_HIT
 ROCKSDB_BLOCK_CACHE_INDEX_MISS
 ROCKSDB_BLOCK_CACHE_MISS
@@ -1580,7 +1613,11 @@ ROCKSDB_COMPACTION_KEY_DROP_NEW
 ROCKSDB_COMPACTION_KEY_DROP_OBSOLETE
 ROCKSDB_COMPACTION_KEY_DROP_USER
 ROCKSDB_FLUSH_WRITE_BYTES
+ROCKSDB_GET_HIT_L0
+ROCKSDB_GET_HIT_L1
+ROCKSDB_GET_HIT_L2_AND_UP
 ROCKSDB_GETUPDATESSINCE_CALLS
+ROCKSDB_ITER_BYTES_READ
 ROCKSDB_MEMTABLE_HIT
 ROCKSDB_MEMTABLE_MISS
 ROCKSDB_NO_FILE_CLOSES
@@ -1588,6 +1625,12 @@ ROCKSDB_NO_FILE_ERRORS
 ROCKSDB_NO_FILE_OPENS
 ROCKSDB_NUM_ITERATORS
 ROCKSDB_NUMBER_BLOCK_NOT_COMPRESSED
+ROCKSDB_NUMBER_DB_NEXT
+ROCKSDB_NUMBER_DB_NEXT_FOUND
+ROCKSDB_NUMBER_DB_PREV
+ROCKSDB_NUMBER_DB_PREV_FOUND
+ROCKSDB_NUMBER_DB_SEEK
+ROCKSDB_NUMBER_DB_SEEK_FOUND
 ROCKSDB_NUMBER_DELETES_FILTERED
 ROCKSDB_NUMBER_KEYS_READ
 ROCKSDB_NUMBER_KEYS_UPDATED
@@ -1602,11 +1645,11 @@ ROCKSDB_NUMBER_SST_ENTRY_MERGE
 ROCKSDB_NUMBER_SST_ENTRY_OTHER
 ROCKSDB_NUMBER_SST_ENTRY_PUT
 ROCKSDB_NUMBER_SST_ENTRY_SINGLEDELETE
-ROCKSDB_NUMBER_STAT_COMPUTES
 ROCKSDB_NUMBER_SUPERVERSION_ACQUIRES
 ROCKSDB_NUMBER_SUPERVERSION_CLEANUPS
 ROCKSDB_NUMBER_SUPERVERSION_RELEASES
-ROCKSDB_RATE_LIMIT_DELAY_MILLIS
+ROCKSDB_ROW_LOCK_DEADLOCKS
+ROCKSDB_ROW_LOCK_WAIT_TIMEOUTS
 ROCKSDB_SNAPSHOT_CONFLICT_ERRORS
 ROCKSDB_STALL_L0_FILE_COUNT_LIMIT_SLOWDOWNS
 ROCKSDB_STALL_LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS
@@ -1636,6 +1679,7 @@ ROCKSDB_ROWS_READ
 ROCKSDB_ROWS_UPDATED
 ROCKSDB_ROWS_DELETED_BLIND
 ROCKSDB_ROWS_EXPIRED
+ROCKSDB_ROWS_FILTERED
 ROCKSDB_SYSTEM_ROWS_DELETED
 ROCKSDB_SYSTEM_ROWS_INSERTED
 ROCKSDB_SYSTEM_ROWS_READ
@@ -1646,11 +1690,22 @@ ROCKSDB_QUERIES_POINT
 ROCKSDB_QUERIES_RANGE
 ROCKSDB_COVERED_SECONDARY_KEY_LOOKUPS
 ROCKSDB_BLOCK_CACHE_ADD
+ROCKSDB_BLOCK_CACHE_ADD_FAILURES
+ROCKSDB_BLOCK_CACHE_BYTES_READ
+ROCKSDB_BLOCK_CACHE_BYTES_WRITE
+ROCKSDB_BLOCK_CACHE_DATA_ADD
+ROCKSDB_BLOCK_CACHE_DATA_BYTES_INSERT
 ROCKSDB_BLOCK_CACHE_DATA_HIT
 ROCKSDB_BLOCK_CACHE_DATA_MISS
+ROCKSDB_BLOCK_CACHE_FILTER_ADD
+ROCKSDB_BLOCK_CACHE_FILTER_BYTES_EVICT
+ROCKSDB_BLOCK_CACHE_FILTER_BYTES_INSERT
 ROCKSDB_BLOCK_CACHE_FILTER_HIT
 ROCKSDB_BLOCK_CACHE_FILTER_MISS
 ROCKSDB_BLOCK_CACHE_HIT
+ROCKSDB_BLOCK_CACHE_INDEX_ADD
+ROCKSDB_BLOCK_CACHE_INDEX_BYTES_EVICT
+ROCKSDB_BLOCK_CACHE_INDEX_BYTES_INSERT
 ROCKSDB_BLOCK_CACHE_INDEX_HIT
 ROCKSDB_BLOCK_CACHE_INDEX_MISS
 ROCKSDB_BLOCK_CACHE_MISS
@@ -1667,7 +1722,11 @@ ROCKSDB_COMPACTION_KEY_DROP_NEW
 ROCKSDB_COMPACTION_KEY_DROP_OBSOLETE
 ROCKSDB_COMPACTION_KEY_DROP_USER
 ROCKSDB_FLUSH_WRITE_BYTES
+ROCKSDB_GET_HIT_L0
+ROCKSDB_GET_HIT_L1
+ROCKSDB_GET_HIT_L2_AND_UP
 ROCKSDB_GETUPDATESSINCE_CALLS
+ROCKSDB_ITER_BYTES_READ
 ROCKSDB_MEMTABLE_HIT
 ROCKSDB_MEMTABLE_MISS
 ROCKSDB_NO_FILE_CLOSES
@@ -1675,6 +1734,12 @@ ROCKSDB_NO_FILE_ERRORS
 ROCKSDB_NO_FILE_OPENS
 ROCKSDB_NUM_ITERATORS
 ROCKSDB_NUMBER_BLOCK_NOT_COMPRESSED
+ROCKSDB_NUMBER_DB_NEXT
+ROCKSDB_NUMBER_DB_NEXT_FOUND
+ROCKSDB_NUMBER_DB_PREV
+ROCKSDB_NUMBER_DB_PREV_FOUND
+ROCKSDB_NUMBER_DB_SEEK
+ROCKSDB_NUMBER_DB_SEEK_FOUND
 ROCKSDB_NUMBER_DELETES_FILTERED
 ROCKSDB_NUMBER_KEYS_READ
 ROCKSDB_NUMBER_KEYS_UPDATED
@@ -1689,11 +1754,11 @@ ROCKSDB_NUMBER_SST_ENTRY_MERGE
 ROCKSDB_NUMBER_SST_ENTRY_OTHER
 ROCKSDB_NUMBER_SST_ENTRY_PUT
 ROCKSDB_NUMBER_SST_ENTRY_SINGLEDELETE
-ROCKSDB_NUMBER_STAT_COMPUTES
 ROCKSDB_NUMBER_SUPERVERSION_ACQUIRES
 ROCKSDB_NUMBER_SUPERVERSION_CLEANUPS
 ROCKSDB_NUMBER_SUPERVERSION_RELEASES
-ROCKSDB_RATE_LIMIT_DELAY_MILLIS
+ROCKSDB_ROW_LOCK_DEADLOCKS
+ROCKSDB_ROW_LOCK_WAIT_TIMEOUTS
 ROCKSDB_SNAPSHOT_CONFLICT_ERRORS
 ROCKSDB_STALL_L0_FILE_COUNT_LIMIT_SLOWDOWNS
 ROCKSDB_STALL_LOCKED_L0_FILE_COUNT_LIMIT_SLOWDOWNS

storage/rocksdb/mysql-test/rocksdb/r/rocksdb_debug.result

@@ -0,0 +1,11 @@
+#
+# Issue #728: Assertion `covers_key(b)' failed in int
+# myrocks::Rdb_key_def::cmp_full_keys(const rocks db::Slice&,
+# const rocksdb::Slice&) 
+#
+CREATE TABLE t2(c1 TINYINT SIGNED KEY,c2 TINYINT UNSIGNED,c3 INT);
+INSERT INTO t2(c1)VALUES(0);
+SELECT * FROM t2 WHERE c1<=127 ORDER BY c1 DESC;
+c1	c2	c3
+0	NULL	NULL
+DROP TABLE t2;

storage/rocksdb/mysql-test/rocksdb/r/rocksdb_range2.result

@@ -7,5 +7,5 @@ count(*)
 10000
 explain select c1 from t1 where c1 > 5 limit 10;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	i	i	9	NULL	9900	Using where; Using index
+1	SIMPLE	t1	range	i	i	9	NULL	#	Using where; Using index
 drop table t1;

storage/rocksdb/mysql-test/rocksdb/r/show_engine.result

@@ -83,12 +83,12 @@ FROM INFORMATION_SCHEMA.ROCKSDB_PERF_CONTEXT
 WHERE TABLE_SCHEMA = 'test'
 GROUP BY TABLE_NAME, PARTITION_NAME;
 TABLE_SCHEMA	TABLE_NAME	PARTITION_NAME	COUNT(STAT_TYPE)
-test	t1	NULL	43
+test	t1	NULL	57
-test	t2	NULL	43
+test	t2	NULL	57
-test	t4	p0	43
+test	t4	p0	57
-test	t4	p1	43
+test	t4	p1	57
-test	t4	p2	43
+test	t4	p2	57
-test	t4	p3	43
+test	t4	p3	57
 SELECT * FROM INFORMATION_SCHEMA.ROCKSDB_CF_OPTIONS;
 CF_NAME	OPTION_TYPE	VALUE
 __system__	COMPARATOR	#
@@ -153,9 +153,15 @@ __system__	TABLE_FACTORY::BLOCK_SIZE	#
 __system__	TABLE_FACTORY::BLOCK_SIZE_DEVIATION	#
 __system__	TABLE_FACTORY::BLOCK_RESTART_INTERVAL	#
 __system__	TABLE_FACTORY::INDEX_BLOCK_RESTART_INTERVAL	#
+__system__	TABLE_FACTORY::METADATA_BLOCK_SIZE	#
+__system__	TABLE_FACTORY::PARTITION_FILTERS	#
+__system__	TABLE_FACTORY::USE_DELTA_ENCODING	#
 __system__	TABLE_FACTORY::FILTER_POLICY	#
 __system__	TABLE_FACTORY::WHOLE_KEY_FILTERING	#
+__system__	TABLE_FACTORY::VERIFY_COMPRESSION	#
+__system__	TABLE_FACTORY::READ_AMP_BYTES_PER_BIT	#
 __system__	TABLE_FACTORY::FORMAT_VERSION	#
+__system__	TABLE_FACTORY::ENABLE_INDEX_COMPRESSION	#
 cf_t1	COMPARATOR	#
 cf_t1	MERGE_OPERATOR	#
 cf_t1	COMPACTION_FILTER	#
@@ -218,9 +224,15 @@ cf_t1	TABLE_FACTORY::BLOCK_SIZE	#
 cf_t1	TABLE_FACTORY::BLOCK_SIZE_DEVIATION	#
 cf_t1	TABLE_FACTORY::BLOCK_RESTART_INTERVAL	#
 cf_t1	TABLE_FACTORY::INDEX_BLOCK_RESTART_INTERVAL	#
+cf_t1	TABLE_FACTORY::METADATA_BLOCK_SIZE	#
+cf_t1	TABLE_FACTORY::PARTITION_FILTERS	#
+cf_t1	TABLE_FACTORY::USE_DELTA_ENCODING	#
 cf_t1	TABLE_FACTORY::FILTER_POLICY	#
 cf_t1	TABLE_FACTORY::WHOLE_KEY_FILTERING	#
+cf_t1	TABLE_FACTORY::VERIFY_COMPRESSION	#
+cf_t1	TABLE_FACTORY::READ_AMP_BYTES_PER_BIT	#
 cf_t1	TABLE_FACTORY::FORMAT_VERSION	#
+cf_t1	TABLE_FACTORY::ENABLE_INDEX_COMPRESSION	#
 default	COMPARATOR	#
 default	MERGE_OPERATOR	#
 default	COMPACTION_FILTER	#
@@ -283,9 +295,15 @@ default	TABLE_FACTORY::BLOCK_SIZE	#
 default	TABLE_FACTORY::BLOCK_SIZE_DEVIATION	#
 default	TABLE_FACTORY::BLOCK_RESTART_INTERVAL	#
 default	TABLE_FACTORY::INDEX_BLOCK_RESTART_INTERVAL	#
+default	TABLE_FACTORY::METADATA_BLOCK_SIZE	#
+default	TABLE_FACTORY::PARTITION_FILTERS	#
+default	TABLE_FACTORY::USE_DELTA_ENCODING	#
 default	TABLE_FACTORY::FILTER_POLICY	#
 default	TABLE_FACTORY::WHOLE_KEY_FILTERING	#
+default	TABLE_FACTORY::VERIFY_COMPRESSION	#
+default	TABLE_FACTORY::READ_AMP_BYTES_PER_BIT	#
 default	TABLE_FACTORY::FORMAT_VERSION	#
+default	TABLE_FACTORY::ENABLE_INDEX_COMPRESSION	#
 rev:cf_t2	COMPARATOR	#
 rev:cf_t2	MERGE_OPERATOR	#
 rev:cf_t2	COMPACTION_FILTER	#
@@ -348,9 +366,15 @@ rev:cf_t2	TABLE_FACTORY::BLOCK_SIZE	#
 rev:cf_t2	TABLE_FACTORY::BLOCK_SIZE_DEVIATION	#
 rev:cf_t2	TABLE_FACTORY::BLOCK_RESTART_INTERVAL	#
 rev:cf_t2	TABLE_FACTORY::INDEX_BLOCK_RESTART_INTERVAL	#
+rev:cf_t2	TABLE_FACTORY::METADATA_BLOCK_SIZE	#
+rev:cf_t2	TABLE_FACTORY::PARTITION_FILTERS	#
+rev:cf_t2	TABLE_FACTORY::USE_DELTA_ENCODING	#
 rev:cf_t2	TABLE_FACTORY::FILTER_POLICY	#
 rev:cf_t2	TABLE_FACTORY::WHOLE_KEY_FILTERING	#
+rev:cf_t2	TABLE_FACTORY::VERIFY_COMPRESSION	#
+rev:cf_t2	TABLE_FACTORY::READ_AMP_BYTES_PER_BIT	#
 rev:cf_t2	TABLE_FACTORY::FORMAT_VERSION	#
+rev:cf_t2	TABLE_FACTORY::ENABLE_INDEX_COMPRESSION	#
 DROP TABLE t1;
 DROP TABLE t2;
 DROP TABLE t3;

storage/rocksdb/mysql-test/rocksdb/r/skip_validate_tmp_table.result

@@ -1,4 +1,19 @@
-CREATE TABLE t1 (pk int primary key) ENGINE=ROCKSDB;
+create table t1 (pk int primary key) engine=rocksdb;
+show tables;
 set session debug_dbug="+d,gen_sql_table_name";
+Tables_in_test
+#mysql50#t1#sql-test
+t1
 rename table t1 to t2;
 set session debug_dbug= "-d,gen_sql_table_name";
+show tables;
+Tables_in_test
+#mysql50#t1#sql-test
+t2
+show tables;
+Tables_in_test
+create table t2 (pk int primary key) engine=rocksdb;
+show tables;
+Tables_in_test
+t2
+drop table t2;

storage/rocksdb/mysql-test/rocksdb/r/ttl_primary_read_filtering.result

@@ -51,18 +51,30 @@ INSERT INTO t1 values (3);
 INSERT INTO t1 values (5);
 INSERT INTO t1 values (7);
 set global rocksdb_debug_ttl_rec_ts = 0;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 SELECT * FROM t1;
 a
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
+variable_value-@a
+4
 set global rocksdb_enable_ttl_read_filtering=0;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 SELECT * FROM t1;
 a
 1
 3
 5
 7
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
+variable_value-@a
+0
 set global rocksdb_enable_ttl_read_filtering=1;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 SELECT * FROM t1;
 a
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
+variable_value-@a
+4
 DROP TABLE t1;
 CREATE TABLE t1 (
 a int,
@@ -191,20 +203,36 @@ a
 connection con2;
 set global rocksdb_force_flush_memtable_now=1;
 set global rocksdb_compact_cf='default';
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 SELECT * FROM t1;
 a
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
+variable_value-@a
+1
 # Switching to connection 1
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 connection con1;
 SELECT * FROM t1;
 a
 1
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
+variable_value-@a
+0
 UPDATE t1 set a = a + 1;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 SELECT * FROM t1;
 a
 2
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
+variable_value-@a
+0
 COMMIT;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 SELECT * FROM t1;
 a
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
+variable_value-@a
+1
 DROP TABLE t1;
 disconnect con1;
 disconnect con2;

storage/rocksdb/mysql-test/rocksdb/r/type_varchar.result

@@ -1,4 +1,3 @@
-drop table if exists t1,t2;
 #
 # A basic test whether endspace-aware variable length encoding 
 # works when in PK
@@ -756,3 +755,16 @@ email_i	1
 drop table t;
 set global rocksdb_checksums_pct = @save_rocksdb_checksums_pct;
 set session rocksdb_verify_row_debug_checksums = @save_rocksdb_verify_row_debug_checksums;
+drop table if exists t;
+Warnings:
+Note	1051	Unknown table 'test.t'
+create table t (h varchar(31) character set utf8 collate utf8_bin not null, i varchar(19) collate latin1_bin not null, primary key(i), key(h)) engine=rocksdb;
+insert into t(i,h) values('a','b');
+check table t;
+Table	Op	Msg_type	Msg_text
+test.t	check	status	OK
+alter table t modify h varchar(31) character set cp1257 collate cp1257_bin not null;
+check table t;
+Table	Op	Msg_type	Msg_text
+test.t	check	status	OK
+drop table t;

storage/rocksdb/mysql-test/rocksdb/r/use_direct_reads_writes.result

@@ -1,3 +1,12 @@
+Checking direct reads
+Checking direct writes
+Checking rocksdb_flush_log_at_trx_commit
+Validate flush_log settings when direct writes is enabled
+set global rocksdb_flush_log_at_trx_commit=0;
+set global rocksdb_flush_log_at_trx_commit=1;
+ERROR 42000: Variable 'rocksdb_flush_log_at_trx_commit' can't be set to the value of '1'
+set global rocksdb_flush_log_at_trx_commit=2;
+ERROR 42000: Variable 'rocksdb_flush_log_at_trx_commit' can't be set to the value of '2'
 call mtr.add_suppression("rocksdb");
 call mtr.add_suppression("Aborting");
 # This shows that RocksDB plugin is loaded:

storage/rocksdb/mysql-test/rocksdb/r/write_sync.result

@@ -3,6 +3,7 @@ SET GLOBAL rocksdb_write_ignore_missing_column_families=true;
 create table aaa (id int primary key, i int) engine rocksdb;
 set @save_rocksdb_flush_log_at_trx_commit=@@global.rocksdb_flush_log_at_trx_commit;
 SET GLOBAL rocksdb_flush_log_at_trx_commit=1;
+insert aaa(id, i) values(0,1);
 select variable_value into @a from information_schema.global_status where variable_name='rocksdb_wal_synced';
 insert aaa(id, i) values(1,1);
 select variable_value-@a from information_schema.global_status where variable_name='rocksdb_wal_synced';
@@ -16,11 +17,11 @@ insert aaa(id, i) values(3,1);
 select variable_value-@a from information_schema.global_status where variable_name='rocksdb_wal_synced';
 variable_value-@a
 3
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_wal_synced';
 SET GLOBAL rocksdb_flush_log_at_trx_commit=0;
-select variable_value into @a from information_schema.global_status where variable_name='rocksdb_wal_synced';
 insert aaa(id, i) values(4,1);
-SET GLOBAL rocksdb_flush_log_at_trx_commit=2;
 select variable_value into @a from information_schema.global_status where variable_name='rocksdb_wal_synced';
+SET GLOBAL rocksdb_flush_log_at_trx_commit=2;
 insert aaa(id, i) values(5,1);
 truncate table aaa;
 drop table aaa;

storage/rocksdb/mysql-test/rocksdb/t/add_index_inplace_sstfilewriter.test

@@ -65,7 +65,12 @@ ALTER TABLE t1 ADD INDEX kb(b), ALGORITHM=INPLACE;
 # disable duplicate index warning
 --disable_warnings
 # now do same index using copy algorithm
+# hitting max row locks (1M)
+--error ER_RDB_STATUS_GENERAL
 ALTER TABLE t1 ADD INDEX kb_copy(b), ALGORITHM=COPY;
+set session rocksdb_bulk_load=1;
+ALTER TABLE t1 ADD INDEX kb_copy(b), ALGORITHM=COPY;
+set session rocksdb_bulk_load=0;
 --enable_warnings
 
 # checksum testing

storage/rocksdb/mysql-test/rocksdb/t/allow_no_primary_key_with_sk.test

@@ -135,3 +135,15 @@ set global rocksdb_force_flush_memtable_now = true;
 
 select * from t1;
 DROP TABLE t1;
+
+## https://github.com/facebook/mysql-5.6/issues/736
+create table t1 (i int auto_increment, key(i)) engine=rocksdb;
+insert into t1 values();
+insert into t1 values();
+insert into t1 values();
+
+show create table t1;
+--source include/restart_mysqld.inc
+show create table t1;
+
+drop table t1;

storage/rocksdb/mysql-test/rocksdb/t/allow_to_start_after_corruption.test

@@ -0,0 +1,75 @@
+--source include/have_rocksdb.inc
+--source include/not_valgrind.inc
+
+--echo #
+--echo #  Test how MyRocks behaves when RocksDB reports corrupted data.
+--echo #
+
+--source include/have_debug.inc
+
+# use custom error log to assert on error message in search_pattern_in_file.inc
+--let LOG=$MYSQLTEST_VARDIR/tmp/allow_to_start_after_corruption_debug.err
+--let SEARCH_FILE=$LOG
+
+# restart server to change error log and ignore corruptopn on startup
+--let $_mysqld_option=--log-error=$LOG --rocksdb_allow_to_start_after_corruption=1
+--source include/restart_mysqld_with_option.inc
+
+--echo #
+--echo #  Test server crashes on corrupted data and restarts
+--echo #
+create table t1 (
+  pk int not null primary key,
+  col1 varchar(10)
+) engine=rocksdb;
+
+insert into t1 values (1,1),(2,2),(3,3);
+
+select * from t1 where pk=1;
+set session debug= "+d,rocksdb_return_status_corrupted";
+--exec echo "wait" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--error 2013
+select * from t1 where pk=1;
+--source include/wait_until_disconnected.inc
+--let SEARCH_PATTERN=data corruption detected
+--source include/search_pattern_in_file.inc
+--remove_file $LOG
+
+--echo #
+--echo #  The same for scan queries
+--echo #
+
+--source include/start_mysqld_with_option.inc
+select * from t1;
+set session debug= "+d,rocksdb_return_status_corrupted";
+--exec echo "wait" > $_expect_file_name
+--error 2013
+select * from t1;
+--source include/wait_until_disconnected.inc
+--let SEARCH_PATTERN=data corruption detected
+--source include/search_pattern_in_file.inc
+--remove_file $LOG
+
+--echo #
+--echo #  Test restart failure. The server is shutdown at this point.
+--echo #
+
+# remove flag to ignore corruption
+--let $_mysqld_option=--log-error=$LOG
+--error 0
+--exec $MYSQLD_CMD $_mysqld_option
+--let SEARCH_PATTERN=The server will exit normally and stop restart attempts
+--source include/search_pattern_in_file.inc
+--remove_file $LOG
+
+--echo #
+--echo #  Remove corruption file and restart cleanly
+--echo #
+
+--exec rm $MYSQLTEST_VARDIR/mysqld.$_server_id/data/.rocksdb/ROCKSDB_CORRUPTED
+--source include/start_mysqld_with_option.inc
+
+drop table t1;
+
+# Restart mysqld with default options
+--source include/restart_mysqld.inc

storage/rocksdb/mysql-test/rocksdb/t/autoinc_crash_safe.cnf

@@ -0,0 +1,8 @@
+!include suite/rpl/my.cnf
+
+[mysqld.1]
+binlog_format=row
+[mysqld.2]
+binlog_format=row
+slave_parallel_workers=1
+rpl_skip_tx_api=ON

storage/rocksdb/mysql-test/rocksdb/t/autoinc_crash_safe.test

@@ -0,0 +1,9 @@
+--source include/have_rocksdb.inc
+--source include/have_binlog_format_row.inc
+--source include/master-slave.inc
+
+create table t (i int primary key auto_increment) engine=rocksdb;
+
+--source suite/rocksdb/include/autoinc_crash_safe.inc
+
+--source include/rpl_end.inc

storage/rocksdb/mysql-test/rocksdb/t/autoinc_crash_safe_partition.cnf

@@ -0,0 +1,8 @@
+!include suite/rpl/my.cnf
+
+[mysqld.1]
+binlog_format=row
+[mysqld.2]
+binlog_format=row
+slave_parallel_workers=1
+rpl_skip_tx_api=ON

storage/rocksdb/mysql-test/rocksdb/t/autoinc_crash_safe_partition.test

@@ -0,0 +1,10 @@
+--source include/have_rocksdb.inc
+--source include/have_binlog_format_row.inc
+--source include/master-slave.inc
+--source include/have_partition.inc
+
+create table t (i int primary key auto_increment) engine=rocksdb partition by key (i) partitions 3;
+
+--source suite/rocksdb/include/autoinc_crash_safe.inc
+
+--source include/rpl_end.inc

storage/rocksdb/mysql-test/rocksdb/t/autoinc_debug-master.opt

@@ -0,0 +1 @@
+--binlog-format=row

storage/rocksdb/mysql-test/rocksdb/t/autoinc_debug.test

@@ -0,0 +1,118 @@
+--source include/have_rocksdb.inc
+--source include/have_debug.inc
+--source include/have_log_bin.inc
+
+--echo #
+--echo # Testing upgrading from server without merges for auto_increment
+--echo # to new server with such support.
+--echo #
+
+set debug='+d,myrocks_autoinc_upgrade';
+create table t (i int primary key auto_increment);
+insert into t values ();
+insert into t values ();
+insert into t values ();
+select * from t;
+
+delete from t where i > 1;
+select * from t;
+
+select table_name, index_name, auto_increment
+  from information_schema.rocksdb_ddl where table_name = 't';
+
+set debug='-d,myrocks_autoinc_upgrade';
+
+--source include/restart_mysqld.inc
+
+insert into t values ();
+insert into t values ();
+insert into t values ();
+select * from t;
+
+select table_name, index_name, auto_increment
+  from information_schema.rocksdb_ddl where table_name = 't';
+
+delete from t where i > 1;
+
+--source include/restart_mysqld.inc
+
+insert into t values ();
+insert into t values ();
+insert into t values ();
+select * from t;
+
+drop table t;
+
+--echo #
+--echo # Testing crash safety of transactions.
+--echo #
+create table t (i int primary key auto_increment);
+insert into t values ();
+insert into t values ();
+insert into t values ();
+
+--echo # Before anything
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_before";
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--error 2013
+commit;
+--source include/wait_until_disconnected.inc
+--enable_reconnect
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--source include/wait_until_connected_again.inc
+--disable_reconnect
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+select max(i) from t;
+
+--echo # After engine prepare
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_after_prepare";
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--error 2013
+commit;
+--source include/wait_until_disconnected.inc
+--enable_reconnect
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--source include/wait_until_connected_again.inc
+--disable_reconnect
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+select max(i) from t;
+
+--echo # After binlog
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_after_log";
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--error 2013
+commit;
+--source include/wait_until_disconnected.inc
+--enable_reconnect
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--source include/wait_until_connected_again.inc
+--disable_reconnect
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+select max(i) from t;
+
+--echo # After everything
+begin;
+insert into t values ();
+insert into t values ();
+set debug="+d,crash_commit_after";
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--error 2013
+commit;
+--source include/wait_until_disconnected.inc
+--enable_reconnect
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--source include/wait_until_connected_again.inc
+--disable_reconnect
+select table_schema, table_name, auto_increment from information_schema.tables where table_name = 't';
+select max(i) from t;
+
+drop table t;

storage/rocksdb/mysql-test/rocksdb/t/autoinc_vars.test

@@ -64,4 +64,42 @@ SELECT LAST_INSERT_ID();
 SELECT a FROM t1 ORDER BY a;
 DROP TABLE t1;
 
+--echo #---------------------------
+--echo # test large autoincrement values
+--echo #---------------------------
 
+SET auto_increment_increment = 1;
+SET auto_increment_offset = 1;
+CREATE TABLE t1 (a BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, b CHAR(8)) ENGINE=rocksdb;
+INSERT INTO t1 VALUES (18446744073709551613, 'a');
+SHOW CREATE TABLE t1;
+INSERT INTO t1 VALUES (NULL, 'b');
+SHOW CREATE TABLE t1;
+--error ER_AUTOINC_READ_FAILED
+INSERT INTO t1 VALUES (NULL, 'c');
+SELECT * FROM t1;
+DROP TABLE t1;
+
+SET auto_increment_increment = 300;
+CREATE TABLE t1 (a BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, b CHAR(8)) ENGINE=rocksdb;
+INSERT INTO t1 VALUES (18446744073709551613, 'a');
+SHOW CREATE TABLE t1;
+--error ER_AUTOINC_READ_FAILED
+INSERT INTO t1 VALUES (NULL, 'b');
+SHOW CREATE TABLE t1;
+--error ER_AUTOINC_READ_FAILED
+INSERT INTO t1 VALUES (NULL, 'c');
+SELECT * FROM t1;
+DROP TABLE t1;
+
+SET auto_increment_offset = 200;
+CREATE TABLE t1 (a BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, b CHAR(8)) ENGINE=rocksdb;
+INSERT INTO t1 VALUES (18446744073709551613, 'a');
+SHOW CREATE TABLE t1;
+--error ER_AUTOINC_READ_FAILED
+INSERT INTO t1 VALUES (NULL, 'b');
+SHOW CREATE TABLE t1;
+--error ER_AUTOINC_READ_FAILED
+INSERT INTO t1 VALUES (NULL, 'c');
+SELECT * FROM t1;
+DROP TABLE t1;

storage/rocksdb/mysql-test/rocksdb/t/autoincrement.test

@@ -1,3 +0,0 @@
---source include/have_rocksdb.inc
-
---echo # The test checks AUTO_INCREMENT capabilities that are not supported by RocksDB-SE.

storage/rocksdb/mysql-test/rocksdb/t/bulk_load.test

@@ -7,4 +7,4 @@
 --let pk_cf=cf1
 --let data_order_desc=0
 
---source bulk_load.inc
+--source ../include/bulk_load.inc

storage/rocksdb/mysql-test/rocksdb/t/bulk_load_drop_table.test

@@ -0,0 +1,19 @@
+--source include/have_rocksdb.inc
+
+CREATE TABLE t1 (pk INT, PRIMARY KEY (pk)) ENGINE=ROCKSDB;
+
+SET rocksdb_bulk_load_allow_unsorted=1;
+SET rocksdb_bulk_load=1;
+
+INSERT INTO t1 VALUES (1);
+
+--connect (con1,localhost,root,,)
+DROP TABLE t1;
+
+--connection default
+--disconnect con1
+
+# This would have crashed the server prior to the fix
+SET rocksdb_bulk_load=0;
+--error ER_NO_SUCH_TABLE
+SELECT * FROM t1;

storage/rocksdb/mysql-test/rocksdb/t/bulk_load_errors.test

@@ -1,7 +1,13 @@
 --source include/have_rocksdb.inc
+--source include/count_sessions.inc
+
+--let LOG1=$MYSQLTEST_VARDIR/tmp/rocksdb.bulk_load_errors.1.err
+--let $_mysqld_option=--log-error=$LOG1
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+--source include/restart_mysqld_with_option.inc
 
 ### Bulk load ###
-CREATE TABLE t1(pk INT, PRIMARY KEY(pk));
+CREATE TABLE t1(pk INT, PRIMARY KEY(pk)) ENGINE=ROCKSDB;
 
 # Make sure we get an error with out of order keys during bulk load
 SET rocksdb_bulk_load=1;
@@ -21,18 +27,51 @@ INSERT INTO t1 VALUES(2);
 INSERT INTO t1 VALUES(20);
 INSERT INTO t1 VALUES(21);
 
---echo # 
---echo # In MyRocks, the following statement will intentionally crash the server.
---echo # In MariaDB, it will cause an error
 --error ER_OVERLAPPING_KEYS
 SET rocksdb_bulk_load=0;
 
+SHOW VARIABLES LIKE 'rocksdb_bulk_load';
+call mtr.add_suppression('finalizing last SST file while setting bulk loading variable');
+
 --echo #
 --echo # Despite the error, bulk load operation is over so the variable value
 --echo # will be 0:
-select @@rocksdb_bulk_load;
+SELECT * FROM t1;
 
-call mtr.add_suppression('finalizing last SST file while setting bulk loading variable');
+--let SEARCH_FILE=$LOG1
+--let SEARCH_PATTERN=RocksDB: Error 198 finalizing last SST file while setting bulk loading variable
+--source include/search_pattern_in_file.inc
+
+--let LOG2=$MYSQLTEST_VARDIR/tmp/rocksdb.bulk_load_errors.2.err
+--let $_mysqld_option=--log-error=$LOG2
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+--source include/restart_mysqld_with_option.inc
+--remove_file $LOG1
+
+
+# Make sure we get an error in log when we disconnect and do not assert the server
+--connect (con1,localhost,root,,)
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES(1);
+INSERT INTO t1 VALUES(2);
+INSERT INTO t1 VALUES(20);
+INSERT INTO t1 VALUES(21);
+--connection default
+--disconnect con1
+
+SELECT * FROM t1;
+
+--source include/wait_until_count_sessions.inc
+
+--let SEARCH_FILE=$LOG2
+--let SEARCH_PATTERN=RocksDB: Error 198 finalizing last SST file while disconnecting
+--source include/search_pattern_in_file.inc
+
+--let LOG3=$MYSQLTEST_VARDIR/tmp/rocksdb.bulk_load_errors.3.err
+--let $_mysqld_option=--log-error=$LOG3
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+--source include/restart_mysqld_with_option.inc
+--remove_file $LOG2
 
 TRUNCATE TABLE t1;
 
@@ -60,3 +99,46 @@ SELECT * FROM t1;
 
 SET rocksdb_bulk_load_allow_unsorted=DEFAULT;
 DROP TABLE t1;
+
+# This would trigger a debug assertion that is just an error in release builds
+CREATE TABLE t1(c1 INT KEY) ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+--error ER_KEYS_OUT_OF_ORDER
+INSERT INTO t1 VALUES (),(),();
+SET rocksdb_bulk_load=0;
+DROP TABLE t1;
+
+# Crash when table open cache closes handler with bulk load operation not finalized
+SET @orig_table_open_cache=@@global.table_open_cache;
+CREATE TABLE t1(a INT AUTO_INCREMENT, b INT, PRIMARY KEY (a)) ENGINE=ROCKSDB DEFAULT CHARSET=latin1;
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES(13, 0);
+INSERT INTO t1 VALUES(2, 'test 2');
+INSERT INTO t1 VALUES(@id, @arg04);
+SET @@global.table_open_cache=FALSE;
+INSERT INTO t1 VALUES(51479+0.333333333,1);
+DROP TABLE t1;
+SET @@global.table_open_cache=@orig_table_open_cache;
+
+--let SEARCH_FILE=$LOG3
+--let SEARCH_PATTERN=RocksDB: Error 198 finalizing bulk load while closing handler
+--source include/search_pattern_in_file.inc
+
+--source include/restart_mysqld.inc
+
+--remove_file $LOG3
+
+# Switch between tables, but also introduce duplicate key errors
+CREATE TABLE t1 (pk INT, PRIMARY KEY (pk)) ENGINE=ROCKSDB;
+CREATE TABLE t2 (pk INT, PRIMARY KEY (pk)) ENGINE=ROCKSDB;
+SET rocksdb_bulk_load=1;
+INSERT INTO t1 VALUES (1), (2);
+INSERT INTO t2 VALUES (1), (2);
+INSERT INTO t1 VALUES (1);
+--error ER_OVERLAPPING_KEYS
+INSERT INTO t2 VALUES (3);
+SET rocksdb_bulk_load=0;
+DROP TABLE t1;
+DROP TABLE t2;
+
+--source include/wait_until_count_sessions.inc

storage/rocksdb/mysql-test/rocksdb/t/bulk_load_rev_cf.test

@@ -6,4 +6,4 @@
 --let pk_cf=rev:cf1
 --let data_order_desc=0
 
---source bulk_load.inc
+--source ../include/bulk_load.inc

storage/rocksdb/mysql-test/rocksdb/t/bulk_load_rev_cf_and_data.test

@@ -6,4 +6,4 @@
 --let pk_cf=rev:cf1
 --let data_order_desc=1
 
---source bulk_load.inc
+--source ../include/bulk_load.inc

storage/rocksdb/mysql-test/rocksdb/t/bulk_load_rev_data.test

@@ -6,4 +6,4 @@
 --let pk_cf=cf1
 --let data_order_desc=1
 
---source bulk_load.inc
+--source ../include/bulk_load.inc

storage/rocksdb/mysql-test/rocksdb/t/bulk_load_unsorted.test

@@ -3,136 +3,5 @@
 
 --let pk_cf=cf1
 
---disable_warnings
+--source ../include/bulk_load_unsorted.inc
-DROP TABLE IF EXISTS t1;
---enable_warnings
-
-SET rocksdb_bulk_load_size=3;
-SET rocksdb_bulk_load_allow_unsorted=1;
-
-### Test individual INSERTs ###
-
-# A table with only a PK won't have rows until the bulk load is finished
-eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf");
-SET rocksdb_bulk_load=1;
---disable_query_log
-let $sign = 1;
-let $max = 5;
-let $i = 1;
-while ($i <= $max) {
-  let $a = 1 + $sign * $i;
-  let $b = 1 - $sign * $i;
-  let $sign = -$sign;
-  let $insert = INSERT INTO t1 VALUES ($a, $b);
-  eval $insert;
-  inc $i;
-}
---enable_query_log
-SELECT * FROM t1;
-SET rocksdb_bulk_load=0;
-SELECT * FROM t1;
-DROP TABLE t1;
-
-# A table with a PK and a SK shows rows immediately
-eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf", KEY(b));
-SET rocksdb_bulk_load=1;
---disable_query_log
-let $sign = 1;
-let $max = 5;
-let $i = 1;
-while ($i <= $max) {
-  let $a = 1 + $sign * $i;
-  let $b = 1 - $sign * $i;
-  let $sign = -$sign;
-  let $insert = INSERT INTO t1 VALUES ($a, $b);
-  eval $insert;
-  inc $i;
-}
---enable_query_log
-
-SELECT * FROM t1;
-SET rocksdb_bulk_load=0;
-DROP TABLE t1;
-
-# Inserting into another table finishes bulk load to the previous table
-eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf");
-eval CREATE TABLE t2(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf");
-
-SET rocksdb_bulk_load=1;
-INSERT INTO t1 VALUES (1,1);
-INSERT INTO t2 VALUES (1,1);
-SELECT * FROM t1;
-INSERT INTO t1 VALUES (2,2);
-SELECT * FROM t2;
-SELECT * FROM t1;
-SET rocksdb_bulk_load=0;
-SELECT * FROM t1;
-DROP TABLE t1, t2;
-
-### Test bulk load from a file ###
-eval CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf");
-eval CREATE TABLE t2(a INT, b INT, PRIMARY KEY(b) COMMENT "$pk_cf");
-eval CREATE TABLE t3(a INT, b INT, PRIMARY KEY(a) COMMENT "$pk_cf")
-     PARTITION BY KEY() PARTITIONS 4;
-
---let $file = `SELECT CONCAT(@@datadir, "test_loadfile.txt")`
-# Create a text file with data to import into the table.
-# PK and SK are not in any order
---let ROCKSDB_INFILE = $file
-perl;
-my $fn = $ENV{'ROCKSDB_INFILE'};
-open(my $fh, '>', $fn) || die "perl open($fn): $!";
 binmode $fh;
-my $max = 5000000;
-my $sign = 1;
-for (my $ii = 0; $ii < $max; $ii++)
-{
-  my $a = 1 + $sign * $ii;
-  my $b = 1 - $sign * $ii;
-  print $fh "$a\t$b\n";
-}
-close($fh);
-EOF
---file_exists $file
-
-# Make sure a snapshot held by another user doesn't block the bulk load
-connect (other,localhost,root,,);
-set session transaction isolation level repeatable read;
-select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';
-start transaction with consistent snapshot;
-select * from information_schema.rocksdb_dbstats where stat_type='DB_NUM_SNAPSHOTS';
-
-connection default;
-set rocksdb_bulk_load=1;
-set rocksdb_bulk_load_size=100000;
---disable_query_log
---echo LOAD DATA INFILE <input_file> INTO TABLE t1;
-eval LOAD DATA INFILE '$file' INTO TABLE t1;
---echo LOAD DATA INFILE <input_file> INTO TABLE t2;
-eval LOAD DATA INFILE '$file' INTO TABLE t2;
---echo LOAD DATA INFILE <input_file> INTO TABLE t3;
-eval LOAD DATA INFILE '$file' INTO TABLE t3;
---enable_query_log
-set rocksdb_bulk_load=0;
-
---remove_file $file
-
-# Make sure row count index stats are correct
---replace_column 6 # 7 # 8 # 9 #
-SHOW TABLE STATUS WHERE name LIKE 't%';
-
-ANALYZE TABLE t1, t2, t3;
-
---replace_column 6 # 7 # 8 # 9 #
-SHOW TABLE STATUS WHERE name LIKE 't%';
-
-# Make sure all the data is there.
-select count(a) from t1;
-select count(b) from t1;
-select count(a) from t2;
-select count(b) from t2;
-select count(a) from t3;
-select count(b) from t3;
-
-DROP TABLE t1, t2, t3;
-SET rocksdb_bulk_load_allow_unsorted=0;

storage/rocksdb/mysql-test/rocksdb/t/bulk_load_unsorted_rev.test

@@ -0,0 +1,5 @@
+--source include/have_rocksdb.inc
+
+--let pk_cf=rev:cf1
+
+--source ../include/bulk_load_unsorted.inc

storage/rocksdb/mysql-test/rocksdb/t/cardinality.test

@@ -2,6 +2,48 @@
 
 --source include/restart_mysqld.inc
 
+# Test memtable cardinality statistics
+CREATE TABLE t0 (id int PRIMARY KEY, a int, INDEX ix_a (a))  engine=rocksdb;
+
+# populate the table with 10 reconds where cardinality of id is N and a is N/2.
+insert into t0 values (0, 0),(1, 1),(2, 2),(3, 3),(4, 4),
+(5, 4),(6, 4),(7, 4),(8, 4),(9, 4);
+
+# Assert no cardinality data exists before ANALYZE TABLE is done
+SELECT cardinality FROM information_schema.statistics where table_name="t0" and
+column_name="id";
+SELECT cardinality FROM information_schema.statistics where table_name="t0" and
+column_name="a";
+
+--disable_result_log
+ANALYZE TABLE t0;
+--enable_result_log
+
+SELECT table_rows into @N FROM information_schema.tables
+WHERE table_name = "t0";
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="id";
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="a";
+
+# Flush the table and re-run the test as statistics is calculated a bit
+# differently for memtable and SST files
+SET GLOBAL rocksdb_force_flush_memtable_now = 1;
+--disable_result_log
+ANALYZE TABLE t0;
+--enable_result_log
+
+SELECT table_rows into @N FROM information_schema.tables
+WHERE table_name = "t0";
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="id";
+SELECT FLOOR(@N/cardinality) FROM
+information_schema.statistics where table_name="t0" and column_name="a";
+
+drop table t0;
+
+# Test big table on SST
+
 --disable_warnings
 DROP TABLE IF EXISTS t1,t10,t11;
 --enable_warnings

storage/rocksdb/mysql-test/rocksdb/t/check_ignore_unknown_options.test

@@ -0,0 +1,21 @@
+--disable_warnings
+let $MYSQLD_DATADIR= `select @@datadir`;
+let $restart_file= $MYSQLTEST_VARDIR/tmp/mysqld.1.expect;
+let $error_log= $MYSQLTEST_VARDIR/log/my_restart.err;
+select variable_name, variable_value from information_schema.global_variables where variable_name="rocksdb_ignore_unknown_options";
+
+--exec find $MYSQLD_DATADIR/.rocksdb/OPTIONS* | sort -n | tail -1 | xargs -0 -I {} -t sh -c "echo hello=world>>{}"
+
+--exec echo "wait" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--shutdown_server 10
+--error 1
+--exec $MYSQLD_CMD --rocksdb_ignore_unknown_options=0 --loose-console > $error_log 2>&1
+
+let SEARCH_FILE= $error_log;
+let SEARCH_PATTERN= RocksDB: Compatibility check against existing database options failed;
+--source include/search_pattern_in_file.inc
+--enable_reconnect
+--exec echo "restart" > $restart_file
+--source include/wait_until_connected_again.inc
+--exec find $MYSQLD_DATADIR/.rocksdb/OPTIONS* | sort -n | tail -1 | xargs -0 -I {} -t sh -c "sed -i '/hello=world/d' {}"
+select variable_name, variable_value from information_schema.global_variables where variable_name="rocksdb_ignore_unknown_options";

storage/rocksdb/mysql-test/rocksdb/t/deadlock_tracking.test

@@ -77,8 +77,10 @@ let $wait_condition = select count(*) = 1 from information_schema.rocksdb_trx
 where thread_id = $con2 and waiting_key != "";
 --source include/wait_condition.inc
 
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_row_lock_deadlocks';
 --error ER_LOCK_DEADLOCK
 select * from t where i=1 for update;
+select case when variable_value-@a = 1 then 'true' else 'false' end as deadlocks from information_schema.global_status where variable_name='rocksdb_row_lock_deadlocks';
 rollback;
 
 connection con2;

storage/rocksdb/mysql-test/rocksdb/t/i_s_ddl.test

@@ -7,6 +7,7 @@
 --disable_warnings
 DROP TABLE IF EXISTS is_ddl_t1;
 DROP TABLE IF EXISTS is_ddl_t2;
+DROP TABLE IF EXISTS is_ddl_t3;
 --enable_warnings
 
 CREATE TABLE is_ddl_t1 (i INT, j INT, k INT, l INT,
@@ -17,8 +18,12 @@ CREATE TABLE is_ddl_t2 (x INT, y INT, z INT,
                         PRIMARY KEY (z, y) COMMENT 'zy_cf',
                         KEY (x)) ENGINE = ROCKSDB;
 --sorted_result
-SELECT TABLE_SCHEMA,TABLE_NAME,PARTITION_NAME,INDEX_NAME,INDEX_TYPE,KV_FORMAT_VERSION,CF FROM INFORMATION_SCHEMA.ROCKSDB_DDL WHERE TABLE_NAME like 'is_ddl_t%';
+CREATE TABLE is_ddl_t3 (a INT, b INT, c INT, PRIMARY KEY (a)) ENGINE = ROCKSDB
+                        COMMENT "ttl_duration=3600;";
+
+SELECT TABLE_SCHEMA,TABLE_NAME,PARTITION_NAME,INDEX_NAME,INDEX_TYPE,KV_FORMAT_VERSION,CF,TTL_DURATION,INDEX_FLAGS FROM INFORMATION_SCHEMA.ROCKSDB_DDL WHERE TABLE_NAME like 'is_ddl_t%';
 
 # cleanup
 DROP TABLE is_ddl_t1;
 DROP TABLE is_ddl_t2;
+DROP TABLE is_ddl_t3;

storage/rocksdb/mysql-test/rocksdb/t/i_s_deadlock.test

@@ -0,0 +1,158 @@
+--source include/have_rocksdb.inc
+
+set @prior_lock_wait_timeout = @@rocksdb_lock_wait_timeout;
+set @prior_deadlock_detect = @@rocksdb_deadlock_detect;
+set @prior_max_latest_deadlocks = @@rocksdb_max_latest_deadlocks;
+set global rocksdb_deadlock_detect = on;
+set global rocksdb_lock_wait_timeout = 10000;
+--echo # Clears deadlock buffer of any prior deadlocks.
+set global rocksdb_max_latest_deadlocks = 0;
+set global rocksdb_max_latest_deadlocks = @prior_max_latest_deadlocks;
+
+# needed by simple_deadlock.inc
+let $engine = rocksdb;
+
+--source include/count_sessions.inc
+connect (con1,localhost,root,,);
+let $con1= `SELECT CONNECTION_ID()`;
+
+connect (con2,localhost,root,,);
+let $con2= `SELECT CONNECTION_ID()`;
+
+connect (con3,localhost,root,,);
+let $con3= `SELECT CONNECTION_ID()`;
+
+connection default;
+show create table information_schema.rocksdb_deadlock;
+
+create table t (i int primary key) engine=rocksdb;
+insert into t values (1), (2), (3);
+select * from information_schema.rocksdb_deadlock;
+
+echo Deadlock #1;
+--source include/simple_deadlock.inc
+connection default;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY
+select * from information_schema.rocksdb_deadlock;
+
+echo Deadlock #2;
+--source include/simple_deadlock.inc
+connection default;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY
+select * from information_schema.rocksdb_deadlock;
+set global rocksdb_max_latest_deadlocks = 10;
+
+echo Deadlock #3;
+--source include/simple_deadlock.inc
+connection default;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY
+select * from information_schema.rocksdb_deadlock;
+set global rocksdb_max_latest_deadlocks = 1;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY
+select * from information_schema.rocksdb_deadlock;
+
+connection con3;
+set rocksdb_deadlock_detect_depth = 2;
+
+echo Deadlock #4;
+connection con1;
+begin;
+select * from t where i=1 for update;
+
+connection con2;
+begin;
+select * from t where i=2 for update;
+
+connection con3;
+begin;
+select * from t where i=3 for update;
+
+connection con1;
+send select * from t where i=2 for update;
+
+connection con2;
+let $wait_condition = select count(*) = 1 from information_schema.rocksdb_trx
+where thread_id = $con1 and waiting_key != "";
+--source include/wait_condition.inc
+
+send select * from t where i=3 for update;
+
+connection con3;
+let $wait_condition = select count(*) = 1 from information_schema.rocksdb_trx
+where thread_id = $con2 and waiting_key != "";
+--source include/wait_condition.inc
+
+--error ER_LOCK_DEADLOCK
+select * from t where i=1 for update;
+rollback;
+
+connection con2;
+reap;
+rollback;
+
+connection con1;
+reap;
+rollback;
+
+connection default;
+set global rocksdb_max_latest_deadlocks = 5;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY
+select * from information_schema.rocksdb_deadlock;
+
+echo Deadlock #5;
+connection con1;
+begin;
+select * from t where i=1 for update;
+
+connection con2;
+begin;
+select * from t where i=2 for update;
+
+connection con3;
+begin;
+select * from t where i=3 lock in share mode;
+
+connection con1;
+select * from t where i=100 for update;
+select * from t where i=101 for update;
+send select * from t where i=2 for update;
+
+connection con2;
+let $wait_condition = select count(*) = 1 from information_schema.rocksdb_trx
+where thread_id = $con1 and waiting_key != "";
+--source include/wait_condition.inc
+
+select * from t where i=3 lock in share mode;
+select * from t where i=200 for update;
+select * from t where i=201 for update;
+
+--error ER_LOCK_DEADLOCK
+select * from t where i=1 lock in share mode;
+rollback;
+
+connection con1;
+reap;
+rollback;
+
+connection con3;
+rollback;
+
+connection default;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY
+select * from information_schema.rocksdb_deadlock;
+
+disconnect con1;
+disconnect con2;
+disconnect con3;
+
+set global rocksdb_lock_wait_timeout = @prior_lock_wait_timeout;
+set global rocksdb_deadlock_detect = @prior_deadlock_detect;
+drop table t;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY 6 INDEX_NAME 7 TABLE_NAME
+select * from information_schema.rocksdb_deadlock;
+set global rocksdb_max_latest_deadlocks = 0;
+--echo # Clears deadlock buffer of any existent deadlocks.
+set global rocksdb_max_latest_deadlocks = @prior_max_latest_deadlocks;
+--replace_column 1 DEADLOCK_ID 2 TRANSACTION_ID 4 WAITING_KEY
+select * from information_schema.rocksdb_deadlock;
+--source include/wait_until_count_sessions.inc

storage/rocksdb/mysql-test/rocksdb/t/index_merge_rocksdb.test

@@ -70,14 +70,15 @@ while ($cnt)
 
 SELECT COUNT(*) FROM t1;
 
+# flush the table first as statistics is calculated a bit differently for memtable and SST files
+SET GLOBAL rocksdb_force_flush_memtable_now = 1;
+
 -- disable_query_log
 -- disable_result_log
 ANALYZE TABLE t1;
 -- enable_result_log
 -- enable_query_log
 
-SET GLOBAL rocksdb_force_flush_memtable_now = 1;
-
 --replace_column 9 #
 EXPLAIN UPDATE t1 SET filler1='to be deleted' WHERE key1=100 AND key2=100;
 UPDATE t1 SET filler1='to be deleted' WHERE key1=100 and key2=100;
@@ -95,8 +96,8 @@ while ($i <= 1000) {
   eval $insert;
 }
 --enable_query_log
-analyze table t1;
 set global rocksdb_force_flush_memtable_now=1;
+analyze table t1;
 
 --replace_column 9 #
 explain select * from t1 where key1 = 1;

storage/rocksdb/mysql-test/rocksdb/t/index_merge_rocksdb2.test

@@ -5,7 +5,8 @@
 
 # t/index_merge_innodb.test
 #
-# Index merge tests
+# Index merge tests (the test is called 'index_merge_rocksdb2' because
+# 'index_merge_rocksdb' has already existed before copying 'index_merge_innodb')
 #
 # Last update:
 # 2006-08-07 ML test refactored (MySQL 5.1)
@@ -61,6 +62,7 @@ INSERT INTO t1 SELECT id + 16, 7, 0 FROM t1;
 
 -- disable_query_log
 -- disable_result_log
+set global rocksdb_force_flush_memtable_now=1;
 analyze table t1;
 -- enable_result_log
 -- enable_query_log

storage/rocksdb/mysql-test/rocksdb/t/insert_optimized_config-master.opt

@@ -1,4 +1,5 @@
 --rocksdb_write_disable_wal=1
+--rocksdb_flush_log_at_trx_commit=0
 --rocksdb_default_cf_options=write_buffer_size=16k;target_file_size_base=16k;level0_file_num_compaction_trigger=4;level0_slowdown_writes_trigger=256;level0_stop_writes_trigger=256;max_write_buffer_number=16;compression_per_level=kNoCompression;memtable=vector:1024
 --rocksdb_override_cf_options=__system__={memtable=skip_list:16}
 --rocksdb_compaction_sequential_deletes=0

storage/rocksdb/mysql-test/rocksdb/t/issue255.test

@@ -8,6 +8,38 @@ SHOW TABLE STATUS LIKE 't1';
 
 INSERT INTO t1 VALUES ('538647864786478647864');
 --replace_column 3 # 6 # 7 # 8 # 9 # 10 #
+SELECT * FROM t1;
+SHOW TABLE STATUS LIKE 't1';
+
+--error ER_DUP_ENTRY
+INSERT INTO t1 VALUES ();
+SELECT * FROM t1;
+--replace_column 3 # 6 # 7 # 8 # 9 # 10 #
+SHOW TABLE STATUS LIKE 't1';
+
+--error ER_DUP_ENTRY
+INSERT INTO t1 VALUES ();
+SELECT * FROM t1;
+--replace_column 3 # 6 # 7 # 8 # 9 # 10 #
+SHOW TABLE STATUS LIKE 't1';
+
+DROP TABLE t1;
+
+CREATE TABLE t1 (pk TINYINT NOT NULL PRIMARY KEY AUTO_INCREMENT);
+
+INSERT INTO t1 VALUES (5);
+--replace_column 3 # 6 # 7 # 8 # 9 # 10 #
+SHOW TABLE STATUS LIKE 't1';
+
+INSERT INTO t1 VALUES (1000);
+--replace_column 3 # 6 # 7 # 8 # 9 # 10 #
+SELECT * FROM t1;
+SHOW TABLE STATUS LIKE 't1';
+
+--error ER_DUP_ENTRY
+INSERT INTO t1 VALUES ();
+SELECT * FROM t1;
+--replace_column 3 # 6 # 7 # 8 # 9 # 10 #
 SHOW TABLE STATUS LIKE 't1';
 
 --error ER_DUP_ENTRY

storage/rocksdb/mysql-test/rocksdb/t/lock_wait_timeout_stats.test

@@ -16,16 +16,20 @@ set @@rocksdb_lock_wait_timeout=1;
 begin;
 
 --connection con1
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
 --error ER_LOCK_WAIT_TIMEOUT
 insert into t values(0);
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
+select case when variable_value-@a = 1 then 'true' else 'false' end as waits from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
 
 --connection con2
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
 --error ER_LOCK_WAIT_TIMEOUT
 insert into t values(0);
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
 select ROW_LOCK_WAIT_TIMEOUTS from information_schema.table_statistics where table_name="t";
+select case when variable_value-@a = 1 then 'true' else 'false' end as waits from information_schema.global_status where variable_name='rocksdb_row_lock_wait_timeouts';
 
 --disconnect con1
 --connection default

storage/rocksdb/mysql-test/rocksdb/t/max_open_files.test

@@ -0,0 +1,53 @@
+--source include/have_rocksdb.inc
+
+# Basic Sysbench run fails with basic MyROCKS install due to lack of open files
+
+# test for over limit
+CALL mtr.add_suppression("RocksDB: rocksdb_max_open_files should not be greater than the open_files_limit*");
+
+--let $over_rocksdb_max_open_files=`SELECT @@global.open_files_limit + 100`
+--let $under_rocksdb_max_open_files=`SELECT @@global.open_files_limit -1`
+--let SEARCH_FILE=$MYSQLTEST_VARDIR/tmp/rocksdb.max_open_files.err
+--let SEARCH_PATTERN=RocksDB: rocksdb_max_open_files should not be greater than the open_files_limit
+
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR $over_rocksdb_max_open_files over_rocksdb_max_open_files
+--let $_mysqld_option=--log-error=$SEARCH_FILE --rocksdb_max_open_files=$over_rocksdb_max_open_files
+--source include/restart_mysqld_with_option.inc
+--source include/search_pattern_in_file.inc
+
+SELECT FLOOR(@@global.open_files_limit / 2) = @@global.rocksdb_max_open_files;
+
+# test for within limit
+--let $_mysqld_option=--rocksdb_max_open_files=$under_rocksdb_max_open_files
+--source include/restart_mysqld_with_option.inc
+
+SELECT @@global.open_files_limit - 1 = @@global.rocksdb_max_open_files;
+
+# test for minimal value
+--let $_mysqld_option=--rocksdb_max_open_files=0
+--source include/restart_mysqld_with_option.inc
+
+SELECT @@global.rocksdb_max_open_files;
+
+# verify that we can still do work with no descriptor cache
+CREATE TABLE t1(a INT) ENGINE=ROCKSDB;
+INSERT INTO t1 VALUES(0),(1),(2),(3),(4);
+SET GLOBAL rocksdb_force_flush_memtable_and_lzero_now=1;
+DROP TABLE t1;
+
+# test for unlimited
+--let $_mysqld_option=--rocksdb_max_open_files=-1
+--source include/restart_mysqld_with_option.inc
+
+SELECT @@global.rocksdb_max_open_files;
+
+# test for auto-tune
+--let $_mysqld_option=--rocksdb_max_open_files=-2
+--source include/restart_mysqld_with_option.inc
+
+SELECT FLOOR(@@global.open_files_limit / 2) = @@global.rocksdb_max_open_files;
+
+# cleanup
+--let _$mysqld_option=
+--source include/restart_mysqld.inc
+--remove_file $SEARCH_FILE

storage/rocksdb/mysql-test/rocksdb/t/mysqldump.test

@@ -32,7 +32,7 @@ BEGIN;
 insert into r1 values (5,5,5,5,5,5,5,5);
 update r1 set value1=value1+100 where id1=1 and id2=1 and id3='1';
 
---exec $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key --rocksdb --order-by-primary-desc --rocksdb_bulk_load test
+--exec ASAN_OPTIONS="detect_leaks=0" $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key --rocksdb --order-by-primary-desc --rocksdb_bulk_load test
 
 rollback;
 
@@ -44,16 +44,16 @@ source include/search_pattern_in_file.inc;
 
 set @save_default_storage_engine=@@global.default_storage_engine;
 SET GLOBAL default_storage_engine=rocksdb;
---exec $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key test
+--exec ASAN_OPTIONS="detect_leaks=0" $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key test
 source include/search_pattern_in_file.inc;
 
 # Sanity test mysqldump when the --innodb-stats-on-metadata is specified (no effect)
 --echo ==== mysqldump with --innodb-stats-on-metadata ====
---exec $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key --innodb-stats-on-metadata test
+--exec ASAN_OPTIONS="detect_leaks=0" $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key --innodb-stats-on-metadata test
 
 # testing mysqldump work with statement based binary logging
 SET GLOBAL binlog_format=statement;
---exec $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key test > /dev/null
+--exec ASAN_OPTIONS="detect_leaks=0" $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key test > /dev/null
 SET GLOBAL binlog_format=row;
 
 drop table r1;

storage/rocksdb/mysql-test/rocksdb/t/mysqldump2.test

@@ -29,7 +29,7 @@ let $restart_file= $MYSQLTEST_VARDIR/tmp/mysqld.1.expect;
 
 select variable_value into @a from information_schema.global_status where variable_name='rocksdb_block_cache_add';
 
---exec $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key --rocksdb test > /dev/null
+--exec ASAN_OPTIONS="detect_leaks=0" $MYSQL_DUMP --skip-comments --single-transaction --master-data=2 --print-ordering-key --rocksdb test > /dev/null
 
 # verifying block cache was not filled
 select case when variable_value - @a > 20 then 'true' else 'false' end from information_schema.global_status where variable_name='rocksdb_block_cache_add';

storage/rocksdb/mysql-test/rocksdb/t/rocksdb.test

@@ -574,7 +574,6 @@ insert into t30 values
   ('row3', 'row3-key', 'row3-data'),
   ('row4', 'row4-key', 'row4-data'),
   ('row5', 'row5-key', 'row5-data');
-analyze table t30;
 
 --replace_column 9 #
 explain 
@@ -786,11 +785,16 @@ drop table t45;
 --echo # Now it fails if there is data overlap with what
 --echo # already exists
 --echo #
+# We exclude rocksdb_max_open_files here because it value is dependent on
+# the value of the servers open_file_limit and is expected to be different
+# across distros and installs
+show variables where variable_name like 'rocksdb%' and variable_name not like 'rocksdb_max_open_files';
 
 --replace_regex /[a-f0-9]{40}/#/
 show variables 
 where 
   variable_name like 'rocksdb%' and 
+  variable_name not like 'rocksdb_max_open_files' and
   variable_name not like 'rocksdb_supported_compression_types';
 
 create table t47 (pk int primary key, col1 varchar(12)) engine=rocksdb;

storage/rocksdb/mysql-test/rocksdb/t/rocksdb_debug.test

@@ -0,0 +1,14 @@
+--source include/have_rocksdb.inc
+--source include/have_debug.inc
+
+--echo #
+--echo # Issue #728: Assertion `covers_key(b)' failed in int
+--echo # myrocks::Rdb_key_def::cmp_full_keys(const rocks db::Slice&,
+--echo # const rocksdb::Slice&) 
+--echo #
+
+CREATE TABLE t2(c1 TINYINT SIGNED KEY,c2 TINYINT UNSIGNED,c3 INT);
+INSERT INTO t2(c1)VALUES(0);
+SELECT * FROM t2 WHERE c1<=127 ORDER BY c1 DESC;
+DROP TABLE t2;
+

storage/rocksdb/mysql-test/rocksdb/t/rocksdb_range2.test

@@ -15,6 +15,7 @@ while ($i<10000)
 --enable_query_log
 analyze table t1;
 select count(*) from t1;
+--replace_column 9 #
 explain select c1 from t1 where c1 > 5 limit 10;
 drop table t1;
 

storage/rocksdb/mysql-test/rocksdb/t/skip_validate_tmp_table.test

@@ -1,39 +1,36 @@
 --source include/have_rocksdb.inc
 --source include/have_debug.inc
 
-# Write file to make mysql-test-run.pl expect the "crash", but don't restart the
-# server until it is told to
 --let $_server_id= `SELECT @@server_id`
---let $_expect_file_name= $MYSQLTEST_VARDIR/tmp/mysqld.$_server_id.expect
 
-CREATE TABLE t1 (pk int primary key) ENGINE=ROCKSDB;
+create table t1 (pk int primary key) engine=rocksdb;
 
 # Create a .frm file without a matching table
 --exec cp $MYSQLTEST_VARDIR/mysqld.$_server_id/data/test/t1.frm $MYSQLTEST_VARDIR/mysqld.$_server_id/data/test/t1#sql-test.frm
 
-# Restart the server with a .frm file exist but that table is not registered in RocksDB
+--source include/restart_mysqld.inc
---exec echo "wait" >$_expect_file_name
+
-shutdown_server 10;
+show tables;
---exec echo "restart" >$_expect_file_name
---sleep 5
---enable_reconnect
---source include/wait_until_connected_again.inc
---disable_reconnect
 
 # This will append '#sql-test' to the end of new name
 set session debug_dbug="+d,gen_sql_table_name";
 rename table t1 to t2;
 set session debug_dbug= "-d,gen_sql_table_name";
 
+show tables;
+
 # Remove the corresponding .frm files
 --remove_files_wildcard $MYSQLTEST_VARDIR/mysqld.$_server_id/data/test *t1*.frm
 --remove_files_wildcard $MYSQLTEST_VARDIR/mysqld.$_server_id/data/test *t2*.frm
 
 # Restart the server with a table registered in RocksDB but does not have a .frm file
---exec echo "wait" >$_expect_file_name
+--source include/restart_mysqld.inc
-shutdown_server 10;
+
---exec echo "restart" >$_expect_file_name
+show tables;
---sleep 5
+
---enable_reconnect
+# try to recreate a table with the same name
---source include/wait_until_connected_again.inc
+create table t2 (pk int primary key) engine=rocksdb;
---disable_reconnect
+
+show tables;
+
+drop table t2;

storage/rocksdb/mysql-test/rocksdb/t/ttl_primary_read_filtering.test

@@ -78,22 +78,28 @@ INSERT INTO t1 values (7);
 set global rocksdb_debug_ttl_rec_ts = 0;
 
 # should return nothing.
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 --sorted_result
 SELECT * FROM t1;
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 
 # disable filtering
 set global rocksdb_enable_ttl_read_filtering=0;
 
 # should return everything
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 --sorted_result
 SELECT * FROM t1;
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 
-# disable filtering
+# enable filtering
 set global rocksdb_enable_ttl_read_filtering=1;
 
 # should return nothing.
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 --sorted_result
 SELECT * FROM t1;
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 
 DROP TABLE t1;
 
@@ -286,28 +292,37 @@ SELECT * FROM t1; # <= shouldn't be filtered out here
 
 --echo # Switching to connection 2
 connection con2;
-# compaction doesn't do anythign since con1 snapshot is still open
+# compaction doesn't do anything since con1 snapshot is still open
 set global rocksdb_force_flush_memtable_now=1;
 set global rocksdb_compact_cf='default';
 # read filtered out, because on a different connection, on
 # this connection the records have 'expired' already so they are filtered out
 # even though they have not yet been removed by compaction
+
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 --sorted_result
 SELECT * FROM t1;
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 
 --echo # Switching to connection 1
 connection con1;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 --sorted_result
 SELECT * FROM t1; # <= shouldn't be filtered out here
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 
 UPDATE t1 set a = a + 1;
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 --sorted_result
 SELECT * FROM t1; # <= shouldn't be filtered out here
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 
 COMMIT;
 
+select variable_value into @a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 --sorted_result # <= filtered out here because time has passed.
 SELECT * FROM t1;
+select variable_value-@a from information_schema.global_status where variable_name='rocksdb_rows_filtered';
 
 DROP TABLE t1;
 disconnect con1;

storage/rocksdb/mysql-test/rocksdb/t/type_varchar.test

@@ -1,9 +1,5 @@
 --source include/have_rocksdb.inc
 
---disable_warnings
-drop table if exists t1,t2;
---enable_warnings
-
 #
 # VARCHAR column types
 #
@@ -73,3 +69,14 @@ select 'email_i' as index_name, count(*) AS count from t force index(email_i);
 drop table t;
 set global rocksdb_checksums_pct = @save_rocksdb_checksums_pct;
 set session rocksdb_verify_row_debug_checksums = @save_rocksdb_verify_row_debug_checksums;
+
+# Issue #784 - Skip trailing space bytes for non-unpackable fields
+
+drop table if exists t;
+create table t (h varchar(31) character set utf8 collate utf8_bin not null, i varchar(19) collate latin1_bin not null, primary key(i), key(h)) engine=rocksdb;
+insert into t(i,h) values('a','b');
+check table t;
+alter table t modify h varchar(31) character set cp1257 collate cp1257_bin not null;
+check table t;
+drop table t;
+

storage/rocksdb/mysql-test/rocksdb/t/use_direct_reads_writes.test

@@ -11,37 +11,52 @@ select plugin_name, plugin_type from information_schema.plugins where plugin_nam
 # caused an assertion in RocksDB. Now it should not be allowed and ROCKSDB
 # plugin will not load in such configuration.
 #
-# We want the server to still start, so we specify default-storage-engine=myisam
+--let LOG=$MYSQLTEST_VARDIR/tmp/use_direct_reads_writes.err
+--let SEARCH_FILE=$LOG
 
---let $_mysqld_option=--rocksdb_use_direct_reads=1 --rocksdb_allow_mmap_reads=1 --default-storage-engine=myisam
+--echo Checking direct reads
+--let $_mysqld_option=--log-error=$LOG --rocksdb_use_direct_reads=1 --rocksdb_allow_mmap_reads=1
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+--source include/restart_mysqld_with_invalid_option.inc
+
+--let SEARCH_PATTERN=enable both use_direct_reads
+--source include/search_pattern_in_file.inc
+--remove_file $LOG
+
+
+# Repeat with direct-writes
+--echo Checking direct writes
+--let $_mysqld_option=--log-error=$LOG --rocksdb_use_direct_io_for_flush_and_compaction=1 --rocksdb_allow_mmap_writes=1
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+--source include/restart_mysqld_with_invalid_option.inc
+
+--let SEARCH_PATTERN=enable both use_direct_io_for_flush_and_compaction
+--source include/search_pattern_in_file.inc
+--remove_file $LOG
+
+select plugin_name, plugin_type from information_schema.plugins where plugin_name='RocksDB';
+
+# Verify invalid direct-writes and --rocksdb_flush_log_at_trx_commit combination at startup fails
+--echo Checking rocksdb_flush_log_at_trx_commit
+--let $_mysqld_option=--log-error=$LOG --rocksdb_flush_log_at_trx_commit=1 --rocksdb_allow_mmap_writes=1
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+--source include/restart_mysqld_with_invalid_option.inc
+
+--let SEARCH_PATTERN=rocksdb_flush_log_at_trx_commit needs to be
+--source include/search_pattern_in_file.inc
+--remove_file $LOG
+
+
+# Verify rocksdb_flush_log_at_trx_commit cannot be changed if direct writes are used
+--echo Validate flush_log settings when direct writes is enabled
+--let $_mysqld_option=--rocksdb_flush_log_at_trx_commit=0 --rocksdb_allow_mmap_writes=1
 --source include/restart_mysqld_with_option.inc
 
---echo # Check that ROCKSDB plugin is not loaded:
+set global rocksdb_flush_log_at_trx_commit=0;
-select plugin_name, plugin_type from information_schema.plugins where plugin_name='RocksDB';
+--error ER_WRONG_VALUE_FOR_VAR
+set global rocksdb_flush_log_at_trx_commit=1;
+--error ER_WRONG_VALUE_FOR_VAR
+set global rocksdb_flush_log_at_trx_commit=2;
 
---echo # Check that MyRocks has printed an error message into server error log:
+# Cleanup
-let SEARCH_FILE=$MYSQLTEST_VARDIR/log/mysqld.1.err;
-let SEARCH_PATTERN=enable both use_direct_reads;
-source include/search_pattern_in_file.inc;
-
---echo # Now, restart the server back with regular settings
 --source include/restart_mysqld.inc
-select plugin_name, plugin_type from information_schema.plugins where plugin_name='RocksDB';
-
---echo #
---echo # Now, repeat the same with another set of invalid arguments
---echo #
---let $_mysqld_option=--rocksdb_use_direct_io_for_flush_and_compaction=1 --rocksdb_allow_mmap_writes=1 --default-storage-engine=myisam
---source include/restart_mysqld_with_option.inc
-
---echo # Check that ROCKSDB plugin is not loaded:
-select plugin_name, plugin_type from information_schema.plugins where plugin_name='RocksDB';
-
-let SEARCH_FILE=$MYSQLTEST_VARDIR/log/mysqld.1.err;
-let SEARCH_PATTERN=enable both use_direct_io_for_flush_and_compaction;
-source include/search_pattern_in_file.inc;
-
---echo # Now, restart the server back with regular settings
---source include/restart_mysqld.inc
-select plugin_name, plugin_type from information_schema.plugins where plugin_name='RocksDB';
-

storage/rocksdb/mysql-test/rocksdb/t/write_sync.test

@@ -7,7 +7,8 @@ SET GLOBAL rocksdb_write_ignore_missing_column_families=true;
 create table aaa (id int primary key, i int) engine rocksdb;
 set @save_rocksdb_flush_log_at_trx_commit=@@global.rocksdb_flush_log_at_trx_commit;
 SET GLOBAL rocksdb_flush_log_at_trx_commit=1;
---exec sleep 5
+insert aaa(id, i) values(0,1);
+
 select variable_value into @a from information_schema.global_status where variable_name='rocksdb_wal_synced';
 insert aaa(id, i) values(1,1);
 select variable_value-@a from information_schema.global_status where variable_name='rocksdb_wal_synced';
@@ -16,18 +17,16 @@ select variable_value-@a from information_schema.global_status where variable_na
 insert aaa(id, i) values(3,1);
 select variable_value-@a from information_schema.global_status where variable_name='rocksdb_wal_synced';
 
-SET GLOBAL rocksdb_flush_log_at_trx_commit=0;
---exec sleep 5
 select variable_value into @a from information_schema.global_status where variable_name='rocksdb_wal_synced';
+SET GLOBAL rocksdb_flush_log_at_trx_commit=0;
 insert aaa(id, i) values(4,1);
 
 let $status_var=rocksdb_wal_synced;
 let $status_var_value=`select @a+1`;
 source include/wait_for_status_var.inc;
 
-SET GLOBAL rocksdb_flush_log_at_trx_commit=2;
---exec sleep 5
 select variable_value into @a from information_schema.global_status where variable_name='rocksdb_wal_synced';
+SET GLOBAL rocksdb_flush_log_at_trx_commit=2;
 insert aaa(id, i) values(5,1);
 
 let $status_var=rocksdb_wal_synced;

storage/rocksdb/mysql-test/rocksdb_rpl/include/rpl_no_unique_check_on_lag.inc

@@ -30,6 +30,7 @@ INSERT INTO t1 VALUES(1, 1);
 connection slave;
 --let $slave_sql_errno= 1062
 --let $not_switch_connection= 0
+--let $slave_timeout= 120
 --source include/wait_for_slave_sql_error_and_skip.inc
 set global reset_seconds_behind_master=0;
 --source include/stop_slave_io.inc

storage/rocksdb/mysql-test/rocksdb_rpl/r/singledelete_idempotent_recovery.result

@@ -10,6 +10,7 @@ insert into r1 values (1, 1000);
 set global rocksdb_force_flush_memtable_now=1;
 include/rpl_start_server.inc [server_number=2]
 include/start_slave.inc
+insert into r1 values (2,2000);
 delete r1 from r1 force index (i) where id2=1000;
 select id1,id2 from r1 force index (primary) where id1=1 and id2=1000;
 id1	id2

storage/rocksdb/mysql-test/rocksdb_rpl/t/multiclient_2pc.test

@@ -62,6 +62,7 @@ SET GLOBAL SYNC_BINLOG = 1;
 
 insert into t1 values (1000000, 1, "i_am_just_here_to_trigger_a_flush");
 
+--error 0,2013
 SET DEBUG_SYNC='now SIGNAL go';
 --source include/wait_until_disconnected.inc
 --enable_reconnect

storage/rocksdb/mysql-test/rocksdb_rpl/t/singledelete_idempotent_recovery.test

@@ -53,8 +53,14 @@ EOF
 
 --source include/rpl_start_server.inc
 --source include/start_slave.inc
+
+# Due to the binlogs being truncated, the slave may still think it's processed up to
+# the truncated binlog and select master_pos_wait() can return prematurely. Add
+# a new transaction to the master to force master_pos_wait() to wait.
 connection master;
+insert into r1 values (2,2000);
 sync_slave_with_master;
+
 connection slave;
 delete r1 from r1 force index (i) where id2=1000;
 select id1,id2 from r1 force index (primary) where id1=1 and id2=1000;

storage/rocksdb/mysql-test/rocksdb_stress/r/rocksdb_stress.result

@@ -9,6 +9,8 @@ zero_sum INT DEFAULT 0,
 msg VARCHAR(1024),
 msg_length int,
 msg_checksum varchar(128),
+auto_inc BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+KEY(auto_inc),
 KEY msg_i(msg(255), zero_sum))
 ENGINE=RocksDB DEFAULT CHARSET=latin1 COLLATE=latin1_bin;
 stop slave;

storage/rocksdb/mysql-test/rocksdb_stress/r/rocksdb_stress_crash.result

@@ -9,6 +9,8 @@ zero_sum INT DEFAULT 0,
 msg VARCHAR(1024),
 msg_length int,
 msg_checksum varchar(128),
+auto_inc BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+KEY(auto_inc),
 KEY msg_i(msg(255), zero_sum))
 ENGINE=RocksDB DEFAULT CHARSET=latin1 COLLATE=latin1_bin;
 stop slave;

storage/rocksdb/mysql-test/rocksdb_stress/t/load_generator.py

@@ -95,6 +95,8 @@ LOADERS_READY = 0
 REQUEST_ID = 1
 REQUEST_ID_LOCK = threading.Lock()
 
+INSERT_ID_SET = set()
+
 def get_next_request_id():
   global REQUEST_ID
   with REQUEST_ID_LOCK:
@@ -302,10 +304,19 @@ class PopulateWorker(WorkerThread):
       execute(self.cur, stmt)
       if i % 101 == 0:
         self.con.commit()
+        check_id(self.con.insert_id())
     self.con.commit()
+    check_id(self.con.insert_id())
     logging.info("Inserted %d rows starting at id %d" %
                  (self.num_to_add, self.start_id))
 
+def check_id(id):
+  if id == 0:
+    return
+  if id in INSERT_ID_SET:
+    raise Exception("Duplicate auto_inc id %d" % id)
+  INSERT_ID_SET.add(id)
+
 def populate_table(num_records):
 
   logging.info("Populate_table started for %d records" % num_records)
@@ -422,6 +433,7 @@ class LoadGenWorker(WorkerThread):
       execute(self.cur, gen_insert(self.table, idx, self.thread_id,
                                    request_id, 0))
       self.con.commit()
+      check_id(self.con.insert_id())
 
     self.id_map.append(request_id)
 
@@ -687,6 +699,7 @@ class LoadGenWorker(WorkerThread):
     else:
       self.cur_txn_state = self.TXN_COMMIT_STARTED
       self.con.commit()
+      check_id(self.con.insert_id())
       if not self.con.get_server_info():
         raise MySQLdb.OperationalError(MySQLdb.constants.CR.CONNECTION_ERROR,
                                        "Possible connection error on commit")

storage/rocksdb/mysql-test/rocksdb_stress/t/rocksdb_stress.test

@@ -17,6 +17,8 @@ CREATE TABLE t1(id INT PRIMARY KEY,
                msg VARCHAR(1024),
                msg_length int,
                msg_checksum varchar(128),
+               auto_inc BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+               KEY(auto_inc),
                KEY msg_i(msg(255), zero_sum))
 ENGINE=RocksDB DEFAULT CHARSET=latin1 COLLATE=latin1_bin;
 

storage/rocksdb/mysql-test/rocksdb_stress/t/rocksdb_stress_crash.test

@@ -18,6 +18,8 @@ CREATE TABLE t1(id INT PRIMARY KEY,
                msg VARCHAR(1024),
                msg_length int,
                msg_checksum varchar(128),
+               auto_inc BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+               KEY(auto_inc),
                KEY msg_i(msg(255), zero_sum))
 ENGINE=RocksDB DEFAULT CHARSET=latin1 COLLATE=latin1_bin;
 

storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_allow_to_start_after_corruption_basic.result

@@ -0,0 +1,7 @@
+SET @start_global_value = @@global.ROCKSDB_ALLOW_TO_START_AFTER_CORRUPTION;
+SELECT @start_global_value;
+@start_global_value
+0
+"Trying to set variable @@global.ROCKSDB_ALLOW_TO_START_AFTER_CORRUPTION to 444. It should fail because it is readonly."
+SET @@global.ROCKSDB_ALLOW_TO_START_AFTER_CORRUPTION   = 444;
+ERROR HY000: Variable 'rocksdb_allow_to_start_after_corruption' is a read only variable

storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_bytes_per_sync_basic.result

@@ -1,7 +1,85 @@
+CREATE TABLE valid_values (value varchar(255)) ENGINE=myisam;
+INSERT INTO valid_values VALUES(100);
+INSERT INTO valid_values VALUES(1);
+INSERT INTO valid_values VALUES(0);
+CREATE TABLE invalid_values (value varchar(255)) ENGINE=myisam;
+INSERT INTO invalid_values VALUES('\'aaa\'');
+INSERT INTO invalid_values VALUES('\'bbb\'');
+INSERT INTO invalid_values VALUES('\'-1\'');
+INSERT INTO invalid_values VALUES('\'101\'');
+INSERT INTO invalid_values VALUES('\'484436\'');
 SET @start_global_value = @@global.ROCKSDB_BYTES_PER_SYNC;
 SELECT @start_global_value;
 @start_global_value
 0
-"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to 444. It should fail because it is readonly."
+'# Setting to valid values in global scope#'
-SET @@global.ROCKSDB_BYTES_PER_SYNC   = 444;
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to 100"
-ERROR HY000: Variable 'rocksdb_bytes_per_sync' is a read only variable
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = 100;
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+100
+"Setting the global scope variable back to default"
+SET @@global.ROCKSDB_BYTES_PER_SYNC = DEFAULT;
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to 1"
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = 1;
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+1
+"Setting the global scope variable back to default"
+SET @@global.ROCKSDB_BYTES_PER_SYNC = DEFAULT;
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to 0"
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = 0;
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Setting the global scope variable back to default"
+SET @@global.ROCKSDB_BYTES_PER_SYNC = DEFAULT;
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Trying to set variable @@session.ROCKSDB_BYTES_PER_SYNC to 444. It should fail because it is not session."
+SET @@session.ROCKSDB_BYTES_PER_SYNC   = 444;
+ERROR HY000: Variable 'rocksdb_bytes_per_sync' is a GLOBAL variable and should be set with SET GLOBAL
+'# Testing with invalid values in global scope #'
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to 'aaa'"
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = 'aaa';
+Got one of the listed errors
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to 'bbb'"
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = 'bbb';
+Got one of the listed errors
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to '-1'"
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = '-1';
+Got one of the listed errors
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to '101'"
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = '101';
+Got one of the listed errors
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+"Trying to set variable @@global.ROCKSDB_BYTES_PER_SYNC to '484436'"
+SET @@global.ROCKSDB_BYTES_PER_SYNC   = '484436';
+Got one of the listed errors
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+SET @@global.ROCKSDB_BYTES_PER_SYNC = @start_global_value;
+SELECT @@global.ROCKSDB_BYTES_PER_SYNC;
+@@global.ROCKSDB_BYTES_PER_SYNC
+0
+DROP TABLE valid_values;
+DROP TABLE invalid_values;

storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_flush_memtable_on_analyze_basic.result

@@ -1,58 +0,0 @@
-drop table if exists t1;
-CREATE TABLE t1 (a INT AUTO_INCREMENT, b INT, PRIMARY KEY(a)) ENGINE=rocksdb;
-SHOW CREATE TABLE t1;
-Table	Create Table
-t1	CREATE TABLE `t1` (
-  `a` int(11) NOT NULL AUTO_INCREMENT,
-  `b` int(11) DEFAULT NULL,
-  PRIMARY KEY (`a`)
-) ENGINE=ROCKSDB DEFAULT CHARSET=latin1
-INSERT INTO t1 (b) VALUES (1);
-INSERT INTO t1 (b) VALUES (2);
-INSERT INTO t1 (b) VALUES (3);
-SELECT * FROM t1;
-a	b
-1	1
-2	2
-3	3
-set session rocksdb_flush_memtable_on_analyze=off;
-ANALYZE TABLE t1;
-Table	Op	Msg_type	Msg_text
-test.t1	analyze	status	OK
-SHOW INDEXES FROM t1;
-Table	Non_unique	Key_name	Seq_in_index	Column_name	Collation	Cardinality	Sub_part	Packed	Null	Index_type	Comment	Index_comment
-t1	0	PRIMARY	1	a	A	3	NULL	NULL		LSMTREE		
-set session rocksdb_flush_memtable_on_analyze=on;
-ANALYZE TABLE t1;
-Table	Op	Msg_type	Msg_text
-test.t1	analyze	status	OK
-SHOW INDEXES FROM t1;
-Table	Non_unique	Key_name	Seq_in_index	Column_name	Collation	Cardinality	Sub_part	Packed	Null	Index_type	Comment	Index_comment
-t1	0	PRIMARY	1	a	A	3	NULL	NULL		LSMTREE		
-DROP TABLE t1;
-CREATE TABLE t1 (a INT AUTO_INCREMENT, b INT, PRIMARY KEY(a)) ENGINE=rocksdb;
-SHOW CREATE TABLE t1;
-Table	Create Table
-t1	CREATE TABLE `t1` (
-  `a` int(11) NOT NULL AUTO_INCREMENT,
-  `b` int(11) DEFAULT NULL,
-  PRIMARY KEY (`a`)
-) ENGINE=ROCKSDB DEFAULT CHARSET=latin1
-INSERT INTO t1 (b) VALUES (1);
-INSERT INTO t1 (b) VALUES (2);
-INSERT INTO t1 (b) VALUES (3);
-SELECT * FROM t1;
-a	b
-1	1
-2	2
-3	3
-SHOW TABLE STATUS LIKE 't1';
-Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
-t1	ROCKSDB	10	Fixed	#	#	#	0	0	0	4	NULL	NULL	NULL	latin1_swedish_ci	NULL		
-ANALYZE TABLE t1;
-Table	Op	Msg_type	Msg_text
-test.t1	analyze	status	OK
-SHOW TABLE STATUS LIKE 't1';
-Name	Engine	Version	Row_format	Rows	Avg_row_length	Data_length	Max_data_length	Index_length	Data_free	Auto_increment	Create_time	Update_time	Check_time	Collation	Checksum	Create_options	Comment
-t1	ROCKSDB	10	Fixed	#	#	#	0	0	0	4	NULL	NULL	NULL	latin1_swedish_ci	NULL		
-DROP TABLE t1;

storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_ignore_unknown_options_basic.result

@@ -0,0 +1,14 @@
+CREATE TABLE valid_values (value varchar(255)) ENGINE=myisam;
+INSERT INTO valid_values VALUES(1);
+INSERT INTO valid_values VALUES(1024);
+CREATE TABLE invalid_values (value varchar(255)) ENGINE=myisam;
+INSERT INTO invalid_values VALUES('\'aaa\'');
+SET @start_global_value = @@global.ROCKSDB_IGNORE_UNKNOWN_OPTIONS;
+SELECT @start_global_value;
+@start_global_value
+1
+"Trying to set variable @@global.ROCKSDB_IGNORE_UNKNOWN_OPTIONS to 444. It should fail because it is readonly."
+SET @@global.ROCKSDB_IGNORE_UNKNOWN_OPTIONS   = 444;
+ERROR HY000: Variable 'rocksdb_ignore_unknown_options' is a read only variable
+DROP TABLE valid_values;
+DROP TABLE invalid_values;

storage/rocksdb/mysql-test/rocksdb_sys_vars/r/rocksdb_max_open_files_basic.result

@@ -1,7 +1,3 @@
-SET @start_global_value = @@global.ROCKSDB_MAX_OPEN_FILES;
+show variables like 'rocksdb_max_open_files';
-SELECT @start_global_value;
+Variable_name	Value
-@start_global_value
+rocksdb_max_open_files	#
--1
-"Trying to set variable @@global.ROCKSDB_MAX_OPEN_FILES to 444. It should fail because it is readonly."
-SET @@global.ROCKSDB_MAX_OPEN_FILES   = 444;
-ERROR HY000: Variable 'rocksdb_max_open_files' is a read only variable