duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -6,6 +6,9 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 FunctionExpression::FunctionExpression(string catalog, string schema, const string &function_name,
@@ -18,7 +21,7 @@ FunctionExpression::FunctionExpression(string catalog, string schema, const stri
       export_state(export_state_p) {
 	D_ASSERT(!function_name.empty());
 	if (!order_bys) {
-		order_bys = make_unique<OrderModifier>();
+		order_bys = make_uniq<OrderModifier>();
 	}
 }
 
@@ -71,6 +74,7 @@ hash_t FunctionExpression::Hash() const {
 unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 	vector<unique_ptr<ParsedExpression>> copy_children;
 	unique_ptr<ParsedExpression> filter_copy;
+	copy_children.reserve(children.size());
 	for (auto &child : children) {
 		copy_children.push_back(child->Copy());
 	}
@@ -82,9 +86,9 @@ unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 		order_copy.reset(static_cast<OrderModifier *>(order_bys->Copy().release()));
 	}
 
-	auto copy = make_unique<FunctionExpression>(catalog, schema, function_name, std::move(copy_children),
-	                                            std::move(filter_copy), std::move(order_copy), distinct, is_operator,
-	                                            export_state);
+	auto copy =
+	    make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(copy_children), std::move(filter_copy),
+	                                  std::move(order_copy), distinct, is_operator, export_state);
 	copy->CopyProperties(*this);
 	return std::move(copy);
 }
@@ -113,8 +117,8 @@ unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type
 	auto catalog = reader.ReadField<string>(INVALID_CATALOG);
 
 	unique_ptr<FunctionExpression> function;
-	function = make_unique<FunctionExpression>(catalog, schema, function_name, std::move(children), std::move(filter),
-	                                           std::move(order_bys), distinct, is_operator, export_state);
+	function = make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(children), std::move(filter),
+	                                         std::move(order_bys), distinct, is_operator, export_state);
 	return std::move(function);
 }
 
@@ -122,4 +126,36 @@ void FunctionExpression::Verify() const {
 	D_ASSERT(!function_name.empty());
 }
 
+void FunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("function_name", function_name);
+	serializer.WriteProperty("schema", schema);
+	serializer.WriteProperty("children", children);
+	serializer.WriteOptionalProperty("filter", filter);
+	serializer.WriteProperty("order_bys", (ResultModifier &)*order_bys);
+	serializer.WriteProperty("distinct", distinct);
+	serializer.WriteProperty("is_operator", is_operator);
+	serializer.WriteProperty("export_state", export_state);
+	serializer.WriteProperty("catalog", catalog);
+}
+
+unique_ptr<ParsedExpression> FunctionExpression::FormatDeserialize(ExpressionType type,
+                                                                   FormatDeserializer &deserializer) {
+	auto function_name = deserializer.ReadProperty<string>("function_name");
+	auto schema = deserializer.ReadProperty<string>("schema");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<ParsedExpression>>>("children");
+	auto filter = deserializer.ReadOptionalProperty<unique_ptr<ParsedExpression>>("filter");
+	auto order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(
+	    deserializer.ReadProperty<unique_ptr<ResultModifier>>("order_bys"));
+	auto distinct = deserializer.ReadProperty<bool>("distinct");
+	auto is_operator = deserializer.ReadProperty<bool>("is_operator");
+	auto export_state = deserializer.ReadProperty<bool>("export_state");
+	auto catalog = deserializer.ReadProperty<string>("catalog");
+
+	unique_ptr<FunctionExpression> function;
+	function = make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(children), std::move(filter),
+	                                         std::move(order_bys), distinct, is_operator, export_state);
+	return std::move(function);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/expression/lambda_expression.cpp

@@ -3,6 +3,9 @@
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/string_util.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 LambdaExpression::LambdaExpression(unique_ptr<ParsedExpression> lhs, unique_ptr<ParsedExpression> expr)
@@ -25,7 +28,7 @@ hash_t LambdaExpression::Hash() const {
 }
 
 unique_ptr<ParsedExpression> LambdaExpression::Copy() const {
-	auto copy = make_unique<LambdaExpression>(lhs->Copy(), expr->Copy());
+	auto copy = make_uniq<LambdaExpression>(lhs->Copy(), expr->Copy());
 	copy->CopyProperties(*this);
 	return std::move(copy);
 }
@@ -38,7 +41,20 @@ void LambdaExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto lhs = reader.ReadRequiredSerializable<ParsedExpression>();
 	auto expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_unique<LambdaExpression>(std::move(lhs), std::move(expr));
