duckdb 0.8.2-dev3458.0 → 0.8.2-dev3949.0

package/src/duckdb/src/include/duckdb/main/relation/read_csv_relation.hpp

@@ -8,19 +8,19 @@
 
 #pragma once
 
-#include "duckdb/execution/operator/persistent/csv_reader_options.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_reader_options.hpp"
 #include "duckdb/main/relation/table_function_relation.hpp"
 
 namespace duckdb {
 
-struct BufferedCSVReaderOptions;
+struct CSVReaderOptions;
 
 class ReadCSVRelation : public TableFunctionRelation {
 public:
-	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
-	                vector<ColumnDefinition> columns, string alias = string());
-	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
-	                BufferedCSVReaderOptions options, string alias = string());
+	ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file, vector<ColumnDefinition> columns,
+	                string alias = string());
+	ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file, CSVReaderOptions options,
+	                string alias = string());
 
 	string alias;
 	bool auto_detect;

package/src/duckdb/src/include/duckdb/parallel/event.hpp

@@ -18,7 +18,7 @@ class Task;
 
 class Event : public std::enable_shared_from_this<Event> {
 public:
-	Event(Executor &executor);
+	explicit Event(Executor &executor);
 	virtual ~Event() = default;
 
 public:
@@ -52,6 +52,17 @@ public:
 	virtual void PrintPipeline() {
 	}
 
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
 protected:
 	Executor &executor;
 	//! The current threads working on the event

package/src/duckdb/src/include/duckdb/storage/block.hpp

@@ -14,6 +14,9 @@
 
 namespace duckdb {
 
+class FormatSerializer;
+class FormatDeserializer;
+
 class Block : public FileBuffer {
 public:
 	Block(Allocator &allocator, block_id_t id);
@@ -51,6 +54,9 @@ struct MetaBlockPointer {
 	}
 	block_id_t GetBlockId();
 	uint32_t GetBlockIndex();
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static MetaBlockPointer FormatDeserialize(FormatDeserializer &source);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp

@@ -97,6 +97,9 @@ public:
 	inline const idx_t &GetMemoryUsage() const {
 		return memory_usage;
 	}
+	bool IsUnloaded() {
+		return state == BlockState::BLOCK_UNLOADED;
+	}
 
 private:
 	static BufferHandle Load(shared_ptr<BlockHandle> &handle, unique_ptr<FileBuffer> buffer = nullptr);

package/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp

@@ -19,6 +19,9 @@
 namespace duckdb {
 struct SelectionVector;
 
+class FormatSerializer;
+class FormatDeserializer;
+
 class Serializer;
 class Deserializer;
 class FieldWriter;
@@ -94,17 +97,18 @@ public:
 
 	void Serialize(Serializer &serializer) const;
 	void Serialize(FieldWriter &writer) const;
-
-	idx_t GetDistinctCount();
-
 	static BaseStatistics Deserialize(Deserializer &source, LogicalType type);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer);
+
 	//! Verify that a vector does not violate the statistics
 	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
 	void Verify(Vector &vector, idx_t count) const;
 
 	string ToString() const;
 
+	idx_t GetDistinctCount();
 	static BaseStatistics FromConstant(const Value &input);
 
 private:

package/src/duckdb/src/include/duckdb/storage/statistics/column_statistics.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
 
 namespace duckdb {
+class FormatSerializer;
 
 class ColumnStatistics {
 public:
@@ -35,6 +36,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	static shared_ptr<ColumnStatistics> Deserialize(Deserializer &source, const LogicalType &type);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static shared_ptr<ColumnStatistics> FormatDeserialize(FormatDeserializer &source);
+
 private:
 	BaseStatistics stats;
 	//! The approximate count distinct stats of the column

package/src/duckdb/src/include/duckdb/storage/statistics/distinct_statistics.hpp

@@ -16,6 +16,8 @@ namespace duckdb {
 class Serializer;
 class Deserializer;
 class Vector;
+class FormatSerializer;
+class FormatDeserializer;
 
 class DistinctStatistics {
 public:
@@ -48,6 +50,9 @@ public:
 
 	static bool TypeIsSupported(const LogicalType &type);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<DistinctStatistics> FormatDeserialize(FormatDeserializer &deserializer);
+
 private:
 	//! For distinct statistics we sample the input to speed up insertions
 	static constexpr const double SAMPLE_RATE = 0.1;

package/src/duckdb/src/include/duckdb/storage/statistics/list_stats.hpp

@@ -31,6 +31,9 @@ struct ListStats {
 	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
 	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
 
+	DUCKDB_API static void FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer);
+	DUCKDB_API static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer, LogicalType type);
+
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 
 	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);

package/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats.hpp

@@ -64,6 +64,9 @@ struct NumericStats {
 	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
 	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
 
+	DUCKDB_API static void FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer);
+	DUCKDB_API static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer, LogicalType type);
+
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 
 	template <class T>

package/src/duckdb/src/include/duckdb/storage/statistics/string_stats.hpp

@@ -61,6 +61,9 @@ struct StringStats {
 	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
 	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
 
+	DUCKDB_API static void FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer);
+	DUCKDB_API static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer, LogicalType type);
+
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 
 	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,

package/src/duckdb/src/include/duckdb/storage/statistics/struct_stats.hpp

@@ -32,6 +32,9 @@ struct StructStats {
 	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
 	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
 
+	DUCKDB_API static void FormatSerialize(const BaseStatistics &stats, FormatSerializer &serializer);
+	DUCKDB_API static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer, LogicalType type);
+
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 
 	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);

package/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp

@@ -18,6 +18,9 @@ struct SelectionVector;
 class Transaction;
 struct TransactionData;
 
+class FormatSerializer;
+class FormatDeserializer;
+
 enum class ChunkInfoType : uint8_t { CONSTANT_INFO, VECTOR_INFO, EMPTY_INFO };
 
 class ChunkInfo {
@@ -46,6 +49,9 @@ public:
 	virtual void Serialize(Serializer &serialize) = 0;
 	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const = 0;
+	static unique_ptr<ChunkInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {
@@ -85,10 +91,13 @@ public:
 	void Serialize(Serializer &serialize) override;
 	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ChunkInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 private:
 	template <class OP>
 	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                            idx_t max_count);
+	                            idx_t max_count) const;
 };
 
 class ChunkVectorInfo : public ChunkInfo {
@@ -109,7 +118,7 @@ public:
 
 public:
 	idx_t GetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                   idx_t max_count);
+	                   idx_t max_count) const;
 	idx_t GetSelVector(TransactionData transaction, SelectionVector &sel_vector, idx_t max_count) override;
 	idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
 	                            SelectionVector &sel_vector, idx_t max_count) override;
