duckdb 0.10.1 → 0.10.2-dev3.0

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

@@ -8,15 +8,15 @@
 
 #pragma once
 
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/common/types.hpp"
 #include "duckdb/planner/column_binding_map.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 
 namespace duckdb {
 
+class Optimizer;
+class ClientContext;
 class LogicalOperator;
-struct JoinCondition;
 
 struct CMChildInfo {
 public:
@@ -75,14 +75,11 @@ typedef column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map_t;
 //! but only if the data enters a materializing operator
 class CompressedMaterialization {
 public:
-	explicit CompressedMaterialization(ClientContext &context, Binder &binder, statistics_map_t &&statistics_map);
+	CompressedMaterialization(Optimizer &optimizer, LogicalOperator &root, 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);
@@ -102,7 +99,7 @@ private:
 	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,
+	                              vector<unique_ptr<CompressExpression>> compress_exprs,
 	                              CompressedMaterializationInfo &info, CMChildInfo &child_info);
 	void CreateDecompressProjection(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
 
@@ -118,15 +115,16 @@ private:
 	                                               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);
+	unique_ptr<Expression> GetStringDecompress(unique_ptr<Expression> input, const LogicalType &result_type,
+	                                           const BaseStatistics &stats);
 
 private:
+	Optimizer &optimizer;
 	ClientContext &context;
-	Binder &binder;
-	statistics_map_t statistics_map;
-	unordered_set<idx_t> compression_table_indices;
-	unordered_set<idx_t> decompression_table_indices;
+	//! The root of the query plan
 	optional_ptr<LogicalOperator> root;
+	//! The map of ColumnBinding -> statistics for the various nodes
+	statistics_map_t &statistics_map;
 };
 
 } // namespace duckdb

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

@@ -28,7 +28,7 @@ struct RelationsToTDom {
 	vector<FilterInfo *> filters;
 	vector<string> column_names;
 
-	RelationsToTDom(const column_binding_set_t &column_binding_set)
+	explicit 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) {};
 };
@@ -82,7 +82,7 @@ public:
 	void PrintRelationToTdomInfo();
 
 private:
-	bool SingleColumnFilter(FilterInfo &filter_info);
+	bool SingleRelationFilter(FilterInfo &filter_info);
 	vector<idx_t> DetermineMatchingEquivalentSets(FilterInfo *filter_info);
 	//! Given a filter, add the column bindings to the matching equivalent set at the index
 	//! given in matching equivalent sets.

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

