/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 **/

#include <algorithm>
#include <cstddef>
#include <memory>
#include <sstream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

#include "gtest/gtest.h"

#include "catalog/CatalogAttribute.hpp"
#include "catalog/CatalogRelation.hpp"
#include "catalog/CatalogTypedefs.hpp"
#include "expressions/predicate/ComparisonPredicate.hpp"
#include "expressions/scalar/Scalar.hpp"
#include "expressions/scalar/ScalarAttribute.hpp"
#include "expressions/scalar/ScalarLiteral.hpp"
#include "storage/BasicColumnStoreTupleStorageSubBlock.hpp"
#include "storage/StorageBlockLayout.hpp"
#include "storage/StorageBlockLayout.pb.h"
#include "storage/StorageConstants.hpp"
#include "storage/StorageErrors.hpp"
#include "storage/TupleIdSequence.hpp"
#include "storage/TupleStorageSubBlock.hpp"
#include "storage/tests/TupleStorePredicateUtil.hpp"
#include "types/CharType.hpp"
#include "types/DoubleType.hpp"
#include "types/IntType.hpp"
#include "types/Type.hpp"
#include "types/TypeFactory.hpp"
#include "types/TypedValue.hpp"
#include "types/TypeID.hpp"
#include "types/VarCharType.hpp"
#include "types/containers/Tuple.hpp"
#include "types/operations/comparisons/Comparison.hpp"
#include "types/operations/comparisons/ComparisonFactory.hpp"
#include "types/operations/comparisons/ComparisonID.hpp"
#include "types/operations/comparisons/ComparisonUtil.hpp"
#include "utility/BitVector.hpp"
#include "utility/ScopedBuffer.hpp"

using std::size_t;
using std::string;
using std::vector;

namespace quickstep {

class BasicColumnStoreTupleStorageSubBlockTest : public ::testing::TestWithParam<bool> {
 protected:
  static const size_t kSubBlockSize = 0x100000;  // 1 MB.

  virtual void SetUp() {
    // Create a sample relation with a variety of attribute types.
    relation_.reset(new CatalogRelation(NULL, "TestRelation"));

    CatalogAttribute *int_attr = new CatalogAttribute(relation_.get(),
                                                      "int_attr",
                                                      TypeFactory::GetType(kInt, GetParam()));
    ASSERT_EQ(0, relation_->addAttribute(int_attr));

    CatalogAttribute *double_attr = new CatalogAttribute(relation_.get(),
                                                         "double_attr",
                                                         TypeFactory::GetType(kDouble, GetParam()));
    ASSERT_EQ(1, relation_->addAttribute(double_attr));

    CatalogAttribute *narrow_char_attr = new CatalogAttribute(relation_.get(),
                                                              "narrow_char_attr",
                                                              TypeFactory::GetType(kChar, 4, GetParam()));
    ASSERT_EQ(2, relation_->addAttribute(narrow_char_attr));

    CatalogAttribute *wide_char_attr = new CatalogAttribute(relation_.get(),
                                                            "wide_char_attr",
                                                            TypeFactory::GetType(kChar, 32, GetParam()));
    ASSERT_EQ(3, relation_->addAttribute(wide_char_attr));

    // Records the 'base_value' of a tuple used in createSampleTuple.
    CatalogAttribute *base_value_attr = new CatalogAttribute(relation_.get(),
                                                             "base_value",
                                                             TypeFactory::GetType(kInt, false));
    ASSERT_EQ(4, relation_->addAttribute(base_value_attr));

    // Don't initialize the block yet. Different tests will use different sort
    // columns.
    tuple_store_memory_.reset();
    tuple_store_description_.reset();
    tuple_store_.reset();
  }

  void createBlock(const attribute_id sort_column, const size_t block_memory_size) {
    tuple_store_memory_.reset(block_memory_size);

    tuple_store_description_.reset(new TupleStorageSubBlockDescription());
    tuple_store_description_->set_sub_block_type(TupleStorageSubBlockDescription::BASIC_COLUMN_STORE);
    if (sort_column != kInvalidCatalogId) {
      tuple_store_description_->SetExtension(
          BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id,
          sort_column);
    }

    tuple_store_.reset(new BasicColumnStoreTupleStorageSubBlock(*relation_,
                                                                *tuple_store_description_,
                                                                true,
                                                                tuple_store_memory_.get(),
                                                                block_memory_size));
  }

  // Caller takes ownership of new heap-created Tuple.
  Tuple* createSampleTuple(const int base_value) const {
    std::vector<TypedValue> attrs;

    // int_attr
    if (GetParam() && (base_value % 8 == 0)) {
      // Throw in a NULL integer for every eighth value.
      attrs.emplace_back(kInt);
    } else {
      attrs.emplace_back(base_value);
    }

    // double_attr
    if (GetParam() && (base_value % 8 == 2)) {
      // NULL very eighth value.
      attrs.emplace_back(kDouble);
    } else {
      attrs.emplace_back(static_cast<double>(0.25 * base_value));
    }

    // narrow_char_attr
    if (GetParam() && (base_value % 8 == 4)) {
      // NULL very eighth value.
      attrs.emplace_back(CharType::InstanceNullable(4).makeNullValue());
    } else {
      std::ostringstream char_buffer;
      char_buffer << base_value;
      std::string string_literal(char_buffer.str());
      attrs.emplace_back(CharType::InstanceNonNullable(4).makeValue(
          string_literal.c_str(),
          string_literal.size() > 3 ? 4
                                    : string_literal.size() + 1));
      attrs.back().ensureNotReference();
    }

    // wide_char_attr
    if (GetParam() && (base_value % 8 == 6)) {
      // NULL very eighth value.
      attrs.emplace_back(CharType::InstanceNullable(32).makeNullValue());
    } else {
      std::ostringstream char_buffer;
      char_buffer << "Here are some numbers: " << base_value;
      std::string string_literal(char_buffer.str());
      attrs.emplace_back(CharType::InstanceNonNullable(32).makeValue(
          string_literal.c_str(),
          string_literal.size() + 1));
      attrs.back().ensureNotReference();
    }

    // base_value
    attrs.emplace_back(base_value);
    return new Tuple(std::move(attrs));
  }

