duckdb 0.3.5-dev1285.0 → 0.3.5-dev1323.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 "2c3c08da3"
-#define DUCKDB_VERSION "v0.3.5-dev1285"
+#define DUCKDB_SOURCE_ID "5d9d00b2a"
+#define DUCKDB_VERSION "v0.3.5-dev1323"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -2194,9 +2194,8 @@ namespace duckdb {
 class VectorBuffer;
 
 struct SelectionData {
-	explicit SelectionData(idx_t count) {
-		owned_data = unique_ptr<sel_t[]>(new sel_t[count]);
-	}
+	explicit SelectionData(idx_t count);
+
 	unique_ptr<sel_t[]> owned_data;
 };
 
@@ -3557,6 +3556,7 @@ class VectorStructBuffer : public VectorBuffer {
 public:
 	VectorStructBuffer();
 	VectorStructBuffer(const LogicalType &struct_type, idx_t capacity = STANDARD_VECTOR_SIZE);
+	VectorStructBuffer(Vector &other, const SelectionVector &sel, idx_t count);
 	~VectorStructBuffer() override;
 
 public:
@@ -3718,7 +3718,7 @@ public:
 	//! Verify that the Vector is in a consistent, not corrupt state. DEBUG
 	//! FUNCTION ONLY!
 	DUCKDB_API void Verify(idx_t count);
-	DUCKDB_API void Verify(const SelectionVector &sel, idx_t count);
+	DUCKDB_API static void Verify(Vector &vector, const SelectionVector &sel, idx_t count);
 	DUCKDB_API void UTFVerify(idx_t count);
 	DUCKDB_API void UTFVerify(const SelectionVector &sel, idx_t count);
 
@@ -3761,6 +3761,10 @@ public:
 	// Setters
 	DUCKDB_API void SetVectorType(VectorType vector_type);
 
+private:
+	//! Returns the [index] element of the Vector as a Value.
+	DUCKDB_API static Value GetValue(const Vector &v, idx_t index);
+
 protected:
 	//! The vector type specifies how the data of the vector is physically stored (i.e. if it is a single repeated
 	//! constant, if it is compressed)
@@ -22944,7 +22948,7 @@ private:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/comparison_expression.hpp
+// duckdb/parser/expression/conjunction_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22953,21 +22957,25 @@ private:
 
 
 
+
 namespace duckdb {
-//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
-//! and has two children.
-class ComparisonExpression : public ParsedExpression {
+
+//! Represents a conjunction (AND/OR)
+class ConjunctionExpression : public ParsedExpression {
 public:
-	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                unique_ptr<ParsedExpression> right);
+	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
+	                                 unique_ptr<ParsedExpression> right);
 
-	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 ComparisonExpression *a, const ComparisonExpression *b);
+	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -22977,14 +22985,18 @@ public:
 public:
 	template <class T, class BASE>
 	static string ToString(const T &entry) {
-		return entry.left->ToString() + " " + ExpressionTypeToOperator(entry.type) + " " + entry.right->ToString();
+		string result = "(" + entry.children[0]->ToString();
+		for (idx_t i = 1; i < entry.children.size(); i++) {
+			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
+		}
+		return result + ")";
 	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/default_expression.hpp
+// duckdb/parser/expression/positional_reference_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -22994,10 +23006,11 @@ public:
 
 
 namespace duckdb {
-//! Represents the default value of a column
-class DefaultExpression : public ParsedExpression {
+class PositionalReferenceExpression : public ParsedExpression {
 public:
-	DefaultExpression();
+	DUCKDB_API PositionalReferenceExpression(idx_t index);
+
+	idx_t index;
 
 public:
 	bool IsScalar() const override {
@@ -23006,7 +23019,9 @@ public:
 
 	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);
@@ -23015,7 +23030,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/case_expression.hpp
+// duckdb/parser/expression/star_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23027,47 +23042,33 @@ 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 {
+//! Represents a * expression in the SELECT clause
+class StarExpression : public ParsedExpression {
 public:
-	DUCKDB_API CaseExpression();
+	StarExpression(string relation_name = string());
 
-	vector<CaseCheck> case_checks;
-	unique_ptr<ParsedExpression> else_expr;
+	//! 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 CaseExpression *a, const CaseExpression *b);
+	static bool Equals(const StarExpression *a, const StarExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string case_str = "CASE ";
-		for (auto &check : entry.case_checks) {
-			case_str += " WHEN (" + check.when_expr->ToString() + ")";
-			case_str += " THEN (" + check.then_expr->ToString() + ")";
-		}
-		case_str += " ELSE " + entry.else_expr->ToString();
-		case_str += " END";
-		return case_str;
-	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/positional_reference_expression.hpp
+// duckdb/parser/expression/operator_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23076,32 +23077,98 @@ public:
 
 
 
+
+
+
 namespace duckdb {
-class PositionalReferenceExpression : public ParsedExpression {
+//! Represents a built-in operator expression
+class OperatorExpression : public ParsedExpression {
 public:
-	DUCKDB_API PositionalReferenceExpression(idx_t index);
+	DUCKDB_API explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
+	                                       unique_ptr<ParsedExpression> right = nullptr);
+	DUCKDB_API OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
 
-	idx_t index;
+	vector<unique_ptr<ParsedExpression>> children;
 
 public:
-	bool IsScalar() const override {
-		return false;
-	}
-
 	string ToString() const override;
 
-	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
+	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);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		auto op = ExpressionTypeToOperator(entry.type);
+		if (!op.empty()) {
+			// use the operator string to represent the operator
+			D_ASSERT(entry.children.size() == 2);
+			return entry.children[0]->ToString() + " " + op + " " + entry.children[1]->ToString();
+		}
+		switch (entry.type) {
+		case ExpressionType::COMPARE_IN:
+		case ExpressionType::COMPARE_NOT_IN: {
+			string op_type = entry.type == ExpressionType::COMPARE_IN ? " IN " : " NOT IN ";
+			string in_child = entry.children[0]->ToString();
+			string child_list = "(";
+			for (idx_t i = 1; i < entry.children.size(); i++) {
+				if (i > 1) {
+					child_list += ", ";
+				}
+				child_list += entry.children[i]->ToString();
+			}
+			child_list += ")";
+			return "(" + in_child + op_type + child_list + ")";
+		}
+		case ExpressionType::OPERATOR_NOT:
+		case ExpressionType::GROUPING_FUNCTION:
+		case ExpressionType::OPERATOR_COALESCE: {
+			string result = ExpressionTypeToString(entry.type);
+			result += "(";
+			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
+			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+			result += ")";
+			return result;
+		}
+		case ExpressionType::OPERATOR_IS_NULL:
+			return "(" + entry.children[0]->ToString() + " IS NULL)";
+		case ExpressionType::OPERATOR_IS_NOT_NULL:
+			return "(" + entry.children[0]->ToString() + " IS NOT NULL)";
+		case ExpressionType::ARRAY_EXTRACT:
+			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + "]";
+		case ExpressionType::ARRAY_SLICE:
+			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + ":" +
+			       entry.children[2]->ToString() + "]";
+		case ExpressionType::STRUCT_EXTRACT: {
+			D_ASSERT(entry.children[1]->type == ExpressionType::VALUE_CONSTANT);
+			auto child_string = entry.children[1]->ToString();
+			D_ASSERT(child_string.size() >= 3);
+			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
+			return "(" + entry.children[0]->ToString() + ")." +
+			       KeywordHelper::WriteOptionallyQuoted(child_string.substr(1, child_string.size() - 2));
+		}
+		case ExpressionType::ARRAY_CONSTRUCTOR: {
+			string result = "(ARRAY[";
+			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
+			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
+			result += "])";
+			return result;
+		}
+		default:
+			throw InternalException("Unrecognized operator type");
+		}
+	}
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/conjunction_expression.hpp
+// duckdb/parser/expression/constant_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23113,38 +23180,26 @@ public:
 
 namespace duckdb {
 
-//! Represents a conjunction (AND/OR)
-class ConjunctionExpression : public ParsedExpression {
+//! ConstantExpression represents a constant value in the query
+class ConstantExpression : public ParsedExpression {
 public:
-	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                 unique_ptr<ParsedExpression> right);
+	DUCKDB_API explicit ConstantExpression(Value val);
 
-	vector<unique_ptr<ParsedExpression>> children;
+	//! The constant value referenced
+	Value value;
 
 public:
-	void AddExpression(unique_ptr<ParsedExpression> expr);
-
 	string ToString() const override;
 
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *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);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string result = "(" + entry.children[0]->ToString();
-		for (idx_t i = 1; i < entry.children.size(); i++) {
-			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
-		}
-		return result + ")";
-	}
 };
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -23198,7 +23253,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/cast_expression.hpp
+// duckdb/parser/expression/parameter_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23207,43 +23262,34 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! CastExpression represents a type cast from one SQL type to another SQL type
-class CastExpression : public ParsedExpression {
+class ParameterExpression : public ParsedExpression {
 public:
-	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
+	ParameterExpression();
 
-	//! The child of the cast expression
-	unique_ptr<ParsedExpression> child;
-	//! The type to cast to
-	LogicalType cast_type;
-	//! Whether or not this is a try_cast expression
-	bool try_cast;
+	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 CastExpression *a, const CastExpression *b);
+	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);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
-		       entry.cast_type.ToString() + ")";
-	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/lambda_expression.hpp
+// duckdb/parser/expression/between_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23252,37 +23298,38 @@ public:
 
 
 
-
 namespace duckdb {
 
-//! LambdaExpression represents either:
-//!  1. A lambda operator that can be used for e.g. mapping an expression to a list
-//!  2. An OperatorExpression with the "->" operator
-//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
-class LambdaExpression : public ParsedExpression {
+class BetweenExpression : public ParsedExpression {
 public:
-	LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> rhs);
+	DUCKDB_API BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
+	                             unique_ptr<ParsedExpression> upper);
 
-	unique_ptr<ParsedExpression> lhs;
-	unique_ptr<ParsedExpression> rhs;
+	unique_ptr<ParsedExpression> input;
+	unique_ptr<ParsedExpression> lower;
+	unique_ptr<ParsedExpression> upper;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
-	hash_t Hash() const override;
+	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
 
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		return entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " + entry.upper->ToString();
+	}
+};
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/function_expression.hpp
+// duckdb/parser/expression/default_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23291,115 +23338,31 @@ public:
 
 
 
-
-
 namespace duckdb {
-//! Represents a function call
-class FunctionExpression : public ParsedExpression {
+//! Represents the default value of a column
+class DefaultExpression : public ParsedExpression {
 public:
-	DUCKDB_API 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, bool export_state = false);
-	DUCKDB_API 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, bool export_state = 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;
-	//! whether this function should export its state or not
-	bool export_state;
+	DefaultExpression();
 
 public:
+	bool IsScalar() const override {
+		return false;
+	}
+
 	string ToString() const override;
 
 	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);
-
-	void Verify() const override;
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
-	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
-	                       bool export_state = false, bool add_alias = false) {
-		if (is_operator) {
-			// built-in operator
-			D_ASSERT(!distinct);
-			if (entry.children.size() == 1) {
-				if (StringUtil::Contains(function_name, "__postfix")) {
-					return "(" + entry.children[0]->ToString() + ")" +
-					       StringUtil::Replace(function_name, "__postfix", "");
-				} else {
-					return function_name + "(" + entry.children[0]->ToString() + ")";
-				}
-			} else if (entry.children.size() == 2) {
-				return "(" + entry.children[0]->ToString() + " " + function_name + " " + entry.children[1]->ToString() +
-				       ")";
-			}
-		}
-		// standard function call
-		string result = schema.empty() ? function_name : schema + "." + function_name;
-		result += "(";
-		if (distinct) {
-			result += "DISTINCT ";
-		}
-		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
-			return child->alias.empty() || !add_alias
-			           ? child->ToString()
-			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
-		});
-		// ordered aggregate
-		if (order_bys && !order_bys->orders.empty()) {
-			if (entry.children.empty()) {
-				result += ") WITHIN GROUP (";
-			}
-			result += " ORDER BY ";
-			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
-				if (i > 0) {
-					result += ", ";
-				}
-				result += order_bys->orders[i].ToString();
-			}
-		}
-		result += ")";
-
-		// filtered aggregate
-		if (filter) {
-			result += " FILTER (WHERE " + filter->ToString() + ")";
-		}
-
-		if (export_state) {
-			result += " EXPORT_STATE";
-		}
-
-		return result;
-	}
 };
 } // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/star_expression.hpp
