duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -17,11 +17,10 @@ PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_
 		requires_batch_index = pipeline.sink->RequiresBatchIndex() && pipeline.source->SupportsBatchIndex();
 		if (requires_batch_index) {
 			auto &partition_info = local_sink_state->partition_info;
-			if (!partition_info.batch_index.IsValid()) {
-				// batch index is not set yet - initialize before fetching anything
-				partition_info.batch_index = pipeline.RegisterNewBatchIndex();
-				partition_info.min_batch_index = partition_info.batch_index;
-			}
+			D_ASSERT(!partition_info.batch_index.IsValid());
+			// batch index is not set yet - initialize before fetching anything
+			partition_info.batch_index = pipeline.RegisterNewBatchIndex();
+			partition_info.min_batch_index = partition_info.batch_index;
 		}
 	}
 	local_source_state = pipeline.source->GetLocalSourceState(context, *pipeline.source_state);
@@ -79,6 +78,7 @@ bool PipelineExecutor::TryFlushCachingOperators() {
 		OperatorResultType push_result;
 
 		if (in_process_operators.empty()) {
+			curr_chunk.Reset();
 			StartOperator(current_operator);
 			finalize_result = current_operator.FinalExecute(context, curr_chunk, *current_operator.op_state,
 			                                                *intermediate_states[flushing_idx]);
@@ -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};
 
-	// run the combine for the sink
-	pipeline.sink->Combine(context, *pipeline.sink->sink_state, *local_sink_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();
+
+		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
@@ -477,7 +496,8 @@ SourceResultType PipelineExecutor::FetchFromSource(DataChunk &result) {
 		} else {
 			next_batch_index =
 			    pipeline.source->GetBatchIndex(context, result, *pipeline.source_state, *local_source_state);
-			next_batch_index += pipeline.base_batch_index;
+			// we start with the base_batch_index as a valid starting value. Make sure that next batch is called below
+			next_batch_index += pipeline.base_batch_index + 1;
 		}
 		auto &partition_info = local_sink_state->partition_info;
 		if (next_batch_index != partition_info.batch_index.GetIndex()) {

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 = 1;
+#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

@@ -13,28 +13,14 @@ 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;
@@ -44,11 +30,7 @@ void ColumnDefinition::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
 	writer.WriteString(name);
 	writer.WriteSerializable(type);
-	if (Generated()) {
-		writer.WriteOptional(generated_expression);
-	} else {
-		writer.WriteOptional(default_value);
-	}
+	writer.WriteOptional(expression);
 	writer.WriteField<TableColumnType>(category);
 	writer.WriteField<duckdb::CompressionType>(compression_type);
 	writer.Finalize();
@@ -69,11 +51,17 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
 }
 
 const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
-	return default_value;
+	if (Generated()) {
+		throw InternalException("Calling DefaultValue() on a generated column");
+	}
+	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 +156,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 +167,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 +198,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()) {

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

@@ -6,6 +6,9 @@
 
 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)) {

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

@@ -6,6 +6,9 @@
 
 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) {
 }

package/src/duckdb/src/parser/expression/between_expression.cpp

@@ -11,6 +11,9 @@ BetweenExpression::BetweenExpression(unique_ptr<ParsedExpression> input_p, uniqu
       lower(std::move(lower_p)), upper(std::move(upper_p)) {
 }
 
+BetweenExpression::BetweenExpression() : BetweenExpression(nullptr, nullptr, nullptr) {
+}
+
 string BetweenExpression::ToString() const {
 	return ToString<BetweenExpression, ParsedExpression>(*this);
 }
@@ -47,19 +50,4 @@ unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type,
 	return make_uniq<BetweenExpression>(std::move(input), std::move(lower), std::move(upper));
 }
 
-void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("input", *input);
-	serializer.WriteProperty("lower", *lower);
-	serializer.WriteProperty("upper", *upper);
-}
-
-unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(ExpressionType type,
-                                                                  FormatDeserializer &deserializer) {
-	auto input = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("input");
-	auto lower = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("lower");
-	auto upper = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("upper");
-	return make_uniq<BetweenExpression>(std::move(input), std::move(lower), std::move(upper));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/case_expression.cpp

@@ -8,18 +8,6 @@
 
 namespace duckdb {
 
-void CaseCheck::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("when_expr", when_expr);
-	serializer.WriteProperty("then_expr", then_expr);
-}
-
-CaseCheck CaseCheck::FormatDeserialize(FormatDeserializer &deserializer) {
-	CaseCheck check;
-	deserializer.ReadProperty("when_expr", check.when_expr);
-	deserializer.ReadProperty("then_expr", check.then_expr);
-	return check;
-}
-
 CaseExpression::CaseExpression() : ParsedExpression(ExpressionType::CASE_EXPR, ExpressionClass::CASE) {
 }
 
@@ -84,17 +72,4 @@ unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, Fi
 	return std::move(result);
 }
 
-void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("case_checks", case_checks);
-	serializer.WriteProperty("else_expr", *else_expr);
-}
-
-unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
-	auto result = make_uniq<CaseExpression>();
-	deserializer.ReadProperty("case_checks", result->case_checks);
-	deserializer.ReadProperty("else_expr", result->else_expr);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/cast_expression.cpp

@@ -15,6 +15,9 @@ CastExpression::CastExpression(LogicalType target, unique_ptr<ParsedExpression>
 	this->child = std::move(child);
 }
 
