duckdb 0.7.1-dev320.0 → 0.7.1-dev341.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.1-dev320.0",
+  "version": "0.7.1-dev341.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/common/types/partitioned_column_data.cpp

@@ -137,6 +137,7 @@ void PartitionedColumnData::FlushAppendState(PartitionedColumnDataAppendState &s
 		auto &partition_buffer = *state.partition_buffers[i];
 		if (partition_buffer.size() > 0) {
 			partitions[i]->Append(partition_buffer);
+			partition_buffer.Reset();
 		}
 	}
 }

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -169,6 +169,10 @@ private:
 };
 
 void WindowGlobalSinkState::ResizeGroupingData(idx_t cardinality) {
+	//	Have we started to combine? Then just live with it.
+	if (grouping_data && !grouping_data->GetPartitions().empty()) {
+		return;
+	}
 	//	Is the average partition size too large?
 	const idx_t partition_size = STANDARD_ROW_GROUPS_SIZE;
 	const auto bits = grouping_data ? grouping_data->GetRadixBits() : 0;
@@ -180,31 +184,7 @@ void WindowGlobalSinkState::ResizeGroupingData(idx_t cardinality) {
 	// Repartition the grouping data
 	if (new_bits != bits) {
 		const auto hash_col_idx = payload_types.size();
-		auto new_grouping_data =
-		    make_unique<RadixPartitionedColumnData>(context, grouping_types, new_bits, hash_col_idx);
-
-		// We have to append to a shared copy for some reason
-		if (grouping_data) {
-			auto new_shared = new_grouping_data->CreateShared();
-			PartitionedColumnDataAppendState shared_append;
-			new_shared->InitializeAppendState(shared_append);
-
-			auto &partitions = grouping_data->GetPartitions();
-			for (auto &partition : partitions) {
-				ColumnDataScanState scanner;
-				partition->InitializeScan(scanner);
-
-				DataChunk scan_chunk;
-				partition->InitializeScanChunk(scan_chunk);
-				for (scan_chunk.Reset(); partition->Scan(scanner, scan_chunk); scan_chunk.Reset()) {
-					new_shared->Append(shared_append, scan_chunk);
-				}
-			}
-			new_shared->FlushAppendState(shared_append);
-			new_grouping_data->Combine(*new_shared);
-		}
-
-		grouping_data = std::move(new_grouping_data);
+		grouping_data = make_unique<RadixPartitionedColumnData>(context, grouping_types, new_bits, hash_col_idx);
 	}
 }
 
@@ -432,8 +412,6 @@ void WindowLocalSinkState::Sink(DataChunk &input_chunk, WindowGlobalSinkState &g
 	}
 
 	// OVER(...)
-	gstate.UpdateLocalPartition(local_partition, local_append);
-
 	payload_chunk.Reset();
 	auto &hash_vector = payload_chunk.data.back();
 	Hash(input_chunk, hash_vector);
@@ -442,6 +420,7 @@ void WindowLocalSinkState::Sink(DataChunk &input_chunk, WindowGlobalSinkState &g
 	}
 	payload_chunk.SetCardinality(input_chunk);
 
+	gstate.UpdateLocalPartition(local_partition, local_append);
 	local_partition->Append(*local_append, payload_chunk);
 }
 

package/src/duckdb/src/function/scalar/map/map.cpp

@@ -66,46 +66,94 @@ void MapConversionVerify(Vector &vector, idx_t count) {
 	}
 }
 
-static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
-
-	//! Otherwise if its not a constant vector, this breaks the optimizer
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
+// Example:
+// source: [1,2,3], expansion_factor: 4
+// target (result): [1,2,3,1,2,3,1,2,3,1,2,3]
+static void CreateExpandedVector(const Vector &source, Vector &target, idx_t expansion_factor) {
+	idx_t count = ListVector::GetListSize(source);
+	auto &entry = ListVector::GetEntry(source);
+
+	idx_t target_idx = 0;
+	for (idx_t copy = 0; copy < expansion_factor; copy++) {
+		for (idx_t key_idx = 0; key_idx < count; key_idx++) {
+			target.SetValue(target_idx, entry.GetValue(key_idx));
+			target_idx++;
 		}
 	}
+	D_ASSERT(target_idx == count * expansion_factor);
+}
+
+static void AlignVectorToReference(const Vector &original, const Vector &reference, idx_t tuple_count, Vector &result) {
+	auto original_length = ListVector::GetListSize(original);
+	auto new_length = ListVector::GetListSize(reference);
+
+	Vector expanded_const(ListType::GetChildType(original.GetType()), new_length);
+
+	auto expansion_factor = new_length / original_length;
+	if (expansion_factor != tuple_count) {
+		throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different "
+		                            "size or incompatible structure");
+	}
+	CreateExpandedVector(original, expanded_const, expansion_factor);
+	result.Reference(expanded_const);
+}
+
+static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
 
 	auto &key_vector = MapVector::GetKeys(result);
 	auto &value_vector = MapVector::GetValues(result);