+// duckdb/parser/expression/case_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23411,69 +23374,48 @@ public:
 
 namespace duckdb {
 
-//! Represents a * expression in the SELECT clause
-class StarExpression : 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:
-	StarExpression(string relation_name = string());
+	DUCKDB_API CaseExpression();
 
-	//! 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;
+	vector<CaseCheck> case_checks;
+	unique_ptr<ParsedExpression> else_expr;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const StarExpression *a, const StarExpression *b);
+	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/parameter_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class ParameterExpression : public ParsedExpression {
-public:
-	ParameterExpression();
-
-	idx_t parameter_nr;
 
 public:
-	bool IsScalar() const override {
-		return true;
-	}
-	bool HasParameter() const override {
-		return true;
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		string case_str = "CASE ";
+		for (auto &check : entry.case_checks) {
+			case_str += " WHEN (" + check.when_expr->ToString() + ")";
+			case_str += " THEN (" + check.then_expr->ToString() + ")";
+		}
+		case_str += " ELSE " + entry.else_expr->ToString();
+		case_str += " END";
+		return case_str;
 	}
-
-	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/between_expression.hpp
+// duckdb/parser/expression/cast_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23482,21 +23424,25 @@ public:
 
 
 
+
 namespace duckdb {
 
-class BetweenExpression : public ParsedExpression {
+//! CastExpression represents a type cast from one SQL type to another SQL type
+class CastExpression : public ParsedExpression {
 public:
-	DUCKDB_API BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
-	                             unique_ptr<ParsedExpression> upper);
+	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
 
-	unique_ptr<ParsedExpression> input;
-	unique_ptr<ParsedExpression> lower;
-	unique_ptr<ParsedExpression> upper;
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The type to cast to
+	LogicalType cast_type;
+	//! Whether or not this is a try_cast expression
+	bool try_cast;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
+	static bool Equals(const CastExpression *a, const CastExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -23506,14 +23452,12 @@ public:
 public:
 	template <class T, class BASE>
 	static string ToString(const T &entry) {
-		return entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " + entry.upper->ToString();
+		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
+		       entry.cast_type.ToString() + ")";
 	}
 };
 } // namespace duckdb
 
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -23551,12 +23495,10 @@ public:
 } // namespace duckdb
 
 
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/constant_expression.hpp
+// duckdb/parser/expression/comparison_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23565,29 +23507,33 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! ConstantExpression represents a constant value in the query
-class ConstantExpression : public ParsedExpression {
+//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
+//! and has two children.
+class ComparisonExpression : public ParsedExpression {
 public:
-	DUCKDB_API explicit ConstantExpression(Value val);
+	DUCKDB_API ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
+	                                unique_ptr<ParsedExpression> right);
 
-	//! The constant value referenced
-	Value value;
+	unique_ptr<ParsedExpression> left;
+	unique_ptr<ParsedExpression> right;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
-	hash_t Hash() const override;
+	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
 
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		return entry.left->ToString() + " " + ExpressionTypeToOperator(entry.type) + " " + entry.right->ToString();
+	}
+};
 } // namespace duckdb
 
 