  // Make a tuple out of the surrogate values used to sort nulls. Caller takes
  // ownership of new heap-created Tuple.
  Tuple* createTupleWithLastValues() const {
    std::vector<TypedValue> attrs;

    attrs.emplace_back(GetLastValueForType(TypeFactory::GetType(kInt, GetParam())));
    attrs.emplace_back(GetLastValueForType(TypeFactory::GetType(kDouble, GetParam())));
    attrs.emplace_back(GetLastValueForType(TypeFactory::GetType(kChar, 4, GetParam())));
    attrs.emplace_back(GetLastValueForType(TypeFactory::GetType(kChar, 32, GetParam())));
    attrs.emplace_back(-1);

    return new Tuple(std::move(attrs));
  }

  int computeRowCapacity() const {
    int initial_estimate = ((kSubBlockSize - 2 * sizeof(tuple_id)) << 3)
                           / ((relation_->getFixedByteLength() << 3) + relation_->numNullableAttributes());
    return (kSubBlockSize
                - (2 * sizeof(tuple_id))
                - (relation_->numNullableAttributes() * BitVector<false>::BytesNeeded(initial_estimate)))
           / relation_->getFixedByteLength();
  }

  int computeNullsInSortColumn(const attribute_id sort_column_id) {
    if (sort_column_id == kInvalidCatalogId || !GetParam()) {
      return 0;
    }

    int row_capacity = computeRowCapacity();
    int full_strides = (row_capacity - 2) / 8;
    int stride_remainder = (row_capacity - 2) % 8;
    switch (sort_column_id) {
      case 0:
        return full_strides + (stride_remainder > 0 ? 1 : 0);
      case 1:
        return full_strides + (stride_remainder > 2 ? 1 : 0);
      case 2:
        return full_strides + (stride_remainder > 4 ? 1 : 0);
      case 3:
        return full_strides + (stride_remainder > 6 ? 1 : 0);
      default:
        return 0;
    }
  }

  void fillBlockWithSampleData(const bool random_order, const bool ad_hoc) {
    std::unique_ptr<Tuple> current_tuple;
    if (random_order) {
      std::vector<int> base_values;
      for (int i = 0; i < computeRowCapacity() - 2; ++i) {
        base_values.push_back(i);
      }
      std::random_shuffle(base_values.begin(), base_values.end());

      if (ad_hoc) {
        // First, insert a tuple with special "last" values.
        TupleStorageSubBlock::InsertResult result(-1, false);
        current_tuple.reset(createTupleWithLastValues());
        result = tuple_store_->insertTuple(*current_tuple);
        EXPECT_EQ(0, result.inserted_id);
        EXPECT_FALSE(result.ids_mutated);
        int inserted = 1;

        // Regular tuples.
        for (const int base_value : base_values) {
          current_tuple.reset(createSampleTuple(base_value));
          result = tuple_store_->insertTuple(*current_tuple);
          EXPECT_GE(result.inserted_id, 0);
          ++inserted;
          if (result.inserted_id == (inserted - 1)) {
            EXPECT_FALSE(result.ids_mutated);
          } else {
            EXPECT_TRUE(result.ids_mutated);
          }
        }

        // Another "last" tuple.
        current_tuple.reset(createTupleWithLastValues());
        result = tuple_store_->insertTuple(*current_tuple);
        EXPECT_GE(result.inserted_id, 0);
        ++inserted;
        if (result.inserted_id == (inserted - 1)) {
          EXPECT_FALSE(result.ids_mutated);
        } else {
          EXPECT_TRUE(result.ids_mutated);
        }

        // No more space.
        result = tuple_store_->insertTuple(*current_tuple);
        EXPECT_EQ(-1, result.inserted_id);
      } else {
        current_tuple.reset(createTupleWithLastValues());
        EXPECT_TRUE(tuple_store_->insertTupleInBatch(*current_tuple));

        for (const int base_value : base_values) {
          current_tuple.reset(createSampleTuple(base_value));
          EXPECT_TRUE(tuple_store_->insertTupleInBatch(*current_tuple));
        }

        current_tuple.reset(createTupleWithLastValues());
        EXPECT_TRUE(tuple_store_->insertTupleInBatch(*current_tuple));

        // No more space.
        EXPECT_FALSE(tuple_store_->insertTupleInBatch(*current_tuple));

        tuple_store_->rebuild();
      }
    } else {
      // Fixed order.
      if (ad_hoc) {
        TupleStorageSubBlock::InsertResult result(-1, false);
        current_tuple.reset(createTupleWithLastValues());
        result = tuple_store_->insertTuple(*current_tuple);
        EXPECT_EQ(0, result.inserted_id);
        EXPECT_FALSE(result.ids_mutated);
        int inserted = 1;

        for (int base_value = 0; base_value < computeRowCapacity() - 2; ++base_value) {
          current_tuple.reset(createSampleTuple(base_value));
          result = tuple_store_->insertTuple(*current_tuple);
          EXPECT_GE(result.inserted_id, 0);
          ++inserted;
          if (result.inserted_id == (inserted - 1)) {
            EXPECT_FALSE(result.ids_mutated);
          } else {
            EXPECT_TRUE(result.ids_mutated);
          }
        }

        current_tuple.reset(createTupleWithLastValues());
        result = tuple_store_->insertTuple(*current_tuple);
        EXPECT_GE(result.inserted_id, 0);
        ++inserted;
        if (result.inserted_id == (inserted - 1)) {
          EXPECT_FALSE(result.ids_mutated);
        } else {
          EXPECT_TRUE(result.ids_mutated);
        }

        // No more space.
        result = tuple_store_->insertTuple(*current_tuple);
        EXPECT_EQ(-1, result.inserted_id);
      } else {
        current_tuple.reset(createTupleWithLastValues());
        EXPECT_TRUE(tuple_store_->insertTupleInBatch(*current_tuple));

        for (int base_value = 0; base_value < computeRowCapacity() - 2; ++base_value) {
          current_tuple.reset(createSampleTuple(base_value));
          EXPECT_TRUE(tuple_store_->insertTupleInBatch(*current_tuple));
        }

        current_tuple.reset(createTupleWithLastValues());
        EXPECT_TRUE(tuple_store_->insertTupleInBatch(*current_tuple));

        // No more space.
        EXPECT_FALSE(tuple_store_->insertTupleInBatch(*current_tuple));

        tuple_store_->rebuild();
      }
    }
  }

