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