@@ -23596,7 +23542,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/operator_expression.hpp
+// duckdb/parser/expression/function_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23607,102 +23553,114 @@ public:
 
 
 
-
 namespace duckdb {
-//! Represents a built-in operator expression
-class OperatorExpression : public ParsedExpression {
+//! Represents a function call
+class FunctionExpression : public ParsedExpression {
 public:
-	DUCKDB_API explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
-	                                       unique_ptr<ParsedExpression> right = nullptr);
-	DUCKDB_API OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	DUCKDB_API 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, bool export_state = false);
+	DUCKDB_API 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, bool export_state = 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;
+	//! whether this function should export its state or not
+	bool export_state;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
-
 	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);
 
+	void Verify() const override;
+
 public:
 	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		auto op = ExpressionTypeToOperator(entry.type);
-		if (!op.empty()) {
-			// use the operator string to represent the operator
-			D_ASSERT(entry.children.size() == 2);
-			return entry.children[0]->ToString() + " " + op + " " + entry.children[1]->ToString();
-		}
-		switch (entry.type) {
-		case ExpressionType::COMPARE_IN:
-		case ExpressionType::COMPARE_NOT_IN: {
-			string op_type = entry.type == ExpressionType::COMPARE_IN ? " IN " : " NOT IN ";
-			string in_child = entry.children[0]->ToString();
-			string child_list = "(";
-			for (idx_t i = 1; i < entry.children.size(); i++) {
-				if (i > 1) {
-					child_list += ", ";
+	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
+	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
+	                       bool export_state = false, bool add_alias = false) {
+		if (is_operator) {
+			// built-in operator
+			D_ASSERT(!distinct);
+			if (entry.children.size() == 1) {
+				if (StringUtil::Contains(function_name, "__postfix")) {
+					return "(" + entry.children[0]->ToString() + ")" +
+					       StringUtil::Replace(function_name, "__postfix", "");
+				} else {
+					return function_name + "(" + entry.children[0]->ToString() + ")";
 				}
-				child_list += entry.children[i]->ToString();
+			} else if (entry.children.size() == 2) {
+				return "(" + entry.children[0]->ToString() + " " + function_name + " " + entry.children[1]->ToString() +
+				       ")";
 			}
-			child_list += ")";
-			return "(" + in_child + op_type + child_list + ")";
 		}
-		case ExpressionType::OPERATOR_NOT:
-		case ExpressionType::GROUPING_FUNCTION:
-		case ExpressionType::OPERATOR_COALESCE: {
-			string result = ExpressionTypeToString(entry.type);
-			result += "(";
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-			result += ")";
-			return result;
+		// standard function call
+		string result = schema.empty() ? function_name : schema + "." + function_name;
+		result += "(";
+		if (distinct) {
+			result += "DISTINCT ";
 		}
-		case ExpressionType::OPERATOR_IS_NULL:
-			return "(" + entry.children[0]->ToString() + " IS NULL)";
-		case ExpressionType::OPERATOR_IS_NOT_NULL:
-			return "(" + entry.children[0]->ToString() + " IS NOT NULL)";
-		case ExpressionType::ARRAY_EXTRACT:
-			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + "]";
-		case ExpressionType::ARRAY_SLICE:
-			return entry.children[0]->ToString() + "[" + entry.children[1]->ToString() + ":" +
-			       entry.children[2]->ToString() + "]";
-		case ExpressionType::STRUCT_EXTRACT: {
-			D_ASSERT(entry.children[1]->type == ExpressionType::VALUE_CONSTANT);
-			auto child_string = entry.children[1]->ToString();
-			D_ASSERT(child_string.size() >= 3);
-			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
-			return "(" + entry.children[0]->ToString() + ")." +
-			       KeywordHelper::WriteOptionallyQuoted(child_string.substr(1, child_string.size() - 2));
+		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
+			return child->alias.empty() || !add_alias
+			           ? child->ToString()
+			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
+		});
+		// ordered aggregate
+		if (order_bys && !order_bys->orders.empty()) {
+			if (entry.children.empty()) {
+				result += ") WITHIN GROUP (";
+			}
+			result += " ORDER BY ";
+			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
+				if (i > 0) {
+					result += ", ";
+				}
+				result += order_bys->orders[i].ToString();
+			}
 		}
-		case ExpressionType::ARRAY_CONSTRUCTOR: {
-			string result = "(ARRAY[";
-			result += StringUtil::Join(entry.children, entry.children.size(), ", ",
-			                           [](const unique_ptr<BASE> &child) { return child->ToString(); });
-			result += "])";
-			return result;
+		result += ")";
+
+		// filtered aggregate
+		if (filter) {
+			result += " FILTER (WHERE " + filter->ToString() + ")";
 		}
-		default:
-			throw InternalException("Unrecognized operator type");
+
+		if (export_state) {
+			result += " EXPORT_STATE";
 		}
+
+		return result;
 	}
 };
-
 } // namespace duckdb
 
-
-
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_view_info.hpp
+// duckdb/parser/expression/lambda_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23714,38 +23672,41 @@ public:
 
 namespace duckdb {
 
-struct CreateViewInfo : public CreateInfo {
-	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
-	}
-	CreateViewInfo(string schema, string view_name)
-	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
-	}
+//! LambdaExpression represents either:
+//!  1. A lambda operator that can be used for e.g. mapping an expression to a list
+//!  2. An OperatorExpression with the "->" operator
+//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
+class LambdaExpression : public ParsedExpression {
+public:
+	LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> rhs);
 
-	//! Table name to insert to
-	string view_name;
-	//! Aliases of the view
-	vector<string> aliases;
-	//! Return types
-	vector<LogicalType> types;
-	//! The SelectStatement of the view
-	unique_ptr<SelectStatement> query;
+	unique_ptr<ParsedExpression> lhs;
+	unique_ptr<ParsedExpression> rhs;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateViewInfo>(schema, view_name);
-		CopyProperties(*result);
-		result->aliases = aliases;
-		result->types = types;
-		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
-		return move(result);
-	}
+	string ToString() const override;
+
+	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/parsed_data/transaction_info.hpp
+// duckdb/parser/parsed_data/vacuum_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23756,14 +23717,19 @@ public:
 
 namespace duckdb {
 
-enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
+enum class LoadType { LOAD, INSTALL, FORCE_INSTALL };
+
+struct LoadInfo : public ParseInfo {
+	std::string filename;
+	LoadType load_type;
 
-struct TransactionInfo : public ParseInfo {
-	explicit TransactionInfo(TransactionType type) : type(type) {
+public:
+	unique_ptr<LoadInfo> Copy() const {
+		auto result = make_unique<LoadInfo>();
+		result->filename = filename;
+		result->load_type = load_type;
+		return result;
 	}
-
-	//! The type of transaction statement
-	TransactionType type;
 };
 
 } // namespace duckdb
@@ -23810,7 +23776,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_schema_info.hpp
+// duckdb/parser/parsed_data/drop_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23819,18 +23785,60 @@ public:
 
 
 
+
 namespace duckdb {
 
-struct CreateSchemaInfo : public CreateInfo {
-	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+struct DropInfo : public ParseInfo {
+	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
 	}
 
+	//! The catalog type to drop
+	CatalogType type;
+	//! Schema name to drop from, if any
+	string schema;
+	//! Element name to drop
+	string name;
+	//! Ignore if the entry does not exist instead of failing
+	bool if_exists = false;
+	//! Cascade drop (drop all dependents instead of throwing an error if there
+	//! are any)
+	bool cascade = false;
+
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateSchemaInfo>();
-		CopyProperties(*result);
-		return move(result);
+	unique_ptr<DropInfo> Copy() const {
+		auto result = make_unique<DropInfo>();
+		result->type = type;
+		result->schema = schema;
+		result->name = name;
+		result->if_exists = if_exists;
+		result->cascade = cascade;
+		return result;
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/transaction_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
+
+struct TransactionInfo : public ParseInfo {
+	explicit TransactionInfo(TransactionType type) : type(type) {
 	}
+
+	//! The type of transaction statement
+	TransactionType type;
 };
 
 } // namespace duckdb
@@ -23921,7 +23929,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
+// duckdb/parser/parsed_data/show_select_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23933,36 +23941,63 @@ public:
 
 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));
-	}
+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;
 
-	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<ShowSelectInfo> Copy() {
+		auto result = make_unique<ShowSelectInfo>();
+		result->types = types;
+		result->query = query->Copy();
+		result->aliases = aliases;
+		result->is_summary = is_summary;
+		return result;
 	}
+};
 
