duckdb 0.6.2-dev919.0 → 0.6.2-dev942.0

package/src/duckdb/src/function/table/system/test_all_types.cpp

@@ -177,9 +177,20 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 
 	// map
 	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	auto min_map_value = Value::MAP(Value::EMPTYLIST(LogicalType::VARCHAR), Value::EMPTYLIST(LogicalType::VARCHAR));
-	auto max_map_value = Value::MAP(Value::LIST({Value("key1"), Value("key2")}),
-	                                Value::LIST({Value("🦆🦆🦆🦆🦆🦆"), Value("goose")}));
+	auto min_map_value = Value::MAP(ListType::GetChildType(map_type), std::vector<Value>());
+
+	child_list_t<Value> map_struct1;
+	map_struct1.push_back(make_pair("key", Value("key1")));
+	map_struct1.push_back(make_pair("value", Value("🦆🦆🦆🦆🦆🦆")));
+	child_list_t<Value> map_struct2;
+	map_struct2.push_back(make_pair("key", Value("key2")));
+	map_struct2.push_back(make_pair("key", Value("goose")));
+
+	std::vector<Value> map_values;
+	map_values.push_back(Value::STRUCT(map_struct1));
+	map_values.push_back(Value::STRUCT(map_struct2));
+
+	auto max_map_value = Value::MAP(ListType::GetChildType(map_type), map_values);
 	result.emplace_back(map_type, "map", move(min_map_value), move(max_map_value));
 
 	return result;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev919"
+#define DUCKDB_VERSION "0.6.2-dev942"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "36f637a40a"
+#define DUCKDB_SOURCE_ID "2dcdc24556"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -157,8 +157,8 @@ public:
 	DUCKDB_API static Value LIST(LogicalType child_type, vector<Value> values);
 	//! Create an empty list with the specified child-type
 	DUCKDB_API static Value EMPTYLIST(LogicalType child_type);
-	//! Create a map value from a (key, value) pair
-	DUCKDB_API static Value MAP(Value key, Value value);
+	//! Create a map value with the given entries
+	DUCKDB_API static Value MAP(LogicalType child_type, vector<Value> values);
 	//! Create a union value from a selected value and a tag from a set of alternatives.
 	DUCKDB_API static Value UNION(child_list_t<LogicalType> members, uint8_t tag, Value value);
 

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

@@ -304,6 +304,7 @@ struct FlatVector {
 		return !vector.validity.RowIsValid(idx);
 	}
 	DUCKDB_API static const SelectionVector *IncrementalSelectionVector();
+	static Value GetValuesFromOffsets(Vector &values, vector<idx_t> &offsets);
 };
 
 struct ListVector {
@@ -330,8 +331,6 @@ struct ListVector {
 	DUCKDB_API static void Append(Vector &target, const Vector &source, const SelectionVector &sel, idx_t source_size,
 	                              idx_t source_offset = 0);
 	DUCKDB_API static void PushBack(Vector &target, const Value &insert);
-	DUCKDB_API static vector<idx_t> Search(Vector &list, const Value &key, idx_t row);
-	DUCKDB_API static Value GetValuesFromOffsets(Vector &list, vector<idx_t> &offsets);
 	//! Share the entry of the other list vector
 	DUCKDB_API static void ReferenceEntry(Vector &vector, Vector &other);
 };
@@ -409,6 +408,7 @@ struct MapVector {
 	DUCKDB_API static const Vector &GetValues(const Vector &vector);
 	DUCKDB_API static Vector &GetKeys(Vector &vector);
 	DUCKDB_API static Vector &GetValues(Vector &vector);
+	static vector<idx_t> Search(Vector &keys, idx_t count, const Value &key, list_entry_t &entry);
 };
 
 struct StructVector {

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;