Skip to content

Commit

Permalink
clean
Browse files Browse the repository at this point in the history
  • Loading branch information
@andyfengHKU
andyfengHKU committed Dec 19, 2022
1 parent b7f4657 commit 0bf53d0
Show file tree
Hide file tree
Showing 13 changed files with 160 additions and 223 deletions.
50 changes: 0 additions & 50 deletions src/common/vector/value_vector.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,6 @@ ValueVector::ValueVector(DataType dataType, MemoryManager* memoryManager)
numBytesPerValue = Types::getDataTypeSize(this->dataType);
}

// TODO: remove
void ValueVector::addString(uint32_t pos, char* value, uint64_t len) const {
assert(dataType.typeID == STRING);
auto& entry = ((ku_string_t*)getData())[pos];
Expand Down Expand Up @@ -50,57 +49,8 @@ bool NodeIDVector::discardNull(ValueVector& vector) {
template<typename T>
void ValueVector::setValue(uint32_t pos, T val) {
((T*)valueBuffer.get())[pos] = val;
// throw NotImplementedException("Unimplemented type for SetValue()");
}

//template<>
//void ValueVector::setValue(uint32_t pos, nodeID_t val) {
// ((nodeID_t*)valueBuffer.get())[pos] = val;
//}
//
//template<>
//void ValueVector::setValue(uint32_t pos, bool val) {
// ((bool*)valueBuffer.get())[pos] = val;
//}
//
//template<>
//void ValueVector::setValue(uint32_t pos, int64_t val) {
// ((int64_t *)valueBuffer.get())[pos] = val;
//}
//
//template<>
//void ValueVector::setValue(uint32_t pos, hash_t val) {
// ((hash_t *)valueBuffer.get())[pos] = val;
//}
//
//
//template<>
//void ValueVector::setValue(uint32_t pos, double_t val) {
// ((double_t *)valueBuffer.get())[pos] = val;
//}
//
//
//template<>
//void ValueVector::setValue(uint32_t pos, date_t val) {
// ((date_t*)valueBuffer.get())[pos] = val;
//}
//
//template<>
//void ValueVector::setValue(uint32_t pos, timestamp_t val) {
// ((timestamp_t*)valueBuffer.get())[pos] = val;
//}
//
//template<>
//void ValueVector::setValue(uint32_t pos, interval_t val) {
// ((interval_t*)valueBuffer.get())[pos] = val;
//}
//
//
//template<>
//void ValueVector::setValue(uint32_t pos, string val) {
// addString(pos, val.data(), val.length());
//}

template<>
void ValueVector::setValue(uint32_t pos, string val) {
addString(pos, val.data(), val.length());
Expand Down
15 changes: 15 additions & 0 deletions src/expression_evaluator/base_evaluator.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,21 @@ void BaseExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager* me
for (auto& child : children) {
child->init(resultSet, memoryManager);
}
resolveResultVector(resultSet, memoryManager);
}

void BaseExpressionEvaluator::resolveResultStateFromChildren(
const vector<BaseExpressionEvaluator*>& inputEvaluators) {
for (auto& input : inputEvaluators) {
if (!input->isResultFlat()) {
isResultFlat_ = false;
resultVector->state = input->resultVector->state;
return;
}
}
// All children are flat.
isResultFlat_ = true;
resultVector->state = DataChunkState::getSingleValueDataChunkState();
}

} // namespace evaluator
Expand Down
105 changes: 99 additions & 6 deletions src/expression_evaluator/case_evaluator.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,17 +11,15 @@ void CaseAlternativeEvaluator::init(const ResultSet& resultSet, MemoryManager* m
}

void CaseExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager* memoryManager) {
BaseExpressionEvaluator::init(resultSet, memoryManager);
for (auto& alternativeEvaluator : alternativeEvaluators) {
alternativeEvaluator->init(resultSet, memoryManager);
}
elseEvaluator->init(resultSet, memoryManager);
resultVector = make_shared<ValueVector>(expression->dataType, memoryManager);
resolveResultState();
BaseExpressionEvaluator::init(resultSet, memoryManager);
}

