Line data    Source code

       1             : // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file. See the AUTHORS file for names of contributors.
       4             : 
       5             : #ifndef STORAGE_LEVELDB_TABLE_FORMAT_H_
       6             : #define STORAGE_LEVELDB_TABLE_FORMAT_H_
       7             : 
       8             : #include <string>
       9             : #include <stdint.h>
      10             : #include "leveldb/slice.h"
      11             : #include "leveldb/status.h"
      12             : #include "leveldb/table_builder.h"
      13             : 
      14             : namespace leveldb {
      15             : 
      16             : class Block;
      17             : class RandomAccessFile;
      18             : struct ReadOptions;
      19             : 
      20             : // BlockHandle is a pointer to the extent of a file that stores a data
      21             : // block or a meta block.
      22             : class BlockHandle {
      23             :  public:
      24             :   BlockHandle();
      25             : 
      26             :   // The offset of the block in the file.
      27           0 :   uint64_t offset() const { return offset_; }
      28         883 :   void set_offset(uint64_t offset) { offset_ = offset; }
      29             : 
      30             :   // The size of the stored block
      31           0 :   uint64_t size() const { return size_; }
      32         883 :   void set_size(uint64_t size) { size_ = size; }
      33             : 
      34             :   void EncodeTo(std::string* dst) const;
      35             :   Status DecodeFrom(Slice* input);
      36             : 
      37             :   // Maximum encoding length of a BlockHandle
      38             :   enum { kMaxEncodedLength = 10 + 10 };
      39             : 
      40             :  private:
      41             :   uint64_t offset_;
      42             :   uint64_t size_;
      43             : };
      44             : 
      45             : // Footer encapsulates the fixed information stored at the tail
      46             : // end of every table file.
      47             : class Footer {
      48             :  public:
      49         564 :   Footer() { }
      50             : 
      51             :   // The block handle for the metaindex block of the table
      52         160 :   const BlockHandle& metaindex_handle() const { return metaindex_handle_; }
      53         122 :   void set_metaindex_handle(const BlockHandle& h) { metaindex_handle_ = h; }
      54             : 
      55             :   // The block handle for the index block of the table
      56             :   const BlockHandle& index_handle() const {
      57             :     return index_handle_;
      58             :   }
      59           0 :   void set_index_handle(const BlockHandle& h) {
      60         122 :     index_handle_ = h;
      61           0 :   }
      62             : 
      63             :   void EncodeTo(std::string* dst) const;
      64             :   Status DecodeFrom(Slice* input);
      65             : 
      66             :   // Encoded length of a Footer.  Note that the serialization of a
      67             :   // Footer will always occupy exactly this many bytes.  It consists
      68             :   // of two block handles and a magic number.
      69             :   enum {
      70             :     kEncodedLength = 2*BlockHandle::kMaxEncodedLength + 8
      71             :   };
      72             : 
      73             :  private:
      74             :   BlockHandle metaindex_handle_;
      75             :   BlockHandle index_handle_;
      76             : };
      77             : 
      78             : // kTableMagicNumber was picked by running
      79             : //    echo http://code.google.com/p/leveldb/ | sha1sum
      80             : // and taking the leading 64 bits.
      81             : static const uint64_t kTableMagicNumber = 0xdb4775248b80fb57ull;
      82             : 
      83             : // 1-byte type + 32-bit crc
      84             : static const size_t kBlockTrailerSize = 5;
      85             : 
      86       12896 : struct BlockContents {
      87             :   Slice data;           // Actual contents of data
      88             :   bool cachable;        // True iff data can be cached
      89             :   bool heap_allocated;  // True iff caller should delete[] data.data()
      90             : };
      91             : 
      92             : // Read the block identified by "handle" from "file".  On failure
      93             : // return non-OK.  On success fill *result and return OK.
      94             : extern Status ReadBlock(RandomAccessFile* file,
      95             :                         const ReadOptions& options,
      96             :                         const BlockHandle& handle,
      97             :                         BlockContents* result);
      98             : 
      99             : // Implementation details follow.  Clients should ignore,
     100             : 
     101           0 : inline BlockHandle::BlockHandle()
     102             :     : offset_(~static_cast<uint64_t>(0)),
     103       30434 :       size_(~static_cast<uint64_t>(0)) {
     104           0 : }
     105             : 
     106             : }  // namespace leveldb
     107             : 
     108             : #endif  // STORAGE_LEVELDB_TABLE_FORMAT_H_