duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_reader.hpp

@@ -9,12 +9,13 @@
 #pragma once
 
 #include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/common/serializer/read_stream.hpp"
 
 namespace duckdb {
 
 enum class BlockReaderType { EXISTING_BLOCKS, REGISTER_BLOCKS };
 
-class MetadataReader : public Deserializer {
+class MetadataReader : public ReadStream {
 public:
 	MetadataReader(MetadataManager &manager, MetaBlockPointer pointer,
 	               BlockReaderType type = BlockReaderType::EXISTING_BLOCKS);

package/src/duckdb/src/include/duckdb/storage/metadata/metadata_writer.hpp

@@ -9,10 +9,11 @@
 #pragma once
 
 #include "duckdb/storage/metadata/metadata_manager.hpp"
+#include "duckdb/common/serializer/write_stream.hpp"
 
 namespace duckdb {
 
-class MetadataWriter : public Serializer {
+class MetadataWriter : public WriteStream {
 public:
 	MetadataWriter(const MetadataWriter &) = delete;
 	MetadataWriter &operator=(const MetadataWriter &) = delete;
@@ -22,7 +23,6 @@ public:
 
 public:
 	void WriteData(const_data_ptr_t buffer, idx_t write_size) override;
-
 	void Flush();
 
 	BlockPointer GetBlockPointer();

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

@@ -19,13 +19,9 @@
 namespace duckdb {
 struct SelectionVector;
 
-class FormatSerializer;
-class FormatDeserializer;
-
 class Serializer;
 class Deserializer;
-class FieldWriter;
-class FieldReader;
+
 class Vector;
 struct UnifiedVectorFormat;
 
@@ -96,11 +92,7 @@ public:
 	void CopyBase(const BaseStatistics &orig);
 
 	void Serialize(Serializer &serializer) const;
-	void Serialize(FieldWriter &writer) const;
-	static BaseStatistics Deserialize(Deserializer &source, LogicalType type);
-
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static BaseStatistics FormatDeserialize(FormatDeserializer &deserializer);
+	static BaseStatistics Deserialize(Deserializer &deserializer);
 
 	//! Verify that a vector does not violate the statistics
 	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
@@ -122,7 +114,6 @@ private:
 
 	static BaseStatistics CreateUnknownType(LogicalType type);
 	static BaseStatistics CreateEmptyType(LogicalType type);
-	static BaseStatistics DeserializeType(FieldReader &reader, LogicalType type);
 	static BaseStatistics FromConstantType(const Value &input);
 
 private:

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

@@ -12,7 +12,7 @@
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
 
 namespace duckdb {
-class FormatSerializer;
+class Serializer;
 
 class ColumnStatistics {
 public:
@@ -33,11 +33,9 @@ public:
 	void SetDistinct(unique_ptr<DistinctStatistics> distinct_stats);
 
 	shared_ptr<ColumnStatistics> Copy() const;
-	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);
+	void Serialize(Serializer &serializer) const;
+	static shared_ptr<ColumnStatistics> Deserialize(Deserializer &source);
 
 private:
 	BaseStatistics stats;

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

@@ -13,11 +13,9 @@
 #include "duckdb/storage/statistics/base_statistics.hpp"
 
 namespace duckdb {
+class Vector;
 class Serializer;
 class Deserializer;
-class Vector;
-class FormatSerializer;
-class FormatDeserializer;
 
 class DistinctStatistics {
 public:
@@ -36,12 +34,6 @@ public:
 
 	unique_ptr<DistinctStatistics> Copy() const;
 
-	void Serialize(Serializer &serializer) const;
-	void Serialize(FieldWriter &writer) const;
-
-	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
-	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
-
 	void Update(Vector &update, idx_t count, bool sample = true);
 	void Update(UnifiedVectorFormat &update_data, const LogicalType &ptype, idx_t count, bool sample = true);
 
@@ -50,8 +42,8 @@ public:
 
 	static bool TypeIsSupported(const LogicalType &type);
 
-	void FormatSerialize(FormatSerializer &serializer) const;
-	static unique_ptr<DistinctStatistics> FormatDeserialize(FormatDeserializer &deserializer);
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &deserializer);
 
 private:
 	//! For distinct statistics we sample the input to speed up insertions

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

@@ -14,8 +14,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -28,11 +26,8 @@ struct ListStats {
 	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats);
 	DUCKDB_API static void SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats);
 
-	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 void Serialize(const BaseStatistics &stats, Serializer &serializer);
+	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
 
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 

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

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 
@@ -24,31 +23,6 @@ public:
 	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(true),
 	      max_cardinality(max_cardinality) {
 	}
-	void Serialize(Serializer &serializer) const {
-		serializer.Write(has_estimated_cardinality);
-		if (has_estimated_cardinality) {
-			serializer.Write(estimated_cardinality);
-			serializer.Write(has_max_cardinality);
-			if (has_max_cardinality) {
-				serializer.Write(max_cardinality);
-			}
-		} else {
-			D_ASSERT(!has_max_cardinality);
-		}
-	}
-	static unique_ptr<NodeStatistics> Deserialize(Deserializer &source) {
-		bool has_estimated_cardinality = source.Read<bool>();
-		if (!has_estimated_cardinality) {
-			return make_uniq<NodeStatistics>();
-		}
-		idx_t estimated_cardinality = source.Read<idx_t>();
-		bool has_max_cardinality = source.Read<bool>();
-		if (!has_max_cardinality) {
-			return make_uniq<NodeStatistics>(estimated_cardinality);
-		}
-		idx_t max_cardinality = source.Read<idx_t>();
-		return make_uniq<NodeStatistics>(estimated_cardinality, max_cardinality);
-	}
 
 	//! Whether or not the node has an estimated cardinality specified
 	bool has_estimated_cardinality;

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

@@ -16,8 +16,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -61,11 +59,8 @@ struct NumericStats {
 
 	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other_p);
 
-	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 void Serialize(const BaseStatistics &stats, Serializer &serializer);
+	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &stats);
 
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 

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

@@ -17,8 +17,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -58,11 +56,8 @@ struct StringStats {
 	//! FIXME: make this part of Set on statistics
 	DUCKDB_API static void SetContainsUnicode(BaseStatistics &stats);
 
-	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 void Serialize(const BaseStatistics &stats, Serializer &serializer);
+	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
 
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 

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

@@ -13,8 +13,6 @@
 
 namespace duckdb {
 class BaseStatistics;
-class FieldWriter;
-class FieldReader;
 struct SelectionVector;
 class Vector;
 
@@ -29,11 +27,8 @@ struct StructStats {
 	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, const BaseStatistics &new_stats);
 	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, unique_ptr<BaseStatistics> new_stats);
 
-	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 void Serialize(const BaseStatistics &stats, Serializer &serializer);
+	DUCKDB_API static void Deserialize(Deserializer &deserializer, BaseStatistics &base);
 
 	DUCKDB_API static string ToString(const BaseStatistics &stats);
 

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

@@ -12,8 +12,6 @@
 #include "duckdb/common/vector_size.hpp"
 
 namespace duckdb {
-class Serializer;
-class Deserializer;
 struct FileHandle;
 
 #define STANDARD_ROW_GROUPS_SIZE 122880
@@ -53,8 +51,8 @@ struct MainHeader {
 
 	static void CheckMagicBytes(FileHandle &handle);
 
-	void Serialize(Serializer &ser);
-	static MainHeader Deserialize(Deserializer &source);
+	void Write(WriteStream &ser);
+	static MainHeader Read(ReadStream &source);
 };
 
 //! The DatabaseHeader contains information about the current state of the database. Every storage file has two
@@ -72,8 +70,8 @@ struct DatabaseHeader {
 	//! block_count any blocks appearing AFTER block_count are implicitly part of the free_list.
 	uint64_t block_count;
 
-	void Serialize(Serializer &ser);
-	static DatabaseHeader Deserialize(Deserializer &source);
+	void Write(WriteStream &ser);
+	static DatabaseHeader Read(ReadStream &source);
 };
 
 } // namespace duckdb

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

@@ -18,8 +18,8 @@ struct SelectionVector;
 class Transaction;
 struct TransactionData;
 
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 enum class ChunkInfoType : uint8_t { CONSTANT_INFO, VECTOR_INFO, EMPTY_INFO };
 
@@ -46,11 +46,8 @@ public:
 	virtual void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) = 0;
 	virtual idx_t GetCommittedDeletedCount(idx_t max_count) = 0;
 
-	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);
+	virtual void Serialize(Serializer &serializer) const = 0;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
 
 public:
 	template <class TARGET>
@@ -88,11 +85,8 @@ public:
 	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
 	idx_t GetCommittedDeletedCount(idx_t max_count) override;
 
-	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);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
 
 private:
 	template <class OP>
@@ -136,11 +130,8 @@ public:
 	idx_t Delete(transaction_t transaction_id, row_t rows[], idx_t count);
 	void CommitDelete(transaction_t commit_id, row_t rows[], idx_t count);
 
-	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);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &deserializer);
 
 private:
 	template <class OP>

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

@@ -41,7 +41,7 @@ public:
 	virtual unique_ptr<BaseStatistics> GetStatistics();
 
 	virtual void FlushSegment(unique_ptr<ColumnSegment> segment, idx_t segment_size);
-	virtual void WriteDataPointers(RowGroupWriter &writer);
+	virtual void WriteDataPointers(RowGroupWriter &writer, Serializer &serializer);
 
 public:
 	template <class TARGET>

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

@@ -125,9 +125,9 @@ public:
 	virtual void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
 	                            Vector &scan_vector);
 
-	virtual void DeserializeColumn(Deserializer &source);
+	virtual void DeserializeColumn(Deserializer &deserializer);
 	static shared_ptr<ColumnData> Deserialize(BlockManager &block_manager, DataTableInfo &info, idx_t column_index,
-	                                          idx_t start_row, Deserializer &source, const LogicalType &type,
+	                                          idx_t start_row, ReadStream &source, const LogicalType &type,
 	                                          optional_ptr<ColumnData> parent);
 
 	virtual void GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path, vector<ColumnSegmentInfo> &result);

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

@@ -56,7 +56,7 @@ public:
 	unique_ptr<ColumnCheckpointState> Checkpoint(RowGroup &row_group, PartialBlockManager &partial_block_manager,
 	                                             ColumnCheckpointInfo &checkpoint_info) override;
 
-	void DeserializeColumn(Deserializer &source) override;
+	void DeserializeColumn(Deserializer &deserializer) override;
 
 	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
 	                          vector<duckdb::ColumnSegmentInfo> &result) override;

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

