| // Copyright (c) 2011-present, Facebook, Inc. All rights reserved. |
| // This source code is licensed under both the GPLv2 (found in the |
| // COPYING file in the root directory) and Apache 2.0 License |
| // (found in the LICENSE.Apache file in the root directory). |
| |
| #pragma once |
| #ifndef ROCKSDB_LITE |
| |
| #include <map> |
| #include <string> |
| #include <vector> |
| |
| #include "rocksdb/db.h" |
| |
| namespace rocksdb { |
| |
| // Date tiered database is a wrapper of DB that implements |
| // a simplified DateTieredCompactionStrategy by using multiple column famillies |
| // as time windows. |
| // |
| // DateTieredDB provides an interface similar to DB, but it assumes that user |
| // provides keys with last 8 bytes encoded as timestamp in seconds. DateTieredDB |
| // is assigned with a TTL to declare when data should be deleted. |
| // |
| // DateTieredDB hides column families layer from standard RocksDB instance. It |
| // uses multiple column families to manage time series data, each containing a |
| // specific range of time. Column families are named by its maximum possible |
| // timestamp. A column family is created automatically when data newer than |
| // latest timestamp of all existing column families. The time range of a column |
| // family is configurable by `column_family_interval`. By doing this, we |
| // guarantee that compaction will only happen in a column family. |
| // |
| // DateTieredDB is assigned with a TTL. When all data in a column family are |
| // expired (CF_Timestamp <= CUR_Timestamp - TTL), we directly drop the whole |
| // column family. |
| // |
| // TODO(jhli): This is only a simplified version of DTCS. In a complete DTCS, |
| // time windows can be merged over time, so that older time windows will have |
| // larger time range. Also, compaction are executed only for adjacent SST files |
| // to guarantee there is no time overlap between SST files. |
| |
| class DateTieredDB { |
| public: |
| // Open a DateTieredDB whose name is `dbname`. |
| // Similar to DB::Open(), created database object is stored in dbptr. |
| // |
| // Two parameters can be configured: `ttl` to specify the length of time that |
| // keys should exist in the database, and `column_family_interval` to specify |
| // the time range of a column family interval. |
| // |
| // Open a read only database if read only is set as true. |
| // TODO(jhli): Should use an option object that includes ttl and |
| // column_family_interval. |
| static Status Open(const Options& options, const std::string& dbname, |
| DateTieredDB** dbptr, int64_t ttl, |
| int64_t column_family_interval, bool read_only = false); |
| |
| explicit DateTieredDB() {} |
| |
| virtual ~DateTieredDB() {} |
| |
| // Wrapper for Put method. Similar to DB::Put(), but column family to be |
| // inserted is decided by the timestamp in keys, i.e. the last 8 bytes of user |
| // key. If key is already obsolete, it will not be inserted. |
| // |
| // When client put a key value pair in DateTieredDB, it assumes last 8 bytes |
| // of keys are encoded as timestamp. Timestamp is a 64-bit signed integer |
| // encoded as the number of seconds since 1970-01-01 00:00:00 (UTC) (Same as |
| // Env::GetCurrentTime()). Timestamp should be encoded in big endian. |
| virtual Status Put(const WriteOptions& options, const Slice& key, |
| const Slice& val) = 0; |
| |
| // Wrapper for Get method. Similar to DB::Get() but column family is decided |
| // by timestamp in keys. If key is already obsolete, it will not be found. |
| virtual Status Get(const ReadOptions& options, const Slice& key, |
| std::string* value) = 0; |
| |
| // Wrapper for Delete method. Similar to DB::Delete() but column family is |
| // decided by timestamp in keys. If key is already obsolete, return NotFound |
| // status. |
| virtual Status Delete(const WriteOptions& options, const Slice& key) = 0; |
| |
| // Wrapper for KeyMayExist method. Similar to DB::KeyMayExist() but column |
| // family is decided by timestamp in keys. Return false when key is already |
| // obsolete. |
| virtual bool KeyMayExist(const ReadOptions& options, const Slice& key, |
| std::string* value, bool* value_found = nullptr) = 0; |
| |
| // Wrapper for Merge method. Similar to DB::Merge() but column family is |
| // decided by timestamp in keys. |
| virtual Status Merge(const WriteOptions& options, const Slice& key, |
| const Slice& value) = 0; |
| |
| // Create an iterator that hides low level details. This iterator internally |
| // merge results from all active time series column families. Note that |
| // column families are not deleted until all data are obsolete, so this |
| // iterator can possibly access obsolete key value pairs. |
| virtual Iterator* NewIterator(const ReadOptions& opts) = 0; |
| |
| // Explicitly drop column families in which all keys are obsolete. This |
| // process is also inplicitly done in Put() operation. |
| virtual Status DropObsoleteColumnFamilies() = 0; |
| |
| static const uint64_t kTSLength = sizeof(int64_t); // size of timestamp |
| }; |
| |
| } // namespace rocksdb |
| #endif // ROCKSDB_LITE |