Home | History | Annotate | Download | only in table 
      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   uint64_t offset() const { return offset_; }
     28   void set_offset(uint64_t offset) { offset_ = offset; }
     29 
     30   // The size of the stored block
     31   uint64_t size() const { return size_; }
     32   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   Footer() { }
     50 
     51   // The block handle for the metaindex block of the table
     52   const BlockHandle& metaindex_handle() const { return metaindex_handle_; }
     53   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   void set_index_handle(const BlockHandle& h) {
     60     index_handle_ = h;
     61   }
     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 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 inline BlockHandle::BlockHandle()
    102     : offset_(~static_cast<uint64_t>(0)),
    103       size_(~static_cast<uint64_t>(0)) {
    104 }
    105 
    106 }  // namespace leveldb
    107 
    108 #endif  // STORAGE_LEVELDB_TABLE_FORMAT_H_
    109