You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by mj...@apache.org on 2019/01/31 00:13:29 UTC

[kafka] branch trunk updated: KAFKA-3522: Add RocksDBTimestampedStore (#6149)

This is an automated email from the ASF dual-hosted git repository.

mjsax pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git


The following commit(s) were added to refs/heads/trunk by this push:
     new 73565b7  KAFKA-3522: Add RocksDBTimestampedStore (#6149)
73565b7 is described below

commit 73565b7f679c281f83a5df11e662b0f27cb1e55d
Author: Matthias J. Sax <mj...@apache.org>
AuthorDate: Wed Jan 30 16:13:19 2019 -0800

    KAFKA-3522: Add RocksDBTimestampedStore (#6149)
    
    Reviewers: Bill Bejeck <bi...@confluent.io>, John Roesler <jo...@confluent.io>, Guozhang Wang <gu...@confluent.io>
---
 .../org/apache/kafka/streams/state/Stores.java     |    2 +-
 ...tionsToDbOptionsColumnFamilyOptionsAdapter.java | 1362 ++++++++++++++++++++
 .../state/internals/RocksDBRangeIterator.java      |   62 +
 .../streams/state/internals/RocksDBStore.java      |  420 +++---
 .../state/internals/RocksDBTimestampedStore.java   |  394 ++++++
 .../streams/state/internals/RocksDbIterator.java   |   89 ++
 .../RocksDbKeyValueBytesStoreSupplier.java         |    7 +-
 ...ytesStoreSupplier.java => StoreProxyUtils.java} |   33 +-
 ...sToDbOptionsColumnFamilyOptionsAdapterTest.java |  263 ++++
 .../state/internals/RocksDBSessionStoreTest.java   |    2 +-
 .../streams/state/internals/RocksDBStoreTest.java  |   83 +-
 .../internals/RocksDBTimestampedStoreTest.java     |  293 +++++
 12 files changed, 2737 insertions(+), 273 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/state/Stores.java b/streams/src/main/java/org/apache/kafka/streams/state/Stores.java
index 8236c1a..b672f3d 100644
--- a/streams/src/main/java/org/apache/kafka/streams/state/Stores.java
+++ b/streams/src/main/java/org/apache/kafka/streams/state/Stores.java
@@ -84,7 +84,7 @@ public class Stores {
      */
     public static KeyValueBytesStoreSupplier persistentKeyValueStore(final String name) {
         Objects.requireNonNull(name, "name cannot be null");
-        return new RocksDbKeyValueBytesStoreSupplier(name);
+        return new RocksDbKeyValueBytesStoreSupplier(name, true);
     }
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter.java
new file mode 100644
index 0000000..c07e43b
--- /dev/null
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter.java
@@ -0,0 +1,1362 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.streams.state.internals;
+
+import org.rocksdb.AbstractComparator;
+import org.rocksdb.AbstractSlice;
+import org.rocksdb.AccessHint;
+import org.rocksdb.BuiltinComparator;
+import org.rocksdb.Cache;
+import org.rocksdb.ColumnFamilyOptions;
+import org.rocksdb.CompactionOptionsFIFO;
+import org.rocksdb.CompactionOptionsUniversal;
+import org.rocksdb.CompactionPriority;
+import org.rocksdb.CompactionStyle;
+import org.rocksdb.CompressionOptions;
+import org.rocksdb.CompressionType;
+import org.rocksdb.DBOptions;
+import org.rocksdb.DbPath;
+import org.rocksdb.Env;
+import org.rocksdb.InfoLogLevel;
+import org.rocksdb.Logger;
+import org.rocksdb.MemTableConfig;
+import org.rocksdb.MergeOperator;
+import org.rocksdb.Options;
+import org.rocksdb.RateLimiter;
+import org.rocksdb.SstFileManager;
+import org.rocksdb.Statistics;
+import org.rocksdb.TableFormatConfig;
+import org.rocksdb.WALRecoveryMode;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * The generic {@link Options} class allows users to set all configs on one object if only default column family
+ * is used. Because we use multiple column families, we need to use {@link DBOptions} and {@link ColumnFamilyOptions}
+ * that cover a part of all options each.
+ *
+ * This class do the translation between generic {@link Options} into {@link DBOptions} and {@link ColumnFamilyOptions}.
+ */
+class RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter extends Options {
+    private final DBOptions dbOptions;
+    private final ColumnFamilyOptions columnFamilyOptions;
+
+    RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter(final DBOptions dbOptions,
+                                                               final ColumnFamilyOptions columnFamilyOptions) {
+        this.dbOptions = dbOptions;
+        this.columnFamilyOptions = columnFamilyOptions;
+    }
+
+    @Override
+    public Options setIncreaseParallelism(final int totalThreads) {
+        dbOptions.setIncreaseParallelism(totalThreads);
+        return this;
+    }
+
+    @Override
+    public Options setCreateIfMissing(final boolean flag) {
+        dbOptions.setCreateIfMissing(flag);
+        return this;
+    }
+
+    @Override
+    public Options setCreateMissingColumnFamilies(final boolean flag) {
+        dbOptions.setCreateMissingColumnFamilies(flag);
+        return this;
+    }
+
+    @Override
+    public Options setEnv(final Env env) {
+        dbOptions.setEnv(env);
+        return this;
+    }
+
+    @Override
+    public Env getEnv() {
+        return dbOptions.getEnv();
+    }
+
+    @Override
+    public Options prepareForBulkLoad() {
+        /* From https://github.com/facebook/rocksdb/wiki/RocksDB-FAQ
+         *
+         * Q: What's the fastest way to load data into RocksDB?
+         *
+         * A: A fast way to direct insert data to the DB:
+         *
+         *  1. using single writer thread and insert in sorted order
+         *  2. batch hundreds of keys into one write batch
+         *  3. use vector memtable
+         *  4. make sure options.max_background_flushes is at least 4
+         *  5. before inserting the data,
+         *       disable automatic compaction,
+         *       set options.level0_file_num_compaction_trigger,
+         *           options.level0_slowdown_writes_trigger
+         *           and options.level0_stop_writes_trigger to very large.
+         *     After inserting all the data, issue a manual compaction.
+         *
+         * 3-5 will be automatically done if you call Options::PrepareForBulkLoad() to your option
+         */
+        // (1) not in our control
+        // (2) is done via bulk-loading API
+        // (3) skipping because, not done in actual PrepareForBulkLoad() code in https://github.com/facebook/rocksdb/blob/master/options/options.cc
+        //columnFamilyOptions.setMemTableConfig(new VectorMemTableConfig());
+        // (4-5) below:
+        dbOptions.setMaxBackgroundFlushes(4);
+        columnFamilyOptions.setDisableAutoCompactions(true);
+        columnFamilyOptions.setLevel0FileNumCompactionTrigger(1 << 30);
+        columnFamilyOptions.setLevel0SlowdownWritesTrigger(1 << 30);
+        columnFamilyOptions.setLevel0StopWritesTrigger(1 << 30);
+        return this;
+    }
+
+    @Override
+    public boolean createIfMissing() {
+        return dbOptions.createIfMissing();
+    }
+
+    @Override
+    public boolean createMissingColumnFamilies() {
+        return dbOptions.createMissingColumnFamilies();
+    }
+
+    @Override
+    public Options optimizeForSmallDb() {
+        dbOptions.optimizeForSmallDb();
+        columnFamilyOptions.optimizeForSmallDb();
+        return this;
+    }
+
+    @Override
+    public Options optimizeForPointLookup(final long blockCacheSizeMb) {
+        columnFamilyOptions.optimizeForPointLookup(blockCacheSizeMb);
+        return this;
+    }
+
+    @Override
+    public Options optimizeLevelStyleCompaction() {
+        columnFamilyOptions.optimizeLevelStyleCompaction();
+        return this;
+    }
+
+    @Override
+    public Options optimizeLevelStyleCompaction(final long memtableMemoryBudget) {
+        columnFamilyOptions.optimizeLevelStyleCompaction(memtableMemoryBudget);
+        return this;
+    }
+
+    @Override
+    public Options optimizeUniversalStyleCompaction() {
+        columnFamilyOptions.optimizeUniversalStyleCompaction();
+        return this;
+    }
+
+    @Override
+    public Options optimizeUniversalStyleCompaction(final long memtableMemoryBudget) {
+        columnFamilyOptions.optimizeUniversalStyleCompaction(memtableMemoryBudget);
+        return this;
+    }
+
+    @Override
+    public Options setComparator(final BuiltinComparator builtinComparator) {
+        columnFamilyOptions.setComparator(builtinComparator);
+        return this;
+    }
+
+    @Override
+    public Options setComparator(final AbstractComparator<? extends AbstractSlice<?>> comparator) {
+        columnFamilyOptions.setComparator(comparator);
+        return this;
+    }
+
+    @Override
+    public Options setMergeOperatorName(final String name) {
+        columnFamilyOptions.setMergeOperatorName(name);
+        return this;
+    }
+
+    @Override
+    public Options setMergeOperator(final MergeOperator mergeOperator) {
+        columnFamilyOptions.setMergeOperator(mergeOperator);
+        return this;
+    }
+
+    @Override
+    public Options setWriteBufferSize(final long writeBufferSize) {
+        columnFamilyOptions.setWriteBufferSize(writeBufferSize);
+        return this;
+    }
+
+    @Override
+    public long writeBufferSize()  {
+        return columnFamilyOptions.writeBufferSize();
+    }
+
+    @Override
+    public Options setMaxWriteBufferNumber(final int maxWriteBufferNumber) {
+        columnFamilyOptions.setMaxWriteBufferNumber(maxWriteBufferNumber);
+        return this;
+    }
+
+    @Override
+    public int maxWriteBufferNumber() {
+        return columnFamilyOptions.maxWriteBufferNumber();
+    }
+
+    @Override
+    public boolean errorIfExists() {
+        return dbOptions.errorIfExists();
+    }
+
+    @Override
+    public Options setErrorIfExists(final boolean errorIfExists) {
+        dbOptions.setErrorIfExists(errorIfExists);
+        return this;
+    }
+
+    @Override
+    public boolean paranoidChecks() {
+        final boolean columnFamilyParanoidFileChecks = columnFamilyOptions.paranoidFileChecks();
+        final boolean dbOptionsParanoidChecks = dbOptions.paranoidChecks();
+
+        if (columnFamilyParanoidFileChecks != dbOptionsParanoidChecks) {
+            throw new IllegalStateException("Config for paranoid checks for RockDB and ColumnFamilies should be the same.");
+        }
+
+        return dbOptionsParanoidChecks;
+    }
+
+    @Override
+    public Options setParanoidChecks(final boolean paranoidChecks) {
+        columnFamilyOptions.paranoidFileChecks();
+        dbOptions.setParanoidChecks(paranoidChecks);
+        return this;
+    }
+
+    @Override
+    public int maxOpenFiles() {
+        return dbOptions.maxOpenFiles();
+    }
+
+    @Override
+    public Options setMaxFileOpeningThreads(final int maxFileOpeningThreads) {
+        dbOptions.setMaxFileOpeningThreads(maxFileOpeningThreads);
+        return this;
+    }
+
+    @Override
+    public int maxFileOpeningThreads() {
+        return dbOptions.maxFileOpeningThreads();
+    }
+
+    @Override
+    public Options setMaxTotalWalSize(final long maxTotalWalSize) {
+        dbOptions.setMaxTotalWalSize(maxTotalWalSize);
+        return this;
+    }
+
+    @Override
+    public long maxTotalWalSize() {
+        return dbOptions.maxTotalWalSize();
+    }
+
+    @Override
+    public Options setMaxOpenFiles(final int maxOpenFiles) {
+        dbOptions.setMaxOpenFiles(maxOpenFiles);
+        return this;
+    }
+
+    @Override
+    public boolean useFsync() {
+        return dbOptions.useFsync();
+    }
+
+    @Override
+    public Options setUseFsync(final boolean useFsync) {
+        dbOptions.setUseFsync(useFsync);
+        return this;
+    }
+
+    @Override
+    public Options setDbPaths(final Collection<DbPath> dbPaths) {
+        dbOptions.setDbPaths(dbPaths);
+        return this;
+    }
+
+    @Override
+    public List<DbPath> dbPaths() {
+        return dbOptions.dbPaths();
+    }
+
+    @Override
+    public String dbLogDir() {
+        return dbOptions.dbLogDir();
+    }
+
+    @Override
+    public Options setDbLogDir(final String dbLogDir) {
+        dbOptions.setDbLogDir(dbLogDir);
+        return this;
+    }
+
+    @Override
+    public String walDir() {
+        return dbOptions.walDir();
+    }
+
+    @Override
+    public Options setWalDir(final String walDir) {
+        dbOptions.setWalDir(walDir);
+        return this;
+    }
+
+    @Override
+    public long deleteObsoleteFilesPeriodMicros() {
+        return dbOptions.deleteObsoleteFilesPeriodMicros();
+    }
+
+    @Override
+    public Options setDeleteObsoleteFilesPeriodMicros(final long micros) {
+        dbOptions.setDeleteObsoleteFilesPeriodMicros(micros);
+        return this;
+    }
+
+    @Override
+    public int maxBackgroundCompactions() {
+        return dbOptions.maxBackgroundCompactions();
+    }
+
+    @Override
+    public Options setStatistics(final Statistics statistics) {
+        dbOptions.setStatistics(statistics);
+        return this;
+    }
+
+    @Override
+    public Statistics statistics() {
+        return dbOptions.statistics();
+    }
+
+    @Override
+    public void setBaseBackgroundCompactions(final int baseBackgroundCompactions) {
+        dbOptions.setBaseBackgroundCompactions(baseBackgroundCompactions);
+    }
+
+    @Override
+    public int baseBackgroundCompactions() {
+        return dbOptions.baseBackgroundCompactions();
+    }
+
+    @Override
+    public Options setMaxBackgroundCompactions(final int maxBackgroundCompactions) {
+        dbOptions.setMaxBackgroundCompactions(maxBackgroundCompactions);
+        return this;
+    }
+
+    @Override
+    public void setMaxSubcompactions(final int maxSubcompactions) {
+        dbOptions.setMaxSubcompactions(maxSubcompactions);
+    }
+
+    @Override
+    public int maxSubcompactions() {
+        return dbOptions.maxSubcompactions();
+    }
+
+    @Override
+    public int maxBackgroundFlushes() {
+        return dbOptions.maxBackgroundFlushes();
+    }
+
+    @Override
+    public Options setMaxBackgroundFlushes(final int maxBackgroundFlushes) {
+        dbOptions.setMaxBackgroundFlushes(maxBackgroundFlushes);
+        return this;
+    }
+
+    @Override
+    public int maxBackgroundJobs() {
+        return dbOptions.maxBackgroundJobs();
+    }
+
+    @Override
+    public Options setMaxBackgroundJobs(final int maxBackgroundJobs) {
+        dbOptions.setMaxBackgroundJobs(maxBackgroundJobs);
+        return this;
+    }
+
+    @Override
+    public long maxLogFileSize() {
+        return dbOptions.maxLogFileSize();
+    }
+
+    @Override
+    public Options setMaxLogFileSize(final long maxLogFileSize) {
+        dbOptions.setMaxLogFileSize(maxLogFileSize);
+        return this;
+    }
+
+    @Override
+    public long logFileTimeToRoll() {
+        return dbOptions.logFileTimeToRoll();
+    }
+
+    @Override
+    public Options setLogFileTimeToRoll(final long logFileTimeToRoll) {
+        dbOptions.setLogFileTimeToRoll(logFileTimeToRoll);
+        return this;
+    }
+
+    @Override
+    public long keepLogFileNum() {
+        return dbOptions.keepLogFileNum();
+    }
+
+    @Override
+    public Options setKeepLogFileNum(final long keepLogFileNum) {
+        dbOptions.setKeepLogFileNum(keepLogFileNum);
+        return this;
+    }
+
+    @Override
+    public Options setRecycleLogFileNum(final long recycleLogFileNum) {
+        dbOptions.setRecycleLogFileNum(recycleLogFileNum);
+        return this;
+    }
+
+    @Override
+    public long recycleLogFileNum() {
+        return dbOptions.recycleLogFileNum();
+    }
+
+    @Override
+    public long maxManifestFileSize() {
+        return dbOptions.maxManifestFileSize();
+    }
+
+    @Override
+    public Options setMaxManifestFileSize(final long maxManifestFileSize) {
+        dbOptions.setMaxManifestFileSize(maxManifestFileSize);
+        return this;
+    }
+
+    @Override
+    public Options setMaxTableFilesSizeFIFO(final long maxTableFilesSize) {
+        columnFamilyOptions.setMaxTableFilesSizeFIFO(maxTableFilesSize);
+        return this;
+    }
+
+    @Override
+    public long maxTableFilesSizeFIFO() {
+        return columnFamilyOptions.maxTableFilesSizeFIFO();
+    }
+
+    @Override
+    public int tableCacheNumshardbits() {
+        return dbOptions.tableCacheNumshardbits();
+    }
+
+    @Override
+    public Options setTableCacheNumshardbits(final int tableCacheNumshardbits) {
+        dbOptions.setTableCacheNumshardbits(tableCacheNumshardbits);
+        return this;
+    }
+
+    @Override
+    public long walTtlSeconds() {
+        return dbOptions.walTtlSeconds();
+    }
+
+    @Override
+    public Options setWalTtlSeconds(final long walTtlSeconds) {
+        dbOptions.setWalTtlSeconds(walTtlSeconds);
+        return this;
+    }
+
+    @Override
+    public long walSizeLimitMB() {
+        return dbOptions.walSizeLimitMB();
+    }
+
+    @Override
+    public Options setWalSizeLimitMB(final long sizeLimitMB) {
+        dbOptions.setWalSizeLimitMB(sizeLimitMB);
+        return this;
+    }
+
+    @Override
+    public long manifestPreallocationSize() {
+        return dbOptions.manifestPreallocationSize();
+    }
+
+    @Override
+    public Options setManifestPreallocationSize(final long size) {
+        dbOptions.setManifestPreallocationSize(size);
+        return this;
+    }
+
+    @Override
+    public Options setUseDirectReads(final boolean useDirectReads) {
+        dbOptions.setUseDirectReads(useDirectReads);
+        return this;
+    }
+
+    @Override
+    public boolean useDirectReads() {
+        return dbOptions.useDirectReads();
+    }
+
+    @Override
+    public Options setUseDirectIoForFlushAndCompaction(final boolean useDirectIoForFlushAndCompaction) {
+        dbOptions.setUseDirectIoForFlushAndCompaction(useDirectIoForFlushAndCompaction);
+        return this;
+    }
+
+    @Override
+    public boolean useDirectIoForFlushAndCompaction() {
+        return dbOptions.useDirectIoForFlushAndCompaction();
+    }
+
+    @Override
+    public Options setAllowFAllocate(final boolean allowFAllocate) {
+        dbOptions.setAllowFAllocate(allowFAllocate);
+        return this;
+    }
+
+    @Override
+    public boolean allowFAllocate() {
+        return dbOptions.allowFAllocate();
+    }
+
+    @Override
+    public boolean allowMmapReads() {
+        return dbOptions.allowMmapReads();
+    }
+
+    @Override
+    public Options setAllowMmapReads(final boolean allowMmapReads) {
+        dbOptions.setAllowMmapReads(allowMmapReads);
+        return this;
+    }
+
+    @Override
+    public boolean allowMmapWrites() {
+        return dbOptions.allowMmapWrites();
+    }
+
+    @Override
+    public Options setAllowMmapWrites(final boolean allowMmapWrites) {
+        dbOptions.setAllowMmapWrites(allowMmapWrites);
+        return this;
+    }
+
+    @Override
+    public boolean isFdCloseOnExec() {
+        return dbOptions.isFdCloseOnExec();
+    }
+
+    @Override
+    public Options setIsFdCloseOnExec(final boolean isFdCloseOnExec) {
+        dbOptions.setIsFdCloseOnExec(isFdCloseOnExec);
+        return this;
+    }
+
+    @Override
+    public int statsDumpPeriodSec() {
+        return dbOptions.statsDumpPeriodSec();
+    }
+
+    @Override
+    public Options setStatsDumpPeriodSec(final int statsDumpPeriodSec) {
+        dbOptions.setStatsDumpPeriodSec(statsDumpPeriodSec);
+        return this;
+    }
+
+    @Override
+    public boolean adviseRandomOnOpen() {
+        return dbOptions.adviseRandomOnOpen();
+    }
+
+    @Override
+    public Options setAdviseRandomOnOpen(final boolean adviseRandomOnOpen) {
+        dbOptions.setAdviseRandomOnOpen(adviseRandomOnOpen);
+        return this;
+    }
+
+    @Override
+    public Options setDbWriteBufferSize(final long dbWriteBufferSize) {
+        dbOptions.setDbWriteBufferSize(dbWriteBufferSize);
+        return this;
+    }
+
+    @Override
+    public long dbWriteBufferSize() {
+        return dbOptions.dbWriteBufferSize();
+    }
+
+    @Override
+    public Options setAccessHintOnCompactionStart(final AccessHint accessHint) {
+        dbOptions.setAccessHintOnCompactionStart(accessHint);
+        return this;
+    }
+
+    @Override
+    public AccessHint accessHintOnCompactionStart() {
+        return dbOptions.accessHintOnCompactionStart();
+    }
+
+    @Override
+    public Options setNewTableReaderForCompactionInputs(final boolean newTableReaderForCompactionInputs) {
+        dbOptions.setNewTableReaderForCompactionInputs(newTableReaderForCompactionInputs);
+        return this;
+    }
+
+    @Override
+    public boolean newTableReaderForCompactionInputs() {
+        return dbOptions.newTableReaderForCompactionInputs();
+    }
+
+    @Override
+    public Options setCompactionReadaheadSize(final long compactionReadaheadSize) {
+        dbOptions.setCompactionReadaheadSize(compactionReadaheadSize);
+        return this;
+    }
+
+    @Override
+    public long compactionReadaheadSize() {
+        return dbOptions.compactionReadaheadSize();
+    }
+
+    @Override
+    public Options setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) {
+        dbOptions.setRandomAccessMaxBufferSize(randomAccessMaxBufferSize);
+        return this;
+    }
+
+    @Override
+    public long randomAccessMaxBufferSize() {
+        return dbOptions.randomAccessMaxBufferSize();
+    }
+
+    @Override
+    public Options setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) {
+        dbOptions.setWritableFileMaxBufferSize(writableFileMaxBufferSize);
+        return this;
+    }
+
+    @Override
+    public long writableFileMaxBufferSize() {
+        return dbOptions.writableFileMaxBufferSize();
+    }
+
+    @Override
+    public boolean useAdaptiveMutex() {
+        return dbOptions.useAdaptiveMutex();
+    }
+
+    @Override
+    public Options setUseAdaptiveMutex(final boolean useAdaptiveMutex) {
+        dbOptions.setUseAdaptiveMutex(useAdaptiveMutex);
+        return this;
+    }
+
+    @Override
+    public long bytesPerSync() {
+        return dbOptions.bytesPerSync();
+    }
+
+    @Override
+    public Options setBytesPerSync(final long bytesPerSync) {
+        dbOptions.setBytesPerSync(bytesPerSync);
+        return this;
+    }
+
+    @Override
+    public Options setWalBytesPerSync(final long walBytesPerSync) {
+        dbOptions.setWalBytesPerSync(walBytesPerSync);
+        return this;
+    }
+
+    @Override
+    public long walBytesPerSync() {
+        return dbOptions.walBytesPerSync();
+    }
+
+    @Override
+    public Options setEnableThreadTracking(final boolean enableThreadTracking) {
+        dbOptions.setEnableThreadTracking(enableThreadTracking);
+        return this;
+    }
+
+    @Override
+    public boolean enableThreadTracking() {
+        return dbOptions.enableThreadTracking();
+    }
+
+    @Override
+    public Options setDelayedWriteRate(final long delayedWriteRate) {
+        dbOptions.setDelayedWriteRate(delayedWriteRate);
+        return this;
+    }
+
+    @Override
+    public long delayedWriteRate() {
+        return dbOptions.delayedWriteRate();
+    }
+
+    @Override
+    public Options setAllowConcurrentMemtableWrite(final boolean allowConcurrentMemtableWrite) {
+        dbOptions.setAllowConcurrentMemtableWrite(allowConcurrentMemtableWrite);
+        return this;
+    }
+
+    @Override
+    public boolean allowConcurrentMemtableWrite() {
+        return dbOptions.allowConcurrentMemtableWrite();
+    }
+
+    @Override
+    public Options setEnableWriteThreadAdaptiveYield(final boolean enableWriteThreadAdaptiveYield) {
+        dbOptions.setEnableWriteThreadAdaptiveYield(enableWriteThreadAdaptiveYield);
+        return this;
+    }
+
+    @Override
+    public boolean enableWriteThreadAdaptiveYield() {
+        return dbOptions.enableWriteThreadAdaptiveYield();
+    }
+
+    @Override
+    public Options setWriteThreadMaxYieldUsec(final long writeThreadMaxYieldUsec) {
+        dbOptions.setWriteThreadMaxYieldUsec(writeThreadMaxYieldUsec);
+        return this;
+    }
+
+    @Override
+    public long writeThreadMaxYieldUsec() {
+        return dbOptions.writeThreadMaxYieldUsec();
+    }
+
+    @Override
+    public Options setWriteThreadSlowYieldUsec(final long writeThreadSlowYieldUsec) {
+        dbOptions.setWriteThreadSlowYieldUsec(writeThreadSlowYieldUsec);
+        return this;
+    }
+
+    @Override
+    public long writeThreadSlowYieldUsec() {
+        return dbOptions.writeThreadSlowYieldUsec();
+    }
+
+    @Override
+    public Options setSkipStatsUpdateOnDbOpen(final boolean skipStatsUpdateOnDbOpen) {
+        dbOptions.setSkipStatsUpdateOnDbOpen(skipStatsUpdateOnDbOpen);
+        return this;
+    }
+
+    @Override
+    public boolean skipStatsUpdateOnDbOpen() {
+        return dbOptions.skipStatsUpdateOnDbOpen();
+    }
+
+    @Override
+    public Options setWalRecoveryMode(final WALRecoveryMode walRecoveryMode) {
+        dbOptions.setWalRecoveryMode(walRecoveryMode);
+        return this;
+    }
+
+    @Override
+    public WALRecoveryMode walRecoveryMode() {
+        return dbOptions.walRecoveryMode();
+    }
+
+    @Override
+    public Options setAllow2pc(final boolean allow2pc) {
+        dbOptions.setAllow2pc(allow2pc);
+        return this;
+    }
+
+    @Override
+    public boolean allow2pc() {
+        return dbOptions.allow2pc();
+    }
+
+    @Override
+    public Options setRowCache(final Cache rowCache) {
+        dbOptions.setRowCache(rowCache);
+        return this;
+    }
+
+    @Override
+    public Cache rowCache() {
+        return dbOptions.rowCache();
+    }
+
+    @Override
+    public Options setFailIfOptionsFileError(final boolean failIfOptionsFileError) {
+        dbOptions.setFailIfOptionsFileError(failIfOptionsFileError);
+        return this;
+    }
+
+    @Override
+    public boolean failIfOptionsFileError() {
+        return dbOptions.failIfOptionsFileError();
+    }
+
+    @Override
+    public Options setDumpMallocStats(final boolean dumpMallocStats) {
+        dbOptions.setDumpMallocStats(dumpMallocStats);
+        return this;
+    }
+
+    @Override
+    public boolean dumpMallocStats() {
+        return dbOptions.dumpMallocStats();
+    }
+
+    @Override
+    public Options setAvoidFlushDuringRecovery(final boolean avoidFlushDuringRecovery) {
+        dbOptions.setAvoidFlushDuringRecovery(avoidFlushDuringRecovery);
+        return this;
+    }
+
+    @Override
+    public boolean avoidFlushDuringRecovery() {
+        return dbOptions.avoidFlushDuringRecovery();
+    }
+
+    @Override
+    public Options setAvoidFlushDuringShutdown(final boolean avoidFlushDuringShutdown) {
+        dbOptions.setAvoidFlushDuringShutdown(avoidFlushDuringShutdown);
+        return this;
+    }
+
+    @Override
+    public boolean avoidFlushDuringShutdown() {
+        return dbOptions.avoidFlushDuringShutdown();
+    }
+
+    @Override
+    public MemTableConfig memTableConfig() {
+        return columnFamilyOptions.memTableConfig();
+    }
+
+    @Override
+    public Options setMemTableConfig(final MemTableConfig config) {
+        columnFamilyOptions.setMemTableConfig(config);
+        return this;
+    }
+
+    @Override
+    public Options setRateLimiter(final RateLimiter rateLimiter) {
+        dbOptions.setRateLimiter(rateLimiter);
+        return this;
+    }
+
+    @Override
+    public Options setSstFileManager(final SstFileManager sstFileManager) {
+        dbOptions.setSstFileManager(sstFileManager);
+        return this;
+    }
+
+    @Override
+    public Options setLogger(final Logger logger) {
+        dbOptions.setLogger(logger);
+        return this;
+    }
+
+    @Override
+    public Options setInfoLogLevel(final InfoLogLevel infoLogLevel) {
+        dbOptions.setInfoLogLevel(infoLogLevel);
+        return this;
+    }
+
+    @Override
+    public InfoLogLevel infoLogLevel() {
+        return dbOptions.infoLogLevel();
+    }
+
+    @Override
+    public String memTableFactoryName() {
+        return columnFamilyOptions.memTableFactoryName();
+    }
+
+    @Override
+    public TableFormatConfig tableFormatConfig() {
+        return columnFamilyOptions.tableFormatConfig();
+    }
+
+    @Override
+    public Options setTableFormatConfig(final TableFormatConfig config) {
+        columnFamilyOptions.setTableFormatConfig(config);
+        return this;
+    }
+
+    @Override
+    public String tableFactoryName() {
+        return columnFamilyOptions.tableFactoryName();
+    }
+
+    @Override
+    public Options useFixedLengthPrefixExtractor(final int n) {
+        columnFamilyOptions.useFixedLengthPrefixExtractor(n);
+        return this;
+    }
+
+    @Override
+    public Options useCappedPrefixExtractor(final int n) {
+        columnFamilyOptions.useCappedPrefixExtractor(n);
+        return this;
+    }
+
+    @Override
+    public CompressionType compressionType() {
+        return columnFamilyOptions.compressionType();
+    }
+
+    @Override
+    public Options setCompressionPerLevel(final List<CompressionType> compressionLevels) {
+        columnFamilyOptions.setCompressionPerLevel(compressionLevels);
+        return this;
+    }
+
+    @Override
+    public List<CompressionType> compressionPerLevel() {
+        return columnFamilyOptions.compressionPerLevel();
+    }
+
+    @Override
+    public Options setCompressionType(final CompressionType compressionType) {
+        columnFamilyOptions.setCompressionType(compressionType);
+        return this;
+    }
+
+
+    @Override
+    public Options setBottommostCompressionType(final CompressionType bottommostCompressionType) {
+        columnFamilyOptions.setBottommostCompressionType(bottommostCompressionType);
+        return this;
+    }
+
+    @Override
+    public CompressionType bottommostCompressionType() {
+        return columnFamilyOptions.bottommostCompressionType();
+    }
+
+    @Override
+    public Options setCompressionOptions(final CompressionOptions compressionOptions) {
+        columnFamilyOptions.setCompressionOptions(compressionOptions);
+        return this;
+    }
+
+    @Override
+    public CompressionOptions compressionOptions() {
+        return columnFamilyOptions.compressionOptions();
+    }
+
+    @Override
+    public CompactionStyle compactionStyle() {
+        return columnFamilyOptions.compactionStyle();
+    }
+
+    @Override
+    public Options setCompactionStyle(final CompactionStyle compactionStyle) {
+        columnFamilyOptions.setCompactionStyle(compactionStyle);
+        return this;
+    }
+
+    @Override
+    public int numLevels() {
+        return columnFamilyOptions.numLevels();
+    }
+
+    @Override
+    public Options setNumLevels(final int numLevels) {
+        columnFamilyOptions.setNumLevels(numLevels);
+        return this;
+    }
+
+    @Override
+    public int levelZeroFileNumCompactionTrigger() {
+        return columnFamilyOptions.levelZeroFileNumCompactionTrigger();
+    }
+
+    @Override
+    public Options setLevelZeroFileNumCompactionTrigger(final int numFiles) {
+        columnFamilyOptions.setLevelZeroFileNumCompactionTrigger(numFiles);
+        return this;
+    }
+
+    @Override
+    public int levelZeroSlowdownWritesTrigger() {
+        return columnFamilyOptions.levelZeroSlowdownWritesTrigger();
+    }
+
+    @Override
+    public Options setLevelZeroSlowdownWritesTrigger(final int numFiles) {
+        columnFamilyOptions.setLevelZeroSlowdownWritesTrigger(numFiles);
+        return this;
+    }
+
+    @Override
+    public int levelZeroStopWritesTrigger() {
+        return columnFamilyOptions.levelZeroStopWritesTrigger();
+    }
+
+    @Override
+    public Options setLevelZeroStopWritesTrigger(final int numFiles) {
+        columnFamilyOptions.setLevelZeroStopWritesTrigger(numFiles);
+        return this;
+    }
+
+    @Override
+    public long targetFileSizeBase() {
+        return columnFamilyOptions.targetFileSizeBase();
+    }
+
+    @Override
+    public Options setTargetFileSizeBase(final long targetFileSizeBase) {
+        columnFamilyOptions.setTargetFileSizeBase(targetFileSizeBase);
+        return this;
+    }
+
+    @Override
+    public int targetFileSizeMultiplier() {
+        return columnFamilyOptions.targetFileSizeMultiplier();
+    }
+
+    @Override
+    public Options setTargetFileSizeMultiplier(final int multiplier) {
+        columnFamilyOptions.setTargetFileSizeMultiplier(multiplier);
+        return this;
+    }
+
+    @Override
+    public Options setMaxBytesForLevelBase(final long maxBytesForLevelBase) {
+        columnFamilyOptions.setMaxBytesForLevelBase(maxBytesForLevelBase);
+        return this;
+    }
+
+    @Override
+    public long maxBytesForLevelBase() {
+        return columnFamilyOptions.maxBytesForLevelBase();
+    }
+
+    @Override
+    public Options setLevelCompactionDynamicLevelBytes(final boolean enableLevelCompactionDynamicLevelBytes) {
+        columnFamilyOptions.setLevelCompactionDynamicLevelBytes(enableLevelCompactionDynamicLevelBytes);
+        return this;
+    }
+
+    @Override
+    public boolean levelCompactionDynamicLevelBytes() {
+        return columnFamilyOptions.levelCompactionDynamicLevelBytes();
+    }
+
+    @Override
+    public double maxBytesForLevelMultiplier() {
+        return columnFamilyOptions.maxBytesForLevelMultiplier();
+    }
+
+    @Override
+    public Options setMaxBytesForLevelMultiplier(final double multiplier) {
+        columnFamilyOptions.setMaxBytesForLevelMultiplier(multiplier);
+        return this;
+    }
+
+    @Override
+    public long maxCompactionBytes() {
+        return columnFamilyOptions.maxCompactionBytes();
+    }
+
+    @Override
+    public Options setMaxCompactionBytes(final long maxCompactionBytes) {
+        columnFamilyOptions.setMaxCompactionBytes(maxCompactionBytes);
+        return this;
+    }
+
+    @Override
+    public long arenaBlockSize() {
+        return columnFamilyOptions.arenaBlockSize();
+    }
+
+    @Override
+    public Options setArenaBlockSize(final long arenaBlockSize) {
+        columnFamilyOptions.setArenaBlockSize(arenaBlockSize);
+        return this;
+    }
+
+    @Override
+    public boolean disableAutoCompactions() {
+        return columnFamilyOptions.disableAutoCompactions();
+    }
+
+    @Override
+    public Options setDisableAutoCompactions(final boolean disableAutoCompactions) {
+        columnFamilyOptions.setDisableAutoCompactions(disableAutoCompactions);
+        return this;
+    }
+
+    @Override
+    public long maxSequentialSkipInIterations() {
+        return columnFamilyOptions.maxSequentialSkipInIterations();
+    }
+
+    @Override
+    public Options setMaxSequentialSkipInIterations(final long maxSequentialSkipInIterations) {
+        columnFamilyOptions.setMaxSequentialSkipInIterations(maxSequentialSkipInIterations);
+        return this;
+    }
+
+    @Override
+    public boolean inplaceUpdateSupport() {
+        return columnFamilyOptions.inplaceUpdateSupport();
+    }
+
+    @Override
+    public Options setInplaceUpdateSupport(final boolean inplaceUpdateSupport) {
+        columnFamilyOptions.setInplaceUpdateSupport(inplaceUpdateSupport);
+        return this;
+    }
+
+    @Override
+    public long inplaceUpdateNumLocks() {
+        return columnFamilyOptions.inplaceUpdateNumLocks();
+    }
+
+    @Override
+    public Options setInplaceUpdateNumLocks(final long inplaceUpdateNumLocks) {
+        columnFamilyOptions.setInplaceUpdateNumLocks(inplaceUpdateNumLocks);
+        return this;
+    }
+
+    @Override
+    public double memtablePrefixBloomSizeRatio() {
+        return columnFamilyOptions.memtablePrefixBloomSizeRatio();
+    }
+
+    @Override
+    public Options setMemtablePrefixBloomSizeRatio(final double memtablePrefixBloomSizeRatio) {
+        columnFamilyOptions.setMemtablePrefixBloomSizeRatio(memtablePrefixBloomSizeRatio);
+        return this;
+    }
+
+    @Override
+    public int bloomLocality() {
+        return columnFamilyOptions.bloomLocality();
+    }
+
+    @Override
+    public Options setBloomLocality(final int bloomLocality) {
+        columnFamilyOptions.setBloomLocality(bloomLocality);
+        return this;
+    }
+
+    @Override
+    public long maxSuccessiveMerges() {
+        return columnFamilyOptions.maxSuccessiveMerges();
+    }
+
+    @Override
+    public Options setMaxSuccessiveMerges(final long maxSuccessiveMerges) {
+        columnFamilyOptions.setMaxSuccessiveMerges(maxSuccessiveMerges);
+        return this;
+    }
+
+    @Override
+    public int minWriteBufferNumberToMerge() {
+        return columnFamilyOptions.minWriteBufferNumberToMerge();
+    }
+
+    @Override
+    public Options setMinWriteBufferNumberToMerge(final int minWriteBufferNumberToMerge) {
+        columnFamilyOptions.setMinWriteBufferNumberToMerge(minWriteBufferNumberToMerge);
+        return this;
+    }
+
+    @Override
+    public Options setOptimizeFiltersForHits(final boolean optimizeFiltersForHits) {
+        columnFamilyOptions.setOptimizeFiltersForHits(optimizeFiltersForHits);
+        return this;
+    }
+
+    @Override
+    public boolean optimizeFiltersForHits() {
+        return columnFamilyOptions.optimizeFiltersForHits();
+    }
+
+    @Override
+    public Options setMemtableHugePageSize(final long memtableHugePageSize) {
+        columnFamilyOptions.setMemtableHugePageSize(memtableHugePageSize);
+        return this;
+    }
+
+    @Override
+    public long memtableHugePageSize() {
+        return columnFamilyOptions.memtableHugePageSize();
+    }
+
+    @Override
+    public Options setSoftPendingCompactionBytesLimit(final long softPendingCompactionBytesLimit) {
+        columnFamilyOptions.setSoftPendingCompactionBytesLimit(softPendingCompactionBytesLimit);
+        return this;
+    }
+
+    @Override
+    public long softPendingCompactionBytesLimit() {
+        return columnFamilyOptions.softPendingCompactionBytesLimit();
+    }
+
+    @Override
+    public Options setHardPendingCompactionBytesLimit(final long hardPendingCompactionBytesLimit) {
+        columnFamilyOptions.setHardPendingCompactionBytesLimit(hardPendingCompactionBytesLimit);
+        return this;
+    }
+
+    @Override
+    public long hardPendingCompactionBytesLimit() {
+        return columnFamilyOptions.hardPendingCompactionBytesLimit();
+    }
+
+    @Override
+    public Options setLevel0FileNumCompactionTrigger(final int level0FileNumCompactionTrigger) {
+        columnFamilyOptions.setLevel0FileNumCompactionTrigger(level0FileNumCompactionTrigger);
+        return this;
+    }
+
+    @Override
+    public int level0FileNumCompactionTrigger() {
+        return columnFamilyOptions.level0FileNumCompactionTrigger();
+    }
+
+    @Override
+    public Options setLevel0SlowdownWritesTrigger(final int level0SlowdownWritesTrigger) {
+        columnFamilyOptions.setLevel0SlowdownWritesTrigger(level0SlowdownWritesTrigger);
+        return this;
+    }
+
+    @Override
+    public int level0SlowdownWritesTrigger() {
+        return columnFamilyOptions.level0SlowdownWritesTrigger();
+    }
+
+    @Override
+    public Options setLevel0StopWritesTrigger(final int level0StopWritesTrigger) {
+        columnFamilyOptions.setLevel0StopWritesTrigger(level0StopWritesTrigger);
+        return this;
+    }
+
+    @Override
+    public int level0StopWritesTrigger() {
+        return columnFamilyOptions.level0StopWritesTrigger();
+    }
+
+    @Override
+    public Options setMaxBytesForLevelMultiplierAdditional(final int[] maxBytesForLevelMultiplierAdditional) {
+        columnFamilyOptions.setMaxBytesForLevelMultiplierAdditional(maxBytesForLevelMultiplierAdditional);
+        return this;
+    }
+
+    @Override
+    public int[] maxBytesForLevelMultiplierAdditional() {
+        return columnFamilyOptions.maxBytesForLevelMultiplierAdditional();
+    }
+
+    @Override
+    public Options setParanoidFileChecks(final boolean paranoidFileChecks) {
+        columnFamilyOptions.setParanoidFileChecks(paranoidFileChecks);
+        return this;
+    }
+
+    @Override
+    public boolean paranoidFileChecks() {
+        return columnFamilyOptions.paranoidFileChecks();
+    }
+
+    @Override
+    public Options setMaxWriteBufferNumberToMaintain(final int maxWriteBufferNumberToMaintain) {
+        columnFamilyOptions.setMaxWriteBufferNumberToMaintain(maxWriteBufferNumberToMaintain);
+        return this;
+    }
+
+    @Override
+    public int maxWriteBufferNumberToMaintain() {
+        return columnFamilyOptions.maxWriteBufferNumberToMaintain();
+    }
+
+    @Override
+    public Options setCompactionPriority(final CompactionPriority compactionPriority) {
+        columnFamilyOptions.setCompactionPriority(compactionPriority);
+        return this;
+    }
+
+    @Override
+    public CompactionPriority compactionPriority() {
+        return columnFamilyOptions.compactionPriority();
+    }
+
+    @Override
+    public Options setReportBgIoStats(final boolean reportBgIoStats) {
+        columnFamilyOptions.setReportBgIoStats(reportBgIoStats);
+        return this;
+    }
+
+    @Override
+    public boolean reportBgIoStats() {
+        return columnFamilyOptions.reportBgIoStats();
+    }
+
+    @Override
+    public Options setCompactionOptionsUniversal(final CompactionOptionsUniversal compactionOptionsUniversal) {
+        columnFamilyOptions.setCompactionOptionsUniversal(compactionOptionsUniversal);
+        return this;
+    }
+
+    @Override
+    public CompactionOptionsUniversal compactionOptionsUniversal() {
+        return columnFamilyOptions.compactionOptionsUniversal();
+    }
+
+    @Override
+    public Options setCompactionOptionsFIFO(final CompactionOptionsFIFO compactionOptionsFIFO) {
+        columnFamilyOptions.setCompactionOptionsFIFO(compactionOptionsFIFO);
+        return this;
+    }
+
+    @Override
+    public CompactionOptionsFIFO compactionOptionsFIFO() {
+        return columnFamilyOptions.compactionOptionsFIFO();
+    }
+
+    @Override
+    public Options setForceConsistencyChecks(final boolean forceConsistencyChecks) {
+        columnFamilyOptions.setForceConsistencyChecks(forceConsistencyChecks);
+        return this;
+    }
+
+    @Override
+    public boolean forceConsistencyChecks() {
+        return columnFamilyOptions.forceConsistencyChecks();
+    }
+
+    @Override
+    public void close() {
+        columnFamilyOptions.close();
+        dbOptions.close();
+    }
+}
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBRangeIterator.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBRangeIterator.java
new file mode 100644
index 0000000..b1cf24d
--- /dev/null
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBRangeIterator.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.streams.state.internals;
+
+import org.apache.kafka.common.utils.Bytes;
+import org.apache.kafka.streams.KeyValue;
+import org.apache.kafka.streams.state.KeyValueIterator;
+import org.rocksdb.RocksIterator;
+
+import java.util.Comparator;
+import java.util.Set;
+
+class RocksDBRangeIterator extends RocksDbIterator {
+    // RocksDB's JNI interface does not expose getters/setters that allow the
+    // comparator to be pluggable, and the default is lexicographic, so it's
+    // safe to just force lexicographic comparator here for now.
+    private final Comparator<byte[]> comparator = Bytes.BYTES_LEXICO_COMPARATOR;
+    private final byte[] rawToKey;
+
+    RocksDBRangeIterator(final String storeName,
+                         final RocksIterator iter,
+                         final Set<KeyValueIterator<Bytes, byte[]>> openIterators,
+                         final Bytes from,
+                         final Bytes to) {
+        super(storeName, iter, openIterators);
+        iter.seek(from.get());
+        rawToKey = to.get();
+        if (rawToKey == null) {
+            throw new NullPointerException("RocksDBRangeIterator: RawToKey is null for key " + to);
+        }
+    }
+
+    @Override
+    public KeyValue<Bytes, byte[]> makeNext() {
+        final KeyValue<Bytes, byte[]> next = super.makeNext();
+
+        if (next == null) {
+            return allDone();
+        } else {
+            if (comparator.compare(next.key.get(), rawToKey) <= 0) {
+                return next;
+            } else {
+                return allDone();
+            }
+        }
+    }
+}
+
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBStore.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBStore.java
index 232d8f2..0528fca 100644
--- a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBStore.java
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBStore.java
@@ -17,7 +17,6 @@
 package org.apache.kafka.streams.state.internals;
 
 import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.utils.AbstractIterator;
 import org.apache.kafka.common.utils.Bytes;
 import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.KeyValue;
@@ -33,8 +32,12 @@ import org.apache.kafka.streams.state.KeyValueStore;
 import org.apache.kafka.streams.state.RocksDBConfigSetter;
 import org.rocksdb.BlockBasedTableConfig;
 import org.rocksdb.BloomFilter;
+import org.rocksdb.ColumnFamilyDescriptor;
+import org.rocksdb.ColumnFamilyHandle;
+import org.rocksdb.ColumnFamilyOptions;
 import org.rocksdb.CompactionStyle;
 import org.rocksdb.CompressionType;
+import org.rocksdb.DBOptions;
 import org.rocksdb.FlushOptions;
 import org.rocksdb.InfoLogLevel;
 import org.rocksdb.Options;
@@ -49,26 +52,20 @@ import org.slf4j.LoggerFactory;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Set;
 import java.util.regex.Pattern;
 
 /**
  * A persistent key-value store based on RocksDB.
- *
- * Note that the use of array-typed keys is discouraged because they result in incorrect caching behavior.
- * If you intend to work on byte arrays as key, for example, you may want to wrap them with the {@code Bytes} class,
- * i.e. use {@code RocksDBStore<Bytes, ...>} rather than {@code RocksDBStore<byte[], ...>}.
  */
 public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
-
     private static final Logger log = LoggerFactory.getLogger(RocksDBStore.class);
 
     private static final Pattern SST_FILE_EXTENSION = Pattern.compile(".*\\.sst");
@@ -81,17 +78,18 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
     private static final int MAX_WRITE_BUFFERS = 3;
     private static final String DB_FILE_DIR = "rocksdb";
 
-    private final String name;
+    final String name;
     private final String parentDir;
-    private final Set<KeyValueIterator> openIterators = Collections.synchronizedSet(new HashSet<>());
+    final Set<KeyValueIterator<Bytes, byte[]>> openIterators = Collections.synchronizedSet(new HashSet<>());
 
     File dbDir;
-    private RocksDB db;
+    RocksDB db;
+    RocksDBAccessor dbAccessor;
 
     // the following option objects will be created in the constructor and closed in the close() method
-    private Options options;
-    private WriteOptions wOptions;
-    private FlushOptions fOptions;
+    private RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter userSpecifiedOptions;
+    WriteOptions wOptions;
+    FlushOptions fOptions;
 
     private volatile boolean prepareForBulkload = false;
     ProcessorContext internalProcessorContext;
@@ -112,25 +110,27 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
 
 
     @SuppressWarnings("unchecked")
-    public void openDB(final ProcessorContext context) {
+    void openDB(final ProcessorContext context) {
         // initialize the default rocksdb options
 
-        options = new Options();
+        final DBOptions dbOptions = new DBOptions();
+        final ColumnFamilyOptions columnFamilyOptions = new ColumnFamilyOptions();
+        userSpecifiedOptions = new RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter(dbOptions, columnFamilyOptions);
 
         final BlockBasedTableConfig tableConfig = new BlockBasedTableConfig();
         tableConfig.setBlockCacheSize(BLOCK_CACHE_SIZE);
         tableConfig.setBlockSize(BLOCK_SIZE);
         tableConfig.setFilter(new BloomFilter());
 
-        options.optimizeFiltersForHits();
-        options.setTableFormatConfig(tableConfig);
-        options.setWriteBufferSize(WRITE_BUFFER_SIZE);
-        options.setCompressionType(COMPRESSION_TYPE);
-        options.setCompactionStyle(COMPACTION_STYLE);
-        options.setMaxWriteBufferNumber(MAX_WRITE_BUFFERS);
-        options.setCreateIfMissing(true);
-        options.setErrorIfExists(false);
-        options.setInfoLogLevel(InfoLogLevel.ERROR_LEVEL);
+        userSpecifiedOptions.optimizeFiltersForHits();
+        userSpecifiedOptions.setTableFormatConfig(tableConfig);
+        userSpecifiedOptions.setWriteBufferSize(WRITE_BUFFER_SIZE);
+        userSpecifiedOptions.setCompressionType(COMPRESSION_TYPE);
+        userSpecifiedOptions.setCompactionStyle(COMPACTION_STYLE);
+        userSpecifiedOptions.setMaxWriteBufferNumber(MAX_WRITE_BUFFERS);
+        userSpecifiedOptions.setCreateIfMissing(true);
+        userSpecifiedOptions.setErrorIfExists(false);
+        userSpecifiedOptions.setInfoLogLevel(InfoLogLevel.ERROR_LEVEL);
         // this is the recommended way to increase parallelism in RocksDb
         // note that the current implementation of setIncreaseParallelism affects the number
         // of compaction threads but not flush threads (the latter remains one). Also
@@ -138,7 +138,7 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
         // https://github.com/facebook/rocksdb/blob/62ad0a9b19f0be4cefa70b6b32876e764b7f3c11/util/options.cc#L580
         // subtracts one from the value passed to determine the number of compaction threads
         // (this could be a bug in the RocksDB code and their devs have been contacted).
-        options.setIncreaseParallelism(Math.max(Runtime.getRuntime().availableProcessors(), 2));
+        userSpecifiedOptions.setIncreaseParallelism(Math.max(Runtime.getRuntime().availableProcessors(), 2));
 
         wOptions = new WriteOptions();
         wOptions.setDisableWAL(true);
@@ -148,34 +148,44 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
 
         final Map<String, Object> configs = context.appConfigs();
         final Class<RocksDBConfigSetter> configSetterClass =
-                (Class<RocksDBConfigSetter>) configs.get(StreamsConfig.ROCKSDB_CONFIG_SETTER_CLASS_CONFIG);
+            (Class<RocksDBConfigSetter>) configs.get(StreamsConfig.ROCKSDB_CONFIG_SETTER_CLASS_CONFIG);
 
         if (configSetterClass != null) {
             final RocksDBConfigSetter configSetter = Utils.newInstance(configSetterClass);
-            configSetter.setConfig(name, options, configs);
+            configSetter.setConfig(name, userSpecifiedOptions, configs);
         }
 
         if (prepareForBulkload) {
-            options.prepareForBulkLoad();
+            userSpecifiedOptions.prepareForBulkLoad();
         }
 
         dbDir = new File(new File(context.stateDir(), parentDir), name);
 
         try {
-            try {
-                Files.createDirectories(dbDir.getParentFile().toPath());
-                Files.createDirectories(dbDir.getAbsoluteFile().toPath());
-                db = RocksDB.open(options, dbDir.getAbsolutePath());
-            } catch (final RocksDBException e) {
-                throw new ProcessorStateException("Error opening store " + name + " at location " + dbDir.toString(), e);
-            }
-        } catch (final IOException e) {
-            throw new ProcessorStateException(e);
+            Files.createDirectories(dbDir.getParentFile().toPath());
+            Files.createDirectories(dbDir.getAbsoluteFile().toPath());
+        } catch (final IOException fatal) {
+            throw new ProcessorStateException(fatal);
         }
 
+        openRocksDB(dbOptions, columnFamilyOptions);
         open = true;
     }
 
+    void openRocksDB(final DBOptions dbOptions,
+                     final ColumnFamilyOptions columnFamilyOptions) {
+        final List<ColumnFamilyDescriptor> columnFamilyDescriptors
+            = Collections.singletonList(new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY, columnFamilyOptions));
+        final List<ColumnFamilyHandle> columnFamilies = new ArrayList<>(columnFamilyDescriptors.size());
+
+        try {
+            db = RocksDB.open(dbOptions, dbDir.getAbsolutePath(), columnFamilyDescriptors, columnFamilies);
+            dbAccessor = new SingleColumnFamilyAccessor(columnFamilies.get(0));
+        } catch (final RocksDBException e) {
+            throw new ProcessorStateException("Error opening store " + name + " at location " + dbDir.toString(), e);
+        }
+    }
+
     public void init(final ProcessorContext context,
                      final StateStore root) {
         // open the DB dir
@@ -208,54 +218,19 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
         return open;
     }
 
-    @Override
-    public synchronized byte[] get(final Bytes key) {
-        validateStoreOpen();
-        return getInternal(key.get());
-    }
-
     private void validateStoreOpen() {
         if (!open) {
             throw new InvalidStateStoreException("Store " + name + " is currently closed");
         }
     }
 
-    private byte[] getInternal(final byte[] rawKey) {
-        try {
-            return db.get(rawKey);
-        } catch (final RocksDBException e) {
-            // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
-            throw new ProcessorStateException("Error while getting value for key %s from store " + name, e);
-        }
-    }
-
-    void toggleDbForBulkLoading(final boolean prepareForBulkload) {
-        if (prepareForBulkload) {
-            // if the store is not empty, we need to compact to get around the num.levels check
-            // for bulk loading
-            final String[] sstFileNames = dbDir.list((dir, name) -> SST_FILE_EXTENSION.matcher(name).matches());
-
-            if (sstFileNames != null && sstFileNames.length > 0) {
-                try {
-                    db.compactRange(true, 1, 0);
-                } catch (final RocksDBException e) {
-                    throw new ProcessorStateException("Error while range compacting during restoring  store " + name, e);
-                }
-            }
-        }
-
-        close();
-        this.prepareForBulkload = prepareForBulkload;
-        openDB(internalProcessorContext);
-    }
-
     @SuppressWarnings("unchecked")
     @Override
     public synchronized void put(final Bytes key,
                                  final byte[] value) {
         Objects.requireNonNull(key, "key cannot be null");
         validateStoreOpen();
-        putInternal(key.get(), value);
+        dbAccessor.put(key.get(), value);
     }
 
     @Override
@@ -269,68 +244,39 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
         return originalValue;
     }
 
