duckdb 1.1.2-dev2.0 → 1.1.2-dev6.0

package/src/duckdb/extension/parquet/include/parquet_rle_bp_decoder.hpp

@@ -66,7 +66,7 @@ public:
 			return 0;
 		}
 		uint8_t ret = 1;
-		while (((idx_t)(1u << ret) - 1) < val) {
+		while ((((idx_t)1u << (idx_t)ret) - 1) < val) {
 			ret++;
 		}
 		return ret;

package/src/duckdb/extension/parquet/include/templated_column_reader.hpp

@@ -68,10 +68,6 @@ public:
 
 	void Offsets(uint32_t *offsets, uint8_t *defines, uint64_t num_values, parquet_filter_t &filter,
 	             idx_t result_offset, Vector &result) override {
-		if (!dict || dict->len == 0) {
-			throw IOException("Parquet file is likely corrupted, cannot have dictionary offsets without seeing a "
-			                  "non-empty dictionary first.");
-		}
 		if (HasDefines()) {
 			OffsetsInternal<true>(*dict, offsets, defines, num_values, filter, result_offset, result);
 		} else {

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -70,8 +70,8 @@ struct ParquetReadBindData : public TableFunctionData {
 	// These come from the initial_reader, but need to be stored in case the initial_reader is removed by a filter
 	idx_t initial_file_cardinality;
 	idx_t initial_file_row_groups;
+	idx_t explicit_cardinality = 0; // can be set to inject exterior cardinality knowledge (e.g. from a data lake)
 	ParquetOptions parquet_options;
-
 	MultiFileReaderBindData reader_bind;
 
 	void Initialize(shared_ptr<ParquetReader> reader) {
@@ -395,6 +395,7 @@ public:
 		table_function.named_parameters["file_row_number"] = LogicalType::BOOLEAN;
 		table_function.named_parameters["debug_use_openssl"] = LogicalType::BOOLEAN;
 		table_function.named_parameters["compression"] = LogicalType::VARCHAR;
+		table_function.named_parameters["explicit_cardinality"] = LogicalType::UBIGINT;
 		table_function.named_parameters["schema"] =
 		    LogicalType::MAP(LogicalType::INTEGER, LogicalType::STRUCT({{{"name", LogicalType::VARCHAR},
 		                                                                 {"type", LogicalType::VARCHAR},
@@ -545,7 +546,11 @@ public:
 			result->reader_bind = result->multi_file_reader->BindReader<ParquetReader>(
 			    context, result->types, result->names, *result->file_list, *result, parquet_options);
 		}
-
+		if (parquet_options.explicit_cardinality) {
+			auto file_count = result->file_list->GetTotalFileCount();
+			result->explicit_cardinality = parquet_options.explicit_cardinality;
+			result->initial_file_cardinality = result->explicit_cardinality / (file_count ? file_count : 1);
+		}
 		if (return_types.empty()) {
 			// no expected types - just copy the types
 			return_types = result->types;
@@ -618,6 +623,8 @@ public:
 
 				// cannot be combined with hive_partitioning=true, so we disable auto-detection
 				parquet_options.file_options.auto_detect_hive_partitioning = false;
+			} else if (loption == "explicit_cardinality") {
+				parquet_options.explicit_cardinality = UBigIntValue::Get(kv.second);
 			} else if (loption == "encryption_config") {
 				parquet_options.encryption_config = ParquetEncryptionConfig::Create(context, kv.second);
 			}
@@ -847,13 +854,15 @@ public:
 
 	static unique_ptr<NodeStatistics> ParquetCardinality(ClientContext &context, const FunctionData *bind_data) {
 		auto &data = bind_data->Cast<ParquetReadBindData>();
-
+		if (data.explicit_cardinality) {
+			return make_uniq<NodeStatistics>(data.explicit_cardinality);
+		}
 		auto file_list_cardinality_estimate = data.file_list->GetCardinality(context);
 		if (file_list_cardinality_estimate) {
 			return file_list_cardinality_estimate;
 		}
-
-		return make_uniq<NodeStatistics>(data.initial_file_cardinality * data.file_list->GetTotalFileCount());
+		return make_uniq<NodeStatistics>(MaxValue(data.initial_file_cardinality, (idx_t)1) *
+		                                 data.file_list->GetTotalFileCount());
 	}
 
 	static idx_t ParquetScanMaxThreads(ClientContext &context, const FunctionData *bind_data) {
@@ -1573,7 +1582,7 @@ static vector<unique_ptr<Expression>> ParquetWriteSelect(CopyToSelectInput &inpu
 		// Spatial types need to be encoded into WKB when writing GeoParquet.
 		// But dont perform this conversion if this is a EXPORT DATABASE statement
 		if (input.copy_to_type == CopyToType::COPY_TO_FILE && type.id() == LogicalTypeId::BLOB && type.HasAlias() &&
-		    type.GetAlias() == "GEOMETRY") {
+		    type.GetAlias() == "GEOMETRY" && GeoParquetFileMetadata::IsGeoParquetConversionEnabled(context)) {
 
 			LogicalType wkb_blob_type(LogicalTypeId::BLOB);
 			wkb_blob_type.SetAlias("WKB_BLOB");
@@ -1680,6 +1689,11 @@ void ParquetExtension::Load(DuckDB &db) {
 	config.replacement_scans.emplace_back(ParquetScanReplacement);
 	config.AddExtensionOption("binary_as_string", "In Parquet files, interpret binary data as a string.",
 	                          LogicalType::BOOLEAN);
+
+	config.AddExtensionOption(
+	    "enable_geoparquet_conversion",
+	    "Attempt to decode/encode geometry data in/as GeoParquet files if the spatial extension is present.",
+	    LogicalType::BOOLEAN, Value::BOOLEAN(true));
 }
 
 std::string ParquetExtension::Name() {

package/src/duckdb/extension/parquet/parquet_reader.cpp

@@ -637,8 +637,7 @@ uint32_t ParquetReader::ReadData(duckdb_apache::thrift::protocol::TProtocol &ipr
 const ParquetRowGroup &ParquetReader::GetGroup(ParquetReaderScanState &state) {
 	auto file_meta_data = GetFileMetadata();
 	D_ASSERT(state.current_group >= 0 && (idx_t)state.current_group < state.group_idx_list.size());
-	D_ASSERT(state.group_idx_list[state.current_group] >= 0 &&
-	         state.group_idx_list[state.current_group] < file_meta_data->row_groups.size());
+	D_ASSERT(state.group_idx_list[state.current_group] < file_meta_data->row_groups.size());
 	return file_meta_data->row_groups[state.group_idx_list[state.current_group]];
 }
 

package/src/duckdb/extension/parquet/parquet_writer.cpp

@@ -466,7 +466,7 @@ void ParquetWriter::PrepareRowGroup(ColumnDataCollection &buffer, PreparedRowGro
 // Validation code adapted from Impala
 static void ValidateOffsetInFile(const string &filename, idx_t col_idx, idx_t file_length, idx_t offset,
                                  const string &offset_name) {
-	if (offset < 0 || offset >= file_length) {
+	if (offset >= file_length) {
 		throw IOException("File '%s': metadata is corrupt. Column %d has invalid "
 		                  "%s (offset=%llu file_size=%llu).",
 		                  filename, col_idx, offset_name, offset, file_length);

package/src/duckdb/extension/parquet/serialize_parquet.cpp

@@ -7,8 +7,6 @@
 #include "duckdb/common/serializer/deserializer.hpp"
 #include "parquet_reader.hpp"
 #include "parquet_crypto.hpp"
-#include "parquet_reader.hpp"
-#include "parquet_writer.hpp"
 #include "parquet_writer.hpp"
 
 namespace duckdb {

package/src/duckdb/src/catalog/catalog_entry/duck_schema_entry.cpp

@@ -119,6 +119,13 @@ optional_ptr<CatalogEntry> DuckSchemaEntry::AddEntryInternal(CatalogTransaction
 	// first find the set for this entry
 	auto &set = GetCatalogSet(entry_type);
 	dependencies.AddDependency(*this);
+	if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
+		auto old_entry = set.GetEntry(transaction, entry_name);
+		if (old_entry) {
+			return nullptr;
+		}
+	}
+
 	if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
 		// CREATE OR REPLACE: first try to drop the entry
 		auto old_entry = set.GetEntry(transaction, entry_name);
@@ -315,7 +322,7 @@ void DuckSchemaEntry::DropEntry(ClientContext &context, DropInfo &info) {
 		throw InternalException("Failed to drop entry \"%s\" - entry could not be found", info.name);
 	}
 	if (existing_entry->type != info.type) {
-		throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", info.name,
+		throw CatalogException("Existing object %s is of type %s, trying to drop type %s", info.name,
 		                       CatalogTypeToString(existing_entry->type), CatalogTypeToString(info.type));
 	}
 

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

@@ -12,7 +12,7 @@ namespace duckdb {
 static const DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "current_role", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // user name of current execution context
 	{DEFAULT_SCHEMA, "current_user", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // user name of current execution context
-	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, {{nullptr, nullptr}}, "current_database()"},          // name of current database (called "catalog" in the SQL standard)
+	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, {{nullptr, nullptr}}, "main.current_database()"},          // name of current database (called "catalog" in the SQL standard)
 	{DEFAULT_SCHEMA, "user", {nullptr}, {{nullptr, nullptr}}, "current_user"},                           // equivalent to current_user
 	{DEFAULT_SCHEMA, "session_user", {nullptr}, {{nullptr, nullptr}}, "'duckdb'"},                       // session user name
 	{"pg_catalog", "inet_client_addr", {nullptr}, {{nullptr, nullptr}}, "NULL"},                       // address of the remote connection
@@ -27,10 +27,10 @@ static const DefaultMacro internal_macros[] = {
 
 	{"pg_catalog", "pg_typeof", {"expression", nullptr}, {{nullptr, nullptr}}, "lower(typeof(expression))"},  // get the data type of any value
 
-	{"pg_catalog", "current_database", {nullptr}, {{nullptr, nullptr}}, "current_database()"},  	    // name of current database (called "catalog" in the SQL standard)
-	{"pg_catalog", "current_query", {nullptr}, {{nullptr, nullptr}}, "current_query()"},  	        // the currently executing query (NULL if not inside a plpgsql function)
-	{"pg_catalog", "current_schema", {nullptr}, {{nullptr, nullptr}}, "current_schema()"},  	        // name of current schema
-	{"pg_catalog", "current_schemas", {"include_implicit"}, {{nullptr, nullptr}}, "current_schemas(include_implicit)"},  	// names of schemas in search path
+	{"pg_catalog", "current_database", {nullptr}, {{nullptr, nullptr}}, "main.current_database()"},  	    // name of current database (called "catalog" in the SQL standard)
+	{"pg_catalog", "current_query", {nullptr}, {{nullptr, nullptr}}, "main.current_query()"},  	        // the currently executing query (NULL if not inside a plpgsql function)
+	{"pg_catalog", "current_schema", {nullptr}, {{nullptr, nullptr}}, "main.current_schema()"},  	        // name of current schema
+	{"pg_catalog", "current_schemas", {"include_implicit"}, {{nullptr, nullptr}}, "main.current_schemas(include_implicit)"},  	// names of schemas in search path
 
 	// privilege functions
 	{"pg_catalog", "has_any_column_privilege", {"table", "privilege", nullptr}, {{nullptr, nullptr}}, "true"},  //boolean  //does current user have privilege for any column of table

package/src/duckdb/src/common/allocator.cpp

@@ -242,12 +242,13 @@ static void MallocTrim(idx_t pad) {
 	static atomic<int64_t> LAST_TRIM_TIMESTAMP_MS {0};
 
 	int64_t last_trim_timestamp_ms = LAST_TRIM_TIMESTAMP_MS.load();
-	const int64_t current_timestamp_ms = Timestamp::GetEpochMs(Timestamp::GetCurrentTimestamp());
+	int64_t current_timestamp_ms = Timestamp::GetEpochMs(Timestamp::GetCurrentTimestamp());
 
 	if (current_timestamp_ms - last_trim_timestamp_ms < TRIM_INTERVAL_MS) {
 		return; // We trimmed less than TRIM_INTERVAL_MS ago
 	}
-	if (!std::atomic_compare_exchange_weak(&LAST_TRIM_TIMESTAMP_MS, &last_trim_timestamp_ms, current_timestamp_ms)) {
+	if (!LAST_TRIM_TIMESTAMP_MS.compare_exchange_strong(last_trim_timestamp_ms, current_timestamp_ms,
+	                                                    std::memory_order_acquire, std::memory_order_relaxed)) {
 		return; // Another thread has updated LAST_TRIM_TIMESTAMP_MS since we loaded it
 	}
 

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -225,6 +225,7 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		break;
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::BIT:
+	case LogicalTypeId::VARINT:
 		if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 			InitializeAppenderForType<ArrowVarcharData<>>(append_data);
 		} else {

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -142,6 +142,17 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.metadata = root_holder.metadata_info.back().get();
 		break;
 	}
+	case LogicalTypeId::VARINT: {
+		if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
+			child.format = "Z";
+		} else {
+			child.format = "z";
+		}
+		auto schema_metadata = ArrowSchemaMetadata::MetadataFromName("duckdb.varint");
+		root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
+		child.metadata = root_holder.metadata_info.back().get();
+		break;
+	}
 	case LogicalTypeId::DOUBLE:
 		child.format = "g";
 		break;

package/src/duckdb/src/common/arrow/schema_metadata.cpp

@@ -36,7 +36,12 @@ void ArrowSchemaMetadata::AddOption(const string &key, const string &value) {
 	metadata_map[key] = value;
 }
 string ArrowSchemaMetadata::GetOption(const string &key) const {
-	return metadata_map.at(key);
+	auto it = metadata_map.find(key);
+	if (it != metadata_map.end()) {
+		return it->second;
+	} else {
+		return "";
+	}
 }
 
 string ArrowSchemaMetadata::GetExtensionName() const {
@@ -51,9 +56,6 @@ ArrowSchemaMetadata ArrowSchemaMetadata::MetadataFromName(const string &extensio
 }
 
 bool ArrowSchemaMetadata::HasExtension() {
-	if (metadata_map.find(ARROW_EXTENSION_NAME) == metadata_map.end()) {
-		return false;
-	}
 	auto arrow_extension = GetOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME);
 	// FIXME: We are currently ignoring the ogc extensions
 	return !arrow_extension.empty() && !StringUtil::StartsWith(arrow_extension, "ogc");

package/src/duckdb/src/common/enum_util.cpp

@@ -4394,6 +4394,10 @@ const char* EnumUtil::ToChars<MetricsType>(MetricsType value) {
 		return "OPERATOR_ROWS_SCANNED";
 	case MetricsType::OPERATOR_TIMING:
 		return "OPERATOR_TIMING";
+	case MetricsType::LATENCY:
+		return "LATENCY";
+	case MetricsType::ROWS_RETURNED:
+		return "ROWS_RETURNED";
 	case MetricsType::RESULT_SET_SIZE:
 		return "RESULT_SET_SIZE";
 	case MetricsType::ALL_OPTIMIZERS:
@@ -4495,6 +4499,12 @@ MetricsType EnumUtil::FromString<MetricsType>(const char *value) {
 	if (StringUtil::Equals(value, "OPERATOR_TIMING")) {
 		return MetricsType::OPERATOR_TIMING;
 	}
+	if (StringUtil::Equals(value, "LATENCY")) {
+		return MetricsType::LATENCY;
+	}
+	if (StringUtil::Equals(value, "ROWS_RETURNED")) {
+		return MetricsType::ROWS_RETURNED;
+	}
 	if (StringUtil::Equals(value, "RESULT_SET_SIZE")) {
 		return MetricsType::RESULT_SET_SIZE;
 	}
@@ -6457,6 +6467,29 @@ SecretPersistType EnumUtil::FromString<SecretPersistType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented in FromString<SecretPersistType>", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<SecretSerializationType>(SecretSerializationType value) {
+	switch(value) {
+	case SecretSerializationType::CUSTOM:
+		return "CUSTOM";
+	case SecretSerializationType::KEY_VALUE_SECRET:
+		return "KEY_VALUE_SECRET";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented in ToChars<SecretSerializationType>", value));
+	}
+}
+
+template<>
+SecretSerializationType EnumUtil::FromString<SecretSerializationType>(const char *value) {
+	if (StringUtil::Equals(value, "CUSTOM")) {
+		return SecretSerializationType::CUSTOM;
+	}
+	if (StringUtil::Equals(value, "KEY_VALUE_SECRET")) {
+		return SecretSerializationType::KEY_VALUE_SECRET;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented in FromString<SecretSerializationType>", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<SequenceInfo>(SequenceInfo value) {
 	switch(value) {

package/src/duckdb/src/common/exception.cpp

@@ -292,6 +292,9 @@ PermissionException::PermissionException(const string &msg) : Exception(Exceptio
 SyntaxException::SyntaxException(const string &msg) : Exception(ExceptionType::SYNTAX, msg) {
 }
 
+ExecutorException::ExecutorException(const string &msg) : Exception(ExceptionType::EXECUTOR, msg) {
+}
+
 ConstraintException::ConstraintException(const string &msg) : Exception(ExceptionType::CONSTRAINT, msg) {
 }
 

package/src/duckdb/src/common/extra_type_info.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/extra_type_info.hpp"
+#include "duckdb/common/extra_type_info/enum_type_info.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/numeric_utils.hpp"
@@ -220,50 +221,6 @@ PhysicalType EnumTypeInfo::DictType(idx_t size) {
 	}
 }
 
-template <class T>
-struct EnumTypeInfoTemplated : public EnumTypeInfo {
-	explicit EnumTypeInfoTemplated(Vector &values_insert_order_p, idx_t size_p)
-	    : EnumTypeInfo(values_insert_order_p, size_p) {
-		D_ASSERT(values_insert_order_p.GetType().InternalType() == PhysicalType::VARCHAR);
-
-		UnifiedVectorFormat vdata;
-		values_insert_order.ToUnifiedFormat(size_p, vdata);
-
-		auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
-		for (idx_t i = 0; i < size_p; i++) {
-			auto idx = vdata.sel->get_index(i);
-			if (!vdata.validity.RowIsValid(idx)) {
-				throw InternalException("Attempted to create ENUM type with NULL value");
-			}
-			if (values.count(data[idx]) > 0) {
-				throw InvalidInputException("Attempted to create ENUM type with duplicate value %s",
-				                            data[idx].GetString());
-			}
-			values[data[idx]] = UnsafeNumericCast<T>(i);
-		}
-	}
-
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(Deserializer &deserializer, uint32_t size) {
-		Vector values_insert_order(LogicalType::VARCHAR, size);
-		auto strings = FlatVector::GetData<string_t>(values_insert_order);
-
-		deserializer.ReadList(201, "values", [&](Deserializer::List &list, idx_t i) {
-			strings[i] = StringVector::AddStringOrBlob(values_insert_order, list.ReadElement<string>());
-		});
-		return make_shared_ptr<EnumTypeInfoTemplated>(values_insert_order, size);
-	}
-
-	const string_map_t<T> &GetValues() const {
-		return values;
-	}
-
-	EnumTypeInfoTemplated(const EnumTypeInfoTemplated &) = delete;
-	EnumTypeInfoTemplated &operator=(const EnumTypeInfoTemplated &) = delete;
-
-private:
-	string_map_t<T> values;
-};
-
 EnumTypeInfo::EnumTypeInfo(Vector &values_insert_order_p, idx_t dict_size_p)
     : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), values_insert_order(values_insert_order_p),
       dict_type(EnumDictType::VECTOR_DICT), dict_size(dict_size_p) {

package/src/duckdb/src/common/field_writer.cpp

@@ -0,0 +1,97 @@
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Field Writer
+//===--------------------------------------------------------------------===//
+FieldWriter::FieldWriter(Serializer &serializer_p)
+    : serializer(serializer_p), buffer(make_uniq<BufferedSerializer>()), field_count(0), finalized(false) {
+	buffer->SetVersion(serializer.GetVersion());
+}
+
+FieldWriter::~FieldWriter() {
+	if (Exception::UncaughtException()) {
+		return;
+	}
+	D_ASSERT(finalized);
+	// finalize should always have been called, unless this is destroyed as part of stack unwinding
+	D_ASSERT(!buffer);
+}
+
+void FieldWriter::WriteData(const_data_ptr_t buffer_ptr, idx_t write_size) {
+	D_ASSERT(buffer);
+	buffer->WriteData(buffer_ptr, write_size);
+}
+
+template <>
+void FieldWriter::Write(const string &val) {
+	Write<uint32_t>((uint32_t)val.size());
+	if (!val.empty()) {
+		WriteData(const_data_ptr_cast(val.c_str()), val.size());
+	}
+}
+
+void FieldWriter::Finalize() {
+	D_ASSERT(buffer);
+	D_ASSERT(!finalized);
+	finalized = true;
+	serializer.Write<uint32_t>(field_count);
+	serializer.Write<uint64_t>(buffer->blob.size);
+	serializer.WriteData(buffer->blob.data.get(), buffer->blob.size);
+
+	buffer.reset();
+}
+
+//===--------------------------------------------------------------------===//
+// Field Deserializer
+//===--------------------------------------------------------------------===//
+FieldDeserializer::FieldDeserializer(Deserializer &root) : root(root), remaining_data(idx_t(-1)) {
+	SetVersion(root.GetVersion());
+}
+
+void FieldDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
+	D_ASSERT(remaining_data != idx_t(-1));
+	D_ASSERT(read_size <= remaining_data);
+	root.ReadData(buffer, read_size);
+	remaining_data -= read_size;
+}
+
+idx_t FieldDeserializer::RemainingData() {
+	return remaining_data;
+}
+
+void FieldDeserializer::SetRemainingData(idx_t remaining_data) {
+	this->remaining_data = remaining_data;
+}
+
+//===--------------------------------------------------------------------===//
+// Field Reader
+//===--------------------------------------------------------------------===//
+FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count(0), finalized(false) {
+	max_field_count = source_p.Read<uint32_t>();
+	total_size = source_p.Read<uint64_t>();
+	D_ASSERT(max_field_count > 0);
+	D_ASSERT(total_size > 0);
+	source.SetRemainingData(total_size);
+}
+
+FieldReader::~FieldReader() {
+	if (Exception::UncaughtException()) {
+		return;
+	}
+	D_ASSERT(finalized);
+}
+
+void FieldReader::Finalize() {
+	D_ASSERT(!finalized);
+	finalized = true;
+	if (field_count < max_field_count) {
+		// we can handle this case by calling source.ReadData(buffer, source.RemainingData())
+		throw SerializationException("Not all fields were read. This file might have been written with a newer version "
+		                             "of DuckDB and is incompatible with this version of DuckDB.");
+	}
+	D_ASSERT(source.RemainingData() == 0);
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/render_tree.cpp

@@ -118,7 +118,7 @@ static unique_ptr<RenderTreeNode> CreateNode(const PipelineRenderNode &op) {
 static unique_ptr<RenderTreeNode> CreateNode(const ProfilingNode &op) {
 	auto &info = op.GetProfilingInfo();
 	InsertionOrderPreservingMap<string> extra_info;
-	if (info.Enabled(MetricsType::EXTRA_INFO)) {
+	if (info.Enabled(info.settings, MetricsType::EXTRA_INFO)) {
 		extra_info = op.GetProfilingInfo().extra_info;
 	}
 
@@ -128,11 +128,13 @@ static unique_ptr<RenderTreeNode> CreateNode(const ProfilingNode &op) {
 	}
 
 	auto result = make_uniq<RenderTreeNode>(node_name, extra_info);
-	if (info.Enabled(MetricsType::OPERATOR_CARDINALITY)) {
-		result->extra_text[RenderTreeNode::CARDINALITY] = info.GetMetricAsString(MetricsType::OPERATOR_CARDINALITY);
+	if (info.Enabled(info.settings, MetricsType::OPERATOR_CARDINALITY)) {
+		auto cardinality = info.GetMetricAsString(MetricsType::OPERATOR_CARDINALITY);
+		result->extra_text[RenderTreeNode::CARDINALITY] = cardinality;
 	}
-	if (info.Enabled(MetricsType::OPERATOR_TIMING)) {
-		string timing = StringUtil::Format("%.2f", info.metrics.at(MetricsType::OPERATOR_TIMING).GetValue<double>());
+	if (info.Enabled(info.settings, MetricsType::OPERATOR_TIMING)) {
+		auto value = info.metrics.at(MetricsType::OPERATOR_TIMING).GetValue<double>();
+		string timing = StringUtil::Format("%.2f", value);
 		result->extra_text[RenderTreeNode::TIMING] = timing + "s";
 	}
 	return result;