+	return make_uniq<LambdaExpression>(std::move(lhs), std::move(expr));
+}
+
+void LambdaExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("lhs", *lhs);
+	serializer.WriteProperty("expr", *expr);
+}
+
+unique_ptr<ParsedExpression> LambdaExpression::FormatDeserialize(ExpressionType type,
+                                                                 FormatDeserializer &deserializer) {
+	auto lhs = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("lhs");
+	auto expr = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expr");
+	return make_uniq<LambdaExpression>(std::move(lhs), std::move(expr));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/expression/operator_expression.cpp

@@ -3,6 +3,9 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/field_writer.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 OperatorExpression::OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
@@ -37,7 +40,7 @@ bool OperatorExpression::Equal(const OperatorExpression *a, const OperatorExpres
 }
 
 unique_ptr<ParsedExpression> OperatorExpression::Copy() const {
-	auto copy = make_unique<OperatorExpression>(type);
+	auto copy = make_uniq<OperatorExpression>(type);
 	copy->CopyProperties(*this);
 	for (auto &it : children) {
 		copy->children.push_back(it->Copy());
@@ -50,9 +53,21 @@ void OperatorExpression::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_unique<OperatorExpression>(type);
+	auto expression = make_uniq<OperatorExpression>(type);
 	expression->children = reader.ReadRequiredSerializableList<ParsedExpression>();
 	return std::move(expression);
 }
 
+void OperatorExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("children", children);
+}
+
+unique_ptr<ParsedExpression> OperatorExpression::FormatDeserialize(ExpressionType type,
+                                                                   FormatDeserializer &deserializer) {
+	auto expression = make_uniq<OperatorExpression>(type);
+	expression->children = deserializer.ReadProperty<vector<unique_ptr<ParsedExpression>>>("children");
+	return std::move(expression);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -5,6 +5,9 @@
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 ParameterExpression::ParameterExpression()
@@ -16,7 +19,7 @@ string ParameterExpression::ToString() const {
 }
 
 unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
-	auto copy = make_unique<ParameterExpression>();
+	auto copy = make_uniq<ParameterExpression>();
 	copy->parameter_nr = parameter_nr;
 	copy->CopyProperties(*this);
 	return std::move(copy);
@@ -36,9 +39,21 @@ void ParameterExpression::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_unique<ParameterExpression>();
+	auto expression = make_uniq<ParameterExpression>();
 	expression->parameter_nr = reader.ReadRequired<idx_t>();
 	return std::move(expression);
 }
 
+void ParameterExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("parameter_nr", parameter_nr);
+}
+
+unique_ptr<ParsedExpression> ParameterExpression::FormatDeserialize(ExpressionType type,
+                                                                    FormatDeserializer &deserializer) {
+	auto expression = make_uniq<ParameterExpression>();
+	expression->parameter_nr = deserializer.ReadProperty<idx_t>("parameter_nr");
+	return std::move(expression);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/expression/positional_reference_expression.cpp

@@ -5,6 +5,9 @@
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 PositionalReferenceExpression::PositionalReferenceExpression(idx_t index)
@@ -21,7 +24,7 @@ bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression *a
 }
 
 unique_ptr<ParsedExpression> PositionalReferenceExpression::Copy() const {
-	auto copy = make_unique<PositionalReferenceExpression>(index);
+	auto copy = make_uniq<PositionalReferenceExpression>(index);
 	copy->CopyProperties(*this);
 	return std::move(copy);
 }
@@ -36,7 +39,18 @@ void PositionalReferenceExpression::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_unique<PositionalReferenceExpression>(reader.ReadRequired<idx_t>());
+	auto expression = make_uniq<PositionalReferenceExpression>(reader.ReadRequired<idx_t>());
+	return std::move(expression);
+}
+
+void PositionalReferenceExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("index", index);
+}
+
+unique_ptr<ParsedExpression> PositionalReferenceExpression::FormatDeserialize(ExpressionType type,
+                                                                              FormatDeserializer &deserializer) {
+	auto expression = make_uniq<PositionalReferenceExpression>(deserializer.ReadProperty<idx_t>("index"));
 	return std::move(expression);
 }
 

package/src/duckdb/src/parser/expression/star_expression.cpp