-    private void restoreAllInternal(final Collection<KeyValue<byte[], byte[]>> records) {
+    @Override
+    public void putAll(final List<KeyValue<Bytes, byte[]>> entries) {
         try (final WriteBatch batch = new WriteBatch()) {
-            for (final KeyValue<byte[], byte[]> record : records) {
-                if (record.value == null) {
-                    batch.delete(record.key);
-                } else {
-                    batch.put(record.key, record.value);
-                }
-            }
+            dbAccessor.prepareBatch(entries, batch);
             write(batch);
         } catch (final RocksDBException e) {
-            throw new ProcessorStateException("Error restoring batch to store " + name, e);
-        }
-    }
-
-    private void putInternal(final byte[] rawKey,
-                             final byte[] rawValue) {
-        if (rawValue == null) {
-            try {
-                db.delete(wOptions, rawKey);
-            } catch (final RocksDBException e) {
-                // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
-                throw new ProcessorStateException("Error while removing key %s from store " + name, e);
-            }
-        } else {
-            try {
-                db.put(wOptions, rawKey, rawValue);
-            } catch (final RocksDBException e) {
-                // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
-                throw new ProcessorStateException("Error while putting key %s value %s into store " + name, e);
-            }
+            throw new ProcessorStateException("Error while batch writing to store " + name, e);
         }
     }
 
-    void write(final WriteBatch batch) throws RocksDBException {
-        db.write(wOptions, batch);
-    }
-
     @Override
-    public void putAll(final List<KeyValue<Bytes, byte[]>> entries) {
-        try (final WriteBatch batch = new WriteBatch()) {
-            for (final KeyValue<Bytes, byte[]> entry : entries) {
-                Objects.requireNonNull(entry.key, "key cannot be null");
-                if (entry.value == null) {
-                    batch.delete(entry.key.get());
-                } else {
-                    batch.put(entry.key.get(), entry.value);
-                }
-            }
-            write(batch);
+    public synchronized byte[] get(final Bytes key) {
+        validateStoreOpen();
+        try {
+            return dbAccessor.get(key.get());
         } catch (final RocksDBException e) {
-            throw new ProcessorStateException("Error while batch writing to store " + name, e);
+            // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+            throw new ProcessorStateException("Error while getting value for key from store " + name, e);
         }
-
     }
 
     @Override
     public synchronized byte[] delete(final Bytes key) {
         Objects.requireNonNull(key, "key cannot be null");
-        final byte[] value = get(key);
+        final byte[] oldValue;
+        try {
+            oldValue = dbAccessor.getOnly(key.get());
+        } catch (final RocksDBException e) {
+            // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+            throw new ProcessorStateException("Error while getting value for key from store " + name, e);
+        }
         put(key, null);
-        return value;
+        return oldValue;
     }
 
     @Override
@@ -340,8 +286,7 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
         Objects.requireNonNull(to, "to cannot be null");
         validateStoreOpen();
 
-        // query rocksdb
-        final RocksDBRangeIterator rocksDBRangeIterator = new RocksDBRangeIterator(name, db.newIterator(), from, to);
+        final KeyValueIterator<Bytes, byte[]> rocksDBRangeIterator = dbAccessor.range(from, to);
         openIterators.add(rocksDBRangeIterator);
 
         return rocksDBRangeIterator;
@@ -350,10 +295,7 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
     @Override
     public synchronized KeyValueIterator<Bytes, byte[]> all() {
         validateStoreOpen();
-        // query rocksdb
-        final RocksIterator innerIter = db.newIterator();
-        innerIter.seekToFirst();
-        final RocksDbIterator rocksDbIterator = new RocksDbIterator(name, innerIter);
+        final KeyValueIterator<Bytes, byte[]> rocksDbIterator = dbAccessor.all();
         openIterators.add(rocksDbIterator);
         return rocksDbIterator;
     }
@@ -372,16 +314,16 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
     @Override
     public long approximateNumEntries() {
         validateStoreOpen();
-        final long value;
+        final long numEntries;
         try {
-            value = db.getLongProperty("rocksdb.estimate-num-keys");
+            numEntries = dbAccessor.approximateNumEntries();
         } catch (final RocksDBException e) {
             throw new ProcessorStateException("Error fetching property from store " + name, e);
         }
-        if (isOverflowing(value)) {
+        if (isOverflowing(numEntries)) {
             return Long.MAX_VALUE;
         }
-        return value;
+        return numEntries;
     }
 
     private boolean isOverflowing(final long value) {
@@ -395,20 +337,32 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
         if (db == null) {
             return;
         }
-        // flush RocksDB
-        flushInternal();
-    }
-    /**
-     * @throws ProcessorStateException if flushing failed because of any internal store exceptions
-     */
-    private void flushInternal() {
         try {
-            db.flush(fOptions);
+            dbAccessor.flush();
         } catch (final RocksDBException e) {
             throw new ProcessorStateException("Error while executing flush from store " + name, e);
         }
     }
 
+    void toggleDbForBulkLoading(final boolean prepareForBulkload) {
+        if (prepareForBulkload) {
+            // if the store is not empty, we need to compact to get around the num.levels check for bulk loading
+            final String[] sstFileNames = dbDir.list((dir, name) -> SST_FILE_EXTENSION.matcher(name).matches());
+
+            if (sstFileNames != null && sstFileNames.length > 0) {
+                dbAccessor.toggleDbForBulkLoading();
+            }
+        }
+
+        close();
+        this.prepareForBulkload = prepareForBulkload;
+        openDB(internalProcessorContext);
+    }
+
+    void write(final WriteBatch batch) throws RocksDBException {
+        db.write(wOptions, batch);
+    }
+
     @Override
     public synchronized void close() {
         if (!open) {
@@ -417,129 +371,170 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
 
         open = false;
         closeOpenIterators();
-        options.close();
+        dbAccessor.close();
+        userSpecifiedOptions.close();
         wOptions.close();
         fOptions.close();
         db.close();
 
-        options = null;
+        userSpecifiedOptions = null;
         wOptions = null;
         fOptions = null;
         db = null;
     }
 
     private void closeOpenIterators() {
-        final HashSet<KeyValueIterator> iterators;
+        final HashSet<KeyValueIterator<Bytes, byte[]>> iterators;
         synchronized (openIterators) {
             iterators = new HashSet<>(openIterators);
         }
         if (iterators.size() != 0) {
             log.warn("Closing {} open iterators for store {}", iterators.size(), name);
-            for (final KeyValueIterator iterator : iterators) {
+            for (final KeyValueIterator<Bytes, byte[]> iterator : iterators) {
                 iterator.close();
             }
         }
     }
 
-    private class RocksDbIterator
-        extends AbstractIterator<KeyValue<Bytes, byte[]>>
-        implements KeyValueIterator<Bytes, byte[]> {
 
-        private final String storeName;
-        private final RocksIterator iter;
 
-        private volatile boolean open = true;
+    interface RocksDBAccessor {
+
+        void put(final byte[] key,
+                 final byte[] value);
+
+        void prepareBatch(final List<KeyValue<Bytes, byte[]>> entries,
+                          final WriteBatch batch) throws RocksDBException;
+
+        byte[] get(final byte[] key) throws RocksDBException;
+
+        /**
+         * In contrast to get(), we don't migrate the key to new CF.
+         * <p>
+         * Use for get() within delete() -- no need to migrate, as it's deleted anyway
+         */
+        byte[] getOnly(final byte[] key) throws RocksDBException;
+
+        KeyValueIterator<Bytes, byte[]> range(final Bytes from,
+                                              final Bytes to);
+
+        KeyValueIterator<Bytes, byte[]> all();
+
+        long approximateNumEntries() throws RocksDBException;
+
+        void flush() throws RocksDBException;
+
+        void prepareBatchForRestore(final Collection<KeyValue<byte[], byte[]>> records,
+                                    final WriteBatch batch) throws RocksDBException;
+
+        void close();
+
+        void toggleDbForBulkLoading();
+    }
 
-        private KeyValue<Bytes, byte[]> next;
+    class SingleColumnFamilyAccessor implements RocksDBAccessor {
+        private final ColumnFamilyHandle columnFamily;
 
-        RocksDbIterator(final String storeName,
-                        final RocksIterator iter) {
-            this.iter = iter;
-            this.storeName = storeName;
+        SingleColumnFamilyAccessor(final ColumnFamilyHandle columnFamily) {
+            this.columnFamily = columnFamily;
         }
 
         @Override
-        public synchronized boolean hasNext() {
-            if (!open) {
-                throw new InvalidStateStoreException(String.format("RocksDB iterator for store %s has closed", storeName));
+        public void put(final byte[] key,
+                        final byte[] value) {
+            if (value == null) {
+                try {
+                    db.delete(columnFamily, wOptions, key);
+                } catch (final RocksDBException e) {
+                    // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+                    throw new ProcessorStateException("Error while removing key from store " + name, e);
+                }
+            } else {
+                try {
+                    db.put(columnFamily, wOptions, key, value);
+                } catch (final RocksDBException e) {
+                    // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+                    throw new ProcessorStateException("Error while putting key/value into store " + name, e);
+                }
             }
-            return super.hasNext();
         }
 
         @Override
-        public synchronized KeyValue<Bytes, byte[]> next() {
-            return super.next();
+        public void prepareBatch(final List<KeyValue<Bytes, byte[]>> entries,
+                                 final WriteBatch batch) throws RocksDBException {
+            for (final KeyValue<Bytes, byte[]> entry : entries) {
+                Objects.requireNonNull(entry.key, "key cannot be null");
+                if (entry.value == null) {
+                    batch.delete(columnFamily, entry.key.get());
+                } else {
+                    batch.put(columnFamily, entry.key.get(), entry.value);
+                }
+            }
         }
 
         @Override
-        public KeyValue<Bytes, byte[]> makeNext() {
-            if (!iter.isValid()) {
-                return allDone();
-            } else {
-                next = getKeyValue();
-                iter.next();
-                return next;
-            }
+        public byte[] get(final byte[] key) throws RocksDBException {
+            return db.get(columnFamily, key);
         }
 
-        private KeyValue<Bytes, byte[]> getKeyValue() {
-            return new KeyValue<>(new Bytes(iter.key()), iter.value());
+        @Override
+        public byte[] getOnly(final byte[] key) throws RocksDBException {
+            return db.get(columnFamily, key);
         }
 
         @Override
-        public void remove() {
-            throw new UnsupportedOperationException("RocksDB iterator does not support remove()");
+        public KeyValueIterator<Bytes, byte[]> range(final Bytes from,
+                                                     final Bytes to) {
+            return new RocksDBRangeIterator(
+                name,
+                db.newIterator(columnFamily),
+                openIterators,
+                from,
+                to);
         }
 
         @Override
-        public synchronized void close() {
-            openIterators.remove(this);
-            iter.close();
-            open = false;
+        public KeyValueIterator<Bytes, byte[]> all() {
+            final RocksIterator innerIterWithTimestamp = db.newIterator(columnFamily);
+            innerIterWithTimestamp.seekToFirst();
+            return new RocksDbIterator(name, innerIterWithTimestamp, openIterators);
         }
 
         @Override
-        public Bytes peekNextKey() {
-            if (!hasNext()) {
-                throw new NoSuchElementException();
-            }
-            return next.key;
+        public long approximateNumEntries() throws RocksDBException {
+            return db.getLongProperty(columnFamily, "rocksdb.estimate-num-keys");
         }
-    }
 
-    private class RocksDBRangeIterator extends RocksDbIterator {
-        // RocksDB's JNI interface does not expose getters/setters that allow the
-        // comparator to be pluggable, and the default is lexicographic, so it's
-        // safe to just force lexicographic comparator here for now.
-        private final Comparator<byte[]> comparator = Bytes.BYTES_LEXICO_COMPARATOR;
-        private final byte[] rawToKey;
-
-        RocksDBRangeIterator(final String storeName,
-                             final RocksIterator iter,
-                             final Bytes from,
-                             final Bytes to) {
-            super(storeName, iter);
-            iter.seek(from.get());
-            rawToKey = to.get();
-            if (rawToKey == null) {
-                throw new NullPointerException("RocksDBRangeIterator: RawToKey is null for key " + to);
-            }
+        @Override
+        public void flush() throws RocksDBException {
+            db.flush(fOptions, columnFamily);
         }
 
         @Override
-        public KeyValue<Bytes, byte[]> makeNext() {
-            final KeyValue<Bytes, byte[]> next = super.makeNext();
-
-            if (next == null) {
-                return allDone();
-            } else {
-                if (comparator.compare(next.key.get(), rawToKey) <= 0) {
-                    return next;
+        public void prepareBatchForRestore(final Collection<KeyValue<byte[], byte[]>> records,
+                                           final WriteBatch batch) throws RocksDBException {
+            for (final KeyValue<byte[], byte[]> record : records) {
+                if (record.value == null) {
+                    batch.delete(columnFamily, record.key);
                 } else {
-                    return allDone();
+                    batch.put(columnFamily, record.key, record.value);
                 }
             }
         }
+
+        @Override
+        public void close() {
+            columnFamily.close();
+        }
+
+        @Override
+        public void toggleDbForBulkLoading() {
+            try {
+                db.compactRange(columnFamily, true, 1, 0);
+            } catch (final RocksDBException e) {
+                throw new ProcessorStateException("Error while range compacting during restoring  store " + name, e);
+            }
+        }
     }
 
     // not private for testing
@@ -553,7 +548,12 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
 
         @Override
         public void restoreAll(final Collection<KeyValue<byte[], byte[]>> records) {
-            rocksDBStore.restoreAllInternal(records);
+            try (final WriteBatch batch = new WriteBatch()) {
+                rocksDBStore.dbAccessor.prepareBatchForRestore(records, batch);
+                rocksDBStore.write(batch);
+            } catch (final RocksDBException e) {
+                throw new ProcessorStateException("Error restoring batch to store " + rocksDBStore.name, e);
+            }
         }
 
         @Override
@@ -574,6 +574,6 @@ public class RocksDBStore implements KeyValueStore<Bytes, byte[]> {
 
     // for testing
     public Options getOptions() {
-        return options;
+        return userSpecifiedOptions;
     }
 }
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBTimestampedStore.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBTimestampedStore.java
new file mode 100644
index 0000000..6d477bd
--- /dev/null
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDBTimestampedStore.java
@@ -0,0 +1,394 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.streams.state.internals;
+
+import org.apache.kafka.common.utils.AbstractIterator;
+import org.apache.kafka.common.utils.Bytes;
+import org.apache.kafka.streams.KeyValue;
+import org.apache.kafka.streams.errors.InvalidStateStoreException;
+import org.apache.kafka.streams.errors.ProcessorStateException;
+import org.apache.kafka.streams.state.KeyValueIterator;
+import org.rocksdb.ColumnFamilyDescriptor;
+import org.rocksdb.ColumnFamilyHandle;
+import org.rocksdb.ColumnFamilyOptions;
+import org.rocksdb.DBOptions;
+import org.rocksdb.RocksDB;
+import org.rocksdb.RocksDBException;
+import org.rocksdb.RocksIterator;
+import org.rocksdb.WriteBatch;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+
+import static java.util.Arrays.asList;
+import static org.apache.kafka.streams.state.internals.StoreProxyUtils.getValueWithUnknownTimestamp;
+
+/**
+ * A persistent key-(value-timestamp) store based on RocksDB.
+ */
+public class RocksDBTimestampedStore extends RocksDBStore {
+    private static final Logger log = LoggerFactory.getLogger(RocksDBTimestampedStore.class);
+
+    RocksDBTimestampedStore(final String name) {
+        super(name);
+    }
+
+    @Override
+    void openRocksDB(final DBOptions dbOptions,
+                     final ColumnFamilyOptions columnFamilyOptions) {
+        final List<ColumnFamilyDescriptor> columnFamilyDescriptors = asList(
+            new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY, columnFamilyOptions),
+            new ColumnFamilyDescriptor("keyValueWithTimestamp".getBytes(StandardCharsets.UTF_8), columnFamilyOptions));
+        final List<ColumnFamilyHandle> columnFamilies = new ArrayList<>(columnFamilyDescriptors.size());
+
+        try {
+            db = RocksDB.open(dbOptions, dbDir.getAbsolutePath(), columnFamilyDescriptors, columnFamilies);
+
+            final ColumnFamilyHandle noTimestampColumnFamily = columnFamilies.get(0);
+
+            final RocksIterator noTimestampsIter = db.newIterator(noTimestampColumnFamily);
+            noTimestampsIter.seekToFirst();
+            if (noTimestampsIter.isValid()) {
+                log.info("Opening store {} in upgrade mode", name);
+                dbAccessor = new DualColumnFamilyAccessor(noTimestampColumnFamily, columnFamilies.get(1));
+            } else {
+                log.info("Opening store {} in regular mode", name);
+                dbAccessor = new SingleColumnFamilyAccessor(columnFamilies.get(1));
+            }
+            noTimestampsIter.close();
+        } catch (final RocksDBException e) {
+            if ("Column family not found: : keyValueWithTimestamp".equals(e.getMessage())) {
+                try {
+                    db = RocksDB.open(dbOptions, dbDir.getAbsolutePath(), columnFamilyDescriptors.subList(0, 1), columnFamilies);
+                    columnFamilies.add(db.createColumnFamily(columnFamilyDescriptors.get(1)));
+                } catch (final RocksDBException fatal) {
+                    throw new ProcessorStateException("Error opening store " + name + " at location " + dbDir.toString(), fatal);
+                }
+                log.info("Opening store {} in upgrade mode", name);
+                dbAccessor = new DualColumnFamilyAccessor(columnFamilies.get(0), columnFamilies.get(1));
+            } else {
+                throw new ProcessorStateException("Error opening store " + name + " at location " + dbDir.toString(), e);
+            }
+        }
+    }
+
+
+
+    private class DualColumnFamilyAccessor implements RocksDBAccessor {
+        private final ColumnFamilyHandle oldColumnFamily;
+        private final ColumnFamilyHandle newColumnFamily;
+
+        private DualColumnFamilyAccessor(final ColumnFamilyHandle oldColumnFamily,
+                                         final ColumnFamilyHandle newColumnFamily) {
+            this.oldColumnFamily = oldColumnFamily;
+            this.newColumnFamily = newColumnFamily;
+        }
+
+        @Override
+        public void put(final byte[] key,
+                        final byte[] valueWithTimestamp) {
+            if (valueWithTimestamp == null) {
+                try {
+                    db.delete(oldColumnFamily, wOptions, key);
+                } catch (final RocksDBException e) {
+                    // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+                    throw new ProcessorStateException("Error while removing key from store " + name, e);
+                }
+                try {
+                    db.delete(newColumnFamily, wOptions, key);
+                } catch (final RocksDBException e) {
+                    // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+                    throw new ProcessorStateException("Error while removing key from store " + name, e);
+                }
+            } else {
+                try {
+                    db.delete(oldColumnFamily, wOptions, key);
+                } catch (final RocksDBException e) {
+                    // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+                    throw new ProcessorStateException("Error while removing key from store " + name, e);
+                }
+                try {
+                    db.put(newColumnFamily, wOptions, key, valueWithTimestamp);
+                } catch (final RocksDBException e) {
+                    // String format is happening in wrapping stores. So formatted message is thrown from wrapping stores.
+                    throw new ProcessorStateException("Error while putting key/value into store " + name, e);
+                }
+            }
+        }
+
+        @Override
+        public void prepareBatch(final List<KeyValue<Bytes, byte[]>> entries,
+                                 final WriteBatch batch) throws RocksDBException {
+            for (final KeyValue<Bytes, byte[]> entry : entries) {
+                Objects.requireNonNull(entry.key, "key cannot be null");
+                if (entry.value == null) {
+                    batch.delete(oldColumnFamily, entry.key.get());
+                    batch.delete(newColumnFamily, entry.key.get());
+                } else {
+                    batch.delete(oldColumnFamily, entry.key.get());
+                    batch.put(newColumnFamily, entry.key.get(), entry.value);
+                }
+            }
+        }
+
+        @Override
+        public byte[] get(final byte[] key) throws RocksDBException {
+            final byte[] valueWithTimestamp = db.get(newColumnFamily, key);
+            if (valueWithTimestamp != null) {
+                return valueWithTimestamp;
+            }
+
+            final byte[] plainValue = db.get(oldColumnFamily, key);
+            if (plainValue != null) {
+                final byte[] valueWithUnknownTimestamp = getValueWithUnknownTimestamp(plainValue);
+                // this does only work, because the changelog topic contains correct data already
+                // for other format changes, we cannot take this short cut and can only migrate data
+                // from old to new store on put()
+                put(key, valueWithUnknownTimestamp);
+                return valueWithUnknownTimestamp;
+            }
+
+            return null;
+        }
+
+        @Override
+        public byte[] getOnly(final byte[] key) throws RocksDBException {
+            final byte[] valueWithTimestamp = db.get(newColumnFamily, key);
+            if (valueWithTimestamp != null) {
+                return valueWithTimestamp;
+            }
+
+            final byte[] plainValue = db.get(oldColumnFamily, key);
+            if (plainValue != null) {
+                return getValueWithUnknownTimestamp(plainValue);
+            }
+
+            return null;
+        }
+
+        @Override
+        public KeyValueIterator<Bytes, byte[]> range(final Bytes from,
+                                                     final Bytes to) {
+            return new RocksDBDualCFRangeIterator(
+                name,
+                db.newIterator(newColumnFamily),
+                db.newIterator(oldColumnFamily),
+                from,
+                to);
+        }
+
+        @Override
+        public KeyValueIterator<Bytes, byte[]> all() {
+            final RocksIterator innerIterWithTimestamp = db.newIterator(newColumnFamily);
+            innerIterWithTimestamp.seekToFirst();
+            final RocksIterator innerIterNoTimestamp = db.newIterator(oldColumnFamily);
+            innerIterNoTimestamp.seekToFirst();
+            return new RocksDBDualCFIterator(name, innerIterWithTimestamp, innerIterNoTimestamp);
+        }
+
+        @Override
+        public long approximateNumEntries() throws RocksDBException {
+            return db.getLongProperty(oldColumnFamily, "rocksdb.estimate-num-keys")
+                + db.getLongProperty(newColumnFamily, "rocksdb.estimate-num-keys");
+        }
+
+        @Override
+        public void flush() throws RocksDBException {
+            db.flush(fOptions, oldColumnFamily);
+            db.flush(fOptions, newColumnFamily);
+        }
+
+        @Override
+        public void prepareBatchForRestore(final Collection<KeyValue<byte[], byte[]>> records,
+                                           final WriteBatch batch) throws RocksDBException {
+            for (final KeyValue<byte[], byte[]> record : records) {
+                if (record.value == null) {
+                    batch.delete(oldColumnFamily, record.key);
+                    batch.delete(newColumnFamily, record.key);
+                } else {
+                    batch.delete(oldColumnFamily, record.key);
+                    batch.put(newColumnFamily, record.key, record.value);
+                }
+            }
+        }
+
+        @Override
+        public void close() {
+            oldColumnFamily.close();
+            newColumnFamily.close();
+        }
+
+        @Override
+        public void toggleDbForBulkLoading() {
+            try {
+                db.compactRange(oldColumnFamily, true, 1, 0);
+            } catch (final RocksDBException e) {
+                throw new ProcessorStateException("Error while range compacting during restoring  store " + name, e);
+            }
+            try {
+                db.compactRange(newColumnFamily, true, 1, 0);
+            } catch (final RocksDBException e) {
+                throw new ProcessorStateException("Error while range compacting during restoring  store " + name, e);
+            }
+        }
+    }
+
+    private class RocksDBDualCFIterator extends AbstractIterator<KeyValue<Bytes, byte[]>>
+        implements KeyValueIterator<Bytes, byte[]> {
+
+        // RocksDB's JNI interface does not expose getters/setters that allow the
+        // comparator to be pluggable, and the default is lexicographic, so it's
+        // safe to just force lexicographic comparator here for now.
+        private final Comparator<byte[]> comparator = Bytes.BYTES_LEXICO_COMPARATOR;
+
+        private final String storeName;
+        private final RocksIterator iterWithTimestamp;
+        private final RocksIterator iterNoTimestamp;
+
+        private volatile boolean open = true;
+
+        private byte[] nextWithTimestamp;
+        private byte[] nextNoTimestamp;
+        private KeyValue<Bytes, byte[]> next;
+
+        RocksDBDualCFIterator(final String storeName,
+                              final RocksIterator iterWithTimestamp,
+                              final RocksIterator iterNoTimestamp) {
+            this.iterWithTimestamp = iterWithTimestamp;
+            this.iterNoTimestamp = iterNoTimestamp;
+            this.storeName = storeName;
+        }
+
+        @Override
+        public synchronized boolean hasNext() {
+            if (!open) {
+                throw new InvalidStateStoreException(String.format("RocksDB iterator for store %s has closed", storeName));
+            }
+            return super.hasNext();
+        }
+
+        @Override
+        public synchronized KeyValue<Bytes, byte[]> next() {
+            return super.next();
+        }
+
+        @Override
+        public KeyValue<Bytes, byte[]> makeNext() {
+            if (nextNoTimestamp == null && iterNoTimestamp.isValid()) {
+                nextNoTimestamp = iterNoTimestamp.key();
+            }
+
+            if (nextWithTimestamp == null && iterWithTimestamp.isValid()) {
+                nextWithTimestamp = iterWithTimestamp.key();
+            }
+
+            if (nextNoTimestamp == null && !iterNoTimestamp.isValid()) {
+                if (nextWithTimestamp == null && !iterWithTimestamp.isValid()) {
+                    return allDone();
+                } else {
+                    next = KeyValue.pair(new Bytes(nextWithTimestamp), iterWithTimestamp.value());
+                    nextWithTimestamp = null;
+                    iterWithTimestamp.next();
+                }
+            } else {
+                if (nextWithTimestamp == null) {
+                    next = KeyValue.pair(new Bytes(nextNoTimestamp), getValueWithUnknownTimestamp(iterNoTimestamp.value()));
+                    nextNoTimestamp = null;
+                    iterNoTimestamp.next();
+                } else {
+                    if (comparator.compare(nextNoTimestamp, nextWithTimestamp) <= 0) {
+                        next = KeyValue.pair(new Bytes(nextNoTimestamp), getValueWithUnknownTimestamp(iterNoTimestamp.value()));
+                        nextNoTimestamp = null;
+                        iterNoTimestamp.next();
+                    } else {
+                        next = KeyValue.pair(new Bytes(nextWithTimestamp), iterWithTimestamp.value());
+                        nextWithTimestamp = null;
+                        iterWithTimestamp.next();
+                    }
+                }
+            }
+
+            return next;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException("RocksDB iterator does not support remove()");
+        }
+
+        @Override
+        public synchronized void close() {
+            openIterators.remove(this);
+            iterNoTimestamp.close();
+            iterWithTimestamp.close();
+            open = false;
+        }
+
+        @Override
+        public Bytes peekNextKey() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            return next.key;
+        }
+    }
+
+    private class RocksDBDualCFRangeIterator extends RocksDBDualCFIterator {
+        // RocksDB's JNI interface does not expose getters/setters that allow the
+        // comparator to be pluggable, and the default is lexicographic, so it's
+        // safe to just force lexicographic comparator here for now.
+        private final Comparator<byte[]> comparator = Bytes.BYTES_LEXICO_COMPARATOR;
+        private final byte[] upperBoundKey;
+
+        RocksDBDualCFRangeIterator(final String storeName,
+                                   final RocksIterator iterWithTimestamp,
+                                   final RocksIterator iterNoTimestamp,
+                                   final Bytes from,
+                                   final Bytes to) {
+            super(storeName, iterWithTimestamp, iterNoTimestamp);
+            iterWithTimestamp.seek(from.get());
+            iterNoTimestamp.seek(from.get());
+            upperBoundKey = to.get();
+            if (upperBoundKey == null) {
+                throw new NullPointerException("RocksDBDualCFRangeIterator: upperBoundKey is null for key " + to);
+            }
+        }
+
+        @Override
+        public KeyValue<Bytes, byte[]> makeNext() {
+            final KeyValue<Bytes, byte[]> next = super.makeNext();
+
+            if (next == null) {
+                return allDone();
+            } else {
+                if (comparator.compare(next.key.get(), upperBoundKey) <= 0) {
+                    return next;
+                } else {
+                    return allDone();
+                }
+            }
+        }
+    }
+
+}
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbIterator.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbIterator.java
new file mode 100644
index 0000000..b26e7af
--- /dev/null
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbIterator.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.streams.state.internals;
+
+import org.apache.kafka.common.utils.AbstractIterator;
+import org.apache.kafka.common.utils.Bytes;
+import org.apache.kafka.streams.KeyValue;
+import org.apache.kafka.streams.errors.InvalidStateStoreException;
+import org.apache.kafka.streams.state.KeyValueIterator;
+import org.rocksdb.RocksIterator;
+
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+class RocksDbIterator extends AbstractIterator<KeyValue<Bytes, byte[]>> implements KeyValueIterator<Bytes, byte[]> {
+
+    private final String storeName;
+    private final RocksIterator iter;
+    private final Set<KeyValueIterator<Bytes, byte[]>> openIterators;
+
+    private volatile boolean open = true;
+
+    private KeyValue<Bytes, byte[]> next;
+
+    RocksDbIterator(final String storeName,
+                    final RocksIterator iter,
+                    final Set<KeyValueIterator<Bytes, byte[]>> openIterators) {
+        this.storeName = storeName;
+        this.iter = iter;
+        this.openIterators = openIterators;
+    }
+
+    @Override
+    public synchronized boolean hasNext() {
+        if (!open) {
+            throw new InvalidStateStoreException(String.format("RocksDB iterator for store %s has closed", storeName));
+        }
+        return super.hasNext();
+    }
+
+    @Override
+    public KeyValue<Bytes, byte[]> makeNext() {
+        if (!iter.isValid()) {
+            return allDone();
+        } else {
+            next = getKeyValue();
+            iter.next();
+            return next;
+        }
+    }
+
+    private KeyValue<Bytes, byte[]> getKeyValue() {
+        return new KeyValue<>(new Bytes(iter.key()), iter.value());
+    }
+
+    @Override
+    public void remove() {
+        throw new UnsupportedOperationException("RocksDB iterator does not support remove()");
+    }
+
+    @Override
+    public synchronized void close() {
+        openIterators.remove(this);
+        iter.close();
+        open = false;
+    }
+
+    @Override
+    public Bytes peekNextKey() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        return next.key;
+    }
+}
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbKeyValueBytesStoreSupplier.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbKeyValueBytesStoreSupplier.java
index b0ad619..1836c27 100644
--- a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbKeyValueBytesStoreSupplier.java
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbKeyValueBytesStoreSupplier.java
@@ -23,9 +23,12 @@ import org.apache.kafka.streams.state.KeyValueStore;
 public class RocksDbKeyValueBytesStoreSupplier implements KeyValueBytesStoreSupplier {
 
     private final String name;
+    private final boolean returnTimestampedStore;
 
-    public RocksDbKeyValueBytesStoreSupplier(final String name) {
+    public RocksDbKeyValueBytesStoreSupplier(final String name,
+                                             final boolean returnTimestampedStore) {
         this.name = name;
+        this.returnTimestampedStore = returnTimestampedStore;
     }
 
     @Override
@@ -35,7 +38,7 @@ public class RocksDbKeyValueBytesStoreSupplier implements KeyValueBytesStoreSupp
 
     @Override
     public KeyValueStore<Bytes, byte[]> get() {
-        return new RocksDBStore(name);
+        return returnTimestampedStore ? new RocksDBTimestampedStore(name) : new RocksDBStore(name);
     }
 
     @Override
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbKeyValueBytesStoreSupplier.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/StoreProxyUtils.java
similarity index 57%
copy from streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbKeyValueBytesStoreSupplier.java
copy to streams/src/main/java/org/apache/kafka/streams/state/internals/StoreProxyUtils.java
index b0ad619..e78b382 100644
--- a/streams/src/main/java/org/apache/kafka/streams/state/internals/RocksDbKeyValueBytesStoreSupplier.java
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/StoreProxyUtils.java
@@ -16,30 +16,21 @@
  */
 package org.apache.kafka.streams.state.internals;
 
-import org.apache.kafka.common.utils.Bytes;
-import org.apache.kafka.streams.state.KeyValueBytesStoreSupplier;
-import org.apache.kafka.streams.state.KeyValueStore;
+import java.nio.ByteBuffer;
 
-public class RocksDbKeyValueBytesStoreSupplier implements KeyValueBytesStoreSupplier {
+import static org.apache.kafka.clients.consumer.ConsumerRecord.NO_TIMESTAMP;
 
-    private final String name;
+class StoreProxyUtils {
 
-    public RocksDbKeyValueBytesStoreSupplier(final String name) {
-        this.name = name;
+    static byte[] getValueWithUnknownTimestamp(final byte[] rawValue) {
+        if (rawValue == null) {
+            return null;
+        }
+        return ByteBuffer
+            .allocate(8 + rawValue.length)
+            .putLong(NO_TIMESTAMP)
+            .put(rawValue)
+            .array();
     }
 
-    @Override
-    public String name() {
-        return name;
-    }
-
-    @Override
-    public KeyValueStore<Bytes, byte[]> get() {
-        return new RocksDBStore(name);
-    }
-
-    @Override
-    public String metricsScope() {
-        return "rocksdb-state";
-    }
 }
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapterTest.java b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapterTest.java
new file mode 100644
index 0000000..897f94f
--- /dev/null
+++ b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapterTest.java
@@ -0,0 +1,263 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.streams.state.internals;
+
+import org.easymock.EasyMockRunner;
+import org.easymock.Mock;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.rocksdb.AccessHint;
+import org.rocksdb.BuiltinComparator;
+import org.rocksdb.ColumnFamilyOptions;
+import org.rocksdb.CompactionPriority;
+import org.rocksdb.CompactionStyle;
+import org.rocksdb.ComparatorOptions;
+import org.rocksdb.CompressionType;
+import org.rocksdb.DBOptions;
+import org.rocksdb.Env;
+import org.rocksdb.InfoLogLevel;
+import org.rocksdb.LRUCache;
+import org.rocksdb.Logger;
+import org.rocksdb.Options;
+import org.rocksdb.PlainTableConfig;
+import org.rocksdb.RateLimiter;
+import org.rocksdb.RocksDB;
+import org.rocksdb.SstFileManager;
+import org.rocksdb.StringAppendOperator;
+import org.rocksdb.VectorMemTableConfig;
+import org.rocksdb.WALRecoveryMode;
+import org.rocksdb.util.BytewiseComparator;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.reset;
+import static org.easymock.EasyMock.verify;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.matchesPattern;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * The purpose of this test is, to catch interface changes if we upgrade {@link RocksDB}.
+ * Using reflections, we make sure the {@link RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter} maps all
+ * methods from {@link DBOptions} and {@link ColumnFamilyOptions} to/from {@link Options} correctly.
+ */
+@RunWith(EasyMockRunner.class)
+public class RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapterTest {
+    private final List<String> ignoreMethods = new LinkedList<String>() {
+        {
+            add("isOwningHandle");
+            add("dispose");
+            add("wait");
+            add("equals");
+            add("getClass");
+            add("hashCode");
+            add("notify");
+            add("notifyAll");
+            add("toString");
+        }
+    };
+
+    @Mock
+    private DBOptions dbOptions;
+    @Mock
+    private ColumnFamilyOptions columnFamilyOptions;
+
+    @Test
+    public void shouldOverwriteAllOptionsMethods() throws Exception {
+        for (final Method method : Options.class.getMethods()) {
+            if (!ignoreMethods.contains(method.getName())) {
+                RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter.class
+                    .getDeclaredMethod(method.getName(), method.getParameterTypes());
+            }
+        }
+    }
+
+    @Test
+    public void shouldForwardAllDbOptionsCalls() throws Exception {
+        for (final Method method : Options.class.getMethods()) {
+            if (!ignoreMethods.contains(method.getName())) {
+                try {
+                    DBOptions.class.getMethod(method.getName(), method.getParameterTypes());
+                    verifyDBOptionsMethodCall(method);
+                } catch (final NoSuchMethodException expectedAndSwallow) { }
+            }
+        }
+    }
+
+    private void verifyDBOptionsMethodCall(final Method method) throws Exception {
+        final RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter optionsFacadeDbOptions
+            = new RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter(dbOptions, new ColumnFamilyOptions());
+
+        final Object[] parameters = getDBOptionsParameters(method.getParameterTypes());
+
+        try {
+            reset(dbOptions);
+            replay(dbOptions);
+            method.invoke(optionsFacadeDbOptions, parameters);
+            verify();
+            fail("Should have called DBOptions." + method.getName() + "()");
+        } catch (final InvocationTargetException undeclaredMockMethodCall) {
+            assertThat(undeclaredMockMethodCall.getCause(), instanceOf(AssertionError.class));
+            assertThat(undeclaredMockMethodCall.getCause().getMessage().trim(),
+                matchesPattern("Unexpected method call DBOptions\\." + method.getName() + "((.*\n*)*):"));
+        }
+    }
+
+    private Object[] getDBOptionsParameters(final Class<?>[] parameterTypes) throws Exception {
+        final Object[] parameters = new Object[parameterTypes.length];
+
+        for (int i = 0; i < parameterTypes.length; ++i) {
+            switch (parameterTypes[i].getName()) {
+                case "boolean":
+                    parameters[i] = true;
+                    break;
+                case "int":
+                    parameters[i] = 0;
+                    break;
+                case "long":
+                    parameters[i] = 0L;
+                    break;
+                case "java.util.Collection":
+                    parameters[i] = new ArrayList<>();
+                    break;
+                case "org.rocksdb.AccessHint":
+                    parameters[i] = AccessHint.NONE;
+                    break;
+                case "org.rocksdb.Cache":
+                    parameters[i] = new LRUCache(1L);
+                    break;
+                case "org.rocksdb.Env":
+                    parameters[i] = Env.getDefault();
+                    break;
+                case "org.rocksdb.InfoLogLevel":
+                    parameters[i] = InfoLogLevel.FATAL_LEVEL;
+                    break;
+                case "org.rocksdb.Logger":
+                    parameters[i] = new Logger(new Options()) {
+                        @Override
+                        protected void log(final InfoLogLevel infoLogLevel, final String logMsg) {}
+                    };
+                    break;
+                case "org.rocksdb.RateLimiter":
+                    parameters[i] = new RateLimiter(1L);
+                    break;
+                case "org.rocksdb.SstFileManager":
+                    parameters[i] = new SstFileManager(Env.getDefault());
+                    break;
+                case "org.rocksdb.WALRecoveryMode":
+                    parameters[i] = WALRecoveryMode.AbsoluteConsistency;
+                    break;
+                default:
+                    parameters[i] = parameterTypes[i].newInstance();
+            }
+        }
+
+        return parameters;
+    }
+
+    @Test
+    public void shouldForwardAllColumnFamilyCalls() throws Exception {
+        for (final Method method : Options.class.getMethods()) {
+            if (!ignoreMethods.contains(method.getName())) {
+                try {
+                    ColumnFamilyOptions.class.getMethod(method.getName(), method.getParameterTypes());
+                    verifyColumnFamilyOptionsMethodCall(method);
+                } catch (final NoSuchMethodException expectedAndSwallow) { }
+            }
+        }
+    }
+
+    private void verifyColumnFamilyOptionsMethodCall(final Method method) throws Exception {
+        final RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter optionsFacadeColumnFamilyOptions
+            = new RocksDBGenericOptionsToDbOptionsColumnFamilyOptionsAdapter(new DBOptions(), columnFamilyOptions);
+
+        final Object[] parameters = getColumnFamilyOptionsParameters(method.getParameterTypes());
+
+        try {
+            reset(columnFamilyOptions);
+            replay(columnFamilyOptions);
+            method.invoke(optionsFacadeColumnFamilyOptions, parameters);
+            verify();
+            fail("Should have called ColumnFamilyOptions." + method.getName() + "()");
+        } catch (final InvocationTargetException undeclaredMockMethodCall) {
+            assertThat(undeclaredMockMethodCall.getCause(), instanceOf(AssertionError.class));
+            assertThat(undeclaredMockMethodCall.getCause().getMessage().trim(),
+                matchesPattern("Unexpected method call ColumnFamilyOptions\\." + method.getName() +  "(.*)"));
+        }
+    }
+
+    private Object[] getColumnFamilyOptionsParameters(final Class<?>[] parameterTypes) throws Exception {
+        final Object[] parameters = new Object[parameterTypes.length];
+
+        for (int i = 0; i < parameterTypes.length; ++i) {
+            switch (parameterTypes[i].getName()) {
+                case "boolean":
+                    parameters[i] = true;
+                    break;
+                case "double":
+                    parameters[i] = 0.0d;
+                    break;
+                case "int":
+                    parameters[i] = 0;
+                    break;
+                case "long":
+                    parameters[i] = 0L;
+                    break;
+                case "[I":
+                    parameters[i] = new int[0];
+                    break;
+                case "java.util.List":
+                    parameters[i] = new ArrayList<>();
+                    break;
+                case "org.rocksdb.AbstractComparator":
+                    parameters[i] = new BytewiseComparator(new ComparatorOptions());
+                    break;
+                case "org.rocksdb.BuiltinComparator":
+                    parameters[i] = BuiltinComparator.BYTEWISE_COMPARATOR;
+                    break;
+                case "org.rocksdb.CompactionPriority":
+                    parameters[i] = CompactionPriority.ByCompensatedSize;
+                    break;
+                case "org.rocksdb.CompactionStyle":
+                    parameters[i] = CompactionStyle.UNIVERSAL;
+                    break;
+                case "org.rocksdb.CompressionType":
+                    parameters[i] = CompressionType.NO_COMPRESSION;
+                    break;
+                case "org.rocksdb.MemTableConfig":
+                    parameters[i] = new VectorMemTableConfig();
+                    break;
+                case "org.rocksdb.MergeOperator":
+                    parameters[i] = new StringAppendOperator();
+                    break;
+                case "org.rocksdb.TableFormatConfig":
+                    parameters[i] = new PlainTableConfig();
+                    break;
+                default:
+                    parameters[i] = parameterTypes[i].newInstance();
+            }
+        }
+
+        return parameters;
+    }
+}
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBSessionStoreTest.java b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBSessionStoreTest.java
index f13ac0a..802df8d 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBSessionStoreTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBSessionStoreTest.java
@@ -280,7 +280,7 @@ public class RocksDBSessionStoreTest {
         return results;
     }
 
-    static <K, V> List<V> valuesToList(final KeyValueIterator<Windowed<K>, V> iterator) {
+    private static <K, V> List<V> valuesToList(final KeyValueIterator<Windowed<K>, V> iterator) {
         final List<V> results = new ArrayList<>();
         while (iterator.hasNext()) {
             results.add(iterator.next().value);
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBStoreTest.java b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBStoreTest.java
index b98f72f..4785673 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBStoreTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBStoreTest.java
@@ -58,18 +58,21 @@ import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 public class RocksDBStoreTest {
+    private static boolean enableBloomFilters = false;
+    final static String DB_NAME = "db-name";
+
+    private File dir;
     private final Serializer<String> stringSerializer = new StringSerializer();
     private final Deserializer<String> stringDeserializer = new StringDeserializer();
-    private RocksDBStore rocksDBStore;
-    private InternalMockProcessorContext context;
-    private File dir;
-    private static boolean enableBloomFilters = false;
+
+    InternalMockProcessorContext context;
+    RocksDBStore rocksDBStore;
 
     @Before
     public void setUp() {
         final Properties props = StreamsTestUtils.getStreamsConfig();
         props.put(StreamsConfig.ROCKSDB_CONFIG_SETTER_CLASS_CONFIG, MockRocksDbConfigSetter.class);
-        rocksDBStore = new RocksDBStore("test");
+        rocksDBStore = getRocksDBStore();
         dir = TestUtils.tempDirectory();
         context = new InternalMockProcessorContext(dir,
             Serdes.String(),
@@ -77,6 +80,10 @@ public class RocksDBStoreTest {
             new StreamsConfig(props));
     }
 
+    RocksDBStore getRocksDBStore() {
+        return new RocksDBStore(DB_NAME);
+    }
+
     @After
     public void tearDown() {
         rocksDBStore.close();
@@ -98,7 +105,8 @@ public class RocksDBStoreTest {
 
         assertThat(rocksDBStore.getOptions().level0FileNumCompactionTrigger(), equalTo(10));
         assertThat(rocksDBStore.getOptions().level0SlowdownWritesTrigger(), equalTo(20));
-        assertThat(rocksDBStore.getOptions().level0StopWritesTrigger(), equalTo(36));    }
+        assertThat(rocksDBStore.getOptions().level0StopWritesTrigger(), equalTo(36));
+    }
 
     @Test
     public void shouldNotThrowExceptionOnRestoreWhenThereIsPreExistingRocksDbFiles() {
@@ -117,7 +125,7 @@ public class RocksDBStoreTest {
         final byte[] restoredValue = "restoredValue".getBytes(UTF_8);
         restoreBytes.add(KeyValue.pair(restoredKey, restoredValue));
 
-        context.restore("test", restoreBytes);
+        context.restore(DB_NAME, restoreBytes);
 
         assertThat(
             stringDeserializer.deserialize(
@@ -168,20 +176,20 @@ public class RocksDBStoreTest {
         rocksDBStore.flush();
 
         assertEquals(
+            "a",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))),
-            "a");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))));
         assertEquals(
+            "b",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))),
-            "b");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))));
         assertEquals(
+            "c",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))),
-            "c");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))));
     }
 
     @Test
@@ -222,20 +230,20 @@ public class RocksDBStoreTest {
         context.restore(rocksDBStore.name(), entries);
 
         assertEquals(
+            "a",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))),
-            "a");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))));
         assertEquals(
+            "b",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))),
-            "b");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))));
         assertEquals(
+            "c",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))),
-            "c");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))));
     }
 
     @Test