-	auto list_data = ListVector::GetData(result);
+	auto result_data = ListVector::GetData(result);
 
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	if (args.data.empty()) {
 		ListVector::SetListSize(result, 0);
-		list_data->offset = 0;
-		list_data->length = 0;
+		result_data->offset = 0;
+		result_data->length = 0;
 		result.Verify(args.size());
 		return;
 	}
 
-	auto args_data = ListVector::GetData(args.data[0]);
+	bool keys_are_const = args.data[0].GetVectorType() == VectorType::CONSTANT_VECTOR;
+	bool values_are_const = args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR;
+	if (!keys_are_const || !values_are_const) {
+		result.SetVectorType(VectorType::FLAT_VECTOR);
+	}
+
 	auto key_count = ListVector::GetListSize(args.data[0]);
 	auto value_count = ListVector::GetListSize(args.data[1]);
-	if (key_count != value_count) {
-		throw InvalidInputException(
-		    "Error in MAP creation: key list has a different size from value list (%lld keys, %lld values)", key_count,
-		    value_count);
+	auto key_data = ListVector::GetData(args.data[0]);
+	auto value_data = ListVector::GetData(args.data[1]);
+	auto src_data = key_data;
+
+	if (keys_are_const && !values_are_const) {
+		AlignVectorToReference(args.data[0], args.data[1], args.size(), key_vector);
+		src_data = value_data;
+	} else if (values_are_const && !keys_are_const) {
+		AlignVectorToReference(args.data[1], args.data[0], args.size(), value_vector);
+	} else {
+		if (key_count != value_count || memcmp(key_data, value_data, args.size() * sizeof(list_entry_t)) != 0) {
+			throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different "
+			                            "size or incompatible structure");
+		}
 	}
-	ListVector::Reserve(result, key_count);
-	ListVector::SetListSize(result, key_count);
 
+	ListVector::SetListSize(result, MaxValue(key_count, value_count));
+
+	result_data = ListVector::GetData(result);
 	for (idx_t i = 0; i < args.size(); i++) {
-		list_data[i] = args_data[i];
+		result_data[i] = src_data[i];
+	}
+
+	// check whether one of the vectors has already been referenced to an expanded vector in the case of const/non-const
+	// combination. If not, then referencing is still necessary
+	if (!(keys_are_const && !values_are_const)) {
+		key_vector.Reference(ListVector::GetEntry(args.data[0]));
+	}
+	if (!(values_are_const && !keys_are_const)) {
+		value_vector.Reference(ListVector::GetEntry(args.data[1]));
 	}
 
-	key_vector.Reference(ListVector::GetEntry(args.data[0]));
-	value_vector.Reference(ListVector::GetEntry(args.data[1]));
 	MapConversionVerify(result, args.size());
 	result.Verify(args.size());
 }

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.1-dev320"
+#define DUCKDB_VERSION "0.7.1-dev341"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "4a6205db95"
+#define DUCKDB_SOURCE_ID "d58ab188ff"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -54,7 +54,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		auto &config = DBConfig::GetConfig(context);
 		// for now assume only one storage extension provides the custom drop_database impl
 		for (auto &extension_entry : config.storage_extensions) {
-			if (extension_entry.second->drop_database != nullptr) {
+			if (extension_entry.second->drop_database == nullptr) {
 				continue;
 			}
 			auto &storage_extension = extension_entry.second;
@@ -64,7 +64,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 				auto bound_drop_database_func = Bind(*drop_database_function_ref);
 				result.plan = CreatePlan(*bound_drop_database_func);
 				result.names = {"Success"};
-				result.types = {LogicalType::BOOLEAN};
+				result.types = {LogicalType::BIGINT};
 				properties.allow_stream_result = false;
 				properties.return_type = StatementReturnType::NOTHING;
 				return result;