@@ -130,10 +139,13 @@ public:
 	void Serialize(Serializer &serialize) override;
 	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ChunkInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 private:
 	template <class OP>
 	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
-	                            idx_t max_count);
+	                            idx_t max_count) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -147,6 +147,10 @@ public:
 
 	void NextVector(CollectionScanState &state);
 
+	// Serialization
+	static void FormatSerialize(RowGroupPointer &pointer, FormatSerializer &serializer);
+	static RowGroupPointer FormatDeserialize(FormatDeserializer &deserializer);
+
 private:
 	ChunkInfo *GetChunkInfo(idx_t vector_idx);
 	ColumnData &GetColumn(storage_t c);

package/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp

@@ -16,6 +16,8 @@
 namespace duckdb {
 class ColumnList;
 class PersistentTableData;
+class FormatSerializer;
+class FormatDeserializer;
 
 class TableStatisticsLock {
 public:
@@ -50,6 +52,9 @@ public:
 	void Serialize(Serializer &serializer);
 	void Deserialize(Deserializer &source, ColumnList &columns);
 
+	void FormatSerialize(FormatSerializer &serializer);
+	void FormatDeserialize(FormatDeserializer &deserializer, ColumnList &columns);
+
 private:
 	//! The statistics lock
 	mutex stats_lock;

package/src/duckdb/src/include/duckdb/verification/deserialized_statement_verifier_v2.hpp

@@ -23,4 +23,10 @@ public:
 	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
 };
 
+class DeserializedStatementVerifierNoDefaultV2 : public StatementVerifier {
+public:
+	explicit DeserializedStatementVerifierNoDefaultV2(unique_ptr<SQLStatement> statement_p);
+	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/verification/statement_verifier.hpp

@@ -19,6 +19,7 @@ enum class VerificationType : uint8_t {
 	COPIED,
 	DESERIALIZED,
 	DESERIALIZED_V2,
+	DESERIALIZED_V2_NO_DEFAULT,
 	PARSED,
 	UNOPTIMIZED,
 	NO_OPERATOR_CACHING,

package/src/duckdb/src/include/duckdb.h

@@ -1372,6 +1372,18 @@ The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 DUCKDB_API duckdb_logical_type duckdb_create_union_type(duckdb_logical_type member_types, const char **member_names,
                                                         idx_t member_count);
 
+/*!
+Creates a STRUCT type from the passed member name and type arrays.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* member_types: The array of types that the struct should consist of.
+* member_names: The array of names that the struct should consist of.
+* member_count: The number of members that were specified for both arrays.
+* returns: The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types, const char **member_names,
+                                                         idx_t member_count);
+
 /*!
 Creates a `duckdb_logical_type` of type decimal with the specified width and scale
 The resulting type should be destroyed with `duckdb_destroy_logical_type`.

package/src/duckdb/src/main/capi/logical_types-c.cpp

@@ -51,6 +51,28 @@ duckdb_logical_type duckdb_create_union_type(duckdb_logical_type member_types_p,
 	return reinterpret_cast<duckdb_logical_type>(mtype);
 }
 
+duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types_p, const char **member_names,
+                                              idx_t member_count) {
+	if (!member_types_p || !member_names) {
+		return nullptr;
+	}
+	duckdb::LogicalType **member_types = (duckdb::LogicalType **)member_types_p;
+	for (idx_t i = 0; i < member_count; i++) {
+		if (!member_names[i] || !member_types[i]) {
+			return nullptr;
+		}
+	}
+
+	duckdb::LogicalType *mtype = new duckdb::LogicalType;
+	duckdb::child_list_t<duckdb::LogicalType> members;
+
+	for (idx_t i = 0; i < member_count; i++) {
+		members.push_back(make_pair(member_names[i], *member_types[i]));
+	}
+	*mtype = duckdb::LogicalType::STRUCT(members);
+	return reinterpret_cast<duckdb_logical_type>(mtype);
+}
+
 duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type) {
 	if (!key_type || !value_type) {
 		return nullptr;

package/src/duckdb/src/main/client_context_file_opener.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/main/client_context_file_opener.hpp"
 
+#include "duckdb/common/file_opener.hpp"
 #include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
@@ -8,6 +9,11 @@ bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &res
 	return context.TryGetCurrentSetting(key, result);
 }
 
+// LCOV_EXCL_START
+bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) {
+	return context.TryGetCurrentSetting(key, result);
+}
+
 ClientContext *FileOpener::TryGetClientContext(FileOpener *opener) {
 	if (!opener) {
 		return nullptr;
@@ -22,4 +28,15 @@ bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Val
 	return opener->TryGetCurrentSetting(key, result);
 }
 
+bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result, FileOpenerInfo &info) {
+	if (!opener) {
+		return false;
+	}
+	return opener->TryGetCurrentSetting(key, result, info);
+}
+
+bool FileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) {
+	return this->TryGetCurrentSetting(key, result);
+}
+// LCOV_EXCL_STOP
 } // namespace duckdb

package/src/duckdb/src/main/client_verify.cpp

@@ -41,6 +41,7 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::COPIED, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED_V2, stmt));
+		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED_V2_NO_DEFAULT, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::UNOPTIMIZED, stmt));
 		prepared_statement_verifier = StatementVerifier::Create(VerificationType::PREPARED, stmt);
 #ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE

package/src/duckdb/src/main/config.cpp

@@ -285,7 +285,7 @@ idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
 	}
 }
 
-idx_t GetSystemMaxThreadsInternal(FileSystem &fs) {
+idx_t DBConfig::GetSystemMaxThreads(FileSystem &fs) {
 #ifndef DUCKDB_NO_THREADS
 	idx_t physical_cores = std::thread::hardware_concurrency();
 #ifdef __linux__
@@ -301,7 +301,7 @@ idx_t GetSystemMaxThreadsInternal(FileSystem &fs) {
 
 void DBConfig::SetDefaultMaxThreads() {
 #ifndef DUCKDB_NO_THREADS
-	options.maximum_threads = GetSystemMaxThreadsInternal(*file_system);
+	options.maximum_threads = GetSystemMaxThreads(*file_system);
 #else
 	options.maximum_threads = 1;
 #endif

package/src/duckdb/src/main/connection.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/main/connection.hpp"
 
 #include "duckdb/common/types/column/column_data_collection.hpp"
-#include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
+#include "duckdb/execution/operator/scan/csv/parallel_csv_reader.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/main/appender.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -219,11 +219,11 @@ shared_ptr<Relation> Connection::Values(const string &values, const vector<strin
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
-	BufferedCSVReaderOptions options;
+	CSVReaderOptions options;
 	return ReadCSV(csv_file, options);
 }
 
-shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, BufferedCSVReaderOptions &options) {
+shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, CSVReaderOptions &options) {
 	options.file_path = csv_file;
 	options.auto_detect = true;
 	return make_shared<ReadCSVRelation>(context, csv_file, options);

package/src/duckdb/src/main/relation/read_csv_relation.cpp

@@ -1,18 +1,21 @@
 #include "duckdb/main/relation/read_csv_relation.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
+
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/execution/operator/scan/csv/buffered_csv_reader.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_sniffer.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/persistent/buffered_csv_reader.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 
 namespace duckdb {
 
-ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
+ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file,
                                  vector<ColumnDefinition> columns_p, string alias_p)
     : TableFunctionRelation(context, "read_csv", {Value(csv_file)}, nullptr, false), alias(std::move(alias_p)),
       auto_detect(false) {
@@ -31,8 +34,8 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 	AddNamedParameter("columns", Value::STRUCT(std::move(column_names)));
 }
 
-ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
-                                 BufferedCSVReaderOptions options, string alias_p)
+ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file,
+                                 CSVReaderOptions options, string alias_p)
     : TableFunctionRelation(context, "read_csv_auto", {Value(csv_file)}, nullptr, false), alias(std::move(alias_p)),
       auto_detect(true) {
 
@@ -42,10 +45,13 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 
 	// Force auto_detect for this constructor
 	options.auto_detect = true;
-	BufferedCSVReader reader(*context, std::move(options));
-
-	auto &types = reader.GetTypes();
-	auto &names = reader.GetNames();
+	auto bm_file_handle = BaseCSVReader::OpenCSV(*context, options);
+	auto buffer_manager = make_shared<CSVBufferManager>(*context, std::move(bm_file_handle), options);
+	CSVStateMachineCache state_machine_cache;
+	CSVSniffer sniffer(options, buffer_manager, state_machine_cache);
+	auto sniffer_result = sniffer.SniffCSV();
+	auto &types = sniffer_result.return_types;
+	auto &names = sniffer_result.names;
 	for (idx_t i = 0; i < types.size(); i++) {
 		columns.emplace_back(names[i], types[i]);
 	}

package/src/duckdb/src/parallel/pipeline_finish_event.cpp

@@ -51,7 +51,7 @@ private:
 	//! Debugging state: number of times blocked
 	int debug_blocked_count = 0;
 	//! Number of times the Finalize will block before actually returning data
-	int debug_blocked_target_count = 1;
+	int debug_blocked_target_count = 10;
 #endif
 };
 

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -2,8 +2,6 @@
 
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -160,12 +158,6 @@ void PivotColumnEntry::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void PivotColumnEntry::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty(100, "values", values);
-	serializer.WriteOptionalProperty(101, "star_expr", star_expr);
-	serializer.WriteProperty(102, "alias", alias);
-}
-
 PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
 	PivotColumnEntry result;
 	FieldReader reader(source);
@@ -176,14 +168,6 @@ PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
 	return result;
 }
 
-PivotColumnEntry PivotColumnEntry::FormatDeserialize(FormatDeserializer &source) {
-	PivotColumnEntry result;
-	source.ReadProperty(100, "values", result.values);
-	source.ReadOptionalProperty(101, "star_expr", result.star_expr);
-	source.ReadProperty(102, "alias", result.alias);
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotRef
 //===--------------------------------------------------------------------===//

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

@@ -5,7 +5,7 @@
 #include "duckdb/common/bind_helpers.hpp"
 #include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
-#include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
+#include "duckdb/execution/operator/scan/csv/parallel_csv_reader.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"