@@ -124,8 +124,6 @@ public:
 	RowGroupWriteData WriteToDisk(PartialBlockManager &manager, const vector<CompressionType> &compression_types);
 	bool AllDeleted();
 	RowGroupPointer Checkpoint(RowGroupWriter &writer, TableStatistics &global_stats);
-	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
-	static RowGroupPointer Deserialize(Deserializer &source, const vector<LogicalType> &columns);
 
 	void InitializeAppend(RowGroupAppendState &append_state);
 	void Append(RowGroupAppendState &append_state, DataChunk &chunk, idx_t append_count);
@@ -148,8 +146,8 @@ public:
 	void NextVector(CollectionScanState &state);
 
 	// Serialization
-	static void FormatSerialize(RowGroupPointer &pointer, FormatSerializer &serializer);
-	static RowGroupPointer FormatDeserialize(FormatDeserializer &deserializer);
+	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
+	static RowGroupPointer Deserialize(Deserializer &deserializer);
 
 private:
 	ChunkInfo *GetChunkInfo(idx_t vector_idx);
@@ -160,9 +158,6 @@ private:
 	template <TableScanType TYPE>
 	void TemplatedScan(TransactionData transaction, CollectionScanState &state, DataChunk &result);
 
-	static void CheckpointDeletes(VersionNode *versions, Serializer &serializer);
-	static shared_ptr<VersionNode> DeserializeDeletes(Deserializer &source);
-
 private:
 	mutex row_group_lock;
 	mutex stats_lock;

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

