clog.h

浏览该文件的文档.

/* Copyright (c) 2021-2022 OceanBase and/or its affiliates. All rights reserved.
miniob is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details. */
 
//
// Created by huhaosheng.hhs on 2022
//
 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
#include <list>
#include <atomic>
#include <unordered_map>
#include <deque>
#include <memory>
#include <string>
 
#include "storage/record/record.h"
#include "storage/persist/persist.h"
#include "common/lang/mutex.h"
 
class CLogManager;
class CLogBuffer;
class CLogFile;
class Db;
 
#define DEFINE_CLOG_TYPE_ENUM         \
  DEFINE_CLOG_TYPE(ERROR)             \
  DEFINE_CLOG_TYPE(MTR_BEGIN)         \
  DEFINE_CLOG_TYPE(MTR_COMMIT)        \
  DEFINE_CLOG_TYPE(MTR_ROLLBACK)      \
  DEFINE_CLOG_TYPE(INSERT)            \
  DEFINE_CLOG_TYPE(DELETE)
 
enum class CLogType 
{ 
#define DEFINE_CLOG_TYPE(name) name,
  DEFINE_CLOG_TYPE_ENUM
#undef DEFINE_CLOG_TYPE
};
 
const char *clog_type_name(CLogType type);
 
int32_t clog_type_to_integer(CLogType type);
 
CLogType clog_type_from_integer(int32_t value);
 
struct CLogRecordHeader 
{
  int32_t lsn_ = -1;     
  int32_t trx_id_ = -1;  
  int32_t type_ = clog_type_to_integer(CLogType::ERROR); 
  int32_t logrec_len_ = 0;  
 
  bool operator==(const CLogRecordHeader &other) const
  {
    return lsn_ == other.lsn_ && trx_id_ == other.trx_id_ && type_ == other.type_ && logrec_len_ == other.logrec_len_;
  }
 
  std::string to_string() const;
};
 
struct CLogRecordCommitData
{
  int32_t commit_xid_ = -1; 
 
  bool operator == (const CLogRecordCommitData &other) const
  {
    return this->commit_xid_ == other.commit_xid_;
  }
 
  std::string to_string() const;
};
 
struct CLogRecordData
{
  int32_t          table_id_ = -1;    
  RID              rid_;              
  int32_t          data_len_ = 0;     
  int32_t          data_offset_ = 0;  
  char *           data_ = nullptr;   
 
  ~CLogRecordData();
 
  bool operator==(const CLogRecordData &other) const
  {
    return table_id_ == other.table_id_ &&
      rid_ == other.rid_ &&
      data_len_ == other.data_len_ &&
      data_offset_ == other.data_offset_ &&
      0 == memcmp(data_, other.data_, data_len_);
  }
 
  std::string to_string() const;
 
  const static int32_t HEADER_SIZE;  
};
 
class CLogRecord 
{
public:
  CLogRecord() = default;
 
  ~CLogRecord();
 
  static CLogRecord *build_mtr_record(CLogType type, int32_t trx_id);
 
  static CLogRecord *build_commit_record(int32_t trx_id, int32_t commit_xid);
 
  static CLogRecord *build_data_record(CLogType type,
                                       int32_t trx_id,
                                       int32_t table_id,
                                       const RID &rid,
                                       int32_t data_len,
                                       int32_t data_offset,
                                       const char *data);
  
  static CLogRecord *build(const CLogRecordHeader &header, char *data);
 
  CLogType log_type() const  { return clog_type_from_integer(header_.type_); }
  int32_t  trx_id() const { return header_.trx_id_; }
  int32_t  logrec_len() const { return header_.logrec_len_; }
 
  CLogRecordHeader &header() { return header_; }
  CLogRecordCommitData &commit_record() { return commit_record_; }
  CLogRecordData   &data_record() { return data_record_; }
 
  const CLogRecordHeader &header() const { return header_; }
  const CLogRecordCommitData &commit_record() const { return commit_record_; }
  const CLogRecordData   &data_record() const { return data_record_; }
 
  std::string to_string() const;
 
protected:
  CLogRecordHeader header_; 
 
  CLogRecordData       data_record_;   
  CLogRecordCommitData commit_record_; 
};
 
class CLogBuffer 
{
public:
  CLogBuffer();
  ~CLogBuffer();
 
  RC append_log_record(CLogRecord *log_record);
 
  RC flush_buffer(CLogFile &log_file);
 
private:
  RC write_log_record(CLogFile &log_file, CLogRecord *log_record);
 
private:
  common::Mutex lock_;  
  std::deque<std::unique_ptr<CLogRecord>> log_records_;  
  std::atomic_int32_t total_size_;  
};
 
class CLogFile 
{
public:
  CLogFile() = default;
  ~CLogFile();
 
  RC init(const char *path);
 
  RC write(const char *data, int len);
 
  RC read(char *data, int len);
 
  RC sync();
 
  RC offset(int64_t &off) const;
 
  bool eof() const { return eof_; }
 
protected:
  std::string filename_;  
  int fd_ = -1;           
  bool eof_ = false;      
};
 
class CLogRecordIterator
{
public:
  CLogRecordIterator() = default;
  ~CLogRecordIterator() = default;
 
  RC init(CLogFile &log_file);
 
  bool valid() const;
  RC next();
  const CLogRecord &log_record();
 
private:
  CLogFile *log_file_ = nullptr;
  CLogRecord *log_record_ = nullptr;
};
 
class CLogManager 
{
public:
  CLogManager() = default;
  ~CLogManager();
 
  RC init(const char *path);
 
  RC append_log(CLogType type,
                int32_t trx_id,
                int32_t table_id,
                const RID &rid,
                int32_t data_len,
                int32_t data_offset,
                const char *data);
 
  RC begin_trx(int32_t trx_id);
 
  RC commit_trx(int32_t trx_id, int32_t commit_xid);
 
  RC rollback_trx(int32_t trx_id);
 
  RC append_log(CLogRecord *log_record);
 
  RC sync();
 
  RC recover(Db *db);
 
private:
  CLogBuffer *log_buffer_ = nullptr;   
  CLogFile *  log_file_   = nullptr;   
};