@@ -3,6 +3,9 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/field_writer.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 StarExpression::StarExpression(string relation_name_p)
@@ -10,9 +13,9 @@ StarExpression::StarExpression(string relation_name_p)
 }
 
 string StarExpression::ToString() const {
-	if (!regex.empty()) {
+	if (expr) {
 		D_ASSERT(columns);
-		return "COLUMNS('" + regex + "')";
+		return "COLUMNS(" + expr->ToString() + ")";
 	}
 	string result;
 	if (columns) {
@@ -70,7 +73,7 @@ bool StarExpression::Equal(const StarExpression *a, const StarExpression *b) {
 			return false;
 		}
 	}
-	if (a->regex != b->regex) {
+	if (!BaseExpression::Equals(a->expr.get(), b->expr.get())) {
 		return false;
 	}
 	return true;
@@ -93,13 +96,13 @@ void StarExpression::Serialize(FieldWriter &writer) const {
 		entry.second->Serialize(serializer);
 	}
 	writer.WriteField<bool>(columns);
-	writer.WriteString(regex);
+	writer.WriteOptional(expr);
 }
 
 unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto &source = reader.GetSource();
 
-	auto result = make_unique<StarExpression>();
+	auto result = make_uniq<StarExpression>();
 	result->relation_name = reader.ReadRequired<string>();
 	auto exclusion_count = reader.ReadRequired<uint32_t>();
 	for (idx_t i = 0; i < exclusion_count; i++) {
@@ -112,20 +115,39 @@ unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, Fi
 		result->replace_list.insert(make_pair(name, std::move(expr)));
 	}
 	result->columns = reader.ReadField<bool>(false);
-	result->regex = reader.ReadField<string>(string());
+	result->expr = reader.ReadOptional<ParsedExpression>(nullptr);
 	return std::move(result);
 }
 
 unique_ptr<ParsedExpression> StarExpression::Copy() const {
-	auto copy = make_unique<StarExpression>(relation_name);
+	auto copy = make_uniq<StarExpression>(relation_name);
 	copy->exclude_list = exclude_list;
 	for (auto &entry : replace_list) {
 		copy->replace_list[entry.first] = entry.second->Copy();
 	}
 	copy->columns = columns;
-	copy->regex = regex;
+	copy->expr = expr ? expr->Copy() : nullptr;
 	copy->CopyProperties(*this);
 	return std::move(copy);
 }
 
+void StarExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("relation_name", relation_name);
+	serializer.WriteProperty("exclude_list", exclude_list);
+	serializer.WriteProperty("replace_list", replace_list);
+	serializer.WriteProperty("columns", columns);
+	serializer.WriteOptionalProperty("expr", expr);
+}
+
+unique_ptr<ParsedExpression> StarExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = make_uniq<StarExpression>();
+	deserializer.ReadProperty("relation_name", result->relation_name);
+	deserializer.ReadProperty("exclude_list", result->exclude_list);
+	deserializer.ReadProperty("replace_list", result->replace_list);
+	deserializer.ReadProperty("columns", result->columns);
+	deserializer.ReadOptionalProperty("expr", result->expr);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -2,6 +2,8 @@
 
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
 
 namespace duckdb {
 
@@ -38,7 +40,7 @@ bool SubqueryExpression::Equal(const SubqueryExpression *a, const SubqueryExpres
 }
 
 unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {
-	auto copy = make_unique<SubqueryExpression>();
+	auto copy = make_uniq<SubqueryExpression>();
 	copy->CopyProperties(*this);
 	copy->subquery = unique_ptr_cast<SQLStatement, SelectStatement>(subquery->Copy());
 	copy->subquery_type = subquery_type;
@@ -64,7 +66,7 @@ unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type
 	auto subquery_type = reader.ReadRequired<SubqueryType>();
 	auto subquery = SelectStatement::Deserialize(source);
 
-	auto expression = make_unique<SubqueryExpression>();
+	auto expression = make_uniq<SubqueryExpression>();
 	expression->subquery_type = subquery_type;
 	expression->subquery = std::move(subquery);
 	expression->child = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -72,4 +74,22 @@ unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type
 	return std::move(expression);
 }
 
+void SubqueryExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("subquery_type", subquery_type);
+	serializer.WriteProperty("subquery", *subquery);
+	serializer.WriteOptionalProperty("child", child);
+	serializer.WriteProperty("comparison_type", comparison_type);
+}
+
+unique_ptr<ParsedExpression> SubqueryExpression::FormatDeserialize(ExpressionType type,
+                                                                   FormatDeserializer &deserializer) {
+	auto expression = make_uniq<SubqueryExpression>();
+	deserializer.ReadProperty("subquery_type", expression->subquery_type);
+	deserializer.ReadProperty("subquery", expression->subquery);
+	deserializer.ReadOptionalProperty("child", expression->child);
+	deserializer.ReadProperty("comparison_type", expression->comparison_type);
+	return std::move(expression);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -4,6 +4,10 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 WindowExpression::WindowExpression(ExpressionType type, string catalog_name, string schema, const string &function_name)
@@ -28,6 +32,33 @@ WindowExpression::WindowExpression(ExpressionType type, string catalog_name, str
 	}
 }
 