+CastExpression::CastExpression() : ParsedExpression(ExpressionType::OPERATOR_CAST, ExpressionClass::CAST) {
+}
+
 string CastExpression::ToString() const {
 	return ToString<CastExpression, ParsedExpression>(*this);
 }
@@ -51,18 +54,4 @@ unique_ptr<ParsedExpression> CastExpression::Deserialize(ExpressionType type, Fi
 	return make_uniq_base<ParsedExpression, CastExpression>(cast_type, std::move(child), try_cast);
 }
 
-void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("child", *child);
-	serializer.WriteProperty("cast_type", cast_type);
-	serializer.WriteProperty("try_cast", try_cast);
-}
-
-unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
-	auto child = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("child");
-	auto cast_type = deserializer.ReadProperty<LogicalType>("cast_type");
-	auto try_cast = deserializer.ReadProperty<bool>("try_cast");
-	return make_uniq_base<ParsedExpression, CastExpression>(cast_type, std::move(child), try_cast);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/collate_expression.cpp

@@ -14,6 +14,9 @@ CollateExpression::CollateExpression(string collation_p, unique_ptr<ParsedExpres
 	this->child = std::move(child);
 }
 
+CollateExpression::CollateExpression() : ParsedExpression(ExpressionType::COLLATE, ExpressionClass::COLLATE) {
+}
+
 string CollateExpression::ToString() const {
 	return StringUtil::Format("%s COLLATE %s", child->ToString(), SQLIdentifier(collation));
 }
@@ -45,17 +48,4 @@ unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type,
 	return make_uniq_base<ParsedExpression, CollateExpression>(collation, std::move(child));
 }
 
-void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("child", *child);
-	serializer.WriteProperty("collation", collation);
-}
-
-unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(ExpressionType type,
-                                                                  FormatDeserializer &deserializer) {
-	auto child = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("child");
-	auto collation = deserializer.ReadProperty<string>("collation");
-	return make_uniq_base<ParsedExpression, CollateExpression>(collation, std::move(child));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/columnref_expression.cpp

@@ -10,6 +10,9 @@
 
 namespace duckdb {
 
+ColumnRefExpression::ColumnRefExpression() : ParsedExpression(ExpressionType::COLUMN_REF, ExpressionClass::COLUMN_REF) {
+}
+
 ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
     : ColumnRefExpression(table_name.empty() ? vector<string> {std::move(column_name)}
                                              : vector<string> {std::move(table_name), std::move(column_name)}) {
@@ -100,16 +103,4 @@ unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType typ
 	return std::move(expression);
 }
 
-void ColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("column_names", column_names);
-}
-
-unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(ExpressionType type,
-                                                                    FormatDeserializer &deserializer) {
-	auto column_names = deserializer.ReadProperty<vector<string>>("column_names");
-	auto expression = make_uniq<ColumnRefExpression>(std::move(column_names));
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/comparison_expression.cpp

@@ -9,6 +9,9 @@
 
 namespace duckdb {
 
+ComparisonExpression::ComparisonExpression(ExpressionType type) : ParsedExpression(type, ExpressionClass::COMPARISON) {
+}
+
 ComparisonExpression::ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
                                            unique_ptr<ParsedExpression> right)
     : ParsedExpression(type, ExpressionClass::COMPARISON), left(std::move(left)), right(std::move(right)) {
@@ -45,17 +48,4 @@ unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType ty
 	return make_uniq<ComparisonExpression>(type, std::move(left_child), std::move(right_child));
 }
 
-void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("left", *left);
-	serializer.WriteProperty("right", *right);
-}
-
-unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(ExpressionType type,
-                                                                     FormatDeserializer &deserializer) {
-	auto left = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("left");
-	auto right = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("right");
-	return make_uniq<ComparisonExpression>(type, std::move(left), std::move(right));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/conjunction_expression.cpp

@@ -68,16 +68,4 @@ unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType t
 	return std::move(result);
 }
 
-void ConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("children", children);
-}
-
-unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(ExpressionType type,
-                                                                      FormatDeserializer &deserializer) {
-	auto result = make_uniq<ConjunctionExpression>(type);
-	result->children = deserializer.ReadProperty<vector<unique_ptr<ParsedExpression>>>("children");
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/constant_expression.cpp

@@ -10,6 +10,9 @@
 
 namespace duckdb {
 
+ConstantExpression::ConstantExpression() : ParsedExpression(ExpressionType::VALUE_CONSTANT, ExpressionClass::CONSTANT) {
+}
+
 ConstantExpression::ConstantExpression(Value val)
     : ParsedExpression(ExpressionType::VALUE_CONSTANT, ExpressionClass::CONSTANT), value(std::move(val)) {
 }
@@ -41,15 +44,4 @@ unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type
 	return make_uniq<ConstantExpression>(std::move(value));
 }
 
-void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-	serializer.WriteProperty("value", value);
-}
-
-unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(ExpressionType type,
-                                                                   FormatDeserializer &deserializer) {
-	auto value = deserializer.ReadProperty<Value>("value");
-	return make_uniq<ConstantExpression>(std::move(value));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/default_expression.cpp

@@ -27,8 +27,4 @@ unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type,
 	return make_uniq<DefaultExpression>();
 }
 
-void DefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
-	ParsedExpression::FormatSerialize(serializer);
-}
-
 } // namespace duckdb