key.hpp

Go to the documentation of this file.

#pragma once
 
#include <fcb/error.hpp>
#include <fcb/span.hpp>
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace fcb {
 
enum class KeyKind {
    Int8,
    UInt8,
    Int16,
    UInt16,
    Int32,
    UInt32,
    Int64,
    UInt64,
    Float32,
    Float64,
    Bool,
    DateTime,
    String20,
    String50,
    String100,
};
 
std::size_t key_serialized_size(KeyKind kind);
 
class KeyValue {
  public:
    KeyValue() = default;
 
    static KeyValue from_i8(std::int8_t v);
    static KeyValue from_u8(std::uint8_t v);
    static KeyValue from_i16(std::int16_t v);
    static KeyValue from_u16(std::uint16_t v);
    static KeyValue from_i32(std::int32_t v);
    static KeyValue from_u32(std::uint32_t v);
    static KeyValue from_i64(std::int64_t v);
    static KeyValue from_u64(std::uint64_t v);
    static KeyValue from_f32(float v);
    static KeyValue from_f64(double v);
    static KeyValue from_bool(bool v);
    static KeyValue from_datetime(std::int64_t seconds, std::uint32_t nanos);
    static KeyValue from_string(KeyKind kind, const std::string& v);
 
    KeyKind kind() const { return kind_; }
 
    const std::string& original_string() const { return str_; }
 
  private:
    friend std::vector<std::uint8_t> encode_key(const KeyValue&);
    friend KeyValue decode_key(KeyKind, bytes_view);
    friend int compare_keys(const KeyValue&, const KeyValue&);
 
    KeyKind kind_ = KeyKind::Int32;
    std::int64_t i_ = 0;   // signed integers, and DateTime seconds
    std::uint64_t u_ = 0;  // unsigned integers, bool, and DateTime nanos
    double f_ = 0.0;       // Float32/Float64
    std::string str_;      // fixed-string kinds, untruncated
};
 
std::vector<std::uint8_t> encode_key(const KeyValue& v);
KeyValue decode_key(KeyKind kind, bytes_view b);
 
int compare_keys(const KeyValue& a, const KeyValue& b);
 
KeyValue key_min(KeyKind kind);
KeyValue key_max(KeyKind kind);
 
KeyKind key_kind_for_column(std::uint8_t column_type);
 
}  // namespace fcb