+ExpressionType WindowExpression::WindowToExpressionType(string &fun_name) {
+	if (fun_name == "rank") {
+		return ExpressionType::WINDOW_RANK;
+	} else if (fun_name == "rank_dense" || fun_name == "dense_rank") {
+		return ExpressionType::WINDOW_RANK_DENSE;
+	} else if (fun_name == "percent_rank") {
+		return ExpressionType::WINDOW_PERCENT_RANK;
+	} else if (fun_name == "row_number") {
+		return ExpressionType::WINDOW_ROW_NUMBER;
+	} else if (fun_name == "first_value" || fun_name == "first") {
+		return ExpressionType::WINDOW_FIRST_VALUE;
+	} else if (fun_name == "last_value" || fun_name == "last") {
+		return ExpressionType::WINDOW_LAST_VALUE;
+	} else if (fun_name == "nth_value") {
+		return ExpressionType::WINDOW_NTH_VALUE;
+	} else if (fun_name == "cume_dist") {
+		return ExpressionType::WINDOW_CUME_DIST;
+	} else if (fun_name == "lead") {
+		return ExpressionType::WINDOW_LEAD;
+	} else if (fun_name == "lag") {
+		return ExpressionType::WINDOW_LAG;
+	} else if (fun_name == "ntile") {
+		return ExpressionType::WINDOW_NTILE;
+	}
+	return ExpressionType::WINDOW_AGGREGATE;
+}
+
 string WindowExpression::ToString() const {
 	return ToString<WindowExpression, ParsedExpression, OrderByNode>(*this, schema, function_name);
 }
@@ -86,7 +117,7 @@ bool WindowExpression::Equal(const WindowExpression *a, const WindowExpression *
 }
 
 unique_ptr<ParsedExpression> WindowExpression::Copy() const {
-	auto new_window = make_unique<WindowExpression>(type, catalog, schema, function_name);
+	auto new_window = make_uniq<WindowExpression>(type, catalog, schema, function_name);
 	new_window->CopyProperties(*this);
 
 	for (auto &child : children) {
@@ -139,10 +170,49 @@ void WindowExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 }
 
+void WindowExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("function_name", function_name);
+	serializer.WriteProperty("schema", schema);
+	serializer.WriteProperty("children", children);
+	serializer.WriteProperty("partitions", partitions);
+	serializer.WriteProperty("orders", orders);
+	serializer.WriteProperty("start", start);
+	serializer.WriteProperty("end", end);
+	serializer.WriteOptionalProperty("start_expr", start_expr);
+	serializer.WriteOptionalProperty("end_expr", end_expr);
+	serializer.WriteOptionalProperty("offset_expr", offset_expr);
+	serializer.WriteOptionalProperty("default_expr", default_expr);
+	serializer.WriteProperty("ignore_nulls", ignore_nulls);
+	serializer.WriteOptionalProperty("filter_expr", filter_expr);
+	serializer.WriteProperty("catalog", catalog);
+}
+
+unique_ptr<ParsedExpression> WindowExpression::FormatDeserialize(ExpressionType type,
+                                                                 FormatDeserializer &deserializer) {
+	auto function_name = deserializer.ReadProperty<string>("function_name");
+	auto schema = deserializer.ReadProperty<string>("schema");
+	auto expr = make_uniq<WindowExpression>(type, INVALID_CATALOG, std::move(schema), function_name);
+
+	deserializer.ReadProperty("children", expr->children);
+	deserializer.ReadProperty("partitions", expr->partitions);
+	deserializer.ReadProperty("orders", expr->orders);
+	deserializer.ReadProperty("start", expr->start);
+	deserializer.ReadProperty("end", expr->end);
+	deserializer.ReadOptionalProperty("start_expr", expr->start_expr);
+	deserializer.ReadOptionalProperty("end_expr", expr->end_expr);
+	deserializer.ReadOptionalProperty("offset_expr", expr->offset_expr);
+	deserializer.ReadOptionalProperty("default_expr", expr->default_expr);
+	deserializer.ReadProperty("ignore_nulls", expr->ignore_nulls);
+	deserializer.ReadOptionalProperty("filter_expr", expr->filter_expr);
+	deserializer.ReadProperty("catalog", expr->catalog);
+	return std::move(expr);
+}
+
 unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto function_name = reader.ReadRequired<string>();
 	auto schema = reader.ReadRequired<string>();
