| /** |
| * 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. |
| **/ |
| |
| #ifndef QUICKSTEP_STORAGE_TESTS_MOCK_TUPLE_STORAGE_SUB_BLOCK_HPP_ |
| #define QUICKSTEP_STORAGE_TESTS_MOCK_TUPLE_STORAGE_SUB_BLOCK_HPP_ |
| |
| #include <unordered_map> |
| #include <vector> |
| |
| #include "catalog/CatalogRelation.hpp" |
| #include "storage/StorageBlockLayout.pb.h" |
| #include "storage/TupleIdSequence.hpp" |
| #include "storage/TupleStorageSubBlock.hpp" |
| #include "types/TypedValue.hpp" |
| #include "types/containers/Tuple.hpp" |
| #include "utility/Macros.hpp" |
| #include "utility/PtrVector.hpp" |
| |
| namespace quickstep { |
| |
| /** \addtogroup Storage |
| * @{ |
| */ |
| |
| /** |
| * @brief A mock memory-only TupleStorageSubBlock which can be used for testing |
| * purposes. |
| **/ |
| class MockTupleStorageSubBlock : public TupleStorageSubBlock { |
| public: |
| explicit MockTupleStorageSubBlock(const CatalogRelation &relation) |
| : TupleStorageSubBlock(relation, |
| TupleStorageSubBlockDescription::default_instance(), |
| true, |
| NULL, |
| 0), |
| packed_(true) { |
| } |
| |
| ~MockTupleStorageSubBlock() { |
| } |
| |
| TupleStorageSubBlockType getTupleStorageSubBlockType() const override { |
| FATAL_ERROR("getTupleStorageSubBlockType() is unimplemented in MockTupleStorageSubBlock."); |
| } |
| |
| bool supportsUntypedGetAttributeValue(const attribute_id attr) const override { |
| return true; |
| } |
| |
| bool supportsAdHocInsert() const override { |
| return true; |
| } |
| |
| bool adHocInsertIsEfficient() const override { |
| return true; |
| } |
| |
| bool isEmpty() const override { |
| return tuples_.emptyNullCheck(); |
| } |
| |
| bool isPacked() const override { |
| return packed_; |
| } |
| |
| tuple_id getMaxTupleID() const override { |
| if (packed_) { |
| return tuples_.size() - 1; |
| } else { |
| for (tuple_id tid = tuples_.size() -1; tid >= 0; --tid) { |
| if (!tuples_.elementIsNull(tid)) { |
| return tid; |
| } |
| } |
| return -1; |
| } |
| } |
| |
| bool hasTupleWithID(const tuple_id tuple) const override { |
| if ((tuple >= 0) && (static_cast<PtrVector<Tuple, true>::size_type>(tuple) < tuples_.size())) { |
| return !tuples_.elementIsNull(tuple); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * @brief Add a Tuple to this MockTupleStorageSubBlock, taking ownership of |
| * the Tuple in the process. Use this instead of insertTuple() when |
| * testing. |
| * |
| * @param tuple A tuple which this MockTupleStorageSubBlock takes ownership |
| * of. |
| * @return tuple's ID in this MockTupleStorageSubBlock. |
| **/ |
| tuple_id addTupleMock(Tuple *tuple) { |
| paranoidInsertTypeCheck(*tuple); |
| tuples_.push_back(tuple); |
| return tuples_.size() - 1; |
| } |
| |
| InsertResult insertTuple(const Tuple &tuple) override { |
| FATAL_ERROR("insertTuple() is unimplemented in MockTupleStorageSubBlock."); |
| } |
| |
| bool insertTupleInBatch(const Tuple &tuple) override { |
| FATAL_ERROR("insertTupleInBatch() is unimplemented in MockTupleStorageSubBlock."); |
| } |
| |
| tuple_id bulkInsertTuples(ValueAccessor *accessor) override { |
| FATAL_ERROR("bulkInsertTuples() is unimplemented in MockTupleStorageSubBlock."); |
| } |
| |
| tuple_id bulkInsertTuplesWithRemappedAttributes( |
| const std::vector<attribute_id> &attribute_map, |
| ValueAccessor *accessor) override { |
| FATAL_ERROR("bulkInsertTuplesWithRemappedAttributes() is unimplemented in MockTupleStorageSubBlock."); |
| } |
| |
| const void* getAttributeValue(const tuple_id tuple, const attribute_id attr) const override { |
| DEBUG_ASSERT(hasTupleWithID(tuple)); |
| DEBUG_ASSERT(relation_.hasAttributeWithId(attr)); |
| if (tuples_.at(tuple).getAttributeValue(attr).isNull()) { |
| return NULL; |
| } else { |
| return tuples_.at(tuple).getAttributeValue(attr).getDataPtr(); |
| } |
| } |
| |
| TypedValue getAttributeValueTyped(const tuple_id tuple, const attribute_id attr) const override { |
| DEBUG_ASSERT(hasTupleWithID(tuple)); |
| DEBUG_ASSERT(relation_.hasAttributeWithId(attr)); |
| return tuples_.at(tuple).getAttributeValue(attr).makeReferenceToThis(); |
| } |
| |
| ValueAccessor* createValueAccessor(const TupleIdSequence *sequence = nullptr) const override { |
| FATAL_ERROR("createValueAccessor() is unimplemented in MockTupleStorageSubBlock."); |
| } |
| |
| bool canSetAttributeValuesInPlaceTyped( |
| const tuple_id tuple, |
| const std::unordered_map<attribute_id, TypedValue> &new_values) const override { |
| return false; |
| } |
| |
| void setAttributeValueInPlaceTyped(const tuple_id tuple, |
| const attribute_id attr, |
| const TypedValue &value) override { |
| FATAL_ERROR("setAttributeValueInPlaceTyped() is unimplemented in MockTupleStorageSubBlock."); |
| } |
| |
| bool deleteTuple(const tuple_id tuple) override { |
| DEBUG_ASSERT(hasTupleWithID(tuple)); |
| tuples_.deleteElement(tuple); |
| packed_ = false; |
| return false; |
| } |
| |
| bool bulkDeleteTuples(TupleIdSequence *tuples) override { |
| for (TupleIdSequence::const_iterator it = tuples->begin(); |
| it != tuples->end(); |
| ++it) { |
| deleteTuple(*it); |
| } |
| return false; |
| } |
| |
| predicate_cost_t estimatePredicateEvaluationCost( |
| const ComparisonPredicate &predicate) const override { |
| return predicate_cost::kRowScan; |
| } |
| |
| void rebuild() override { |
| } |
| |
| bool isInsertOrderPreserving() const override { |
| return false; |
| } |
| |
| private: |
| PtrVector<Tuple, true> tuples_; |
| bool packed_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MockTupleStorageSubBlock); |
| }; |
| |
| /** @} */ |
| |
| } // namespace quickstep |
| |
| #endif // QUICKSTEP_STORAGE_TESTS_MOCK_TUPLE_STORAGE_SUB_BLOCK_HPP_ |