-	AggregateFunctionSet functions;
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/vacuum_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
-		CopyProperties(*result);
-		return move(result);
-	}
+
+
+
+
+namespace duckdb {
+
+struct VacuumInfo : public ParseInfo {
+	// nothing for now
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/show_select_info.hpp
+// duckdb/parser/parsed_data/create_index_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/basetableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -23973,24 +24008,63 @@ public:
 
 
 namespace duckdb {
+//! Represents a TableReference to a base table in the schema
+class BaseTableRef : public TableRef {
+public:
+	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
+	}
 
-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;
+	//! Schema name
+	string schema_name;
+	//! Table name
+	string table_name;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
-	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;
+public:
+	string ToString() const override;
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a BaseTableRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a BaseTableRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+};
+} // namespace duckdb
+
+
+
+namespace duckdb {
+
+struct CreateIndexInfo : public CreateInfo {
+	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
+	}
+
+	//! 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);
 	}
 };
 
@@ -24034,7 +24108,7 @@ struct BoundExportData : public ParseInfo {
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/drop_info.hpp
+// duckdb/parser/parsed_data/create_schema_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24043,34 +24117,17 @@ struct BoundExportData : public ParseInfo {
 
 
 
-
 namespace duckdb {
 
-struct DropInfo : public ParseInfo {
-	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
+struct CreateSchemaInfo : public CreateInfo {
+	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
 	}
 
-	//! The catalog type to drop
-	CatalogType type;
-	//! Schema name to drop from, if any
-	string schema;
-	//! Element name to drop
-	string name;
-	//! Ignore if the entry does not exist instead of failing
-	bool if_exists = false;
-	//! Cascade drop (drop all dependents instead of throwing an error if there
-	//! are any)
-	bool cascade = false;
-
 public:
-	unique_ptr<DropInfo> Copy() const {
-		auto result = make_unique<DropInfo>();
-		result->type = type;
-		result->schema = schema;
-		result->name = name;
-		result->if_exists = if_exists;
-		result->cascade = cascade;
-		return result;
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateSchemaInfo>();
+		CopyProperties(*result);
+		return move(result);
 	}
 };
 
@@ -24078,20 +24135,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_index_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/tableref/basetableref.hpp
+// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24102,62 +24146,28 @@ public:
 
 
 namespace duckdb {
-//! Represents a TableReference to a base table in the schema
-class BaseTableRef : public TableRef {
-public:
-	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
-	}
-
-	//! Schema name
-	string schema_name;
-	//! Table name
-	string table_name;
-	//! 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
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
-};
-} // namespace duckdb
-
-
-
-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));
+	}
 
