duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

package/src/duckdb/src/include/duckdb/optimizer/join_order/query_graph_manager.hpp

@@ -0,0 +1,113 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_order/query_graph_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/pair.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/optimizer/join_order/join_node.hpp"
+#include "duckdb/optimizer/join_order/join_relation.hpp"
+#include "duckdb/optimizer/join_order/query_graph.hpp"
+#include "duckdb/optimizer/join_order/relation_manager.hpp"
+#include "duckdb/planner/column_binding.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+
+#include <functional>
+
+namespace duckdb {
+
+struct GenerateJoinRelation {
+	GenerateJoinRelation(optional_ptr<JoinRelationSet> set, unique_ptr<LogicalOperator> op_p)
+	    : set(set), op(std::move(op_p)) {
+	}
+
+	optional_ptr<JoinRelationSet> set;
+	unique_ptr<LogicalOperator> op;
+};
+
+//! Filter info struct that is used by the cardinality estimator to set the initial cardinality
+//! but is also eventually transformed into a query edge.
+struct FilterInfo {
+	FilterInfo(unique_ptr<Expression> filter, JoinRelationSet &set, idx_t filter_index)
+	    : filter(std::move(filter)), set(set), filter_index(filter_index) {
+	}
+
+	unique_ptr<Expression> filter;
+	JoinRelationSet &set;
+	idx_t filter_index;
+	optional_ptr<JoinRelationSet> left_set;
+	optional_ptr<JoinRelationSet> right_set;
+	ColumnBinding left_binding;
+	ColumnBinding right_binding;
+};
+
+//! The QueryGraphManager manages the process of extracting the reorderable and nonreorderable operations
+//! from the logical plan and creating the intermediate structures needed by the plan enumerator.
+//! When the plan enumerator finishes, the Query Graph Manger can then recreate the logical plan.
+class QueryGraphManager {
+public:
+	QueryGraphManager(ClientContext &context) : relation_manager(context), context(context) {
+	}
+
+	//! manage relations and the logical operators they represent
+	RelationManager relation_manager;
+
+	//! A structure holding all the created JoinRelationSet objects
+	JoinRelationSetManager set_manager;
+
+	ClientContext &context;
+
+	//! Extract the join relations, optimizing non-reoderable relations when encountered
+	bool Build(LogicalOperator &op);
+
+	//! Reconstruct the logical plan using the plan found by the plan enumerator
+	unique_ptr<LogicalOperator> Reconstruct(unique_ptr<LogicalOperator> plan, JoinNode &node);
+
+	//! Get a reference to the QueryGraphEdges structure that stores edges between
+	//! nodes and hypernodes.
+	const QueryGraphEdges &GetQueryGraphEdges() const;
+
+	//! Get a list of the join filters in the join plan than eventually are
+	//! transformed into the query graph edges
+	const vector<unique_ptr<FilterInfo>> &GetFilterBindings() const;
+
+	//! Plan enumerator may not find a full plan and therefore will need to create cross
+	//! products to create edges.
+	void CreateQueryGraphCrossProduct(JoinRelationSet &left, JoinRelationSet &right);
+
+	//! after join order optimization, we perform build side probe side optimizations.
+	//! (Basically we put lower expected cardinality columns on the build side, and larger
+	//! tables on the probe side)
+	unique_ptr<LogicalOperator> LeftRightOptimizations(unique_ptr<LogicalOperator> op);
+
+private:
+	vector<reference<LogicalOperator>> filter_operators;
+
+	//! Filter information including the column_bindings that join filters
+	//! used by the cardinality estimator to estimate distinct counts
+	vector<unique_ptr<FilterInfo>> filters_and_bindings;
+
+	QueryGraphEdges query_graph;
+
+	void GetColumnBinding(Expression &expression, ColumnBinding &binding);
+
+	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
+	bool LeftCardLessThanRight(LogicalOperator &op);
+
+	void CreateHyperGraphEdges();
+
+	GenerateJoinRelation GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode &node);
+
+	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode &node);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp

@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_order/relation_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/optimizer/join_order/join_relation.hpp"
+#include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
+#include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
+#include "duckdb/optimizer/join_order/join_node.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/planner/logical_operator_visitor.hpp"
+
+namespace duckdb {
+
+struct FilterInfo;
+
+//! Represents a single relation and any metadata accompanying that relation
+struct SingleJoinRelation {
+	LogicalOperator &op;
+	optional_ptr<LogicalOperator> parent;
+	RelationStats stats;
+
+	SingleJoinRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent) : op(op), parent(parent) {
+	}
+	SingleJoinRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, RelationStats stats)
+	    : op(op), parent(parent), stats(stats) {
+	}
+};
+
+class RelationManager {
+public:
+	explicit RelationManager(ClientContext &context) : context(context) {
+	}
+
+	idx_t NumRelations();
+
+	bool ExtractJoinRelations(LogicalOperator &input_op, vector<reference<LogicalOperator>> &filter_operators,
+	                          optional_ptr<LogicalOperator> parent = nullptr);
+
+	//! for each join filter in the logical plan op, extract the relations that are referred to on
+	//! both sides of the join filter, along with the tables & indexes.
+	vector<unique_ptr<FilterInfo>> ExtractEdges(LogicalOperator &op,
+	                                            vector<reference<LogicalOperator>> &filter_operators,
+	                                            JoinRelationSetManager &set_manager);
+
+	//! Extract the set of relations referred to inside an expression
+	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
+	void AddRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, const RelationStats &stats);
+
+	void AddAggregateRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, const RelationStats &stats);
+	vector<unique_ptr<SingleJoinRelation>> GetRelations();
+
+	const vector<RelationStats> GetRelationStats();
+	//! A mapping of base table index -> index into relations array (relation number)
+	unordered_map<idx_t, idx_t> relation_mapping;
+
+	void PrintRelationStats();
+
+private:
+	ClientContext &context;
+	//! Set of all relations considered in the join optimizer
+	vector<unique_ptr<SingleJoinRelation>> relations;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp

@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_order/statistics_extractor.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+#pragma once
+
+#include "duckdb/planner/filter/conjunction_filter.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+
+namespace duckdb {
+
+class CardinalityEstimator;
+
+struct DistinctCount {
+	idx_t distinct_count;
+	bool from_hll;
+};
+
+struct ExpressionBinding {
+	bool found_expression = false;
+	ColumnBinding child_binding;
+	bool expression_is_constant = false;
+};
+
+struct RelationStats {
+	// column_id -> estimated distinct count for column
+	vector<DistinctCount> column_distinct_count;
+	idx_t cardinality;
+	double filter_strength = 1;
+	bool stats_initialized = false;
+
+	// for debug, column names and tables
+	vector<string> column_names;
+	string table_name;
+
+	RelationStats() : cardinality(1), filter_strength(1), stats_initialized(false) {
+	}
+};
+
+class RelationStatisticsHelper {
+public:
+	static constexpr double DEFAULT_SELECTIVITY = 0.2;
+
+public:
+	static idx_t InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter &filter,
+	                                   BaseStatistics &base_stats);
+	//	static idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &filter,
+	//	                                  BaseStatistics &base_stats);
+	//! Extract Statistics from a LogicalGet.
+	static RelationStats ExtractGetStats(LogicalGet &get, ClientContext &context);
+	static RelationStats ExtractDelimGetStats(LogicalDelimGet &delim_get, ClientContext &context);
+	//! Create the statistics for a projection using the statistics of the operator that sits underneath the
+	//! projection. Then also create statistics for any extra columns the projection creates.
+	static RelationStats ExtractDummyScanStats(LogicalDummyScan &dummy_scan, ClientContext &context);
+	static RelationStats ExtractExpressionGetStats(LogicalExpressionGet &expression_get, ClientContext &context);
+	//! All relation extractors for blocking relations
+	static RelationStats ExtractProjectionStats(LogicalProjection &proj, RelationStats &child_stats);
+	static RelationStats ExtractAggregationStats(LogicalAggregate &aggr, RelationStats &child_stats);
+	static RelationStats ExtractWindowStats(LogicalWindow &window, RelationStats &child_stats);
+	//! Called after reordering a query plan with potentially 2+ relations.
+	static RelationStats CombineStatsOfReorderableOperator(vector<ColumnBinding> &bindings,
+	                                                       vector<RelationStats> relation_stats);
+	//! Called after reordering a query plan with potentially 2+ relations.
+	static RelationStats CombineStatsOfNonReorderableOperator(LogicalOperator &op, vector<RelationStats> child_stats);
+	static void CopyRelationStats(RelationStats &to, const RelationStats &from);
+
+private:
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/matcher/set_matcher.hpp

@@ -23,6 +23,8 @@ public:
 		UNORDERED,
 		//! Only some entries have to be matched, the order of the matches does not matter
 		SOME,
+		//! Only some entries have to be matched. The order of the matches does matter.
+		SOME_ORDERED,
 		//! Not initialized
 		INVALID
 	};