void CaseExpressionEvaluator::evaluate() {
trueMask.reset();
filledMask.reset();
for (auto& alternativeEvaluator : alternativeEvaluators) {
auto whenSelVector = alternativeEvaluator->whenSelVector.get();
auto hasAtLeastOneValue = alternativeEvaluator->whenEvaluator->select(*whenSelVector);
Expand All @@ -35,7 +33,7 @@ void CaseExpressionEvaluator::evaluate() {
} else {
fillSelectedSwitch(*whenSelVector, *thenVector);
}
if (trueMask.count() == resultVector->state->selVector->selectedSize) {
if (filledMask.count() == resultVector->state->selVector->selectedSize) {
return;
}
}
Expand All @@ -56,5 +54,100 @@ unique_ptr<BaseExpressionEvaluator> CaseExpressionEvaluator::clone() {
expression, std::move(clonedAlternativeEvaluators), std::move(elseEvaluator->clone()));
}

void CaseExpressionEvaluator::resolveResultVector(
const ResultSet& resultSet, MemoryManager* memoryManager) {
resultVector = make_shared<ValueVector>(expression->dataType, memoryManager);
vector<BaseExpressionEvaluator*> inputEvaluators;
for (auto& alternative : alternativeEvaluators) {
inputEvaluators.push_back(alternative->whenEvaluator.get());
inputEvaluators.push_back(alternative->thenEvaluator.get());
}
inputEvaluators.push_back(elseEvaluator.get());
resolveResultStateFromChildren(inputEvaluators);
}

template<typename T>
void CaseExpressionEvaluator::fillEntry(sel_t resultPos, const ValueVector& thenVector) {
if (filledMask[resultPos]) {
return;
}
filledMask[resultPos] = true;
auto thenPos =
thenVector.state->isFlat() ? thenVector.state->selVector->selectedPositions[0] : resultPos;
if (thenVector.isNull(thenPos)) {
resultVector->setNull(resultPos, true);
} else {
auto val = thenVector.getValue<T>(thenPos);
resultVector->setValue<T>(resultPos, val);
}
}

void CaseExpressionEvaluator::fillAllSwitch(const ValueVector& thenVector) {
auto typeID = resultVector->dataType.typeID;
switch (typeID) {
case BOOL: {
fillAll<bool>(thenVector);
} break;
case INT64: {
fillAll<int64_t>(thenVector);
} break;
case DOUBLE: {
fillAll<double_t>(thenVector);
} break;
case DATE: {
fillAll<date_t>(thenVector);
} break;
case TIMESTAMP: {
fillAll<timestamp_t>(thenVector);
} break;
case INTERVAL: {
fillAll<interval_t>(thenVector);
} break;
case STRING: {
fillAll<ku_string_t>(thenVector);
} break;
case LIST: {
fillAll<ku_list_t>(thenVector);
} break;
default:
throw NotImplementedException(
"Unimplemented type " + Types::dataTypeToString(typeID) + " for case expression.");
}
}

void CaseExpressionEvaluator::fillSelectedSwitch(
const SelectionVector& selVector, const ValueVector& thenVector) {
auto typeID = resultVector->dataType.typeID;
switch (typeID) {
case BOOL: {
fillSelected<bool>(selVector, thenVector);
} break;
case INT64: {
fillSelected<int64_t>(selVector, thenVector);
} break;
case DOUBLE: {
fillSelected<double_t>(selVector, thenVector);
} break;
case DATE: {
fillSelected<date_t>(selVector, thenVector);
} break;
case TIMESTAMP: {
fillSelected<timestamp_t>(selVector, thenVector);
} break;
case INTERVAL: {
fillSelected<interval_t>(selVector, thenVector);
} break;
case STRING: { // TODO(double check if this is correct)
fillSelected<ku_string_t>(selVector, thenVector);
} break;
case LIST: {
fillSelected<ku_list_t>(selVector, thenVector);
} break;
default:
throw NotImplementedException(
"Unimplemented type " + Types::dataTypeToString(typeID) + " for case expression.");
}
}

} // namespace evaluator
} // namespace kuzu
} // namespace kuzu
15 changes: 10 additions & 5 deletions src/expression_evaluator/function_evaluator.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,14 +11,9 @@ void FunctionExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager
if (expression->dataType.typeID == BOOL) {
selectFunc = ((ScalarFunctionExpression&)*expression).selectFunc;
}
resultVector = make_shared<ValueVector>(expression->dataType, memoryManager);
// if (children.empty()) { // const function, e.g. PI()
// resultVector->state = DataChunkState::getSingleValueDataChunkState();
// }
for (auto& child : children) {
parameters.push_back(child->resultVector);
}
resolveResultState();
}

