duckdb 0.8.1-dev194.0 → 0.8.1-dev219.0

package/binding.gyp

@@ -237,18 +237,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
-                "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-table-range.cpp", 
-                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/extension/icu/./icu-list-range.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/extension/icu/./icu-datepart.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
                 "src/duckdb/extension/icu/./icu-extension.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-datesub.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 

package/package.json

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

package/src/duckdb/src/common/types/row/row_data_collection_scanner.cpp

@@ -101,16 +101,17 @@ void RowDataCollectionScanner::AlignHeapBlocks(RowDataCollection &swizzled_block
 			    make_uniq<RowDataBlock>(buffer_manager, MaxValue<idx_t>(total_size, (idx_t)Storage::BLOCK_SIZE), 1));
 			auto new_heap_handle = buffer_manager.Pin(swizzled_string_heap.blocks.back()->block);
 			auto new_heap_ptr = new_heap_handle.Ptr();
+			for (auto &ptr_and_size : ptrs_and_sizes) {
+				memcpy(new_heap_ptr, ptr_and_size.first, ptr_and_size.second);
+				new_heap_ptr += ptr_and_size.second;
+			}
+			new_heap_ptr = new_heap_handle.Ptr();
 			if (swizzled_string_heap.keep_pinned) {
 				// Since the heap blocks are pinned, we can unswizzle the data again.
 				swizzled_string_heap.pinned_blocks.emplace_back(std::move(new_heap_handle));
 				RowOperations::UnswizzlePointers(layout, base_row_ptr, new_heap_ptr, data_block->count);
 				RowOperations::UnswizzleHeapPointer(layout, base_row_ptr, new_heap_ptr, data_block->count);
 			}
-			for (auto &ptr_and_size : ptrs_and_sizes) {
-				memcpy(new_heap_ptr, ptr_and_size.first, ptr_and_size.second);
-				new_heap_ptr += ptr_and_size.second;
-			}
 		}
 	}
 

package/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp

@@ -62,8 +62,19 @@ inline string_t TupleDataWithinListValueLoad(const data_ptr_t &location, data_pt
 	return result;
 }
 
+static void ResetCombinedListData(vector<TupleDataVectorFormat> &vector_data) {
+	for (auto &vd : vector_data) {
+		vd.combined_list_data = nullptr;
+		ResetCombinedListData(vd.child_formats);
+	}
+}
+
 void TupleDataCollection::ComputeHeapSizes(TupleDataChunkState &chunk_state, const DataChunk &new_chunk,
                                            const SelectionVector &append_sel, const idx_t append_count) {
+#ifdef DEBUG
+	ResetCombinedListData(chunk_state.vector_data);
+#endif
+
 	auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
 	std::fill_n(heap_sizes, new_chunk.size(), 0);
 
@@ -293,7 +304,12 @@ static void ApplySliceRecursive(const Vector &source_v, TupleDataVectorFormat &s
 		for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
 			auto &struct_source = *struct_sources[struct_col_idx];
 			auto &struct_format = source_format.child_formats[struct_col_idx];
-			struct_format.combined_list_data = make_uniq<CombinedListData>();
+#ifdef DEBUG
+			D_ASSERT(!struct_format.combined_list_data);
+#endif
+			if (!struct_format.combined_list_data) {
+				struct_format.combined_list_data = make_uniq<CombinedListData>();
+			}
 			ApplySliceRecursive(struct_source, struct_format, *source_format.data.sel, count);
 		}
 	}
@@ -308,14 +324,15 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	const auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
 	const auto &list_validity = list_data.validity;
 
-	// Child list
+	// Child list ("source_v")
 	const auto &child_list_data = source_format.data;
 	const auto child_list_sel = *child_list_data.sel;
 	const auto child_list_entries = UnifiedVectorFormat::GetData<list_entry_t>(child_list_data);
 	const auto &child_list_validity = child_list_data.validity;
 