@@ -79,6 +81,17 @@ public:
 				}
 			}
 			return true;
+		} else if (policy == Policy::SOME_ORDERED) {
+			if (entries.size() < matchers.size()) {
+				return false;
+			}
+			// now provided entries have to match in order
+			for (idx_t i = 0; i < matchers.size(); i++) {
+				if (!matchers[i]->Match(entries[i], bindings)) {
+					return false;
+				}
+			}
+			return true;
 		} else {
 			if (policy == Policy::UNORDERED && matchers.size() != entries.size()) {
 				// unordered policy, count does not match: no match

package/src/duckdb/src/include/duckdb/optimizer/optimizer.hpp

@@ -22,7 +22,10 @@ class Optimizer {
 public:
 	Optimizer(Binder &binder, ClientContext &context);
 
+	//! Optimize a plan by running specialized optimizers
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
+	//! Return a reference to the client context of this optimizer
+	ClientContext &GetContext();
 
 	ClientContext &context;
 	Binder &binder;

package/src/duckdb/src/include/duckdb/optimizer/remove_duplicate_groups.hpp

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/remove_duplicate_groups.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/column_binding_map.hpp"
+#include "duckdb/planner/logical_operator_visitor.hpp"
+
+namespace duckdb {
+
+class BoundColumnRefExpression;
+
+//! The RemoveDuplicateGroups optimizer traverses the logical operator tree and removes any duplicate aggregate groups
+//! Duplicate groups may be introduced when joins columns are removed, e.g., by Deliminator or RemoveUnusedColumns
+class RemoveDuplicateGroups : public LogicalOperatorVisitor {
+public:
+	RemoveDuplicateGroups() {
+	}
+
+	void VisitOperator(LogicalOperator &op) override;
+
+private:
+	void VisitAggregate(LogicalAggregate &aggr);
+
+protected:
+	unique_ptr<Expression> VisitReplace(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr) override;
+
+private:
+	//! The map of column references
+	column_binding_map_t<vector<reference<BoundColumnRefExpression>>> column_references;
+	//! Stored expressions (kept around so we don't have dangling pointers)
+	vector<unique_ptr<Expression>> stored_expressions;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp

@@ -18,6 +18,8 @@
 #include "duckdb/storage/statistics/node_statistics.hpp"
 
 namespace duckdb {
+
+class Optimizer;
 class ClientContext;
 class LogicalOperator;
 class TableFilter;
@@ -25,10 +27,14 @@ struct BoundOrderByNode;
 
 class StatisticsPropagator {
 public:
-	explicit StatisticsPropagator(ClientContext &context);
+	explicit StatisticsPropagator(Optimizer &optimizer);
 
 	unique_ptr<NodeStatistics> PropagateStatistics(unique_ptr<LogicalOperator> &node_ptr);
 
+	column_binding_map_t<unique_ptr<BaseStatistics>> GetStatisticsMap() {
+		return std::move(statistics_map);
+	}
+
 private:
 	//! Propagate statistics through an operator
 	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOperator &node, unique_ptr<LogicalOperator> *node_ptr);
@@ -75,6 +81,9 @@ private:
 	//! Multiply the cardinalities together (i.e. new max cardinality is stats.max * new_stats.max): used for
 	//! joins/cross products
 	void MultiplyCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats);
+	//! Creates and pushes down a filter based on join statistics
+	void CreateFilterFromJoinStats(unique_ptr<LogicalOperator> &child, unique_ptr<Expression> &expr,
+	                               const BaseStatistics &stats_before, const BaseStatistics &stats_after);
 
 	unique_ptr<BaseStatistics> PropagateExpression(unique_ptr<Expression> &expr);
 	unique_ptr<BaseStatistics> PropagateExpression(Expression &expr, unique_ptr<Expression> *expr_ptr);
@@ -90,14 +99,13 @@ private:
 	unique_ptr<BaseStatistics> PropagateExpression(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr);
 	unique_ptr<BaseStatistics> PropagateExpression(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr);
 
-	void PropagateAndCompress(unique_ptr<Expression> &expr, unique_ptr<BaseStatistics> &stats);
-
 	void ReplaceWithEmptyResult(unique_ptr<LogicalOperator> &node);
 
 	bool ExpressionIsConstant(Expression &expr, const Value &val);
 	bool ExpressionIsConstantOrNull(Expression &expr, const Value &val);
 
 private:
+	Optimizer &optimizer;
 	ClientContext &context;
 	//! The map of ColumnBinding -> statistics for the various nodes
 	column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map;

package/src/duckdb/src/include/duckdb/optimizer/topn_optimizer.hpp

@@ -18,6 +18,8 @@ class TopN {
 public:
 	//! Optimize ORDER BY + LIMIT to TopN
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
+	//! Whether we can perform the optimization on this operator
+	static bool CanOptimize(LogicalOperator &op);
 };
 
 } // namespace duckdb

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/parallel/pipeline.hpp

@@ -30,6 +30,8 @@ public:
 public:
 	//! Duplicate eliminated join scan dependencies
 	reference_map_t<const PhysicalOperator, reference<Pipeline>> delim_join_dependencies;
+	//! Materialized CTE scan dependencies
+	reference_map_t<const PhysicalOperator, reference<Pipeline>> cte_dependencies;
 
 public:
 	void SetPipelineSource(Pipeline &pipeline, PhysicalOperator &op);
@@ -69,9 +71,6 @@ public:
 	void ClearSource();
 	void Schedule(shared_ptr<Event> &event);
 
-	//! Finalize this pipeline
-	void Finalize(Event &event);
-
 	string ToString() const;
 	void Print() const;
 	void PrintDependencies() const;

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

@@ -48,8 +48,8 @@ public:
 	//! If OperatorResultType::FINISHED is returned, more input will not change the result anymore
 	OperatorResultType ExecutePush(DataChunk &input);
 	//! Called after depleting the source: finalizes the execution of this pipeline executor
-	//! This should only be called once per PipelineExecutor
-	void PushFinalize();
+	//! This should only be called once per PipelineExecutor.
+	PipelineExecuteResult PushFinalize();
 
 	//! Initializes a chunk with the types that will flow out of ExecutePull
 	void InitializeChunk(DataChunk &chunk);
@@ -142,6 +142,7 @@ private:
 	//! Debugging state: number of times blocked
 	int debug_blocked_sink_count = 0;
 	int debug_blocked_source_count = 0;
+	int debug_blocked_combine_count = 0;
 	//! Number of times the Sink/Source will block before actually returning data
 	int debug_blocked_target_count = 1;
 #endif

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

@@ -39,7 +39,7 @@ class TaskScheduler {
 	constexpr static int64_t TASK_TIMEOUT_USECS = 5000;
 
 public:
-	TaskScheduler(DatabaseInstance &db);
+	explicit TaskScheduler(DatabaseInstance &db);
 	~TaskScheduler();
 
 	DUCKDB_API static TaskScheduler &GetScheduler(ClientContext &context);
@@ -67,6 +67,12 @@ public:
 	//! Send signals to n threads, signalling for them to wake up and attempt to execute a task
 	void Signal(idx_t n);
 
+	//! Yield to other threads
+	void YieldThread();
+
+	//! Set the allocator flush threshold
+	void SetAllocatorFlushTreshold(idx_t threshold);
+
 private:
 	void SetThreadsInternal(int32_t n);
 
@@ -80,6 +86,8 @@ private:
 	vector<unique_ptr<SchedulerThread>> threads;
 	//! Markers used by the various threads, if the markers are set to "false" the thread execution is stopped
 	vector<unique_ptr<atomic<bool>>> markers;
+	//! The threshold after which to flush the allocator after completing a task
+	atomic<idx_t> allocator_flush_threshold;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/column_definition.hpp

@@ -29,9 +29,6 @@ public:
 	DUCKDB_API ColumnDefinition(string name, LogicalType type, unique_ptr<ParsedExpression> expression,
 	                            TableColumnType category);
 
-	//! The default value of the column (if any)
-	unique_ptr<ParsedExpression> default_value;
-
 public:
 	//! default_value
 	const unique_ptr<ParsedExpression> &DefaultValue() const;
@@ -70,6 +67,9 @@ public:
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static ColumnDefinition Deserialize(Deserializer &source);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static ColumnDefinition FormatDeserialize(FormatDeserializer &deserializer);
+
 	//===--------------------------------------------------------------------===//
 	// Generated Columns (VIRTUAL)
 	//===--------------------------------------------------------------------===//
@@ -97,8 +97,9 @@ private:
 	idx_t oid = DConstants::INVALID_INDEX;
 	//! The category of the column
 	TableColumnType category = TableColumnType::STANDARD;
-	//! Used by Generated Columns
-	unique_ptr<ParsedExpression> generated_expression;
+	//! The default value of the column (for non-generated columns)
+	//! The generated column expression (for generated columns)
+	unique_ptr<ParsedExpression> expression;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/column_list.hpp

@@ -20,6 +20,7 @@ public:
 
 public:
 	DUCKDB_API ColumnList(bool allow_duplicate_names = false);
+	DUCKDB_API explicit ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names = false);
 
 	DUCKDB_API void AddColumn(ColumnDefinition column);
 	void Finalize();
@@ -53,6 +54,9 @@ public:
 	void Serialize(FieldWriter &writer) const;
 	static ColumnList Deserialize(FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ColumnList FormatDeserialize(FormatDeserializer &deserializer);
+
 	DUCKDB_API ColumnListIterator Logical() const;
 	DUCKDB_API ColumnListIterator Physical() const;
 

package/src/duckdb/src/include/duckdb/parser/common_table_expression_info.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/common/enums/cte_materialize.hpp"
 
 namespace duckdb {
 
@@ -17,6 +18,7 @@ class SelectStatement;
 struct CommonTableExpressionInfo {
 	vector<string> aliases;
 	unique_ptr<SelectStatement> query;
+	CTEMaterialize materialized = CTEMaterialize::CTE_MATERIALIZE_DEFAULT;
 
 	void FormatSerialize(FormatSerializer &serializer) const;
 	static unique_ptr<CommonTableExpressionInfo> FormatDeserialize(FormatDeserializer &deserializer);

package/src/duckdb/src/include/duckdb/parser/constraint.hpp

@@ -16,6 +16,8 @@ namespace duckdb {
 
 class Serializer;
 class Deserializer;
+class FormatSerializer;
+class FormatDeserializer;
 class FieldWriter;
 class FieldReader;
 
@@ -68,6 +70,9 @@ public:
 	//! Deserializes a blob back into a Constraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
 
+	DUCKDB_API virtual void FormatSerialize(FormatSerializer &serializer) const;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

package/src/duckdb/src/include/duckdb/parser/constraints/check_constraint.hpp

@@ -32,6 +32,9 @@ public:
 
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/foreign_key_constraint.hpp

@@ -35,6 +35,12 @@ public:
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a ParsedConstraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+
+private:
+	ForeignKeyConstraint();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/not_null_constraint.hpp

@@ -32,6 +32,9 @@ public:
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a NotNullConstraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/constraints/unique_constraint.hpp

@@ -38,6 +38,12 @@ public:
 	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a ParsedConstraint
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<Constraint> FormatDeserialize(FormatDeserializer &deserializer);
+
+private:
+	UniqueConstraint();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/between_expression.hpp

@@ -35,7 +35,7 @@ public:
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>
@@ -43,5 +43,8 @@ public:
 		return "(" + entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " +
 		       entry.upper->ToString() + ")";
 	}
+
+private:
+	BetweenExpression();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/expression/case_expression.hpp

@@ -42,7 +42,7 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 	void FormatSerialize(FormatSerializer &serializer) const override;
-	static unique_ptr<ParsedExpression> FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer);
+	static unique_ptr<ParsedExpression> FormatDeserialize(FormatDeserializer &deserializer);
 
 public:
 	template <class T, class BASE>