-struct CreateIndexInfo : public CreateInfo {
-	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
+	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;
+		}
 	}
 
-	//! 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;
+	AggregateFunctionSet functions;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateIndexInfo>();
+		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
 		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);
 	}
 };
@@ -24166,7 +24176,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/vacuum_info.hpp
+// duckdb/parser/parsed_data/create_type_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24175,10 +24185,29 @@ public:
 
 
 
+
+
+
 namespace duckdb {
 
-struct VacuumInfo : public ParseInfo {
-	// nothing for now
+struct CreateTypeInfo : public CreateInfo {
+
+	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+	}
+
+	//! Name of the Type
+	string name;
+	//! Logical Type
+	LogicalType type;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateTypeInfo>();
+		CopyProperties(*result);
+		result->name = name;
+		result->type = type;
+		return move(result);
+	}
 };
 
 } // namespace duckdb
@@ -24227,37 +24256,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/vacuum_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-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/create_type_info.hpp
+// duckdb/parser/parsed_data/create_view_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24267,26 +24266,31 @@ public:
 
 
 
-
-
 namespace duckdb {
 
-struct CreateTypeInfo : public CreateInfo {
-
-	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+struct CreateViewInfo : public CreateInfo {
+	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
+	}
+	CreateViewInfo(string schema, string view_name)
+	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
 	}
 
-	//! Name of the Type
-	string name;
-	//! Logical Type
-	LogicalType type;
+	//! Table name to insert to
+	string view_name;
+	//! Aliases of the view
+	vector<string> aliases;
+	//! Return types
+	vector<LogicalType> types;
+	//! The SelectStatement of the view
+	unique_ptr<SelectStatement> query;
 
 public:
 	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateTypeInfo>();
+		auto result = make_unique<CreateViewInfo>(schema, view_name);
 		CopyProperties(*result);
-		result->name = name;
-		result->type = type;
+		result->aliases = aliases;
+		result->types = types;
+		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
 		return move(result);
 	}
 };