-	// Figure out actual child list size (differs from ListVector::GetListSize if dict/const vector)
-	idx_t child_list_child_count = ListVector::GetListSize(source_v);
+	// Figure out actual child list size (can differ from ListVector::GetListSize if dict/const vector),
+	// and we cannot use ConstantVector::ZeroSelectionVector because it may need to be longer than STANDARD_VECTOR_SIZE
+	idx_t sum_of_sizes = 0;
 	for (idx_t i = 0; i < append_count; i++) {
 		const auto list_idx = list_sel.get_index(append_sel.get_index(i));
 		if (!list_validity.RowIsValid(list_idx)) {
@@ -324,15 +341,33 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 		const auto &list_entry = list_entries[list_idx];
 		const auto &list_offset = list_entry.offset;
 		const auto &list_length = list_entry.length;
-		child_list_child_count = MaxValue<idx_t>(child_list_child_count, list_offset + list_length);
+
+		for (idx_t child_i = 0; child_i < list_length; child_i++) {
+			const auto child_list_idx = child_list_sel.get_index(list_offset + child_i);
+			if (!child_list_validity.RowIsValid(child_list_idx)) {
+				continue;
+			}
+
+			const auto &child_list_entry = child_list_entries[child_list_idx];
+			const auto &child_list_length = child_list_entry.length;
+
+			sum_of_sizes += child_list_length;
+		}
 	}
+	const auto child_list_child_count = MaxValue<idx_t>(sum_of_sizes, ListVector::GetListSize(source_v));
 
 	// Target
 	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
 
 	// Construct combined list entries and a selection vector for the child list child
 	auto &child_format = source_format.child_formats[0];
-	child_format.combined_list_data = make_uniq<CombinedListData>();
+#ifdef DEBUG
+	// In debug mode this should be deleted by ResetCombinedListData
+	D_ASSERT(!child_format.combined_list_data);
+#endif
+	if (!child_format.combined_list_data) {
+		child_format.combined_list_data = make_uniq<CombinedListData>();
+	}
 	auto &combined_list_data = *child_format.combined_list_data;
 	auto &combined_list_entries = combined_list_data.combined_list_entries;
 	SelectionVector combined_sel(child_list_child_count);
@@ -365,7 +400,7 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 				const auto &child_list_offset = child_list_entry.offset;
 				const auto &child_list_length = child_list_entry.length;
 
-				// Add this child's list entry's to the combined selection vector
+				// Add this child's list entries to the combined selection vector
 				for (idx_t child_value_i = 0; child_value_i < child_list_length; child_value_i++) {
 					auto idx = combined_list_offset + child_list_size + child_value_i;
 					auto loc = child_list_offset + child_value_i;

package/src/duckdb/src/core_functions/aggregate/distributive/bitstring_agg.cpp

@@ -199,7 +199,7 @@ unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, Bound
 unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() == 3) {
-		if (!arguments[1]->IsFoldable() && !arguments[2]->IsFoldable()) {
+		if (!arguments[1]->IsFoldable() || !arguments[2]->IsFoldable()) {
 			throw BinderException("bitstring_agg requires a constant min and max argument");
 		}
 		auto min = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);

package/src/duckdb/src/core_functions/scalar/map/map_concat.cpp

@@ -153,6 +153,9 @@ static unique_ptr<FunctionData> MapConcatBind(ClientContext &context, ScalarFunc
 			// The maps are allowed to be NULL
 			continue;
 		}
+		if (map.id() != LogicalTypeId::MAP) {
+			throw InvalidInputException("MAP_CONCAT only takes map arguments");
+		}
 		is_null = false;
 		if (IsEmptyMap(map)) {
 			// Map is allowed to be empty

package/src/duckdb/src/function/table/repeat_row.cpp

@@ -25,7 +25,14 @@ static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunct
 		return_types.push_back(inputs[input_idx].type());
 		names.push_back("column" + std::to_string(input_idx));
 	}
-	return make_uniq<RepeatRowFunctionData>(inputs, input.named_parameters["num_rows"].GetValue<int64_t>());
+	auto entry = input.named_parameters.find("num_rows");
+	if (entry == input.named_parameters.end()) {
+		throw BinderException("repeat_rows requires num_rows to be specified");
+	}
+	if (inputs.empty()) {
+		throw BinderException("repeat_rows requires at least one column to be specified");
+	}
+	return make_uniq<RepeatRowFunctionData>(inputs, entry->second.GetValue<int64_t>());
 }
 
 static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.1-dev194"
+#define DUCKDB_VERSION "0.8.1-dev219"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "54a1955565"
+#define DUCKDB_SOURCE_ID "fc724f980f"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/planner/bind_context.hpp

@@ -56,7 +56,7 @@ public:
 	//! or throws an exception if the column could not be bound.
 	BindResult BindColumn(ColumnRefExpression &colref, idx_t depth);
 	string BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name);
