// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include "leveldb/table_builder.h"

#include <assert.h>

#include "leveldb/comparator.h"

#include "leveldb/env.h"

#include "leveldb/filter_policy.h"

#include "leveldb/options.h"

#include "table/block_builder.h"

#include "table/filter_block.h"

#include "table/format.h"

#include "util/coding.h"

#include "util/crc32c.h"

namespace leveldb {

struct TableBuilder::Rep {

  Rep(const Options& opt, WritableFile* f)

      : options(opt),

        index_block_options(opt),

        file(f),

        offset(0),

        data_block(&options),

        index_block(&index_block_options),

        num_entries(0),

        closed(false),

        filter_block(opt.filter_policy == nullptr

  Branch (31:22): [True: 0, False: 24]

                         ? nullptr

                         : new FilterBlockBuilder(opt.filter_policy)),

        pending_index_entry(false) {

    index_block_options.block_restart_interval = 1;

  }

  Options options;

  Options index_block_options;

  WritableFile* file;

  uint64_t offset;

  Status status;

  BlockBuilder data_block;

  BlockBuilder index_block;

  std::string last_key;

  int64_t num_entries;

  bool closed;  // Either Finish() or Abandon() has been called.

  FilterBlockBuilder* filter_block;

  // We do not emit the index entry for a block until we have seen the

  // first key for the next data block.  This allows us to use shorter

  // keys in the index block.  For example, consider a block boundary

  // between the keys "the quick brown fox" and "the who".  We can use

  // "the r" as the key for the index block entry since it is >= all

  // entries in the first block and < all entries in subsequent

  // blocks.

  //

  // Invariant: r->pending_index_entry is true only if data_block is empty.

  bool pending_index_entry;

  BlockHandle pending_handle;  // Handle to add to index block

  std::string compressed_output;

};

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

    : rep_(new Rep(options, file)) {

  if (rep_->filter_block != nullptr) {

  Branch (67:7): [True: 24, False: 0]

    rep_->filter_block->StartBlock(0);

  }

}

TableBuilder::~TableBuilder() {

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

  Branch (73:3): [True: 24, False: 0]

  delete rep_->filter_block;

  delete rep_;

}

Status TableBuilder::ChangeOptions(const Options& options) {

  // 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) {

  Branch (82:7): [True: 0, False: 0]

    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();

}

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

  Rep* r = rep_;

  assert(!r->closed);

  Branch (96:3): [True: 11.7k, False: 0]

  if (!ok()) return;

  Branch (97:7): [True: 0, False: 11.7k]

  if (r->num_entries > 0) {

  Branch (98:7): [True: 11.7k, False: 24]

    assert(r->options.comparator->Compare(key, Slice(r->last_key)) > 0);

  Branch (99:5): [True: 11.7k, False: 0]

  }

  if (r->pending_index_entry) {

  Branch (102:7): [True: 601, False: 11.1k]

    assert(r->data_block.empty());

  Branch (103:5): [True: 601, False: 0]

    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 != nullptr) {

  Branch (111:7): [True: 11.7k, False: 0]

    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) {

  Branch (120:7): [True: 607, False: 11.1k]

    Flush();

  }

}

void TableBuilder::Flush() {

  Rep* r = rep_;

  assert(!r->closed);

  Branch (127:3): [True: 631, False: 0]

  if (!ok()) return;

  Branch (128:7): [True: 0, False: 631]

  if (r->data_block.empty()) return;

  Branch (129:7): [True: 6, False: 625]

  assert(!r->pending_index_entry);

  Branch (130:3): [True: 625, False: 0]

  WriteBlock(&r->data_block, &r->pending_handle);

  if (ok()) {

  Branch (132:7): [True: 625, False: 0]

    r->pending_index_entry = true;

    r->status = r->file->Flush();

  }

  if (r->filter_block != nullptr) {

  Branch (136:7): [True: 625, False: 0]

    r->filter_block->StartBlock(r->offset);

  }

}

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

  // File format contains a sequence of blocks where each block has:

  //    block_data: uint8[n]

  //    type: uint8

  //    crc: uint32

  assert(ok());

  Branch (146:3): [True: 673, False: 0]

  Rep* r = rep_;

  Slice raw = block->Finish();

  Slice block_contents;

  CompressionType type = r->options.compression;

  // TODO(postrelease): Support more compression options: zlib?

  switch (type) {

  Branch (153:11): [True: 0, False: 673]

    case kNoCompression:

  Branch (154:5): [True: 673, False: 0]

      block_contents = raw;

      break;

    case kSnappyCompression: {

  Branch (158:5): [True: 0, False: 673]

      std::string* compressed = &r->compressed_output;

      if (port::Snappy_Compress(raw.data(), raw.size(), compressed) &&

  Branch (160:11): [True: 0, False: 0]

          compressed->size() < raw.size() - (raw.size() / 8u)) {

  Branch (161:11): [True: 0, False: 0]

        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();

}

void TableBuilder::WriteRawBlock(const Slice& block_contents,

                                 CompressionType type, BlockHandle* handle) {

  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()) {

  Branch (183:7): [True: 697, False: 0]

    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()) {

  Branch (190:9): [True: 697, False: 0]

      r->offset += block_contents.size() + kBlockTrailerSize;

    }

  }

}

Status TableBuilder::status() const { return rep_->status; }

Status TableBuilder::Finish() {

  Rep* r = rep_;

  Flush();

  assert(!r->closed);

  Branch (201:3): [True: 24, False: 0]

  r->closed = true;

  BlockHandle filter_block_handle, metaindex_block_handle, index_block_handle;

  // Write filter block

  if (ok() && r->filter_block != nullptr) {

  Branch (207:7): [True: 24, False: 0]
  Branch (207:15): [True: 24, False: 0]

    WriteRawBlock(r->filter_block->Finish(), kNoCompression,

                  &filter_block_handle);

  }

  // Write metaindex block

  if (ok()) {

  Branch (213:7): [True: 24, False: 0]

    BlockBuilder meta_index_block(&r->options);

    if (r->filter_block != nullptr) {

  Branch (215:9): [True: 24, False: 0]

      // 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()) {

  Branch (229:7): [True: 24, False: 0]

    if (r->pending_index_entry) {

  Branch (230:9): [True: 24, False: 0]

      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()) {

  Branch (241:7): [True: 24, False: 0]

    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()) {

  Branch (248:9): [True: 24, False: 0]

      r->offset += footer_encoding.size();

    }

  }

  return r->status;

}

void TableBuilder::Abandon() {

  Rep* r = rep_;

  assert(!r->closed);

  Branch (257:3): [True: 0, False: 0]

  r->closed = true;

}

uint64_t TableBuilder::NumEntries() const { return rep_->num_entries; }

uint64_t TableBuilder::FileSize() const { return rep_->offset; }

}  // namespace leveldb