@@ -249,7 +257,7 @@ public class RocksDBStoreTest {
         rocksDBStore.putIfAbsent(keyBytes, valueBytesUpdate);
 
         final String retrievedValue = stringDeserializer.deserialize(null, rocksDBStore.get(keyBytes));
-        assertEquals(retrievedValue, "A");
+        assertEquals("A", retrievedValue);
     }
 
     @Test
@@ -294,20 +302,20 @@ public class RocksDBStoreTest {
         assertThat(keys, equalTo(Utils.mkSet("1", "2", "3")));
 
         assertEquals(
+            "restored",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))),
-            "restored");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))));
         assertEquals(
+            "b",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))),
-            "b");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))));
         assertEquals(
+            "c",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))),
-            "c");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))));
     }
 
     @Test
@@ -319,20 +327,20 @@ public class RocksDBStoreTest {
         context.restore(rocksDBStore.name(), entries);
 
         assertEquals(
+            "a",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))),
-            "a");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "1")))));
         assertEquals(
+            "b",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))),
-            "b");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "2")))));
         assertEquals(
+            "c",
             stringDeserializer.deserialize(
                 null,
-                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))),
-            "c");
+                rocksDBStore.get(new Bytes(stringSerializer.serialize(null, "3")))));
 
         entries.clear();
 
