diff --git a/dataset/load-from-test/var_list/bracket_error.csv b/dataset/load-from-test/list/bracket_error.csv similarity index 100% rename from dataset/load-from-test/var_list/bracket_error.csv rename to dataset/load-from-test/list/bracket_error.csv diff --git a/dataset/load-from-test/var_list/change_config.csv b/dataset/load-from-test/list/change_config.csv similarity index 100% rename from dataset/load-from-test/var_list/change_config.csv rename to dataset/load-from-test/list/change_config.csv diff --git a/dataset/load-from-test/var_list/change_config_error.csv b/dataset/load-from-test/list/change_config_error.csv similarity index 100% rename from dataset/load-from-test/var_list/change_config_error.csv rename to dataset/load-from-test/list/change_config_error.csv diff --git a/dataset/load-from-test/var_list/conversion_error.csv b/dataset/load-from-test/list/conversion_error.csv similarity index 100% rename from dataset/load-from-test/var_list/conversion_error.csv rename to dataset/load-from-test/list/conversion_error.csv diff --git a/dataset/load-from-test/var_list/delim_error.csv b/dataset/load-from-test/list/delim_error.csv similarity index 100% rename from dataset/load-from-test/var_list/delim_error.csv rename to dataset/load-from-test/list/delim_error.csv diff --git a/dataset/load-from-test/var_list/quote_error.csv b/dataset/load-from-test/list/quote_error.csv similarity index 100% rename from dataset/load-from-test/var_list/quote_error.csv rename to dataset/load-from-test/list/quote_error.csv diff --git a/dataset/load-from-test/var_list/should_pass.csv b/dataset/load-from-test/list/should_pass.csv similarity index 100% rename from dataset/load-from-test/var_list/should_pass.csv rename to dataset/load-from-test/list/should_pass.csv diff --git a/dataset/load-from-test/var_list/single_quote.csv b/dataset/load-from-test/list/single_quote.csv similarity index 100% rename from dataset/load-from-test/var_list/single_quote.csv rename to dataset/load-from-test/list/single_quote.csv diff --git a/dataset/load-from-test/var_list/single_quote2.csv b/dataset/load-from-test/list/single_quote2.csv similarity index 100% rename from dataset/load-from-test/var_list/single_quote2.csv rename to dataset/load-from-test/list/single_quote2.csv diff --git a/dataset/load-from-test/var_list/single_struct_bracket.csv b/dataset/load-from-test/list/single_struct_bracket.csv similarity index 100% rename from dataset/load-from-test/var_list/single_struct_bracket.csv rename to dataset/load-from-test/list/single_struct_bracket.csv diff --git a/extension/duckdb_scanner/src/duckdb_scan.cpp b/extension/duckdb_scanner/src/duckdb_scan.cpp index 5c248dade5c..095c5086e89 100644 --- a/extension/duckdb_scanner/src/duckdb_scan.cpp +++ b/extension/duckdb_scanner/src/duckdb_scan.cpp @@ -143,7 +143,7 @@ void getDuckDBVectorConversionFunc( case PhysicalTypeID::INTERVAL: { conversion_func = convertDuckDBVectorToVector; } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { conversion_func = convertDuckDBVectorToVector; } break; case PhysicalTypeID::STRUCT: { diff --git a/extension/duckdb_scanner/src/duckdb_type_converter.cpp b/extension/duckdb_scanner/src/duckdb_type_converter.cpp index 2eca69582b1..811dbb4f6d2 100644 --- a/extension/duckdb_scanner/src/duckdb_type_converter.cpp +++ b/extension/duckdb_scanner/src/duckdb_type_converter.cpp @@ -60,7 +60,7 @@ common::LogicalType DuckDBTypeConverter::convertDuckDBType(std::string typeStr) return LogicalType{LogicalTypeID::STRING}; } else if (typeStr.ends_with("[]")) { auto innerType = convertDuckDBType(typeStr.substr(0, typeStr.size() - 2)); - return *LogicalType::VAR_LIST(innerType.copy()); + return *LogicalType::LIST(innerType.copy()); } else if (typeStr.starts_with("STRUCT")) { return *LogicalType::STRUCT(parseStructTypeInfo(typeStr)); } else if (typeStr.starts_with("UNION")) { diff --git a/src/binder/bind/bind_graph_pattern.cpp b/src/binder/bind/bind_graph_pattern.cpp index fd47455422c..099437f92c4 100644 --- a/src/binder/bind/bind_graph_pattern.cpp +++ b/src/binder/bind/bind_graph_pattern.cpp @@ -63,8 +63,8 @@ QueryGraph Binder::bindPatternElement(const PatternElement& patternElement) { static std::unique_ptr getRecursiveRelLogicalType( const LogicalType& nodeType, const LogicalType& relType) { - auto nodesType = LogicalType::VAR_LIST(nodeType.copy()); - auto relsType = LogicalType::VAR_LIST(relType.copy()); + auto nodesType = LogicalType::LIST(nodeType.copy()); + auto relsType = LogicalType::LIST(relType.copy()); std::vector recursiveRelFields; recursiveRelFields.emplace_back(InternalKeyword::NODES, std::move(nodesType)); recursiveRelFields.emplace_back(InternalKeyword::RELS, std::move(relsType)); diff --git a/src/binder/bind/bind_reading_clause.cpp b/src/binder/bind/bind_reading_clause.cpp index f73f2008441..8f1ab1ed256 100644 --- a/src/binder/bind/bind_reading_clause.cpp +++ b/src/binder/bind/bind_reading_clause.cpp @@ -107,9 +107,9 @@ void Binder::rewriteMatchPattern(BoundGraphPattern& boundGraphPattern) { std::unique_ptr Binder::bindUnwindClause(const ReadingClause& readingClause) { auto& unwindClause = ku_dynamic_cast(readingClause); auto boundExpression = expressionBinder.bindExpression(*unwindClause.getExpression()); - ExpressionBinder::validateDataType(*boundExpression, LogicalTypeID::VAR_LIST); + ExpressionBinder::validateDataType(*boundExpression, LogicalTypeID::LIST); auto aliasName = unwindClause.getAlias(); - auto alias = createVariable(aliasName, *VarListType::getChildType(&boundExpression->dataType)); + auto alias = createVariable(aliasName, *ListType::getChildType(&boundExpression->dataType)); std::shared_ptr idExpr = nullptr; if (scope.hasMemorizedTableIDs(boundExpression->getAlias())) { auto tableIDs = scope.getMemorizedTableIDs(boundExpression->getAlias()); diff --git a/src/binder/bind_expression/bind_function_expression.cpp b/src/binder/bind_expression/bind_function_expression.cpp index c67aa059cb1..66ca34e216e 100644 --- a/src/binder/bind_expression/bind_function_expression.cpp +++ b/src/binder/bind_expression/bind_function_expression.cpp @@ -250,7 +250,7 @@ static std::vector> populateLabelValues(std::vector ExpressionBinder::bindLabelFunction(const Expression& expression) { auto catalog = context->getCatalog(); - auto listType = LogicalType::VAR_LIST(LogicalType::STRING()); + auto listType = LogicalType::LIST(LogicalType::STRING()); expression_vector children; switch (expression.getDataType().getLogicalTypeID()) { case LogicalTypeID::NODE: { diff --git a/src/c_api/data_type.cpp b/src/c_api/data_type.cpp index 67f006e360c..6030fae4c0c 100644 --- a/src/c_api/data_type.cpp +++ b/src/c_api/data_type.cpp @@ -26,7 +26,7 @@ kuzu_logical_type* kuzu_data_type_create( auto extraTypeInfo = num_elements_in_array > 0 ? std::make_unique(std::move(child_type_pty), num_elements_in_array) : - std::make_unique(std::move(child_type_pty)); + std::make_unique(std::move(child_type_pty)); data_type = CAPIHelper::createLogicalType(logicalTypeID, std::move(extraTypeInfo)); } c_data_type->_data_type = data_type; diff --git a/src/common/arrow/arrow_array_scan.cpp b/src/common/arrow/arrow_array_scan.cpp index 93c0bc96ec4..9e44af89593 100644 --- a/src/common/arrow/arrow_array_scan.cpp +++ b/src/common/arrow/arrow_array_scan.cpp @@ -155,7 +155,7 @@ static void scanArrowArrayFixedBLOB(const ArrowArray* array, ValueVector& output } template -static void scanArrowArrayVarList(const ArrowSchema* schema, const ArrowArray* array, +static void scanArrowArrayList(const ArrowSchema* schema, const ArrowArray* array, ValueVector& outputVector, ArrowNullMaskTree* mask, uint64_t srcOffset, uint64_t dstOffset, uint64_t count) { auto offsets = ((const offsetsT*)array->buffers[1]) + srcOffset; @@ -177,7 +177,7 @@ static void scanArrowArrayVarList(const ArrowSchema* schema, const ArrowArray* a } template -static void scanArrowArrayVarListView(const ArrowSchema* schema, const ArrowArray* array, +static void scanArrowArrayListView(const ArrowSchema* schema, const ArrowArray* array, ValueVector& outputVector, ArrowNullMaskTree* mask, uint64_t srcOffset, uint64_t dstOffset, uint64_t count) { auto offsets = ((const offsetsT*)array->buffers[1]) + srcOffset; @@ -491,12 +491,12 @@ void ArrowConverter::fromArrowArray(const ArrowSchema* schema, const ArrowArray* return scanArrowArrayRunEndEncoded( schema, array, outputVector, mask, srcOffset, dstOffset, count); case 'l': - // VAR_LIST - return scanArrowArrayVarList( + // LIST + return scanArrowArrayList( schema, array, outputVector, mask, srcOffset, dstOffset, count); case 'L': - // LONG VAR_LIST - return scanArrowArrayVarList( + // LONG LIST + return scanArrowArrayList( schema, array, outputVector, mask, srcOffset, dstOffset, count); case 'w': // FIXED_LIST @@ -525,12 +525,12 @@ void ArrowConverter::fromArrowArray(const ArrowSchema* schema, const ArrowArray* case 'v': switch (arrowType[2]) { case 'l': - return scanArrowArrayVarListView( + return scanArrowArrayListView( schema, array, outputVector, mask, srcOffset, dstOffset, count); case 'L': - return scanArrowArrayVarListView( + return scanArrowArrayListView( schema, array, outputVector, mask, srcOffset, dstOffset, count); - // LONG VAR_LIST VIEW + // LONG LIST VIEW default: KU_UNREACHABLE; } diff --git a/src/common/arrow/arrow_converter.cpp b/src/common/arrow/arrow_converter.cpp index 9b666cdce04..513ae926009 100644 --- a/src/common/arrow/arrow_converter.cpp +++ b/src/common/arrow/arrow_converter.cpp @@ -127,7 +127,7 @@ void ArrowConverter::setArrowFormat( case LogicalTypeID::STRING: { child.format = "u"; } break; - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { child.format = "+l"; child.n_children = 1; rootHolder.nestedChildren.emplace_back(); diff --git a/src/common/arrow/arrow_row_batch.cpp b/src/common/arrow/arrow_row_batch.cpp index 98874ed16a8..bb7280c6d1e 100644 --- a/src/common/arrow/arrow_row_batch.cpp +++ b/src/common/arrow/arrow_row_batch.cpp @@ -48,7 +48,7 @@ void ArrowRowBatch::templateInitializeVector( } template<> -void ArrowRowBatch::templateInitializeVector( +void ArrowRowBatch::templateInitializeVector( ArrowVector* vector, const main::DataTypeInfo& typeInfo, std::int64_t capacity) { initializeNullBits(vector->validity, capacity); KU_ASSERT(typeInfo.childrenTypesInfo.size() == 1); @@ -168,8 +168,8 @@ std::unique_ptr ArrowRowBatch::createVector( case LogicalTypeID::STRING: { templateInitializeVector(result.get(), typeInfo, capacity); } break; - case LogicalTypeID::VAR_LIST: { - templateInitializeVector(result.get(), typeInfo, capacity); + case LogicalTypeID::LIST: { + templateInitializeVector(result.get(), typeInfo, capacity); } break; case LogicalTypeID::ARRAY: { templateInitializeVector(result.get(), typeInfo, capacity); @@ -263,7 +263,7 @@ void ArrowRowBatch::templateCopyNonNullValue( } template<> -void ArrowRowBatch::templateCopyNonNullValue( +void ArrowRowBatch::templateCopyNonNullValue( ArrowVector* vector, const main::DataTypeInfo& typeInfo, Value* value, std::int64_t pos) { vector->data.resize((pos + 2) * sizeof(std::uint32_t)); auto offsets = (std::uint32_t*)vector->data.data(); @@ -277,11 +277,11 @@ void ArrowRowBatch::templateCopyNonNullValue( for (auto i = currentNumBytesForChildValidity; i < numBytesForChildValidity; i++) { vector->childData[0]->validity.data()[i] = 0xFF; // Init each value to be valid (as 1). } - // If vector->childData[0] is a VAR_LIST, its data buffer will be resized when we add a new + // If vector->childData[0] is a LIST, its data buffer will be resized when we add a new // value into it // If vector->childData[0] is an ARRAY, its data buffer is supposed to be empty, // so we don't resize it here - if (typeInfo.childrenTypesInfo[0]->typeID != LogicalTypeID::VAR_LIST && + if (typeInfo.childrenTypesInfo[0]->typeID != LogicalTypeID::LIST && typeInfo.childrenTypesInfo[0]->typeID != LogicalTypeID::ARRAY) { vector->childData[0]->data.resize( numChildElements * storage::StorageUtils::getDataTypeSize( @@ -305,11 +305,11 @@ void ArrowRowBatch::templateCopyNonNullValue( for (auto i = currentNumBytesForChildValidity; i < numBytesForChildValidity; i++) { vector->childData[0]->validity.data()[i] = 0xFF; // Init each value to be valid (as 1). } - // If vector->childData[0] is a VAR_LIST, its data buffer will be resized when we add a new + // If vector->childData[0] is a LIST, its data buffer will be resized when we add a new // value into it // If vector->childData[0] is an ARRAY, its data buffer is supposed to be empty, // so we don't resize it here - if (typeInfo.childrenTypesInfo[0]->typeID != LogicalTypeID::VAR_LIST && + if (typeInfo.childrenTypesInfo[0]->typeID != LogicalTypeID::LIST && typeInfo.childrenTypesInfo[0]->typeID != LogicalTypeID::ARRAY) { vector->childData[0]->data.resize( numChildElements * storage::StorageUtils::getDataTypeSize( @@ -442,8 +442,8 @@ void ArrowRowBatch::copyNonNullValue( case LogicalTypeID::STRING: { templateCopyNonNullValue(vector, typeInfo, value, pos); } break; - case LogicalTypeID::VAR_LIST: { - templateCopyNonNullValue(vector, typeInfo, value, pos); + case LogicalTypeID::LIST: { + templateCopyNonNullValue(vector, typeInfo, value, pos); } break; case LogicalTypeID::ARRAY: { templateCopyNonNullValue(vector, typeInfo, value, pos); @@ -483,7 +483,7 @@ void ArrowRowBatch::templateCopyNullValue( } template<> -void ArrowRowBatch::templateCopyNullValue( +void ArrowRowBatch::templateCopyNullValue( ArrowVector* vector, std::int64_t pos) { auto offsets = (std::uint32_t*)vector->data.data(); offsets[pos + 1] = offsets[pos]; @@ -568,8 +568,8 @@ void ArrowRowBatch::copyNullValue(ArrowVector* vector, Value* value, std::int64_ case LogicalTypeID::STRING: { templateCopyNullValue(vector, pos); } break; - case LogicalTypeID::VAR_LIST: { - templateCopyNullValue(vector, pos); + case LogicalTypeID::LIST: { + templateCopyNullValue(vector, pos); } break; case LogicalTypeID::ARRAY: { templateCopyNullValue(vector, pos); @@ -639,7 +639,7 @@ ArrowArray* ArrowRowBatch::templateCreateArray( } template<> -ArrowArray* ArrowRowBatch::templateCreateArray( +ArrowArray* ArrowRowBatch::templateCreateArray( ArrowVector& vector, const main::DataTypeInfo& typeInfo) { auto result = createArrayFromVector(vector); vector.childPointers.resize(1); @@ -768,8 +768,8 @@ ArrowArray* ArrowRowBatch::convertVectorToArray( case LogicalTypeID::STRING: { return templateCreateArray(vector, typeInfo); } - case LogicalTypeID::VAR_LIST: { - return templateCreateArray(vector, typeInfo); + case LogicalTypeID::LIST: { + return templateCreateArray(vector, typeInfo); } case LogicalTypeID::ARRAY: { return templateCreateArray(vector, typeInfo); diff --git a/src/common/arrow/arrow_type.cpp b/src/common/arrow/arrow_type.cpp index a530e3c0362..a1e4a692609 100644 --- a/src/common/arrow/arrow_type.cpp +++ b/src/common/arrow/arrow_type.cpp @@ -100,7 +100,7 @@ LogicalType ArrowConverter::fromArrowSchema(const ArrowSchema* schema) { // complex types need a complementary ExtraTypeInfo object case 'l': case 'L': - return *LogicalType::VAR_LIST( + return *LogicalType::LIST( std::make_unique(fromArrowSchema(schema->children[0]))); case 'w': throw RuntimeException("Fixed list is currently WIP."); @@ -129,7 +129,7 @@ LogicalType ArrowConverter::fromArrowSchema(const ArrowSchema* schema) { switch (arrowType[2]) { case 'l': case 'L': - return *LogicalType::VAR_LIST( + return *LogicalType::LIST( std::make_unique(fromArrowSchema(schema->children[0]))); default: KU_UNREACHABLE; diff --git a/src/common/type_utils.cpp b/src/common/type_utils.cpp index bc30e8d2292..5c97be92873 100644 --- a/src/common/type_utils.cpp +++ b/src/common/type_utils.cpp @@ -52,7 +52,7 @@ static std::string entryToString( case LogicalTypeID::INTERNAL_ID: return TypeUtils::toString(*reinterpret_cast(value)); case LogicalTypeID::ARRAY: - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: return TypeUtils::toString(*reinterpret_cast(value), valueVector); case LogicalTypeID::MAP: return TypeUtils::toString(*reinterpret_cast(value), valueVector); diff --git a/src/common/types/ku_list.cpp b/src/common/types/ku_list.cpp index f0d530d4d2b..f923339d9b7 100644 --- a/src/common/types/ku_list.cpp +++ b/src/common/types/ku_list.cpp @@ -9,7 +9,7 @@ namespace common { void ku_list_t::set(const uint8_t* values, const LogicalType& dataType) const { memcpy(reinterpret_cast(overflowPtr), values, - size * storage::StorageUtils::getDataTypeSize(*VarListType::getChildType(&dataType))); + size * storage::StorageUtils::getDataTypeSize(*ListType::getChildType(&dataType))); } void ku_list_t::set(const std::vector& parameters, LogicalTypeID childTypeId) { diff --git a/src/common/types/types.cpp b/src/common/types/types.cpp index bb30920ba56..e74732c19d7 100644 --- a/src/common/types/types.cpp +++ b/src/common/types/types.cpp @@ -51,8 +51,8 @@ std::string PhysicalTypeUtils::physicalTypeToString(PhysicalTypeID physicalType) return "STRING"; case PhysicalTypeID::STRUCT: return "STRUCT"; - case PhysicalTypeID::VAR_LIST: - return "VAR_LIST"; + case PhysicalTypeID::LIST: + return "LIST"; case PhysicalTypeID::POINTER: return "POINTER"; default: @@ -96,19 +96,19 @@ uint32_t PhysicalTypeUtils::getFixedTypeSize(PhysicalTypeID physicalType) { } } -bool VarListTypeInfo::operator==(const VarListTypeInfo& other) const { +bool ListTypeInfo::operator==(const ListTypeInfo& other) const { return *childType == *other.childType; } -std::unique_ptr VarListTypeInfo::copy() const { - return std::make_unique(childType->copy()); +std::unique_ptr ListTypeInfo::copy() const { + return std::make_unique(childType->copy()); } -std::unique_ptr VarListTypeInfo::deserialize(Deserializer& deserializer) { - return std::make_unique(LogicalType::deserialize(deserializer)); +std::unique_ptr ListTypeInfo::deserialize(Deserializer& deserializer) { + return std::make_unique(LogicalType::deserialize(deserializer)); } -void VarListTypeInfo::serializeInternal(Serializer& serializer) const { +void ListTypeInfo::serializeInternal(Serializer& serializer) const { childType->serialize(serializer); } @@ -128,7 +128,7 @@ std::unique_ptr ArrayTypeInfo::copy() const { } void ArrayTypeInfo::serializeInternal(Serializer& serializer) const { - VarListTypeInfo::serializeInternal(serializer); + ListTypeInfo::serializeInternal(serializer); serializer.serializeValue(numElements); } @@ -256,7 +256,7 @@ void StructTypeInfo::serializeInternal(Serializer& serializer) const { LogicalType::LogicalType(LogicalTypeID typeID) : typeID{typeID}, extraTypeInfo{nullptr} { physicalType = getPhysicalType(typeID); // Complex types should not use this constructor as they need extra type information - KU_ASSERT(physicalType != PhysicalTypeID::VAR_LIST); + KU_ASSERT(physicalType != PhysicalTypeID::LIST); // Node/Rel types are exempted due to some complex code in bind_graph_pattern.cpp KU_ASSERT(physicalType != PhysicalTypeID::STRUCT || typeID == LogicalTypeID::NODE || typeID == LogicalTypeID::REL || typeID == LogicalTypeID::RECURSIVE_REL); @@ -286,13 +286,13 @@ bool LogicalType::operator==(const LogicalType& other) const { return false; } switch (other.getPhysicalType()) { - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: if (typeID == LogicalTypeID::ARRAY) { return *ku_dynamic_cast(extraTypeInfo.get()) == *ku_dynamic_cast(other.extraTypeInfo.get()); } else { - return *ku_dynamic_cast(extraTypeInfo.get()) == - *ku_dynamic_cast(other.extraTypeInfo.get()); + return *ku_dynamic_cast(extraTypeInfo.get()) == + *ku_dynamic_cast(other.extraTypeInfo.get()); } case PhysicalTypeID::STRUCT: return *ku_dynamic_cast(extraTypeInfo.get()) == @@ -310,14 +310,13 @@ std::string LogicalType::toString() const { switch (typeID) { case LogicalTypeID::MAP: { auto structType = - ku_dynamic_cast(extraTypeInfo.get())->getChildType(); + ku_dynamic_cast(extraTypeInfo.get())->getChildType(); auto fieldTypes = StructType::getFieldTypes(structType); return "MAP(" + fieldTypes[0]->toString() + ": " + fieldTypes[1]->toString() + ")"; } - case LogicalTypeID::VAR_LIST: { - auto varListTypeInfo = - ku_dynamic_cast(extraTypeInfo.get()); - return varListTypeInfo->getChildType()->toString() + "[]"; + case LogicalTypeID::LIST: { + auto listTypeInfo = ku_dynamic_cast(extraTypeInfo.get()); + return listTypeInfo->getChildType()->toString() + "[]"; } case LogicalTypeID::ARRAY: { auto arrayTypeInfo = ku_dynamic_cast(extraTypeInfo.get()); @@ -389,7 +388,7 @@ void LogicalType::serialize(Serializer& serializer) const { serializer.serializeValue(typeID); serializer.serializeValue(physicalType); switch (physicalType) { - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::STRUCT: extraTypeInfo->serialize(serializer); default: @@ -404,11 +403,11 @@ std::unique_ptr LogicalType::deserialize(Deserializer& deserializer deserializer.deserializeValue(physicalType); std::unique_ptr extraTypeInfo; switch (physicalType) { - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { if (typeID == LogicalTypeID::ARRAY) { extraTypeInfo = ArrayTypeInfo::deserialize(deserializer); } else { - extraTypeInfo = VarListTypeInfo::deserialize(deserializer); + extraTypeInfo = ListTypeInfo::deserialize(deserializer); } } break; case PhysicalTypeID::STRUCT: { @@ -519,8 +518,8 @@ PhysicalTypeID LogicalType::getPhysicalType(LogicalTypeID typeID) { } break; case LogicalTypeID::ARRAY: case LogicalTypeID::MAP: - case LogicalTypeID::VAR_LIST: { - return PhysicalTypeID::VAR_LIST; + case LogicalTypeID::LIST: { + return PhysicalTypeID::LIST; } break; case LogicalTypeID::NODE: case LogicalTypeID::REL: @@ -543,7 +542,7 @@ LogicalType LogicalTypeUtils::dataTypeFromString(const std::string& dataTypeStri auto trimmedStr = StringUtils::ltrim(StringUtils::rtrim(dataTypeString)); auto upperDataTypeString = StringUtils::getUpper(trimmedStr); if (upperDataTypeString.ends_with("[]")) { - dataType = *parseVarListType(trimmedStr); + dataType = *parseListType(trimmedStr); } else if (upperDataTypeString.ends_with("]")) { dataType = *parseArrayType(trimmedStr); } else if (upperDataTypeString.starts_with("STRUCT")) { @@ -671,8 +670,8 @@ std::string LogicalTypeUtils::toString(LogicalTypeID dataTypeID) { return "UUID"; case LogicalTypeID::STRING: return "STRING"; - case LogicalTypeID::VAR_LIST: - return "VAR_LIST"; + case LogicalTypeID::LIST: + return "LIST"; case LogicalTypeID::ARRAY: return "ARRAY"; case LogicalTypeID::STRUCT: @@ -722,7 +721,7 @@ uint32_t LogicalTypeUtils::getRowLayoutSize(const LogicalType& type) { case PhysicalTypeID::STRING: { return sizeof(ku_string_t); } - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { return sizeof(ku_list_t); } case PhysicalTypeID::STRUCT: { @@ -766,7 +765,7 @@ bool LogicalTypeUtils::isNested(const LogicalType& dataType) { bool LogicalTypeUtils::isNested(kuzu::common::LogicalTypeID logicalTypeID) { switch (logicalTypeID) { case LogicalTypeID::STRUCT: - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::ARRAY: case LogicalTypeID::UNION: case LogicalTypeID::MAP: @@ -809,7 +808,7 @@ std::vector LogicalTypeUtils::getAllValidLogicTypes() { LogicalTypeID::INT128, LogicalTypeID::DOUBLE, LogicalTypeID::STRING, LogicalTypeID::BLOB, LogicalTypeID::UUID, LogicalTypeID::DATE, LogicalTypeID::TIMESTAMP, LogicalTypeID::TIMESTAMP_NS, LogicalTypeID::TIMESTAMP_MS, LogicalTypeID::TIMESTAMP_SEC, - LogicalTypeID::TIMESTAMP_TZ, LogicalTypeID::INTERVAL, LogicalTypeID::VAR_LIST, + LogicalTypeID::TIMESTAMP_TZ, LogicalTypeID::INTERVAL, LogicalTypeID::LIST, LogicalTypeID::ARRAY, LogicalTypeID::MAP, LogicalTypeID::FLOAT, LogicalTypeID::SERIAL, LogicalTypeID::NODE, LogicalTypeID::REL, LogicalTypeID::STRUCT, LogicalTypeID::UNION, LogicalTypeID::RDF_VARIANT}; @@ -846,8 +845,8 @@ std::vector LogicalTypeUtils::parseStructFields(const std::string& return structFieldsStr; } -std::unique_ptr LogicalTypeUtils::parseVarListType(const std::string& trimmedStr) { - return LogicalType::VAR_LIST(dataTypeFromString(trimmedStr.substr(0, trimmedStr.size() - 2))); +std::unique_ptr LogicalTypeUtils::parseListType(const std::string& trimmedStr) { + return LogicalType::LIST(dataTypeFromString(trimmedStr.substr(0, trimmedStr.size() - 2))); } std::unique_ptr LogicalTypeUtils::parseArrayType(const std::string& trimmedStr) { @@ -938,9 +937,9 @@ std::unique_ptr LogicalType::UNION(std::vector&& field new LogicalType(LogicalTypeID::UNION, std::make_unique(std::move(fields)))); } -std::unique_ptr LogicalType::VAR_LIST(std::unique_ptr childType) { - return std::unique_ptr(new LogicalType( - LogicalTypeID::VAR_LIST, std::make_unique(std::move(childType)))); +std::unique_ptr LogicalType::LIST(std::unique_ptr childType) { + return std::unique_ptr( + new LogicalType(LogicalTypeID::LIST, std::make_unique(std::move(childType)))); } std::unique_ptr LogicalType::MAP( @@ -950,7 +949,7 @@ std::unique_ptr LogicalType::MAP( structFields.emplace_back(InternalKeyword::MAP_VALUE, std::move(valueType)); auto mapStructType = LogicalType::STRUCT(std::move(structFields)); return std::unique_ptr(new LogicalType( - LogicalTypeID::MAP, std::make_unique(std::move(mapStructType)))); + LogicalTypeID::MAP, std::make_unique(std::move(mapStructType)))); } std::unique_ptr LogicalType::ARRAY( diff --git a/src/common/types/value/value.cpp b/src/common/types/value/value.cpp index b56cdcb1d66..8911e70b63f 100644 --- a/src/common/types/value/value.cpp +++ b/src/common/types/value/value.cpp @@ -107,7 +107,7 @@ Value Value::createDefaultValue(const LogicalType& dataType) { return Value(dataType.copy(), std::move(children)); } case LogicalTypeID::MAP: - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { return Value(dataType.copy(), std::vector>{}); } case LogicalTypeID::UNION: { @@ -330,11 +330,11 @@ void Value::copyValueFrom(const uint8_t* value) { strVal = ((ku_string_t*)value)->getAsString(); } break; case LogicalTypeID::MAP: - case LogicalTypeID::VAR_LIST: { - copyFromVarList(*(ku_list_t*)value, *VarListType::getChildType(dataType.get())); + case LogicalTypeID::LIST: { + copyFromList(*(ku_list_t*)value, *ListType::getChildType(dataType.get())); } break; case LogicalTypeID::ARRAY: { - copyFromVarList(*(ku_list_t*)value, *ArrayType::getChildType(dataType.get())); + copyFromList(*(ku_list_t*)value, *ArrayType::getChildType(dataType.get())); } break; case LogicalTypeID::UNION: { copyFromUnion(value); @@ -407,7 +407,7 @@ void Value::copyValueFrom(const Value& other) { case PhysicalTypeID::STRING: { strVal = other.strVal; } break; - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::STRUCT: { for (auto& child : other.children) { children.push_back(child->copy()); @@ -480,7 +480,7 @@ std::string Value::toString() const { case LogicalTypeID::MAP: { return mapToString(); } - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::ARRAY: { return listToString(); } @@ -512,7 +512,7 @@ Value::Value(const LogicalType& dataType_) : isNull_{true} { dataType = dataType_.copy(); } -void Value::copyFromVarList(ku_list_t& list, const LogicalType& childType) { +void Value::copyFromList(ku_list_t& list, const LogicalType& childType) { if (list.size > children.size()) { children.reserve(list.size); for (auto i = children.size(); i < list.size; ++i) { @@ -624,7 +624,7 @@ void Value::serialize(Serializer& serializer) const { case PhysicalTypeID::STRING: { serializer.serializeValue(strVal); } break; - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::STRUCT: { for (auto i = 0u; i < childrenSize; ++i) { children[i]->serialize(serializer); @@ -688,7 +688,7 @@ std::unique_ptr Value::deserialize(Deserializer& deserializer) { case PhysicalTypeID::STRING: { deserializer.deserializeValue(val->strVal); } break; - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::STRUCT: { deserializer.deserializeVectorOfPtrs(val->children); } break; diff --git a/src/common/vector/auxiliary_buffer.cpp b/src/common/vector/auxiliary_buffer.cpp index a31d6f3ca1e..1ce635623a4 100644 --- a/src/common/vector/auxiliary_buffer.cpp +++ b/src/common/vector/auxiliary_buffer.cpp @@ -79,9 +79,8 @@ std::unique_ptr AuxiliaryBufferFactory::getAuxiliaryBuffer( return std::make_unique(memoryManager); case PhysicalTypeID::STRUCT: return std::make_unique(type, memoryManager); - case PhysicalTypeID::VAR_LIST: - return std::make_unique( - *VarListType::getChildType(&type), memoryManager); + case PhysicalTypeID::LIST: + return std::make_unique(*ListType::getChildType(&type), memoryManager); default: return nullptr; } diff --git a/src/common/vector/value_vector.cpp b/src/common/vector/value_vector.cpp index 9b69223dc35..0e45a3c1cf1 100644 --- a/src/common/vector/value_vector.cpp +++ b/src/common/vector/value_vector.cpp @@ -74,7 +74,7 @@ void ValueVector::copyFromRowData(uint32_t pos, const uint8_t* rowData) { case PhysicalTypeID::STRUCT: { StructVector::copyFromRowData(this, pos, rowData); } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { ListVector::copyFromRowData(this, pos, rowData); } break; case PhysicalTypeID::STRING: { @@ -93,7 +93,7 @@ void ValueVector::copyToRowData( case PhysicalTypeID::STRUCT: { StructVector::copyToRowData(this, pos, rowData, rowOverflowBuffer); } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { ListVector::copyToRowData(this, pos, rowData, rowOverflowBuffer); } break; case PhysicalTypeID::STRING: { @@ -113,7 +113,7 @@ void ValueVector::copyFromVectorData( case PhysicalTypeID::STRUCT: { StructVector::copyFromVectorData(this, dstData, srcVector, srcVectorData); } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { ListVector::copyFromVectorData(this, dstData, srcVector, srcVectorData); } break; case PhysicalTypeID::STRING: { @@ -185,7 +185,7 @@ void ValueVector::copyFromValue(uint64_t pos, const Value& value) { StringVector::addString( this, *(ku_string_t*)dstValue, value.strVal.data(), value.strVal.length()); } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { auto listEntry = reinterpret_cast(dstValue); auto numValues = NestedVal::getChildrenSize(&value); *listEntry = ListVector::addList(this, numValues); @@ -259,7 +259,7 @@ std::unique_ptr ValueVector::getAsValue(uint64_t pos) const { case PhysicalTypeID::STRING: { value->strVal = getValue(pos).getAsString(); } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { auto dataVector = ListVector::getDataVector(this); auto listEntry = getValue(pos); std::vector> children; @@ -294,7 +294,7 @@ void ValueVector::resetAuxiliaryBuffer() { ->resetOverflowBuffer(); return; } - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { auto listAuxiliaryBuffer = ku_dynamic_cast(auxiliaryBuffer.get()); listAuxiliaryBuffer->resetSize(); @@ -322,7 +322,7 @@ uint32_t ValueVector::getDataTypeSize(const LogicalType& type) { case PhysicalTypeID::STRUCT: { return sizeof(struct_entry_t); } - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { return sizeof(list_entry_t); } default: { @@ -504,7 +504,7 @@ void StringVector::copyToRowData(const ValueVector* vector, uint32_t pos, uint8_ } void ListVector::copyFromRowData(ValueVector* vector, uint32_t pos, const uint8_t* rowData) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); auto& srcKuList = *(ku_list_t*)rowData; auto srcNullBytes = reinterpret_cast(srcKuList.overflowPtr); auto srcListValues = srcNullBytes + NullBuffer::getNumBytesForNullValues(srcKuList.size); diff --git a/src/function/aggregate/collect.cpp b/src/function/aggregate/collect.cpp index d08295d0b26..c24b7a5e1a0 100644 --- a/src/function/aggregate/collect.cpp +++ b/src/function/aggregate/collect.cpp @@ -81,7 +81,7 @@ std::unique_ptr CollectFunction::bindFunc( KU_ASSERT(arguments.size() == 1); auto aggFuncDefinition = reinterpret_cast(definition); aggFuncDefinition->parameterTypeIDs[0] = arguments[0]->dataType.getLogicalTypeID(); - auto returnType = LogicalType::VAR_LIST(std::make_unique(arguments[0]->dataType)); + auto returnType = LogicalType::LIST(std::make_unique(arguments[0]->dataType)); return std::make_unique(std::move(returnType)); } @@ -89,7 +89,7 @@ function_set CollectFunction::getFunctionSet() { function_set result; for (auto isDistinct : std::vector{true, false}) { result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::ANY}, LogicalTypeID::VAR_LIST, initialize, + std::vector{LogicalTypeID::ANY}, LogicalTypeID::LIST, initialize, updateAll, updatePos, combine, finalize, isDistinct, bindFunc)); } return result; diff --git a/src/function/built_in_function_utils.cpp b/src/function/built_in_function_utils.cpp index b2db1038a94..c836a03c99f 100644 --- a/src/function/built_in_function_utils.cpp +++ b/src/function/built_in_function_utils.cpp @@ -164,7 +164,7 @@ uint32_t BuiltInFunctionsUtils::getTargetTypeCost(LogicalTypeID typeID) { case LogicalTypeID::STRUCT: case LogicalTypeID::MAP: case LogicalTypeID::ARRAY: - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::UNION: return 160; case LogicalTypeID::RDF_VARIANT: @@ -358,7 +358,7 @@ uint32_t BuiltInFunctionsUtils::castFromString(LogicalTypeID inputTypeID) { uint32_t BuiltInFunctionsUtils::castFromRDFVariant(LogicalTypeID inputTypeID) { switch (inputTypeID) { case LogicalTypeID::STRUCT: - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::ARRAY: case LogicalTypeID::UNION: case LogicalTypeID::MAP: diff --git a/src/function/cast/cast_array.cpp b/src/function/cast/cast_array.cpp index 207b58099c0..7d2da8da739 100644 --- a/src/function/cast/cast_array.cpp +++ b/src/function/cast/cast_array.cpp @@ -9,8 +9,8 @@ namespace function { bool CastArrayHelper::checkCompatibleNestedTypes( LogicalTypeID sourceTypeID, LogicalTypeID targetTypeID) { switch (sourceTypeID) { - case LogicalTypeID::VAR_LIST: { - if (targetTypeID == LogicalTypeID::ARRAY || targetTypeID == LogicalTypeID::VAR_LIST) { + case LogicalTypeID::LIST: { + if (targetTypeID == LogicalTypeID::ARRAY || targetTypeID == LogicalTypeID::LIST) { return true; } } @@ -21,7 +21,7 @@ bool CastArrayHelper::checkCompatibleNestedTypes( } } case LogicalTypeID::ARRAY: { - if (targetTypeID == LogicalTypeID::VAR_LIST || targetTypeID == LogicalTypeID::ARRAY) { + if (targetTypeID == LogicalTypeID::LIST || targetTypeID == LogicalTypeID::ARRAY) { return true; } } @@ -32,7 +32,7 @@ bool CastArrayHelper::checkCompatibleNestedTypes( } bool CastArrayHelper::containsListToArray(const LogicalType* srcType, const LogicalType* dstType) { - if ((srcType->getLogicalTypeID() == LogicalTypeID::VAR_LIST || + if ((srcType->getLogicalTypeID() == LogicalTypeID::LIST || srcType->getLogicalTypeID() == LogicalTypeID::ARRAY) && dstType->getLogicalTypeID() == LogicalTypeID::ARRAY) { return true; @@ -40,13 +40,13 @@ bool CastArrayHelper::containsListToArray(const LogicalType* srcType, const Logi if (checkCompatibleNestedTypes(srcType->getLogicalTypeID(), dstType->getLogicalTypeID())) { switch (srcType->getPhysicalType()) { - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { auto srcChildType = (srcType->getLogicalTypeID() == LogicalTypeID::ARRAY) ? ArrayType::getChildType(srcType) : - VarListType::getChildType(srcType); + ListType::getChildType(srcType); auto dstChildType = (dstType->getLogicalTypeID() == LogicalTypeID::ARRAY) ? ArrayType::getChildType(dstType) : - VarListType::getChildType(dstType); + ListType::getChildType(dstType); return containsListToArray(srcChildType, dstChildType); } case PhysicalTypeID::STRUCT: { @@ -79,8 +79,8 @@ void CastArrayHelper::validateListEntry( auto inputType = inputVector->dataType; switch (resultType->getPhysicalType()) { - case PhysicalTypeID::VAR_LIST: { - if (inputType.getPhysicalType() == PhysicalTypeID::VAR_LIST) { + case PhysicalTypeID::LIST: { + if (inputType.getPhysicalType() == PhysicalTypeID::LIST) { if (inputType.getLogicalTypeID() == LogicalTypeID::ARRAY && resultType->getLogicalTypeID() == LogicalTypeID::ARRAY) { if (ArrayType::getNumElements(&inputType) != @@ -90,22 +90,22 @@ void CastArrayHelper::validateListEntry( inputType.toString(), resultType->toString())); } } - if (inputType.getLogicalTypeID() == LogicalTypeID::VAR_LIST && + if (inputType.getLogicalTypeID() == LogicalTypeID::LIST && resultType->getLogicalTypeID() == LogicalTypeID::ARRAY) { auto listEntry = inputVector->getValue(pos); if (listEntry.size != ArrayType::getNumElements(resultType)) { - throw ConversionException{stringFormat( - "Unsupported casting VAR_LIST with incorrect list entry to ARRAY. " - "Expected: {}, Actual: {}.", - ArrayType::getNumElements(resultType), - inputVector->getValue(pos).size)}; + throw ConversionException{ + stringFormat("Unsupported casting LIST with incorrect list entry to ARRAY. " + "Expected: {}, Actual: {}.", + ArrayType::getNumElements(resultType), + inputVector->getValue(pos).size)}; } } auto listEntry = inputVector->getValue(pos); auto inputChildVector = ListVector::getDataVector(inputVector); auto resultChildType = (resultType->getLogicalTypeID() == LogicalTypeID::ARRAY) ? ArrayType::getChildType(resultType) : - VarListType::getChildType(resultType); + ListType::getChildType(resultType); for (auto i = listEntry.offset; i < listEntry.offset + listEntry.size; i++) { validateListEntry(inputChildVector, resultChildType, i); } diff --git a/src/function/cast_from_string_functions.cpp b/src/function/cast_from_string_functions.cpp index 522309b48c6..6d16df66ecc 100644 --- a/src/function/cast_from_string_functions.cpp +++ b/src/function/cast_from_string_functions.cpp @@ -252,7 +252,7 @@ static bool isNull(std::string_view& str) { return false; } -// ---------------------- cast String to Varlist Helper ------------------------------ // +// ---------------------- cast String to List Helper ------------------------------ // struct CountPartOperation { uint64_t count = 0; @@ -883,7 +883,7 @@ void CastString::copyStringToVector( CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, vectorPos, option); } break; case LogicalTypeID::ARRAY: - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { list_entry_t val; CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, vectorPos, option); } break; diff --git a/src/function/comparison_functions.cpp b/src/function/comparison_functions.cpp index 304a7e899e8..c845320bfd4 100644 --- a/src/function/comparison_functions.cpp +++ b/src/function/comparison_functions.cpp @@ -86,7 +86,7 @@ static void executeNestedOperation(uint8_t& result, ValueVector* leftVector, rightVector->getValue(rightPos), result, nullptr /* left */, nullptr /* right */); } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { OP::operation(leftVector->getValue(leftPos), rightVector->getValue(rightPos), result, leftVector, rightVector); } break; diff --git a/src/function/table/call/storage_info.cpp b/src/function/table/call/storage_info.cpp index dba3109a326..d7247d8703e 100644 --- a/src/function/table/call/storage_info.cpp +++ b/src/function/table/call/storage_info.cpp @@ -3,10 +3,10 @@ #include "function/table/bind_input.h" #include "function/table/call_functions.h" #include "storage/storage_manager.h" +#include "storage/store/list_column.h" #include "storage/store/node_table.h" #include "storage/store/string_column.h" #include "storage/store/struct_column.h" -#include "storage/store/var_list_column.h" using namespace kuzu::common; using namespace kuzu::catalog; @@ -85,9 +85,9 @@ struct StorageInfoSharedState final : public CallFuncSharedState { result.push_back(dictionary.getDataColumn()); result.push_back(dictionary.getOffsetColumn()); } break; - case PhysicalTypeID::VAR_LIST: { - auto varListColumn = ku_dynamic_cast(column); - result.push_back(varListColumn->getDataColumn()); + case PhysicalTypeID::LIST: { + auto listColumn = ku_dynamic_cast(column); + result.push_back(listColumn->getDataColumn()); } break; default: { // DO NOTHING. diff --git a/src/function/vector_arithmetic_functions.cpp b/src/function/vector_arithmetic_functions.cpp index c90e614c96f..d7d824e66dc 100644 --- a/src/function/vector_arithmetic_functions.cpp +++ b/src/function/vector_arithmetic_functions.cpp @@ -147,8 +147,7 @@ function_set AddFunction::getFunctionSet() { } // list + list -> list result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::VAR_LIST}, - LogicalTypeID::VAR_LIST, + std::vector{LogicalTypeID::LIST, LogicalTypeID::LIST}, LogicalTypeID::LIST, ScalarFunction::BinaryExecListStructFunction, nullptr, ListConcatFunction::bindFunc, false /* isVarlength*/)); diff --git a/src/function/vector_cast_functions.cpp b/src/function/vector_cast_functions.cpp index 17871fab5df..793527bbd63 100644 --- a/src/function/vector_cast_functions.cpp +++ b/src/function/vector_cast_functions.cpp @@ -21,8 +21,8 @@ static void resolveNestedVector(std::shared_ptr inputVector, ValueV auto inputType = &inputVector->dataType; auto resultType = &resultVector->dataType; while (true) { - if (inputType->getPhysicalType() == PhysicalTypeID::VAR_LIST && - resultType->getPhysicalType() == PhysicalTypeID::VAR_LIST) { + if (inputType->getPhysicalType() == PhysicalTypeID::LIST && + resultType->getPhysicalType() == PhysicalTypeID::LIST) { // copy data and nullmask from input memcpy(resultVector->getData(), inputVector->getData(), numOfEntries * resultVector->getNumBytesPerValue()); @@ -100,8 +100,8 @@ static void nestedTypesCastExecFunction( bool CastFunction::hasImplicitCast(const LogicalType& srcType, const LogicalType& dstType) { // TODO(Jiamin): should remove after support list implicit cast - if (srcType.getLogicalTypeID() == LogicalTypeID::VAR_LIST && - dstType.getLogicalTypeID() == LogicalTypeID::VAR_LIST) { + if (srcType.getLogicalTypeID() == LogicalTypeID::LIST && + dstType.getLogicalTypeID() == LogicalTypeID::LIST) { return false; } if (BuiltInFunctionsUtils::getCastCost( @@ -211,7 +211,7 @@ static std::unique_ptr bindCastFromStringFunction( ScalarFunction::UnaryCastStringExecFunction; } break; case LogicalTypeID::ARRAY: - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { execFunc = ScalarFunction::UnaryCastStringExecFunction; } break; @@ -404,7 +404,7 @@ static std::unique_ptr bindCastToStringFunction( ScalarFunction::UnaryCastExecFunction; } break; case LogicalTypeID::ARRAY: - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { func = ScalarFunction::UnaryCastExecFunction; } break; @@ -570,7 +570,7 @@ template static std::unique_ptr bindCastBetweenNested( const std::string& functionName, LogicalTypeID sourceTypeID, LogicalTypeID targetTypeID) { switch (sourceTypeID) { - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::MAP: case LogicalTypeID::STRUCT: case LogicalTypeID::ARRAY: { @@ -700,7 +700,7 @@ std::unique_ptr CastFunction::bindCastFunction( return bindCastToTimestampFunction( functionName, sourceTypeID, targetTypeID); } - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::ARRAY: case LogicalTypeID::MAP: case LogicalTypeID::STRUCT: { diff --git a/src/function/vector_hash_functions.cpp b/src/function/vector_hash_functions.cpp index f619690184d..b4167363c86 100644 --- a/src/function/vector_hash_functions.cpp +++ b/src/function/vector_hash_functions.cpp @@ -8,7 +8,7 @@ namespace kuzu { namespace function { static std::unique_ptr computeDataVecHash(ValueVector* operand) { - auto hashVector = std::make_unique(*LogicalType::VAR_LIST(LogicalType::HASH())); + auto hashVector = std::make_unique(*LogicalType::LIST(LogicalType::HASH())); auto numValuesInDataVec = ListVector::getDataVectorSize(operand); ListVector::resizeDataVector(hashVector.get(), numValuesInDataVec); auto selectionState = std::make_shared(); @@ -127,7 +127,7 @@ void VectorHashFunction::computeHash(ValueVector* operand, ValueVector* result) case PhysicalTypeID::STRUCT: { computeStructVecHash(operand, result); } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { computeListVectorHash(operand, result); } break; // LCOV_EXCL_START diff --git a/src/function/vector_list_functions.cpp b/src/function/vector_list_functions.cpp index ae384a65777..daf554432e5 100644 --- a/src/function/vector_list_functions.cpp +++ b/src/function/vector_list_functions.cpp @@ -92,7 +92,7 @@ static scalar_func_exec_t getBinaryListExecFuncSwitchRight(const LogicalType& ri execFunc = ScalarFunction::BinaryExecListStructFunction; } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { execFunc = ScalarFunction::BinaryExecListStructFunction; } break; @@ -165,7 +165,7 @@ template static std::unique_ptr bindFuncListAggr( const binder::expression_vector& arguments, Function* function) { auto scalarFunction = ku_dynamic_cast(function); - auto resultType = VarListType::getChildType(&arguments[0]->dataType); + auto resultType = ListType::getChildType(&arguments[0]->dataType); switch (resultType->getLogicalTypeID()) { case LogicalTypeID::SERIAL: case LogicalTypeID::INT64: { @@ -257,7 +257,7 @@ static LogicalType getValidLogicalType(const binder::expression_vector& expressi static std::unique_ptr ListCreationBindFunc( const binder::expression_vector& arguments, Function* /*function*/) { - auto resultType = LogicalType::VAR_LIST(ListCreationFunction::getChildType(arguments).copy()); + auto resultType = LogicalType::LIST(ListCreationFunction::getChildType(arguments).copy()); return std::make_unique(std::move(resultType)); } @@ -286,17 +286,17 @@ LogicalType ListCreationFunction::getChildType(const binder::expression_vector& function_set ListCreationFunction::getFunctionSet() { function_set result; - result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::ANY}, LogicalTypeID::VAR_LIST, execFunc, nullptr, - ListCreationBindFunc, true /* isVarLength */)); + result.push_back( + std::make_unique(name, std::vector{LogicalTypeID::ANY}, + LogicalTypeID::LIST, execFunc, nullptr, ListCreationBindFunc, true /* isVarLength */)); return result; } static std::unique_ptr ListRangeBindFunc( const binder::expression_vector& arguments, Function* /*function*/) { KU_ASSERT(arguments[0]->dataType == arguments[1]->dataType); - auto resultType = LogicalType::VAR_LIST( - std::make_unique(arguments[0]->dataType.getLogicalTypeID())); + auto resultType = + LogicalType::LIST(std::make_unique(arguments[0]->dataType.getLogicalTypeID())); return std::make_unique(std::move(resultType)); } @@ -305,12 +305,12 @@ function_set ListRangeFunction::getFunctionSet() { for (auto typeID : LogicalTypeUtils::getIntegerLogicalTypeIDs()) { // start, end result.push_back(std::make_unique(name, - std::vector{typeID, typeID}, LogicalTypeID::VAR_LIST, + std::vector{typeID, typeID}, LogicalTypeID::LIST, getBinaryListExecFuncSwitchAll(LogicalType{typeID}), nullptr, ListRangeBindFunc, false)); // start, end, step result.push_back(std::make_unique(name, - std::vector{typeID, typeID, typeID}, LogicalTypeID::VAR_LIST, + std::vector{typeID, typeID, typeID}, LogicalTypeID::LIST, getTernaryListExecFuncSwitchAll(LogicalType{typeID}), nullptr, ListRangeBindFunc, false)); } @@ -320,7 +320,7 @@ function_set ListRangeFunction::getFunctionSet() { function_set SizeFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST}, LogicalTypeID::INT64, + std::vector{LogicalTypeID::LIST}, LogicalTypeID::INT64, ScalarFunction::UnaryExecFunction, true /* isVarlength*/)); result.push_back(std::make_unique(alias, std::vector{LogicalTypeID::MAP}, LogicalTypeID::INT64, @@ -341,7 +341,7 @@ static void BinaryExecListExtractFunction(const std::vector ListExtractBindFunc( const binder::expression_vector& arguments, Function* function) { - auto resultType = VarListType::getChildType(&arguments[0]->dataType); + auto resultType = ListType::getChildType(&arguments[0]->dataType); auto scalarFunction = ku_dynamic_cast(function); switch (resultType->getPhysicalType()) { case PhysicalTypeID::BOOL: { @@ -400,7 +400,7 @@ static std::unique_ptr ListExtractBindFunc( scalarFunction->execFunc = BinaryExecListExtractFunction; } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { scalarFunction->execFunc = BinaryExecListExtractFunction; } break; @@ -422,8 +422,8 @@ static std::unique_ptr ListExtractBindFunc( function_set ListExtractFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::INT64}, - LogicalTypeID::ANY, nullptr, nullptr, ListExtractBindFunc, false /* isVarlength*/)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::INT64}, LogicalTypeID::ANY, + nullptr, nullptr, ListExtractBindFunc, false /* isVarlength*/)); result.push_back(std::make_unique(name, std::vector{LogicalTypeID::STRING, LogicalTypeID::INT64}, LogicalTypeID::STRING, @@ -449,14 +449,14 @@ function_set ListConcatFunction::getFunctionSet() { auto execFunc = ScalarFunction::BinaryExecListStructFunction; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::VAR_LIST}, - LogicalTypeID::VAR_LIST, execFunc, nullptr, bindFunc, false /* isVarlength*/)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::LIST}, LogicalTypeID::LIST, + execFunc, nullptr, bindFunc, false /* isVarlength*/)); return result; } static std::unique_ptr ListAppendBindFunc( const binder::expression_vector& arguments, Function* function) { - if (*VarListType::getChildType(&arguments[0]->dataType) != arguments[1]->getDataType()) { + if (*ListType::getChildType(&arguments[0]->dataType) != arguments[1]->getDataType()) { throw BinderException(getListFunctionIncompatibleChildrenTypeErrorMsg( ListAppendFunction::name, arguments[0]->getDataType(), arguments[1]->getDataType())); } @@ -470,15 +470,15 @@ static std::unique_ptr ListAppendBindFunc( function_set ListAppendFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::ANY}, - LogicalTypeID::VAR_LIST, nullptr, nullptr, ListAppendBindFunc, false /* isVarlength*/)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::ANY}, LogicalTypeID::LIST, + nullptr, nullptr, ListAppendBindFunc, false /* isVarlength*/)); return result; } static std::unique_ptr ListPrependBindFunc( const binder::expression_vector& arguments, Function* function) { if (arguments[0]->getDataType().getLogicalTypeID() != LogicalTypeID::ANY && - arguments[1]->dataType != *VarListType::getChildType(&arguments[0]->dataType)) { + arguments[1]->dataType != *ListType::getChildType(&arguments[0]->dataType)) { throw BinderException(getListFunctionIncompatibleChildrenTypeErrorMsg( ListPrependFunction::name, arguments[0]->getDataType(), arguments[1]->getDataType())); } @@ -492,8 +492,8 @@ static std::unique_ptr ListPrependBindFunc( function_set ListPrependFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::ANY}, - LogicalTypeID::VAR_LIST, nullptr, nullptr, ListPrependBindFunc, false /* isVarlength */)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::ANY}, LogicalTypeID::LIST, + nullptr, nullptr, ListPrependBindFunc, false /* isVarlength */)); return result; } @@ -508,8 +508,8 @@ static std::unique_ptr ListPositionBindFunc( function_set ListPositionFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::ANY}, - LogicalTypeID::INT64, nullptr, nullptr, ListPositionBindFunc, false /* isVarlength */)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::ANY}, LogicalTypeID::INT64, + nullptr, nullptr, ListPositionBindFunc, false /* isVarlength */)); return result; } @@ -524,8 +524,8 @@ static std::unique_ptr ListContainsBindFunc( function_set ListContainsFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::ANY}, - LogicalTypeID::BOOL, nullptr, nullptr, ListContainsBindFunc, false /* isVarlength */)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::ANY}, LogicalTypeID::BOOL, + nullptr, nullptr, ListContainsBindFunc, false /* isVarlength */)); return result; } @@ -537,9 +537,8 @@ static std::unique_ptr ListSliceBindFunc( function_set ListSliceFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{ - LogicalTypeID::VAR_LIST, LogicalTypeID::INT64, LogicalTypeID::INT64}, - LogicalTypeID::VAR_LIST, + std::vector{LogicalTypeID::LIST, LogicalTypeID::INT64, LogicalTypeID::INT64}, + LogicalTypeID::LIST, ScalarFunction::TernaryExecListStructFunction, nullptr, ListSliceBindFunc, false /* isVarlength*/)); @@ -575,7 +574,7 @@ static void getListSortExecFunction( static std::unique_ptr ListSortBindFunc( const binder::expression_vector& arguments, Function* function) { auto scalarFunction = ku_dynamic_cast(function); - switch (VarListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { + switch (ListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { case LogicalTypeID::SERIAL: case LogicalTypeID::INT64: { getListSortExecFunction(arguments, scalarFunction->execFunc); @@ -647,15 +646,15 @@ static std::unique_ptr ListSortBindFunc( function_set ListSortFunction::getFunctionSet() { function_set result; result.push_back( - std::make_unique(name, std::vector{LogicalTypeID::VAR_LIST}, - LogicalTypeID::VAR_LIST, nullptr, nullptr, ListSortBindFunc, false /* isVarlength*/)); + std::make_unique(name, std::vector{LogicalTypeID::LIST}, + LogicalTypeID::LIST, nullptr, nullptr, ListSortBindFunc, false /* isVarlength*/)); result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::STRING}, - LogicalTypeID::VAR_LIST, nullptr, nullptr, ListSortBindFunc, false /* isVarlength*/)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::STRING}, LogicalTypeID::LIST, + nullptr, nullptr, ListSortBindFunc, false /* isVarlength*/)); result.push_back(std::make_unique(name, std::vector{ - LogicalTypeID::VAR_LIST, LogicalTypeID::STRING, LogicalTypeID::STRING}, - LogicalTypeID::VAR_LIST, nullptr, nullptr, ListSortBindFunc, false /* isVarlength*/)); + LogicalTypeID::LIST, LogicalTypeID::STRING, LogicalTypeID::STRING}, + LogicalTypeID::LIST, nullptr, nullptr, ListSortBindFunc, false /* isVarlength*/)); return result; } @@ -678,7 +677,7 @@ static void getListReverseSortExecFunction( static std::unique_ptr ListReverseSortBindFunc( const binder::expression_vector& arguments, Function* function) { auto scalarFunction = ku_dynamic_cast(function); - switch (VarListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { + switch (ListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { case LogicalTypeID::SERIAL: case LogicalTypeID::INT64: { getListReverseSortExecFunction(arguments, scalarFunction->execFunc); @@ -750,19 +749,18 @@ static std::unique_ptr ListReverseSortBindFunc( function_set ListReverseSortFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST}, LogicalTypeID::VAR_LIST, nullptr, - nullptr, ListReverseSortBindFunc, false /* isVarlength*/)); + std::vector{LogicalTypeID::LIST}, LogicalTypeID::LIST, nullptr, nullptr, + ListReverseSortBindFunc, false /* isVarlength*/)); result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::STRING}, - LogicalTypeID::VAR_LIST, nullptr, nullptr, ListReverseSortBindFunc, - false /* isVarlength*/)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::STRING}, LogicalTypeID::LIST, + nullptr, nullptr, ListReverseSortBindFunc, false /* isVarlength*/)); return result; } function_set ListSumFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST}, LogicalTypeID::INT64, nullptr, nullptr, + std::vector{LogicalTypeID::LIST}, LogicalTypeID::INT64, nullptr, nullptr, bindFuncListAggr, false /* isVarlength*/)); return result; } @@ -770,7 +768,7 @@ function_set ListSumFunction::getFunctionSet() { function_set ListProductFunction::getFunctionSet() { function_set result; result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST}, LogicalTypeID::INT64, nullptr, nullptr, + std::vector{LogicalTypeID::LIST}, LogicalTypeID::INT64, nullptr, nullptr, bindFuncListAggr, false /* isVarlength*/)); return result; } @@ -778,7 +776,7 @@ function_set ListProductFunction::getFunctionSet() { static std::unique_ptr ListDistinctBindFunc( const binder::expression_vector& arguments, Function* function) { auto scalarFunction = ku_dynamic_cast(function); - switch (VarListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { + switch (ListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { case LogicalTypeID::SERIAL: case LogicalTypeID::INT64: { scalarFunction->execFunc = ScalarFunction::UnaryExecNestedTypeFunction ListDistinctBindFunc( function_set ListDistinctFunction::getFunctionSet() { function_set result; - result.push_back(std::make_unique(name, - std::vector{LogicalTypeID::VAR_LIST}, LogicalTypeID::VAR_LIST, nullptr, - nullptr, ListDistinctBindFunc, false /* isVarlength*/)); + result.push_back( + std::make_unique(name, std::vector{LogicalTypeID::LIST}, + LogicalTypeID::LIST, nullptr, nullptr, ListDistinctBindFunc, false /* isVarlength*/)); return result; } static std::unique_ptr ListUniqueBindFunc( const binder::expression_vector& arguments, Function* function) { auto scalarFunction = ku_dynamic_cast(function); - switch (VarListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { + switch (ListType::getChildType(&arguments[0]->dataType)->getLogicalTypeID()) { case LogicalTypeID::SERIAL: case LogicalTypeID::INT64: { scalarFunction->execFunc = @@ -978,7 +976,7 @@ static std::unique_ptr ListUniqueBindFunc( function_set ListUniqueFunction::getFunctionSet() { function_set result; result.push_back( - std::make_unique(name, std::vector{LogicalTypeID::VAR_LIST}, + std::make_unique(name, std::vector{LogicalTypeID::LIST}, LogicalTypeID::INT64, nullptr, nullptr, ListUniqueBindFunc, false /* isVarlength*/)); return result; } @@ -986,7 +984,7 @@ function_set ListUniqueFunction::getFunctionSet() { static std::unique_ptr ListAnyValueBindFunc( const binder::expression_vector& arguments, Function* function) { auto scalarFunction = ku_dynamic_cast(function); - auto resultType = VarListType::getChildType(&arguments[0]->dataType); + auto resultType = ListType::getChildType(&arguments[0]->dataType); switch (resultType->getLogicalTypeID()) { case LogicalTypeID::SERIAL: case LogicalTypeID::INT64: { @@ -1069,7 +1067,7 @@ static std::unique_ptr ListAnyValueBindFunc( scalarFunction->execFunc = ScalarFunction::UnaryExecNestedTypeFunction; } break; - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { scalarFunction->execFunc = ScalarFunction::UnaryExecNestedTypeFunction; } break; @@ -1087,7 +1085,7 @@ static std::unique_ptr ListAnyValueBindFunc( function_set ListAnyValueFunction::getFunctionSet() { function_set result; result.push_back( - std::make_unique(name, std::vector{LogicalTypeID::VAR_LIST}, + std::make_unique(name, std::vector{LogicalTypeID::LIST}, LogicalTypeID::ANY, nullptr, nullptr, ListAnyValueBindFunc, false /* isVarlength*/)); return result; } @@ -1104,7 +1102,7 @@ static std::unique_ptr ListReverseBindFunc( function_set ListReverseFunction::getFunctionSet() { function_set result; result.push_back( - std::make_unique(name, std::vector{LogicalTypeID::VAR_LIST}, + std::make_unique(name, std::vector{LogicalTypeID::LIST}, LogicalTypeID::ANY, nullptr, nullptr, ListReverseBindFunc, false /* isVarlength*/)); return result; } diff --git a/src/function/vector_map_functions.cpp b/src/function/vector_map_functions.cpp index 5e60733464d..05b4e9b6472 100644 --- a/src/function/vector_map_functions.cpp +++ b/src/function/vector_map_functions.cpp @@ -13,8 +13,8 @@ namespace function { static std::unique_ptr MapCreationBindFunc( const binder::expression_vector& arguments, kuzu::function::Function* /*function*/) { - auto keyType = VarListType::getChildType(&arguments[0]->dataType); - auto valueType = VarListType::getChildType(&arguments[1]->dataType); + auto keyType = ListType::getChildType(&arguments[0]->dataType); + auto valueType = ListType::getChildType(&arguments[1]->dataType); auto resultType = LogicalType::MAP(*keyType, *valueType); return std::make_unique(std::move(resultType)); } @@ -24,8 +24,8 @@ function_set MapCreationFunctions::getFunctionSet() { list_entry_t, MapCreation>; function_set functionSet; functionSet.push_back(make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::VAR_LIST}, - LogicalTypeID::MAP, execFunc, nullptr, MapCreationBindFunc, false /* isVarLength */)); + std::vector{LogicalTypeID::LIST, LogicalTypeID::LIST}, LogicalTypeID::MAP, + execFunc, nullptr, MapCreationBindFunc, false /* isVarLength */)); return functionSet; } @@ -102,7 +102,7 @@ static std::unique_ptr MapExtractBindFunc( scalarFunction->execFunc = ScalarFunction::BinaryExecListStructFunction; } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { scalarFunction->execFunc = ScalarFunction::BinaryExecListStructFunction; } break; @@ -114,21 +114,21 @@ static std::unique_ptr MapExtractBindFunc( KU_UNREACHABLE; } } - return std::make_unique(LogicalType::VAR_LIST( + return std::make_unique(LogicalType::LIST( std::make_unique(*MapType::getValueType(&arguments[0]->dataType)))); } function_set MapExtractFunctions::getFunctionSet() { function_set functionSet; functionSet.push_back(make_unique(name, - std::vector{LogicalTypeID::MAP, LogicalTypeID::ANY}, LogicalTypeID::VAR_LIST, + std::vector{LogicalTypeID::MAP, LogicalTypeID::ANY}, LogicalTypeID::LIST, nullptr, nullptr, MapExtractBindFunc, false /* isVarLength */)); return functionSet; } static std::unique_ptr MapKeysBindFunc( const binder::expression_vector& arguments, kuzu::function::Function* /*function*/) { - return std::make_unique(LogicalType::VAR_LIST( + return std::make_unique(LogicalType::LIST( std::make_unique(*MapType::getKeyType(&arguments[0]->dataType)))); } @@ -138,13 +138,13 @@ function_set MapKeysFunctions::getFunctionSet() { function_set functionSet; functionSet.push_back( make_unique(name, std::vector{LogicalTypeID::MAP}, - LogicalTypeID::VAR_LIST, execFunc, nullptr, MapKeysBindFunc, false /* isVarLength */)); + LogicalTypeID::LIST, execFunc, nullptr, MapKeysBindFunc, false /* isVarLength */)); return functionSet; } static std::unique_ptr MapValuesBindFunc( const binder::expression_vector& arguments, kuzu::function::Function* /*function*/) { - return std::make_unique(LogicalType::VAR_LIST( + return std::make_unique(LogicalType::LIST( std::make_unique(*MapType::getValueType(&arguments[0]->dataType)))); } @@ -152,9 +152,9 @@ function_set MapValuesFunctions::getFunctionSet() { auto execFunc = ScalarFunction::UnaryExecNestedTypeFunction; function_set functionSet; - functionSet.push_back(make_unique(name, - std::vector{LogicalTypeID::MAP}, LogicalTypeID::VAR_LIST, execFunc, nullptr, - MapValuesBindFunc, false /* isVarLength */)); + functionSet.push_back( + make_unique(name, std::vector{LogicalTypeID::MAP}, + LogicalTypeID::LIST, execFunc, nullptr, MapValuesBindFunc, false /* isVarLength */)); return functionSet; } diff --git a/src/function/vector_path_functions.cpp b/src/function/vector_path_functions.cpp index 242a4e83aa4..a3eec3f9655 100644 --- a/src/function/vector_path_functions.cpp +++ b/src/function/vector_path_functions.cpp @@ -53,7 +53,7 @@ static std::unique_ptr PropertiesBindFunc( } auto key = ((binder::LiteralExpression&)*arguments[1]).getValue()->getValue(); auto listType = arguments[0]->getDataType(); - auto childType = VarListType::getChildType(&listType); + auto childType = ListType::getChildType(&listType); struct_field_idx_t fieldIdx; if (childType->getLogicalTypeID() == LogicalTypeID::NODE || childType->getLogicalTypeID() == LogicalTypeID::REL) { @@ -66,14 +66,14 @@ static std::unique_ptr PropertiesBindFunc( stringFormat("Cannot extract properties from {}.", listType.toString())); } auto field = StructType::getField(childType, fieldIdx); - auto returnType = LogicalType::VAR_LIST(field->getType()->copy()); + auto returnType = LogicalType::LIST(field->getType()->copy()); return std::make_unique(std::move(returnType), fieldIdx); } static void PropertiesCompileFunc(FunctionBindData* bindData, const std::vector>& parameters, std::shared_ptr& result) { - KU_ASSERT(parameters[0]->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(parameters[0]->dataType.getPhysicalType() == PhysicalTypeID::LIST); auto propertiesBindData = reinterpret_cast(bindData); auto fieldVector = StructVector::getFieldVector( ListVector::getDataVector(parameters[0].get()), propertiesBindData->childIdx); @@ -111,8 +111,8 @@ static void PropertiesExecFunc(const std::vector>& function_set PropertiesFunction::getFunctionSet() { function_set functions; functions.push_back(make_unique(name, - std::vector{LogicalTypeID::VAR_LIST, LogicalTypeID::STRING}, - LogicalTypeID::ANY, PropertiesExecFunc, nullptr, PropertiesCompileFunc, PropertiesBindFunc, + std::vector{LogicalTypeID::LIST, LogicalTypeID::STRING}, LogicalTypeID::ANY, + PropertiesExecFunc, nullptr, PropertiesCompileFunc, PropertiesBindFunc, false /* isVarLength */)); return functions; } diff --git a/src/function/vector_string_functions.cpp b/src/function/vector_string_functions.cpp index 4e44b326ed4..cdf07f9e81d 100644 --- a/src/function/vector_string_functions.cpp +++ b/src/function/vector_string_functions.cpp @@ -304,14 +304,14 @@ function_set RegexpExtractAllFunction::getFunctionSet() { function_set functionSet; functionSet.emplace_back(make_unique(name, std::vector{LogicalTypeID::STRING, LogicalTypeID::STRING}, - LogicalTypeID::VAR_LIST, + LogicalTypeID::LIST, ScalarFunction::BinaryStringExecFunction, nullptr, bindFunc, false /* isVarLength */)); functionSet.emplace_back(make_unique(name, std::vector{ LogicalTypeID::STRING, LogicalTypeID::STRING, LogicalTypeID::INT64}, - LogicalTypeID::VAR_LIST, + LogicalTypeID::LIST, ScalarFunction::TernaryStringExecFunction, nullptr, bindFunc, false /* isVarLength */)); @@ -320,7 +320,7 @@ function_set RegexpExtractAllFunction::getFunctionSet() { std::unique_ptr RegexpExtractAllFunction::bindFunc( const binder::expression_vector& /*arguments*/, Function* /*definition*/) { - return std::make_unique(LogicalType::VAR_LIST(LogicalType::STRING())); + return std::make_unique(LogicalType::LIST(LogicalType::STRING())); } function_set LevenshteinFunction::getFunctionSet() { diff --git a/src/include/c_api/kuzu.h b/src/include/c_api/kuzu.h index f27677d303c..c1688e11186 100644 --- a/src/include/c_api/kuzu.h +++ b/src/include/c_api/kuzu.h @@ -296,7 +296,7 @@ typedef enum { // variable size types KUZU_STRING = 50, KUZU_BLOB = 51, - KUZU_VAR_LIST = 52, + KUZU_LIST = 52, KUZU_ARRAY = 53, KUZU_STRUCT = 54, KUZU_MAP = 55, @@ -896,8 +896,8 @@ KUZU_C_API void kuzu_value_destroy(kuzu_value* value); */ KUZU_C_API uint64_t kuzu_value_get_list_size(kuzu_value* value); /** - * @brief Returns the element at index of the given value. The value must be of type VAR_LIST. - * @param value The VAR_LIST value to return. + * @brief Returns the element at index of the given value. The value must be of type LIST. + * @param value The LIST value to return. * @param index The index of the element to return. */ KUZU_C_API kuzu_value* kuzu_value_get_list_element(kuzu_value* value, uint64_t index); diff --git a/src/include/common/type_utils.h b/src/include/common/type_utils.h index 0c50619c500..edb5473ace6 100644 --- a/src/include/common/type_utils.h +++ b/src/include/common/type_utils.h @@ -174,7 +174,7 @@ class TypeUtils { case LogicalTypeID::UUID: return func(ku_uuid_t()); case LogicalTypeID::ARRAY: - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: return func(list_entry_t()); case LogicalTypeID::MAP: return func(map_entry_t()); @@ -230,7 +230,7 @@ class TypeUtils { return func(internalID_t()); case PhysicalTypeID::STRING: return func(ku_string_t()); - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: return func(list_entry_t()); case PhysicalTypeID::STRUCT: return func(struct_entry_t()); diff --git a/src/include/common/types/types.h b/src/include/common/types/types.h index 7377701cd02..528e28ba474 100644 --- a/src/include/common/types/types.h +++ b/src/include/common/types/types.h @@ -130,7 +130,7 @@ enum class KUZU_API LogicalTypeID : uint8_t { STRING = 50, BLOB = 51, - VAR_LIST = 52, + LIST = 52, ARRAY = 53, STRUCT = 54, MAP = 55, @@ -161,7 +161,7 @@ enum class PhysicalTypeID : uint8_t { // Variable size types. STRING = 20, - VAR_LIST = 22, + LIST = 22, STRUCT = 23, POINTER = 24, }; @@ -180,13 +180,13 @@ class ExtraTypeInfo { virtual void serializeInternal(Serializer& serializer) const = 0; }; -class VarListTypeInfo : public ExtraTypeInfo { +class ListTypeInfo : public ExtraTypeInfo { public: - VarListTypeInfo() = default; - explicit VarListTypeInfo(std::unique_ptr childType) + ListTypeInfo() = default; + explicit ListTypeInfo(std::unique_ptr childType) : childType{std::move(childType)} {} inline LogicalType* getChildType() const { return childType.get(); } - bool operator==(const VarListTypeInfo& other) const; + bool operator==(const ListTypeInfo& other) const; std::unique_ptr copy() const override; static std::unique_ptr deserialize(Deserializer& deserializer); @@ -198,11 +198,11 @@ class VarListTypeInfo : public ExtraTypeInfo { std::unique_ptr childType; }; -class ArrayTypeInfo : public VarListTypeInfo { +class ArrayTypeInfo : public ListTypeInfo { public: ArrayTypeInfo() = default; explicit ArrayTypeInfo(std::unique_ptr childType, uint64_t numElements) - : VarListTypeInfo{std::move(childType)}, numElements{numElements} {} + : ListTypeInfo{std::move(childType)}, numElements{numElements} {} inline uint64_t getNumElements() const { return numElements; } bool operator==(const ArrayTypeInfo& other) const; static std::unique_ptr deserialize(Deserializer& deserializer); @@ -269,7 +269,7 @@ class StructTypeInfo : public ExtraTypeInfo { class LogicalType { friend class LogicalTypeUtils; friend struct StructType; - friend struct VarListType; + friend struct ListType; friend struct ArrayType; public: @@ -405,10 +405,10 @@ class LogicalType { static KUZU_API std::unique_ptr UNION(std::vector&& fields); - static KUZU_API std::unique_ptr VAR_LIST(std::unique_ptr childType); + static KUZU_API std::unique_ptr LIST(std::unique_ptr childType); template - static inline std::unique_ptr VAR_LIST(T&& childType) { - return LogicalType::VAR_LIST(std::make_unique(std::forward(childType))); + static inline std::unique_ptr LIST(T&& childType) { + return LogicalType::LIST(std::make_unique(std::forward(childType))); } static KUZU_API std::unique_ptr MAP( @@ -443,11 +443,11 @@ class LogicalType { using logical_types_t = std::vector>; using logical_type_vec_t = std::vector; -struct VarListType { +struct ListType { static inline LogicalType* getChildType(const LogicalType* type) { - KU_ASSERT(type->getPhysicalType() == PhysicalTypeID::VAR_LIST); - auto varListTypeInfo = reinterpret_cast(type->extraTypeInfo.get()); - return varListTypeInfo->getChildType(); + KU_ASSERT(type->getPhysicalType() == PhysicalTypeID::LIST); + auto listTypeInfo = reinterpret_cast(type->extraTypeInfo.get()); + return listTypeInfo->getChildType(); } }; @@ -533,12 +533,12 @@ struct StructType { struct MapType { static inline LogicalType* getKeyType(const LogicalType* type) { KU_ASSERT(type->getLogicalTypeID() == LogicalTypeID::MAP); - return StructType::getFieldTypes(VarListType::getChildType(type))[0]; + return StructType::getFieldTypes(ListType::getChildType(type))[0]; } static inline LogicalType* getValueType(const LogicalType* type) { KU_ASSERT(type->getLogicalTypeID() == LogicalTypeID::MAP); - return StructType::getFieldTypes(VarListType::getChildType(type))[1]; + return StructType::getFieldTypes(ListType::getChildType(type))[1]; } }; @@ -590,7 +590,7 @@ class LogicalTypeUtils { private: static LogicalTypeID dataTypeIDFromString(const std::string& trimmedStr); static std::vector parseStructFields(const std::string& structTypeStr); - static std::unique_ptr parseVarListType(const std::string& trimmedStr); + static std::unique_ptr parseListType(const std::string& trimmedStr); static std::unique_ptr parseArrayType(const std::string& trimmedStr); static std::vector parseStructTypeInfo(const std::string& structTypeStr); static std::unique_ptr parseStructType(const std::string& trimmedStr); diff --git a/src/include/common/types/value/value.h b/src/include/common/types/value/value.h index 8b59f60f0c6..90306c02b19 100644 --- a/src/include/common/types/value/value.h +++ b/src/include/common/types/value/value.h @@ -236,7 +236,7 @@ class Value { Value(); explicit Value(const LogicalType& dataType); - void copyFromVarList(ku_list_t& list, const LogicalType& childType); + void copyFromList(ku_list_t& list, const LogicalType& childType); void copyFromStruct(const uint8_t* kuStruct); void copyFromUnion(const uint8_t* kuUnion); diff --git a/src/include/common/vector/value_vector.h b/src/include/common/vector/value_vector.h index a18e4eba843..ef360a48627 100644 --- a/src/include/common/vector/value_vector.h +++ b/src/include/common/vector/value_vector.h @@ -28,7 +28,7 @@ class KUZU_API ValueVector { explicit ValueVector(LogicalType dataType, storage::MemoryManager* memoryManager = nullptr); explicit ValueVector(LogicalTypeID dataTypeID, storage::MemoryManager* memoryManager = nullptr) : ValueVector(LogicalType(dataTypeID), memoryManager) { - KU_ASSERT(dataTypeID != LogicalTypeID::VAR_LIST); + KU_ASSERT(dataTypeID != LogicalTypeID::LIST); } ~ValueVector() = default; @@ -149,43 +149,43 @@ struct KUZU_API BlobVector { class KUZU_API ListVector { public: static void setDataVector(const ValueVector* vector, std::shared_ptr dataVector) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); auto listBuffer = ku_dynamic_cast(vector->auxiliaryBuffer.get()); listBuffer->setDataVector(std::move(dataVector)); } static ValueVector* getDataVector(const ValueVector* vector) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); return ku_dynamic_cast( vector->auxiliaryBuffer.get()) ->getDataVector(); } static std::shared_ptr getSharedDataVector(const ValueVector* vector) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); return ku_dynamic_cast( vector->auxiliaryBuffer.get()) ->getSharedDataVector(); } static uint64_t getDataVectorSize(const ValueVector* vector) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); return ku_dynamic_cast( vector->auxiliaryBuffer.get()) ->getSize(); } static uint8_t* getListValues(const ValueVector* vector, const list_entry_t& listEntry) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); auto dataVector = getDataVector(vector); return dataVector->getData() + dataVector->getNumBytesPerValue() * listEntry.offset; } static uint8_t* getListValuesWithOffset( const ValueVector* vector, const list_entry_t& listEntry, offset_t elementOffsetInList) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); return getListValues(vector, listEntry) + elementOffsetInList * getDataVector(vector)->getNumBytesPerValue(); } static list_entry_t addList(ValueVector* vector, uint64_t listSize) { - KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(vector->dataType.getPhysicalType() == PhysicalTypeID::LIST); return ku_dynamic_cast( vector->auxiliaryBuffer.get()) ->addList(listSize); diff --git a/src/include/function/comparison/vector_comparison_functions.h b/src/include/function/comparison/vector_comparison_functions.h index 3d056821361..61e0c3f112e 100644 --- a/src/include/function/comparison/vector_comparison_functions.h +++ b/src/include/function/comparison/vector_comparison_functions.h @@ -15,8 +15,8 @@ struct ComparisonFunction { for (auto& comparableType : common::LogicalTypeUtils::getAllValidComparableLogicalTypes()) { functionSet.push_back(getFunction(name, comparableType, comparableType)); } - functionSet.push_back(getFunction( - name, common::LogicalTypeID::VAR_LIST, common::LogicalTypeID::VAR_LIST)); + functionSet.push_back( + getFunction(name, common::LogicalTypeID::LIST, common::LogicalTypeID::LIST)); functionSet.push_back( getFunction(name, common::LogicalTypeID::STRUCT, common::LogicalTypeID::STRUCT)); // We can only check whether two internal ids are equal or not. So INTERNAL_ID is not @@ -112,7 +112,7 @@ struct ComparisonFunction { func = BinaryComparisonExecFunction; } break; - case common::PhysicalTypeID::VAR_LIST: { + case common::PhysicalTypeID::LIST: { func = BinaryComparisonExecFunction; } break; @@ -178,7 +178,7 @@ struct ComparisonFunction { case common::PhysicalTypeID::INTERVAL: { func = BinaryComparisonSelectFunction; } break; - case common::PhysicalTypeID::VAR_LIST: { + case common::PhysicalTypeID::LIST: { func = BinaryComparisonSelectFunction; } break; case common::PhysicalTypeID::STRUCT: { diff --git a/src/include/function/list/functions/list_position_function.h b/src/include/function/list/functions/list_position_function.h index 50567a52b35..d47f0558c73 100644 --- a/src/include/function/list/functions/list_position_function.h +++ b/src/include/function/list/functions/list_position_function.h @@ -13,7 +13,7 @@ struct ListPosition { static inline void operation(common::list_entry_t& list, T& element, int64_t& result, common::ValueVector& listVector, common::ValueVector& elementVector, common::ValueVector& /*resultVector*/) { - if (*common::VarListType::getChildType(&listVector.dataType) != elementVector.dataType) { + if (*common::ListType::getChildType(&listVector.dataType) != elementVector.dataType) { result = 0; return; } diff --git a/src/include/function/list/functions/list_range_function.h b/src/include/function/list/functions/list_range_function.h index b7bf9b118a1..6d8be4e96c5 100644 --- a/src/include/function/list/functions/list_range_function.h +++ b/src/include/function/list/functions/list_range_function.h @@ -9,7 +9,7 @@ struct Range { public: // range function: // - include end - // - when start = end: there is only one element in result varlist + // - when start = end: there is only one element in result list // - when end - start are of opposite sign of step, the result will be empty // - default step = 1 template diff --git a/src/include/processor/operator/persistent/reader/parquet/list_column_reader.h b/src/include/processor/operator/persistent/reader/parquet/list_column_reader.h index 1e94f8757df..de3aea6cb05 100644 --- a/src/include/processor/operator/persistent/reader/parquet/list_column_reader.h +++ b/src/include/processor/operator/persistent/reader/parquet/list_column_reader.h @@ -7,7 +7,7 @@ namespace processor { class ListColumnReader : public ColumnReader { public: - static constexpr const common::PhysicalTypeID TYPE = common::PhysicalTypeID::VAR_LIST; + static constexpr const common::PhysicalTypeID TYPE = common::PhysicalTypeID::LIST; public: ListColumnReader(ParquetReader& reader, std::unique_ptr type, diff --git a/src/include/processor/operator/persistent/writer/parquet/var_list_column_writer.h b/src/include/processor/operator/persistent/writer/parquet/list_column_writer.h similarity index 91% rename from src/include/processor/operator/persistent/writer/parquet/var_list_column_writer.h rename to src/include/processor/operator/persistent/writer/parquet/list_column_writer.h index 30a5d1f08fa..ef35460a234 100644 --- a/src/include/processor/operator/persistent/writer/parquet/var_list_column_writer.h +++ b/src/include/processor/operator/persistent/writer/parquet/list_column_writer.h @@ -5,9 +5,9 @@ namespace kuzu { namespace processor { -class VarListColumnWriter : public ColumnWriter { +class ListColumnWriter : public ColumnWriter { public: - VarListColumnWriter(ParquetWriter& writer, uint64_t schemaIdx, std::vector schema, + ListColumnWriter(ParquetWriter& writer, uint64_t schemaIdx, std::vector schema, uint64_t maxRepeat, uint64_t maxDefine, std::unique_ptr childWriter, bool canHaveNulls) : ColumnWriter(writer, schemaIdx, std::move(schema), maxRepeat, maxDefine, canHaveNulls), diff --git a/src/include/storage/storage_utils.h b/src/include/storage/storage_utils.h index 9ac95a005f9..804541f056a 100644 --- a/src/include/storage/storage_utils.h +++ b/src/include/storage/storage_utils.h @@ -65,8 +65,8 @@ class StorageUtils { enum class ColumnType { DEFAULT = 0, INDEX = 1, // This is used for index columns in STRING columns. - OFFSET = 2, // This is used for offset columns in VAR_LIST and STRING columns. - DATA = 3, // This is used for data columns in VAR_LIST and STRING columns. + OFFSET = 2, // This is used for offset columns in LIST and STRING columns. + DATA = 3, // This is used for data columns in LIST and STRING columns. CSR_OFFSET = 4, CSR_LENGTH = 5, STRUCT_CHILD = 6, diff --git a/src/include/storage/store/column.h b/src/include/storage/store/column.h index 657ba8bd933..4ef9eace434 100644 --- a/src/include/storage/store/column.h +++ b/src/include/storage/store/column.h @@ -30,9 +30,9 @@ class NullColumn; class StructColumn; class Column { friend class StringColumn; - friend class VarListLocalColumn; + friend class ListLocalColumn; friend class StructColumn; - friend class VarListColumn; + friend class ListColumn; public: struct ReadState { diff --git a/src/include/storage/store/column_chunk.h b/src/include/storage/store/column_chunk.h index 534e34d88e2..eee12291358 100644 --- a/src/include/storage/store/column_chunk.h +++ b/src/include/storage/store/column_chunk.h @@ -32,7 +32,7 @@ struct ColumnChunkMetadata { class ColumnChunk { public: friend struct ColumnChunkFactory; - friend struct VarListDataColumnChunk; + friend struct ListDataColumnChunk; // ColumnChunks must be initialized after construction, so this constructor should only be used // through the ColumnChunkFactory diff --git a/src/include/storage/store/var_list_column.h b/src/include/storage/store/list_column.h similarity index 95% rename from src/include/storage/store/var_list_column.h rename to src/include/storage/store/list_column.h index 641ef601728..b98e95571a1 100644 --- a/src/include/storage/store/var_list_column.h +++ b/src/include/storage/store/list_column.h @@ -17,7 +17,7 @@ // in-place updates of a list column. In a list column chunk, offsets of lists are not always sorted // after updates. This is good for writes, but it introduces extra overheads for scans, as lists can // be scattered, and scans have to be broken into multiple small reads. To achieve a balance between -// reads and writes, during updates, we rewrite the whole var list column chunk in ascending order +// reads and writes, during updates, we rewrite the whole list column chunk in ascending order // when the offsets are not sorted in ascending order and the size of data column chunk is larger // than half of its capacity. @@ -41,11 +41,11 @@ struct ListOffsetSizeInfo { bool isOffsetSortedAscending(uint64_t startPos, uint64_t endPos) const; }; -class VarListColumn : public Column { - friend class VarListLocalColumn; +class ListColumn : public Column { + friend class ListLocalColumn; public: - VarListColumn(std::string name, common::LogicalType dataType, + ListColumn(std::string name, common::LogicalType dataType, const MetadataDAHInfo& metaDAHeaderInfo, BMFileHandle* dataFH, BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal, transaction::Transaction* transaction, RWPropertyStats propertyStatistics, bool enableCompression); diff --git a/src/include/storage/store/var_list_column_chunk.h b/src/include/storage/store/list_column_chunk.h similarity index 87% rename from src/include/storage/store/var_list_column_chunk.h rename to src/include/storage/store/list_column_chunk.h index 992ca00bbc8..871a4616fff 100644 --- a/src/include/storage/store/var_list_column_chunk.h +++ b/src/include/storage/store/list_column_chunk.h @@ -7,11 +7,11 @@ namespace kuzu { namespace storage { // TODO(Guodong): Let's simplify the data structure here by getting rid of this class. -struct VarListDataColumnChunk { +struct ListDataColumnChunk { std::unique_ptr dataColumnChunk; uint64_t capacity; - explicit VarListDataColumnChunk(std::unique_ptr dataChunk) + explicit ListDataColumnChunk(std::unique_ptr dataChunk) : dataColumnChunk{std::move(dataChunk)}, capacity{this->dataColumnChunk->capacity} {} void reset() const; @@ -25,14 +25,14 @@ struct VarListDataColumnChunk { inline uint64_t getNumValues() const { return dataColumnChunk->getNumValues(); } }; -class VarListColumnChunk final : public ColumnChunk { +class ListColumnChunk final : public ColumnChunk { public: - VarListColumnChunk( + ListColumnChunk( common::LogicalType dataType, uint64_t capacity, bool enableCompression, bool inMemory); inline ColumnChunk* getDataColumnChunk() const { - return varListDataColumnChunk->dataColumnChunk.get(); + return listDataColumnChunk->dataColumnChunk.get(); } inline ColumnChunk* getSizeColumnChunk() const { return sizeColumnChunk.get(); } @@ -60,7 +60,7 @@ class VarListColumnChunk final : public ColumnChunk { common::offset_t dstOffsetInChunk, common::offset_t numValuesToCopy) override; inline void resizeDataColumnChunk(uint64_t numValues) { - varListDataColumnChunk->resizeBuffer(numValues); + listDataColumnChunk->resizeBuffer(numValues); } inline void resize(uint64_t newCapacity) override { @@ -75,7 +75,7 @@ class VarListColumnChunk final : public ColumnChunk { common::list_size_t getListSize(common::offset_t offset) const; void resetOffset(); - void resetFromOtherChunk(VarListColumnChunk* other); + void resetFromOtherChunk(ListColumnChunk* other); void finalize() override; bool isOffsetsConsecutiveAndSortedAscending(uint64_t startPos, uint64_t endPos) const; bool sanityCheck() override; @@ -91,7 +91,7 @@ class VarListColumnChunk final : public ColumnChunk { protected: std::unique_ptr sizeColumnChunk; - std::unique_ptr varListDataColumnChunk; + std::unique_ptr listDataColumnChunk; // we use checkOffsetSortedAsc flag to indicate that we do not trigger random write bool checkOffsetSortedAsc; }; diff --git a/src/main/query_result.cpp b/src/main/query_result.cpp index af96d6038cd..d3cdc47226d 100644 --- a/src/main/query_result.cpp +++ b/src/main/query_result.cpp @@ -23,9 +23,9 @@ std::unique_ptr DataTypeInfo::getInfoForDataType( columnTypeInfo->childrenTypesInfo.push_back( std::make_unique(LogicalTypeID::INT64, "tableID")); } break; - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { auto parentTypeInfo = columnTypeInfo.get(); - auto childType = VarListType::getChildType(&type); + auto childType = ListType::getChildType(&type); parentTypeInfo->childrenTypesInfo.push_back(getInfoForDataType(*childType, "")); } break; case LogicalTypeID::ARRAY: { diff --git a/src/main/storage_driver.cpp b/src/main/storage_driver.cpp index b6930a49319..b4e38a9f271 100644 --- a/src/main/storage_driver.cpp +++ b/src/main/storage_driver.cpp @@ -64,7 +64,7 @@ uint64_t StorageDriver::getNumRels(const std::string& relName) { void StorageDriver::scanColumn(Transaction* transaction, storage::Column* column, offset_t* offsets, size_t size, uint8_t* result) { auto dataType = column->getDataType(); - if (dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST) { + if (dataType.getPhysicalType() == PhysicalTypeID::LIST) { auto resultVector = ValueVector(dataType); for (auto i = 0u; i < size; ++i) { auto nodeOffset = offsets[i]; diff --git a/src/processor/map/map_path_property_probe.cpp b/src/processor/map/map_path_property_probe.cpp index e5f6c4a68b5..9451953a6e9 100644 --- a/src/processor/map/map_path_property_probe.cpp +++ b/src/processor/map/map_path_property_probe.cpp @@ -65,7 +65,7 @@ std::unique_ptr PlanMapper::mapPathPropertyProbe( std::move(nodeBuildInfo), std::move(nodeBuildPrevOperator), getOperatorID(), ""); auto relDataType = rel->getDataType(); auto nodesField = StructType::getField(&relDataType, InternalKeyword::NODES); - auto nodeStructType = VarListType::getChildType(nodesField->getType()); + auto nodeStructType = ListType::getChildType(nodesField->getType()); auto [fieldIndices, columnIndices] = getColIdxToScan(nodePayloads, nodeKeys.size(), *nodeStructType); nodeFieldIndices = std::move(fieldIndices); @@ -92,7 +92,7 @@ std::unique_ptr PlanMapper::mapPathPropertyProbe( std::move(relBuildInfo), std::move(relBuildPrvOperator), getOperatorID(), ""); auto relDataType = rel->getDataType(); auto relsField = StructType::getField(&relDataType, InternalKeyword::RELS); - auto relStructType = VarListType::getChildType(relsField->getType()); + auto relStructType = ListType::getChildType(relsField->getType()); auto [fieldIndices, columnIndices] = getColIdxToScan(relPayloads, relKeys.size(), *relStructType); relFieldIndices = std::move(fieldIndices); diff --git a/src/processor/operator/persistent/copy_to_csv.cpp b/src/processor/operator/persistent/copy_to_csv.cpp index 4d80e982b26..7b242a91f0d 100644 --- a/src/processor/operator/persistent/copy_to_csv.cpp +++ b/src/processor/operator/persistent/copy_to_csv.cpp @@ -167,10 +167,10 @@ void CopyToCSVLocalState::writeRows(CopyToCSVInfo* copyToCsvInfo) { continue; } auto strValue = vector->getValue(pos); - // Note: we need blindly add quotes to VAR_LIST. + // Note: we need blindly add quotes to LIST. writeString(serializer.get(), copyToCsvInfo, strValue.getData(), strValue.len, CopyToCSVConstants::DEFAULT_FORCE_QUOTE || - vectorsToCast[j]->dataType.getLogicalTypeID() == LogicalTypeID::VAR_LIST); + vectorsToCast[j]->dataType.getLogicalTypeID() == LogicalTypeID::LIST); } serializer->writeBufferData(CopyToCSVConstants::DEFAULT_CSV_NEWLINE); } diff --git a/src/processor/operator/persistent/reader/parquet/list_column_reader.cpp b/src/processor/operator/persistent/reader/parquet/list_column_reader.cpp index 50c8e70bb07..18028ae0ddc 100644 --- a/src/processor/operator/persistent/reader/parquet/list_column_reader.cpp +++ b/src/processor/operator/persistent/reader/parquet/list_column_reader.cpp @@ -15,7 +15,7 @@ ListColumnReader::ListColumnReader(ParquetReader& reader, std::unique_ptr( - *common::VarListType::getChildType(this->type.get()), memoryManager); + *common::ListType::getChildType(this->type.get()), memoryManager); } void ListColumnReader::applyPendingSkips(uint64_t numValues) { diff --git a/src/processor/operator/persistent/reader/parquet/parquet_reader.cpp b/src/processor/operator/persistent/reader/parquet/parquet_reader.cpp index ab92d893949..469325fdd6c 100644 --- a/src/processor/operator/persistent/reader/parquet/parquet_reader.cpp +++ b/src/processor/operator/persistent/reader/parquet/parquet_reader.cpp @@ -272,10 +272,10 @@ std::unique_ptr ParquetReader::createReaderRecursive(uint64_t dept // LCOV_EXCL_STOP auto structType = LogicalType::STRUCT(std::move(structFields)); resultType = std::unique_ptr(new LogicalType( - LogicalTypeID::MAP, std::make_unique(std::move(structType)))); + LogicalTypeID::MAP, std::make_unique(std::move(structType)))); auto structReader = std::make_unique(*this, - VarListType::getChildType(resultType.get())->copy(), sEle, thisIdx, maxDefine - 1, + ListType::getChildType(resultType.get())->copy(), sEle, thisIdx, maxDefine - 1, maxRepeat - 1, std::move(childrenReaders)); return std::make_unique(*this, std::move(resultType), sEle, thisIdx, maxDefine, maxRepeat, std::move(structReader), context->getMemoryManager()); @@ -291,7 +291,7 @@ std::unique_ptr ParquetReader::createReaderRecursive(uint64_t dept result = std::move(childrenReaders[0]); } if (isRepeated) { - resultType = LogicalType::VAR_LIST(std::move(resultType)); + resultType = LogicalType::LIST(std::move(resultType)); return std::make_unique(*this, std::move(resultType), sEle, thisIdx, maxDefine, maxRepeat, std::move(result), context->getMemoryManager()); } @@ -305,7 +305,7 @@ std::unique_ptr ParquetReader::createReaderRecursive(uint64_t dept // LCOV_EXCL_STOP if (sEle.repetition_type == FieldRepetitionType::REPEATED) { auto derivedType = deriveLogicalType(sEle); - auto listType = LogicalType::VAR_LIST(derivedType->copy()); + auto listType = LogicalType::LIST(derivedType->copy()); auto elementReader = ColumnReader::createReader( *this, std::move(derivedType), sEle, nextFileIdx++, maxDefine, maxRepeat); return std::make_unique(*this, std::move(listType), sEle, thisIdx, diff --git a/src/processor/operator/persistent/reader/parquet/struct_column_reader.cpp b/src/processor/operator/persistent/reader/parquet/struct_column_reader.cpp index b1d70525aee..87bb3800232 100644 --- a/src/processor/operator/persistent/reader/parquet/struct_column_reader.cpp +++ b/src/processor/operator/persistent/reader/parquet/struct_column_reader.cpp @@ -72,7 +72,7 @@ void StructColumnReader::skip(uint64_t num_values) { static bool TypeHasExactRowCount(const common::LogicalType* type) { switch (type->getLogicalTypeID()) { - case common::LogicalTypeID::VAR_LIST: + case common::LogicalTypeID::LIST: case common::LogicalTypeID::MAP: return false; case common::LogicalTypeID::STRUCT: diff --git a/src/processor/operator/persistent/writer/parquet/CMakeLists.txt b/src/processor/operator/persistent/writer/parquet/CMakeLists.txt index 829581ddd73..b379ed42820 100644 --- a/src/processor/operator/persistent/writer/parquet/CMakeLists.txt +++ b/src/processor/operator/persistent/writer/parquet/CMakeLists.txt @@ -6,7 +6,7 @@ add_library(kuzu_processor_operator_parquet_writer interval_column_writer.cpp struct_column_writer.cpp string_column_writer.cpp - var_list_column_writer.cpp + list_column_writer.cpp parquet_writer.cpp parquet_rle_bp_encoder.cpp) diff --git a/src/processor/operator/persistent/writer/parquet/column_writer.cpp b/src/processor/operator/persistent/writer/parquet/column_writer.cpp index 9b0b0dc6be3..659c426a2e1 100644 --- a/src/processor/operator/persistent/writer/parquet/column_writer.cpp +++ b/src/processor/operator/persistent/writer/parquet/column_writer.cpp @@ -4,11 +4,11 @@ #include "function/cast/functions/numeric_limits.h" #include "processor/operator/persistent/writer/parquet/boolean_column_writer.h" #include "processor/operator/persistent/writer/parquet/interval_column_writer.h" +#include "processor/operator/persistent/writer/parquet/list_column_writer.h" #include "processor/operator/persistent/writer/parquet/parquet_writer.h" #include "processor/operator/persistent/writer/parquet/standard_column_writer.h" #include "processor/operator/persistent/writer/parquet/string_column_writer.h" #include "processor/operator/persistent/writer/parquet/struct_column_writer.h" -#include "processor/operator/persistent/writer/parquet/var_list_column_writer.h" #include "snappy/snappy.h" namespace kuzu { @@ -89,8 +89,8 @@ std::unique_ptr ColumnWriter::createWriterRecursive( std::move(schemaPathToCreate), maxRepeatToCreate, maxDefineToCreate, std::move(childWriters), canHaveNullsToCreate); } - case LogicalTypeID::VAR_LIST: { - auto childType = VarListType::getChildType(type); + case LogicalTypeID::LIST: { + auto childType = ListType::getChildType(type); // Set up the two schema elements for the list // for some reason we only set the converted type in the OPTIONAL element // first an OPTIONAL element. @@ -119,9 +119,8 @@ std::unique_ptr ColumnWriter::createWriterRecursive( auto child_writer = createWriterRecursive(schemas, writer, childType, "element", schemaPathToCreate, mm, maxRepeatToCreate + 1, maxDefineToCreate + 2); - return std::make_unique(writer, schemaIdx, - std::move(schemaPathToCreate), maxRepeatToCreate, maxDefineToCreate, - std::move(child_writer), canHaveNullsToCreate); + return std::make_unique(writer, schemaIdx, std::move(schemaPathToCreate), + maxRepeatToCreate, maxDefineToCreate, std::move(child_writer), canHaveNullsToCreate); } case LogicalTypeID::MAP: { // Maps are stored as follows in parquet: @@ -168,7 +167,7 @@ std::unique_ptr ColumnWriter::createWriterRecursive( auto structWriter = std::make_unique(writer, schemaIdx, schemaPathToCreate, maxRepeatToCreate, maxDefineToCreate, std::move(childrenWriters), canHaveNullsToCreate); - return std::make_unique(writer, schemaIdx, schemaPathToCreate, + return std::make_unique(writer, schemaIdx, schemaPathToCreate, maxRepeatToCreate, maxDefineToCreate, std::move(structWriter), canHaveNullsToCreate); } default: { diff --git a/src/processor/operator/persistent/writer/parquet/var_list_column_writer.cpp b/src/processor/operator/persistent/writer/parquet/list_column_writer.cpp similarity index 86% rename from src/processor/operator/persistent/writer/parquet/var_list_column_writer.cpp rename to src/processor/operator/persistent/writer/parquet/list_column_writer.cpp index 43cd40a5181..b4243f6971c 100644 --- a/src/processor/operator/persistent/writer/parquet/var_list_column_writer.cpp +++ b/src/processor/operator/persistent/writer/parquet/list_column_writer.cpp @@ -1,34 +1,34 @@ -#include "processor/operator/persistent/writer/parquet/var_list_column_writer.h" +#include "processor/operator/persistent/writer/parquet/list_column_writer.h" namespace kuzu { namespace processor { using namespace kuzu_parquet::format; -std::unique_ptr VarListColumnWriter::initializeWriteState( +std::unique_ptr ListColumnWriter::initializeWriteState( kuzu_parquet::format::RowGroup& rowGroup) { auto result = std::make_unique(rowGroup, rowGroup.columns.size()); result->childState = childWriter->initializeWriteState(rowGroup); return result; } -bool VarListColumnWriter::hasAnalyze() { +bool ListColumnWriter::hasAnalyze() { return childWriter->hasAnalyze(); } -void VarListColumnWriter::analyze(ColumnWriterState& writerState, ColumnWriterState* /*parent*/, +void ListColumnWriter::analyze(ColumnWriterState& writerState, ColumnWriterState* /*parent*/, common::ValueVector* vector, uint64_t /*count*/) { auto& state = reinterpret_cast(writerState); childWriter->analyze(*state.childState, &writerState, common::ListVector::getDataVector(vector), common::ListVector::getDataVectorSize(vector)); } -void VarListColumnWriter::finalizeAnalyze(ColumnWriterState& writerState) { +void ListColumnWriter::finalizeAnalyze(ColumnWriterState& writerState) { auto& state = reinterpret_cast(writerState); childWriter->finalizeAnalyze(*state.childState); } -void VarListColumnWriter::prepare(ColumnWriterState& writerState, ColumnWriterState* parent, +void ListColumnWriter::prepare(ColumnWriterState& writerState, ColumnWriterState* parent, common::ValueVector* vector, uint64_t count) { auto& state = reinterpret_cast(writerState); @@ -85,19 +85,19 @@ void VarListColumnWriter::prepare(ColumnWriterState& writerState, ColumnWriterSt common::ListVector::getDataVectorSize(vector)); } -void VarListColumnWriter::beginWrite(ColumnWriterState& state_p) { +void ListColumnWriter::beginWrite(ColumnWriterState& state_p) { auto& state = reinterpret_cast(state_p); childWriter->beginWrite(*state.childState); } -void VarListColumnWriter::write( +void ListColumnWriter::write( ColumnWriterState& writerState, common::ValueVector* vector, uint64_t /*count*/) { auto& state = reinterpret_cast(writerState); childWriter->write(*state.childState, common::ListVector::getDataVector(vector), common::ListVector::getDataVectorSize(vector)); } -void VarListColumnWriter::finalizeWrite(ColumnWriterState& writerState) { +void ListColumnWriter::finalizeWrite(ColumnWriterState& writerState) { auto& state = reinterpret_cast(writerState); childWriter->finalizeWrite(*state.childState); } diff --git a/src/storage/compression/compression.cpp b/src/storage/compression/compression.cpp index 4b2952320b4..76b21f82f05 100644 --- a/src/storage/compression/compression.cpp +++ b/src/storage/compression/compression.cpp @@ -33,7 +33,7 @@ uint32_t getDataTypeSizeInChunk(const common::PhysicalTypeID& dataType) { case PhysicalTypeID::STRING: { return sizeof(uint32_t); } - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::INTERNAL_ID: { return sizeof(offset_t); } @@ -100,7 +100,7 @@ bool CompressionMetadata::canUpdateInPlace( value, BitpackHeader::readHeader(this->data)); } case PhysicalTypeID::INTERNAL_ID: - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::UINT64: { auto value = reinterpret_cast(data)[pos]; return IntegerBitpacking::canUpdateInPlace( @@ -156,7 +156,7 @@ uint64_t CompressionMetadata::numValues(uint64_t pageSize, const LogicalType& da case PhysicalTypeID::INT8: return IntegerBitpacking::numValues(pageSize, BitpackHeader::readHeader(data)); case PhysicalTypeID::INTERNAL_ID: - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::UINT64: return IntegerBitpacking::numValues( pageSize, BitpackHeader::readHeader(data)); @@ -213,7 +213,7 @@ std::optional ConstantCompression::analyze(const ColumnChun } return std::optional(CompressionMetadata(CompressionType::CONSTANT, value)); } - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::STRING: case PhysicalTypeID::INTERNAL_ID: case PhysicalTypeID::DOUBLE: @@ -636,7 +636,7 @@ void ReadCompressedValuesFromPageToVector::operator()(const uint8_t* frame, Page resultVector->getData(), posInVector, numValuesToRead, metadata); } case PhysicalTypeID::INTERNAL_ID: - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::UINT64: { return IntegerBitpacking().decompressFromPage(frame, pageCursor.elemPosInPage, resultVector->getData(), posInVector, numValuesToRead, metadata); @@ -697,7 +697,7 @@ void ReadCompressedValuesFromPage::operator()(const uint8_t* frame, PageCursor& result, startPosInResult, numValuesToRead, metadata); } case PhysicalTypeID::INTERNAL_ID: - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::UINT64: { return IntegerBitpacking().decompressFromPage(frame, pageCursor.elemPosInPage, result, startPosInResult, numValuesToRead, metadata); @@ -759,7 +759,7 @@ void WriteCompressedValuesToPage::operator()(uint8_t* frame, uint16_t posInFrame data, dataOffset, frame, posInFrame, numValues, metadata); } case PhysicalTypeID::INTERNAL_ID: - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::UINT64: { return IntegerBitpacking().setValuesFromUncompressed( data, dataOffset, frame, posInFrame, numValues, metadata); diff --git a/src/storage/stats/property_statistics.cpp b/src/storage/stats/property_statistics.cpp index fb808b30a16..3bdeb096e3e 100644 --- a/src/storage/stats/property_statistics.cpp +++ b/src/storage/stats/property_statistics.cpp @@ -26,7 +26,7 @@ std::unique_ptr PropertyStatistics::deserialize( // overwrite them and invalidate the reference bool RWPropertyStats::mayHaveNull(const transaction::Transaction& transaction) { // Columns internal to the storage, i.e., not mapping to a property in table schema, are not - // tracked in statistics. For example, offset of var list column, csr offset column, etc. + // tracked in statistics. For example, offset of list column, csr offset column, etc. // TODO(Guodong): INVALID_PROPERTY_ID is used here because we have a column, i.e., nbrIDColumn, // not exposed as property in table schema, but still have nullColumn. Should be fixed once we // properly align properties and chunks. diff --git a/src/storage/stats/table_statistics_collection.cpp b/src/storage/stats/table_statistics_collection.cpp index 965765d6f8d..442759245ea 100644 --- a/src/storage/stats/table_statistics_collection.cpp +++ b/src/storage/stats/table_statistics_collection.cpp @@ -96,11 +96,11 @@ std::unique_ptr TablesStatistics::createMetadataDAHInfo( createMetadataDAHInfo(*fields[i]->getType(), metadataFH, bm, wal); } } break; - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { metadataDAHInfo->childrenInfos.push_back( createMetadataDAHInfo(*LogicalType::UINT32(), metadataFH, bm, wal)); metadataDAHInfo->childrenInfos.push_back( - createMetadataDAHInfo(*VarListType::getChildType(&dataType), metadataFH, bm, wal)); + createMetadataDAHInfo(*ListType::getChildType(&dataType), metadataFH, bm, wal)); } break; case PhysicalTypeID::STRING: { auto dataMetadataDAHInfo = std::make_unique(); diff --git a/src/storage/storage_utils.cpp b/src/storage/storage_utils.cpp index baf868a0049..3b01b81b74e 100644 --- a/src/storage/storage_utils.cpp +++ b/src/storage/storage_utils.cpp @@ -86,7 +86,7 @@ uint32_t StorageUtils::getDataTypeSize(PhysicalTypeID type) { case PhysicalTypeID::STRING: { return sizeof(ku_string_t); } - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { return sizeof(ku_list_t); } case PhysicalTypeID::STRUCT: { @@ -104,7 +104,7 @@ uint32_t StorageUtils::getDataTypeSize(const LogicalType& type) { case PhysicalTypeID::STRING: { return sizeof(ku_string_t); } - case PhysicalTypeID::VAR_LIST: { + case PhysicalTypeID::LIST: { return sizeof(ku_list_t); } case PhysicalTypeID::STRUCT: { diff --git a/src/storage/store/CMakeLists.txt b/src/storage/store/CMakeLists.txt index 62de9fd2314..4a03cc5dccc 100644 --- a/src/storage/store/CMakeLists.txt +++ b/src/storage/store/CMakeLists.txt @@ -16,8 +16,8 @@ add_library(kuzu_storage_store struct_column_chunk.cpp struct_column.cpp table_data.cpp - var_list_column_chunk.cpp - var_list_column.cpp) + list_column_chunk.cpp + list_column.cpp) set(ALL_OBJECT_FILES ${ALL_OBJECT_FILES} $ diff --git a/src/storage/store/column.cpp b/src/storage/store/column.cpp index 2fe76401ba5..8e3f318994e 100644 --- a/src/storage/store/column.cpp +++ b/src/storage/store/column.cpp @@ -8,10 +8,10 @@ #include "storage/stats/property_statistics.h" #include "storage/storage_utils.h" #include "storage/store/column_chunk.h" +#include "storage/store/list_column.h" #include "storage/store/null_column.h" #include "storage/store/string_column.h" #include "storage/store/struct_column.h" -#include "storage/store/var_list_column.h" #include "transaction/transaction.h" #include @@ -932,8 +932,8 @@ std::unique_ptr ColumnFactory::createColumn(std::string name, LogicalTyp } case LogicalTypeID::ARRAY: case LogicalTypeID::MAP: - case LogicalTypeID::VAR_LIST: { - return std::make_unique(name, std::move(dataType), metaDAHeaderInfo, dataFH, + case LogicalTypeID::LIST: { + return std::make_unique(name, std::move(dataType), metaDAHeaderInfo, dataFH, metadataFH, bufferManager, wal, transaction, propertyStatistics, enableCompression); } case LogicalTypeID::UNION: diff --git a/src/storage/store/column_chunk.cpp b/src/storage/store/column_chunk.cpp index f13d6c78083..4ab880d38ef 100644 --- a/src/storage/store/column_chunk.cpp +++ b/src/storage/store/column_chunk.cpp @@ -6,9 +6,9 @@ #include "common/types/types.h" #include "storage/compression/compression.h" #include "storage/storage_utils.h" +#include "storage/store/list_column_chunk.h" #include "storage/store/string_column_chunk.h" #include "storage/store/struct_column_chunk.h" -#include "storage/store/var_list_column_chunk.h" using namespace kuzu::common; @@ -126,7 +126,7 @@ static std::shared_ptr getCompression( return std::make_shared>(); } case PhysicalTypeID::INTERNAL_ID: - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::UINT64: { return std::make_shared>(); } @@ -183,7 +183,7 @@ void ColumnChunk::initializeFunction() { case PhysicalTypeID::INT16: case PhysicalTypeID::INT8: case PhysicalTypeID::INTERNAL_ID: - case PhysicalTypeID::VAR_LIST: + case PhysicalTypeID::LIST: case PhysicalTypeID::UINT64: case PhysicalTypeID::UINT32: case PhysicalTypeID::UINT16: @@ -262,12 +262,12 @@ void ColumnChunk::write(ColumnChunk* chunk, ColumnChunk* dstOffsets, RelMultipli } // NOTE: This function is only called in LocalTable right now when performing out-of-place -// committing. VAR_LIST has a different logic for handling out-of-place committing as it has to +// committing. LIST has a different logic for handling out-of-place committing as it has to // be slided. However, this is unsafe, as this function can also be used for other purposes later. // Thus, an assertion is added at the first line. void ColumnChunk::write(ValueVector* vector, offset_t offsetInVector, offset_t offsetInChunk) { KU_ASSERT(dataType.getPhysicalType() != PhysicalTypeID::BOOL && - dataType.getPhysicalType() != PhysicalTypeID::VAR_LIST); + dataType.getPhysicalType() != PhysicalTypeID::LIST); nullChunk->setNull(offsetInChunk, vector->isNull(offsetInVector)); if (offsetInChunk >= numValues) { numValues = offsetInChunk + 1; @@ -642,8 +642,8 @@ std::unique_ptr ColumnChunkFactory::createColumnChunk( return std::make_unique( std::move(dataType), capacity, enableCompression, inMemory); } - case PhysicalTypeID::VAR_LIST: { - return std::make_unique( + case PhysicalTypeID::LIST: { + return std::make_unique( std::move(dataType), capacity, enableCompression, inMemory); } case PhysicalTypeID::STRUCT: { diff --git a/src/storage/store/var_list_column.cpp b/src/storage/store/list_column.cpp similarity index 80% rename from src/storage/store/var_list_column.cpp rename to src/storage/store/list_column.cpp index 9fe70cc89c5..df0c01d9227 100644 --- a/src/storage/store/var_list_column.cpp +++ b/src/storage/store/list_column.cpp @@ -1,8 +1,8 @@ -#include "storage/store/var_list_column.h" +#include "storage/store/list_column.h" #include "storage/store/column.h" +#include "storage/store/list_column_chunk.h" #include "storage/store/null_column.h" -#include "storage/store/var_list_column_chunk.h" #include using namespace kuzu::common; @@ -47,7 +47,7 @@ bool ListOffsetSizeInfo::isOffsetSortedAscending(uint64_t startPos, uint64_t end return true; } -VarListColumn::VarListColumn(std::string name, LogicalType dataType, +ListColumn::ListColumn(std::string name, LogicalType dataType, const MetadataDAHInfo& metaDAHeaderInfo, BMFileHandle* dataFH, BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal, Transaction* transaction, RWPropertyStats propertyStatistics, bool enableCompression) @@ -59,11 +59,11 @@ VarListColumn::VarListColumn(std::string name, LogicalType dataType, *metaDAHeaderInfo.childrenInfos[0], dataFH, metadataFH, bufferManager, wal, transaction, propertyStatistics, enableCompression); dataColumn = ColumnFactory::createColumn(dataColName, - *VarListType::getChildType(&this->dataType)->copy(), *metaDAHeaderInfo.childrenInfos[1], + *ListType::getChildType(&this->dataType)->copy(), *metaDAHeaderInfo.childrenInfos[1], dataFH, metadataFH, bufferManager, wal, transaction, propertyStatistics, enableCompression); } -void VarListColumn::scan(Transaction* transaction, node_group_idx_t nodeGroupIdx, +void ListColumn::scan(Transaction* transaction, node_group_idx_t nodeGroupIdx, offset_t startOffsetInGroup, offset_t endOffsetInGroup, ValueVector* resultVector, uint64_t offsetInVector) { nullColumn->scan(transaction, nodeGroupIdx, startOffsetInGroup, endOffsetInGroup, resultVector, @@ -101,21 +101,21 @@ void VarListColumn::scan(Transaction* transaction, node_group_idx_t nodeGroupIdx } } -void VarListColumn::scan(Transaction* transaction, node_group_idx_t nodeGroupIdx, +void ListColumn::scan(Transaction* transaction, node_group_idx_t nodeGroupIdx, kuzu::storage::ColumnChunk* columnChunk, offset_t startOffset, offset_t endOffset) { if (nodeGroupIdx >= metadataDA->getNumElements(transaction->getType())) { columnChunk->setNumValues(0); } else { - auto varListColumnChunk = ku_dynamic_cast(columnChunk); + auto listColumnChunk = ku_dynamic_cast(columnChunk); Column::scan(transaction, nodeGroupIdx, columnChunk, startOffset, endOffset); - auto sizeColumnChunk = varListColumnChunk->getSizeColumnChunk(); + auto sizeColumnChunk = listColumnChunk->getSizeColumnChunk(); sizeColumn->scan(transaction, nodeGroupIdx, sizeColumnChunk, startOffset, endOffset); - auto resizeNumValues = varListColumnChunk->getDataColumnChunk()->getNumValues(); + auto resizeNumValues = listColumnChunk->getDataColumnChunk()->getNumValues(); bool isOffsetSortedAscending = true; - offset_t prevOffset = varListColumnChunk->getListStartOffset(0); + offset_t prevOffset = listColumnChunk->getListStartOffset(0); for (auto i = 0u; i < columnChunk->getNumValues(); i++) { - auto currentEndOffset = varListColumnChunk->getListEndOffset(i); - auto appendSize = varListColumnChunk->getListSize(i); + auto currentEndOffset = listColumnChunk->getListEndOffset(i); + auto appendSize = listColumnChunk->getListSize(i); prevOffset += appendSize; if (currentEndOffset != prevOffset) { isOffsetSortedAscending = false; @@ -123,37 +123,36 @@ void VarListColumn::scan(Transaction* transaction, node_group_idx_t nodeGroupIdx resizeNumValues += appendSize; } if (isOffsetSortedAscending) { - varListColumnChunk->resizeDataColumnChunk(std::bit_ceil(resizeNumValues)); - offset_t startVarListOffset = varListColumnChunk->getListStartOffset(0); - offset_t endVarListOffset = - varListColumnChunk->getListStartOffset(columnChunk->getNumValues()); - dataColumn->scan(transaction, nodeGroupIdx, varListColumnChunk->getDataColumnChunk(), - startVarListOffset, endVarListOffset); - varListColumnChunk->resetOffset(); + listColumnChunk->resizeDataColumnChunk(std::bit_ceil(resizeNumValues)); + offset_t startListOffset = listColumnChunk->getListStartOffset(0); + offset_t endListOffset = + listColumnChunk->getListStartOffset(columnChunk->getNumValues()); + dataColumn->scan(transaction, nodeGroupIdx, listColumnChunk->getDataColumnChunk(), + startListOffset, endListOffset); + listColumnChunk->resetOffset(); } else { - varListColumnChunk->resizeDataColumnChunk(std::bit_ceil(resizeNumValues)); + listColumnChunk->resizeDataColumnChunk(std::bit_ceil(resizeNumValues)); auto tmpDataColumnChunk = - std::make_unique(ColumnChunkFactory::createColumnChunk( - *VarListType::getChildType(&this->dataType)->copy(), enableCompression, + std::make_unique(ColumnChunkFactory::createColumnChunk( + *ListType::getChildType(&this->dataType)->copy(), enableCompression, std::bit_ceil(resizeNumValues))); - auto dataVarListColumnChunk = varListColumnChunk->getDataColumnChunk(); + auto dataListColumnChunk = listColumnChunk->getDataColumnChunk(); for (auto i = 0u; i < columnChunk->getNumValues(); i++) { - offset_t startVarListOffset = varListColumnChunk->getListStartOffset(i); - offset_t endVarListOffset = varListColumnChunk->getListEndOffset(i); + offset_t startListOffset = listColumnChunk->getListStartOffset(i); + offset_t endListOffset = listColumnChunk->getListEndOffset(i); dataColumn->scan(transaction, nodeGroupIdx, - tmpDataColumnChunk->dataColumnChunk.get(), startVarListOffset, - endVarListOffset); - KU_ASSERT(endVarListOffset - startVarListOffset == + tmpDataColumnChunk->dataColumnChunk.get(), startListOffset, endListOffset); + KU_ASSERT(endListOffset - startListOffset == tmpDataColumnChunk->dataColumnChunk->getNumValues()); - dataVarListColumnChunk->append(tmpDataColumnChunk->dataColumnChunk.get(), 0, + dataListColumnChunk->append(tmpDataColumnChunk->dataColumnChunk.get(), 0, tmpDataColumnChunk->dataColumnChunk->getNumValues()); } - varListColumnChunk->resetOffset(); + listColumnChunk->resetOffset(); } } } -void VarListColumn::scanInternal( +void ListColumn::scanInternal( Transaction* transaction, ValueVector* nodeIDVector, ValueVector* resultVector) { resultVector->resetAuxiliaryBuffer(); auto startNodeOffset = nodeIDVector->readNodeOffset(0); @@ -170,7 +169,7 @@ void VarListColumn::scanInternal( } } -void VarListColumn::lookupValue(Transaction* transaction, offset_t nodeOffset, +void ListColumn::lookupValue(Transaction* transaction, offset_t nodeOffset, ValueVector* resultVector, uint32_t posInVector) { auto nodeGroupIdx = StorageUtils::getNodeGroupIdx(nodeOffset); auto nodeOffsetInGroup = nodeOffset - StorageUtils::getStartOffsetOfNodeGroup(nodeGroupIdx); @@ -185,17 +184,17 @@ void VarListColumn::lookupValue(Transaction* transaction, offset_t nodeOffset, listEndOffset, dataVector, offsetInVector); } -void VarListColumn::append(ColumnChunk* columnChunk, uint64_t nodeGroupIdx) { +void ListColumn::append(ColumnChunk* columnChunk, uint64_t nodeGroupIdx) { KU_ASSERT(columnChunk->getDataType().getPhysicalType() == dataType.getPhysicalType()); - auto varListColumnChunk = ku_dynamic_cast(columnChunk); - Column::append(varListColumnChunk, nodeGroupIdx); - auto sizeColumnChunk = varListColumnChunk->getSizeColumnChunk(); + auto listColumnChunk = ku_dynamic_cast(columnChunk); + Column::append(listColumnChunk, nodeGroupIdx); + auto sizeColumnChunk = listColumnChunk->getSizeColumnChunk(); sizeColumn->append(sizeColumnChunk, nodeGroupIdx); - auto dataColumnChunk = varListColumnChunk->getDataColumnChunk(); + auto dataColumnChunk = listColumnChunk->getDataColumnChunk(); dataColumn->append(dataColumnChunk, nodeGroupIdx); } -void VarListColumn::scanUnfiltered(Transaction* transaction, node_group_idx_t nodeGroupIdx, +void ListColumn::scanUnfiltered(Transaction* transaction, node_group_idx_t nodeGroupIdx, ValueVector* resultVector, const ListOffsetSizeInfo& listOffsetInfoInStorage) { auto numValuesToScan = resultVector->state->selVector->selectedSize; offset_t offsetInVector = 0; @@ -225,7 +224,7 @@ void VarListColumn::scanUnfiltered(Transaction* transaction, node_group_idx_t no } } -void VarListColumn::scanFiltered(Transaction* transaction, node_group_idx_t nodeGroupIdx, +void ListColumn::scanFiltered(Transaction* transaction, node_group_idx_t nodeGroupIdx, ValueVector* resultVector, const ListOffsetSizeInfo& listOffsetSizeInfo) { offset_t listOffset = 0; for (auto i = 0u; i < resultVector->state->selVector->selectedSize; i++) { @@ -247,25 +246,25 @@ void VarListColumn::scanFiltered(Transaction* transaction, node_group_idx_t node } } -void VarListColumn::prepareCommit() { +void ListColumn::prepareCommit() { Column::prepareCommit(); sizeColumn->prepareCommit(); dataColumn->prepareCommit(); } -void VarListColumn::checkpointInMemory() { +void ListColumn::checkpointInMemory() { Column::checkpointInMemory(); sizeColumn->checkpointInMemory(); dataColumn->checkpointInMemory(); } -void VarListColumn::rollbackInMemory() { +void ListColumn::rollbackInMemory() { Column::rollbackInMemory(); sizeColumn->rollbackInMemory(); dataColumn->rollbackInMemory(); } -offset_t VarListColumn::readOffset( +offset_t ListColumn::readOffset( Transaction* transaction, node_group_idx_t nodeGroupIdx, offset_t offsetInNodeGroup) { auto chunkMeta = metadataDA->get(nodeGroupIdx, transaction->getType()); auto pageCursor = PageUtils::getPageCursorForPos(offsetInNodeGroup, @@ -279,7 +278,7 @@ offset_t VarListColumn::readOffset( return value; } -list_size_t VarListColumn::readSize( +list_size_t ListColumn::readSize( Transaction* transaction, node_group_idx_t nodeGroupIdx, offset_t offsetInNodeGroup) { auto chunkMeta = sizeColumn->getMetadataDA()->get(nodeGroupIdx, transaction->getType()); auto pageCursor = PageUtils::getPageCursorForPos(offsetInNodeGroup, @@ -293,7 +292,7 @@ list_size_t VarListColumn::readSize( return value; } -ListOffsetSizeInfo VarListColumn::getListOffsetSizeInfo(Transaction* transaction, +ListOffsetSizeInfo ListColumn::getListOffsetSizeInfo(Transaction* transaction, node_group_idx_t nodeGroupIdx, offset_t startOffsetInNodeGroup, offset_t endOffsetInNodeGroup) { auto numOffsetsToRead = endOffsetInNodeGroup - startOffsetInNodeGroup; auto offsetColumnChunk = ColumnChunkFactory::createColumnChunk( @@ -307,7 +306,7 @@ ListOffsetSizeInfo VarListColumn::getListOffsetSizeInfo(Transaction* transaction return {numOffsetsToRead, std::move(offsetColumnChunk), std::move(sizeColumnChunk)}; } -void VarListColumn::prepareCommitForChunk(Transaction* transaction, node_group_idx_t nodeGroupIdx, +void ListColumn::prepareCommitForChunk(Transaction* transaction, node_group_idx_t nodeGroupIdx, const ChunkCollection& localInsertChunks, const offset_to_row_idx_t& insertInfo, const ChunkCollection& localUpdateChunks, const offset_to_row_idx_t& updateInfo, const offset_set_t& deleteInfo) { @@ -337,7 +336,7 @@ void VarListColumn::prepareCommitForChunk(Transaction* transaction, node_group_i } } -void VarListColumn::prepareCommitForChunk(Transaction* transaction, node_group_idx_t nodeGroupIdx, +void ListColumn::prepareCommitForChunk(Transaction* transaction, node_group_idx_t nodeGroupIdx, const std::vector& dstOffsets, ColumnChunk* chunk, offset_t startSrcOffset) { auto currentNumNodeGroups = metadataDA->getNumElements(transaction->getType()); auto isNewNodeGroup = nodeGroupIdx >= currentNumNodeGroups; @@ -347,23 +346,23 @@ void VarListColumn::prepareCommitForChunk(Transaction* transaction, node_group_i } else { // we separate the commit into three parts: offset chunk commit, size column chunk commit, // data column chunk - auto varListChunk = ku_dynamic_cast(chunk); - sizeColumn->prepareCommitForChunk(transaction, nodeGroupIdx, dstOffsets, - varListChunk->getSizeColumnChunk(), startSrcOffset); + auto listChunk = ku_dynamic_cast(chunk); + sizeColumn->prepareCommitForChunk( + transaction, nodeGroupIdx, dstOffsets, listChunk->getSizeColumnChunk(), startSrcOffset); auto dataColumnSize = dataColumn->getMetadata(nodeGroupIdx, transaction->getType()).numValues; - auto dataColumnChunk = varListChunk->getDataColumnChunk(); + auto dataColumnChunk = listChunk->getDataColumnChunk(); auto numListsToAppend = std::min(chunk->getNumValues(), (uint64_t)dstOffsets.size()); auto dataSize = 0u; - auto startVarListOffset = varListChunk->getListStartOffset(startSrcOffset); + auto startListOffset = listChunk->getListStartOffset(startSrcOffset); std::vector dstOffsetsInDataColumn; for (auto i = 0u; i < numListsToAppend; i++) { - for (auto j = 0u; j < varListChunk->getListSize(startSrcOffset + i); j++) { + for (auto j = 0u; j < listChunk->getListSize(startSrcOffset + i); j++) { dstOffsetsInDataColumn.push_back(dataColumnSize + dataSize++); } } dataColumn->prepareCommitForChunk( - transaction, nodeGroupIdx, dstOffsetsInDataColumn, dataColumnChunk, startVarListOffset); + transaction, nodeGroupIdx, dstOffsetsInDataColumn, dataColumnChunk, startListOffset); // we need to update the offset since we do not do in-place list data update but append data // in the end of list data column we need to plus to original data column size to get the // new offset @@ -374,13 +373,13 @@ void VarListColumn::prepareCommitForChunk(Transaction* transaction, node_group_i enableCompression, 1.5 * std::bit_ceil(offsetChunkMeta.numValues + dstOffsets.size())); Column::scan(transaction, nodeGroupIdx, offsetColumnChunk.get()); for (auto i = 0u; i < numListsToAppend; i++) { - auto listEndOffset = varListChunk->getListEndOffset(startSrcOffset + i); - auto isNull = varListChunk->getNullChunk()->isNull(startSrcOffset + i); + auto listEndOffset = listChunk->getListEndOffset(startSrcOffset + i); + auto isNull = listChunk->getNullChunk()->isNull(startSrcOffset + i); offsetColumnChunk->setValue(dataColumnSize + listEndOffset, dstOffsets[i]); offsetColumnChunk->getNullChunk()->setNull(dstOffsets[i], isNull); } auto offsetListChunk = - ku_dynamic_cast(offsetColumnChunk.get()); + ku_dynamic_cast(offsetColumnChunk.get()); offsetListChunk->getSizeColumnChunk()->setNumValues(offsetColumnChunk->getNumValues()); Column::append(offsetColumnChunk.get(), nodeGroupIdx); } diff --git a/src/storage/store/var_list_column_chunk.cpp b/src/storage/store/list_column_chunk.cpp similarity index 69% rename from src/storage/store/var_list_column_chunk.cpp rename to src/storage/store/list_column_chunk.cpp index 1cb9f096495..6797aa8ac31 100644 --- a/src/storage/store/var_list_column_chunk.cpp +++ b/src/storage/store/list_column_chunk.cpp @@ -1,4 +1,4 @@ -#include "storage/store/var_list_column_chunk.h" +#include "storage/store/list_column_chunk.h" #include "common/cast.h" #include "common/data_chunk/sel_vector.h" @@ -10,11 +10,11 @@ using namespace kuzu::common; namespace kuzu { namespace storage { -void VarListDataColumnChunk::reset() const { +void ListDataColumnChunk::reset() const { dataColumnChunk->resetToEmpty(); } -void VarListDataColumnChunk::resizeBuffer(uint64_t numValues) { +void ListDataColumnChunk::resizeBuffer(uint64_t numValues) { if (numValues <= capacity) { return; } @@ -25,19 +25,19 @@ void VarListDataColumnChunk::resizeBuffer(uint64_t numValues) { dataColumnChunk->resize(capacity); } -VarListColumnChunk::VarListColumnChunk( +ListColumnChunk::ListColumnChunk( LogicalType dataType, uint64_t capacity, bool enableCompression, bool inMemory) : ColumnChunk{std::move(dataType), capacity, enableCompression, true /* hasNullChunk */} { sizeColumnChunk = ColumnChunkFactory::createColumnChunk( *common::LogicalType::UINT32(), enableCompression, capacity); - varListDataColumnChunk = std::make_unique( - ColumnChunkFactory::createColumnChunk(*VarListType::getChildType(&this->dataType)->copy(), + listDataColumnChunk = std::make_unique( + ColumnChunkFactory::createColumnChunk(*ListType::getChildType(&this->dataType)->copy(), enableCompression, 0 /* capacity */, inMemory)); checkOffsetSortedAsc = false; - KU_ASSERT(this->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(this->dataType.getPhysicalType() == PhysicalTypeID::LIST); } -bool VarListColumnChunk::isOffsetsConsecutiveAndSortedAscending( +bool ListColumnChunk::isOffsetsConsecutiveAndSortedAscending( uint64_t startPos, uint64_t endPos) const { offset_t prevEndOffset = getListStartOffset(startPos); for (auto i = startPos; i < endPos; i++) { @@ -51,60 +51,60 @@ bool VarListColumnChunk::isOffsetsConsecutiveAndSortedAscending( return true; } -offset_t VarListColumnChunk::getListStartOffset(offset_t offset) const { +offset_t ListColumnChunk::getListStartOffset(offset_t offset) const { if (numValues == 0) return 0; return offset == numValues ? getListEndOffset(offset - 1) : getListEndOffset(offset) - getListSize(offset); } -offset_t VarListColumnChunk::getListEndOffset(offset_t offset) const { +offset_t ListColumnChunk::getListEndOffset(offset_t offset) const { if (numValues == 0) return 0; KU_ASSERT(offset < numValues); return getValue(offset); } -list_size_t VarListColumnChunk::getListSize(common::offset_t offset) const { +list_size_t ListColumnChunk::getListSize(common::offset_t offset) const { if (numValues == 0) return 0; KU_ASSERT(offset < sizeColumnChunk->getNumValues()); return sizeColumnChunk->getValue(offset); } -void VarListColumnChunk::append( +void ListColumnChunk::append( ColumnChunk* other, offset_t startPosInOtherChunk, uint32_t numValuesToAppend) { checkOffsetSortedAsc = true; - auto otherListChunk = ku_dynamic_cast(other); + auto otherListChunk = ku_dynamic_cast(other); nullChunk->append(other->getNullChunk(), startPosInOtherChunk, numValuesToAppend); sizeColumnChunk->getNullChunk()->append( other->getNullChunk(), startPosInOtherChunk, numValuesToAppend); - offset_t offsetInDataChunkToAppend = varListDataColumnChunk->getNumValues(); + offset_t offsetInDataChunkToAppend = listDataColumnChunk->getNumValues(); for (auto i = 0u; i < numValuesToAppend; i++) { auto appendSize = otherListChunk->getListSize(startPosInOtherChunk + i); sizeColumnChunk->setValue(appendSize, numValues); offsetInDataChunkToAppend += appendSize; setValue(offsetInDataChunkToAppend, numValues); } - varListDataColumnChunk->resizeBuffer(offsetInDataChunkToAppend); + listDataColumnChunk->resizeBuffer(offsetInDataChunkToAppend); for (auto i = 0u; i < numValuesToAppend; i++) { auto startOffset = otherListChunk->getListStartOffset(startPosInOtherChunk + i); auto appendSize = otherListChunk->getListSize(startPosInOtherChunk + i); - varListDataColumnChunk->dataColumnChunk->append( - otherListChunk->varListDataColumnChunk->dataColumnChunk.get(), startOffset, appendSize); + listDataColumnChunk->dataColumnChunk->append( + otherListChunk->listDataColumnChunk->dataColumnChunk.get(), startOffset, appendSize); } sanityCheck(); } -void VarListColumnChunk::resetToEmpty() { +void ListColumnChunk::resetToEmpty() { ColumnChunk::resetToEmpty(); sizeColumnChunk->resetToEmpty(); - varListDataColumnChunk = std::make_unique( - ColumnChunkFactory::createColumnChunk(*VarListType::getChildType(&this->dataType)->copy(), - enableCompression, 0 /* capacity */)); + listDataColumnChunk = + std::make_unique(ColumnChunkFactory::createColumnChunk( + *ListType::getChildType(&this->dataType)->copy(), enableCompression, 0 /* capacity */)); } -void VarListColumnChunk::append(ValueVector* vector, const SelectionVector& selVector) { +void ListColumnChunk::append(ValueVector* vector, const SelectionVector& selVector) { auto numToAppend = selVector.selectedSize; auto newCapacity = capacity; while (numValues + numToAppend >= newCapacity) { @@ -113,7 +113,7 @@ void VarListColumnChunk::append(ValueVector* vector, const SelectionVector& selV if (capacity < newCapacity) { resize(newCapacity); } - offset_t nextListOffsetInChunk = varListDataColumnChunk->getNumValues(); + offset_t nextListOffsetInChunk = listDataColumnChunk->getNumValues(); auto offsetBufferToWrite = (offset_t*)(buffer.get()); for (auto i = 0u; i < selVector.selectedSize; i++) { auto pos = selVector.selectedPositions[i]; @@ -124,7 +124,7 @@ void VarListColumnChunk::append(ValueVector* vector, const SelectionVector& selV nextListOffsetInChunk += listLen; offsetBufferToWrite[numValues + i] = nextListOffsetInChunk; } - varListDataColumnChunk->resizeBuffer(nextListOffsetInChunk); + listDataColumnChunk->resizeBuffer(nextListOffsetInChunk); auto dataVector = ListVector::getDataVector(vector); // TODO(Guodong): we should not set vector to a new state. dataVector->setState(std::make_unique()); @@ -140,8 +140,8 @@ void VarListColumnChunk::append(ValueVector* vector, const SelectionVector& selV sanityCheck(); } -void VarListColumnChunk::appendNullList() { - offset_t nextListOffsetInChunk = varListDataColumnChunk->getNumValues(); +void ListColumnChunk::appendNullList() { + offset_t nextListOffsetInChunk = listDataColumnChunk->getNumValues(); auto offsetBufferToWrite = (offset_t*)(buffer.get()); sizeColumnChunk->setValue(0, numValues); sizeColumnChunk->getNullChunk()->setNull(numValues, true); @@ -150,7 +150,7 @@ void VarListColumnChunk::appendNullList() { numValues++; } -void VarListColumnChunk::lookup( +void ListColumnChunk::lookup( offset_t offsetInChunk, ValueVector& output, sel_t posInOutputVector) const { KU_ASSERT(offsetInChunk < numValues); output.setNull(posInOutputVector, nullChunk->isNull(offsetInChunk)); @@ -164,23 +164,23 @@ void VarListColumnChunk::lookup( ListVector::resizeDataVector(&output, currentListDataSize + listSize); // TODO(Guodong): Should add `scan` interface and use `scan` here. for (auto i = 0u; i < listSize; i++) { - varListDataColumnChunk->dataColumnChunk->lookup(startOffset + i, *dataVector, i); + listDataColumnChunk->dataColumnChunk->lookup(startOffset + i, *dataVector, i); } } -void VarListColumnChunk::write( +void ListColumnChunk::write( ColumnChunk* chunk, ColumnChunk* dstOffsets, RelMultiplicity /*multiplicity*/) { KU_ASSERT(chunk->getDataType().getPhysicalType() == dataType.getPhysicalType() && dstOffsets->getDataType().getPhysicalType() == PhysicalTypeID::INTERNAL_ID && chunk->getNumValues() == dstOffsets->getNumValues()); checkOffsetSortedAsc = true; - offset_t currentIndex = varListDataColumnChunk->getNumValues(); - auto otherListChunk = ku_dynamic_cast(chunk); - varListDataColumnChunk->resizeBuffer(varListDataColumnChunk->getNumValues() + - otherListChunk->varListDataColumnChunk->getNumValues()); - varListDataColumnChunk->dataColumnChunk->append( - otherListChunk->varListDataColumnChunk->dataColumnChunk.get(), 0, - otherListChunk->varListDataColumnChunk->getNumValues()); + offset_t currentIndex = listDataColumnChunk->getNumValues(); + auto otherListChunk = ku_dynamic_cast(chunk); + listDataColumnChunk->resizeBuffer( + listDataColumnChunk->getNumValues() + otherListChunk->listDataColumnChunk->getNumValues()); + listDataColumnChunk->dataColumnChunk->append( + otherListChunk->listDataColumnChunk->dataColumnChunk.get(), 0, + otherListChunk->listDataColumnChunk->getNumValues()); offset_t maxDstOffset = 0; for (auto i = 0u; i < dstOffsets->getNumValues(); i++) { auto posInChunk = dstOffsets->getValue(i); @@ -203,15 +203,14 @@ void VarListColumnChunk::write( sanityCheck(); } -void VarListColumnChunk::write( - ValueVector* vector, offset_t offsetInVector, offset_t offsetInChunk) { +void ListColumnChunk::write(ValueVector* vector, offset_t offsetInVector, offset_t offsetInChunk) { checkOffsetSortedAsc = true; auto selVector = std::make_unique(1); selVector->setToFiltered(); selVector->selectedPositions[0] = offsetInVector; auto appendSize = vector->isNull(offsetInVector) ? 0 : vector->getValue(offsetInVector).size; - varListDataColumnChunk->resizeBuffer(varListDataColumnChunk->getNumValues() + appendSize); + listDataColumnChunk->resizeBuffer(listDataColumnChunk->getNumValues() + appendSize); // TODO(Guodong): Do not set vector to a new state. auto dataVector = ListVector::getDataVector(vector); dataVector->setState(std::make_unique()); @@ -225,17 +224,17 @@ void VarListColumnChunk::write( sizeColumnChunk->getNullChunk()->setNull(offsetInChunk, isNull); if (!isNull) { sizeColumnChunk->setValue(appendSize, offsetInChunk); - setValue(varListDataColumnChunk->getNumValues(), offsetInChunk); + setValue(listDataColumnChunk->getNumValues(), offsetInChunk); } sanityCheck(); } -void VarListColumnChunk::write(ColumnChunk* srcChunk, offset_t srcOffsetInChunk, +void ListColumnChunk::write(ColumnChunk* srcChunk, offset_t srcOffsetInChunk, offset_t dstOffsetInChunk, offset_t numValuesToCopy) { - KU_ASSERT(srcChunk->getDataType().getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(srcChunk->getDataType().getPhysicalType() == PhysicalTypeID::LIST); checkOffsetSortedAsc = true; - auto srcListChunk = ku_dynamic_cast(srcChunk); - auto offsetInDataChunkToAppend = varListDataColumnChunk->getNumValues(); + auto srcListChunk = ku_dynamic_cast(srcChunk); + auto offsetInDataChunkToAppend = listDataColumnChunk->getNumValues(); for (auto i = 0u; i < numValuesToCopy; i++) { auto appendSize = srcListChunk->getListSize(srcOffsetInChunk + i); offsetInDataChunkToAppend += appendSize; @@ -246,20 +245,20 @@ void VarListColumnChunk::write(ColumnChunk* srcChunk, offset_t srcOffsetInChunk, sizeColumnChunk->getNullChunk()->setNull( dstOffsetInChunk + i, srcListChunk->nullChunk->isNull(srcOffsetInChunk + i)); } - varListDataColumnChunk->resizeBuffer(offsetInDataChunkToAppend); + listDataColumnChunk->resizeBuffer(offsetInDataChunkToAppend); for (auto i = 0u; i < numValuesToCopy; i++) { auto startOffsetInSrcChunk = srcListChunk->getListStartOffset(srcOffsetInChunk + i); auto appendSize = srcListChunk->getListSize(srcOffsetInChunk + i); - varListDataColumnChunk->dataColumnChunk->append( - srcListChunk->varListDataColumnChunk->dataColumnChunk.get(), startOffsetInSrcChunk, + listDataColumnChunk->dataColumnChunk->append( + srcListChunk->listDataColumnChunk->dataColumnChunk.get(), startOffsetInSrcChunk, appendSize); } sanityCheck(); } -void VarListColumnChunk::copy(ColumnChunk* srcChunk, offset_t srcOffsetInChunk, +void ListColumnChunk::copy(ColumnChunk* srcChunk, offset_t srcOffsetInChunk, offset_t dstOffsetInChunk, offset_t numValuesToCopy) { - KU_ASSERT(srcChunk->getDataType().getPhysicalType() == PhysicalTypeID::VAR_LIST); + KU_ASSERT(srcChunk->getDataType().getPhysicalType() == PhysicalTypeID::LIST); KU_ASSERT(dstOffsetInChunk >= numValues); while (numValues < dstOffsetInChunk) { appendNullList(); @@ -267,7 +266,7 @@ void VarListColumnChunk::copy(ColumnChunk* srcChunk, offset_t srcOffsetInChunk, append(srcChunk, srcOffsetInChunk, numValuesToCopy); } -void VarListColumnChunk::copyListValues(const list_entry_t& entry, ValueVector* dataVector) { +void ListColumnChunk::copyListValues(const list_entry_t& entry, ValueVector* dataVector) { auto numListValuesToCopy = entry.size; auto numListValuesCopied = 0u; while (numListValuesCopied < numListValuesToCopy) { @@ -278,12 +277,12 @@ void VarListColumnChunk::copyListValues(const list_entry_t& entry, ValueVector* dataVector->state->selVector->selectedPositions[j] = entry.offset + numListValuesCopied + j; } - varListDataColumnChunk->append(dataVector, *dataVector->state->selVector); + listDataColumnChunk->append(dataVector, *dataVector->state->selVector); numListValuesCopied += numListValuesToCopyInBatch; } } -void VarListColumnChunk::resetOffset() { +void ListColumnChunk::resetOffset() { offset_t nextListOffsetReset = 0; for (auto i = 0u; i < numValues; i++) { auto listSize = getListSize(i); @@ -293,12 +292,12 @@ void VarListColumnChunk::resetOffset() { } } -void VarListColumnChunk::finalize() { +void ListColumnChunk::finalize() { // rewrite the column chunk for better scanning performance auto newColumnChunk = ColumnChunkFactory::createColumnChunk( std::move(*dataType.copy()), enableCompression, capacity); - uint64_t totalListLen = varListDataColumnChunk->getNumValues(); - uint64_t resizeThreshold = varListDataColumnChunk->capacity / 2; + uint64_t totalListLen = listDataColumnChunk->getNumValues(); + uint64_t resizeThreshold = listDataColumnChunk->capacity / 2; // if the list is not very long, we do not need to rewrite if (totalListLen < resizeThreshold) { return; @@ -311,43 +310,43 @@ void VarListColumnChunk::finalize() { if (isOffsetsConsecutiveAndSortedAscending(0, numValues)) { return; } - auto newVarListChunk = ku_dynamic_cast(newColumnChunk.get()); - newVarListChunk->resize(numValues); - newVarListChunk->getDataColumnChunk()->resize(totalListLen); - auto dataColumnChunk = newVarListChunk->getDataColumnChunk(); - newVarListChunk->varListDataColumnChunk->resizeBuffer(totalListLen); + auto newListChunk = ku_dynamic_cast(newColumnChunk.get()); + newListChunk->resize(numValues); + newListChunk->getDataColumnChunk()->resize(totalListLen); + auto dataColumnChunk = newListChunk->getDataColumnChunk(); + newListChunk->listDataColumnChunk->resizeBuffer(totalListLen); offset_t offsetInChunk = 0; offset_t currentIndex = 0; for (auto i = 0u; i < numValues; i++) { if (nullChunk->isNull(i)) { - newVarListChunk->appendNullList(); + newListChunk->appendNullList(); } else { auto startOffset = getListStartOffset(i); auto listSize = getListSize(i); dataColumnChunk->append( - varListDataColumnChunk->dataColumnChunk.get(), startOffset, listSize); + listDataColumnChunk->dataColumnChunk.get(), startOffset, listSize); offsetInChunk += listSize; - newVarListChunk->getNullChunk()->setNull(currentIndex, false); - newVarListChunk->sizeColumnChunk->getNullChunk()->setNull(currentIndex, false); - newVarListChunk->sizeColumnChunk->setValue(listSize, currentIndex); - newVarListChunk->setValue(offsetInChunk, currentIndex); + newListChunk->getNullChunk()->setNull(currentIndex, false); + newListChunk->sizeColumnChunk->getNullChunk()->setNull(currentIndex, false); + newListChunk->sizeColumnChunk->setValue(listSize, currentIndex); + newListChunk->setValue(offsetInChunk, currentIndex); } currentIndex++; } - newVarListChunk->sanityCheck(); - // Move offsets, null, data from newVarListChunk to this column chunk. And release indices. - resetFromOtherChunk(newVarListChunk); + newListChunk->sanityCheck(); + // Move offsets, null, data from newListChunk to this column chunk. And release indices. + resetFromOtherChunk(newListChunk); } -void VarListColumnChunk::resetFromOtherChunk(VarListColumnChunk* other) { +void ListColumnChunk::resetFromOtherChunk(ListColumnChunk* other) { buffer = std::move(other->buffer); nullChunk = std::move(other->nullChunk); sizeColumnChunk = std::move(other->sizeColumnChunk); - varListDataColumnChunk = std::move(other->varListDataColumnChunk); + listDataColumnChunk = std::move(other->listDataColumnChunk); numValues = other->numValues; checkOffsetSortedAsc = false; } -bool VarListColumnChunk::sanityCheck() { +bool ListColumnChunk::sanityCheck() { KU_ASSERT(ColumnChunk::sanityCheck()); KU_ASSERT(sizeColumnChunk->sanityCheck()); KU_ASSERT(getDataColumnChunk()->sanityCheck()); diff --git a/test/c_api/data_type_test.cpp b/test/c_api/data_type_test.cpp index 917a8d1ef67..70c3faf75c6 100644 --- a/test/c_api/data_type_test.cpp +++ b/test/c_api/data_type_test.cpp @@ -10,10 +10,10 @@ TEST(CApiDataTypeTest, Create) { auto dataTypeCpp = (LogicalType*)dataType->_data_type; ASSERT_EQ(dataTypeCpp->getLogicalTypeID(), LogicalTypeID::INT64); - auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_VAR_LIST, dataType, 0); + auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_LIST, dataType, 0); ASSERT_NE(dataType2, nullptr); auto dataTypeCpp2 = (LogicalType*)dataType2->_data_type; - ASSERT_EQ(dataTypeCpp2->getLogicalTypeID(), LogicalTypeID::VAR_LIST); + ASSERT_EQ(dataTypeCpp2->getLogicalTypeID(), LogicalTypeID::LIST); // ASSERT_EQ(dataTypeCpp2->getChildType()->getLogicalTypeID(), LogicalTypeID::INT64); auto dataType3 = kuzu_data_type_create(kuzu_data_type_id::KUZU_ARRAY, dataType, 100); @@ -38,7 +38,7 @@ TEST(CApiDataTypeTest, Clone) { auto dataTypeCloneCpp = (LogicalType*)dataTypeClone->_data_type; ASSERT_TRUE(*dataTypeCpp == *dataTypeCloneCpp); - auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_VAR_LIST, dataType, 0); + auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_LIST, dataType, 0); ASSERT_NE(dataType2, nullptr); auto dataTypeClone2 = kuzu_data_type_clone(dataType2); ASSERT_NE(dataTypeClone2, nullptr); @@ -69,7 +69,7 @@ TEST(CApiDataTypeTest, Eqauls) { ASSERT_NE(dataTypeClone, nullptr); ASSERT_TRUE(kuzu_data_type_equals(dataType, dataTypeClone)); - auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_VAR_LIST, dataType, 0); + auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_LIST, dataType, 0); ASSERT_NE(dataType2, nullptr); auto dataTypeClone2 = kuzu_data_type_clone(dataType2); ASSERT_NE(dataTypeClone2, nullptr); @@ -98,9 +98,9 @@ TEST(CApiDataTypeTest, GetID) { ASSERT_NE(dataType, nullptr); ASSERT_EQ(kuzu_data_type_get_id(dataType), kuzu_data_type_id::KUZU_INT64); - auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_VAR_LIST, dataType, 0); + auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_LIST, dataType, 0); ASSERT_NE(dataType2, nullptr); - ASSERT_EQ(kuzu_data_type_get_id(dataType2), kuzu_data_type_id::KUZU_VAR_LIST); + ASSERT_EQ(kuzu_data_type_get_id(dataType2), kuzu_data_type_id::KUZU_LIST); auto dataType3 = kuzu_data_type_create(kuzu_data_type_id::KUZU_ARRAY, dataType, 100); ASSERT_NE(dataType3, nullptr); @@ -118,7 +118,7 @@ TEST(CApiDataTypeTest, GetID) { // ASSERT_NE(dataType, nullptr); // ASSERT_EQ(kuzu_data_type_get_child_type(dataType), nullptr); // -// auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_VAR_LIST, dataType, 0); +// auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_LIST, dataType, 0); // ASSERT_NE(dataType2, nullptr); // auto childType2 = kuzu_data_type_get_child_type(dataType2); // ASSERT_NE(childType2, nullptr); @@ -143,7 +143,7 @@ TEST(CApiDataTypeTest, GetFixedNumElementsInList) { ASSERT_NE(dataType, nullptr); ASSERT_EQ(kuzu_data_type_get_num_elements_in_array(dataType), 0); - auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_VAR_LIST, dataType, 0); + auto dataType2 = kuzu_data_type_create(kuzu_data_type_id::KUZU_LIST, dataType, 0); ASSERT_NE(dataType2, nullptr); ASSERT_EQ(kuzu_data_type_get_num_elements_in_array(dataType2), 0); diff --git a/test/c_api/value_test.cpp b/test/c_api/value_test.cpp index 3063298da48..ff552819e79 100644 --- a/test/c_api/value_test.cpp +++ b/test/c_api/value_test.cpp @@ -520,7 +520,7 @@ TEST_F(CApiValueTest, GetDataType) { value = kuzu_flat_tuple_get_value(flatTuple, 2); dataType = kuzu_value_get_data_type(value); - ASSERT_EQ(kuzu_data_type_get_id(dataType), KUZU_VAR_LIST); + ASSERT_EQ(kuzu_data_type_get_id(dataType), KUZU_LIST); kuzu_data_type_destroy(dataType); kuzu_value_destroy(value); diff --git a/test/include/graph_test/base_graph_test.h b/test/include/graph_test/base_graph_test.h index 3e099137aa9..105eb1a9603 100644 --- a/test/include/graph_test/base_graph_test.h +++ b/test/include/graph_test/base_graph_test.h @@ -107,7 +107,7 @@ class BaseGraphTest : public Test { ASSERT_EQ(actualResult, expectedResult); } static inline bool containsOverflowFile(common::LogicalTypeID typeID) { - return typeID == common::LogicalTypeID::STRING || typeID == common::LogicalTypeID::VAR_LIST; + return typeID == common::LogicalTypeID::STRING || typeID == common::LogicalTypeID::LIST; } void commitOrRollbackConnectionAndInitDBIfNecessary( diff --git a/test/test_files/exceptions/binder/binder_error.test b/test/test_files/exceptions/binder/binder_error.test index f90af46521d..8030e349fb4 100644 --- a/test/test_files/exceptions/binder/binder_error.test +++ b/test/test_files/exceptions/binder/binder_error.test @@ -106,7 +106,7 @@ Binder exception: Cannot match a built-in function for given function +(INTERNAL (DOUBLE,DOUBLE) -> DOUBLE (FLOAT,FLOAT) -> FLOAT (SERIAL,SERIAL) -> SERIAL -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST (STRING,STRING) -> STRING (INTERVAL,INTERVAL) -> INTERVAL (DATE,INT64) -> DATE @@ -132,7 +132,7 @@ Binder exception: Cannot match a built-in function for given function +(DATE,DAT (DOUBLE,DOUBLE) -> DOUBLE (FLOAT,FLOAT) -> FLOAT (SERIAL,SERIAL) -> SERIAL -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST (STRING,STRING) -> STRING (INTERVAL,INTERVAL) -> INTERVAL (DATE,INT64) -> DATE @@ -158,7 +158,7 @@ Binder exception: Cannot match a built-in function for given function +(TIMESTAM (DOUBLE,DOUBLE) -> DOUBLE (FLOAT,FLOAT) -> FLOAT (SERIAL,SERIAL) -> SERIAL -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST (STRING,STRING) -> STRING (INTERVAL,INTERVAL) -> INTERVAL (DATE,INT64) -> DATE @@ -184,7 +184,7 @@ Binder exception: Cannot match a built-in function for given function +(TIMESTAM (DOUBLE,DOUBLE) -> DOUBLE (FLOAT,FLOAT) -> FLOAT (SERIAL,SERIAL) -> SERIAL -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST (STRING,STRING) -> STRING (INTERVAL,INTERVAL) -> INTERVAL (DATE,INT64) -> DATE @@ -302,7 +302,7 @@ Binder exception: No file found that matches the pattern: wrong_path.parquet. -STATEMENT COPY person FROM "${KUZU_ROOT_DIRECTORY}/dataset/tinysnb/vPerson.csv" (pk=",") ---- error Binder exception: Unrecognized csv parsing option: PK. --STATEMENT LOAD WITH HEADERS (list STRING[], str STRING, struct STRUCT(a STRUCT(b STRUCT(c INT64[])))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/change_config.csv" (HEADER=true, DELIM="|", ESCAPE="~", QUOTE="'", LIST_END=")") RETURN * ; +-STATEMENT LOAD WITH HEADERS (list STRING[], str STRING, struct STRUCT(a STRUCT(b STRUCT(c INT64[])))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/change_config.csv" (HEADER=true, DELIM="|", ESCAPE="~", QUOTE="'", LIST_END=")") RETURN * ; ---- error Binder exception: Unrecognized csv parsing option: LIST_END. -STATEMENT LOAD WITH HEADERS (map MAP(STRING, MAP(STRING, INT16))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/map/nested_map_correct.csv" (LIST_BEGIN="(") RETURN *; @@ -310,7 +310,7 @@ Binder exception: Unrecognized csv parsing option: LIST_END. Binder exception: Unrecognized csv parsing option: LIST_BEGIN. -LOG LoadCSVInvalidCol --STATEMENT LOAD WITH HEADERS (list INT32[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/quote_error.csv" RETURN * ; +-STATEMENT LOAD WITH HEADERS (list INT32[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/quote_error.csv" RETURN * ; ---- error Binder exception: Number of columns mismatch. Expected 1 but got 3. @@ -517,7 +517,7 @@ Binder exception: Cannot match a built-in function for given function +(INT64,ST (DOUBLE,DOUBLE) -> DOUBLE (FLOAT,FLOAT) -> FLOAT (SERIAL,SERIAL) -> SERIAL -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST (STRING,STRING) -> STRING (INTERVAL,INTERVAL) -> INTERVAL (DATE,INT64) -> DATE @@ -587,7 +587,7 @@ Binder exception: Cannot match a built-in function for given function +(TIMESTAM (DOUBLE,DOUBLE) -> DOUBLE (FLOAT,FLOAT) -> FLOAT (SERIAL,SERIAL) -> SERIAL -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST (STRING,STRING) -> STRING (INTERVAL,INTERVAL) -> INTERVAL (DATE,INT64) -> DATE @@ -611,7 +611,7 @@ Binder exception: Cannot match a built-in function for given function +(TIMESTAM (DOUBLE,DOUBLE) -> DOUBLE (FLOAT,FLOAT) -> FLOAT (SERIAL,SERIAL) -> SERIAL -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST (STRING,STRING) -> STRING (INTERVAL,INTERVAL) -> INTERVAL (DATE,INT64) -> DATE diff --git a/test/test_files/tck/expressions/list/List1.test b/test/test_files/tck/expressions/list/List1.test index b8d34f4de7c..e2f393bfa90 100644 --- a/test/test_files/tck/expressions/list/List1.test +++ b/test/test_files/tck/expressions/list/List1.test @@ -80,21 +80,21 @@ # RETURN list[idx]; #---- error #Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(BOOL,INT64). Supported inputs are -#(VAR_LIST,INT64) -> ANY +#(LIST,INT64) -> ANY #(STRING,INT64) -> STRING -STATEMENT WITH 123 AS list, 0 AS idx RETURN list[idx]; ---- error Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(INT64,INT64). Supported inputs are -(VAR_LIST,INT64) -> ANY +(LIST,INT64) -> ANY (STRING,INT64) -> STRING -STATEMENT WITH 4.7 AS list, 0 AS idx RETURN list[idx]; ---- error Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(DOUBLE,INT64). Supported inputs are -(VAR_LIST,INT64) -> ANY +(LIST,INT64) -> ANY (STRING,INT64) -> STRING # Fail when indexing with a non-integer #Example: boolean @@ -104,7 +104,7 @@ Binder exception: Cannot match a built-in function for given function LIST_EXTRA RETURN list[idx]; ---- error Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(INT64[],BOOL). Supported inputs are -(VAR_LIST,INT64) -> ANY +(LIST,INT64) -> ANY (STRING,INT64) -> STRING (ARRAY,INT64) -> ANY @@ -112,7 +112,7 @@ Binder exception: Cannot match a built-in function for given function LIST_EXTRA RETURN list[idx]; ---- error Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(INT64[],DOUBLE). Supported inputs are -(VAR_LIST,INT64) -> ANY +(LIST,INT64) -> ANY (STRING,INT64) -> STRING (ARRAY,INT64) -> ANY @@ -120,7 +120,7 @@ Binder exception: Cannot match a built-in function for given function LIST_EXTRA RETURN list[idx]; ---- error Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(INT64[],STRING). Supported inputs are -(VAR_LIST,INT64) -> ANY +(LIST,INT64) -> ANY (STRING,INT64) -> STRING (ARRAY,INT64) -> ANY @@ -128,7 +128,7 @@ Binder exception: Cannot match a built-in function for given function LIST_EXTRA RETURN list[idx]; ---- error Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(INT64[],INT64[]). Supported inputs are -(VAR_LIST,INT64) -> ANY +(LIST,INT64) -> ANY (STRING,INT64) -> STRING (ARRAY,INT64) -> ANY @@ -136,6 +136,6 @@ Binder exception: Cannot match a built-in function for given function LIST_EXTRA RETURN list[idx]; ---- error Binder exception: Cannot match a built-in function for given function LIST_EXTRACT(INT64[],STRUCT(x:INT64)). Supported inputs are -(VAR_LIST,INT64) -> ANY +(LIST,INT64) -> ANY (STRING,INT64) -> STRING (ARRAY,INT64) -> ANY diff --git a/test/test_files/tck/expressions/list/List11.test b/test/test_files/tck/expressions/list/List11.test index cc59d17d122..5e617174f41 100644 --- a/test/test_files/tck/expressions/list/List11.test +++ b/test/test_files/tck/expressions/list/List11.test @@ -200,294 +200,294 @@ Runtime exception: Step of range cannot be 0. ## Outcome: an Error should be raised at runtime: InvalidArgumentType ---- error Binder exception: Cannot match a built-in function for given function RANGE(BOOL,INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, true, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,BOOL,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 1, true); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,INT64,BOOL). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(-1.1, 1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(DOUBLE,INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(-0.0, 1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(DOUBLE,INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0.0, 1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(DOUBLE,INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(1.1, 1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(DOUBLE,INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, -1.1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,DOUBLE,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, -0.0, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,DOUBLE,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 0.0, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,DOUBLE,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 1.1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,DOUBLE,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 1, -1.1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,INT64,DOUBLE). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 1, 1.1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,INT64,DOUBLE). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range('xyz', 1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(STRING,INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 'xyz', 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,STRING,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 1, 'xyz'); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,INT64,STRING). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range([0], 1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64[],INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, [1], 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,INT64[],INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 1, [1]); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,INT64,INT64[]). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range({start: 0}, 1, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(STRUCT(start:INT64),INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(0, 1, {step: 1}); ---- error Binder exception: Cannot match a built-in function for given function RANGE(INT64,INT64,STRUCT(step:INT64)). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST diff --git a/test/test_files/tck/match/match2.test b/test/test_files/tck/match/match2.test index e8eb7d79f33..4c06b5229e4 100644 --- a/test/test_files/tck/match/match2.test +++ b/test/test_files/tck/match/match2.test @@ -380,7 +380,7 @@ Binder exception: r has data type DOUBLE but (REL) was expected. Binder exception: r has data type STRING but (REL) was expected. -STATEMENT WITH [10] AS r MATCH ()-[r]-() RETURN r; ---- error -Binder exception: r has data type VAR_LIST but (REL) was expected. +Binder exception: r has data type LIST but (REL) was expected. -STATEMENT WITH {x: 1} AS r MATCH ()-[r]-() RETURN r; ---- error Binder exception: r has data type STRUCT but (REL) was expected. diff --git a/test/test_files/tck/match/match4.test b/test/test_files/tck/match/match4.test index dcc2c42d620..9802b38c3ca 100644 --- a/test/test_files/tck/match/match4.test +++ b/test/test_files/tck/match/match4.test @@ -66,7 +66,7 @@ ---- ok -STATEMENT CREATE REL TABLE T(FROM A TO A); ---- ok -# indexing on varlist causes segmentaion fault +# indexing on list causes segmentaion fault -STATEMENT CREATE (a {var: -2}), (b {var: 0}) WITH * UNWIND range(1, 20) AS i @@ -160,7 +160,7 @@ Binder exception: Bind relationship r to relationship with same name is not supp MATCH (first)-[rs*]->(second) RETURN first, second; ---- error -Binder exception: rs has data type VAR_LIST but (RECURSIVE_REL) was expected. +Binder exception: rs has data type LIST but (RECURSIVE_REL) was expected. # Fail when asterisk operator is missing # Fail on negative bound diff --git a/test/test_files/tinysnb/agg/hash.test b/test/test_files/tinysnb/agg/hash.test index c795470e8e4..4bcb6eaa913 100644 --- a/test/test_files/tinysnb/agg/hash.test +++ b/test/test_files/tinysnb/agg/hash.test @@ -353,7 +353,7 @@ True|\xAB\xCD {_ID: 0:2, _LABEL: person, ID: 3, fName: Carol, gender: 1, isStudent: False, isWorker: True, age: 45, eyeSight: 5.000000, birthdate: 1940-06-22, registerTime: 1911-08-20 02:32:21, lastJobDuration: 48:24:11, workedHours: [4,5], usedNames: [Carmen,Fred], courseScoresPerTerm: [[8,10]], grades: [91,75,21,95], height: 1.000000, u: a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a13}|9 {_ID: 0:3, _LABEL: person, ID: 5, fName: Dan, gender: 2, isStudent: False, isWorker: True, age: 20, eyeSight: 4.800000, birthdate: 1950-07-23, registerTime: 2031-11-30 12:25:30, lastJobDuration: 10 years 5 months 13:00:00.000024, workedHours: [1,9], usedNames: [Wolfeschlegelstein,Daniel], courseScoresPerTerm: [[7,4],[8,8],[9]], grades: [76,88,99,89], height: 1.300000, u: a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a14}|9 --CASE VarListHashTest +-CASE ListHashTest -STATEMENT CREATE (:person {ID: 17, usedNames: ['Alice'], workedHours: [1,2,3], courseScoresPerTerm: [[1,2],[3,4]]}) ---- ok -STATEMENT CREATE (:person {ID: 25, usedNames: ['Carmen'], workedHours: [10, 5], courseScoresPerTerm: [[1,2],[3,4]]}) diff --git a/test/test_files/tinysnb/cast/cast_error.test b/test/test_files/tinysnb/cast/cast_error.test index 1b41e89b3ae..74cbc2b7be6 100644 --- a/test/test_files/tinysnb/cast/cast_error.test +++ b/test/test_files/tinysnb/cast/cast_error.test @@ -581,24 +581,24 @@ Conversion exception: Cast failed. bool is not in INT64[] range. Conversion exception: Cast failed. [[231|4324] is not in INT64[][] range. -CASE CastStringToNestedError --STATEMENT LOAD WITH HEADERS (list STRING[][]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/delim_error.csv" (DELIM="|", ESCAPE="~", QUOTE="'") RETURN * ; +-STATEMENT LOAD WITH HEADERS (list STRING[][]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/delim_error.csv" (DELIM="|", ESCAPE="~", QUOTE="'") RETURN * ; ---- error -Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/delim_error.csv on line 1: Conversion exception: Cast failed. "[[hello],[bdfadf],]" is not in STRING[][] range. --STATEMENT LOAD WITH HEADERS (list STRING[][]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/bracket_error.csv" (DELIM="|", ESCAPE="~") RETURN * ; +Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/delim_error.csv on line 1: Conversion exception: Cast failed. "[[hello],[bdfadf],]" is not in STRING[][] range. +-STATEMENT LOAD WITH HEADERS (list STRING[][]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/bracket_error.csv" (DELIM="|", ESCAPE="~") RETURN * ; ---- error -Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/bracket_error.csv on line 1: Conversion exception: Cast failed. [[] is not in STRING[][] range. --STATEMENT LOAD WITH HEADERS (list STRING[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/single_quote.csv" RETURN *; +Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/bracket_error.csv on line 1: Conversion exception: Cast failed. [[] is not in STRING[][] range. +-STATEMENT LOAD WITH HEADERS (list STRING[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/single_quote.csv" RETURN *; ---- error -Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/single_quote.csv on line 1: Conversion exception: Cast failed. ['fdsfdsfe werw] is not in STRING[] range. --STATEMENT LOAD WITH HEADERS (list STRING[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/single_quote2.csv" RETURN *; +Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/single_quote.csv on line 1: Conversion exception: Cast failed. ['fdsfdsfe werw] is not in STRING[] range. +-STATEMENT LOAD WITH HEADERS (list STRING[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/single_quote2.csv" RETURN *; ---- error -Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/single_quote2.csv on line 1: Conversion exception: Cast failed. [[' this is a signle quote]] is not in STRING[] range. --STATEMENT LOAD WITH HEADERS (list UINT8[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/single_struct_bracket.csv" RETURN *; +Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/single_quote2.csv on line 1: Conversion exception: Cast failed. [[' this is a signle quote]] is not in STRING[] range. +-STATEMENT LOAD WITH HEADERS (list UINT8[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/single_struct_bracket.csv" RETURN *; ---- error -Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/single_struct_bracket.csv on line 1: Conversion exception: Cast failed. [{32, 32] is not in UINT8[] range. --STATEMENT LOAD WITH HEADERS (list UINT8[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/conversion_error.csv" RETURN *; +Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/single_struct_bracket.csv on line 1: Conversion exception: Cast failed. [{32, 32] is not in UINT8[] range. +-STATEMENT LOAD WITH HEADERS (list UINT8[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/conversion_error.csv" RETURN *; ---- error -Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/conversion_error.csv on line 1: Conversion exception: Cast failed. Could not convert "432412" to UINT8. +Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/conversion_error.csv on line 1: Conversion exception: Cast failed. Could not convert "432412" to UINT8. -STATEMENT LOAD WITH HEADERS (q STRUCT(a STRUCT(b STRING))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/struct/struct_bracket_error1.csv" RETURN *; ---- error Copy exception: Error in file ${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/struct/struct_bracket_error1.csv on line 1: Conversion exception: Cast failed. {a: {b: fsdf is not in STRUCT(a:STRUCT(b:STRING)) range. @@ -692,16 +692,16 @@ Conversion exception: Unsupported casting function from REL to TIMESTAMP. ---- error Conversion exception: Unsupported casting function from RECURSIVE_REL to INT64. --LOG InvalidVarListToVarList +-LOG InvalidListToList -STATEMENT RETURN cast([31231], "INT64[][]"); ---- error -Conversion exception: Unsupported casting function from INT64 to VAR_LIST. +Conversion exception: Unsupported casting function from INT64 to LIST. -STATEMENT RETURN cast([-1], "UINT8[]"); ---- error Overflow exception: Value -1 is not within UINT8 range -STATEMENT RETURN cast([[1, 1]], "UINT8[]"); ---- error -Conversion exception: Unsupported casting function from VAR_LIST to UINT8. +Conversion exception: Unsupported casting function from LIST to UINT8. -LOG InvalidMapToMap -STATEMENT RETURN cast(cast("{-1=3}", "MAP(INT64, INT64)"), "MAP(UINT8, UINT8)"); @@ -754,16 +754,16 @@ Overflow exception: Value 1000000000000000000 is not within INT16 range Overflow exception: Value 43121 is not within INT8 range -STATEMENT RETURN cast([[1000000000000000000]], "INT64[1]"); ---- error -Conversion exception: Unsupported casting function from VAR_LIST to INT64. +Conversion exception: Unsupported casting function from LIST to INT64. -STATEMENT RETURN cast([1, 2], "DOUBLE[100]"); ---- error -Conversion exception: Unsupported casting VAR_LIST with incorrect list entry to ARRAY. Expected: 100, Actual: 2. +Conversion exception: Unsupported casting LIST with incorrect list entry to ARRAY. Expected: 100, Actual: 2. -STATEMENT RETURN cast([[1, 2], [1, 4], [2, 4, 5], [1, 2]], "INT64[2][]"); ---- error -Conversion exception: Unsupported casting VAR_LIST with incorrect list entry to ARRAY. Expected: 2, Actual: 3. +Conversion exception: Unsupported casting LIST with incorrect list entry to ARRAY. Expected: 2, Actual: 3. -STATEMENT RETURN cast(cast("{3={}, 3= {a: 12}, 3={a:32, b:[1, 2, 3]}}", "MAP(STRING, STRUCT(a INT64, b INT64[]))"), "MAP(STRING, STRUCT(a INT64, b INT64[1]))"); ---- error -Conversion exception: Unsupported casting VAR_LIST with incorrect list entry to ARRAY. Expected: 1, Actual: 3. +Conversion exception: Unsupported casting LIST with incorrect list entry to ARRAY. Expected: 1, Actual: 3. -LOG InvalidArrayToArray -STATEMENT RETURN cast(cast([4, 1], "INT16[2]"), "FLOAT[3]"); @@ -776,10 +776,10 @@ Conversion exception: Unsupported casting function from INT16[2] to FLOAT[1]. -LOG InvalidNestedCast -STATEMENT RETURN cast({a: {b: {c: [[1, 3, 4]], d: "str"}}, e: [1, 9, NULL]}, "STRUCT(a STRUCT(b STRUCT(c INT64[2][], d STRING)), e INT128[3])"); ---- error -Conversion exception: Unsupported casting VAR_LIST with incorrect list entry to ARRAY. Expected: 2, Actual: 3. +Conversion exception: Unsupported casting LIST with incorrect list entry to ARRAY. Expected: 2, Actual: 3. -STATEMENT RETURN cast(cast("{a: {b: {c: [[1, 3, 4]], d: {18=[3, 2]}}}, e: [1, 9, 3]}", "STRUCT(a STRUCT(b STRUCT(c INT64[3][], d MAP(INT32,INT32[]))), e FLOAT[3])"), "STRUCT(a STRUCT(b STRUCT(c INT64[3][], d MAP(INT32,INT32[5]))), e INT32[3])"); ---- error -Conversion exception: Unsupported casting VAR_LIST with incorrect list entry to ARRAY. Expected: 5, Actual: 2. +Conversion exception: Unsupported casting LIST with incorrect list entry to ARRAY. Expected: 5, Actual: 2. -LOG InvalidNameCast -STATEMENT RETURN cast("nop", "STRUCT()"); diff --git a/test/test_files/tinysnb/cast/cast_to_nested_types.test b/test/test_files/tinysnb/cast/cast_to_nested_types.test index 3dc6ebfe8e8..e33e3c39254 100644 --- a/test/test_files/tinysnb/cast/cast_to_nested_types.test +++ b/test/test_files/tinysnb/cast/cast_to_nested_types.test @@ -4,7 +4,7 @@ -- -CASE CastToNestedTypes --STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array INT16[3]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/should_pass.csv" RETURN *; +-STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array INT16[3]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/should_pass.csv" RETURN *; ---- 10 [[1,3,423,124,43242],[432]]|{num: -423432, str: this is a string []}|[255,254,43] [[1,3,423,124,43242],[432]]|{num: 3423423, str: this is a string}|[250,249,21] @@ -16,7 +16,7 @@ []||[111,0,0] ||[0,111,12] |{num: , str: }|[0,0,0] --STATEMENT LOAD WITH HEADERS (list STRING[], str STRING, struct STRUCT(a STRUCT(b STRUCT(c INT64[])))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/change_config.csv" (HEADER=true, DELIM="|", DELIM="|", ESCAPE="~", QUOTE="'") RETURN * ; +-STATEMENT LOAD WITH HEADERS (list STRING[], str STRING, struct STRUCT(a STRUCT(b STRUCT(c INT64[])))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/change_config.csv" (HEADER=true, DELIM="|", DELIM="|", ESCAPE="~", QUOTE="'") RETURN * ; ---- 3 [escape,is escape success? ~]| ' [ ] do not need to escape sepeical | []|{a: {b: }} [this,is a word,normal not escape,' [ ] | , ~ ']|try escape ~|{a: {b: {c: [3432423,-43423,31231,]}}} @@ -74,7 +74,7 @@ True|2022-06-06|4324.123047|-32768| 0|0|2014-05-12 12:11:59|4324254534123134124032.000000|fsaf False|-4325||18446744073709551616.000000| dfsa --LOG CastToVarList +-LOG CastToList -STATEMENT RETURN cast(" [ [ 1 ,3, 423 , 124,43242 ] , [ 432 ]]", "INT64[][]"); ---- 1 [[1,3,423,124,43242],[432]] @@ -182,7 +182,7 @@ True|2019-03-19|-12.343200|32768| 0|0|2014-05-12 12:11:59|4324254534123134124032.000000|fsaf False|-4325|14|18446744073709551616.000000| dfsa --LOG CastVarListToVarList +-LOG CastListToList -STATEMENT RETURN cast([321, 432], "DOUBLE[]"), cast([321, 432], "FLOAT[]"), cast([321, 432], "INT128[]"), cast([321, 432], "INT64[]"), cast([321, 432], "INT32[]"), cast([321, 432], "INT16[]"), cast([-1, -43], "INT8[]"), cast([0, 23], "UINT8[]"), cast([0, 23], "UINT16[]"), cast([0, 23], "UINT32[]"), cast([0, 23], "UINT64[]"), cast([5435234412435123, -432425341231], "STRING[]"); ---- 1 [321.000000,432.000000]|[321.000000,432.000000]|[321,432]|[321,432]|[321,432]|[321,432]|[-1,-43]|[0,23]|[0,23]|[0,23]|[0,23]|[5435234412435123,-432425341231] @@ -190,7 +190,7 @@ False|-4325|14|18446744073709551616.000000| dfsa ---- 1 []|[,]||[,432124,0,] --LOG CastNestedVarListToNestedVarList +-LOG CastNestedListToNestedList -STATEMENT RETURN cast([[4324.2312, 432.321, 43242.543], [31214.59,4132.72], NULL, [NULL,,4324.32]], "INT64[][]"); ---- 1 [[4324,432,43243],[31215,4133],,[,,4324]] @@ -249,7 +249,7 @@ False|-4325|14|18446744073709551616.000000| dfsa -STATEMENT RETURN cast(cast(cast("{a: 12, b: 0}", "STRUCT(a STRING, b STRING, c STRING)"), "STRUCT(a INT128, b INT128, c INT128)"), "STRUCT(a INT64, b INT64, c INT64)"), cast(cast(cast("{a: 15}", "STRUCT(a STRING, b STRING)"), "STRUCT(a INT32, b INT32)"), "STRUCT(a INT16, b INT16)"), cast(cast(cast("{b: 15}", "STRUCT(a STRING, b STRING)"), "STRUCT(a INT8, b INT8)"), "STRUCT(a UINT16, b UINT16)"), cast(cast(cast("{}", "STRUCT(a STRING, b STRING)"), "STRUCT(a UINT32, b UINT32)"), "STRUCT(a UINT64, b UINT64)"), cast(cast("{a: 12, b: 0}", "STRUCT(a STRING, b STRING)"), "STRUCT(a DOUBLE, b DOUBLE)"), cast(cast("{a: 12, b: 0}", "STRUCT(a STRING, b STRING)"), "STRUCT(a FLOAT, b FLOAT)"); ---- 1 {a: 12, b: 0, c: }|{a: 15, b: }|{a: , b: 15}|{a: , b: }|{a: 12.000000, b: 0.000000}|{a: 12.000000, b: 0.000000} --STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array INT16[3]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/should_pass.csv" RETURN cast(a, "struct(num INT64, str STRING)"), cast(a, "struct(num INT128, str STRING)"), cast(a, "struct(num STRING, str STRING)"), cast(a, "struct(num DOUBLE, str STRING)"), cast(a, "struct(num FLOAT, str STRING)"); +-STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array INT16[3]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/should_pass.csv" RETURN cast(a, "struct(num INT64, str STRING)"), cast(a, "struct(num INT128, str STRING)"), cast(a, "struct(num STRING, str STRING)"), cast(a, "struct(num DOUBLE, str STRING)"), cast(a, "struct(num FLOAT, str STRING)"); ---- 10 {num: -423432, str: this is a string []}|{num: -423432, str: this is a string []}|{num: -423432, str: this is a string []}|{num: -423432.000000, str: this is a string []}|{num: -423432.000000, str: this is a string []} {num: 0, str: this is a string}|{num: 0, str: this is a string}|{num: 0, str: this is a string}|{num: 0.000000, str: this is a string}|{num: 0.000000, str: this is a string} @@ -263,7 +263,7 @@ False|-4325|14|18446744073709551616.000000| dfsa |||| -LOG CastNestedStructToStruct --STATEMENT LOAD WITH HEADERS (list STRING[], str STRING, struct STRUCT(a STRUCT(b STRUCT(c INT64[])))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/change_config.csv" (HEADER=true, DELIM="|", DELIM="|", ESCAPE="~", QUOTE="'") RETURN cast(struct, "STRUCT(a STRUCT(b STRUCT(c INT128[])))"), cast(struct, "STRUCT(a STRUCT(b STRUCT(c DOUBLE[])))"), cast(struct, "STRUCT(a STRUCT(b STRUCT(c STRING)))"), cast(struct, "STRUCT(a STRUCT(b STRING))"), cast(struct, "STRUCT(a STRING)"); +-STATEMENT LOAD WITH HEADERS (list STRING[], str STRING, struct STRUCT(a STRUCT(b STRUCT(c INT64[])))) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/change_config.csv" (HEADER=true, DELIM="|", DELIM="|", ESCAPE="~", QUOTE="'") RETURN cast(struct, "STRUCT(a STRUCT(b STRUCT(c INT128[])))"), cast(struct, "STRUCT(a STRUCT(b STRUCT(c DOUBLE[])))"), cast(struct, "STRUCT(a STRUCT(b STRUCT(c STRING)))"), cast(struct, "STRUCT(a STRUCT(b STRING))"), cast(struct, "STRUCT(a STRING)"); ---- 3 {a: {b: {c: [3432423,-43423,31231,]}}}|{a: {b: {c: [3432423.000000,-43423.000000,31231.000000,]}}}|{a: {b: {c: [3432423,-43423,31231,]}}}|{a: {b: {c: [3432423,-43423,31231,]}}}|{a: {b: {c: [3432423,-43423,31231,]}}} {a: {b: {c: }}}|{a: {b: {c: }}}|{a: {b: {c: }}}|{a: {b: {c: }}}|{a: {b: {c: }}} @@ -283,7 +283,7 @@ False|-4325|14|18446744073709551616.000000| dfsa -STATEMENT RETURN cast(cast("[1,2,3]", "INT64[3]"), "INT128[]"), cast(cast("[1,2,3]", "INT64[3]"), "INT64[]"), cast(cast("[1,2,3]", "INT64[3]"), "INT32[]"), cast(cast("[1,2,3]", "INT64[3]"), "INT16[]"), cast(cast("[1,2,3]", "INT64[3]"), "INT8[]"), cast(cast("[1,2,3]", "INT64[3]"), "UINT64[]"), cast(cast("[1,2,3]", "INT64[3]"), "UINT32[]"), cast(cast("[1,2,3]", "INT64[3]"), "UINT16[]"), cast(cast("[1,2,3]", "INT64[3]"), "UINT8[]"), cast(cast("[1,2,3]", "INT64[3]"), "DOUBLE[]"), cast(cast("[1,2,3]", "INT64[3]"), "STRING[]"), cast(cast("[1,2,3]", "INT64[3]"), "FLOAT[]"); ---- 1 [1,2,3]|[1,2,3]|[1,2,3]|[1,2,3]|[1,2,3]|[1,2,3]|[1,2,3]|[1,2,3]|[1,2,3]|[1.000000,2.000000,3.000000]|[1,2,3]|[1.000000,2.000000,3.000000] --STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array INT16[3]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/should_pass.csv" RETURN cast(cast(cast(array, "DOUBLE[]"), "STRING[]"), "FLOAT[]"); +-STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array INT16[3]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/should_pass.csv" RETURN cast(cast(cast(array, "DOUBLE[]"), "STRING[]"), "FLOAT[]"); ---- 10 @@ -305,7 +305,7 @@ False|-4325|14|18446744073709551616.000000| dfsa -STATEMENT RETURN cast([1], "INT64[1]"), cast([1], "INT32[1]"), cast([1], "INT16[1]"), cast([1], "DOUBLE[1]"), cast([1], "FLOAT[1]"), cast(NULL, "INT64[15]"); ---- 1 [1]|[1]|[1]|[1.000000]|[1.000000]| --STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array STRING[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/var_list/should_pass.csv" RETURN cast(cast(cast(array, "INT16[3]"), "STRING[]"), "FLOAT[3]"); +-STATEMENT LOAD WITH HEADERS (list INT64[][], a struct(num INT64, str STRING), array STRING[]) FROM "${KUZU_ROOT_DIRECTORY}/dataset/load-from-test/list/should_pass.csv" RETURN cast(cast(cast(array, "INT16[3]"), "STRING[]"), "FLOAT[3]"); ---- 10 diff --git a/test/test_files/tinysnb/exception/list.test b/test/test_files/tinysnb/exception/list.test index 20f8eef086f..30a1f6eb010 100644 --- a/test/test_files/tinysnb/exception/list.test +++ b/test/test_files/tinysnb/exception/list.test @@ -12,7 +12,7 @@ Binder exception: Expression LIST_CREATION(A,B) has data type STRING[] but expec -STATEMENT MATCH (a:person) RETURN array_concat(a.workedHours, a.age) ---- error Binder exception: Cannot match a built-in function for given function ARRAY_CONCAT(INT64[],INT64). Supported inputs are -(VAR_LIST,VAR_LIST) -> VAR_LIST +(LIST,LIST) -> LIST -STATEMENT MATCH (a:person) RETURN array_concat(a.workedHours, ['A']) ---- error diff --git a/test/test_files/tinysnb/function/map.test b/test/test_files/tinysnb/function/map.test index 24f09b0ac0b..ce02c8288fc 100644 --- a/test/test_files/tinysnb/function/map.test +++ b/test/test_files/tinysnb/function/map.test @@ -35,7 +35,7 @@ ---- 1 [3.200000] --LOG MapExtractVarList +-LOG MapExtractList -STATEMENT RETURN element_at(map([1, 88], [[4,5], [2,3,1]]), 1) ---- 1 [[4,5]] diff --git a/test/test_files/tinysnb/function/range.test b/test/test_files/tinysnb/function/range.test index 48c45a21d70..cb2a815a003 100644 --- a/test/test_files/tinysnb/function/range.test +++ b/test/test_files/tinysnb/function/range.test @@ -55,16 +55,16 @@ Runtime exception: Step of range cannot be 0. -STATEMENT MATCH (a) RETURN range(a.NAME, 4, 1); ---- error Binder exception: Cannot match a built-in function for given function RANGE(STRING,INT64,INT64). Supported inputs are -(INT64,INT64) -> VAR_LIST -(INT64,INT64,INT64) -> VAR_LIST -(INT32,INT32) -> VAR_LIST -(INT32,INT32,INT32) -> VAR_LIST -(INT16,INT16) -> VAR_LIST -(INT16,INT16,INT16) -> VAR_LIST -(INT8,INT8) -> VAR_LIST -(INT8,INT8,INT8) -> VAR_LIST -(SERIAL,SERIAL) -> VAR_LIST -(SERIAL,SERIAL,SERIAL) -> VAR_LIST +(INT64,INT64) -> LIST +(INT64,INT64,INT64) -> LIST +(INT32,INT32) -> LIST +(INT32,INT32,INT32) -> LIST +(INT16,INT16) -> LIST +(INT16,INT16,INT16) -> LIST +(INT8,INT8) -> LIST +(INT8,INT8,INT8) -> LIST +(SERIAL,SERIAL) -> LIST +(SERIAL,SERIAL,SERIAL) -> LIST -STATEMENT RETURN range(4, 3); ---- 1 [] diff --git a/test/test_files/tinysnb/nested_types/nested_types.test b/test/test_files/tinysnb/nested_types/nested_types.test index b660f0223af..f03a887af3a 100644 --- a/test/test_files/tinysnb/nested_types/nested_types.test +++ b/test/test_files/tinysnb/nested_types/nested_types.test @@ -185,7 +185,7 @@ Hubert Blaine Wolfeschlegelsteinhausenbergerdorff -STATEMENT MATCH (a) RETURN a.* UNION ALL MATCH (b) RETURN b.* ---- ok --CASE RelVarList +-CASE RelList -STATEMENT MATCH (a:person)-[r:knows]->(b:person) RETURN r.comments ---- 14 [rnme,m8sihsdnf2990nfiwf] diff --git a/test/test_files/tinysnb/path/path.test b/test/test_files/tinysnb/path/path.test index b1f8ab146a2..62d81362978 100644 --- a/test/test_files/tinysnb/path/path.test +++ b/test/test_files/tinysnb/path/path.test @@ -83,18 +83,18 @@ -STATEMENT MATCH p = (a:person)-[e:knows*1..2]->(b:person) RETURN size(a) ---- error Binder exception: Cannot match a built-in function for given function SIZE(NODE). Supported inputs are -(VAR_LIST) -> INT64 +(LIST) -> INT64 (MAP) -> INT64 (STRING) -> INT64 -STATEMENT MATCH p = (a:person)-[e:knows*1..2]->(b:person) RETURN size(p) ---- error Binder exception: Cannot match a built-in function for given function SIZE(RECURSIVE_REL). Supported inputs are -(VAR_LIST) -> INT64 +(LIST) -> INT64 (MAP) -> INT64 (STRING) -> INT64 -STATEMENT MATCH p = (a:person)-[e:knows]->(b:person) RETURN size(e) ---- error Binder exception: Cannot match a built-in function for given function SIZE(REL). Supported inputs are -(VAR_LIST) -> INT64 +(LIST) -> INT64 (MAP) -> INT64 (STRING) -> INT64 diff --git a/test/test_files/tinysnb/unwind/unwind.test b/test/test_files/tinysnb/unwind/unwind.test index 75c30785856..1c0e2c27fd7 100644 --- a/test/test_files/tinysnb/unwind/unwind.test +++ b/test/test_files/tinysnb/unwind/unwind.test @@ -17,10 +17,10 @@ Binder exception: Cannot set expression n with type VARIABLE. Expect node or rel Binder exception: Cannot delete expression n with type VARIABLE. Expect node or rel pattern. -STATEMENT UNWIND 1 AS a RETURN a; ---- error -Binder exception: 1 has data type INT64 but VAR_LIST was expected. +Binder exception: 1 has data type INT64 but LIST was expected. -STATEMENT MATCH p = (a:person)-[e:knows*1..2]->(b:person) UNWIND p AS x RETURN x; ---- error -Binder exception: p has data type RECURSIVE_REL but VAR_LIST was expected. +Binder exception: p has data type RECURSIVE_REL but LIST was expected. -STATEMENT MATCH p = (a:person)-[e:knows*1..1]->(b:person) UNWIND nodes(p) AS x RETURN x.fName, COUNT(*); ---- 7 Alice|6 diff --git a/test/test_files/update_node/create_empty.test b/test/test_files/update_node/create_empty.test index b2abd0f580c..74f7b552b7e 100644 --- a/test/test_files/update_node/create_empty.test +++ b/test/test_files/update_node/create_empty.test @@ -36,7 +36,7 @@ -STATEMENT COMMIT ---- ok --CASE CreateVarList +-CASE CreateList -STATEMENT CREATE NODE TABLE test(id INT64, prop STRING[], PRIMARY KEY(id)); ---- ok -STATEMENT CREATE (a:test {id:1, prop:['A', 'B', 'C', 'This is a long string for test']}) diff --git a/tools/java_api/src/jni/kuzu_java.cpp b/tools/java_api/src/jni/kuzu_java.cpp index 29911ef785b..4f7418cd988 100644 --- a/tools/java_api/src/jni/kuzu_java.cpp +++ b/tools/java_api/src/jni/kuzu_java.cpp @@ -545,7 +545,7 @@ JNIEXPORT jlong JNICALL Java_com_kuzudb_KuzuNative_kuzu_1data_1type_1create( auto extraTypeInfo = num_elements_in_array > 0 ? std::make_unique( std::move(child_type_pty), num_elements_in_array) : - std::make_unique(std::move(child_type_pty)); + std::make_unique(std::move(child_type_pty)); data_type = JavaAPIHelper::createLogicalType(logicalTypeID, std::move(extraTypeInfo)); } uint64_t address = reinterpret_cast(data_type); @@ -593,8 +593,8 @@ JNIEXPORT jobject JNICALL Java_com_kuzudb_KuzuNative_kuzu_1data_1type_1get_1chil LogicalType* child_type; if (parent_type->getLogicalTypeID() == LogicalTypeID::ARRAY) { child_type = ArrayType::getChildType(parent_type); - } else if (parent_type->getLogicalTypeID() == LogicalTypeID::VAR_LIST) { - child_type = VarListType::getChildType(parent_type); + } else if (parent_type->getLogicalTypeID() == LogicalTypeID::LIST) { + child_type = ListType::getChildType(parent_type); } else { return nullptr; } diff --git a/tools/java_api/src/main/java/com/kuzudb/KuzuDataTypeID.java b/tools/java_api/src/main/java/com/kuzudb/KuzuDataTypeID.java index 09fff10ef2c..20e94b971d2 100644 --- a/tools/java_api/src/main/java/com/kuzudb/KuzuDataTypeID.java +++ b/tools/java_api/src/main/java/com/kuzudb/KuzuDataTypeID.java @@ -31,7 +31,7 @@ public enum KuzuDataTypeID { INTERNAL_ID(42), STRING(50), BLOB(51), - VAR_LIST(52), + LIST(52), ARRAY(53), STRUCT(54), MAP(55), diff --git a/tools/java_api/src/test/java/com/kuzudb/test/DataTypeTest.java b/tools/java_api/src/test/java/com/kuzudb/test/DataTypeTest.java index 158db7e05a8..6829ff50fe3 100644 --- a/tools/java_api/src/test/java/com/kuzudb/test/DataTypeTest.java +++ b/tools/java_api/src/test/java/com/kuzudb/test/DataTypeTest.java @@ -16,11 +16,11 @@ void DataTypeClone() throws KuzuObjectRefDestroyedException { assertNotNull(dataTypeClone); assertEquals(dataTypeClone.getID(), KuzuDataTypeID.INT64); - KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.VAR_LIST, dataType, 0); + KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.LIST, dataType, 0); assertNotNull(dataType2); KuzuDataType dataTypeClone2 = dataType2.clone(); assertNotNull(dataTypeClone2); - assertEquals(dataTypeClone2.getID(), KuzuDataTypeID.VAR_LIST); + assertEquals(dataTypeClone2.getID(), KuzuDataTypeID.LIST); assertEquals(dataTypeClone2.getChildType().getID(), KuzuDataTypeID.INT64); KuzuDataType dataType3 = new KuzuDataType(KuzuDataTypeID.ARRAY, dataType, 100); @@ -49,7 +49,7 @@ void DataTypeEquals() throws KuzuObjectRefDestroyedException { assertNotNull(dataTypeClone); assertTrue(dataType.equals(dataTypeClone)); - KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.VAR_LIST, dataType, 0); + KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.LIST, dataType, 0); assertNotNull(dataType2); KuzuDataType dataTypeClone2 = dataType2.clone(); assertNotNull(dataTypeClone2); @@ -80,9 +80,9 @@ void DataTypeGetID() throws KuzuObjectRefDestroyedException { assertNotNull(dataType); assertEquals(dataType.getID(), KuzuDataTypeID.INT64); - KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.VAR_LIST, dataType, 0); + KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.LIST, dataType, 0); assertNotNull(dataType2); - assertEquals(dataType2.getID(), KuzuDataTypeID.VAR_LIST); + assertEquals(dataType2.getID(), KuzuDataTypeID.LIST); KuzuDataType dataType3 = new KuzuDataType(KuzuDataTypeID.ARRAY, dataType, 100); assertNotNull(dataType3); @@ -98,7 +98,7 @@ void DataTypeGetChildType() throws KuzuObjectRefDestroyedException { KuzuDataType dataType = new KuzuDataType(KuzuDataTypeID.INT64, null, 0); assertNotNull(dataType); - KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.VAR_LIST, dataType, 0); + KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.LIST, dataType, 0); assertNotNull(dataType2); assertEquals(dataType2.getChildType().getID(), KuzuDataTypeID.INT64); @@ -117,7 +117,7 @@ void DataTypeGetFixedNumElementsInList() throws KuzuObjectRefDestroyedException assertNotNull(dataType); assertEquals(dataType.getFixedNumElementsInList(), 0); - KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.VAR_LIST, dataType, 0); + KuzuDataType dataType2 = new KuzuDataType(KuzuDataTypeID.LIST, dataType, 0); assertNotNull(dataType2); assertEquals(dataType.getFixedNumElementsInList(), 0); diff --git a/tools/java_api/src/test/java/com/kuzudb/test/ValueTest.java b/tools/java_api/src/test/java/com/kuzudb/test/ValueTest.java index 00338caf143..4e1c057885e 100644 --- a/tools/java_api/src/test/java/com/kuzudb/test/ValueTest.java +++ b/tools/java_api/src/test/java/com/kuzudb/test/ValueTest.java @@ -323,7 +323,7 @@ void ValueGetDatatype() throws KuzuObjectRefDestroyedException { value = flatTuple.getValue(2); dataType = value.getDataType(); - assertEquals(dataType.getID(), KuzuDataTypeID.VAR_LIST); + assertEquals(dataType.getID(), KuzuDataTypeID.LIST); KuzuDataType childDataType = dataType.getChildType(); assertEquals(childDataType.getID(), KuzuDataTypeID.INT64); childDataType.destroy(); diff --git a/tools/nodejs_api/src_cpp/node_util.cpp b/tools/nodejs_api/src_cpp/node_util.cpp index bb925a884a3..fd676a9fc34 100644 --- a/tools/nodejs_api/src_cpp/node_util.cpp +++ b/tools/nodejs_api/src_cpp/node_util.cpp @@ -184,7 +184,7 @@ Napi::Value Util::ConvertToNapiObject(const Value& value, Napi::Env env) { auto milliseconds = microseconds / Interval::MICROS_PER_MSEC; return Napi::Number::New(env, milliseconds); } - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::ARRAY: { auto size = NestedVal::getChildrenSize(&value); auto napiArray = Napi::Array::New(env, size); diff --git a/tools/nodejs_api/test/test_data_type.js b/tools/nodejs_api/test/test_data_type.js index 75b4eb598c0..033eb107e95 100644 --- a/tools/nodejs_api/test/test_data_type.js +++ b/tools/nodejs_api/test/test_data_type.js @@ -339,8 +339,8 @@ describe("INTERVAL", function () { }); }); -describe("VAR_LIST", function () { - it("should convert VAR_LIST type", async function () { +describe("LIST", function () { + it("should convert LIST type", async function () { const queryResult = await conn.query( "MATCH (a:person) WHERE a.ID = 0 RETURN a.courseScoresPerTerm;" ); diff --git a/tools/python_api/src_cpp/pandas/pandas_analyzer.cpp b/tools/python_api/src_cpp/pandas/pandas_analyzer.cpp index 354aa9a55b3..0e8a35b3c66 100644 --- a/tools/python_api/src_cpp/pandas/pandas_analyzer.cpp +++ b/tools/python_api/src_cpp/pandas/pandas_analyzer.cpp @@ -11,14 +11,14 @@ static bool upgradeType(common::LogicalType& left, const common::LogicalType& ri return true; } if (left.getLogicalTypeID() == common::LogicalTypeID::ANY || - ((left.getLogicalTypeID() == common::LogicalTypeID::VAR_LIST) && - (common::VarListType::getChildType(&left)->getLogicalTypeID() == + ((left.getLogicalTypeID() == common::LogicalTypeID::LIST) && + (common::ListType::getChildType(&left)->getLogicalTypeID() == common::LogicalTypeID::ANY))) { left = right; return true; } - if (((right.getLogicalTypeID() == common::LogicalTypeID::VAR_LIST) && - (common::VarListType::getChildType(&right)->getLogicalTypeID() == + if (((right.getLogicalTypeID() == common::LogicalTypeID::LIST) && + (common::ListType::getChildType(&right)->getLogicalTypeID() == common::LogicalTypeID::ANY))) { return true; } @@ -71,7 +71,7 @@ common::LogicalType PandasAnalyzer::getItemType(py::object ele, bool& canConvert case PythonObjectType::String: return *common::LogicalType::STRING(); case PythonObjectType::List: - return *common::LogicalType::VAR_LIST(getListType(ele, canConvert)); + return *common::LogicalType::LIST(getListType(ele, canConvert)); default: KU_UNREACHABLE; } diff --git a/tools/python_api/src_cpp/py_connection.cpp b/tools/python_api/src_cpp/py_connection.cpp index 37f206a4976..b98c7bac3aa 100644 --- a/tools/python_api/src_cpp/py_connection.cpp +++ b/tools/python_api/src_cpp/py_connection.cpp @@ -194,12 +194,12 @@ static bool canCastPyLogicalType(const LogicalType& from, const LogicalType& to) canCastPyLogicalType(*toKeyType, *fromKeyType)) && (canCastPyLogicalType(*fromValueType, *toValueType) || canCastPyLogicalType(*toValueType, *fromValueType)); - } else if (from.getLogicalTypeID() == LogicalTypeID::VAR_LIST) { - if (to.getLogicalTypeID() != LogicalTypeID::VAR_LIST) { + } else if (from.getLogicalTypeID() == LogicalTypeID::LIST) { + if (to.getLogicalTypeID() != LogicalTypeID::LIST) { return false; } return canCastPyLogicalType( - *VarListType::getChildType(&from), *VarListType::getChildType(&to)); + *ListType::getChildType(&from), *ListType::getChildType(&to)); } else { auto castCost = function::BuiltInFunctionsUtils::getCastCost( from.getLogicalTypeID(), to.getLogicalTypeID()); @@ -266,7 +266,7 @@ static std::unique_ptr pyLogicalType(py::handle val) { auto curChildType = pyLogicalType(child); tryConvertPyLogicalType(*childType, *curChildType); } - return LogicalType::VAR_LIST(std::move(childType)); + return LogicalType::LIST(std::move(childType)); } else if (py::isinstance(val)) { py::dict dict = py::reinterpret_borrow(val); auto childKeyType = LogicalType::ANY(), childValueType = LogicalType::ANY(); @@ -343,12 +343,12 @@ static Value transformPythonValueAs(py::handle val, const LogicalType* type) { uuidToAppend.value = uuidVal; return Value{uuidToAppend}; } - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { py::list lst = py::reinterpret_borrow(val); std::vector> children; for (auto child : lst) { children.push_back(std::make_unique( - transformPythonValueAs(child, VarListType::getChildType(type)))); + transformPythonValueAs(child, ListType::getChildType(type)))); } return Value(std::make_unique(*type), std::move(children)); } diff --git a/tools/python_api/src_cpp/py_query_result.cpp b/tools/python_api/src_cpp/py_query_result.cpp index f20d3ea9b1b..6a8446e4bfa 100644 --- a/tools/python_api/src_cpp/py_query_result.cpp +++ b/tools/python_api/src_cpp/py_query_result.cpp @@ -242,7 +242,7 @@ py::object PyQueryResult::convertValueToPyObject(const Value& value) { return py::cast(importCache->datetime.timedelta()(py::arg("days") = days, py::arg("microseconds") = intervalVal.micros)); } - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::ARRAY: { py::list list; for (auto i = 0u; i < NestedVal::getChildrenSize(&value); ++i) { diff --git a/tools/python_api/src_cpp/py_query_result_converter.cpp b/tools/python_api/src_cpp/py_query_result_converter.cpp index 9fb9f2ef0a8..9c75c157d8b 100644 --- a/tools/python_api/src_cpp/py_query_result_converter.cpp +++ b/tools/python_api/src_cpp/py_query_result_converter.cpp @@ -94,7 +94,7 @@ void NPArrayWrapper::appendElement(Value* value) { ((py::object*)dataBuffer)[numElements] = PyQueryResult::convertValueToPyObject(*value); } break; case LogicalTypeID::ARRAY: - case LogicalTypeID::VAR_LIST: { + case LogicalTypeID::LIST: { ((py::list*)dataBuffer)[numElements] = PyQueryResult::convertValueToPyObject(*value); } break; case LogicalTypeID::RECURSIVE_REL: { @@ -173,7 +173,7 @@ py::dtype NPArrayWrapper::convertToArrayType(const LogicalType& type) { case LogicalTypeID::STRUCT: case LogicalTypeID::NODE: case LogicalTypeID::REL: - case LogicalTypeID::VAR_LIST: + case LogicalTypeID::LIST: case LogicalTypeID::ARRAY: case LogicalTypeID::STRING: case LogicalTypeID::MAP: diff --git a/tools/python_api/src_py/types.py b/tools/python_api/src_py/types.py index 4ec3f7b7830..4566e24af54 100644 --- a/tools/python_api/src_py/types.py +++ b/tools/python_api/src_py/types.py @@ -32,7 +32,7 @@ class Type(Enum): STRING = "STRING" BLOB = "BLOB" UUID = "UUID" - VAR_LIST = "VAR_LIST" + LIST = "LIST" ARRAY = "ARRAY" STRUCT = "STRUCT" MAP = "MAP" diff --git a/tools/rust_api/include/kuzu_rs.h b/tools/rust_api/include/kuzu_rs.h index 8cfca801b5e..0155aa4d97b 100644 --- a/tools/rust_api/include/kuzu_rs.h +++ b/tools/rust_api/include/kuzu_rs.h @@ -39,7 +39,7 @@ struct QueryParams { std::unique_ptr new_params(); std::unique_ptr create_logical_type(kuzu::common::LogicalTypeID id); -std::unique_ptr create_logical_type_var_list( +std::unique_ptr create_logical_type_list( std::unique_ptr childType); std::unique_ptr create_logical_type_array( std::unique_ptr childType, uint64_t numElements); @@ -68,7 +68,7 @@ inline std::unique_ptr create_logical_type_rdf_varian return kuzu::common::LogicalType::RDF_VARIANT(); } -const kuzu::common::LogicalType& logical_type_get_var_list_child_type( +const kuzu::common::LogicalType& logical_type_get_list_child_type( const kuzu::common::LogicalType& logicalType); const kuzu::common::LogicalType& logical_type_get_array_child_type( const kuzu::common::LogicalType& logicalType); diff --git a/tools/rust_api/src/connection.rs b/tools/rust_api/src/connection.rs index 68bae150e07..853d941f287 100644 --- a/tools/rust_api/src/connection.rs +++ b/tools/rust_api/src/connection.rs @@ -128,7 +128,7 @@ impl<'a> Connection<'a> { // should be generic. // // E.g. - // let result: QueryResult> = conn.query("...")?; + // let result: QueryResult> = conn.query("...")?; // let result: QueryResult = conn.query("...")?; // // But this would really just be syntactic sugar wrapping the current system diff --git a/tools/rust_api/src/ffi.rs b/tools/rust_api/src/ffi.rs index 00dc763f4f7..f906838285b 100644 --- a/tools/rust_api/src/ffi.rs +++ b/tools/rust_api/src/ffi.rs @@ -78,7 +78,7 @@ pub(crate) mod ffi { // variable size types STRING = 50, BLOB = 51, - VAR_LIST = 52, + LIST = 52, ARRAY = 53, STRUCT = 54, MAP = 55, @@ -205,9 +205,7 @@ pub(crate) mod ffi { fn getLogicalTypeID(&self) -> LogicalTypeID; fn create_logical_type(id: LogicalTypeID) -> UniquePtr; - fn create_logical_type_var_list( - child_type: UniquePtr, - ) -> UniquePtr; + fn create_logical_type_list(child_type: UniquePtr) -> UniquePtr; fn create_logical_type_array( child_type: UniquePtr, num_elements: u64, @@ -225,7 +223,7 @@ pub(crate) mod ffi { valueType: UniquePtr, ) -> UniquePtr; - fn logical_type_get_var_list_child_type(value: &LogicalType) -> &LogicalType; + fn logical_type_get_list_child_type(value: &LogicalType) -> &LogicalType; fn logical_type_get_array_child_type(value: &LogicalType) -> &LogicalType; fn logical_type_get_array_num_elements(value: &LogicalType) -> u64; fn logical_type_get_struct_field_names(value: &LogicalType) -> Vec; diff --git a/tools/rust_api/src/kuzu_rs.cpp b/tools/rust_api/src/kuzu_rs.cpp index 59f2e3d7aa5..545291d3424 100644 --- a/tools/rust_api/src/kuzu_rs.cpp +++ b/tools/rust_api/src/kuzu_rs.cpp @@ -8,7 +8,7 @@ using kuzu::common::NodeVal; using kuzu::common::RelVal; using kuzu::common::StructField; using kuzu::common::Value; -using kuzu::common::VarListTypeInfo; +using kuzu::common::ListTypeInfo; using kuzu::main::Connection; using kuzu::main::Database; using kuzu::main::SystemConfig; @@ -22,8 +22,8 @@ std::unique_ptr new_params() { std::unique_ptr create_logical_type(kuzu::common::LogicalTypeID id) { return std::make_unique(id); } -std::unique_ptr create_logical_type_var_list(std::unique_ptr childType) { - return LogicalType::VAR_LIST(std::move(childType)); +std::unique_ptr create_logical_type_list(std::unique_ptr childType) { + return LogicalType::LIST(std::move(childType)); } std::unique_ptr create_logical_type_array( @@ -36,8 +36,8 @@ std::unique_ptr create_logical_type_map( return LogicalType::MAP(std::move(keyType), std::move(valueType)); } -const LogicalType& logical_type_get_var_list_child_type(const LogicalType& logicalType) { - return *kuzu::common::VarListType::getChildType(&logicalType); +const LogicalType& logical_type_get_list_child_type(const LogicalType& logicalType) { + return *kuzu::common::ListType::getChildType(&logicalType); } const LogicalType& logical_type_get_array_child_type(const LogicalType& logicalType) { return *kuzu::common::ArrayType::getChildType(&logicalType); diff --git a/tools/rust_api/src/logical_type.rs b/tools/rust_api/src/logical_type.rs index 69195603d82..2b562b8707d 100644 --- a/tools/rust_api/src/logical_type.rs +++ b/tools/rust_api/src/logical_type.rs @@ -54,8 +54,8 @@ pub enum LogicalType { String, /// Correponds to [Value::Blob](crate::value::Value::Blob) Blob, - /// Correponds to [Value::VarList](crate::value::Value::VarList) - VarList { + /// Correponds to [Value::List](crate::value::Value::List) + List { child_type: Box, }, /// Correponds to [Value::Array](crate::value::Value::Array) @@ -118,10 +118,8 @@ impl From<&ffi::LogicalType> for LogicalType { LogicalTypeID::TIMESTAMP_MS => LogicalType::TimestampMs, LogicalTypeID::TIMESTAMP_SEC => LogicalType::TimestampSec, LogicalTypeID::INTERNAL_ID => LogicalType::InternalID, - LogicalTypeID::VAR_LIST => LogicalType::VarList { - child_type: Box::new( - ffi::logical_type_get_var_list_child_type(logical_type).into(), - ), + LogicalTypeID::LIST => LogicalType::List { + child_type: Box::new(ffi::logical_type_get_list_child_type(logical_type).into()), }, LogicalTypeID::ARRAY => LogicalType::Array { child_type: Box::new(ffi::logical_type_get_array_child_type(logical_type).into()), @@ -141,7 +139,7 @@ impl From<&ffi::LogicalType> for LogicalType { LogicalTypeID::REL => LogicalType::Rel, LogicalTypeID::RECURSIVE_REL => LogicalType::RecursiveRel, LogicalTypeID::MAP => { - let child_types = ffi::logical_type_get_var_list_child_type(logical_type); + let child_types = ffi::logical_type_get_list_child_type(logical_type); let types = ffi::logical_type_get_struct_field_types(child_types); let key_type = types .as_ref() @@ -212,8 +210,8 @@ impl From<&LogicalType> for cxx::UniquePtr { | LogicalType::Rel | LogicalType::RecursiveRel | LogicalType::UUID => ffi::create_logical_type(typ.id()), - LogicalType::VarList { child_type } => { - ffi::create_logical_type_var_list(child_type.as_ref().into()) + LogicalType::List { child_type } => { + ffi::create_logical_type_list(child_type.as_ref().into()) } LogicalType::Array { child_type, @@ -276,7 +274,7 @@ impl LogicalType { LogicalType::TimestampMs => LogicalTypeID::TIMESTAMP_MS, LogicalType::TimestampSec => LogicalTypeID::TIMESTAMP_SEC, LogicalType::InternalID => LogicalTypeID::INTERNAL_ID, - LogicalType::VarList { .. } => LogicalTypeID::VAR_LIST, + LogicalType::List { .. } => LogicalTypeID::LIST, LogicalType::Array { .. } => LogicalTypeID::ARRAY, LogicalType::Struct { .. } => LogicalTypeID::STRUCT, LogicalType::Node => LogicalTypeID::NODE, diff --git a/tools/rust_api/src/value.rs b/tools/rust_api/src/value.rs index 272a6d728c7..9f07af1bed9 100644 --- a/tools/rust_api/src/value.rs +++ b/tools/rust_api/src/value.rs @@ -244,7 +244,7 @@ pub enum Value { // LogicalType is necessary so that we can pass the correct type to the C++ API if the list is empty. /// These must contain elements which are all the given type. /// - VarList(LogicalType, Vec), + List(LogicalType, Vec), /// These must contain elements which are all the same type. /// Array(LogicalType, Vec), @@ -300,7 +300,7 @@ impl std::fmt::Display for Value { Value::String(x) => write!(f, "{x}"), Value::Blob(x) => write!(f, "{x:x?}"), Value::Null(_) => write!(f, ""), - Value::VarList(_, x) | Value::Array(_, x) => display_list(f, x), + Value::List(_, x) | Value::Array(_, x) => display_list(f, x), // Note: These don't match kuzu's toString, but we probably don't want them to Value::Interval(x) => write!(f, "{x}"), Value::Timestamp(x) => write!(f, "{x}"), @@ -373,7 +373,7 @@ impl From<&Value> for LogicalType { Value::String(_) => LogicalType::String, Value::Blob(_) => LogicalType::Blob, Value::Null(x) => x.clone(), - Value::VarList(x, _) => LogicalType::VarList { + Value::List(x, _) => LogicalType::List { child_type: Box::new(x.clone()), }, Value::Array(x, value) => LogicalType::Array { @@ -497,14 +497,14 @@ impl TryFrom<&ffi::Value> for Value { .map(Value::TimestampSec) .ok_or(ConversionError::TimestampSec(sec)) } - LogicalTypeID::VAR_LIST => { + LogicalTypeID::LIST => { let mut result = vec![]; for index in 0..ffi::value_get_children_size(value) { let value: Value = ffi::value_get_child(value, index).try_into()?; result.push(value); } - if let LogicalType::VarList { child_type } = value.into() { - Ok(Value::VarList(*child_type, result)) + if let LogicalType::List { child_type } = value.into() { + Ok(Value::List(*child_type, result)) } else { unreachable!() } @@ -612,7 +612,7 @@ impl TryFrom<&ffi::Value> for Value { LogicalTypeID::RECURSIVE_REL => { let nodes: Value = ffi::recursive_rel_get_nodes(value).try_into()?; let rels: Value = ffi::recursive_rel_get_rels(value).try_into()?; - let nodes = if let Value::VarList(LogicalType::Node, nodes) = nodes { + let nodes = if let Value::List(LogicalType::Node, nodes) = nodes { nodes.into_iter().map(|x| { if let Value::Node(x) = x { x @@ -623,7 +623,7 @@ impl TryFrom<&ffi::Value> for Value { } else { panic!("Unexpected value in RecursiveRel's rels: {}", rels) }; - let rels = if let Value::VarList(LogicalType::Rel, rels) = rels { + let rels = if let Value::List(LogicalType::Rel, rels) = rels { rels.into_iter().map(|x| { if let Value::Rel(x) = x { x @@ -811,13 +811,13 @@ impl TryInto> for Value { let (months, days, micros) = get_interval_t(value); Ok(ffi::create_value_interval(months, days, micros)) } - Value::VarList(typ, value) => { + Value::List(typ, value) => { let mut builder = ffi::create_list(); for elem in value { builder.pin_mut().insert(elem.try_into()?); } Ok(ffi::get_list_value( - (&LogicalType::VarList { + (&LogicalType::List { child_type: Box::new(typ), }) .into(), @@ -1122,7 +1122,7 @@ mod tests { } type_tests! { - convert_var_list_type: LogicalType::VarList { child_type: Box::new(LogicalType::String) }, + convert_list_type: LogicalType::List { child_type: Box::new(LogicalType::String) }, convert_array_type: LogicalType::Array { child_type: Box::new(LogicalType::Int64), num_elements: 3 }, convert_int8_type: LogicalType::Int8, convert_int16_type: LogicalType::Int16, @@ -1157,8 +1157,8 @@ mod tests { } value_tests! { - convert_var_list: Value::VarList(LogicalType::String, vec!["Alice".into(), "Bob".into()]), - convert_var_list_empty: Value::VarList(LogicalType::String, vec![]), + convert_list: Value::List(LogicalType::String, vec!["Alice".into(), "Bob".into()]), + convert_list_empty: Value::List(LogicalType::String, vec![]), convert_array: Value::Array(LogicalType::String, vec!["Alice".into(), "Bob".into()]), convert_int8: Value::Int8(0), convert_int16: Value::Int16(1), @@ -1186,7 +1186,7 @@ mod tests { convert_string: Value::String("Hello World".to_string()), convert_blob: Value::Blob("Hello World".into()), convert_bool: Value::Bool(false), - convert_null: Value::Null(LogicalType::VarList { + convert_null: Value::Null(LogicalType::List { child_type: Box::new(LogicalType::Array { child_type: Box::new(LogicalType::Int16), num_elements: 3 }) }), convert_struct: Value::Struct(vec![("NAME".to_string(), "Alice".into()), ("AGE".to_string(), 25.into())]), @@ -1200,8 +1200,8 @@ mod tests { } display_tests! { - display_var_list: Value::VarList(LogicalType::String, vec!["Alice".into(), "Bob".into()]), - display_var_list_empty: Value::VarList(LogicalType::String, vec![]), + display_list: Value::List(LogicalType::String, vec!["Alice".into(), "Bob".into()]), + display_list_empty: Value::List(LogicalType::String, vec![]), display_array: Value::Array(LogicalType::String, vec!["Alice".into(), "Bob".into()]), display_int8: Value::Int8(0), display_int16: Value::Int16(1), @@ -1218,7 +1218,7 @@ mod tests { // The C++ API escapes data in the blob as hex display_string: Value::String("Hello World".to_string()), display_bool: Value::Bool(false), - display_null: Value::Null(LogicalType::VarList { + display_null: Value::Null(LogicalType::List { child_type: Box::new(LogicalType::Array { child_type: Box::new(LogicalType::Int16), num_elements: 3 }) }), display_struct: Value::Struct(vec![("NAME".to_string(), "Alice".into()), ("AGE".to_string(), 25.into())]), @@ -1237,8 +1237,8 @@ mod tests { database_tests! { // Passing these values as arguments is not yet implemented in kuzu: - // db_var_list_string: Value::VarList(LogicalType::String, vec!["Alice".into(), "Bob".into()]), "STRING[]", - // db_var_list_int: Value::VarList(LogicalType::Int64, vec![0i64.into(), 1i64.into(), 2i64.into()]), "INT64[]", + // db_list_string: Value::List(LogicalType::String, vec!["Alice".into(), "Bob".into()]), "STRING[]", + // db_list_int: Value::List(LogicalType::Int64, vec![0i64.into(), 1i64.into(), 2i64.into()]), "INT64[]", // db_map: Value::Map((LogicalType::String, LogicalType::Int64), vec![(Value::String("key".to_string()), Value::Int64(24))]), "MAP(STRING,INT64)", // db_array: Value::Array(LogicalType::Int64, vec![1i64.into(), 2i64.into(), 3i64.into()]), "INT64[3]", // db_union: Value::Union { @@ -1250,7 +1250,7 @@ mod tests { "STRUCT(item STRING, count INT32)", db_null_string: Value::Null(LogicalType::String), "STRING", db_null_int: Value::Null(LogicalType::Int64), "INT64", - db_null_list: Value::Null(LogicalType::VarList { + db_null_list: Value::Null(LogicalType::List { child_type: Box::new(LogicalType::Array { child_type: Box::new(LogicalType::Int16), num_elements: 3 }) }), "INT16[3][]", db_int8: Value::Int8(0), "INT8", @@ -1280,7 +1280,7 @@ mod tests { #[test] /// Tests that the list value is correctly constructed - fn test_var_list_get() -> Result<()> { + fn test_list_get() -> Result<()> { let temp_dir = tempfile::tempdir()?; let db = Database::new(temp_dir.path(), SystemConfig::default())?; let conn = Connection::new(&db)?; @@ -1288,7 +1288,7 @@ mod tests { assert_eq!(result.len(), 1); assert_eq!( result[0], - Value::VarList(LogicalType::String, vec!["Alice".into(), "Bob".into(),]) + Value::List(LogicalType::String, vec!["Alice".into(), "Bob".into(),]) ); } temp_dir.close()?;