duckdb 0.6.2-dev919.0 → 0.6.2-dev939.0

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -195,9 +195,6 @@ enum class PhysicalType : uint8_t {
 	///// ArrayData struct
 	//DICTIONARY = 26,
 
-	/// Map, a repeated struct logical type
-	MAP = 27,
-
 	///// Custom data type, implemented by user
 	//EXTENSION = 28,
 
@@ -410,6 +407,7 @@ public:
 	DUCKDB_API static LogicalType LIST( LogicalType child);                       // NOLINT
 	DUCKDB_API static LogicalType STRUCT( child_list_t<LogicalType> children);    // NOLINT
 	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
+	DUCKDB_API static LogicalType MAP(LogicalType child);				// NOLINT
 	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT
 	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value); // NOLINT
 	DUCKDB_API static LogicalType UNION( child_list_t<LogicalType> members);     // NOLINT

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -83,6 +83,10 @@ public:
 	}
 };
 
+struct ListCast {
+	static bool ListToListCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+};
+
 struct StructBoundCastData : public BoundCastData {
 	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p)
 	    : child_cast_info(move(child_casts)), target(move(target_p)) {

package/src/duckdb/src/main/capi/logical_types-c.cpp

@@ -151,11 +151,12 @@ char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index) {
 }
 
 duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) {
-	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::LIST)) {
+	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::LIST) &&
+	    !AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
 		return nullptr;
 	}
 	auto &ltype = *((duckdb::LogicalType *)type);
-	if (ltype.id() != duckdb::LogicalTypeId::LIST) {
+	if (ltype.id() != duckdb::LogicalTypeId::LIST && ltype.id() != duckdb::LogicalTypeId::MAP) {
 		return nullptr;
 	}
 	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(duckdb::ListType::GetChildType(ltype)));

package/src/duckdb/src/parser/transform/helpers/transform_typename.cpp

@@ -54,21 +54,14 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 		D_ASSERT(!children.empty());
 		result_type = LogicalType::STRUCT(move(children));
 	} else if (base_type == LogicalTypeId::MAP) {
-		//! We transform MAP<TYPE_KEY, TYPE_VALUE> to STRUCT<LIST<key: TYPE_KEY>, LIST<value: TYPE_VALUE>>
 
 		if (!type_name->typmods || type_name->typmods->length != 2) {
 			throw ParserException("Map type needs exactly two entries, key and value type");
 		}
-		child_list_t<LogicalType> children;
 		auto key_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)type_name->typmods->head->data.ptr_value);
 		auto value_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)type_name->typmods->tail->data.ptr_value);
 
-		children.push_back({"key", LogicalType::LIST(key_type)});
-		children.push_back({"value", LogicalType::LIST(value_type)});
-
-		D_ASSERT(children.size() == 2);
-
-		result_type = LogicalType::MAP(move(children));
+		result_type = LogicalType::MAP(move(key_type), move(value_type));
 	} else if (base_type == LogicalTypeId::UNION) {
 		if (!type_name->typmods || type_name->typmods->length == 0) {
 			throw ParserException("Union type needs at least one member");

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -176,24 +176,26 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 }
 
 void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const string &catalog, const string &schema) {
-	if (type.id() == LogicalTypeId::LIST) {
+	if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP) {
 		auto child_type = ListType::GetChildType(type);
 		BindLogicalType(context, child_type, catalog, schema);
 		auto alias = type.GetAlias();
-		type = LogicalType::LIST(child_type);
+		if (type.id() == LogicalTypeId::LIST) {
+			type = LogicalType::LIST(child_type);
+		} else {
+			D_ASSERT(child_type.id() == LogicalTypeId::STRUCT); // map must be list of structs
+			type = LogicalType::MAP(child_type);
+		}
+
 		type.SetAlias(alias);
-	} else if (type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::MAP) {
+	} else if (type.id() == LogicalTypeId::STRUCT) {
 		auto child_types = StructType::GetChildTypes(type);
 		for (auto &child_type : child_types) {
 			BindLogicalType(context, child_type.second, catalog, schema);
 		}
-		// Generate new Struct/Map Type
+		// Generate new Struct Type
 		auto alias = type.GetAlias();
-		if (type.id() == LogicalTypeId::STRUCT) {
-			type = LogicalType::STRUCT(child_types);
-		} else {
-			type = LogicalType::MAP(child_types);
-		}
+		type = LogicalType::STRUCT(child_types);
 		type.SetAlias(alias);
 	} else if (type.id() == LogicalTypeId::UNION) {
 		auto member_types = UnionType::CopyMemberTypes(type);

package/src/duckdb/src/planner/expression_binder.cpp

@@ -120,8 +120,7 @@ bool ExpressionBinder::ContainsType(const LogicalType &type, LogicalTypeId targe
 		return true;
 	}
 	switch (type.id()) {
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP: {
+	case LogicalTypeId::STRUCT: {
 		auto child_count = StructType::GetChildCount(type);
 		for (idx_t i = 0; i < child_count; i++) {
 			if (ContainsType(StructType::GetChildType(type, i), target)) {
@@ -140,6 +139,7 @@ bool ExpressionBinder::ContainsType(const LogicalType &type, LogicalTypeId targe
 		return false;
 	}
 	case LogicalTypeId::LIST:
+	case LogicalTypeId::MAP:
 		return ContainsType(ListType::GetChildType(type), target);
 	default:
 		return false;
@@ -151,15 +151,13 @@ LogicalType ExpressionBinder::ExchangeType(const LogicalType &type, LogicalTypeI
 		return new_type;
 	}
 	switch (type.id()) {
-	case LogicalTypeId::STRUCT:
-	case LogicalTypeId::MAP: {
+	case LogicalTypeId::STRUCT: {
 		// we make a copy of the child types of the struct here
 		auto child_types = StructType::GetChildTypes(type);
 		for (auto &child_type : child_types) {
 			child_type.second = ExchangeType(child_type.second, target, new_type);
 		}
-		return type.id() == LogicalTypeId::MAP ? LogicalType::MAP(move(child_types))
-		                                       : LogicalType::STRUCT(move(child_types));
+		return LogicalType::STRUCT(move(child_types));
 	}
 	case LogicalTypeId::UNION: {
 		auto member_types = UnionType::CopyMemberTypes(type);
@@ -170,6 +168,8 @@ LogicalType ExpressionBinder::ExchangeType(const LogicalType &type, LogicalTypeI
 	}
 	case LogicalTypeId::LIST:
 		return LogicalType::LIST(ExchangeType(ListType::GetChildType(type), target, new_type));
+	case LogicalTypeId::MAP:
+		return LogicalType::MAP(ExchangeType(ListType::GetChildType(type), target, new_type));
 	default:
 		return type;
 	}

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 40;
+const uint64_t VERSION_NUMBER = 41;
 
 struct StorageVersionInfo {
 	const char *version_name;