duckdb 0.8.2-dev145.0 → 0.8.2-dev1493.0

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

@@ -9,21 +9,24 @@
 #pragma once
 
 #include "duckdb/main/relation.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 
 namespace duckdb {
 
 class JoinRelation : public Relation {
 public:
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
-	                        unique_ptr<ParsedExpression> condition, JoinType type);
+	                        unique_ptr<ParsedExpression> condition, JoinType type,
+	                        JoinRefType join_ref_type = JoinRefType::REGULAR);
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns,
-	                        JoinType type);
+	                        JoinType type, JoinRefType join_ref_type = JoinRefType::REGULAR);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
 	unique_ptr<ParsedExpression> condition;
 	vector<string> using_columns;
 	JoinType join_type;
+	JoinRefType join_ref_type;
 	vector<ColumnDefinition> columns;
 
 public:

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/enums/relation_type.hpp"
 #include "duckdb/common/winapi.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/common/named_parameter_map.hpp"
@@ -94,10 +95,11 @@ public:
 
 	// JOIN operation
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
-	                                     JoinType type = JoinType::INNER);
+	                                     JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
 
 	// CROSS PRODUCT operation
-	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other);
+	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other,
+	                                             JoinRefType join_ref_type = JoinRefType::CROSS);
 
 	// SET operations
 	DUCKDB_API shared_ptr<Relation> Union(const shared_ptr<Relation> &other);

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -122,6 +122,15 @@ struct DefaultNullOrderSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct DisabledFileSystemsSetting {
+	static constexpr const char *Name = "disabled_filesystems";
+	static constexpr const char *Description = "Disable specific file systems preventing access (e.g. LocalFileSystem)";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct DisabledOptimizersSetting {
 	static constexpr const char *Name = "disabled_optimizers";
 	static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)";
@@ -366,10 +375,20 @@ struct PerfectHashThresholdSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PivotFilterThreshold {
+	static constexpr const char *Name = "pivot_filter_threshold";
+	static constexpr const char *Description =
+	    "The threshold to switch from using filtered aggregates to LIST with a dedicated pivot operator";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct PivotLimitSetting {
 	static constexpr const char *Name = "pivot_limit";
 	static constexpr const char *Description =
-	    "The maximum numer of pivot columns in a pivot statement (default: 100000)";
+	    "The maximum number of pivot columns in a pivot statement (default: 100000)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);
@@ -492,4 +511,14 @@ struct UsernameSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct FlushAllocatorSetting {
+	static constexpr const char *Name = "allocator_flush_threshold";
+	static constexpr const char *Description =
+	    "Peak allocation threshold at which to flush the allocator after completing a task.";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 } // namespace duckdb

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

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/column_binding_replacer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/logical_operator.hpp"
+
+namespace duckdb {
+
+struct ReplacementBinding {
+public:
+	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding);
+	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding, LogicalType new_type);
+
+public:
+	ColumnBinding old_binding;
+	ColumnBinding new_binding;
+
+	bool replace_type;
+	LogicalType new_type;
+};
+
+//! The ColumnBindingReplacer updates column bindings (e.g., after changing the operator plan), utility for optimizers
+class ColumnBindingReplacer : LogicalOperatorVisitor {
+public:
+	ColumnBindingReplacer();
+
+public:
+	//! Update each operator of the plan
+	void VisitOperator(LogicalOperator &op) override;
+	//! Visit an expression and update its column bindings
+	void VisitExpression(unique_ptr<Expression> *expression) override;
+
+public:
+	//! Contains all bindings that need to be updated
+	vector<ReplacementBinding> replacement_bindings;
+
+	//! Do not recurse further than this operator (optional)
+	optional_ptr<LogicalOperator> stop_operator;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/compressed_materialization.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/planner/column_binding_map.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+
+namespace duckdb {
+
+class LogicalOperator;
+struct JoinCondition;
+
+struct CMChildInfo {
+public:
+	CMChildInfo(LogicalOperator &op, const column_binding_set_t &referenced_bindings);
+
+public:
+	//! Bindings and types before compressing
+	vector<ColumnBinding> bindings_before;
+	vector<LogicalType> &types;
+	//! Whether the input binding is eligible for compression
+	vector<bool> can_compress;
+
+	//! Bindings after compressing (projection on top)
+	vector<ColumnBinding> bindings_after;
+};
+
+struct CMBindingInfo {
+public:
+	explicit CMBindingInfo(ColumnBinding binding, const LogicalType &type);
+
+public:
+	ColumnBinding binding;
+
+	//! Type before compressing
+	LogicalType type;
+	bool needs_decompression;
+	unique_ptr<BaseStatistics> stats;
+};
+
+struct CompressedMaterializationInfo {
+public:
+	CompressedMaterializationInfo(LogicalOperator &op, vector<idx_t> &&child_idxs,
+	                              const column_binding_set_t &referenced_bindings);
+
+public:
+	//! Mapping from incoming bindings to outgoing bindings
+	column_binding_map_t<CMBindingInfo> binding_map;
+
+	//! Operator child info
+	vector<idx_t> child_idxs;
+	vector<CMChildInfo> child_info;
+};
+
+struct CompressExpression {
+public:
+	CompressExpression(unique_ptr<Expression> expression, unique_ptr<BaseStatistics> stats);
+
+public:
+	unique_ptr<Expression> expression;
+	unique_ptr<BaseStatistics> stats;
+};
+
+typedef column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map_t;
+
+//! The CompressedMaterialization optimizer compressed columns using projections, based on available statistics,
+//! but only if the data enters a materializing operator
+class CompressedMaterialization {
+public:
+	explicit CompressedMaterialization(ClientContext &context, Binder &binder, statistics_map_t &&statistics_map);
+
+	void Compress(unique_ptr<LogicalOperator> &op);
+
+private:
+	//! Depth-first traversal of the plan
+	void CompressInternal(unique_ptr<LogicalOperator> &op);
+
+	//! Compress materializing operators
+	void CompressAggregate(unique_ptr<LogicalOperator> &op);
+	void CompressDistinct(unique_ptr<LogicalOperator> &op);
+	void CompressOrder(unique_ptr<LogicalOperator> &op);
+
+	//! Update statistics after compressing
+	void UpdateAggregateStats(unique_ptr<LogicalOperator> &op);
+	void UpdateOrderStats(unique_ptr<LogicalOperator> &op);
+
+	//! Adds bindings referenced in expression to referenced_bindings
+	static void GetReferencedBindings(const Expression &expression, column_binding_set_t &referenced_bindings);
+	//! Updates CMBindingInfo in the binding_map in info
+	void UpdateBindingInfo(CompressedMaterializationInfo &info, const ColumnBinding &binding, bool needs_decompression);
+
+	//! Create (de)compress projections around the operator
+	void CreateProjections(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
+	bool TryCompressChild(CompressedMaterializationInfo &info, const CMChildInfo &child_info,
+	                      vector<unique_ptr<CompressExpression>> &compress_expressions);
+	void CreateCompressProjection(unique_ptr<LogicalOperator> &child_op,
+	                              vector<unique_ptr<CompressExpression>> &&compress_exprs,
+	                              CompressedMaterializationInfo &info, CMChildInfo &child_info);
+	void CreateDecompressProjection(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
+
+	//! Create expressions that apply a scalar compression function
+	unique_ptr<CompressExpression> GetCompressExpression(const ColumnBinding &binding, const LogicalType &type,
+	                                                     const bool &can_compress);
+	unique_ptr<CompressExpression> GetCompressExpression(unique_ptr<Expression> input, const BaseStatistics &stats);
+	unique_ptr<CompressExpression> GetIntegralCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+	unique_ptr<CompressExpression> GetStringCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+
+	//! Create an expression that applies a scalar decompression function
+	unique_ptr<Expression> GetDecompressExpression(unique_ptr<Expression> input, const LogicalType &result_type,
+	                                               const BaseStatistics &stats);
+	unique_ptr<Expression> GetIntegralDecompress(unique_ptr<Expression> input, const LogicalType &result_type,
+	                                             const BaseStatistics &stats);
+	unique_ptr<Expression> GetStringDecompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+
+private:
+	ClientContext &context;
+	Binder &binder;
+	statistics_map_t statistics_map;
+	unordered_set<idx_t> compression_table_indices;
+	unordered_set<idx_t> decompression_table_indices;
+	optional_ptr<LogicalOperator> root;
+};
+
+} // namespace duckdb

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

@@ -8,36 +8,33 @@
 
 #pragma once
 
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
+#include "duckdb/optimizer/column_binding_replacer.hpp"
 
 namespace duckdb {
 
-class Optimizer;
-class DeliminatorPlanUpdater;
+struct DelimCandidate;
 
 //! The Deliminator optimizer traverses the logical operator tree and removes any redundant DelimGets/DelimJoins
 class Deliminator {
 public:
-	explicit Deliminator(ClientContext &context) : context(context) {
+	Deliminator() {
 	}
 	//! Perform DelimJoin elimination
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
 
 private:
-	//! Find Joins with a DelimGet that can be removed
-	void FindCandidates(unique_ptr<LogicalOperator> *op_ptr, vector<unique_ptr<LogicalOperator> *> &candidates);
-	//! Try to remove a Join with a DelimGet, returns true if it was successful
-	bool RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<LogicalOperator> *candidate,
-	                     DeliminatorPlanUpdater &updater);
-	//! Try to remove an inequality Join with a DelimGet, returns true if it was successful
-	bool RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<LogicalOperator> *candidate,
-	                               DeliminatorPlanUpdater &updater);
+	//! Finds DelimJoins and their corresponding DelimGets
+	void FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCandidate> &candidates);
+	void FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate);
+	//! Remove joins with a DelimGet
+	bool RemoveJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+	                            unique_ptr<LogicalOperator> &join, bool &all_equality_conditions);
+	bool RemoveInequalityJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+	                                      unique_ptr<LogicalOperator> &join,
+	                                      const vector<ReplacementBinding> &replacement_bindings);
 
 private:
-	ClientContext &context;
+	optional_ptr<LogicalOperator> root;
 };
 
 } // namespace duckdb

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

@@ -19,8 +19,11 @@ class Optimizer;
 class FilterPushdown {
 public:
 	explicit FilterPushdown(Optimizer &optimizer);
+
 	//! Perform filter pushdown
 	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
+	//! Return a reference to the client context (from the optimizer)
+	ClientContext &GetContext();
 
 	struct Filter {
 		unordered_set<idx_t> bindings;

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

@@ -34,7 +34,7 @@ struct RelationsToTDom {
 	bool has_tdom_hll;
 	vector<FilterInfo *> filters;
 
-	RelationsToTDom(column_binding_set_t column_binding_set)
+	RelationsToTDom(const column_binding_set_t &column_binding_set)
 	    : equivalent_relations(column_binding_set), tdom_hll(0), tdom_no_hll(NumericLimits<idx_t>::Maximum()),
 	      has_tdom_hll(false) {};
 };

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

@@ -27,7 +27,10 @@ public:
 	T GetCardinality() const {
 		throw NotImplementedException("Unsupported type for GetCardinality");
 	}
-	double GetCost() const;
+	template <class T>
+	T GetCost() const {
+		throw NotImplementedException("Unsupported type for GetCost");
+	}
 	void SetCost(double new_cost);
 	void SetCardinality(double cardinality);
 
@@ -45,4 +48,10 @@ double EstimatedProperties::GetCardinality() const;
 template <>
 idx_t EstimatedProperties::GetCardinality() const;
 
+template <>
+double EstimatedProperties::GetCost() const;
+
+template <>
+idx_t EstimatedProperties::GetCost() const;
+
 } // namespace duckdb

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

@@ -90,7 +90,7 @@ private:
 	//! cancelling the dynamic programming step.
 	bool TryEmitPair(JoinRelationSet &left, JoinRelationSet &right, const vector<reference<NeighborInfo>> &info);
 
-	bool EnumerateCmpRecursive(JoinRelationSet &left, JoinRelationSet &right, unordered_set<idx_t> exclusion_set);
+	bool EnumerateCmpRecursive(JoinRelationSet &left, JoinRelationSet &right, unordered_set<idx_t> &exclusion_set);
 	//! Emit a relation set node
 	bool EmitCSG(JoinRelationSet &node);
 	//! Enumerate the possible connected subgraphs that can be joined together in the join graph

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

@@ -53,7 +53,7 @@ public:
 	//! Create or get a JoinRelationSet from a single node with the given index
 	JoinRelationSet &GetJoinRelation(idx_t index);
 	//! Create or get a JoinRelationSet from a set of relation bindings
-	JoinRelationSet &GetJoinRelation(unordered_set<idx_t> &bindings);
+	JoinRelationSet &GetJoinRelation(const unordered_set<idx_t> &bindings);
 	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
 	JoinRelationSet &GetJoinRelation(unsafe_unique_array<idx_t> relations, idx_t count);
 	//! Union two sets of relations together and create a new relation set

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

@@ -75,6 +75,9 @@ private:
 	//! Get the QueryEdge of a specific node
 	QueryEdge &GetQueryEdge(JoinRelationSet &left);
 
+	void EnumerateNeighborsDFS(JoinRelationSet &node, reference<QueryEdge> info, idx_t index,
+	                           const std::function<bool(NeighborInfo &)> &callback);
+
 	QueryEdge root;
 };
 

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/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);

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

@@ -67,6 +67,9 @@ public:
 	//! Send signals to n threads, signalling for them to wake up and attempt to execute a task
 	void Signal(idx_t n);
 
+	//! Set the allocator flush threshold
+	void SetAllocatorFlushTreshold(idx_t threshold);
+
 private:
 	void SetThreadsInternal(int32_t n);
 
@@ -80,6 +83,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/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/expression/between_expression.hpp

@@ -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/cast_expression.hpp

@@ -46,5 +46,8 @@ public:
 		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
 		       entry.cast_type.ToString() + ")";
 	}
+
+private:
+	CastExpression();
 };
 } // namespace duckdb

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

@@ -36,5 +36,8 @@ 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);
+
+private:
+	CollateExpression();
 };
 } // namespace duckdb

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

@@ -50,5 +50,8 @@ 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);
+
+private:
+	ColumnRefExpression();
 };
 } // namespace duckdb

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

@@ -42,5 +42,8 @@ public:
 		return StringUtil::Format("(%s %s %s)", entry.left->ToString(), ExpressionTypeToOperator(entry.type),
 		                          entry.right->ToString());
 	}
+
+private:
+	explicit ComparisonExpression(ExpressionType type);
 };
 } // namespace duckdb