void FunctionExpressionEvaluator::evaluate() {
Expand All @@ -43,5 +38,15 @@ unique_ptr<BaseExpressionEvaluator> FunctionExpressionEvaluator::clone() {
return make_unique<FunctionExpressionEvaluator>(expression, move(clonedChildren));
}

void FunctionExpressionEvaluator::resolveResultVector(
const ResultSet& resultSet, MemoryManager* memoryManager) {
resultVector = make_shared<ValueVector>(expression->dataType, memoryManager);
vector<BaseExpressionEvaluator*> inputEvaluators;
for (auto& child : children) {
inputEvaluators.push_back(child.get());
}
resolveResultStateFromChildren(inputEvaluators);
}

} // namespace evaluator
} // namespace kuzu
14 changes: 7 additions & 7 deletions src/expression_evaluator/literal_evaluator.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,19 +5,19 @@
namespace kuzu {
namespace evaluator {

void LiteralExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager* memoryManager) {
assert(children.empty());
resultVector = make_shared<ValueVector>(literal->dataType, memoryManager);
ValueVectorUtils::addLiteralToStructuredVector(*resultVector, 0, *literal);
resultVector->state = DataChunkState::getSingleValueDataChunkState();
}

bool LiteralExpressionEvaluator::select(SelectionVector& selVector) {
assert(resultVector->dataType.typeID == BOOL);
auto pos = resultVector->state->selVector->selectedPositions[0];
assert(pos == 0u);
return resultVector->getValue<bool>(pos) && (!resultVector->isNull(pos));
}

void LiteralExpressionEvaluator::resolveResultVector(
const ResultSet& resultSet, MemoryManager* memoryManager) {
resultVector = make_shared<ValueVector>(literal->dataType, memoryManager);
ValueVectorUtils::addLiteralToStructuredVector(*resultVector, 0, *literal);
resultVector->state = DataChunkState::getSingleValueDataChunkState();
}

} // namespace evaluator
} // namespace kuzu
6 changes: 0 additions & 6 deletions src/expression_evaluator/reference_evaluator.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,12 +8,6 @@ inline static bool isTrue(ValueVector& vector, uint64_t pos) {
return !vector.isNull(pos) && vector.getValue<bool>(pos);
}

void ReferenceExpressionEvaluator::init(const ResultSet& resultSet, MemoryManager* memoryManager) {
assert(children.empty());
resultVector =
resultSet.dataChunks[vectorPos.dataChunkPos]->valueVectors[vectorPos.valueVectorPos];
}

bool ReferenceExpressionEvaluator::select(SelectionVector& selVector) {
uint64_t numSelectedValues = 0;
auto selectedBuffer = resultVector->state->selVector->getSelectedPositionsBuffer();
Expand Down
10 changes: 6 additions & 4 deletions src/include/expression_evaluator/base_evaluator.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,7 @@ class BaseExpressionEvaluator {
public:
BaseExpressionEvaluator() = default;
// Leaf evaluators (reference or literal)
BaseExpressionEvaluator(bool isResultFlat) : isResultFlat_{isResultFlat} {}
explicit BaseExpressionEvaluator(bool isResultFlat) : isResultFlat_{isResultFlat} {}

explicit BaseExpressionEvaluator(vector<unique_ptr<BaseExpressionEvaluator>> children)
: children{std::move(children)} {}
Expand All @@ -32,15 +32,17 @@ class BaseExpressionEvaluator {

virtual unique_ptr<BaseExpressionEvaluator> clone() = 0;

protected:
virtual void resolveResultVector(const ResultSet& resultSet, MemoryManager* memoryManager) = 0;

void resolveResultStateFromChildren(const vector<BaseExpressionEvaluator*>& inputEvaluators);

public:
shared_ptr<ValueVector> resultVector;

protected:
bool isResultFlat_;
// Children evaluators
bool isResultFlat_ = true;
vector<unique_ptr<BaseExpressionEvaluator>> children;

};

} // namespace evaluator
Expand Down
Loading

0 comments on commit 0bf53d0

Please sign in to comment.