@@ -16,7 +16,7 @@ class QueryGraphManager;
 
 class CostModel {
 public:
-	CostModel(QueryGraphManager &query_graph_manager);
+	explicit CostModel(QueryGraphManager &query_graph_manager);
 
 private:
 	//! query graph storing relation manager information

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

@@ -38,7 +38,7 @@ public:
 	//! Create a leaf node in the join tree
 	//! set cost to 0 for leaf nodes
 	//! cost will be the cost to *produce* an intermediate table
-	JoinNode(JoinRelationSet &set);
+	explicit JoinNode(JoinRelationSet &set);
 
 	bool operator==(const JoinNode &other) {
 		return other.set.ToString().compare(set.ToString()) == 0;

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

@@ -26,7 +26,7 @@ namespace duckdb {
 struct FilterInfo;
 
 struct NeighborInfo {
-	NeighborInfo(optional_ptr<JoinRelationSet> neighbor) : neighbor(neighbor) {
+	explicit NeighborInfo(optional_ptr<JoinRelationSet> neighbor) : neighbor(neighbor) {
 	}
 
 	optional_ptr<JoinRelationSet> neighbor;

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

@@ -57,7 +57,7 @@ struct FilterInfo {
 //! 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) {
+	explicit QueryGraphManager(ClientContext &context) : relation_manager(context), context(context) {
 	}
 
 	//! manage relations and the logical operators they represent

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

@@ -31,7 +31,7 @@ struct SingleJoinRelation {
 	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) {
+	    : op(op), parent(parent), stats(std::move(stats)) {
 	}
 };
 

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

@@ -40,7 +40,7 @@ public:
 //! The ExpressionEqualityMatcher matches on equality with another (given) expression
 class ExpressionEqualityMatcher : public ExpressionMatcher {
 public:
-	explicit ExpressionEqualityMatcher(Expression &expr)
+	explicit ExpressionEqualityMatcher(const Expression &expr)
 	    : ExpressionMatcher(ExpressionClass::INVALID), expression(expr) {
 	}
 
@@ -61,7 +61,7 @@ public:
 	CaseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CASE) {
 	}
 
-	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 class ComparisonExpressionMatcher : public ExpressionMatcher {
@@ -74,7 +74,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 class CastExpressionMatcher : public ExpressionMatcher {
@@ -84,7 +84,7 @@ public:
 	//! The matcher for the child expressions
 	unique_ptr<ExpressionMatcher> matcher;
 
-	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 class InClauseExpressionMatcher : public ExpressionMatcher {
@@ -96,7 +96,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 class ConjunctionExpressionMatcher : public ExpressionMatcher {
@@ -109,7 +109,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 class FunctionExpressionMatcher : public ExpressionMatcher {
@@ -123,7 +123,7 @@ public:
 	//! The function name to match
 	unique_ptr<FunctionMatcher> function;
 
-	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 //! The FoldableConstant matcher matches any expression that is foldable into a constant by the ExpressionExecutor (i.e.

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

@@ -20,9 +20,9 @@ public:
 	virtual ~FunctionMatcher() {
 	}
 
-	virtual bool Match(string &name) = 0;
+	virtual bool Match(const string &name) = 0;
 
-	static bool Match(unique_ptr<FunctionMatcher> &matcher, string &name) {
+	static bool Match(unique_ptr<FunctionMatcher> &matcher, const string &name) {
 		if (!matcher) {
 			return true;
 		}
@@ -33,11 +33,11 @@ public:
 //! The SpecificFunctionMatcher class matches a single specified function name
 class SpecificFunctionMatcher : public FunctionMatcher {
 public:
-	explicit SpecificFunctionMatcher(string name) : name(std::move(name)) {
+	explicit SpecificFunctionMatcher(string name_p) : name(std::move(name_p)) {
 	}
 
-	bool Match(string &name) override {
-		return name == this->name;
+	bool Match(const string &matched_name) override {
+		return matched_name == this->name;
 	}
 
 private:
@@ -47,10 +47,10 @@ private:
 //! The ManyFunctionMatcher class matches a set of functions
 class ManyFunctionMatcher : public FunctionMatcher {
 public:
-	explicit ManyFunctionMatcher(unordered_set<string> names) : names(std::move(names)) {
+	explicit ManyFunctionMatcher(unordered_set<string> names_p) : names(std::move(names_p)) {
 	}
 
-	bool Match(string &name) override {
+	bool Match(const string &name) override {
 		return names.find(name) != names.end();
 	}
 

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

@@ -24,7 +24,7 @@ public:
 //! The SpecificTypeMatcher class matches only a single specified type
 class SpecificTypeMatcher : public TypeMatcher {
 public:
-	explicit SpecificTypeMatcher(LogicalType type) : type(type) {
+	explicit SpecificTypeMatcher(LogicalType type) : type(std::move(type)) {
 	}
 
 	bool Match(const LogicalType &type_p) override {

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

@@ -26,7 +26,10 @@ public:
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
 	//! Return a reference to the client context of this optimizer
 	ClientContext &GetContext();
+	//! Whether the specific optimizer is disabled
+	bool OptimizerDisabled(OptimizerType type);
 
+public:
 	ClientContext &context;
 	Binder &binder;
 	ExpressionRewriter rewriter;

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

@@ -27,7 +27,7 @@ struct BoundOrderByNode;
 
 class StatisticsPropagator {
 public:
-	explicit StatisticsPropagator(Optimizer &optimizer);
+	StatisticsPropagator(Optimizer &optimizer, LogicalOperator &root);
 
 	unique_ptr<NodeStatistics> PropagateStatistics(unique_ptr<LogicalOperator> &node_ptr);
 
@@ -37,23 +37,23 @@ public:
 
 private:
 	//! Propagate statistics through an operator
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOperator &node, unique_ptr<LogicalOperator> *node_ptr);
-
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalFilter &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalGet &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalJoin &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalPositionalJoin &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalProjection &op, unique_ptr<LogicalOperator> *node_ptr);
-	void PropagateStatistics(LogicalComparisonJoin &op, unique_ptr<LogicalOperator> *node_ptr);
-	void PropagateStatistics(LogicalAnyJoin &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalSetOperation &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalAggregate &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalCrossProduct &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalLimit &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOrder &op, unique_ptr<LogicalOperator> *node_ptr);
-	unique_ptr<NodeStatistics> PropagateStatistics(LogicalWindow &op, unique_ptr<LogicalOperator> *node_ptr);
-
-	unique_ptr<NodeStatistics> PropagateChildren(LogicalOperator &node, unique_ptr<LogicalOperator> *node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOperator &node, unique_ptr<LogicalOperator> &node_ptr);
+
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalFilter &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalGet &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalJoin &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalPositionalJoin &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalProjection &op, unique_ptr<LogicalOperator> &node_ptr);
+	void PropagateStatistics(LogicalComparisonJoin &op, unique_ptr<LogicalOperator> &node_ptr);
+	void PropagateStatistics(LogicalAnyJoin &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalSetOperation &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalAggregate &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalCrossProduct &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalLimit &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalOrder &op, unique_ptr<LogicalOperator> &node_ptr);
+	unique_ptr<NodeStatistics> PropagateStatistics(LogicalWindow &op, unique_ptr<LogicalOperator> &node_ptr);
+
+	unique_ptr<NodeStatistics> PropagateChildren(LogicalOperator &node, unique_ptr<LogicalOperator> &node_ptr);
 
 	//! Return statistics from a constant value
 	unique_ptr<BaseStatistics> StatisticsFromValue(const Value &input);
@@ -86,18 +86,18 @@ private:
 	                               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);
-
-	unique_ptr<BaseStatistics> PropagateExpression(BoundAggregateExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundBetweenExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundCaseExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundCastExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundConjunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundFunctionExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundComparisonExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundConstantExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundColumnRefExpression &expr, unique_ptr<Expression> *expr_ptr);
-	unique_ptr<BaseStatistics> PropagateExpression(BoundOperatorExpression &expr, unique_ptr<Expression> *expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(Expression &expr, unique_ptr<Expression> &expr_ptr);
+
+	unique_ptr<BaseStatistics> PropagateExpression(BoundAggregateExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundBetweenExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundCaseExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundCastExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundConjunctionExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundFunctionExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundComparisonExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundConstantExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundColumnRefExpression &expr, unique_ptr<Expression> &expr_ptr);
+	unique_ptr<BaseStatistics> PropagateExpression(BoundOperatorExpression &expr, unique_ptr<Expression> &expr_ptr);
 
 	void ReplaceWithEmptyResult(unique_ptr<LogicalOperator> &node);
 
@@ -107,6 +107,8 @@ private:
 private:
 	Optimizer &optimizer;
 	ClientContext &context;
+	//! The root of the query plan
+	optional_ptr<LogicalOperator> root;
 	//! The map of ColumnBinding -> statistics for the various nodes
 	column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map;
 	//! Node stats for the current node

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

@@ -26,7 +26,7 @@ struct ReplaceBinding {
 
 struct LHSBinding {
 	LHSBinding() {};
-	LHSBinding(ColumnBinding binding, LogicalType type) : binding(binding), type(type) {
+	LHSBinding(ColumnBinding binding, LogicalType type_p) : binding(binding), type(std::move(type_p)) {
 	}
 	ColumnBinding binding;
 	LogicalType type;

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

@@ -59,7 +59,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 

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

@@ -19,7 +19,7 @@ class ExecutorTask : public Task {
 public:
 	ExecutorTask(Executor &executor, shared_ptr<Event> event);
 	ExecutorTask(ClientContext &context, shared_ptr<Event> event);
-	virtual ~ExecutorTask();
+	~ExecutorTask() override;
 
 public:
 	void Deschedule() override;

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

@@ -44,9 +44,9 @@ public:
 	//! Default interrupt state will be set to InterruptMode::NO_INTERRUPTS and throw an error on use of Callback()
 	InterruptState();
 	//! Register the task to be interrupted and set mode to InterruptMode::TASK, the preferred way to handle interrupts
-	InterruptState(weak_ptr<Task> task);
+	explicit InterruptState(weak_ptr<Task> task);
 	//! Register signal state and set mode to InterruptMode::BLOCKING, used for code paths without Task.
-	InterruptState(weak_ptr<InterruptDoneSignalState> done_signal);
+	explicit InterruptState(weak_ptr<InterruptDoneSignalState> done_signal);
 
 	//! Perform the callback to indicate the Interrupt is over
 	DUCKDB_API void Callback() const;

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

@@ -15,7 +15,7 @@ namespace duckdb {
 //! A PipelineEvent is responsible for scheduling a pipeline
 class PipelineEvent : public BasePipelineEvent {
 public:
-	PipelineEvent(shared_ptr<Pipeline> pipeline);
+	explicit PipelineEvent(shared_ptr<Pipeline> pipeline);
 
 public:
 	void Schedule() override;

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

@@ -18,7 +18,7 @@ public:
 	class ColumnListIterator;
 
 public:
-	DUCKDB_API ColumnList(bool allow_duplicate_names = false);
+	DUCKDB_API explicit ColumnList(bool allow_duplicate_names = false);
 	DUCKDB_API explicit ColumnList(vector<ColumnDefinition> columns, bool allow_duplicate_names = false);
 
 	DUCKDB_API void AddColumn(ColumnDefinition column);
@@ -45,7 +45,7 @@ public:
 	idx_t PhysicalColumnCount() const {
 		return physical_columns.size();
 	}
-	bool empty() const {
+	bool empty() const { // NOLINT: match stl API
 		return columns.empty();
 	}
 
@@ -117,10 +117,10 @@ public:
 			return physical ? list.PhysicalColumnCount() : list.LogicalColumnCount();
 		}
 
-		ColumnLogicalIteratorInternal begin() {
+		ColumnLogicalIteratorInternal begin() { // NOLINT: match stl API
 			return ColumnLogicalIteratorInternal(list, physical, 0, Size());
 		}
-		ColumnLogicalIteratorInternal end() {
+		ColumnLogicalIteratorInternal end() { // NOLINT: match stl API
 			return ColumnLogicalIteratorInternal(list, physical, Size(), Size());
 		}
 	};

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

@@ -21,14 +21,6 @@ public:
 	DUCKDB_API UniqueConstraint(LogicalIndex index, bool is_primary_key);
 	DUCKDB_API UniqueConstraint(vector<string> columns, bool is_primary_key);
 
-	//! The index of the column for which this constraint holds. Only used when the constraint relates to a single
-	//! column, equal to DConstants::INVALID_INDEX if not used
-	LogicalIndex index;
-	//! The set of columns for which this constraint holds by name. Only used when the index field is not used.
-	vector<string> columns;
-	//! Whether or not this is a PRIMARY KEY constraint, or a UNIQUE constraint.
-	bool is_primary_key;
-
 public:
 	DUCKDB_API string ToString() const override;
 
@@ -37,8 +29,57 @@ public:
 	DUCKDB_API void Serialize(Serializer &serializer) const override;
 	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &deserializer);
 
+	bool IsPrimaryKey() const {
+		return is_primary_key;
+	}
+
+	bool HasIndex() const {
+		return index.index != DConstants::INVALID_INDEX;
+	}
+
+	LogicalIndex GetIndex() const {
+		if (!HasIndex()) {
+			throw InternalException("UniqueConstraint::GetIndex called on a unique constraint without a defined index");
+		}
+		return index;
+	}
+	void SetIndex(LogicalIndex new_index) {
+		D_ASSERT(new_index.index != DConstants::INVALID_INDEX);
+		index = new_index;
+	}
+
+	const vector<string> &GetColumnNames() const {
+		D_ASSERT(columns.size() >= 1);
+		return columns;
+	}
+	vector<string> &GetColumnNamesMutable() {
+		D_ASSERT(columns.size() >= 1);
+		return columns;
+	}
+
+	void SetColumnName(string name) {
+		if (!columns.empty()) {
+			// name has already been set
+			return;
+		}
+		columns.push_back(std::move(name));
+	}
+
 private:
 	UniqueConstraint();
+
+#ifdef DUCKDB_API_1_0
+private:
+#else
+public:
+#endif
+	//! The index of the column for which this constraint holds. Only used when the constraint relates to a single
+	//! column, equal to DConstants::INVALID_INDEX if not used
+	LogicalIndex index;
+	//! The set of columns for which this constraint holds by name. Only used when the index field is not used.
+	vector<string> columns;
+	//! Whether or not this is a PRIMARY KEY constraint, or a UNIQUE constraint.
+	bool is_primary_key;
 };
 
 } // namespace duckdb

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

@@ -22,7 +22,7 @@ public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_EXPRESSION;
 
 public:
-	BoundExpression(unique_ptr<Expression> expr);
+	explicit BoundExpression(unique_ptr<Expression> expr);
 
 	unique_ptr<Expression> expr;
 

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

@@ -16,7 +16,7 @@ public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::POSITIONAL_REFERENCE;
 
 public:
-	DUCKDB_API PositionalReferenceExpression(idx_t index);
+	DUCKDB_API explicit PositionalReferenceExpression(idx_t index);
 
 	idx_t index;
 

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

@@ -19,7 +19,7 @@ public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::STAR;
 
 public:
-	StarExpression(string relation_name = string());
+	explicit StarExpression(string relation_name = string());
 
 	//! The relation name in case of tbl.*, or empty if this is a normal *
 	string relation_name;

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_scalar_function_info.hpp

@@ -21,7 +21,7 @@ enum class AlterScalarFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOA
 
 struct AlterScalarFunctionInfo : public AlterInfo {
 	AlterScalarFunctionInfo(AlterScalarFunctionType type, AlterEntryData data);
-	virtual ~AlterScalarFunctionInfo() override;
+	~AlterScalarFunctionInfo() override;
 
 	AlterScalarFunctionType alter_scalar_function_type;
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_function_info.hpp

@@ -21,7 +21,7 @@ enum class AlterTableFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOAD
 
 struct AlterTableFunctionInfo : public AlterInfo {
 	AlterTableFunctionInfo(AlterTableFunctionType type, AlterEntryData data);
-	virtual ~AlterTableFunctionInfo() override;
+	~AlterTableFunctionInfo() override;
 
 	AlterTableFunctionType alter_table_function_type;
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp

@@ -307,7 +307,7 @@ public:
 	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
 
 protected:
-	AlterViewInfo(AlterViewType type);
+	explicit AlterViewInfo(AlterViewType type);
 };
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/parser/parsed_data/copy_database_info.hpp

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/copy_database_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/vector.hpp"
+#include "duckdb/parser/parsed_data/create_info.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
+
+namespace duckdb {
+
+struct CopyDatabaseInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::COPY_DATABASE_INFO;
+
+public:
+	explicit CopyDatabaseInfo() : ParseInfo(TYPE), target_database(INVALID_CATALOG) {
+	}
+
+	explicit CopyDatabaseInfo(const string &target_database) : ParseInfo(TYPE), target_database(target_database) {
+	}
+
+	// The destination database to which catalog entries are being copied
+	string target_database;
+
+	// The catalog entries that are going to be created in the destination DB
+	vector<unique_ptr<CreateInfo>> entries;
+
+public:
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_function_info.hpp

@@ -14,7 +14,8 @@
 namespace duckdb {
 
 struct CreateFunctionInfo : public CreateInfo {
-	explicit CreateFunctionInfo(CatalogType type, string schema = DEFAULT_SCHEMA) : CreateInfo(type, schema) {
+	explicit CreateFunctionInfo(CatalogType type, string schema = DEFAULT_SCHEMA)
+	    : CreateInfo(type, std::move(schema)) {
 		D_ASSERT(type == CatalogType::SCALAR_FUNCTION_ENTRY || type == CatalogType::AGGREGATE_FUNCTION_ENTRY ||
 		         type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY ||
 		         type == CatalogType::MACRO_ENTRY || type == CatalogType::TABLE_MACRO_ENTRY);

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp

@@ -47,6 +47,7 @@ struct CreateIndexInfo : public CreateInfo {
 public:
 	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
 
+	string ToString() const override;
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
 };

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_info.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/enums/on_create_conflict.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 
 namespace duckdb {
 struct AlterInfo;
@@ -23,7 +24,7 @@ public:
 
 public:
 	explicit CreateInfo(CatalogType type, string schema = DEFAULT_SCHEMA, string catalog_p = INVALID_CATALOG)
-	    : ParseInfo(TYPE), type(type), catalog(std::move(catalog_p)), schema(schema),
+	    : ParseInfo(TYPE), type(type), catalog(std::move(catalog_p)), schema(std::move(schema)),
 	      on_conflict(OnCreateConflict::ERROR_ON_CONFLICT), temporary(false), internal(false) {
 	}
 	~CreateInfo() override {