-	BindResult BindColumn(PositionalReferenceExpression &ref, idx_t depth);
+	unique_ptr<ColumnRefExpression> PositionToColumn(PositionalReferenceExpression &ref);
 
 	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &table_name, const string &column_name);
 

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -124,8 +124,8 @@ protected:
 	                          const LogicalType &list_child_type);
 	BindResult BindExpression(OperatorExpression &expr, idx_t depth);
 	BindResult BindExpression(ParameterExpression &expr, idx_t depth);
-	BindResult BindExpression(PositionalReferenceExpression &ref, idx_t depth);
 	BindResult BindExpression(SubqueryExpression &expr, idx_t depth);
+	BindResult BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression);
 
 	void TransformCapturedLambdaColumn(unique_ptr<Expression> &original, unique_ptr<Expression> &replacement,
 	                                   vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type);

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -87,6 +87,9 @@ unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr
 		result->unpivot_names = TransformStringList(root.unpivots);
 	}
 	result->pivots = TransformPivotList(*root.pivots);
+	if (!result->unpivot_names.empty() && result->pivots.size() > 1) {
+		throw ParserException("UNPIVOT requires a single pivot element");
+	}
 	if (root.groups) {
 		result->groups = TransformStringList(root.groups);
 	}

package/src/duckdb/src/planner/bind_context.cpp

@@ -286,15 +286,14 @@ string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table
 	return StringUtil::Format("Positional reference %d out of range (total %d columns)", ref.index, total_columns);
 }
 
-BindResult BindContext::BindColumn(PositionalReferenceExpression &ref, idx_t depth) {
+unique_ptr<ColumnRefExpression> BindContext::PositionToColumn(PositionalReferenceExpression &ref) {
 	string table_name, column_name;
 
 	string error = BindColumn(ref, table_name, column_name);
 	if (!error.empty()) {
-		return BindResult(error);
+		throw BinderException(error);
 	}
-	auto column_ref = make_uniq<ColumnRefExpression>(column_name, table_name);
-	return BindColumn(*column_ref, depth);
+	return make_uniq<ColumnRefExpression>(column_name, table_name);
 }
 
 bool BindContext::CheckExclusionList(StarExpression &expr, const string &column_name,

package/src/duckdb/src/planner/binder/expression/bind_positional_reference_expression.cpp

@@ -4,11 +4,16 @@
 
 namespace duckdb {
 
-BindResult ExpressionBinder::BindExpression(PositionalReferenceExpression &ref, idx_t depth) {
+BindResult ExpressionBinder::BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth,
+                                                     bool root_expression) {
+	auto &ref = expr->Cast<PositionalReferenceExpression>();
 	if (depth != 0) {
 		return BindResult("Positional reference expression could not be bound");
 	}
-	return binder.bind_context.BindColumn(ref, depth);
+	// replace the positional reference with a column
+	auto column = binder.bind_context.PositionToColumn(ref);
+	expr = std::move(column);
+	return BindExpression(expr, depth, root_expression);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp

@@ -250,7 +250,9 @@ unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
 	auto &aggregates = result->bound_pivot.aggregates;
 	ExtractPivotAggregates(*result->child, aggregates);
 	if (aggregates.size() != ref.bound_aggregate_names.size()) {
-		throw InternalException("Pivot - aggregate count mismatch");
+		throw BinderException("Pivot aggregate count mismatch. Expected %llu aggregates but found %llu. Are all pivot "
+		                      "expressions aggregate functions?",
+		                      ref.bound_aggregate_names.size(), aggregates.size());
 	}
 
 	vector<string> child_names;

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

@@ -64,8 +64,9 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		return BindExpression(expr_ref.Cast<SubqueryExpression>(), depth);
 	case ExpressionClass::PARAMETER:
 		return BindExpression(expr_ref.Cast<ParameterExpression>(), depth);
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return BindExpression(expr_ref.Cast<PositionalReferenceExpression>(), depth);
+	case ExpressionClass::POSITIONAL_REFERENCE: {
+		return BindPositionalReference(expr, depth, root_expression);
+	}
 	case ExpressionClass::STAR:
 		return BindResult(binder.FormatError(expr_ref, "STAR expression is not supported here"));
 	default:

package/src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp

@@ -348,17 +348,17 @@
 
 #include "extension/icu/third_party/icu/i18n/wintzimpl.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
-
 #include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
 
+#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
+
 #include "extension/icu/third_party/icu/i18n/double-conversion-bignum-dtoa.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"