remove getPositionOfCurrIdx()

kuzudb · Dec 6, 2022 · 9b39143 · 9b39143
1 parent b739582
commit 9b39143
Show file tree

Hide file tree

Showing 107 changed files with 331 additions and 2,503 deletions.
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
diff --git a/src/common/data_chunk/data_chunk_state.cpp b/src/common/data_chunk/data_chunk_state.cpp
@@ -3,9 +3,9 @@
 namespace kuzu {
 namespace common {
 
-shared_ptr<DataChunkState> DataChunkState::getSingleValueDataChunkState() {
-    auto state = make_shared<DataChunkState>(1);
-    state->selVector->selectedSize = 1;
+std::shared_ptr<DataChunkState> DataChunkState::getSingleValueDataChunkState() {
+    auto state = std::make_shared<DataChunkState>(1);
+    state->initOriginalAndSelectedSize(1);
     state->currIdx = 0;
     return state;
 }

diff --git a/src/common/vector/value_vector.cpp b/src/common/vector/value_vector.cpp
@@ -25,29 +25,25 @@ void ValueVector::addString(uint32_t pos, char* value, uint64_t len) const {
 }
 
 bool NodeIDVector::discardNull(ValueVector& vector) {
-    if (vector.state->isFlat()) {
-        return !vector.isNull(vector.state->getPositionOfCurrIdx());
+    if (vector.hasNoNullsGuarantee()) {
+        return true;
     } else {
-        if (vector.hasNoNullsGuarantee()) {
-            return true;
+        auto selectedPos = 0u;
+        if (vector.state->selVector->isUnfiltered()) {
+            vector.state->selVector->resetSelectorToValuePosBuffer();
+            for (auto i = 0u; i < vector.state->selVector->selectedSize; i++) {
+                vector.state->selVector->selectedPositions[selectedPos] = i;
+                selectedPos += !vector.isNull(i);
+            }
         } else {
-            auto selectedPos = 0u;
-            if (vector.state->selVector->isUnfiltered()) {
-                vector.state->selVector->resetSelectorToValuePosBuffer();
-                for (auto i = 0u; i < vector.state->selVector->selectedSize; i++) {
-                    vector.state->selVector->selectedPositions[selectedPos] = i;
-                    selectedPos += !vector.isNull(i);
-                }
-            } else {
-                for (auto i = 0u; i < vector.state->selVector->selectedSize; i++) {
-                    auto pos = vector.state->selVector->selectedPositions[i];
-                    vector.state->selVector->selectedPositions[selectedPos] = pos;
-                    selectedPos += !vector.isNull(pos);
-                }
+            for (auto i = 0u; i < vector.state->selVector->selectedSize; i++) {
+                auto pos = vector.state->selVector->selectedPositions[i];
+                vector.state->selVector->selectedPositions[selectedPos] = pos;
+                selectedPos += !vector.isNull(pos);
             }
-            vector.state->selVector->selectedSize = selectedPos;
-            return selectedPos > 0;
         }
+        vector.state->selVector->selectedSize = selectedPos;
+        return selectedPos > 0;
     }
 }
 

diff --git a/src/expression_evaluator/literal_evaluator.cpp b/src/expression_evaluator/literal_evaluator.cpp
@@ -13,8 +13,8 @@ void LiteralExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager*
 }
 
 bool LiteralExpressionEvaluator::select(SelectionVector& selVector) {
-    assert(resultVector->dataType.typeID == BOOL); // TODO(Guodong): Is this expected here?
-    auto pos = resultVector->state->getPositionOfCurrIdx();
+    assert(resultVector->dataType.typeID == BOOL);
+    auto pos = resultVector->state->selVector->selectedPositions[0];
     assert(pos == 0u);
     return resultVector->getValue<bool>(pos) == true && (!resultVector->isNull(pos));
 }

diff --git a/src/expression_evaluator/reference_evaluator.cpp b/src/expression_evaluator/reference_evaluator.cpp
@@ -16,25 +16,20 @@ void ReferenceExpressionEvaluator::init(const ResultSet& resultSet, MemoryManage
 
 bool ReferenceExpressionEvaluator::select(SelectionVector& selVector) {
     uint64_t numSelectedValues = 0;
-    if (resultVector->state->isFlat()) {
-        auto pos = resultVector->state->getPositionOfCurrIdx();
-        numSelectedValues += isTrue(*resultVector, pos);
+    auto selectedBuffer = resultVector->state->selVector->getSelectedPositionsBuffer();
+    if (resultVector->state->selVector->isUnfiltered()) {
+        for (auto i = 0u; i < resultVector->state->selVector->selectedSize; i++) {
+            selectedBuffer[numSelectedValues] = i;
+            numSelectedValues += isTrue(*resultVector, i);
+        }
     } else {
-        auto selectedBuffer = resultVector->state->selVector->getSelectedPositionsBuffer();
-        if (resultVector->state->selVector->isUnfiltered()) {
-            for (auto i = 0u; i < resultVector->state->selVector->selectedSize; i++) {
-                selectedBuffer[numSelectedValues] = i;
-                numSelectedValues += isTrue(*resultVector, i);
-            }
-        } else {
-            for (auto i = 0u; i < resultVector->state->selVector->selectedSize; i++) {
-                auto pos = resultVector->state->selVector->selectedPositions[i];
-                selectedBuffer[numSelectedValues] = pos;
-                numSelectedValues += isTrue(*resultVector, pos);
-            }
+        for (auto i = 0u; i < resultVector->state->selVector->selectedSize; i++) {
+            auto pos = resultVector->state->selVector->selectedPositions[i];
+            selectedBuffer[numSelectedValues] = pos;
+            numSelectedValues += isTrue(*resultVector, pos);
         }
-        selVector.selectedSize = numSelectedValues;
     }
+    selVector.selectedSize = numSelectedValues;
     return numSelectedValues > 0;
 }
 

diff --git a/src/function/vector_list_operation.cpp b/src/function/vector_list_operation.cpp
@@ -32,35 +32,21 @@ void VectorListOperations::ListCreation(
     auto& childType = parameters[0]->dataType;
     auto numBytesOfListElement = Types::getDataTypeSize(childType);
     auto elements = make_unique<uint8_t[]>(parameters.size() * numBytesOfListElement);
-    if (result.state->isFlat()) {
-        auto pos = result.state->getPositionOfCurrIdx();
+    for (auto selectedPos = 0u; selectedPos < result.state->selVector->selectedSize;
+         ++selectedPos) {
+        auto pos = result.state->selVector->selectedPositions[selectedPos];
         auto& kuList = ((ku_list_t*)result.getData())[pos];
         for (auto paramIdx = 0u; paramIdx < parameters.size(); paramIdx++) {
-            assert(parameters[paramIdx]->state->isFlat());
+            auto paramPos = parameters[paramIdx]->state->isFlat() ?
+                                parameters[paramIdx]->state->selVector->selectedPositions[0] :
+                                pos;
             memcpy(elements.get() + paramIdx * numBytesOfListElement,
-                parameters[paramIdx]->getData() + pos * numBytesOfListElement,
+                parameters[paramIdx]->getData() + paramPos * numBytesOfListElement,
                 numBytesOfListElement);
         }
         ku_list_t tmpList(parameters.size(), (uint64_t)elements.get());
         InMemOverflowBufferUtils::copyListRecursiveIfNested(
             tmpList, kuList, result.dataType, result.getOverflowBuffer());
-    } else {
-        for (auto selectedPos = 0u; selectedPos < result.state->selVector->selectedSize;
-             ++selectedPos) {
-            auto pos = result.state->selVector->selectedPositions[selectedPos];
-            auto& kuList = ((ku_list_t*)result.getData())[pos];
-            for (auto paramIdx = 0u; paramIdx < parameters.size(); paramIdx++) {
-                auto parameterPos = parameters[paramIdx]->state->isFlat() ?
-                                        parameters[paramIdx]->state->getPositionOfCurrIdx() :
-                                        pos;
-                memcpy(elements.get() + paramIdx * numBytesOfListElement,
-                    parameters[paramIdx]->getData() + parameterPos * numBytesOfListElement,
-                    numBytesOfListElement);
-            }
-            ku_list_t tmpList(parameters.size(), (uint64_t)elements.get());
-            InMemOverflowBufferUtils::copyListRecursiveIfNested(
-                tmpList, kuList, result.dataType, result.getOverflowBuffer());
-        }
     }
 }
 

diff --git a/src/include/common/data_chunk/data_chunk_state.h b/src/include/common/data_chunk/data_chunk_state.h
@@ -1,74 +1,29 @@
 #pragma once
 
 #include <cstring>
-#include <memory>
 #include <vector>
 
-#include "common/configs.h"
-#include "common/types/types.h"
-
-using namespace std;
+#include "common/data_chunk/sel_vector.h"
 
 namespace kuzu {
 namespace common {
 
-class SelectionVector {
-public:
-    explicit SelectionVector(sel_t capacity) : selectedSize{0} {
-        selectedPositionsBuffer = make_unique<sel_t[]>(capacity);
-        resetSelectorToUnselected();
-    }
-
-    inline bool isUnfiltered() const {
-        return selectedPositions == (sel_t*)&INCREMENTAL_SELECTED_POS;
-    }
-    inline void resetSelectorToUnselected() {
-        selectedPositions = (sel_t*)&INCREMENTAL_SELECTED_POS;
-    }
-    inline void resetSelectorToUnselectedWithSize(sel_t size) {
-        selectedPositions = (sel_t*)&INCREMENTAL_SELECTED_POS;
-        selectedSize = size;
-    }
-    inline void resetSelectorToValuePosBuffer() {
-        selectedPositions = selectedPositionsBuffer.get();
-    }
-    inline void resetSelectorToValuePosBufferWithSize(sel_t size) {
-        selectedPositions = selectedPositionsBuffer.get();
-        selectedSize = size;
-    }
-    inline sel_t* getSelectedPositionsBuffer() { return selectedPositionsBuffer.get(); }
-
-    static const sel_t INCREMENTAL_SELECTED_POS[DEFAULT_VECTOR_CAPACITY];
-
-public:
-    sel_t* selectedPositions;
-    sel_t selectedSize;
-
-private:
-    unique_ptr<sel_t[]> selectedPositionsBuffer;
-};
-
 class DataChunkState {
 
 public:
     DataChunkState() : DataChunkState(DEFAULT_VECTOR_CAPACITY) {}
     explicit DataChunkState(uint64_t capacity) : currIdx{-1}, originalSize{0} {
-        selVector = make_unique<SelectionVector>(capacity);
+        selVector = std::make_shared<SelectionVector>(capacity);
     }
 
     // returns a dataChunkState for vectors holding a single value.
-    static shared_ptr<DataChunkState> getSingleValueDataChunkState();
+    static std::shared_ptr<DataChunkState> getSingleValueDataChunkState();
 
     inline void initOriginalAndSelectedSize(uint64_t size) {
         originalSize = size;
         selVector->selectedSize = size;
     }
     inline bool isFlat() const { return currIdx != -1; }
-    inline bool isCurrIdxLast() const { return currIdx == selVector->selectedSize - 1; }
-    inline uint64_t getPositionOfCurrIdx() const {
-        assert(isFlat());
-        return selVector->selectedPositions[currIdx];
-    }
     inline uint64_t getNumSelectedValues() const { return isFlat() ? 1 : selVector->selectedSize; }
 
 public:
@@ -81,7 +36,7 @@ class DataChunkState {
     // has to scan to generate a vector that is consistent with the rest of the vectors in the
     // data chunk.
     uint64_t originalSize;
-    unique_ptr<SelectionVector> selVector;
+    std::shared_ptr<SelectionVector> selVector;
 };
 
 } // namespace common

diff --git a/src/include/common/data_chunk/sel_vector.h b/src/include/common/data_chunk/sel_vector.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+
+#include "common/configs.h"
+#include "common/types/types.h"
+
+namespace kuzu {
+namespace common {
+
+class SelectionVector {
+public:
+    explicit SelectionVector(sel_t capacity) : selectedSize{0} {
+        selectedPositionsBuffer = std::make_unique<sel_t[]>(capacity);
+        resetSelectorToUnselected();
+    }
+
+    inline bool isUnfiltered() const {
+        return selectedPositions == (sel_t*)&INCREMENTAL_SELECTED_POS;
+    }
+    inline void resetSelectorToUnselected() {
+        selectedPositions = (sel_t*)&INCREMENTAL_SELECTED_POS;
+    }
+    inline void resetSelectorToUnselectedWithSize(sel_t size) {
+        selectedPositions = (sel_t*)&INCREMENTAL_SELECTED_POS;
+        selectedSize = size;
+    }
+    inline void resetSelectorToValuePosBuffer() {
+        selectedPositions = selectedPositionsBuffer.get();
+    }
+    inline void resetSelectorToValuePosBufferWithSize(sel_t size) {
+        selectedPositions = selectedPositionsBuffer.get();
+        selectedSize = size;
+    }
+    inline sel_t* getSelectedPositionsBuffer() { return selectedPositionsBuffer.get(); }
+
+    static const sel_t INCREMENTAL_SELECTED_POS[DEFAULT_VECTOR_CAPACITY];
+
+public:
+    sel_t* selectedPositions;
+    sel_t selectedSize;
+
+private:
+    std::unique_ptr<sel_t[]> selectedPositionsBuffer;
+};
+
+} // namespace common
+} // namespace kuzu
diff --git a/src/include/common/vector/value_vector.h b/src/include/common/vector/value_vector.h
@@ -30,12 +30,7 @@ class ValueVector {
     inline void setMayContainNulls() { nullMask->setMayContainNulls(); }
     // Note that if this function returns true, there are no null. However, if it returns false, it
     // doesn't mean there are nulls, i.e., there may or may not be nulls.
-    inline bool hasNoNullsGuarantee() const {
-        // This function should not be used for flat values. For flat values, the null value
-        // of the value should be checked directly.
-        assert(!state->isFlat());
-        return nullMask->hasNoNullsGuarantee();
-    }
+    inline bool hasNoNullsGuarantee() const { return nullMask->hasNoNullsGuarantee(); }
     inline void setRangeNonNull(uint32_t startPos, uint32_t len) {
         for (auto i = 0u; i < len; ++i) {
             setNull(startPos + i, false);

diff --git a/src/include/expression_evaluator/literal_evaluator.h b/src/include/expression_evaluator/literal_evaluator.h
@@ -9,7 +9,7 @@ class LiteralExpressionEvaluator : public BaseExpressionEvaluator {
 
 public:
     LiteralExpressionEvaluator(shared_ptr<Literal> literal)
-        : BaseExpressionEvaluator{}, literal{move(literal)} {}
+        : BaseExpressionEvaluator{}, literal{std::move(literal)} {}
 
     ~LiteralExpressionEvaluator() = default;
 

diff --git a/src/include/function/binary_operation_executor.h b/src/include/function/binary_operation_executor.h
@@ -53,9 +53,9 @@ struct BinaryOperationExecutor {
         typename OP_WRAPPER>
     static void executeBothFlat(ValueVector& left, ValueVector& right, ValueVector& result) {
         result.state = left.state;
-        auto lPos = left.state->getPositionOfCurrIdx();
-        auto rPos = right.state->getPositionOfCurrIdx();
-        auto resPos = result.state->getPositionOfCurrIdx();
+        auto lPos = left.state->selVector->selectedPositions[0];
+        auto rPos = right.state->selVector->selectedPositions[0];
+        auto resPos = result.state->selVector->selectedPositions[0];
         result.setNull(resPos, left.isNull(lPos) || right.isNull(rPos));
         if (!result.isNull(resPos)) {
             executeOnValue<LEFT_TYPE, RIGHT_TYPE, RESULT_TYPE, FUNC, OP_WRAPPER>(
@@ -67,7 +67,7 @@ struct BinaryOperationExecutor {
         typename OP_WRAPPER>
     static void executeFlatUnFlat(ValueVector& left, ValueVector& right, ValueVector& result) {
         result.state = right.state;
-        auto lPos = left.state->getPositionOfCurrIdx();
+        auto lPos = left.state->selVector->selectedPositions[0];
         if (left.isNull(lPos)) {
             result.setAllNull();
         } else if (right.hasNoNullsGuarantee()) {
@@ -109,7 +109,7 @@ struct BinaryOperationExecutor {
         typename OP_WRAPPER>
     static void executeUnFlatFlat(ValueVector& left, ValueVector& right, ValueVector& result) {
         result.state = left.state;
-        auto rPos = right.state->getPositionOfCurrIdx();
+        auto rPos = right.state->selVector->selectedPositions[0];
         if (right.isNull(rPos)) {
             result.setAllNull();
         } else if (left.hasNoNullsGuarantee()) {
@@ -239,8 +239,8 @@ struct BinaryOperationExecutor {
 
     template<class LEFT_TYPE, class RIGHT_TYPE, class FUNC>
     static uint64_t selectBothFlat(ValueVector& left, ValueVector& right) {
-        auto lPos = left.state->getPositionOfCurrIdx();
-        auto rPos = right.state->getPositionOfCurrIdx();
+        auto lPos = left.state->selVector->selectedPositions[0];
+        auto rPos = right.state->selVector->selectedPositions[0];
         uint8_t resultValue = 0;
         if (!left.isNull(lPos) && !right.isNull(rPos)) {
             FUNC::operation(((LEFT_TYPE*)left.getData())[lPos],
@@ -252,7 +252,7 @@ struct BinaryOperationExecutor {
     template<typename LEFT_TYPE, typename RIGHT_TYPE, typename FUNC>
     static bool selectFlatUnFlat(
         ValueVector& left, ValueVector& right, SelectionVector& selVector) {
-        auto lPos = left.state->getPositionOfCurrIdx();
+        auto lPos = left.state->selVector->selectedPositions[0];
         uint64_t numSelectedValues = 0;
         auto selectedPositionsBuffer = selVector.getSelectedPositionsBuffer();
         if (left.isNull(lPos)) {
@@ -295,7 +295,7 @@ struct BinaryOperationExecutor {
     template<typename LEFT_TYPE, typename RIGHT_TYPE, typename FUNC>
     static bool selectUnFlatFlat(
         ValueVector& left, ValueVector& right, SelectionVector& selVector) {
-        auto rPos = right.state->getPositionOfCurrIdx();
+        auto rPos = right.state->selVector->selectedPositions[0];
         uint64_t numSelectedValues = 0;
         auto selectedPositionsBuffer = selVector.getSelectedPositionsBuffer();
         if (right.isNull(rPos)) {