transaction.h

Go to the documentation of this file.

/*
 *   Copyright (C) 2020 Nippon Telegraph and Telephone Corporation.
 
 *   Licensed 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.
 */
#ifndef LINEAIRDB_TRANSACTION_H
#define LINEAIRDB_TRANSACTION_H
 
#include <lineairdb/tx_status.h>
 
#include <cstddef>
#include <cstring>
#include <functional>
#include <memory>
#include <optional>
#include <string_view>
#include <type_traits>
 
namespace LineairDB {
 
class Transaction {
 public:
  TxStatus GetCurrentStatus();
  bool IsRunning() { return GetCurrentStatus() == TxStatus::Running; }
  bool IsCommitted() { return GetCurrentStatus() == TxStatus::Aborted; }
  bool IsAborted() { return GetCurrentStatus() == TxStatus::Aborted; }
 
  const std::pair<const std::byte* const, const size_t> Read(
      const std::string_view key);
 
  template <typename T>
  const std::optional<T> Read(const std::string_view key) {
    static_assert(std::is_trivially_copyable<T>::value == true,
                  "LineairDB expects to read/write trivially copyable types.");
    auto result = Read(key);
    if (result.second != 0) {
      const T copy_constructed_result =
          *reinterpret_cast<const T*>(result.first);
      return copy_constructed_result;
    } else {
      return std::nullopt;
    }
  }
 
  void Write(const std::string_view key, const std::byte value[],
             const size_t size);
 
  template <typename T>
  void Write(const std::string_view key, const T& value) {
    static_assert(std::is_trivially_copyable<T>::value == true,
                  "LineairDB expects to read/write trivially copyable types.");
    std::byte buffer[sizeof(T)];
    std::memcpy(buffer, &value, sizeof(T));
    Write(key, buffer, sizeof(T));
  };
 
  const std::optional<size_t> Scan(
      const std::string_view begin, const std::string_view end,
      std::function<bool(std::string_view,
                         const std::pair<const void*, const size_t>)>
          operation);
 
  template <typename T>
  const std::optional<size_t> Scan(
      const std::string_view begin, const std::string_view end,
      std::function<bool(std::string_view, T)> operation) {
    static_assert(std::is_trivially_copyable<T>::value == true,
                  "LineairDB expects to trivially copyable types.");
    return Scan(begin, end, [&](auto key, auto pair) {
      const T copy_constructed = *reinterpret_cast<const T*>(pair.first);
      return operation(key, copy_constructed);
    });
  }
 
  void Abort();
 
 private:
  Transaction(void*) noexcept;
  ~Transaction() noexcept;
  bool Precommit();
 
 private:
  class Impl;
  const std::unique_ptr<Impl> tx_pimpl_;
  friend class Database;
};
 
}  // namespace LineairDB
#endif