  void checkBlockValues(const attribute_id sort_attribute_id,
                        const size_t regular_tuples_deleted,
                        const size_t last_tuples_deleted) const {
    EXPECT_EQ(computeRowCapacity() - regular_tuples_deleted - last_tuples_deleted,
              static_cast<std::size_t>(tuple_store_->getMaxTupleID() + 1));

    std::unique_ptr<UncheckedComparator> sort_attribute_comparator;
    if (sort_attribute_id != kInvalidCatalogId) {
      const Type &sort_attribute_type =
          relation_->getAttributeById(sort_attribute_id)->getType();
      sort_attribute_comparator.reset(
          ComparisonFactory::GetComparison(ComparisonID::kLessOrEqual)
              .makeUncheckedComparatorForTypes(sort_attribute_type,
                                               sort_attribute_type));
    }

    std::vector<bool> existence_check_vector;
    existence_check_vector.resize(computeRowCapacity() - 2, false);
    size_t num_last_tuples = 0;
    size_t num_regular_tuples = 0;

    std::unique_ptr<TypedValue> previous_sort_attribute_value;
    for (tuple_id tid = 0;
         tid <= tuple_store_->getMaxTupleID();
         ++tid) {
      EXPECT_TRUE(tuple_store_->hasTupleWithID(tid));

      const int base_value = *static_cast<const int*>(tuple_store_->getAttributeValue(tid, 4));
      ASSERT_LT(base_value, computeRowCapacity() - 2);
      std::unique_ptr<Tuple> comparison_tuple;
      if (base_value == -1) {
        ++num_last_tuples;
        comparison_tuple.reset(createTupleWithLastValues());
      } else {
        ++num_regular_tuples;
        EXPECT_FALSE(existence_check_vector[base_value]);
        existence_check_vector[base_value] = true;
        comparison_tuple.reset(createSampleTuple(base_value));
      }

      // Check attribute values.
      for (const CatalogAttribute &attr : *relation_) {
        const void *untyped_value = tuple_store_->getAttributeValue(tid, attr.getID());
        TypedValue typed_value = tuple_store_->getAttributeValueTyped(tid, attr.getID());

        EXPECT_TRUE(typed_value.isPlausibleInstanceOf(attr.getType().getSignature()));
        if (comparison_tuple->getAttributeValue(attr.getID()).isNull()) {
          EXPECT_EQ(nullptr, untyped_value);
          EXPECT_TRUE(typed_value.isNull());
        } else {
          EXPECT_TRUE(CheckUntypedValuesEqual(attr.getType(),
                                              comparison_tuple->getAttributeValue(attr.getID()).getDataPtr(),
                                              untyped_value));
          EXPECT_TRUE(CheckUntypedValuesEqual(attr.getType(),
                                              comparison_tuple->getAttributeValue(attr.getID()).getDataPtr(),
                                              typed_value.getDataPtr()));
        }
      }

      // Check ordering if block is sorted.
      if (sort_attribute_id != kInvalidCatalogId) {
        TypedValue sort_attribute_value =
            tuple_store_->getAttributeValueTyped(tid, sort_attribute_id);
        if (previous_sort_attribute_value) {
          if (previous_sort_attribute_value->isNull()) {
            EXPECT_TRUE(sort_attribute_value.isNull());
          } else if (!sort_attribute_value.isNull()) {
            EXPECT_TRUE(sort_attribute_comparator->compareTypedValues(
                *previous_sort_attribute_value,
                sort_attribute_value));
          }
        }
        previous_sort_attribute_value.reset(new TypedValue(sort_attribute_value));
      }
    }

    EXPECT_EQ(2 - last_tuples_deleted, num_last_tuples);
    EXPECT_EQ(computeRowCapacity() - 2 - regular_tuples_deleted,
              num_regular_tuples);
  }

