leveldb::TableBuilder Class Reference

#include <table_builder.h>

Collaboration diagram for leveldb::TableBuilder:

Classes
struct	Rep

Public Member Functions
	TableBuilder (const Options &options, WritableFile *file)
	~TableBuilder ()
Status	ChangeOptions (const Options &options)
void	Add (const Slice &key, const Slice &value)
void	Flush ()
Status	status () const
Status	Finish ()
void	Abandon ()
uint64_t	NumEntries () const
uint64_t	FileSize () const

Private Member Functions
bool	ok () const
void	WriteBlock (BlockBuilder *block, BlockHandle *handle)
void	WriteRawBlock (const Slice &data, CompressionType, BlockHandle *handle)
	TableBuilder (const TableBuilder &)
void	operator= (const TableBuilder &)

Private Attributes
Rep *	rep_

Detailed Description

Definition at line 26 of file table_builder.h.

Constructor & Destructor Documentation

TableBuilder() [1/2]

leveldb::TableBuilder::TableBuilder	(	const Options &	options,
		WritableFile *	file
	)

Definition at line 63 of file table_builder.cc.

    : rep_(new Rep(options, file)) {
  if (rep_->filter_block != NULL) {
    rep_->filter_block->StartBlock(0);
  }
}

Here is the call graph for this function:

~TableBuilder()

leveldb::TableBuilder::~TableBuilder

(

)

Definition at line 70 of file table_builder.cc.

                            {
  assert(rep_->closed);  // Catch errors where caller forgot to call Finish()
  delete rep_->filter_block;
  delete rep_;
}

TableBuilder() [2/2]

leveldb::TableBuilder::TableBuilder ( const TableBuilder &  )

private

Member Function Documentation

Abandon()

void leveldb::TableBuilder::Abandon

(

)

Definition at line 256 of file table_builder.cc.

                           {
  Rep* r = rep_;
  assert(!r->closed);
  r->closed = true;
}

Here is the caller graph for this function:

Add()

void leveldb::TableBuilder::Add	(	const Slice &	key,
		const Slice &	value
	)