@@ -352,8 +360,6 @@ public class RocksDBStoreTest {
         assertThat(keys, equalTo(Utils.mkSet("2", "3")));
     }
 
-
-
     @Test
     public void shouldThrowNullPointerExceptionOnNullPut() {
         rocksDBStore.init(context, rocksDBStore);
@@ -424,13 +430,14 @@ public class RocksDBStoreTest {
 
         final Properties props = StreamsTestUtils.getStreamsConfig();
         props.put(StreamsConfig.ROCKSDB_CONFIG_SETTER_CLASS_CONFIG, TestingBloomFilterRocksDBConfigSetter.class);
-        rocksDBStore = new RocksDBStore("test");
+        rocksDBStore = getRocksDBStore();
         dir = TestUtils.tempDirectory();
         context = new InternalMockProcessorContext(dir,
             Serdes.String(),
             Serdes.String(),
             new StreamsConfig(props));
 
+        enableBloomFilters = false;
         rocksDBStore.init(context, rocksDBStore);
 
         final List<String> expectedValues = new ArrayList<>();
@@ -451,11 +458,11 @@ public class RocksDBStoreTest {
         assertFalse(TestingBloomFilterRocksDBConfigSetter.bloomFiltersSet);
 
         rocksDBStore.close();
-        enableBloomFilters = true;
         expectedIndex = 0;
 
         // reopen with Bloom Filters enabled
         // should open fine without errors
+        enableBloomFilters = true;
         rocksDBStore.init(context, rocksDBStore);
 
         for (final KeyValue<byte[], byte[]> keyValue : keyValues) {
@@ -479,7 +486,7 @@ public class RocksDBStoreTest {
 
     public static class TestingBloomFilterRocksDBConfigSetter implements RocksDBConfigSetter {
 
-        static boolean bloomFiltersSet = false;
+        static boolean bloomFiltersSet;
 
         @Override
         public void setConfig(final String storeName, final Options options, final Map<String, Object> configs) {
@@ -493,10 +500,10 @@ public class RocksDBStoreTest {
                 bloomFiltersSet = true;
             } else {
                 options.setOptimizeFiltersForHits(false);
+                bloomFiltersSet = false;
             }
 
             options.setTableFormatConfig(tableConfig);
-
         }
     }
 
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBTimestampedStoreTest.java b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBTimestampedStoreTest.java
new file mode 100644
index 0000000..3347d02
--- /dev/null
+++ b/streams/src/test/java/org/apache/kafka/streams/state/internals/RocksDBTimestampedStoreTest.java
@@ -0,0 +1,293 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.streams.state.internals;
+
+import org.apache.kafka.common.utils.Bytes;
+import org.apache.kafka.streams.KeyValue;
+import org.apache.kafka.streams.processor.internals.testutil.LogCaptureAppender;
+import org.apache.kafka.streams.state.KeyValueIterator;
+import org.hamcrest.core.IsNull;
+import org.junit.Test;
+import org.rocksdb.ColumnFamilyDescriptor;
+import org.rocksdb.ColumnFamilyHandle;
+import org.rocksdb.ColumnFamilyOptions;
+import org.rocksdb.DBOptions;
+import org.rocksdb.RocksDB;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+
+public class RocksDBTimestampedStoreTest extends RocksDBStoreTest {
+
+    RocksDBStore getRocksDBStore() {
+        return new RocksDBTimestampedStore(DB_NAME);
+    }
+
+    @Test
+    public void shouldMigrateDataFromDefaultToTimestampColumnFamily() throws Exception {
+        prepareOldStore();
+
+        LogCaptureAppender.setClassLoggerToDebug(RocksDBTimestampedStore.class);
+
+        final LogCaptureAppender appender = LogCaptureAppender.createAndRegister();
+        rocksDBStore.init(context, rocksDBStore);
+        assertThat(appender.getMessages(), hasItem("Opening store " + DB_NAME + " in upgrade mode"));
+        LogCaptureAppender.unregister(appender);
+
+        // approx: 7 entries on old CF, 0 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(7L));
+
+        // get()
+
+        // should be no-op on both CF
+        assertThat(rocksDBStore.get(new Bytes("unknown".getBytes())), new IsNull<>());
+        // approx: 7 entries on old CF, 0 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(7L));
+
+        // should migrate key1 from old to new CF
+        // must return timestamp plus value, ie, it's not 1 byte but 9 bytes
+        assertThat(rocksDBStore.get(new Bytes("key1".getBytes())).length, is(8 + 1));
+        // one delete on old CF, one put on new CF
+        // approx: 6 entries on old CF, 1 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(7L));
+
+        // put()
+
+        // should migrate key2 from old to new CF with new value
+        rocksDBStore.put(new Bytes("key2".getBytes()), "timestamp+22".getBytes());
+        // one delete on old CF, one put on new CF
+        // approx: 5 entries on old CF, 2 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(7L));
+
+        // should delete key3 from old and new CF
+        rocksDBStore.put(new Bytes("key3".getBytes()), null);
+        // count is off by one, due to two delete operations (even if one does not delete anything)
+        // approx: 4 entries on old CF, 1 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(5L));
+
+        // should add new key8 to new CF
+        rocksDBStore.put(new Bytes("key8".getBytes()), "timestamp+88888888".getBytes());
+        // one delete on old CF, one put on new CF
+        // approx: 3 entries on old CF, 2 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(5L));
+
+        // putIfAbsent()
+
+        // should migrate key4 from old to new CF with old value
+        assertThat(rocksDBStore.putIfAbsent(new Bytes("key4".getBytes()), "timestamp+4444".getBytes()).length, is(8 + 4));
+        // one delete on old CF, one put on new CF
+        // approx: 2 entries on old CF, 3 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(5L));
+
+        // should add new key11 to new CF
+        assertThat(rocksDBStore.putIfAbsent(new Bytes("key11".getBytes()), "timestamp+11111111111".getBytes()), new IsNull<>());
+        // one delete on old CF, one put on new CF
+        // approx: 1 entries on old CF, 4 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(5L));
+
+        // should not delete key5 but migrate to new CF
+        assertThat(rocksDBStore.putIfAbsent(new Bytes("key5".getBytes()), null).length, is(8 + 5));
+        // one delete on old CF, one put on new CF
+        // approx: 0 entries on old CF, 5 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(5L));
+
+        // should be no-op on both CF
+        assertThat(rocksDBStore.putIfAbsent(new Bytes("key12".getBytes()), null), new IsNull<>());
+        // two delete operation, however, only one is counted because old CF count was zero before already
+        // approx: 0 entries on old CF, 4 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(4L));
+
+        // delete()
+
+        // should delete key6 from old and new CF
+        assertThat(rocksDBStore.delete(new Bytes("key6".getBytes())).length, is(8 + 6));
+        // two delete operation, however, only one is counted because old CF count was zero before already
+        // approx: 0 entries on old CF, 3 in new CF
+        assertThat(rocksDBStore.approximateNumEntries(), is(3L));
+
+
+        iteratorsShouldNotMigrateData();
+        assertThat(rocksDBStore.approximateNumEntries(), is(3L));
+
+        rocksDBStore.close();
+
+        verifyOldAndNewColumnFamily();
+    }
+
+    private void iteratorsShouldNotMigrateData() {
+        // iterating should not migrate any data, but return all key over both CF (plus surrogate timestamps for old CF)
+        final KeyValueIterator<Bytes, byte[]> itAll = rocksDBStore.all();
+        {
+            final KeyValue<Bytes, byte[]> keyValue = itAll.next();
+            assertArrayEquals("key1".getBytes(), keyValue.key.get());
+            // unknown timestamp == -1 plus value == 1
+            assertArrayEquals(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, '1'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = itAll.next();
+            assertArrayEquals("key11".getBytes(), keyValue.key.get());
+            assertArrayEquals(new byte[]{'t', 'i', 'm', 'e', 's', 't', 'a', 'm', 'p', '+', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = itAll.next();
+            assertArrayEquals("key2".getBytes(), keyValue.key.get());
+            assertArrayEquals(new byte[]{'t', 'i', 'm', 'e', 's', 't', 'a', 'm', 'p', '+', '2', '2'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = itAll.next();
+            assertArrayEquals("key4".getBytes(), keyValue.key.get());
+            // unknown timestamp == -1 plus value == 4444
+            assertArrayEquals(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, '4', '4', '4', '4'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = itAll.next();
+            assertArrayEquals("key5".getBytes(), keyValue.key.get());
+            // unknown timestamp == -1 plus value == 55555
+            assertArrayEquals(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, '5', '5', '5', '5', '5'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = itAll.next();
+            assertArrayEquals("key7".getBytes(), keyValue.key.get());
+            // unknown timestamp == -1 plus value == 7777777
+            assertArrayEquals(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, '7', '7', '7', '7', '7', '7', '7'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = itAll.next();
+            assertArrayEquals("key8".getBytes(), keyValue.key.get());
+            assertArrayEquals(new byte[]{'t', 'i', 'm', 'e', 's', 't', 'a', 'm', 'p', '+', '8', '8', '8', '8', '8', '8', '8', '8'}, keyValue.value);
+        }
+        assertFalse(itAll.hasNext());
+        itAll.close();
+
+        final KeyValueIterator<Bytes, byte[]> it =
+            rocksDBStore.range(new Bytes("key2".getBytes()), new Bytes("key5".getBytes()));
+        {
+            final KeyValue<Bytes, byte[]> keyValue = it.next();
+            assertArrayEquals("key2".getBytes(), keyValue.key.get());
+            assertArrayEquals(new byte[]{'t', 'i', 'm', 'e', 's', 't', 'a', 'm', 'p', '+', '2', '2'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = it.next();
+            assertArrayEquals("key4".getBytes(), keyValue.key.get());
+            // unknown timestamp == -1 plus value == 4444
+            assertArrayEquals(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, '4', '4', '4', '4'}, keyValue.value);
+        }
+        {
+            final KeyValue<Bytes, byte[]> keyValue = it.next();
+            assertArrayEquals("key5".getBytes(), keyValue.key.get());
+            // unknown timestamp == -1 plus value == 55555
+            assertArrayEquals(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, '5', '5', '5', '5', '5'}, keyValue.value);
+        }
+        assertFalse(it.hasNext());
+        it.close();
+    }
+
+    private void verifyOldAndNewColumnFamily() throws Exception {
+        final DBOptions dbOptions = new DBOptions();
+        final ColumnFamilyOptions columnFamilyOptions = new ColumnFamilyOptions();
+
+        final List<ColumnFamilyDescriptor> columnFamilyDescriptors = asList(
+            new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY, columnFamilyOptions),
+            new ColumnFamilyDescriptor("keyValueWithTimestamp".getBytes(StandardCharsets.UTF_8), columnFamilyOptions));
+        final List<ColumnFamilyHandle> columnFamilies = new ArrayList<>(columnFamilyDescriptors.size());
+
+        RocksDB db = RocksDB.open(
+            dbOptions,
+            new File(new File(context.stateDir(), "rocksdb"), DB_NAME).getAbsolutePath(),
+            columnFamilyDescriptors,
+            columnFamilies);
+
+        ColumnFamilyHandle noTimestampColumnFamily = columnFamilies.get(0);
+        final ColumnFamilyHandle withTimestampColumnFamily = columnFamilies.get(1);
+
+        assertThat(db.get(noTimestampColumnFamily, "unknown".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key1".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key2".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key3".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key4".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key5".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key6".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key7".getBytes()).length, is(7));
+        assertThat(db.get(noTimestampColumnFamily, "key8".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key11".getBytes()), new IsNull<>());
+        assertThat(db.get(noTimestampColumnFamily, "key12".getBytes()), new IsNull<>());
+
+        assertThat(db.get(withTimestampColumnFamily, "unknown".getBytes()), new IsNull<>());
+        assertThat(db.get(withTimestampColumnFamily, "key1".getBytes()).length, is(8 + 1));
+        assertThat(db.get(withTimestampColumnFamily, "key2".getBytes()).length, is(12));
+        assertThat(db.get(withTimestampColumnFamily, "key3".getBytes()), new IsNull<>());
+        assertThat(db.get(withTimestampColumnFamily, "key4".getBytes()).length, is(8 + 4));
+        assertThat(db.get(withTimestampColumnFamily, "key5".getBytes()).length, is(8 + 5));
+        assertThat(db.get(withTimestampColumnFamily, "key6".getBytes()), new IsNull<>());
+        assertThat(db.get(withTimestampColumnFamily, "key7".getBytes()), new IsNull<>());
+        assertThat(db.get(withTimestampColumnFamily, "key8".getBytes()).length, is(18));
+        assertThat(db.get(withTimestampColumnFamily, "key11".getBytes()).length, is(21));
+        assertThat(db.get(withTimestampColumnFamily, "key12".getBytes()), new IsNull<>());
+
+        db.close();
+
+        // check that still in upgrade mode
+        LogCaptureAppender appender = LogCaptureAppender.createAndRegister();
+        rocksDBStore.init(context, rocksDBStore);
+        assertThat(appender.getMessages(), hasItem("Opening store " + DB_NAME + " in upgrade mode"));
+        LogCaptureAppender.unregister(appender);
+        rocksDBStore.close();
+
+        // clear old CF
+        columnFamilies.clear();
+        db = RocksDB.open(
+            dbOptions,
+            new File(new File(context.stateDir(), "rocksdb"), DB_NAME).getAbsolutePath(),
+            columnFamilyDescriptors,
+            columnFamilies);
+
+        noTimestampColumnFamily = columnFamilies.get(0);
+        db.delete(noTimestampColumnFamily, "key7".getBytes());
+        db.close();
+
+        // check that still in regular mode
+        appender = LogCaptureAppender.createAndRegister();
+        rocksDBStore.init(context, rocksDBStore);
+        assertThat(appender.getMessages(), hasItem("Opening store " + DB_NAME + " in regular mode"));
+        LogCaptureAppender.unregister(appender);
+    }
+
+    private void prepareOldStore() {
+        final RocksDBStore keyValueStore = new RocksDBStore(DB_NAME);
+        keyValueStore.init(context, keyValueStore);
+
+        keyValueStore.put(new Bytes("key1".getBytes()), "1".getBytes());
+        keyValueStore.put(new Bytes("key2".getBytes()), "22".getBytes());
+        keyValueStore.put(new Bytes("key3".getBytes()), "333".getBytes());
+        keyValueStore.put(new Bytes("key4".getBytes()), "4444".getBytes());
+        keyValueStore.put(new Bytes("key5".getBytes()), "55555".getBytes());
+        keyValueStore.put(new Bytes("key6".getBytes()), "666666".getBytes());
+        keyValueStore.put(new Bytes("key7".getBytes()), "7777777".getBytes());
+
+        keyValueStore.close();
+    }
+
+}