  void runDeleteTest(const attribute_id sort_attribute_id) {
    createBlock(sort_attribute_id, kSubBlockSize);
    fillBlockWithSampleData(true, false);

    int row_capacity = computeRowCapacity();

    // Delete last tuple.
    EXPECT_FALSE(tuple_store_->deleteTuple(row_capacity - 1));

    // Delete first tuple.
    EXPECT_TRUE(tuple_store_->deleteTuple(0));

    // Delete a sequence of tuples.
    TupleIdSequence delete_sequence(tuple_store_->getMaxTupleID() + 1);
    for (tuple_id tid = 0;
         tid < row_capacity - computeNullsInSortColumn(sort_attribute_id) - 2 - 2;
         tid += 5) {
      // Some non-null values.
      delete_sequence.set(tid, true);
    }
    // Some nulls, if any exist.
    for (tuple_id tid = row_capacity - computeNullsInSortColumn(sort_attribute_id) + 1;
         tid < row_capacity - 2;
         tid += 5) {
      delete_sequence.set(tid, true);
    }
    // One of the special "last" values.
    if (sort_attribute_id != kInvalidCatalogId && GetParam()) {
      delete_sequence.set(row_capacity - computeNullsInSortColumn(sort_attribute_id) - 2, true);
    }

    EXPECT_TRUE(tuple_store_->bulkDeleteTuples(&delete_sequence));

    if (sort_attribute_id == kInvalidCatalogId) {
      // There is no special treatment of "last" values without sorting.
      checkBlockValues(sort_attribute_id, delete_sequence.numTuples(), 2);
    } else {
      checkBlockValues(sort_attribute_id, delete_sequence.numTuples() + 2 - 1, 1);
    }
  }

  // Create a ComparisonPredicate of the form "attribute comp literal".
  template <typename AttributeType>
  Predicate* generateNumericComparisonPredicate(const ComparisonID comp,
                                                const attribute_id attribute,
                                                const typename AttributeType::cpptype literal) const {
    ScalarAttribute *scalar_attribute = new ScalarAttribute(*relation_->getAttributeById(attribute));
    ScalarLiteral *scalar_literal
        = new ScalarLiteral(AttributeType::InstanceNonNullable().makeValue(&literal),
                            AttributeType::InstanceNonNullable());
    return new ComparisonPredicate(ComparisonFactory::GetComparison(comp), scalar_attribute, scalar_literal);
  }

  Predicate* generateStringComparisonPredicate(const ComparisonID comp,
                                               const attribute_id attribute,
                                               const string &literal) const {
    ScalarAttribute *scalar_attribute = new ScalarAttribute(*relation_->getAttributeById(attribute));
    ScalarLiteral *scalar_literal = new ScalarLiteral(
        VarCharType::InstanceNonNullable(literal.size()).makeValue(
            literal.c_str(),
            literal.size() + 1).ensureNotReference(),
        VarCharType::InstanceNonNullable(literal.size()));
    return new ComparisonPredicate(ComparisonFactory::GetComparison(comp),
                                   scalar_attribute,
                                   scalar_literal);
  }

  template <typename ValueType>
  inline static bool matchExpected(const ComparisonID comp,
                                   const ValueType &left,
                                   const ValueType &right) {
    switch (comp) {
      case ComparisonID::kEqual:
        return (left == right);
      case ComparisonID::kNotEqual:
        return (left != right);
      case ComparisonID::kLess:
        return (left < right);
      case ComparisonID::kLessOrEqual:
        return (left <= right);
      case ComparisonID::kGreater:
        return (left > right);
      case ComparisonID::kGreaterOrEqual:
        return (left >= right);
      default:
        FATAL_ERROR("Unrecognized ComparisonID");
    }
  }