@@ -54,11 +54,11 @@ public:
 	void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t row_group_start, idx_t count,
 	                    Vector &scan_vector) override;
 
-	void DeserializeColumn(Deserializer &source) override;
-
 	void GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
 	                          vector<duckdb::ColumnSegmentInfo> &result) override;
 
+	void DeserializeColumn(Deserializer &deserializer) override;
+
 	void Verify(RowGroup &parent) override;
 };
 

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

@@ -16,8 +16,8 @@
 namespace duckdb {
 class ColumnList;
 class PersistentTableData;
-class FormatSerializer;
-class FormatDeserializer;
+class Serializer;
+class Deserializer;
 
 class TableStatisticsLock {
 public:
@@ -49,11 +49,8 @@ public:
 
 	unique_ptr<TableStatisticsLock> GetLock();
 
-	void Serialize(Serializer &serializer);
-	void Deserialize(Deserializer &source, ColumnList &columns);
-
-	void FormatSerialize(FormatSerializer &serializer);
-	void FormatDeserialize(FormatDeserializer &deserializer, ColumnList &columns);
+	void Serialize(Serializer &serializer) const;
+	void Deserialize(Deserializer &deserializer, ColumnList &columns);
 
 private:
 	//! The statistics lock

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

@@ -24,7 +24,6 @@ namespace duckdb {
 struct AlterInfo;
 
 class AttachedDatabase;
-class BufferedSerializer;
 class Catalog;
 class DatabaseInstance;
 class SchemaCatalogEntry;
@@ -38,53 +37,52 @@ class TransactionManager;
 
 class ReplayState {
 public:
-	ReplayState(AttachedDatabase &db, ClientContext &context, Deserializer &source)
-	    : db(db), context(context), catalog(db.GetCatalog()), source(source), deserialize_only(false) {
+	ReplayState(AttachedDatabase &db, ClientContext &context)
+	    : db(db), context(context), catalog(db.GetCatalog()), deserialize_only(false) {
 	}
 
 	AttachedDatabase &db;
 	ClientContext &context;
 	Catalog &catalog;
-	Deserializer &source;
 	optional_ptr<TableCatalogEntry> current_table;
 	bool deserialize_only;
 	MetaBlockPointer checkpoint_id;
 
 public:
-	void ReplayEntry(WALType entry_type);
+	void ReplayEntry(WALType entry_type, BinaryDeserializer &deserializer);
 
 protected:
-	virtual void ReplayCreateTable();
-	void ReplayDropTable();
-	void ReplayAlter();
+	virtual void ReplayCreateTable(BinaryDeserializer &deserializer);
+	void ReplayDropTable(BinaryDeserializer &deserializer);
+	void ReplayAlter(BinaryDeserializer &deserializer);
 
-	void ReplayCreateView();
-	void ReplayDropView();
+	void ReplayCreateView(BinaryDeserializer &deserializer);
+	void ReplayDropView(BinaryDeserializer &deserializer);
 
-	void ReplayCreateSchema();
-	void ReplayDropSchema();
+	void ReplayCreateSchema(BinaryDeserializer &deserializer);
+	void ReplayDropSchema(BinaryDeserializer &deserializer);
 
-	void ReplayCreateType();
-	void ReplayDropType();
+	void ReplayCreateType(BinaryDeserializer &deserializer);
+	void ReplayDropType(BinaryDeserializer &deserializer);
 
-	void ReplayCreateSequence();
-	void ReplayDropSequence();
-	void ReplaySequenceValue();
+	void ReplayCreateSequence(BinaryDeserializer &deserializer);
+	void ReplayDropSequence(BinaryDeserializer &deserializer);
+	void ReplaySequenceValue(BinaryDeserializer &deserializer);
 
-	void ReplayCreateMacro();
-	void ReplayDropMacro();
+	void ReplayCreateMacro(BinaryDeserializer &deserializer);
+	void ReplayDropMacro(BinaryDeserializer &deserializer);
 
-	void ReplayCreateTableMacro();
-	void ReplayDropTableMacro();
+	void ReplayCreateTableMacro(BinaryDeserializer &deserializer);
+	void ReplayDropTableMacro(BinaryDeserializer &deserializer);
 
-	void ReplayCreateIndex();
-	void ReplayDropIndex();
+	void ReplayCreateIndex(BinaryDeserializer &deserializer);
+	void ReplayDropIndex(BinaryDeserializer &deserializer);
 
-	void ReplayUseTable();
-	void ReplayInsert();
-	void ReplayDelete();
-	void ReplayUpdate();
-	void ReplayCheckpoint();
+	void ReplayUseTable(BinaryDeserializer &deserializer);
+	void ReplayInsert(BinaryDeserializer &deserializer);
+	void ReplayDelete(BinaryDeserializer &deserializer);
+	void ReplayUpdate(BinaryDeserializer &deserializer);
+	void ReplayCheckpoint(BinaryDeserializer &deserializer);
 };
 
 //! The WriteAheadLog (WAL) is a log that is used to provide durability. Prior
@@ -136,7 +134,7 @@ public:
 	//! Sets the table used for subsequent insert/delete/update commands
 	void WriteSetTable(string &schema, string &table);
 
-	void WriteAlter(data_ptr_t ptr, idx_t data_size);
+	void WriteAlter(const AlterInfo &info);
 
 	void WriteInsert(DataChunk &chunk);
 	void WriteDelete(DataChunk &chunk);

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

@@ -18,8 +18,6 @@ enum class VerificationType : uint8_t {
 	ORIGINAL,
 	COPIED,
 	DESERIALIZED,
-	DESERIALIZED_V2,
-	DESERIALIZED_V2_NO_DEFAULT,
 	PARSED,
 	UNOPTIMIZED,
 	NO_OPERATOR_CACHING,

package/src/duckdb/src/main/client_context.cpp

@@ -7,9 +7,7 @@
 #include "duckdb/common/http_state.hpp"
 #include "duckdb/common/preserved_error.hpp"
 #include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/execution/operator/helper/physical_result_collector.hpp"
@@ -27,11 +25,9 @@
 #include "duckdb/main/relation.hpp"
 #include "duckdb/main/stream_query_result.hpp"
 #include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/parameter_expression.hpp"
 #include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/drop_statement.hpp"
@@ -43,9 +39,7 @@
 #include "duckdb/planner/operator/logical_execute.hpp"
 #include "duckdb/planner/planner.hpp"
 #include "duckdb/planner/pragma_handler.hpp"
-#include "duckdb/storage/data_table.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 
 namespace duckdb {

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

@@ -40,8 +40,6 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 	if (config.query_verification_enabled) {
 		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/extension/extension_helper.cpp

@@ -118,6 +118,7 @@ static DefaultExtension internal_extensions[] = {
     {"spatial", "Geospatial extension that adds support for working with spatial data and functions", false},
     {"substrait", "Adds support for the Substrait integration", false},
     {"aws", "Provides features that depend on the AWS SDK", false},
+    {"arrow", "A zero-copy data integration between Apache Arrow and DuckDB", false},
     {"azure", "Adds a filesystem abstraction for Azure blob storage to DuckDB", false},
     {"iceberg", "Adds support for Apache Iceberg", false},
     {"visualizer", "Creates an HTML-based visualization of the query plan", false},
@@ -194,13 +195,30 @@ string ExtensionHelper::AddExtensionInstallHintToErrorMsg(ClientContext &context
 	return base_error;
 }
 
+bool ExtensionHelper::TryAutoLoadExtension(ClientContext &context, const string &extension_name) noexcept {
+	auto &dbconfig = DBConfig::GetConfig(context);
+	try {
+		if (dbconfig.options.autoinstall_known_extensions) {
+			ExtensionHelper::InstallExtension(context, extension_name, false,
+			                                  context.config.autoinstall_extension_repo);
+		}
+		ExtensionHelper::LoadExternalExtension(context, extension_name);
+		return true;
+	} catch (...) {
+		return false;
+	}
+	return false;
+}
+
 void ExtensionHelper::AutoLoadExtension(ClientContext &context, const string &extension_name) {
 	auto &dbconfig = DBConfig::GetConfig(context);
 	try {
+#ifndef DUCKDB_WASM
 		if (dbconfig.options.autoinstall_known_extensions) {
 			ExtensionHelper::InstallExtension(context, extension_name, false,
 			                                  context.config.autoinstall_extension_repo);
 		}
+#endif
 		ExtensionHelper::LoadExternalExtension(context, extension_name);
 	} catch (Exception &e) {
 		throw AutoloadException(extension_name, e);