-	auto expr = make_unique<WindowExpression>(type, INVALID_CATALOG, std::move(schema), function_name);
+	auto expr = make_uniq<WindowExpression>(type, INVALID_CATALOG, std::move(schema), function_name);
 	expr->children = reader.ReadRequiredSerializableList<ParsedExpression>();
 	expr->partitions = reader.ReadRequiredSerializableList<ParsedExpression>();
 

package/src/duckdb/src/parser/expression_util.cpp

@@ -18,7 +18,7 @@ bool ExpressionUtil::ExpressionListEquals(const vector<unique_ptr<T>> &a, const
 	return true;
 }
 
-template <class T>
+template <class T, class EXPRESSION_MAP>
 bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const vector<unique_ptr<T>> &b) {
 	if (a.size() != b.size()) {
 		return false;
@@ -26,14 +26,14 @@ bool ExpressionUtil::ExpressionSetEquals(const vector<unique_ptr<T>> &a, const v
 	// we create a map of expression -> count for the left side
 	// we keep the count because the same expression can occur multiple times (e.g. "1 AND 1" is legal)
 	// in this case we track the following value: map["Constant(1)"] = 2
-	expression_map_t<idx_t> map;
+	EXPRESSION_MAP map;
 	for (idx_t i = 0; i < a.size(); i++) {
-		map[a[i].get()]++;
+		map[*a[i]]++;
 	}
 	// now on the right side we reduce the counts again
 	// if the conjunctions are identical, all the counts will be 0 after the
 	for (auto &expr : b) {
-		auto entry = map.find(expr.get());
+		auto entry = map.find(*expr);
 		// first we check if we can find the expression in the map at all
 		if (entry == map.end()) {
 			return false;
@@ -62,11 +62,11 @@ bool ExpressionUtil::ListEquals(const vector<unique_ptr<Expression>> &a, const v
 
 bool ExpressionUtil::SetEquals(const vector<unique_ptr<ParsedExpression>> &a,
                                const vector<unique_ptr<ParsedExpression>> &b) {
-	return ExpressionSetEquals<ParsedExpression>(a, b);
+	return ExpressionSetEquals<ParsedExpression, parsed_expression_map_t<idx_t>>(a, b);
 }
 
 bool ExpressionUtil::SetEquals(const vector<unique_ptr<Expression>> &a, const vector<unique_ptr<Expression>> &b) {
-	return ExpressionSetEquals<Expression>(a, b);
+	return ExpressionSetEquals<Expression, expression_map_t<idx_t>>(a, b);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/alter_info.cpp

@@ -7,8 +7,8 @@
 
 namespace duckdb {
 
-AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, bool if_exists)
-    : type(type), if_exists(if_exists), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
+AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
+    : type(type), if_not_found(if_not_found), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
       name(std::move(name_p)), allow_internal(false) {
 }
 
@@ -53,7 +53,7 @@ AlterEntryData AlterInfo::GetAlterEntryData() const {
 	data.catalog = catalog;
 	data.schema = schema;
 	data.name = name;
-	data.if_exists = if_exists;
+	data.if_not_found = if_not_found;
 	return data;
 }
 

package/src/duckdb/src/parser/parsed_data/alter_scalar_function_info.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 AlterScalarFunctionInfo::AlterScalarFunctionInfo(AlterScalarFunctionType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_SCALAR_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_scalar_function_type(type) {
 }
 AlterScalarFunctionInfo::~AlterScalarFunctionInfo() {
@@ -25,7 +25,7 @@ void AlterScalarFunctionInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField(if_exists);
+	writer.WriteField(if_not_found);
 }
 
 unique_ptr<AlterInfo> AlterScalarFunctionInfo::Deserialize(FieldReader &reader) {
@@ -50,7 +50,7 @@ AddScalarFunctionOverloadInfo::~AddScalarFunctionOverloadInfo() {
 }
 
 unique_ptr<AlterInfo> AddScalarFunctionOverloadInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddScalarFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
+	return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/alter_table_function_info.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 AlterTableFunctionInfo::AlterTableFunctionInfo(AlterTableFunctionType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_TABLE_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_table_function_type(type) {
 }
 AlterTableFunctionInfo::~AlterTableFunctionInfo() {
@@ -25,7 +25,7 @@ void AlterTableFunctionInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField(if_exists);
+	writer.WriteField(if_not_found);
 }
 
 unique_ptr<AlterInfo> AlterTableFunctionInfo::Deserialize(FieldReader &reader) {
@@ -45,7 +45,7 @@ AddTableFunctionOverloadInfo::~AddTableFunctionOverloadInfo() {
 }
 
 unique_ptr<AlterInfo> AddTableFunctionOverloadInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddTableFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
+	return make_uniq_base<AlterInfo, AddTableFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
 }
 
 } // namespace duckdb