Skip to content

Commit

Permalink
Refactor comparison framework
Browse files Browse the repository at this point in the history
  • Loading branch information
@acquamarin
acquamarin committed Jun 22, 2023
1 parent 3c5f892 commit e954f7f
Show file tree
Hide file tree
Showing 16 changed files with 678 additions and 338 deletions.
1 change: 1 addition & 0 deletions .github/workflows/ci-workflow.yml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,6 +46,7 @@ jobs:
uses: codecov/codecov-action@v3
with:
file: cover.info
functionalities: 'search'

gcc-build-test-with-asan:
name: gcc build & test with asan
Expand Down
209 changes: 0 additions & 209 deletions src/common/type_utils.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -101,214 +101,5 @@ std::string TypeUtils::prefixConversionExceptionMessage(
LogicalTypeUtils::dataTypeToString(dataTypeID) + ".";
}

template<>
bool TypeUtils::isValueEqual(
common::list_entry_t& leftEntry, common::list_entry_t& rightEntry, void* left, void* right) {
auto leftVector = (ValueVector*)left;
auto rightVector = (ValueVector*)right;
if (leftVector->dataType != rightVector->dataType || leftEntry.size != rightEntry.size) {
return false;
}
auto leftDataVector = ListVector::getDataVector(leftVector);
auto rightDataVector = ListVector::getDataVector(rightVector);
for (auto i = 0u; i < leftEntry.size; i++) {
auto leftPos = leftEntry.offset + i;
auto rightPos = rightEntry.offset + i;
if (leftDataVector->isNull(leftPos) && rightDataVector->isNull(rightPos)) {
continue;
} else if (leftDataVector->isNull(leftPos) != rightDataVector->isNull(rightPos)) {
return false;
}
switch (leftDataVector->dataType.getPhysicalType()) {
case PhysicalTypeID::BOOL: {
if (!isValueEqual(leftDataVector->getValue<uint8_t>(leftPos),
rightDataVector->getValue<uint8_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INT64: {
if (!isValueEqual(leftDataVector->getValue<int64_t>(leftPos),
rightDataVector->getValue<int64_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INT32: {
if (!isValueEqual(leftDataVector->getValue<int32_t>(leftPos),
rightDataVector->getValue<int32_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INT16: {
if (!isValueEqual(leftDataVector->getValue<int16_t>(leftPos),
rightDataVector->getValue<int16_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::DOUBLE: {
if (!isValueEqual(leftDataVector->getValue<double_t>(leftPos),
rightDataVector->getValue<double_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::FLOAT: {
if (!isValueEqual(leftDataVector->getValue<float_t>(leftPos),
rightDataVector->getValue<float_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::STRING: {
if (!isValueEqual(leftDataVector->getValue<ku_string_t>(leftPos),
rightDataVector->getValue<ku_string_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INTERVAL: {
if (!isValueEqual(leftDataVector->getValue<interval_t>(leftPos),
rightDataVector->getValue<interval_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INTERNAL_ID: {
if (!isValueEqual(leftDataVector->getValue<internalID_t>(leftPos),
rightDataVector->getValue<internalID_t>(rightPos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::VAR_LIST: {
if (!isValueEqual(leftDataVector->getValue<list_entry_t>(leftPos),
rightDataVector->getValue<list_entry_t>(rightPos), leftDataVector,
rightDataVector)) {
return false;
}
} break;
case PhysicalTypeID::STRUCT: {
if (!isValueEqual(leftDataVector->getValue<struct_entry_t>(leftPos),
rightDataVector->getValue<struct_entry_t>(rightPos), leftDataVector,
rightDataVector)) {
return false;
}
} break;
default: {
throw NotImplementedException("TypeUtils::isValueEqual");
}
}
}
return true;
}

template<>
bool TypeUtils::isValueEqual(common::struct_entry_t& leftEntry, common::struct_entry_t& rightEntry,
void* left, void* right) {
auto leftVector = (ValueVector*)left;
auto rightVector = (ValueVector*)right;
if (leftVector->dataType != rightVector->dataType) {
return false;
}
auto leftStructFields = common::StructVector::getFieldVectors(leftVector);
auto rightStructFields = common::StructVector::getFieldVectors(rightVector);
for (auto i = 0u; i < leftStructFields.size(); i++) {
auto leftStructField = leftStructFields[i];
auto rightStructField = rightStructFields[i];
if (leftStructField->isNull(leftEntry.pos) && rightStructField->isNull(rightEntry.pos)) {
continue;
} else if (leftStructField->isNull(leftEntry.pos) !=
rightStructField->isNull(rightEntry.pos)) {
return false;
}
switch (leftStructFields[i]->dataType.getPhysicalType()) {
case PhysicalTypeID::BOOL: {
if (!isValueEqual(leftStructField->getValue<uint8_t>(leftEntry.pos),
rightStructField->getValue<uint8_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INT64: {
if (!isValueEqual(leftStructField->getValue<int64_t>(leftEntry.pos),
rightStructField->getValue<int64_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INT32: {
if (!isValueEqual(leftStructField->getValue<int32_t>(leftEntry.pos),
rightStructField->getValue<int32_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INT16: {
if (!isValueEqual(leftStructField->getValue<int16_t>(leftEntry.pos),
rightStructField->getValue<int16_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::DOUBLE: {
if (!isValueEqual(leftStructField->getValue<double_t>(leftEntry.pos),
rightStructField->getValue<double_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::FLOAT: {
if (!isValueEqual(leftStructField->getValue<float_t>(leftEntry.pos),
rightStructField->getValue<float_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::STRING: {
if (!isValueEqual(leftStructField->getValue<ku_string_t>(leftEntry.pos),
rightStructField->getValue<ku_string_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INTERVAL: {
if (!isValueEqual(leftStructField->getValue<interval_t>(leftEntry.pos),
rightStructField->getValue<interval_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::INTERNAL_ID: {
if (!isValueEqual(leftStructField->getValue<internalID_t>(leftEntry.pos),
rightStructField->getValue<internalID_t>(rightEntry.pos), nullptr /* left */,
nullptr /* right */)) {
return false;
}
} break;
case PhysicalTypeID::VAR_LIST: {
if (!isValueEqual(leftStructField->getValue<list_entry_t>(leftEntry.pos),
rightStructField->getValue<list_entry_t>(rightEntry.pos), leftStructField.get(),
rightStructField.get())) {
return false;
}
} break;
case PhysicalTypeID::STRUCT: {
if (!isValueEqual(leftStructField->getValue<struct_entry_t>(leftEntry.pos),
rightStructField->getValue<struct_entry_t>(rightEntry.pos),
leftStructField.get(), rightStructField.get())) {
return false;
}
} break;
default: {
throw NotImplementedException("TypeUtils::isValueEqual");
}
}
}
return true;
}

} // namespace common
} // namespace kuzu
2 changes: 2 additions & 0 deletions src/function/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,5 @@
add_subdirectory(comparison)

add_library(kuzu_function
OBJECT
aggregate_function.cpp
Expand Down
7 changes: 7 additions & 0 deletions src/function/comparison/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,7 @@
add_library(kuzu_comparison_function
OBJECT
comparison_operations.cpp)

set(ALL_OBJECT_FILES
${ALL_OBJECT_FILES} $<TARGET_OBJECTS:kuzu_comparison_function>
PARENT_SCOPE)

0 comments on commit e954f7f

Please sign in to comment.