@@ -24295,7 +24299,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/subqueryref.hpp
+// duckdb/parser/tableref/emptytableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24304,17 +24308,12 @@ public:
 
 
 
-
 namespace duckdb {
-//! Represents a subquery
-class SubqueryRef : public TableRef {
+//! Represents a cross product
+class EmptyTableRef : public TableRef {
 public:
-	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
-
-	//! The subquery
-	unique_ptr<SelectStatement> subquery;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
+	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
+	}
 
 public:
 	string ToString() const override;
@@ -24322,16 +24321,16 @@ public:
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a SubqueryRef
+	//! Serializes a blob into a DummyTableRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a SubqueryRef
+	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/expressionlistref.hpp
+// duckdb/parser/tableref/joinref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24343,19 +24342,26 @@ 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:
 	string ToString() const override;
@@ -24363,13 +24369,12 @@ public:
 
 	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
 //
@@ -24407,10 +24412,12 @@ public:
 };
 } // namespace duckdb
 
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/emptytableref.hpp
+// duckdb/parser/tableref/expressionlistref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24419,22 +24426,32 @@ 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:
 	string ToString() const override;
 	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
@@ -24443,7 +24460,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/joinref.hpp
+// duckdb/parser/tableref/subqueryref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -24453,28 +24470,16 @@ public:
 
 
 
-
-
-
 namespace duckdb {
-//! Represents a JOIN between two expressions
-class JoinRef : public TableRef {
+//! Represents a subquery
+class SubqueryRef : public TableRef {
 public:
-	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
-	}
+	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
 
-	//! 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;
+	//! The subquery
+	unique_ptr<SelectStatement> subquery;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
 public:
 	string ToString() const override;
@@ -24482,14 +24487,13 @@ public:
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a JoinRef
+	//! Serializes a blob into a SubqueryRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a JoinRef
+	//! Deserializes a blob back into a SubqueryRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //