duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -117,16 +117,29 @@ public:
 	DUCKDB_API shared_ptr<Relation> Alias(const string &alias);
 
 	//! Insert the data from this relation into a table
+	DUCKDB_API shared_ptr<Relation> InsertRel(const string &schema_name, const string &table_name);
 	DUCKDB_API void Insert(const string &table_name);
 	DUCKDB_API void Insert(const string &schema_name, const string &table_name);
 	//! Insert a row (i.e.,list of values) into a table
 	DUCKDB_API void Insert(const vector<vector<Value>> &values);
 	//! Create a table and insert the data from this relation into that table
+	DUCKDB_API shared_ptr<Relation> CreateRel(const string &schema_name, const string &table_name);
 	DUCKDB_API void Create(const string &table_name);
 	DUCKDB_API void Create(const string &schema_name, const string &table_name);
 
 	//! Write a relation to a CSV file
-	DUCKDB_API void WriteCSV(const string &csv_file);
+	DUCKDB_API shared_ptr<Relation>
+	WriteCSVRel(const string &csv_file,
+	            case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
+	DUCKDB_API void WriteCSV(const string &csv_file,
+	                         case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
+	//! Write a relation to a Parquet file
+	DUCKDB_API shared_ptr<Relation>
+	WriteParquetRel(const string &parquet_file,
+	                case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
+	DUCKDB_API void
+	WriteParquet(const string &parquet_file,
+	             case_insensitive_map_t<vector<Value>> options = case_insensitive_map_t<vector<Value>>());
 
 	//! Update a table, can only be used on a TableRelation
 	DUCKDB_API virtual void Update(const string &update, const string &condition = string());

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

@@ -142,6 +142,15 @@ struct AllowUnsignedExtensionsSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct CustomExtensionRepository {
+	static constexpr const char *Name = "custom_extension_repository";
+	static constexpr const char *Description = "Overrides the custom endpoint for remote extension installation";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct EnableObjectCacheSetting {
 	static constexpr const char *Name = "enable_object_cache";
 	static constexpr const char *Description = "Whether or not object cache is used to cache e.g. Parquet metadata";

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

@@ -33,7 +33,7 @@ public:
 	}
 	template <class T>
 	static void Invalidate(T &o, string error) {
-		Get(o).Invalidate(move(error));
+		Get(o).Invalidate(std::move(error));
 	}
 
 	template <class T>

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

@@ -21,7 +21,7 @@ class DeliminatorPlanUpdater;
 //! The Deliminator optimizer traverses the logical operator tree and removes any redundant DelimGets/DelimJoins
 class Deliminator {
 public:
-	Deliminator() {
+	explicit Deliminator(ClientContext &context) : context(context) {
 	}
 	//! Perform DelimJoin elimination
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
@@ -35,6 +35,9 @@ private:
 	//! 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);
+
+private:
+	ClientContext &context;
 };
 
 } // namespace duckdb

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

@@ -75,7 +75,7 @@ private:
 	//	void GenerateConjunctionFilter(BoundConjunctionExpression *conjunction, ConjunctionFilter *last_conj_filter) {
 	//		auto new_filter = NextConjunctionFilter<CONJUNCTION_TYPE>(conjunction);
 	//		auto conj_filter_ptr = (ConjunctionFilter *)new_filter.get();
-	//		last_conj_filter->child_filters.push_back(move(new_filter));
+	//		last_conj_filter->child_filters.push_back(std::move(new_filter));
 	//		last_conj_filter = conj_filter_ptr;
 	//	}
 	//
@@ -88,9 +88,9 @@ private:
 	//			    (comp_expr->left->type == ExpressionType::VALUE_CONSTANT) ? *comp_expr->left : *comp_expr->right;
 	//			auto const_value = ExpressionExecutor::EvaluateScalar(const_expr);
 	//			auto const_filter = make_unique<ConstantFilter>(comp_expr->type, const_value);
-	//			conj_filter->child_filters.push_back(move(const_filter));
+	//			conj_filter->child_filters.push_back(std::move(const_filter));
 	//		}
-	//		return move(conj_filter);
+	//		return std::move(conj_filter);
 	//	}
 
 private:

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

@@ -28,7 +28,7 @@ public:
 
 		Filter() {
 		}
-		explicit Filter(unique_ptr<Expression> filter) : filter(move(filter)) {
+		explicit Filter(unique_ptr<Expression> filter) : filter(std::move(filter)) {
 		}
 
 		void ExtractBindings();

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

@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/optimizer/join_order/join_node.hpp"
 #include "duckdb/planner/column_binding.hpp"
 #include "duckdb/planner/column_binding_map.hpp"
@@ -44,7 +43,7 @@ struct NodeOp {
 	unique_ptr<JoinNode> node;
 	LogicalOperator *op;
 
-	NodeOp(unique_ptr<JoinNode> node, LogicalOperator *op) : node(move(node)), op(op) {};
+	NodeOp(unique_ptr<JoinNode> node, LogicalOperator *op) : node(std::move(node)), op(op) {};
 };
 
 struct Subgraph2Denominator {
@@ -69,13 +68,11 @@ private:
 
 	vector<RelationsToTDom> relations_to_tdoms;
 
+public:
 	static constexpr double DEFAULT_SELECTIVITY = 0.2;
 
-public:
 	static void VerifySymmetry(JoinNode *result, JoinNode *entry);
 
-	void AssertEquivalentRelationSize();
-
 	//! given a binding of (relation, column) used for DP, and a (table, column) in that catalog
 	//! Add the key value entry into the relation_column_to_original_column
 	void AddRelationToColumnMapping(ColumnBinding key, ColumnBinding value);
@@ -92,7 +89,7 @@ public:
 	void UpdateTotalDomains(JoinNode *node, LogicalOperator *op);
 	void InitEquivalentRelations(vector<unique_ptr<FilterInfo>> *filter_infos);
 
-	void InitCardinalityEstimatorProps(vector<struct NodeOp> *node_ops, vector<unique_ptr<FilterInfo>> *filter_infos);
+	void InitCardinalityEstimatorProps(vector<NodeOp> *node_ops, vector<unique_ptr<FilterInfo>> *filter_infos);
 	double EstimateCardinalityWithSet(JoinRelationSet *new_set);
 	void EstimateBaseTableCardinality(JoinNode *node, LogicalOperator *op);
 	double EstimateCrossProduct(const JoinNode *left, const JoinNode *right);

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

@@ -15,7 +15,6 @@
 #include "duckdb/planner/logical_operator_visitor.hpp"
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
 #include "duckdb/planner/table_filter.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 

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

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/optimizer/join_order/estimated_properties.hpp"

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

@@ -54,8 +54,7 @@ private:
 	//! The set of filter infos created from the extracted filters
 	vector<unique_ptr<FilterInfo>> filter_infos;
 	//! A map of all expressions a given expression has to be equivalent to. This is used to add "implied join edges".
-	//! i.e. in the join A=B AND B=C, the equivalence set of {B} is {A, C}, thus we can add an implied join edge {A <->
-	//! C}
+	//! i.e. in the join A=B AND B=C, the equivalence set of {B} is {A, C}, thus we can add an implied join edge {A = C}
 	expression_map_t<vector<FilterInfo *>> equivalence_sets;
 
 	CardinalityEstimator cardinality_estimator;

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

@@ -28,7 +28,7 @@ struct SingleJoinRelation {
 
 //! Set of relations, used in the join graph.
 struct JoinRelationSet {
-	JoinRelationSet(unique_ptr<idx_t[]> relations, idx_t count) : relations(move(relations)), count(count) {
+	JoinRelationSet(unique_ptr<idx_t[]> relations, idx_t count) : relations(std::move(relations)), count(count) {
 	}
 
 	string ToString() const;

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

@@ -42,7 +42,7 @@ private:
 //! The ManyExpressionTypeMatcher class matches a set of ExpressionTypes
 class ManyExpressionTypeMatcher : public ExpressionTypeMatcher {
 public:
-	explicit ManyExpressionTypeMatcher(vector<ExpressionType> types) : types(move(types)) {
+	explicit ManyExpressionTypeMatcher(vector<ExpressionType> types) : types(std::move(types)) {
 	}
 
 	bool Match(ExpressionType type) override {

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

@@ -33,7 +33,7 @@ public:
 //! The SpecificFunctionMatcher class matches a single specified function name
 class SpecificFunctionMatcher : public FunctionMatcher {
 public:
-	explicit SpecificFunctionMatcher(string name) : name(move(name)) {
+	explicit SpecificFunctionMatcher(string name) : name(std::move(name)) {
 	}
 
 	bool Match(string &name) override {
@@ -47,7 +47,7 @@ private:
 //! The ManyFunctionMatcher class matches a set of functions
 class ManyFunctionMatcher : public FunctionMatcher {
 public:
-	explicit ManyFunctionMatcher(unordered_set<string> names) : names(move(names)) {
+	explicit ManyFunctionMatcher(unordered_set<string> names) : names(std::move(names)) {
 	}
 
 	bool Match(string &name) override {

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

@@ -36,6 +36,7 @@ private:
 	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);

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

@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/unnest_rewriter.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/common/pair.hpp"
+
+namespace duckdb {
+
+class Optimizer;
+
+struct ReplaceBinding {
+	ReplaceBinding() {};
+	ReplaceBinding(ColumnBinding old_binding, ColumnBinding new_binding)
+	    : old_binding(old_binding), new_binding(new_binding) {
+	}
+	ColumnBinding old_binding;
+	ColumnBinding new_binding;
+};
+
+struct LHSBinding {
+	LHSBinding() {};
+	LHSBinding(ColumnBinding binding, LogicalType type) : binding(binding), type(type) {
+	}
+	ColumnBinding binding;
+	LogicalType type;
+	string alias;
+};
+
+//! The UnnestRewriterPlanUpdater updates column bindings after changing the operator plan
+class UnnestRewriterPlanUpdater : LogicalOperatorVisitor {
+public:
+	UnnestRewriterPlanUpdater() {
+	}
+	//! Update each operator of the plan after moving an UNNEST into a projection
+	void VisitOperator(LogicalOperator &op) override;
+	//! Visit an expression and update its column bindings after moving and UNNEST into a projection
+	void VisitExpression(unique_ptr<Expression> *expression) override;
+
+	//! Contains all bindings that need to be updated
+	vector<ReplaceBinding> replace_bindings;
+};
+
+//! The UnnestRewriter optimizer traverses the logical operator tree and rewrites duplicate
+//! eliminated joins that contain UNNESTs by moving the UNNESTs into the projection of
+//! the SELECT
+class UnnestRewriter {
+public:
+	UnnestRewriter() {
+	}
+	//! Rewrite duplicate eliminated joins with UNNESTs
+	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
+
+private:
+	//! Find delim joins that contain an UNNEST
+	void FindCandidates(unique_ptr<LogicalOperator> *op_ptr, vector<unique_ptr<LogicalOperator> *> &candidates);
+	//! Rewrite a delim join that contains an UNNEST
+	bool RewriteCandidate(unique_ptr<LogicalOperator> *candidate);
+	//! Update the bindings of the RHS sequence of LOGICAL_PROJECTION(s)
+	void UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, unique_ptr<LogicalOperator> *candidate,
+	                       UnnestRewriterPlanUpdater &updater);
+	//! Update the bindings of the BOUND_UNNEST expression of the LOGICAL_UNNEST
+	void UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &updater, unique_ptr<LogicalOperator> *candidate);
+
+	//! Store all delim columns of the delim join
+	void GetDelimColumns(LogicalOperator &op);
+	//! Store all LHS expressions of the LOGICAL_PROJECTION
+	void GetLHSExpressions(LogicalOperator &op);
+
+	//! Keep track of the delim columns to find the correct UNNEST column
+	vector<ColumnBinding> delim_columns;
+	//! Store the column bindings of the LHS child of the LOGICAL_DELIM_JOIN
+	vector<LHSBinding> lhs_bindings;
+	//! Stores the table index of the former child of the LOGICAL_UNNEST
+	idx_t overwritten_tbl_idx;
+};
+
+} // namespace duckdb

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

@@ -20,7 +20,7 @@ public:
 
 	virtual void AddTask(unique_ptr<Task> task) {
 		++task_count;
-		scheduler.ScheduleTask(*token, move(task));
+		scheduler.ScheduleTask(*token, std::move(task));
 	}
 
 	virtual void FinishTask() const {

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

@@ -42,8 +42,8 @@ public:
 	TaskScheduler(DatabaseInstance &db);
 	~TaskScheduler();
 
-	static TaskScheduler &GetScheduler(ClientContext &context);
-	static TaskScheduler &GetScheduler(DatabaseInstance &db);
+	DUCKDB_API static TaskScheduler &GetScheduler(ClientContext &context);
+	DUCKDB_API static TaskScheduler &GetScheduler(DatabaseInstance &db);
 
 	unique_ptr<ProducerToken> CreateProducer();
 	//! Schedule a task to be executed by the task scheduler
@@ -62,7 +62,7 @@ public:
 	//! The main thread will also be used for execution
 	void SetThreads(int32_t n);
 	//! Returns the number of threads
-	int32_t NumberOfThreads();
+	DUCKDB_API int32_t NumberOfThreads();
 
 	//! Send signals to n threads, signalling for them to wake up and attempt to execute a task
 	void Signal(idx_t n);

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

@@ -19,7 +19,7 @@ public:
 	class ColumnListIterator;
 
 public:
-	ColumnList(bool allow_duplicate_names = false);
+	DUCKDB_API ColumnList(bool allow_duplicate_names = false);
 
 	DUCKDB_API void AddColumn(ColumnDefinition column);
 	void Finalize();
@@ -30,6 +30,8 @@ public:
 	DUCKDB_API ColumnDefinition &GetColumnMutable(LogicalIndex index);
 	DUCKDB_API ColumnDefinition &GetColumnMutable(PhysicalIndex index);
 	DUCKDB_API ColumnDefinition &GetColumnMutable(const string &name);
+	DUCKDB_API vector<string> GetColumnNames() const;
+	DUCKDB_API vector<LogicalType> GetColumnTypes() const;
 
 	DUCKDB_API bool ColumnExists(const string &name) const;
 

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

@@ -24,7 +24,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
+	static bool Equal(const BetweenExpression *a, const BetweenExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -29,7 +29,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const CaseExpression *a, const CaseExpression *b);
+	static bool Equal(const CaseExpression *a, const CaseExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -28,7 +28,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const CastExpression *a, const CastExpression *b);
+	static bool Equal(const CastExpression *a, const CastExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -25,7 +25,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+	static bool Equal(const CollateExpression *a, const CollateExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -38,7 +38,7 @@ public:
 	string GetName() const override;
 	string ToString() const override;
 
-	static bool Equals(const ColumnRefExpression *a, const ColumnRefExpression *b);
+	static bool Equal(const ColumnRefExpression *a, const ColumnRefExpression *b);
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;

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

@@ -24,7 +24,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
+	static bool Equal(const ComparisonExpression *a, const ComparisonExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -28,7 +28,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
+	static bool Equal(const ConjunctionExpression *a, const ConjunctionExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -24,7 +24,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
+	static bool Equal(const ConstantExpression *a, const ConstantExpression *b);
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;

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

@@ -50,7 +50,7 @@ public:
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
-	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
+	static bool Equal(const FunctionExpression *a, const FunctionExpression *b);
 	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
@@ -68,8 +68,8 @@ public:
 			D_ASSERT(!distinct);
 			if (entry.children.size() == 1) {
 				if (StringUtil::Contains(function_name, "__postfix")) {
-					return "(" + entry.children[0]->ToString() + ")" +
-					       StringUtil::Replace(function_name, "__postfix", "");
+					return "((" + entry.children[0]->ToString() + ")" +
+					       StringUtil::Replace(function_name, "__postfix", "") + ")";
 				} else {
 					return function_name + "(" + entry.children[0]->ToString() + ")";
 				}

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

@@ -30,7 +30,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
+	static bool Equal(const LambdaExpression *a, const LambdaExpression *b);
 	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;

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

@@ -26,7 +26,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
+	static bool Equal(const OperatorExpression *a, const OperatorExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -27,7 +27,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const ParameterExpression *a, const ParameterExpression *b);
+	static bool Equal(const ParameterExpression *a, const ParameterExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 	hash_t Hash() const override;

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

@@ -24,7 +24,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
+	static bool Equal(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
 	unique_ptr<ParsedExpression> Copy() const override;
 	hash_t Hash() const override;
 

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

@@ -32,7 +32,7 @@ public:
 public:
 	string ToString() const override;
 
-	static bool Equals(const StarExpression *a, const StarExpression *b);
+	static bool Equal(const StarExpression *a, const StarExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -39,7 +39,7 @@ public:
 
 	string ToString() const override;
 
-	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
+	static bool Equal(const SubqueryExpression *a, const SubqueryExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -65,7 +65,7 @@ public:
 	//! Convert the Expression to a String
 	string ToString() const override;
 
-	static bool Equals(const WindowExpression *a, const WindowExpression *b);
+	static bool Equal(const WindowExpression *a, const WindowExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 

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

@@ -27,7 +27,7 @@ struct AlterEntryData {
 	AlterEntryData() {
 	}
 	AlterEntryData(string catalog_p, string schema_p, string name_p, bool if_exists)
-	    : catalog(move(catalog_p)), schema(move(schema_p)), name(move(name_p)), if_exists(if_exists) {
+	    : catalog(std::move(catalog_p)), schema(std::move(schema_p)), name(std::move(name_p)), if_exists(if_exists) {
 	}
 
 	string catalog;

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
@@ -27,14 +28,14 @@ struct CopyInfo : public ParseInfo {
 	string table;
 	//! List of columns to copy to/from
 	vector<string> select_list;
-	//! The file path to copy to/from
-	string file_path;
 	//! Whether or not this is a copy to file (false) or copy from a file (true)
 	bool is_from;
 	//! The file format of the external file
 	string format;
+	//! The file path to copy to/from
+	string file_path;
 	//! Set of (key, value) options
-	unordered_map<string, vector<Value>> options;
+	case_insensitive_map_t<vector<Value>> options;
 
 public:
 	unique_ptr<CopyInfo> Copy() const {

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_database_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_data/create_info.hpp"
+
+namespace duckdb {
+
+struct CreateDatabaseInfo : public CreateInfo {
+	CreateDatabaseInfo() : CreateInfo(CatalogType::DATABASE_ENTRY) {
+	}
+
+	//! Extension name which creates databases
+	string extension_name;
+
+	//! Name of the database
+	string name;
+
+	//! Source path of the database if it's created from another database
+	string path;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateDatabaseInfo>();
+		CopyProperties(*result);
+		result->extension_name = extension_name;
+		result->name = name;
+		result->path = path;
+		return unique_ptr<CreateInfo>(result.release());
+	}
+
+	static unique_ptr<CreateDatabaseInfo> Deserialize(Deserializer &deserializer) {
+		auto result = make_unique<CreateDatabaseInfo>();
+		result->DeserializeBase(deserializer);
+		return result;
+	}
+
+protected:
+	void SerializeInternal(Serializer &) const override {
+		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
+	}
+};
+
+} // namespace duckdb

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

@@ -29,7 +29,7 @@ enum class OnCreateConflict : uint8_t {
 
 struct CreateInfo : public ParseInfo {
 	explicit CreateInfo(CatalogType type, string schema = DEFAULT_SCHEMA, string catalog_p = INVALID_CATALOG)
-	    : type(type), catalog(move(catalog_p)), schema(schema), on_conflict(OnCreateConflict::ERROR_ON_CONFLICT),
+	    : type(type), catalog(std::move(catalog_p)), schema(schema), on_conflict(OnCreateConflict::ERROR_ON_CONFLICT),
 	      temporary(false), internal(false) {
 	}
 	~CreateInfo() override {

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

@@ -28,7 +28,7 @@ public:
 		result->function = function->Copy();
 		result->name = name;
 		CopyProperties(*result);
-		return move(result);
+		return std::move(result);
 	}
 };