Definition at line 92 of file table_builder.cc.

                                                           {
  Rep* r = rep_;
  assert(!r->closed);
  if (!ok()) return;
  if (r->num_entries > 0) {
    assert(r->options.comparator->Compare(key, Slice(r->last_key)) > 0);
  }

  if (r->pending_index_entry) {
    assert(r->data_block.empty());
    r->options.comparator->FindShortestSeparator(&r->last_key, key);
    std::string handle_encoding;
    r->pending_handle.EncodeTo(&handle_encoding);
    r->index_block.Add(r->last_key, Slice(handle_encoding));
    r->pending_index_entry = false;
  }

  if (r->filter_block != NULL) {
    r->filter_block->AddKey(key);
  }

  r->last_key.assign(key.data(), key.size());
  r->num_entries++;
  r->data_block.Add(key, value);

  const size_t estimated_block_size = r->data_block.CurrentSizeEstimate();
  if (estimated_block_size >= r->options.block_size) {
    Flush();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ChangeOptions()

Status leveldb::TableBuilder::ChangeOptions

(

const Options &

options

)

Definition at line 76 of file table_builder.cc.

                                                         {
  // Note: if more fields are added to Options, update
  // this function to catch changes that should not be allowed to
  // change in the middle of building a Table.
  if (options.comparator != rep_->options.comparator) {
    return Status::InvalidArgument("changing comparator while building table");
  }

  // Note that any live BlockBuilders point to rep_->options and therefore
  // will automatically pick up the updated options.
  rep_->options = options;
  rep_->index_block_options = options;
  rep_->index_block_options.block_restart_interval = 1;
  return Status::OK();
}

Here is the call graph for this function:

FileSize()

uint64_t leveldb::TableBuilder::FileSize

(

)

const

Definition at line 266 of file table_builder.cc.

                                      {
  return rep_->offset;
}

Here is the caller graph for this function:

Finish()

Status leveldb::TableBuilder::Finish

(

)

Definition at line 199 of file table_builder.cc.

                            {
  Rep* r = rep_;
  Flush();
  assert(!r->closed);
  r->closed = true;

  BlockHandle filter_block_handle, metaindex_block_handle, index_block_handle;

  // Write filter block
  if (ok() && r->filter_block != NULL) {
    WriteRawBlock(r->filter_block->Finish(), kNoCompression,
                  &filter_block_handle);
  }

  // Write metaindex block
  if (ok()) {
    BlockBuilder meta_index_block(&r->options);
    if (r->filter_block != NULL) {
      // Add mapping from "filter.Name" to location of filter data
      std::string key = "filter.";
      key.append(r->options.filter_policy->Name());
      std::string handle_encoding;
      filter_block_handle.EncodeTo(&handle_encoding);
      meta_index_block.Add(key, handle_encoding);
    }

    // TODO(postrelease): Add stats and other meta blocks
    WriteBlock(&meta_index_block, &metaindex_block_handle);
  }

  // Write index block
  if (ok()) {
    if (r->pending_index_entry) {
      r->options.comparator->FindShortSuccessor(&r->last_key);
      std::string handle_encoding;
      r->pending_handle.EncodeTo(&handle_encoding);
      r->index_block.Add(r->last_key, Slice(handle_encoding));
      r->pending_index_entry = false;
    }
    WriteBlock(&r->index_block, &index_block_handle);
  }

  // Write footer
  if (ok()) {
    Footer footer;
    footer.set_metaindex_handle(metaindex_block_handle);
    footer.set_index_handle(index_block_handle);
    std::string footer_encoding;
    footer.EncodeTo(&footer_encoding);
    r->status = r->file->Append(footer_encoding);
    if (r->status.ok()) {
      r->offset += footer_encoding.size();
    }
  }
  return r->status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Flush()

void leveldb::TableBuilder::Flush

(

)

Definition at line 123 of file table_builder.cc.

                         {
  Rep* r = rep_;
  assert(!r->closed);
  if (!ok()) return;
  if (r->data_block.empty()) return;
  assert(!r->pending_index_entry);
  WriteBlock(&r->data_block, &r->pending_handle);
  if (ok()) {
    r->pending_index_entry = true;
    r->status = r->file->Flush();
  }
  if (r->filter_block != NULL) {
    r->filter_block->StartBlock(r->offset);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

NumEntries()

uint64_t leveldb::TableBuilder::NumEntries

(

)

const

Definition at line 262 of file table_builder.cc.

                                        {
  return rep_->num_entries;
}

Here is the caller graph for this function:

ok()

bool leveldb::TableBuilder::ok ( ) const

inlineprivate

Definition at line 78 of file table_builder.h.

{ return status().ok(); }

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

void leveldb::TableBuilder::operator= ( const TableBuilder &  )

private

status()

Status leveldb::TableBuilder::status

(

)

const

Definition at line 195 of file table_builder.cc.

                                  {
  return rep_->status;
}

Here is the caller graph for this function:

WriteBlock()

void leveldb::TableBuilder::WriteBlock ( BlockBuilder *  block, BlockHandle *  handle  )

private

Definition at line 139 of file table_builder.cc.

                                                                      {
  // File format contains a sequence of blocks where each block has:
  //    block_data: uint8[n]
  //    type: uint8
  //    crc: uint32
  assert(ok());
  Rep* r = rep_;
  Slice raw = block->Finish();

  Slice block_contents;
  CompressionType type = r->options.compression;
  // TODO(postrelease): Support more compression options: zlib?
  switch (type) {
    case kNoCompression:
      block_contents = raw;
      break;

    case kSnappyCompression: {
      std::string* compressed = &r->compressed_output;
      if (port::Snappy_Compress(raw.data(), raw.size(), compressed) &&
          compressed->size() < raw.size() - (raw.size() / 8u)) {
        block_contents = *compressed;
      } else {
        // Snappy not supported, or compressed less than 12.5%, so just
        // store uncompressed form
        block_contents = raw;
        type = kNoCompression;
      }
      break;
    }
  }
  WriteRawBlock(block_contents, type, handle);
  r->compressed_output.clear();
  block->Reset();
}

Here is the call graph for this function:

Here is the caller graph for this function:

WriteRawBlock()

void leveldb::TableBuilder::WriteRawBlock ( const Slice &  data, CompressionType  type, BlockHandle *  handle  )

private

Definition at line 175 of file table_builder.cc.

                                                      {
  Rep* r = rep_;
  handle->set_offset(r->offset);
  handle->set_size(block_contents.size());
  r->status = r->file->Append(block_contents);
  if (r->status.ok()) {
    char trailer[kBlockTrailerSize];
    trailer[0] = type;
    uint32_t crc = crc32c::Value(block_contents.data(), block_contents.size());
    crc = crc32c::Extend(crc, trailer, 1);  // Extend crc to cover block type
    EncodeFixed32(trailer+1, crc32c::Mask(crc));
    r->status = r->file->Append(Slice(trailer, kBlockTrailerSize));
    if (r->status.ok()) {
      r->offset += block_contents.size() + kBlockTrailerSize;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

rep_

Rep* leveldb::TableBuilder::rep_

private

Definition at line 82 of file table_builder.h.

---

The documentation for this class was generated from the following files:

• include/leveldb/table_builder.h
• table/table_builder.cc