  void checkPredicateIntAttr(const ComparisonID comp) const {
    int comparison_literal = computeRowCapacity() >> 1;

    std::unique_ptr<Predicate> predicate(
        generateNumericComparisonPredicate<IntType>(comp,
                                                    0,
                                                    comparison_literal));
    std::unique_ptr<TupleIdSequence> matches(
        TupleStorePredicateUtil::GetMatchesForPredicateOnTupleStore(*predicate, *tuple_store_));

    for (tuple_id tid = 0;
         tid < static_cast<tuple_id>(matches->length());
         ++tid) {
      int insert_order_value = *static_cast<const int*>(tuple_store_->getAttributeValue(tid, 4));
      if (GetParam() && (insert_order_value % 8 == 0)) {
        // Value is NULL.
        EXPECT_FALSE(matches->get(tid));
      } else if (insert_order_value == -1) {
        // Special last value.
        if (matchExpected(comp,
                          GetLastValueForType(TypeFactory::GetType(kInt, GetParam())).getLiteral<int>(),
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      } else {
        if (matchExpected(comp,
                          insert_order_value,
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      }
    }
  }

  void checkPredicateDoubleAttr(const ComparisonID comp) const {
    double comparison_literal = (computeRowCapacity() >> 1) * 0.25;

    std::unique_ptr<Predicate> predicate(
        generateNumericComparisonPredicate<DoubleType>(comp,
                                                       1,
                                                       comparison_literal));
    std::unique_ptr<TupleIdSequence> matches(
        TupleStorePredicateUtil::GetMatchesForPredicateOnTupleStore(*predicate, *tuple_store_));

    for (tuple_id tid = 0;
         tid < static_cast<tuple_id>(matches->length());
         ++tid) {
      int insert_order_value = *static_cast<const int*>(tuple_store_->getAttributeValue(tid, 4));
      if (GetParam() && (insert_order_value % 8 == 2)) {
        // Value is NULL.
        EXPECT_FALSE(matches->get(tid));
      } else if (insert_order_value == -1) {
        // Special last value.
        if (matchExpected(comp,
                          GetLastValueForType(TypeFactory::GetType(kDouble, GetParam())).getLiteral<double>(),
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      } else {
        if (matchExpected(comp,
                          insert_order_value * 0.25,
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      }
    }
  }

  void checkPredicateNarrowCharAttr(const ComparisonID comp) const {
    string comparison_literal = "500";

    std::unique_ptr<Predicate> predicate(
        generateStringComparisonPredicate(comp,
                                          2,
                                          comparison_literal));
    std::unique_ptr<TupleIdSequence> matches(
        TupleStorePredicateUtil::GetMatchesForPredicateOnTupleStore(*predicate, *tuple_store_));

    for (tuple_id tid = 0;
         tid < static_cast<tuple_id>(matches->length());
         ++tid) {
      int insert_order_value = *static_cast<const int*>(tuple_store_->getAttributeValue(tid, 4));
      if (GetParam() && (insert_order_value % 8 == 4)) {
        // Value is NULL.
        EXPECT_FALSE(matches->get(tid));
      } else if (insert_order_value == -1) {
        // Special last value.
        if (matchExpected(comp,
                          std::string(static_cast<const char*>(
                              GetLastValueForType(TypeFactory::GetType(kChar, 4, GetParam())).getDataPtr())),
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      } else {
        std::ostringstream char_buffer;
        char_buffer << insert_order_value;
        std::string string_literal(char_buffer.str());
        if (string_literal.size() > 4) {
          string_literal.resize(4);
        }
        if (matchExpected(comp,
                          string_literal,
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      }
    }
  }

  void checkPredicateWideCharAttr(const ComparisonID comp) const {
    string comparison_literal = "Here are some numbers: 5000";

    std::unique_ptr<Predicate> predicate(
        generateStringComparisonPredicate(comp,
                                          3,
                                          comparison_literal));
    std::unique_ptr<TupleIdSequence> matches(
        TupleStorePredicateUtil::GetMatchesForPredicateOnTupleStore(*predicate, *tuple_store_));

    for (tuple_id tid = 0;
         tid < static_cast<tuple_id>(matches->length());
         ++tid) {
      int insert_order_value = *static_cast<const int*>(tuple_store_->getAttributeValue(tid, 4));
      if (GetParam() && (insert_order_value % 8 == 6)) {
        // Value is NULL.
        EXPECT_FALSE(matches->get(tid));
      } else if (insert_order_value == -1) {
        // Special last value.
        if (matchExpected(comp,
                          std::string(static_cast<const char*>(
                              GetLastValueForType(TypeFactory::GetType(kChar, 32, GetParam())).getDataPtr())),
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      } else {
        std::ostringstream char_buffer;
        char_buffer << "Here are some numbers: " << insert_order_value;
        std::string string_literal(char_buffer.str());
        if (matchExpected(comp,
                          string_literal,
                          comparison_literal)) {
          EXPECT_TRUE(matches->get(tid));
        } else {
          EXPECT_FALSE(matches->get(tid));
        }
      }
    }
  }

  void runCheckPredicateTest(const attribute_id sort_attribute_id) {
    createBlock(sort_attribute_id, kSubBlockSize);
    fillBlockWithSampleData(true, false);

    checkPredicateIntAttr(ComparisonID::kEqual);
    checkPredicateIntAttr(ComparisonID::kNotEqual);
    checkPredicateIntAttr(ComparisonID::kLess);
    checkPredicateIntAttr(ComparisonID::kLessOrEqual);
    checkPredicateIntAttr(ComparisonID::kGreater);
    checkPredicateIntAttr(ComparisonID::kGreaterOrEqual);

    checkPredicateDoubleAttr(ComparisonID::kEqual);
    checkPredicateDoubleAttr(ComparisonID::kNotEqual);
    checkPredicateDoubleAttr(ComparisonID::kLess);
    checkPredicateDoubleAttr(ComparisonID::kLessOrEqual);
    checkPredicateDoubleAttr(ComparisonID::kGreater);
    checkPredicateDoubleAttr(ComparisonID::kGreaterOrEqual);

    checkPredicateNarrowCharAttr(ComparisonID::kEqual);
    checkPredicateNarrowCharAttr(ComparisonID::kNotEqual);
    checkPredicateNarrowCharAttr(ComparisonID::kLess);
    checkPredicateNarrowCharAttr(ComparisonID::kLessOrEqual);
    checkPredicateNarrowCharAttr(ComparisonID::kGreater);
    checkPredicateNarrowCharAttr(ComparisonID::kGreaterOrEqual);

    checkPredicateWideCharAttr(ComparisonID::kEqual);
    checkPredicateWideCharAttr(ComparisonID::kNotEqual);
    checkPredicateWideCharAttr(ComparisonID::kLess);
    checkPredicateWideCharAttr(ComparisonID::kLessOrEqual);
    checkPredicateWideCharAttr(ComparisonID::kGreater);
    checkPredicateWideCharAttr(ComparisonID::kGreaterOrEqual);
  }

  void runSetAttributeValueInPlaceTypedTest(const attribute_id sort_attribute_id) {
    createBlock(sort_attribute_id, kSubBlockSize);
    fillBlockWithSampleData(true, false);

    const tuple_id target_tid = tuple_store_->getMaxTupleID() >> 1;

    TypedValue new_int_value(-42);
    TypedValue new_double_value(static_cast<double>(-4.2));
    const char new_narrow_char_lit[4] = "foo";
    TypedValue new_narrow_char_value(kChar, new_narrow_char_lit, 4);
    const char new_wide_char_lit[32] = "I am not a number!";
    TypedValue new_wide_char_value(kChar, new_wide_char_lit, 32);

    std::unordered_map<attribute_id, TypedValue> proposed_values;
    if (sort_attribute_id != kInvalidCatalogId) {
      switch (sort_attribute_id) {
        case 0:
          proposed_values.emplace(0, new_int_value);
          break;
        case 1:
          proposed_values.emplace(1, new_double_value);
          break;
        case 2:
          proposed_values.emplace(2, new_narrow_char_value);
          break;
        case 3:
          proposed_values.emplace(3, new_wide_char_value);
          break;
      }

      // Can't overwrite a sort column value in-place.
      EXPECT_FALSE(tuple_store_->canSetAttributeValuesInPlaceTyped(
          target_tid, proposed_values));
    }

    // Other column values should be OK.
    proposed_values.clear();
    proposed_values.emplace(0, new_int_value);
    proposed_values.emplace(1, new_double_value);
    proposed_values.emplace(2, new_narrow_char_value);
    proposed_values.emplace(3, new_wide_char_value);
    if (sort_attribute_id != kInvalidCatalogId) {
      proposed_values.erase(sort_attribute_id);
    }
    EXPECT_TRUE(tuple_store_->canSetAttributeValuesInPlaceTyped(target_tid, proposed_values));

    // Actually set values.
    for (const auto &update_pair : proposed_values) {
      tuple_store_->setAttributeValueInPlaceTyped(target_tid, update_pair.first, update_pair.second);
    }

    if (sort_attribute_id != 0) {
      ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 0).isNull());
      EXPECT_EQ(new_int_value.getLiteral<int>(),
                tuple_store_->getAttributeValueTyped(target_tid, 0).getLiteral<int>());
    }
    if (sort_attribute_id != 1) {
      ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 1).isNull());
      EXPECT_EQ(new_double_value.getLiteral<double>(),
                tuple_store_->getAttributeValueTyped(target_tid, 1).getLiteral<double>());
    }
    if (sort_attribute_id != 2) {
      ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 2).isNull());
      EXPECT_STREQ(static_cast<const char*>(new_narrow_char_value.getDataPtr()),
                   static_cast<const char*>(tuple_store_->getAttributeValueTyped(target_tid, 2).getDataPtr()));
    }
    if (sort_attribute_id != 3) {
      ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 3).isNull());
      EXPECT_STREQ(static_cast<const char*>(new_wide_char_value.getDataPtr()),
                   static_cast<const char*>(tuple_store_->getAttributeValueTyped(target_tid, 3).getDataPtr()));
    }

    if (GetParam()) {
      // Set NULL values.
      for (const auto &update_pair : proposed_values) {
        tuple_store_->setAttributeValueInPlaceTyped(target_tid,
                                                    update_pair.first,
                                                    TypedValue(update_pair.second.getTypeID()));
      }

      for (attribute_id attr_id = 0; attr_id < 4; ++attr_id) {
        if (attr_id != sort_attribute_id) {
          EXPECT_TRUE(tuple_store_->getAttributeValueTyped(target_tid, attr_id).isNull());
        }
      }

      // Set back to non-null values.
      for (const auto &update_pair : proposed_values) {
        tuple_store_->setAttributeValueInPlaceTyped(target_tid, update_pair.first, update_pair.second);
      }

      if (sort_attribute_id != 0) {
        ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 0).isNull());
        EXPECT_EQ(new_int_value.getLiteral<int>(),
                  tuple_store_->getAttributeValueTyped(target_tid, 0).getLiteral<int>());
      }
      if (sort_attribute_id != 1) {
        ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 1).isNull());
        EXPECT_EQ(new_double_value.getLiteral<double>(),
                  tuple_store_->getAttributeValueTyped(target_tid, 1).getLiteral<double>());
      }
      if (sort_attribute_id != 2) {
        ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 2).isNull());
        EXPECT_STREQ(static_cast<const char*>(new_narrow_char_value.getDataPtr()),
                    static_cast<const char*>(tuple_store_->getAttributeValueTyped(target_tid, 2).getDataPtr()));
      }
      if (sort_attribute_id != 3) {
        ASSERT_FALSE(tuple_store_->getAttributeValueTyped(target_tid, 3).isNull());
        EXPECT_STREQ(static_cast<const char*>(new_wide_char_value.getDataPtr()),
                    static_cast<const char*>(tuple_store_->getAttributeValueTyped(target_tid, 3).getDataPtr()));
      }
    }
  }

  std::unique_ptr<CatalogRelation> relation_;
  ScopedBuffer tuple_store_memory_;
  std::unique_ptr<TupleStorageSubBlockDescription> tuple_store_description_;
  std::unique_ptr<BasicColumnStoreTupleStorageSubBlock> tuple_store_;
};

typedef BasicColumnStoreTupleStorageSubBlockTest BasicColumnStoreTupleStorageSubBlockDeathTest;

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DescriptionIsValidTest) {
  // The descriptions we use for the other tests should be valid.
  for (const CatalogAttribute &attr : *relation_) {
    tuple_store_description_.reset(
        new TupleStorageSubBlockDescription());
    tuple_store_description_->set_sub_block_type(
        TupleStorageSubBlockDescription::BASIC_COLUMN_STORE);
    tuple_store_description_->SetExtension(
        BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id,
        attr.getID());
    EXPECT_TRUE(BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid(
        *relation_,
        *tuple_store_description_));
  }

  // Also check a description that doesn't specify a sort column.
  tuple_store_description_.reset(new TupleStorageSubBlockDescription());
  tuple_store_description_->set_sub_block_type(
      TupleStorageSubBlockDescription::BASIC_COLUMN_STORE);
  EXPECT_TRUE(BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid(
      *relation_,
      *tuple_store_description_));

  // An uninitialized description is not valid.
  tuple_store_description_.reset(new TupleStorageSubBlockDescription());
  EXPECT_FALSE(BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid(
                   *relation_,
                   *tuple_store_description_));

  // A description that specifies the wrong sub_block_type is not valid.
  tuple_store_description_->set_sub_block_type(
      TupleStorageSubBlockDescription::SPLIT_ROW_STORE);
  EXPECT_FALSE(BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid(
                   *relation_,
                   *tuple_store_description_));

  // A relation with a variable-length attribute can't be used with this block type.
  std::unique_ptr<CatalogRelation> variable_length_relation(
      new CatalogRelation(nullptr, "variable_length_relation"));
  CatalogAttribute *variable_length_attribute = new CatalogAttribute(
      variable_length_relation.get(),
      "variable_length_attr",
      TypeFactory::GetType(kVarChar, 20, false));
  ASSERT_EQ(0, variable_length_relation->addAttribute(variable_length_attribute));
  tuple_store_description_.reset(new TupleStorageSubBlockDescription());
  tuple_store_description_->set_sub_block_type(
      TupleStorageSubBlockDescription::BASIC_COLUMN_STORE);
  tuple_store_description_->SetExtension(
      BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id,
      0);
  EXPECT_FALSE(BasicColumnStoreTupleStorageSubBlock::DescriptionIsValid(*variable_length_relation,
                                                                        *tuple_store_description_));
}

