Update vendored DuckDB sources to be5250ba48

Author: duckdblabs-bot

src/duckdb/extension/parquet/parquet_reader.cpp

@@ -504,7 +504,8 @@ static bool IsGeometryType(const SchemaElement &s_ele, const ParquetFileMetadata
 	// geoparquet types have to be at the root of the schema, and have to be present in the kv metadata.
 	const auto is_at_root = depth == 1;
 	const auto is_in_gpq_metadata = metadata.geo_metadata && metadata.geo_metadata->IsGeometryColumn(s_ele.name);
-	const auto is_leaf = s_ele.num_children == 0;
+	// A leaf node has a type set (as per Parquet spec)
+	const auto is_leaf = s_ele.__isset.type;
 	const auto is_geoparquet_geom = is_at_root && is_in_gpq_metadata && is_leaf;
 
 	if (is_geoparquet_geom) {
@@ -557,11 +558,23 @@ ParquetColumnSchema ParquetReader::ParseSchemaRecursive(idx_t depth, idx_t max_d
 		                                             ParquetColumnSchemaType::GEOMETRY);
 	}
 
-	if (s_ele.__isset.num_children && s_ele.num_children > 0) { // inner node
+	// Determine if this is an inner node
+	// According to Parquet spec: nodes without 'type' set are inner nodes (groups)
+	// For backwards compatibility with non-standard files, also check the old condition
+	bool is_inner_node = !s_ele.__isset.type || (s_ele.__isset.num_children && s_ele.num_children > 0);
+
+	if (is_inner_node && s_ele.__isset.type) {
+		// This case handles non-standard files where both type and num_children are set
+		// Prioritize num_children if set and > 0
+		is_inner_node = s_ele.__isset.num_children && s_ele.num_children > 0;
+	}
+
+	if (is_inner_node) { // inner node
 		vector<ParquetColumnSchema> child_schemas;
 
 		idx_t c_idx = 0;
-		while (c_idx < NumericCast<idx_t>(s_ele.num_children)) {
+		idx_t num_children = (s_ele.__isset.num_children) ? NumericCast<idx_t>(s_ele.num_children) : 0;
+		while (c_idx < num_children) {
 			next_schema_idx++;
 
 			auto child_schema =

src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -264,7 +264,7 @@ void LogicalUpdate::BindExtraColumns(TableCatalogEntry &table, LogicalGet &get,
 			found_columns.insert(update.columns[i]);
 		}
 	}
-	if (found_column_count > 0 && found_column_count != bound_columns.size()) {
+	if (found_column_count != bound_columns.size()) {
 		// columns that were required are not all part of the UPDATE
 		// add them to the scan and update set
 		for (auto &physical_id : bound_columns) {

src/duckdb/src/catalog/default/default_functions.cpp

@@ -164,7 +164,7 @@ static const DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "days_in_month", {"date", nullptr}, {{nullptr, nullptr}}, "day(last_day(date))"},
 
 	// timestamptz functions
-	{DEFAULT_SCHEMA, "ago", {"interval", nullptr}, {{nullptr, nullptr}}, "current_timestamp - interval"},
+	{DEFAULT_SCHEMA, "ago", {"i", nullptr}, {{nullptr, nullptr}}, "current_timestamp - i::interval"},
 
 	// regexp functions
 	{DEFAULT_SCHEMA, "regexp_split_to_table", {"text", "pattern", nullptr}, {{nullptr, nullptr}}, "unnest(string_split_regex(text, pattern))"},

src/duckdb/src/common/sort/sorted_run_merger.cpp

@@ -824,13 +824,13 @@ unique_ptr<SortedRun> SortedRunMergerLocalState::TemplatedMaterializePartition(S
 //===--------------------------------------------------------------------===//
 SortedRunMerger::SortedRunMerger(const Sort &sort_p, vector<unique_ptr<SortedRun>> &&sorted_runs_p,
                                  idx_t partition_size_p, bool external_p, bool is_index_sort_p)
-    : db(*sort_p.context.db), sort(sort_p), sorted_runs(std::move(sorted_runs_p)),
+    : scheduler(TaskScheduler::GetScheduler(*sort_p.context.db)), sort(sort_p), sorted_runs(std::move(sorted_runs_p)),
       total_count(SortedRunsTotalCount(sorted_runs)), partition_size(partition_size_p), external(external_p),
       is_index_sort(is_index_sort_p) {
 }
 
 SortedRunMerger::~SortedRunMerger() {
-	ParallelDestroyTask<decltype(sorted_runs)>::Schedule(db, sorted_runs);
+	ParallelDestroyTask<decltype(sorted_runs)>::Schedule(scheduler, sorted_runs);
 }
 
 unique_ptr<LocalSourceState> SortedRunMerger::GetLocalSourceState(ExecutionContext &,

src/duckdb/src/common/types/row/tuple_data_collection.cpp

@@ -16,7 +16,7 @@ using ValidityBytes = TupleDataLayout::ValidityBytes;
 
 TupleDataCollection::TupleDataCollection(BufferManager &buffer_manager, shared_ptr<TupleDataLayout> layout_ptr_p,
                                          MemoryTag tag_p, shared_ptr<ArenaAllocator> stl_allocator_p)
-    : db(buffer_manager.GetDatabase()),
+    : scheduler(TaskScheduler::GetScheduler(buffer_manager.GetDatabase())),
       stl_allocator(stl_allocator_p ? std::move(stl_allocator_p)
                                     : make_shared_ptr<ArenaAllocator>(buffer_manager.GetBufferAllocator())),
       layout_ptr(std::move(layout_ptr_p)), layout(*layout_ptr), tag(tag_p),
@@ -32,7 +32,7 @@ TupleDataCollection::TupleDataCollection(ClientContext &context, shared_ptr<Tupl
 }
 
 TupleDataCollection::~TupleDataCollection() {
-	ParallelDestroyTask<decltype(segments)>::Schedule(db, segments);
+	ParallelDestroyTask<decltype(segments)>::Schedule(scheduler, segments);
 }
 
 void TupleDataCollection::Initialize() {

src/duckdb/src/execution/index/art/art.cpp

@@ -894,20 +894,23 @@ string ART::GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t
 void ART::TransformToDeprecated() {
 	auto idx = Node::GetAllocatorIdx(NType::PREFIX);
 	auto &block_manager = (*allocators)[idx]->block_manager;
-	unsafe_unique_ptr<FixedSizeAllocator> deprecated_allocator;
-
+	unsafe_unique_ptr<FixedSizeAllocator> deprecated_allocator = nullptr;
 	if (prefix_count != Prefix::DEPRECATED_COUNT) {
 		auto prefix_size = NumericCast<idx_t>(Prefix::DEPRECATED_COUNT) + NumericCast<idx_t>(Prefix::METADATA_SIZE);
 		deprecated_allocator = make_unsafe_uniq<FixedSizeAllocator>(prefix_size, block_manager);
 	}
 
+	unique_ptr<TransformToDeprecatedState> state =
+	    make_uniq<TransformToDeprecatedState>(std::move(deprecated_allocator));
+
 	// Transform all leaves, and possibly the prefixes.
 	if (tree.HasMetadata()) {
-		Node::TransformToDeprecated(*this, tree, deprecated_allocator);
+		Node::TransformToDeprecated(*this, tree, *state);
 	}
 
 	// Replace the prefix allocator with the deprecated allocator.
-	if (deprecated_allocator) {
+	if (state->HasAllocator()) {
+		deprecated_allocator = state->TakeAllocator();
 		prefix_count = Prefix::DEPRECATED_COUNT;
 
 		D_ASSERT((*allocators)[idx]->Empty());

src/duckdb/src/execution/index/art/art_merger.cpp

@@ -255,7 +255,7 @@ void ARTMerger::MergePrefixes(NodeEntry &entry) {
 
 	Prefix l_prefix(art, entry.left, true);
 	Prefix r_prefix(art, entry.right, true);
-	const auto count = Prefix::Count(art);
+	const auto count = art.PrefixCount();
 
 	// Find a byte at pos where the prefixes differ.
 	// If they match up to max_count, then pos stays invalid.

src/duckdb/src/execution/index/art/const_prefix_handle.cpp

@@ -0,0 +1,63 @@
+#include "duckdb/execution/index/art/const_prefix_handle.hpp"
+
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+
+namespace duckdb {
+
+ConstPrefixHandle::ConstPrefixHandle(const ART &art, const Node node)
+    : segment_handle(Node::GetAllocator(art, PREFIX).GetHandle(node)) {
+	data = segment_handle.GetPtr();
+	child = reinterpret_cast<Node *>(data + art.PrefixCount() + 1);
+	// Read-only: don't mark segment as modified
+}
+
+uint8_t ConstPrefixHandle::GetCount(const ART &art) const {
+	return data[art.PrefixCount()];
+}
+
+uint8_t ConstPrefixHandle::GetByte(const idx_t pos) const {
+	return data[pos];
+}
+
+string ConstPrefixHandle::ToString(ART &art, const Node &node, const ToStringOptions &options) {
+	auto indent = [](string &str, const idx_t n) {
+		str.append(n, ' ');
+	};
+	auto format_byte = [&](const uint8_t byte) {
+		if (!options.inside_gate && options.display_ascii && byte >= 32 && byte <= 126) {
+			return string(1, static_cast<char>(byte));
+		}
+		return to_string(byte);
+	};
+
+	string str = "";
+	indent(str, options.indent_level);
+	reference<const Node> ref(node);
+	ToStringOptions child_options = options;
+	Iterator(art, ref, true, [&](const ConstPrefixHandle &handle) {
+		str += "Prefix: |";
+		for (idx_t i = 0; i < handle.data[art.PrefixCount()]; i++) {
+			str += format_byte(handle.data[i]) + "|";
+			if (options.key_path) {
+				child_options.key_depth++;
+			}
+		}
+	});
+
+	auto child = ref.get().ToString(art, child_options);
+	return str + "\n" + child;
+}
+
+void ConstPrefixHandle::Verify(ART &art, const Node &node) {
+	reference<const Node> ref(node);
+
+	Iterator(art, ref, true, [&](const ConstPrefixHandle &handle) {
+		D_ASSERT(handle.data[art.PrefixCount()] != 0);
+		D_ASSERT(handle.data[art.PrefixCount()] <= art.PrefixCount());
+	});
+
+	ref.get().Verify(art);
+}
+
+} // namespace duckdb

src/duckdb/src/execution/index/art/iterator.cpp

@@ -115,7 +115,7 @@ void Iterator::FindMinimum(const Node &node) {
 		// Traverse the prefix.
 		if (ref.get().GetType() == NType::PREFIX) {
 			Prefix prefix(art, ref.get());
-			for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
+			for (idx_t i = 0; i < prefix.data[art.PrefixCount()]; i++) {
 				current_key.Push(prefix.data[i]);
 				if (status == GateStatus::GATE_SET) {
 					row_id[nested_depth] = prefix.data[i];
@@ -195,13 +195,13 @@ bool Iterator::LowerBound(const Node &node, const ARTKey &key, const bool equal)
 
 		// Push back all prefix bytes.
 		Prefix prefix(art, ref.get());
-		for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
+		for (idx_t i = 0; i < prefix.data[art.PrefixCount()]; i++) {
 			current_key.Push(prefix.data[i]);
 		}
 		nodes.emplace(ref.get(), 0);
 
 		// We compare the prefix bytes with the key bytes.
-		for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
+		for (idx_t i = 0; i < prefix.data[art.PrefixCount()]; i++) {
 			// We found a prefix byte that is less than its corresponding key byte.
 			// I.e., the subsequent node is lesser than the key. Thus, the next node
 			// is the lower bound.
@@ -219,7 +219,7 @@ bool Iterator::LowerBound(const Node &node, const ARTKey &key, const bool equal)
 		}
 
 		// The prefix matches the key. Move to the child and update depth.
-		depth += prefix.data[Prefix::Count(art)];
+		depth += prefix.data[art.PrefixCount()];
 		ref = *prefix.ptr;
 	}
 	// Should always have a node with metadata.
@@ -278,7 +278,7 @@ void Iterator::PopNode() {
 	} else {
 		// Pop all prefix bytes and the node.
 		Prefix prefix(art, nodes.top().node);
-		auto prefix_byte_count = prefix.data[Prefix::Count(art)];
+		auto prefix_byte_count = prefix.data[art.PrefixCount()];
 		current_key.Pop(prefix_byte_count);
 
 		if (status == GateStatus::GATE_SET) {

src/duckdb/src/execution/index/art/node.cpp

@@ -11,7 +11,9 @@
 #include "duckdb/execution/index/art/node256.hpp"
 #include "duckdb/execution/index/art/node256_leaf.hpp"
 #include "duckdb/execution/index/art/node48.hpp"
+#include "duckdb/execution/index/art/const_prefix_handle.hpp"
 #include "duckdb/execution/index/art/prefix.hpp"
+#include "duckdb/execution/index/art/prefix_handle.hpp"
 #include "duckdb/storage/table_io_manager.hpp"
 
 namespace duckdb {
@@ -357,8 +359,7 @@ bool Node::IsAnyLeaf() const {
 // TransformToDeprecated
 //===--------------------------------------------------------------------===//
 
-void Node::TransformToDeprecated(ART &art, Node &node,
-                                 unsafe_unique_ptr<FixedSizeAllocator> &deprecated_prefix_allocator) {
+void Node::TransformToDeprecated(ART &art, Node &node, TransformToDeprecatedState &state) {
 	D_ASSERT(node.HasMetadata());
 
 	if (node.GetGateStatus() == GateStatus::GATE_SET) {
@@ -369,19 +370,19 @@ void Node::TransformToDeprecated(ART &art, Node &node,
 	auto type = node.GetType();
 	switch (type) {
 	case NType::PREFIX:
-		return Prefix::TransformToDeprecated(art, node, deprecated_prefix_allocator);
+		return PrefixHandle::TransformToDeprecated(art, node, state);
 	case NType::LEAF_INLINED:
 		return;
 	case NType::LEAF:
 		return;
 	case NType::NODE_4:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node4>(art, node, type), deprecated_prefix_allocator);
+		return TransformToDeprecatedInternal(art, InMemoryRef<Node4>(art, node, type), state);
 	case NType::NODE_16:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node16>(art, node, type), deprecated_prefix_allocator);
+		return TransformToDeprecatedInternal(art, InMemoryRef<Node16>(art, node, type), state);
 	case NType::NODE_48:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node48>(art, node, type), deprecated_prefix_allocator);
+		return TransformToDeprecatedInternal(art, InMemoryRef<Node48>(art, node, type), state);
 	case NType::NODE_256:
-		return TransformToDeprecatedInternal(art, InMemoryRef<Node256>(art, node, type), deprecated_prefix_allocator);
+		return TransformToDeprecatedInternal(art, InMemoryRef<Node256>(art, node, type), state);
 	default:
 		throw InternalException("invalid node type for TransformToDeprecated: %d", type);
 	}
@@ -402,7 +403,7 @@ void Node::Verify(ART &art) const {
 		Leaf::DeprecatedVerify(art, *this);
 		return;
 	case NType::PREFIX: {
-		Prefix::Verify(art, *this);
+		ConstPrefixHandle::Verify(art, *this);
 		return;
 	}
 	default:
@@ -496,7 +497,7 @@ string Node::ToString(ART &art, const ToStringOptions &options) const {
 	case NType::PREFIX: {
 		ToStringOptions prefix_options = options;
 		prefix_options.inside_gate = propagate_gate;
-		string str = Prefix::ToString(art, *this, prefix_options);
+		string str = ConstPrefixHandle::ToString(art, *this, prefix_options);
 		if (is_gate) {
 			string s = "";
 			indent(s, options.indent_level);