duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

package/src/duckdb/src/parallel/executor.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/execution/operator/helper/physical_result_collector.hpp"
 #include "duckdb/execution/operator/set/physical_recursive_cte.hpp"
+#include "duckdb/execution/operator/set/physical_cte.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
@@ -106,7 +107,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 			                                  group_stack.pipeline_finish_event, base_stack.pipeline_complete_event);
 
 			// dependencies: base_finish -> pipeline_event -> group_finish
-			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_event);
+			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_finish_event);
 			group_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
 
 			// add pipeline stack to event map
@@ -267,6 +268,10 @@ void Executor::AddRecursiveCTE(PhysicalOperator &rec_cte) {
 	recursive_ctes.push_back(rec_cte);
 }
 
+void Executor::AddMaterializedCTE(PhysicalOperator &mat_cte) {
+	materialized_ctes.push_back(mat_cte);
+}
+
 void Executor::ReschedulePipelines(const vector<shared_ptr<MetaPipeline>> &pipelines_p,
                                    vector<shared_ptr<Event>> &events_p) {
 	ScheduleEventData event_data(pipelines_p, events_p, false);
@@ -344,6 +349,12 @@ void Executor::InitializeInternal(PhysicalOperator &plan) {
 			rec_cte.recursive_meta_pipeline->Ready();
 		}
 
+		// ready materialized cte pipelines too
+		for (auto &mat_cte_ref : materialized_ctes) {
+			auto &mat_cte = mat_cte_ref.get().Cast<PhysicalCTE>();
+			mat_cte.recursive_meta_pipeline->Ready();
+		}
+
 		// set root pipelines, i.e., all pipelines that end in the final sink
 		root_pipeline->GetPipelines(root_pipelines, false);
 		root_pipeline_idx = 0;
@@ -381,6 +392,10 @@ void Executor::CancelTasks() {
 			auto &rec_cte = rec_cte_ref.get().Cast<PhysicalRecursiveCTE>();
 			rec_cte.recursive_meta_pipeline.reset();
 		}
+		for (auto &mat_cte_ref : materialized_ctes) {
+			auto &mat_cte = mat_cte_ref.get().Cast<PhysicalCTE>();
+			mat_cte.recursive_meta_pipeline.reset();
+		}
 		pipelines.clear();
 		root_pipelines.clear();
 		to_be_rescheduled_tasks.clear();
@@ -443,6 +458,8 @@ bool Executor::ExecutionIsFinished() {
 }
 
 PendingExecutionResult Executor::ExecuteTask() {
+	// Only executor should return NO_TASKS_AVAILABLE
+	D_ASSERT(execution_result != PendingExecutionResult::NO_TASKS_AVAILABLE);
 	if (execution_result != PendingExecutionResult::RESULT_NOT_READY) {
 		return execution_result;
 	}
@@ -453,6 +470,10 @@ PendingExecutionResult Executor::ExecuteTask() {
 		if (!task) {
 			scheduler.GetTaskFromProducer(*producer, task);
 		}
+		if (!task && !HasError()) {
+			// there are no tasks to be scheduled and there are tasks blocked
+			return PendingExecutionResult::NO_TASKS_AVAILABLE;
+		}
 		if (task) {
 			// if we have a task, partially process it
 			auto result = task->Execute(TaskExecutionMode::PROCESS_PARTIAL);
@@ -574,6 +595,9 @@ bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_STA
 		total_cardinality += child_cardinality;
 	}
 	current_progress = 0;
+	if (total_cardinality == 0) {
+		return true;
+	}
 	for (size_t i = 0; i < progress.size(); i++) {
 		current_progress += progress[i] * double(cardinality[i]) / double(total_cardinality);
 	}

package/src/duckdb/src/parallel/pipeline.cpp

@@ -218,23 +218,6 @@ void Pipeline::Ready() {
 	std::reverse(operators.begin(), operators.end());
 }
 
-void Pipeline::Finalize(Event &event) {
-	if (executor.HasError()) {
-		return;
-	}
-	D_ASSERT(ready);
-	try {
-		auto sink_state = sink->Finalize(*this, event, executor.context, *sink->sink_state);
-		sink->sink_state->state = sink_state;
-	} catch (Exception &ex) { // LCOV_EXCL_START
-		executor.PushError(PreservedError(ex));
-	} catch (std::exception &ex) {
-		executor.PushError(PreservedError(ex));
-	} catch (...) {
-		executor.PushError(PreservedError("Unknown exception in Finalize!"));
-	} // LCOV_EXCL_STOP
-}
-
 void Pipeline::AddDependency(shared_ptr<Pipeline> &pipeline) {
 	D_ASSERT(pipeline);
 	dependencies.push_back(weak_ptr<Pipeline>(pipeline));

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -171,9 +171,7 @@ PipelineExecuteResult PipelineExecutor::Execute(idx_t max_chunks) {
 		return PipelineExecuteResult::NOT_FINISHED;
 	}
 
-	PushFinalize();
-
-	return PipelineExecuteResult::FINISHED;
+	return PushFinalize();
 }
 
 PipelineExecuteResult PipelineExecutor::Execute() {
@@ -238,24 +236,45 @@ OperatorResultType PipelineExecutor::ExecutePushInternal(DataChunk &input, idx_t
 	}
 }
 
-void PipelineExecutor::PushFinalize() {
+PipelineExecuteResult PipelineExecutor::PushFinalize() {
 	if (finalized) {
 		throw InternalException("Calling PushFinalize on a pipeline that has been finalized already");
 	}
 
 	D_ASSERT(local_sink_state);
 
-	finalized = true;
+	// Run the combine for the sink
+	OperatorSinkCombineInput combine_input {*pipeline.sink->sink_state, *local_sink_state, interrupt_state};
+
+#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
+	if (debug_blocked_combine_count < debug_blocked_target_count) {
+		debug_blocked_combine_count++;
+
+		auto &callback_state = combine_input.interrupt_state;
+		std::thread rewake_thread([callback_state] {
+			std::this_thread::sleep_for(std::chrono::milliseconds(1));
+			callback_state.Callback();
+		});
+		rewake_thread.detach();
 
-	// run the combine for the sink
-	pipeline.sink->Combine(context, *pipeline.sink->sink_state, *local_sink_state);
+		return PipelineExecuteResult::INTERRUPTED;
+	}
+#endif
+	auto result = pipeline.sink->Combine(context, combine_input);
 
+	if (result == SinkCombineResultType::BLOCKED) {
+		return PipelineExecuteResult::INTERRUPTED;
+	}
+
+	finalized = true;
 	// flush all query profiler info
 	for (idx_t i = 0; i < intermediate_states.size(); i++) {
 		intermediate_states[i]->Finalize(pipeline.operators[i].get(), context);
 	}
 	pipeline.executor.Flush(thread);
 	local_sink_state.reset();
+
+	return PipelineExecuteResult::FINISHED;
 }
 
 // TODO: Refactoring the StreamingQueryResult to use Push-based execution should eliminate the need for this code

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

@@ -1,16 +1,70 @@
 #include "duckdb/parallel/pipeline_finish_event.hpp"
 #include "duckdb/execution/executor.hpp"
+#include "duckdb/parallel/interrupt.hpp"
 
 namespace duckdb {
 
+//! The PipelineFinishTask calls Finalize on the sink. Note that this is a single-threaded operation, but is executed
+//! in a task to allow the Finalize call to block (e.g. for async I/O)
+class PipelineFinishTask : public ExecutorTask {
+public:
+	explicit PipelineFinishTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
+	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(std::move(event_p)) {
+	}
+
+	Pipeline &pipeline;
+	shared_ptr<Event> event;
+
+public:
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
+		auto sink = pipeline.GetSink();
+		InterruptState interrupt_state(shared_from_this());
+		OperatorSinkFinalizeInput finalize_input {*sink->sink_state, interrupt_state};
+
+#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
+		if (debug_blocked_count < debug_blocked_target_count) {
+			debug_blocked_count++;
+
+			auto &callback_state = interrupt_state;
+			std::thread rewake_thread([callback_state] {
+				std::this_thread::sleep_for(std::chrono::milliseconds(1));
+				callback_state.Callback();
+			});
+			rewake_thread.detach();
+
+			return TaskExecutionResult::TASK_BLOCKED;
+		}
+#endif
+		auto sink_state = sink->Finalize(pipeline, *event, executor.context, finalize_input);
+
+		if (sink_state == SinkFinalizeType::BLOCKED) {
+			return TaskExecutionResult::TASK_BLOCKED;
+		}
+
+		sink->sink_state->state = sink_state;
+		event->FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
+	}
+
+private:
+#ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
+	//! 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 = 10;
+#endif
+};
+
 PipelineFinishEvent::PipelineFinishEvent(shared_ptr<Pipeline> pipeline_p) : BasePipelineEvent(std::move(pipeline_p)) {
 }
 
 void PipelineFinishEvent::Schedule() {
+	vector<shared_ptr<Task>> tasks;
+	tasks.push_back(make_uniq<PipelineFinishTask>(*pipeline, shared_from_this()));
+	SetTasks(std::move(tasks));
 }
 
 void PipelineFinishEvent::FinishEvent() {
-	pipeline->Finalize(*this);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -1,13 +1,15 @@
 #include "duckdb/parallel/task_scheduler.hpp"
 
+#include "duckdb/common/chrono.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "concurrentqueue.h"
-#include "lightweightsemaphore.h"
 #include "duckdb/common/thread.hpp"
+#include "lightweightsemaphore.h"
+#include <thread>
 #else
 #include <queue>
 #endif
@@ -93,7 +95,9 @@ ProducerToken::ProducerToken(TaskScheduler &scheduler, unique_ptr<QueueProducerT
 ProducerToken::~ProducerToken() {
 }
 
-TaskScheduler::TaskScheduler(DatabaseInstance &db) : db(db), queue(make_uniq<ConcurrentQueue>()) {
+TaskScheduler::TaskScheduler(DatabaseInstance &db)
+    : db(db), queue(make_uniq<ConcurrentQueue>()),
+      allocator_flush_threshold(db.config.options.allocator_flush_threshold) {
 }
 
 TaskScheduler::~TaskScheduler() {
@@ -146,6 +150,9 @@ void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 				task.reset();
 				break;
 			}
+
+			// Flushes the outstanding allocator's outstanding allocations
+			Allocator::ThreadFlush(allocator_flush_threshold);
 		}
 	}
 #else
@@ -241,12 +248,21 @@ void TaskScheduler::SetThreads(int32_t n) {
 #endif
 }
 
+void TaskScheduler::SetAllocatorFlushTreshold(idx_t threshold) {
+}
+
 void TaskScheduler::Signal(idx_t n) {
 #ifndef DUCKDB_NO_THREADS
 	queue->semaphore.signal(n);
 #endif
 }
 
+void TaskScheduler::YieldThread() {
+#ifndef DUCKDB_NO_THREADS
+	std::this_thread::yield();
+#endif
+}
+
 void TaskScheduler::SetThreadsInternal(int32_t n) {
 #ifndef DUCKDB_NO_THREADS
 	if (threads.size() == idx_t(n - 1)) {

package/src/duckdb/src/parser/column_definition.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
@@ -13,67 +12,31 @@ ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p)
 
 ColumnDefinition::ColumnDefinition(string name_p, LogicalType type_p, unique_ptr<ParsedExpression> expression,
                                    TableColumnType category)
-    : name(std::move(name_p)), type(std::move(type_p)), category(category) {
-	switch (category) {
-	case TableColumnType::STANDARD: {
-		default_value = std::move(expression);
-		break;
-	}
-	case TableColumnType::GENERATED: {
-		generated_expression = std::move(expression);
-		break;
-	}
-	default: {
-		throw InternalException("Type not implemented for TableColumnType");
-	}
-	}
+    : name(std::move(name_p)), type(std::move(type_p)), category(category), expression(std::move(expression)) {
 }
 
 ColumnDefinition ColumnDefinition::Copy() const {
 	ColumnDefinition copy(name, type);
 	copy.oid = oid;
 	copy.storage_oid = storage_oid;
-	copy.SetDefaultValue(default_value ? default_value->Copy() : nullptr);
-	copy.generated_expression = generated_expression ? generated_expression->Copy() : nullptr;
+	copy.expression = expression ? expression->Copy() : nullptr;
 	copy.compression_type = compression_type;
 	copy.category = category;
 	return copy;
 }
 
-void ColumnDefinition::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(type);
+const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
 	if (Generated()) {
-		writer.WriteOptional(generated_expression);
-	} else {
-		writer.WriteOptional(default_value);
+		throw InternalException("Calling DefaultValue() on a generated column");
 	}
-	writer.WriteField<TableColumnType>(category);
-	writer.WriteField<duckdb::CompressionType>(compression_type);
-	writer.Finalize();
-}
-
-ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto column_name = reader.ReadRequired<string>();
-	auto column_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	auto category = reader.ReadField<TableColumnType>(TableColumnType::STANDARD);
-	auto compression_type = reader.ReadField<duckdb::CompressionType>(duckdb::CompressionType::COMPRESSION_AUTO);
-	reader.Finalize();
-
-	ColumnDefinition result(column_name, column_type, std::move(expression), category);
-	result.compression_type = compression_type;
-	return result;
-}
-
-const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
-	return default_value;
+	return expression;
 }
 
 void ColumnDefinition::SetDefaultValue(unique_ptr<ParsedExpression> default_value) {
-	this->default_value = std::move(default_value);
+	if (Generated()) {
+		throw InternalException("Calling SetDefaultValue() on a generated column");
+	}
+	this->expression = std::move(default_value);
 }
 
 const LogicalType &ColumnDefinition::Type() const {
@@ -168,7 +131,7 @@ static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &d
 
 void ColumnDefinition::GetListOfDependencies(vector<string> &dependencies) const {
 	D_ASSERT(Generated());
-	InnerGetListOfDependencies(*generated_expression, dependencies);
+	InnerGetListOfDependencies(*expression, dependencies);
 }
 
 string ColumnDefinition::GetName() const {
@@ -179,28 +142,28 @@ LogicalType ColumnDefinition::GetType() const {
 	return type;
 }
 
-void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> expression) {
+void ColumnDefinition::SetGeneratedExpression(unique_ptr<ParsedExpression> new_expr) {
 	category = TableColumnType::GENERATED;
 
-	if (expression->HasSubquery()) {
+	if (new_expr->HasSubquery()) {
 		throw ParserException("Expression of generated column \"%s\" contains a subquery, which isn't allowed", name);
 	}
 
-	VerifyColumnRefs(*expression);
+	VerifyColumnRefs(*new_expr);
 	if (type.id() == LogicalTypeId::ANY) {
-		generated_expression = std::move(expression);
+		expression = std::move(new_expr);
 		return;
 	}
 	// Always wrap the expression in a cast, that way we can always update the cast when we change the type
 	// Except if the type is LogicalType::ANY (no type specified)
-	generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
+	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(new_expr));
 }
 
 void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 	D_ASSERT(Generated());
 	// First time the type is set, add a cast around the expression
 	D_ASSERT(this->type.id() == LogicalTypeId::ANY);
-	generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(generated_expression));
+	expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
 	// Every generated expression should be wrapped in a cast on creation
 	// D_ASSERT(generated_expression->type == ExpressionType::OPERATOR_CAST);
 	// auto &cast_expr = generated_expression->Cast<CastExpression>();
@@ -210,12 +173,12 @@ void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 
 const ParsedExpression &ColumnDefinition::GeneratedExpression() const {
 	D_ASSERT(Generated());
-	return *generated_expression;
+	return *expression;
 }
 
 ParsedExpression &ColumnDefinition::GeneratedExpressionMutable() {
 	D_ASSERT(Generated());
-	return *generated_expression;
+	return *expression;
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/column_list.cpp

@@ -6,6 +6,14 @@ namespace duckdb {
 
 ColumnList::ColumnList(bool allow_duplicate_names) : allow_duplicate_names(allow_duplicate_names) {
 }
+
+ColumnList::ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names)
+    : allow_duplicate_names(allow_duplicate_names) {
+	for (auto &col : columns) {
+		AddColumn(std::move(col));
+	}
+}
+
 void ColumnList::AddColumn(ColumnDefinition column) {
 	auto oid = columns.size();
 	if (!column.Generated()) {
@@ -150,19 +158,6 @@ ColumnList ColumnList::Copy() const {
 	return result;
 }
 
-void ColumnList::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(columns);
-}
-
-ColumnList ColumnList::Deserialize(FieldReader &reader) {
-	ColumnList result;
-	auto columns = reader.ReadRequiredSerializableList<ColumnDefinition, ColumnDefinition>();
-	for (auto &col : columns) {
-		result.AddColumn(std::move(col));
-	}
-	return result;
-}
-
 ColumnList::ColumnListIterator ColumnList::Logical() const {
 	return ColumnListIterator(*this, false);
 }

package/src/duckdb/src/parser/constraint.cpp

@@ -1,9 +1,7 @@
 #include "duckdb/parser/constraint.hpp"
 
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -13,37 +11,6 @@ Constraint::Constraint(ConstraintType type) : type(type) {
 Constraint::~Constraint() {
 }
 
-void Constraint::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ConstraintType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<Constraint> Constraint::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<ConstraintType>();
-	unique_ptr<Constraint> result;
-	switch (type) {
-	case ConstraintType::NOT_NULL:
-		result = NotNullConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::CHECK:
-		result = CheckConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::UNIQUE:
-		result = UniqueConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::FOREIGN_KEY:
-		result = ForeignKeyConstraint::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unrecognized constraint type for serialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
 void Constraint::Print() const {
 	Printer::Print(ToString());
 }

package/src/duckdb/src/parser/constraints/check_constraint.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/constraints/check_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 CheckConstraint::CheckConstraint(unique_ptr<ParsedExpression> expression)
@@ -16,13 +14,4 @@ unique_ptr<Constraint> CheckConstraint::Copy() const {
 	return make_uniq<CheckConstraint>(expression->Copy());
 }
 
-void CheckConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*expression);
-}
-
-unique_ptr<Constraint> CheckConstraint::Deserialize(FieldReader &source) {
-	auto expression = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<CheckConstraint>(std::move(expression));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp

@@ -1,11 +1,13 @@
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
 
+ForeignKeyConstraint::ForeignKeyConstraint() : Constraint(ConstraintType::FOREIGN_KEY) {
+}
+
 ForeignKeyConstraint::ForeignKeyConstraint(vector<string> pk_columns, vector<string> fk_columns, ForeignKeyInfo info)
     : Constraint(ConstraintType::FOREIGN_KEY), pk_columns(std::move(pk_columns)), fk_columns(std::move(fk_columns)),
       info(std::move(info)) {
@@ -47,30 +49,4 @@ unique_ptr<Constraint> ForeignKeyConstraint::Copy() const {
 	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, info);
 }
 
-void ForeignKeyConstraint::Serialize(FieldWriter &writer) const {
-	D_ASSERT(pk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(pk_columns);
-	D_ASSERT(fk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(fk_columns);
-	writer.WriteField<ForeignKeyType>(info.type);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	writer.WriteIndexList<PhysicalIndex>(info.pk_keys);
-	writer.WriteIndexList<PhysicalIndex>(info.fk_keys);
-}
-
-unique_ptr<Constraint> ForeignKeyConstraint::Deserialize(FieldReader &source) {
-	ForeignKeyInfo read_info;
-	auto pk_columns = source.ReadRequiredList<string>();
-	auto fk_columns = source.ReadRequiredList<string>();
-	read_info.type = source.ReadRequired<ForeignKeyType>();
-	read_info.schema = source.ReadRequired<string>();
-	read_info.table = source.ReadRequired<string>();
-	read_info.pk_keys = source.ReadRequiredIndexList<PhysicalIndex>();
-	read_info.fk_keys = source.ReadRequiredIndexList<PhysicalIndex>();
-
-	// column list parsed constraint
-	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(read_info));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/not_null_constraint.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/constraints/not_null_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 NotNullConstraint::NotNullConstraint(LogicalIndex index) : Constraint(ConstraintType::NOT_NULL), index(index) {
@@ -18,13 +16,4 @@ unique_ptr<Constraint> NotNullConstraint::Copy() const {
 	return make_uniq<NotNullConstraint>(index);
 }
 
-void NotNullConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(index.index);
-}
-
-unique_ptr<Constraint> NotNullConstraint::Deserialize(FieldReader &source) {
-	auto index = source.ReadRequired<idx_t>();
-	return make_uniq_base<Constraint, NotNullConstraint>(LogicalIndex(index));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/unique_constraint.cpp

@@ -1,11 +1,13 @@
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
 
+UniqueConstraint::UniqueConstraint() : Constraint(ConstraintType::UNIQUE), index(DConstants::INVALID_INDEX) {
+}
+
 UniqueConstraint::UniqueConstraint(LogicalIndex index, bool is_primary_key)
     : Constraint(ConstraintType::UNIQUE), index(index), is_primary_key(is_primary_key) {
 }
@@ -35,27 +37,4 @@ unique_ptr<Constraint> UniqueConstraint::Copy() const {
 	}
 }
 
-void UniqueConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<bool>(is_primary_key);
-	writer.WriteField<uint64_t>(index.index);
-	D_ASSERT(columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(columns);
-}
-
-unique_ptr<Constraint> UniqueConstraint::Deserialize(FieldReader &source) {
-	auto is_primary_key = source.ReadRequired<bool>();
-	auto index = source.ReadRequired<uint64_t>();
-	auto columns = source.ReadRequiredList<string>();
-
-	if (index != DConstants::INVALID_INDEX) {
-		// single column parsed constraint
-		auto result = make_uniq<UniqueConstraint>(LogicalIndex(index), is_primary_key);
-		result->columns = std::move(columns);
-		return std::move(result);
-	} else {
-		// column list parsed constraint
-		return make_uniq<UniqueConstraint>(std::move(columns), is_primary_key);
-	}
-}
-
 } // namespace duckdb