TEST_P(BasicColumnStoreTupleStorageSubBlockDeathTest, ConstructWithInvalidDescriptionTest) {
  EXPECT_DEATH(createBlock(10, kSubBlockSize), "");
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, BlockTooSmallTest) {
  EXPECT_THROW(createBlock(0, 32), BlockMemoryTooSmall);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithNoSortColumnTest) {
  // Non-random, batch insert.
  createBlock(kInvalidCatalogId, kSubBlockSize);
  fillBlockWithSampleData(false, false);

  // Non-random, ad-hoc insert.
  createBlock(kInvalidCatalogId, kSubBlockSize);
  fillBlockWithSampleData(false, true);

  // Random order, batch insert.
  createBlock(kInvalidCatalogId, kSubBlockSize);
  fillBlockWithSampleData(true, false);

  // Random order, ad-hoc insert.
  createBlock(kInvalidCatalogId, kSubBlockSize);
  fillBlockWithSampleData(true, true);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithIntSortColumnTest) {
  // Non-random, batch insert.
  createBlock(0, kSubBlockSize);
  fillBlockWithSampleData(false, false);

  // Non-random, ad-hoc insert.
  createBlock(0, kSubBlockSize);
  fillBlockWithSampleData(false, true);

  // Random order, batch insert.
  createBlock(0, kSubBlockSize);
  fillBlockWithSampleData(true, false);

  // Random order, ad-hoc insert.
  createBlock(0, kSubBlockSize);
  fillBlockWithSampleData(true, true);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithDoubleSortColumnTest) {
  // Non-random, batch insert.
  createBlock(1, kSubBlockSize);
  fillBlockWithSampleData(false, false);

  // Non-random, ad-hoc insert.
  createBlock(1, kSubBlockSize);
  fillBlockWithSampleData(false, true);

  // Random order, batch insert.
  createBlock(1, kSubBlockSize);
  fillBlockWithSampleData(true, false);

  // Random order, ad-hoc insert.
  createBlock(1, kSubBlockSize);
  fillBlockWithSampleData(true, true);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithNarrowCharSortColumnTest) {
  // Non-random, batch insert.
  createBlock(2, kSubBlockSize);
  fillBlockWithSampleData(false, false);

  // Non-random, ad-hoc insert.
  createBlock(2, kSubBlockSize);
  fillBlockWithSampleData(false, true);

  // Random order, batch insert.
  createBlock(2, kSubBlockSize);
  fillBlockWithSampleData(true, false);

  // Random order, ad-hoc insert.
  createBlock(2, kSubBlockSize);
  fillBlockWithSampleData(true, true);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, InsertWithWideCharSortColumnTest) {
  // Non-random, batch insert.
  createBlock(3, kSubBlockSize);
  fillBlockWithSampleData(false, false);

  // Non-random, ad-hoc insert.
  createBlock(3, kSubBlockSize);
  fillBlockWithSampleData(false, true);

  // Random order, batch insert.
  createBlock(3, kSubBlockSize);
  fillBlockWithSampleData(true, false);

  // Random order, ad-hoc insert.
  createBlock(3, kSubBlockSize);
  fillBlockWithSampleData(true, true);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithNoSortColumnTest) {
  createBlock(kInvalidCatalogId, kSubBlockSize);
  fillBlockWithSampleData(true, false);
  checkBlockValues(kInvalidCatalogId, 0, 0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithIntSortColumnTest) {
  createBlock(0, kSubBlockSize);
  fillBlockWithSampleData(true, false);
  checkBlockValues(0, 0, 0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithDoubleSortColumnTest) {
  createBlock(1, kSubBlockSize);
  fillBlockWithSampleData(true, false);
  checkBlockValues(1, 0, 0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithNarrowCharSortColumnTest) {
  createBlock(2, kSubBlockSize);
  fillBlockWithSampleData(true, false);
  checkBlockValues(2, 0, 0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetValuesWithWideCharSortColumnTest) {
  createBlock(3, kSubBlockSize);
  fillBlockWithSampleData(true, false);
  checkBlockValues(3, 0, 0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithNoSortColumnTest) {
  runDeleteTest(kInvalidCatalogId);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithIntSortColumnTest) {
  runDeleteTest(0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithDoubleSortColumnTest) {
  runDeleteTest(1);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithNarrowCharSortColumnTest) {
  runDeleteTest(2);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, DeleteWithWideCharSortColumnTest) {
  runDeleteTest(3);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithNoSortColumnTest) {
  runCheckPredicateTest(kInvalidCatalogId);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithIntSortColumnTest) {
  runCheckPredicateTest(0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithDoubleSortColumnTest) {
  runCheckPredicateTest(1);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithNarrowCharSortColumnTest) {
  runCheckPredicateTest(2);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, GetMatchesForPredicateWithWideCharSortColumnTest) {
  runCheckPredicateTest(3);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, SetAttributeValueInPlaceTypedWithNoSortColumnTest) {
  runSetAttributeValueInPlaceTypedTest(kInvalidCatalogId);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, SetAttributeValueInPlaceTypedWithIntSortColumnTest) {
  runSetAttributeValueInPlaceTypedTest(0);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, SetAttributeValueInPlaceTypedWithDoubleSortColumnTest) {
  runSetAttributeValueInPlaceTypedTest(1);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, SetAttributeValueInPlaceTypedWithNarrowCharSortColumnTest) {
  runSetAttributeValueInPlaceTypedTest(2);
}

TEST_P(BasicColumnStoreTupleStorageSubBlockTest, SetAttributeValueInPlaceTypedWithWideCharSortColumnTest) {
  runSetAttributeValueInPlaceTypedTest(3);
}

TEST(BasicColumnStoreTupleStorageSubBlockNullTypeTest, NullTypeTest) {
  // Set up a relation with an int attribute (need a sortable attribute to use
  // BasicColumnStore) and a single NullType attribute.
  CatalogRelation test_relation(nullptr, "TestRelation");
  CatalogAttribute *int_attr = new CatalogAttribute(&test_relation,
                                                    "int_attr",
                                                    TypeFactory::GetType(kInt, false));
  ASSERT_EQ(0, test_relation.addAttribute(int_attr));
  CatalogAttribute *nulltype_attr = new CatalogAttribute(&test_relation,
                                                         "nulltype_attr",
                                                         TypeFactory::GetType(kNullType, true));
  ASSERT_EQ(1, test_relation.addAttribute(nulltype_attr));

  // Set up a minimal StorageBlockLayoutDescription.
  StorageBlockLayoutDescription layout_desc;
  layout_desc.set_num_slots(1);
  layout_desc.mutable_tuple_store_description()->set_sub_block_type(
      TupleStorageSubBlockDescription::BASIC_COLUMN_STORE);
  layout_desc.mutable_tuple_store_description()->SetExtension(
      BasicColumnStoreTupleStorageSubBlockDescription::sort_attribute_id,
      0);

  // Check that the description is considered valid.
  EXPECT_TRUE(StorageBlockLayout::DescriptionIsValid(test_relation, layout_desc));

  StorageBlockLayout layout(test_relation, layout_desc);

  // Construct an actual PackedRowStoreTupleStorageSubBlock.
  ScopedBuffer tuple_store_memory(kSlotSizeBytes);
  BasicColumnStoreTupleStorageSubBlock tuple_store(test_relation,
                                                   layout_desc.tuple_store_description(),
                                                   true,
                                                   tuple_store_memory.get(),
                                                   kSlotSizeBytes);

  // Insert some NullType values.
  std::vector<TypedValue> attr_values;
  attr_values.emplace_back(0);
  attr_values.emplace_back(kNullType);
  Tuple tuple(std::move(attr_values));

  for (tuple_id tid = 0; tid < 100; ++tid) {
    tuple_store.insertTuple(tuple);
  }

  EXPECT_EQ(100, tuple_store.numTuples());

  // Read out values.
  for (tuple_id tid = 0; tid < 100; ++tid) {
    ASSERT_TRUE(tuple_store.hasTupleWithID(tid));
    EXPECT_EQ(nullptr, tuple_store.getAttributeValue(tid, 1));

    TypedValue value = tuple_store.getAttributeValueTyped(tid, 1);
    EXPECT_TRUE(value.isNull());
    EXPECT_EQ(kNullType, value.getTypeID());
  }

  // Delete some values.
  TupleIdSequence delete_sequence(100);
  delete_sequence.set(5, true);
  delete_sequence.set(25, true);
  delete_sequence.set(45, true);
  delete_sequence.set(65, true);
  delete_sequence.set(85, true);

  EXPECT_TRUE(tuple_store.bulkDeleteTuples(&delete_sequence));
  EXPECT_EQ(95, tuple_store.numTuples());
  ASSERT_EQ(94, tuple_store.getMaxTupleID());

  // Read out the remaining undeleted values.
  for (tuple_id tid = 0; tid < 95; ++tid) {
    ASSERT_TRUE(tuple_store.hasTupleWithID(tid));
    EXPECT_EQ(nullptr, tuple_store.getAttributeValue(tid, 1));

    TypedValue value = tuple_store.getAttributeValueTyped(tid, 1);
    EXPECT_TRUE(value.isNull());
    EXPECT_EQ(kNullType, value.getTypeID());
  }
}

// Note: INSTANTIATE_TEST_CASE_P has variadic arguments part. If the variable argument part
//       is empty, C++11 standard says it should produce a warning. A warning is converted
//       to an error since we use -Werror as a compiler parameter. It causes Travis to build.
//       This is the reason that we must give an empty string argument as a last parameter
//       to supress warning that clang gives.
INSTANTIATE_TEST_CASE_P(WithAndWithoutNullableAttributes,
                        BasicColumnStoreTupleStorageSubBlockTest,
                        ::testing::Bool(),);  // NOLINT(whitespace/comma)

INSTANTIATE_TEST_CASE_P(WithAndWithoutNullableAttributes,
                        BasicColumnStoreTupleStorageSubBlockDeathTest,
                        ::testing::Bool(),);  // NOLINT(whitespace/comma)

}  // namespace quickstep