duckdb 0.3.2-dev1309.0 → 0.3.2-dev1320.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "9552f65a2"
-#define DUCKDB_VERSION "v0.3.2-dev1309"
+#define DUCKDB_SOURCE_ID "73578846c"
+#define DUCKDB_VERSION "v0.3.2-dev1320"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -21019,7 +21019,7 @@ private:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/comparison_expression.hpp
+// duckdb/parser/expression/lambda_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21028,31 +21028,35 @@ private:
 
 
 
+
 namespace duckdb {
-//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
-//! and has two children.
-class ComparisonExpression : public ParsedExpression {
+
+//! LambdaExpression represents a lambda operator that can be used for e.g. mapping an expression to a list
+//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
+class LambdaExpression : public ParsedExpression {
 public:
-	ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+	LambdaExpression(vector<string> parameters, unique_ptr<ParsedExpression> expression);
 
-	unique_ptr<ParsedExpression> left;
-	unique_ptr<ParsedExpression> right;
+	vector<string> parameters;
+	unique_ptr<ParsedExpression> expression;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
+	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
+	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/constant_expression.hpp
+// duckdb/parser/expression/case_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21064,31 +21068,34 @@ public:
 
 namespace duckdb {
 
-//! ConstantExpression represents a constant value in the query
-class ConstantExpression : public ParsedExpression {
+struct CaseCheck {
+	unique_ptr<ParsedExpression> when_expr;
+	unique_ptr<ParsedExpression> then_expr;
+};
+
+//! The CaseExpression represents a CASE expression in the query
+class CaseExpression : public ParsedExpression {
 public:
-	explicit ConstantExpression(Value val);
+	CaseExpression();
 
-	//! The constant value referenced
-	Value value;
+	vector<CaseCheck> case_checks;
+	unique_ptr<ParsedExpression> else_expr;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
-	hash_t Hash() const override;
+	static bool Equals(const CaseExpression *a, const CaseExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
-
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/operator_expression.hpp
+// duckdb/parser/expression/conjunction_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21099,19 +21106,22 @@ public:
 
 
 namespace duckdb {
-//! Represents a built-in operator expression
-class OperatorExpression : public ParsedExpression {
+
+//! Represents a conjunction (AND/OR)
+class ConjunctionExpression : public ParsedExpression {
 public:
-	explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
-	                            unique_ptr<ParsedExpression> right = nullptr);
-	OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	explicit ConjunctionExpression(ExpressionType type);
+	ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
 
 	vector<unique_ptr<ParsedExpression>> children;
 
 public:
+	void AddExpression(unique_ptr<ParsedExpression> expr);
+
 	string ToString() const override;
 
-	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
+	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -21122,7 +21132,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/subquery_expression.hpp
+// duckdb/parser/expression/function_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21134,34 +21144,68 @@ public:
 
 
 namespace duckdb {
+//! Represents a function call
+class FunctionExpression : public ParsedExpression {
+public:
+	FunctionExpression(string schema_name, const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
+	                   bool distinct = false, bool is_operator = false);
+	FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
+	                   bool distinct = false, bool is_operator = false);
+
+	//! Schema of the function
+	string schema;
+	//! Function name
+	string function_name;
+	//! Whether or not the function is an operator, only used for rendering
+	bool is_operator;
+	//! List of arguments to the function
+	vector<unique_ptr<ParsedExpression>> children;
+	//! Whether or not the aggregate function is distinct, only used for aggregates
+	bool distinct;
+	//! Expression representing a filter, only used for aggregates
+	unique_ptr<ParsedExpression> filter;
+	//! Modifier representing an ORDER BY, only used for aggregates
+	unique_ptr<OrderModifier> order_bys;
 
-//! Represents a subquery
-class SubqueryExpression : public ParsedExpression {
 public:
-	SubqueryExpression();
+	string ToString() const override;
 
-	//! The actual subquery
-	unique_ptr<SelectStatement> subquery;
-	//! The subquery type
-	SubqueryType subquery_type;
-	//! the child expression to compare with (in case of IN, ANY, ALL operators, empty for EXISTS queries and scalar
-	//! subquery)
-	unique_ptr<ParsedExpression> child;
-	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators), empty otherwise
-	ExpressionType comparison_type;
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
+	hash_t Hash() const override;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/default_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! Represents the default value of a column
+class DefaultExpression : public ParsedExpression {
+public:
+	DefaultExpression();
 
 public:
-	bool HasSubquery() const override {
-		return true;
-	}
 	bool IsScalar() const override {
 		return false;
 	}
 
 	string ToString() const override;
 
-	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
-
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
@@ -21171,7 +21215,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/conjunction_expression.hpp
+// duckdb/parser/expression/comparison_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21180,24 +21224,20 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! Represents a conjunction (AND/OR)
-class ConjunctionExpression : public ParsedExpression {
+//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
+//! and has two children.
+class ComparisonExpression : public ParsedExpression {
 public:
-	explicit ConjunctionExpression(ExpressionType type);
-	ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+	ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
 
-	vector<unique_ptr<ParsedExpression>> children;
+	unique_ptr<ParsedExpression> left;
+	unique_ptr<ParsedExpression> right;
 
 public:
-	void AddExpression(unique_ptr<ParsedExpression> expr);
-
 	string ToString() const override;
 
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
+	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -21208,7 +21248,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/between_expression.hpp
+// duckdb/parser/expression/constant_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21217,32 +21257,34 @@ public:
 
 
 
+
 namespace duckdb {
 
-class BetweenExpression : public ParsedExpression {
+//! ConstantExpression represents a constant value in the query
+class ConstantExpression : public ParsedExpression {
 public:
-	BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
-	                  unique_ptr<ParsedExpression> upper);
+	explicit ConstantExpression(Value val);
 
-	unique_ptr<ParsedExpression> input;
-	unique_ptr<ParsedExpression> lower;
-	unique_ptr<ParsedExpression> upper;
+	//! The constant value referenced
+	Value value;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
+	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
+	hash_t Hash() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/parameter_expression.hpp
+// duckdb/parser/expression/operator_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21251,25 +21293,23 @@ public:
 
 
 
+
 namespace duckdb {
-class ParameterExpression : public ParsedExpression {
+//! Represents a built-in operator expression
+class OperatorExpression : public ParsedExpression {
 public:
-	ParameterExpression();
+	explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
+	                            unique_ptr<ParsedExpression> right = nullptr);
+	OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
 
-	idx_t parameter_nr;
+	vector<unique_ptr<ParsedExpression>> children;
 
 public:
-	bool IsScalar() const override {
-		return true;
-	}
-	bool HasParameter() const override {
-		return true;
-	}
-
 	string ToString() const override;
 
+	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
+
 	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
@@ -21278,7 +21318,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/star_expression.hpp
+// duckdb/parser/expression/between_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21287,25 +21327,21 @@ public:
 
 
 
-
 namespace duckdb {
 
-//! Represents a * expression in the SELECT clause
-class StarExpression : public ParsedExpression {
+class BetweenExpression : public ParsedExpression {
 public:
-	StarExpression(string relation_name = string());
+	BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
+	                  unique_ptr<ParsedExpression> upper);
 
-	//! The relation name in case of tbl.*, or empty if this is a normal *
-	string relation_name;
-	//! List of columns to exclude from the STAR expression
-	case_insensitive_set_t exclude_list;
-	//! List of columns to replace with another expression
-	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
+	unique_ptr<ParsedExpression> input;
+	unique_ptr<ParsedExpression> lower;
+	unique_ptr<ParsedExpression> upper;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const StarExpression *a, const StarExpression *b);
+	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -21316,7 +21352,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/case_expression.hpp
+// duckdb/parser/expression/positional_reference_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21325,33 +21361,31 @@ public:
 
 
 
-
 namespace duckdb {
-
-struct CaseCheck {
-	unique_ptr<ParsedExpression> when_expr;
-	unique_ptr<ParsedExpression> then_expr;
-};
-
-//! The CaseExpression represents a CASE expression in the query
-class CaseExpression : public ParsedExpression {
+class PositionalReferenceExpression : public ParsedExpression {
 public:
-	CaseExpression();
+	PositionalReferenceExpression(idx_t index);
 
-	vector<CaseCheck> case_checks;
-	unique_ptr<ParsedExpression> else_expr;
+	idx_t index;
 
 public:
-	string ToString() const override;
+	bool IsScalar() const override {
+		return false;
+	}
 
-	static bool Equals(const CaseExpression *a, const CaseExpression *b);
+	string ToString() const override;
 
+	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
 	unique_ptr<ParsedExpression> Copy() const override;
+	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -21390,10 +21424,11 @@ public:
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/positional_reference_expression.hpp
+// duckdb/parser/expression/collate_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21403,31 +21438,41 @@ public:
 
 
 namespace duckdb {
-class PositionalReferenceExpression : public ParsedExpression {
+
+//! CollateExpression represents a COLLATE statement
+class CollateExpression : public ParsedExpression {
 public:
-	PositionalReferenceExpression(idx_t index);
+	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
 
-	idx_t index;
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The collation clause
+	string collation;
 
 public:
-	bool IsScalar() const override {
-		return false;
-	}
-
 	string ToString() const override;
 
-	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
-	unique_ptr<ParsedExpression> Copy() const override;
-	hash_t Hash() const override;
+	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
 } // namespace duckdb
+
+
+
+
+
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/lambda_expression.hpp
+// duckdb/parser/expression/parameter_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21436,39 +21481,36 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! LambdaExpression represents a lambda operator that can be used for e.g. mapping an expression to a list
-//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
-class LambdaExpression : public ParsedExpression {
+class ParameterExpression : public ParsedExpression {
 public:
-	LambdaExpression(vector<string> parameters, unique_ptr<ParsedExpression> expression);
+	ParameterExpression();
 
-	vector<string> parameters;
-	unique_ptr<ParsedExpression> expression;
+	idx_t parameter_nr;
 
 public:
-	string ToString() const override;
+	bool IsScalar() const override {
+		return true;
+	}
+	bool HasParameter() const override {
+		return true;
+	}
 
-	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
-	hash_t Hash() const override;
+	string ToString() const override;
 
 	unique_ptr<ParsedExpression> Copy() const override;
+	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
-
 } // namespace duckdb
 
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/collate_expression.hpp
+// duckdb/parser/expression/star_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21477,22 +21519,25 @@ public:
 
 
 
+
 namespace duckdb {
 
-//! CollateExpression represents a COLLATE statement
-class CollateExpression : public ParsedExpression {
+//! Represents a * expression in the SELECT clause
+class StarExpression : public ParsedExpression {
 public:
-	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
+	StarExpression(string relation_name = string());
 
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The collation clause
-	string collation;
+	//! The relation name in case of tbl.*, or empty if this is a normal *
+	string relation_name;
+	//! List of columns to exclude from the STAR expression
+	case_insensitive_set_t exclude_list;
+	//! List of columns to replace with another expression
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+	static bool Equals(const StarExpression *a, const StarExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -21501,14 +21546,10 @@ public:
 };
 } // namespace duckdb
 
-
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/default_expression.hpp
+// duckdb/parser/expression/subquery_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21517,19 +21558,37 @@ public:
 
 
 
+
+
 namespace duckdb {
-//! Represents the default value of a column
-class DefaultExpression : public ParsedExpression {
+
+//! Represents a subquery
+class SubqueryExpression : public ParsedExpression {
 public:
-	DefaultExpression();
+	SubqueryExpression();
+
+	//! The actual subquery
+	unique_ptr<SelectStatement> subquery;
+	//! The subquery type
+	SubqueryType subquery_type;
+	//! the child expression to compare with (in case of IN, ANY, ALL operators, empty for EXISTS queries and scalar
+	//! subquery)
+	unique_ptr<ParsedExpression> child;
+	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators), empty otherwise
+	ExpressionType comparison_type;
 
 public:
+	bool HasSubquery() const override {
+		return true;
+	}
 	bool IsScalar() const override {
 		return false;
 	}
 
 	string ToString() const override;
 
+	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
+
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
@@ -21537,10 +21596,11 @@ public:
 };
 } // namespace duckdb
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/function_expression.hpp
+// duckdb/parser/parsed_data/create_collation_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21550,57 +21610,105 @@ public:
 
 
 
-
 namespace duckdb {
-//! Represents a function call
-class FunctionExpression : public ParsedExpression {
-public:
-	FunctionExpression(string schema_name, const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
-	                   bool distinct = false, bool is_operator = false);
-	FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
-	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
-	                   bool distinct = false, bool is_operator = false);
 
-	//! Schema of the function
-	string schema;
-	//! Function name
-	string function_name;
-	//! Whether or not the function is an operator, only used for rendering
-	bool is_operator;
-	//! List of arguments to the function
-	vector<unique_ptr<ParsedExpression>> children;
-	//! Whether or not the aggregate function is distinct, only used for aggregates
-	bool distinct;
-	//! Expression representing a filter, only used for aggregates
-	unique_ptr<ParsedExpression> filter;
-	//! Modifier representing an ORDER BY, only used for aggregates
-	unique_ptr<OrderModifier> order_bys;
+struct CreateCollationInfo : public CreateInfo {
+	CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p, bool not_required_for_equality_p)
+	    : CreateInfo(CatalogType::COLLATION_ENTRY), function(move(function_p)), combinable(combinable_p),
+	      not_required_for_equality(not_required_for_equality_p) {
+		this->name = move(name_p);
+	}
+
+	//! The name of the collation
+	string name;
+	//! The collation function to push in case collation is required
+	ScalarFunction function;
+	//! Whether or not the collation can be combined with other collations.
+	bool combinable;
+	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
+	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
+	//! speeds up processing.
+	bool not_required_for_equality;
 
 public:
-	string ToString() const override;
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
+		CopyProperties(*result);
+		return move(result);
+	}
+};
 
-	unique_ptr<ParsedExpression> Copy() const override;
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/vacuum_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
-	hash_t Hash() const override;
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+
+
+namespace duckdb {
+
+enum class LoadType { LOAD, INSTALL, FORCE_INSTALL };
+
+struct LoadInfo : public ParseInfo {
+	std::string filename;
+	LoadType load_type;
+
+public:
+	unique_ptr<LoadInfo> Copy() const {
+		auto result = make_unique<LoadInfo>();
+		result->filename = filename;
+		result->load_type = load_type;
+		return result;
+	}
 };
+
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/show_select_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
 
 
 
 
 
+namespace duckdb {
 
+struct ShowSelectInfo : public ParseInfo {
+	//! Types of projected columns
+	vector<LogicalType> types;
+	//! The QueryNode of select query
+	unique_ptr<QueryNode> query;
+	//! Aliases of projected columns
+	vector<string> aliases;
+	//! Whether or not we are requesting a summary or a describe
+	bool is_summary;
 
+	unique_ptr<ShowSelectInfo> Copy() {
+		auto result = make_unique<ShowSelectInfo>();
+		result->types = types;
+		result->query = query->Copy();
+		result->aliases = aliases;
+		result->is_summary = is_summary;
+		return result;
+	}
+};
+
+} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_pragma_function_info.hpp
+// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21612,25 +21720,26 @@ public:
 
 namespace duckdb {
 
-struct CreatePragmaFunctionInfo : public CreateFunctionInfo {
-	explicit CreatePragmaFunctionInfo(PragmaFunction function)
-	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY) {
-		functions.push_back(move(function));
+struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
+	explicit CreateAggregateFunctionInfo(AggregateFunction function)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
 		this->name = function.name;
+		functions.AddFunction(move(function));
 	}
-	CreatePragmaFunctionInfo(string name, vector<PragmaFunction> functions_)
-	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(move(functions_)) {
-		this->name = name;
-		for (auto &function : functions) {
-			function.name = name;
+
+	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
+		this->name = functions.name;
+		for (auto &func : functions.functions) {
+			func.name = functions.name;
 		}
 	}
 
-	vector<PragmaFunction> functions;
+	AggregateFunctionSet functions;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreatePragmaFunctionInfo>(functions[0].name, functions);
+		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
 		CopyProperties(*result);
 		return move(result);
 	}
@@ -21640,7 +21749,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_collation_info.hpp
+// duckdb/parser/parsed_data/create_type_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21650,30 +21759,26 @@ public:
 
 
 
+
+
 namespace duckdb {
 
-struct CreateCollationInfo : public CreateInfo {
-	CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p, bool not_required_for_equality_p)
-	    : CreateInfo(CatalogType::COLLATION_ENTRY), function(move(function_p)), combinable(combinable_p),
-	      not_required_for_equality(not_required_for_equality_p) {
-		this->name = move(name_p);
+struct CreateTypeInfo : public CreateInfo {
+
+	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
 	}
 
-	//! The name of the collation
+	//! Name of the Type
 	string name;
-	//! The collation function to push in case collation is required
-	ScalarFunction function;
-	//! Whether or not the collation can be combined with other collations.
-	bool combinable;
-	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
-	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
-	//! speeds up processing.
-	bool not_required_for_equality;
+	//! Logical Type
+	LogicalType type;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
+		auto result = make_unique<CreateTypeInfo>();
 		CopyProperties(*result);
+		result->name = name;
+		result->type = type;
 		return move(result);
 	}
 };
@@ -21682,7 +21787,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_schema_info.hpp
+// duckdb/parser/parsed_data/vacuum_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21693,16 +21798,8 @@ public:
 
 namespace duckdb {
 
-struct CreateSchemaInfo : public CreateInfo {
-	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
-	}
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateSchemaInfo>();
-		CopyProperties(*result);
-		return move(result);
-	}
+struct VacuumInfo : public ParseInfo {
+	// nothing for now
 };
 
 } // namespace duckdb
@@ -21778,7 +21875,18 @@ struct TransactionInfo : public ParseInfo {
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
+// duckdb/parser/parsed_data/create_macro_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/macro_function.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -21788,28 +21896,74 @@ struct TransactionInfo : public ParseInfo {
 
 
 
+
+
 namespace duckdb {
 
-struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
-	explicit CreateAggregateFunctionInfo(AggregateFunction function)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
-		this->name = function.name;
-		functions.AddFunction(move(function));
+class MacroCatalogEntry;
+
+class MacroFunction {
+public:
+	explicit MacroFunction(unique_ptr<ParsedExpression> expression);
+
+	//! Check whether the supplied arguments are valid
+	static string ValidateArguments(MacroCatalogEntry &macro_func, FunctionExpression &function_expr,
+	                                vector<unique_ptr<ParsedExpression>> &positionals,
+	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
+	//! The macro expression
+	unique_ptr<ParsedExpression> expression;
+	//! The positional parameters
+	vector<unique_ptr<ParsedExpression>> parameters;
+	//! The default parameters and their associated values
+	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
+
+public:
+	unique_ptr<MacroFunction> Copy();
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct CreateMacroInfo : public CreateFunctionInfo {
+	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
 	}
 
-	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
-		this->name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
+	unique_ptr<MacroFunction> function;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateMacroInfo>();
+		result->function = function->Copy();
+		result->name = name;
+		CopyProperties(*result);
+		return move(result);
 	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_schema_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 
-	AggregateFunctionSet functions;
+
+
+
+namespace duckdb {
+
+struct CreateSchemaInfo : public CreateInfo {
+	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+	}
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
+		auto result = make_unique<CreateSchemaInfo>();
 		CopyProperties(*result);
 		return move(result);
 	}
@@ -21880,99 +22034,25 @@ struct CreateIndexInfo : public CreateInfo {
 	//! Index Type (e.g., B+-tree, Skip-List, ...)
 	IndexType index_type;
 	//! Name of the Index
-	string index_name;
-	//! If it is an unique index
-	bool unique = false;
-	//! The table to create the index on
-	unique_ptr<BaseTableRef> table;
-	//! Set of expressions to index by
-	vector<unique_ptr<ParsedExpression>> expressions;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateIndexInfo>();
-		CopyProperties(*result);
-		result->index_type = index_type;
-		result->index_name = index_name;
-		result->unique = unique;
-		result->table = unique_ptr_cast<TableRef, BaseTableRef>(table->Copy());
-		for (auto &expr : expressions) {
-			result->expressions.push_back(expr->Copy());
-		}
-		return move(result);
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/show_select_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct ShowSelectInfo : public ParseInfo {
-	//! Types of projected columns
-	vector<LogicalType> types;
-	//! The QueryNode of select query
-	unique_ptr<QueryNode> query;
-	//! Aliases of projected columns
-	vector<string> aliases;
-	//! Whether or not we are requesting a summary or a describe
-	bool is_summary;
-
-	unique_ptr<ShowSelectInfo> Copy() {
-		auto result = make_unique<ShowSelectInfo>();
-		result->types = types;
-		result->query = query->Copy();
-		result->aliases = aliases;
-		result->is_summary = is_summary;
-		return result;
-	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_type_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct CreateTypeInfo : public CreateInfo {
-
-	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
-	}
-
-	//! Name of the Type
-	string name;
-	//! Logical Type
-	LogicalType type;
+	string index_name;
+	//! If it is an unique index
+	bool unique = false;
+	//! The table to create the index on
+	unique_ptr<BaseTableRef> table;
+	//! Set of expressions to index by
+	vector<unique_ptr<ParsedExpression>> expressions;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateTypeInfo>();
+		auto result = make_unique<CreateIndexInfo>();
 		CopyProperties(*result);
-		result->name = name;
-		result->type = type;
+		result->index_type = index_type;
+		result->index_name = index_name;
+		result->unique = unique;
+		result->table = unique_ptr_cast<TableRef, BaseTableRef>(table->Copy());
+		for (auto &expr : expressions) {
+			result->expressions.push_back(expr->Copy());
+		}
 		return move(result);
 	}
 };
@@ -21981,18 +22061,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_macro_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/macro_function.hpp
+// duckdb/parser/parsed_data/create_pragma_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22002,47 +22071,27 @@ public:
 
 
 
-
-
-namespace duckdb {
-
-class MacroCatalogEntry;
-
-class MacroFunction {
-public:
-	explicit MacroFunction(unique_ptr<ParsedExpression> expression);
-
-	//! Check whether the supplied arguments are valid
-	static string ValidateArguments(MacroCatalogEntry &macro_func, FunctionExpression &function_expr,
-	                                vector<unique_ptr<ParsedExpression>> &positionals,
-	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
-	//! The macro expression
-	unique_ptr<ParsedExpression> expression;
-	//! The positional parameters
-	vector<unique_ptr<ParsedExpression>> parameters;
-	//! The default parameters and their associated values
-	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
-
-public:
-	unique_ptr<MacroFunction> Copy();
-};
-
-} // namespace duckdb
-
-
 namespace duckdb {
 
-struct CreateMacroInfo : public CreateFunctionInfo {
-	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
+struct CreatePragmaFunctionInfo : public CreateFunctionInfo {
+	explicit CreatePragmaFunctionInfo(PragmaFunction function)
+	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY) {
+		functions.push_back(move(function));
+		this->name = function.name;
+	}
+	CreatePragmaFunctionInfo(string name, vector<PragmaFunction> functions_)
+	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(move(functions_)) {
+		this->name = name;
+		for (auto &function : functions) {
+			function.name = name;
+		}
 	}
 
-	unique_ptr<MacroFunction> function;
+	vector<PragmaFunction> functions;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateMacroInfo>();
-		result->function = function->Copy();
-		result->name = name;
+		auto result = make_unique<CreatePragmaFunctionInfo>(functions[0].name, functions);
 		CopyProperties(*result);
 		return move(result);
 	}
@@ -22079,25 +22128,6 @@ struct BoundExportData : public ParseInfo {
 	unordered_map<TableCatalogEntry *, ExportedTableData> data;
 };
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/vacuum_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-struct VacuumInfo : public ParseInfo {
-	// nothing for now
-};
-
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -22145,7 +22175,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/vacuum_info.hpp
+// duckdb/parser/tableref/table_function_ref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22154,56 +22184,32 @@ public:
 
 
 
-namespace duckdb {
 
-enum class LoadType { LOAD, INSTALL, FORCE_INSTALL };
 
-struct LoadInfo : public ParseInfo {
-	std::string filename;
-	LoadType load_type;
 
+namespace duckdb {
+//! Represents a Table producing function
+class TableFunctionRef : public TableRef {
 public:
-	unique_ptr<LoadInfo> Copy() const {
-		auto result = make_unique<LoadInfo>();
-		result->filename = filename;
-		result->load_type = load_type;
-		return result;
+	TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
 	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/subqueryref.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
 
+	unique_ptr<ParsedExpression> function;
+	vector<string> column_name_alias;
 
-namespace duckdb {
-//! Represents a subquery
-class SubqueryRef : public TableRef {
-public:
-	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
-
-	//! The subquery
+	// if the function takes a subquery as argument its in here
 	unique_ptr<SelectStatement> subquery;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
 
 public:
+	string ToString() const override;
+
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a SubqueryRef
+	//! Serializes a blob into a BaseTableRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a SubqueryRef
+	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
@@ -22245,7 +22251,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/joinref.hpp
+// duckdb/parser/tableref/emptytableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22254,47 +22260,31 @@ public:
 
 
 
-
-
-
-
 namespace duckdb {
-//! Represents a JOIN between two expressions
-class JoinRef : public TableRef {
+//! Represents a cross product
+class EmptyTableRef : public TableRef {
 public:
-	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
+	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
 	}
 
-	//! The left hand side of the join
-	unique_ptr<TableRef> left;
-	//! The right hand side of the join
-	unique_ptr<TableRef> right;
-	//! The join condition
-	unique_ptr<ParsedExpression> condition;
-	//! The join type
-	JoinType type;
-	//! Natural join
-	bool is_natural;
-	//! The set of USING columns (if any)
-	vector<string> using_columns;
-
 public:
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a JoinRef
+	//! Serializes a blob into a DummyTableRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a JoinRef
+	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/emptytableref.hpp
+// duckdb/parser/tableref/expressionlistref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22303,21 +22293,31 @@ public:
 
 
 
+
+
+
 namespace duckdb {
-//! Represents a cross product
-class EmptyTableRef : public TableRef {
+//! Represents an expression list as generated by a VALUES statement
+class ExpressionListRef : public TableRef {
 public:
-	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
+	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
 	}
 
+	//! Value list, only used for VALUES statement
+	vector<vector<unique_ptr<ParsedExpression>>> values;
+	//! Expected SQL types
+	vector<LogicalType> expected_types;
+	//! The set of expected names
+	vector<string> expected_names;
+
 public:
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a DummyTableRef
+	//! Serializes a blob into a ExpressionListRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a DummyTableRef
+	//! Deserializes a blob back into a ExpressionListRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
@@ -22325,7 +22325,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/expressionlistref.hpp
+// duckdb/parser/tableref/joinref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22337,38 +22337,43 @@ public:
 
 
 
+
 namespace duckdb {
-//! Represents an expression list as generated by a VALUES statement
-class ExpressionListRef : public TableRef {
+//! Represents a JOIN between two expressions
+class JoinRef : public TableRef {
 public:
-	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
+	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
 	}
 
-	//! Value list, only used for VALUES statement
-	vector<vector<unique_ptr<ParsedExpression>>> values;
-	//! Expected SQL types
-	vector<LogicalType> expected_types;
-	//! The set of expected names
-	vector<string> expected_names;
+	//! The left hand side of the join
+	unique_ptr<TableRef> left;
+	//! The right hand side of the join
+	unique_ptr<TableRef> right;
+	//! The join condition
+	unique_ptr<ParsedExpression> condition;
+	//! The join type
+	JoinType type;
+	//! Natural join
+	bool is_natural;
+	//! The set of USING columns (if any)
+	vector<string> using_columns;
 
 public:
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a ExpressionListRef
+	//! Serializes a blob into a JoinRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a ExpressionListRef
+	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/table_function_ref.hpp
+// duckdb/parser/tableref/subqueryref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22378,32 +22383,27 @@ public:
 
 
 
-
-
 namespace duckdb {
-//! Represents a Table producing function
-class TableFunctionRef : public TableRef {
+//! Represents a subquery
+class SubqueryRef : public TableRef {
 public:
-	TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
-	}
-
-	unique_ptr<ParsedExpression> function;
-	vector<string> column_name_alias;
+	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
 
-	// if the function takes a subquery as argument its in here
+	//! The subquery
 	unique_ptr<SelectStatement> subquery;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
 public:
-	string ToString() const override;
-
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a BaseTableRef
+	//! Serializes a blob into a SubqueryRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
+	//! Deserializes a blob back into a SubqueryRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 
+