duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

package/src/duckdb/src/parser/parsed_expression_iterator.cpp

@@ -29,14 +29,14 @@ void ParsedExpressionIterator::EnumerateChildren(
     ParsedExpression &expr, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
 	switch (expr.expression_class) {
 	case ExpressionClass::BETWEEN: {
-		auto &cast_expr = (BetweenExpression &)expr;
+		auto &cast_expr = expr.Cast<BetweenExpression>();
 		callback(cast_expr.input);
 		callback(cast_expr.lower);
 		callback(cast_expr.upper);
 		break;
 	}
 	case ExpressionClass::CASE: {
-		auto &case_expr = (CaseExpression &)expr;
+		auto &case_expr = expr.Cast<CaseExpression>();
 		for (auto &check : case_expr.case_checks) {
 			callback(check.when_expr);
 			callback(check.then_expr);
@@ -45,23 +45,23 @@ void ParsedExpressionIterator::EnumerateChildren(
 		break;
 	}
 	case ExpressionClass::CAST: {
-		auto &cast_expr = (CastExpression &)expr;
+		auto &cast_expr = expr.Cast<CastExpression>();
 		callback(cast_expr.child);
 		break;
 	}
 	case ExpressionClass::COLLATE: {
-		auto &cast_expr = (CollateExpression &)expr;
+		auto &cast_expr = expr.Cast<CollateExpression>();
 		callback(cast_expr.child);
 		break;
 	}
 	case ExpressionClass::COMPARISON: {
-		auto &comp_expr = (ComparisonExpression &)expr;
+		auto &comp_expr = expr.Cast<ComparisonExpression>();
 		callback(comp_expr.left);
 		callback(comp_expr.right);
 		break;
 	}
 	case ExpressionClass::CONJUNCTION: {
-		auto &conj_expr = (ConjunctionExpression &)expr;
+		auto &conj_expr = expr.Cast<ConjunctionExpression>();
 		for (auto &child : conj_expr.children) {
 			callback(child);
 		}
@@ -69,7 +69,7 @@ void ParsedExpressionIterator::EnumerateChildren(
 	}
 
 	case ExpressionClass::FUNCTION: {
-		auto &func_expr = (FunctionExpression &)expr;
+		auto &func_expr = expr.Cast<FunctionExpression>();
 		for (auto &child : func_expr.children) {
 			callback(child);
 		}
@@ -84,27 +84,34 @@ void ParsedExpressionIterator::EnumerateChildren(
 		break;
 	}
 	case ExpressionClass::LAMBDA: {
-		auto &lambda_expr = (LambdaExpression &)expr;
+		auto &lambda_expr = expr.Cast<LambdaExpression>();
 		callback(lambda_expr.lhs);
 		callback(lambda_expr.expr);
 		break;
 	}
 	case ExpressionClass::OPERATOR: {
-		auto &op_expr = (OperatorExpression &)expr;
+		auto &op_expr = expr.Cast<OperatorExpression>();
 		for (auto &child : op_expr.children) {
 			callback(child);
 		}
 		break;
 	}
+	case ExpressionClass::STAR: {
+		auto &star_expr = expr.Cast<StarExpression>();
+		if (star_expr.expr) {
+			callback(star_expr.expr);
+		}
+		break;
+	}
 	case ExpressionClass::SUBQUERY: {
-		auto &subquery_expr = (SubqueryExpression &)expr;
+		auto &subquery_expr = expr.Cast<SubqueryExpression>();
 		if (subquery_expr.child) {
 			callback(subquery_expr.child);
 		}
 		break;
 	}
 	case ExpressionClass::WINDOW: {
-		auto &window_expr = (WindowExpression &)expr;
+		auto &window_expr = expr.Cast<WindowExpression>();
 		for (auto &partition : window_expr.partitions) {
 			callback(partition);
 		}
@@ -135,7 +142,6 @@ void ParsedExpressionIterator::EnumerateChildren(
 	case ExpressionClass::COLUMN_REF:
 	case ExpressionClass::CONSTANT:
 	case ExpressionClass::DEFAULT:
-	case ExpressionClass::STAR:
 	case ExpressionClass::PARAMETER:
 	case ExpressionClass::POSITIONAL_REFERENCE:
 		// these node types have no children
@@ -196,7 +202,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
     TableRef &ref, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
 	switch (ref.type) {
 	case TableReferenceType::EXPRESSION_LIST: {
-		auto &el_ref = (ExpressionListRef &)ref;
+		auto &el_ref = ref.Cast<ExpressionListRef>();
 		for (idx_t i = 0; i < el_ref.values.size(); i++) {
 			for (idx_t j = 0; j < el_ref.values[i].size(); j++) {
 				callback(el_ref.values[i][j]);
@@ -205,7 +211,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 		break;
 	}
 	case TableReferenceType::JOIN: {
-		auto &j_ref = (JoinRef &)ref;
+		auto &j_ref = ref.Cast<JoinRef>();
 		EnumerateTableRefChildren(*j_ref.left, callback);
 		EnumerateTableRefChildren(*j_ref.right, callback);
 		if (j_ref.condition) {
@@ -214,7 +220,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 		break;
 	}
 	case TableReferenceType::PIVOT: {
-		auto &p_ref = (PivotRef &)ref;
+		auto &p_ref = ref.Cast<PivotRef>();
 		EnumerateTableRefChildren(*p_ref.source, callback);
 		for (auto &aggr : p_ref.aggregates) {
 			callback(aggr);
@@ -222,12 +228,12 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 		break;
 	}
 	case TableReferenceType::SUBQUERY: {
-		auto &sq_ref = (SubqueryRef &)ref;
+		auto &sq_ref = ref.Cast<SubqueryRef>();
 		EnumerateQueryNodeChildren(*sq_ref.subquery->node, callback);
 		break;
 	}
 	case TableReferenceType::TABLE_FUNCTION: {
-		auto &tf_ref = (TableFunctionRef &)ref;
+		auto &tf_ref = ref.Cast<TableFunctionRef>();
 		callback(tf_ref.function);
 		break;
 	}
@@ -245,13 +251,13 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
     QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
 	switch (node.type) {
 	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &rcte_node = (RecursiveCTENode &)node;
+		auto &rcte_node = node.Cast<RecursiveCTENode>();
 		EnumerateQueryNodeChildren(*rcte_node.left, callback);
 		EnumerateQueryNodeChildren(*rcte_node.right, callback);
 		break;
 	}
 	case QueryNodeType::SELECT_NODE: {
-		auto &sel_node = (SelectNode &)node;
+		auto &sel_node = node.Cast<SelectNode>();
 		for (idx_t i = 0; i < sel_node.select_list.size(); i++) {
 			callback(sel_node.select_list[i]);
 		}
@@ -272,7 +278,7 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
 		break;
 	}
 	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &setop_node = (SetOperationNode &)node;
+		auto &setop_node = node.Cast<SetOperationNode>();
 		EnumerateQueryNodeChildren(*setop_node.left, callback);
 		EnumerateQueryNodeChildren(*setop_node.right, callback);
 		break;

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

@@ -125,7 +125,7 @@ end:
 }
 
 void Parser::ParseQuery(const string &query) {
-	Transformer transformer(options.max_expression_depth);
+	Transformer transformer(options);
 	string parser_error;
 	{
 		// check if there are any unicode spaces in the string
@@ -159,7 +159,7 @@ void Parser::ParseQuery(const string &query) {
 				D_ASSERT(ext.parse_function);
 				auto result = ext.parse_function(ext.parser_info.get(), query);
 				if (result.type == ParserExtensionResultType::PARSE_SUCCESSFUL) {
-					auto statement = make_unique<ExtensionStatement>(ext, std::move(result.parse_data));
+					auto statement = make_uniq<ExtensionStatement>(ext, std::move(result.parse_data));
 					statement->stmt_length = query.size();
 					statement->stmt_location = 0;
 					statements.push_back(std::move(statement));
@@ -178,7 +178,7 @@ void Parser::ParseQuery(const string &query) {
 		for (auto &statement : statements) {
 			statement->query = query;
 			if (statement->type == StatementType::CREATE_STATEMENT) {
-				auto &create = (CreateStatement &)*statement;
+				auto &create = statement->Cast<CreateStatement>();
 				create.info->sql = query.substr(statement->stmt_location, statement->stmt_length);
 			}
 		}
@@ -261,11 +261,11 @@ vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &s
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
 		throw ParserException("Expected a single SELECT statement");
 	}
-	auto &select = (SelectStatement &)*parser.statements[0];
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
 	if (select.node->type != QueryNodeType::SELECT_NODE) {
 		throw ParserException("Expected a single SELECT node");
 	}
-	auto &select_node = (SelectNode &)*select.node;
+	auto &select_node = select.node->Cast<SelectNode>();
 	return std::move(select_node.select_list);
 }
 
@@ -279,11 +279,11 @@ vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOpti
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
 		throw ParserException("Expected a single SELECT statement");
 	}
-	auto &select = (SelectStatement &)*parser.statements[0];
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
 	if (select.node->type != QueryNodeType::SELECT_NODE) {
 		throw ParserException("Expected a single SELECT node");
 	}
-	auto &select_node = (SelectNode &)*select.node;
+	auto &select_node = select.node->Cast<SelectNode>();
 	if (select_node.modifiers.empty() || select_node.modifiers[0]->type != ResultModifierType::ORDER_MODIFIER ||
 	    select_node.modifiers.size() != 1) {
 		throw ParserException("Expected a single ORDER clause");
@@ -303,7 +303,7 @@ void Parser::ParseUpdateList(const string &update_list, vector<string> &update_c
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::UPDATE_STATEMENT) {
 		throw ParserException("Expected a single UPDATE statement");
 	}
-	auto &update = (UpdateStatement &)*parser.statements[0];
+	auto &update = parser.statements[0]->Cast<UpdateStatement>();
 	update_columns = std::move(update.set_info->columns);
 	expressions = std::move(update.set_info->expressions);
 }
@@ -318,15 +318,15 @@ vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const strin
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
 		throw ParserException("Expected a single SELECT statement");
 	}
-	auto &select = (SelectStatement &)*parser.statements[0];
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
 	if (select.node->type != QueryNodeType::SELECT_NODE) {
 		throw ParserException("Expected a single SELECT node");
 	}
-	auto &select_node = (SelectNode &)*select.node;
+	auto &select_node = select.node->Cast<SelectNode>();
 	if (!select_node.from_table || select_node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
 		throw ParserException("Expected a single VALUES statement");
 	}
-	auto &values_list = (ExpressionListRef &)*select_node.from_table;
+	auto &values_list = select_node.from_table->Cast<ExpressionListRef>();
 	return std::move(values_list.values);
 }
 
@@ -337,7 +337,7 @@ ColumnList Parser::ParseColumnList(const string &column_list, ParserOptions opti
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
 		throw ParserException("Expected a single CREATE statement");
 	}
-	auto &create = (CreateStatement &)*parser.statements[0];
+	auto &create = parser.statements[0]->Cast<CreateStatement>();
 	if (create.info->type != CatalogType::TABLE_ENTRY) {
 		throw InternalException("Expected a single CREATE TABLE statement");
 	}

package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -21,22 +23,22 @@ bool RecursiveCTENode::Equals(const QueryNode *other_p) const {
 	if (this == other_p) {
 		return true;
 	}
-	auto other = (RecursiveCTENode *)other_p;
+	auto &other = other_p->Cast<RecursiveCTENode>();
 
-	if (other->union_all != union_all) {
+	if (other.union_all != union_all) {
 		return false;
 	}
-	if (!left->Equals(other->left.get())) {
+	if (!left->Equals(other.left.get())) {
 		return false;
 	}
-	if (!right->Equals(other->right.get())) {
+	if (!right->Equals(other.right.get())) {
 		return false;
 	}
 	return true;
 }
 
 unique_ptr<QueryNode> RecursiveCTENode::Copy() const {
-	auto result = make_unique<RecursiveCTENode>();
+	auto result = make_uniq<RecursiveCTENode>();
 	result->ctename = ctename;
 	result->union_all = union_all;
 	result->left = left->Copy();
@@ -55,7 +57,7 @@ void RecursiveCTENode::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<QueryNode> RecursiveCTENode::Deserialize(FieldReader &reader) {
-	auto result = make_unique<RecursiveCTENode>();
+	auto result = make_uniq<RecursiveCTENode>();
 	result->ctename = reader.ReadRequired<string>();
 	result->union_all = reader.ReadRequired<bool>();
 	result->left = reader.ReadRequiredSerializable<QueryNode>();
@@ -64,4 +66,23 @@ unique_ptr<QueryNode> RecursiveCTENode::Deserialize(FieldReader &reader) {
 	return std::move(result);
 }
 
+void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("cte_name", ctename);
+	serializer.WriteProperty("union_all", union_all);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+	serializer.WriteProperty("aliases", aliases);
+}
+
+unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_uniq<RecursiveCTENode>();
+	deserializer.ReadProperty("cte_name", result->ctename);
+	deserializer.ReadProperty("union_all", result->union_all);
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	deserializer.ReadProperty("aliases", result->aliases);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/query_node/select_node.cpp

@@ -2,6 +2,8 @@
 #include "duckdb/parser/expression_util.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -111,50 +113,50 @@ bool SelectNode::Equals(const QueryNode *other_p) const {
 	if (this == other_p) {
 		return true;
 	}
-	auto other = (SelectNode *)other_p;
+	auto &other = other_p->Cast<SelectNode>();
 
 	// SELECT
-	if (!ExpressionUtil::ListEquals(select_list, other->select_list)) {
+	if (!ExpressionUtil::ListEquals(select_list, other.select_list)) {
 		return false;
 	}
 	// FROM
 	if (from_table) {
 		// we have a FROM clause, compare to the other one
-		if (!from_table->Equals(other->from_table.get())) {
+		if (!from_table->Equals(other.from_table.get())) {
 			return false;
 		}
-	} else if (other->from_table) {
+	} else if (other.from_table) {
 		// we don't have a FROM clause, if the other statement has one they are
 		// not equal
 		return false;
 	}
 	// WHERE
-	if (!BaseExpression::Equals(where_clause.get(), other->where_clause.get())) {
+	if (!BaseExpression::Equals(where_clause.get(), other.where_clause.get())) {
 		return false;
 	}
 	// GROUP BY
-	if (!ExpressionUtil::ListEquals(groups.group_expressions, other->groups.group_expressions)) {
+	if (!ExpressionUtil::ListEquals(groups.group_expressions, other.groups.group_expressions)) {
 		return false;
 	}
-	if (groups.grouping_sets != other->groups.grouping_sets) {
+	if (groups.grouping_sets != other.groups.grouping_sets) {
 		return false;
 	}
-	if (!SampleOptions::Equals(sample.get(), other->sample.get())) {
+	if (!SampleOptions::Equals(sample.get(), other.sample.get())) {
 		return false;
 	}
 	// HAVING
-	if (!BaseExpression::Equals(having.get(), other->having.get())) {
+	if (!BaseExpression::Equals(having.get(), other.having.get())) {
 		return false;
 	}
 	// QUALIFY
-	if (!BaseExpression::Equals(qualify.get(), other->qualify.get())) {
+	if (!BaseExpression::Equals(qualify.get(), other.qualify.get())) {
 		return false;
 	}
 	return true;
 }
 
 unique_ptr<QueryNode> SelectNode::Copy() const {
-	auto result = make_unique<SelectNode>();
+	auto result = make_uniq<SelectNode>();
 	for (auto &child : select_list) {
 		result->select_list.push_back(child->Copy());
 	}
@@ -192,8 +194,37 @@ void SelectNode::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(qualify);
 }
 
+void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("select_list", select_list);
+	serializer.WriteOptionalProperty("from_table", from_table);
+	serializer.WriteOptionalProperty("where_clause", where_clause);
+	serializer.WriteProperty("group_expressions", groups.group_expressions);
+	serializer.WriteProperty("group_sets", groups.grouping_sets);
+	serializer.WriteProperty("aggregate_handling", aggregate_handling);
+	serializer.WriteOptionalProperty("having", having);
+	serializer.WriteOptionalProperty("sample", sample);
+	serializer.WriteOptionalProperty("qualify", qualify);
+}
+
+unique_ptr<QueryNode> SelectNode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_uniq<SelectNode>();
+
+	deserializer.ReadProperty("select_list", result->select_list);
+	deserializer.ReadOptionalProperty("from_table", result->from_table);
+	deserializer.ReadOptionalProperty("where_clause", result->where_clause);
+	deserializer.ReadProperty("group_expressions", result->groups.group_expressions);
+	deserializer.ReadProperty("group_sets", result->groups.grouping_sets);
+	deserializer.ReadProperty("aggregate_handling", result->aggregate_handling);
+	deserializer.ReadOptionalProperty("having", result->having);
+	deserializer.ReadOptionalProperty("sample", result->sample);
+	deserializer.ReadOptionalProperty("qualify", result->qualify);
+
+	return std::move(result);
+}
+
 unique_ptr<QueryNode> SelectNode::Deserialize(FieldReader &reader) {
-	auto result = make_unique<SelectNode>();
+	auto result = make_uniq<SelectNode>();
 	result->select_list = reader.ReadRequiredSerializableList<ParsedExpression>();
 	result->from_table = reader.ReadOptional<TableRef>(nullptr);
 	result->where_clause = reader.ReadOptional<ParsedExpression>(nullptr);

package/src/duckdb/src/parser/query_node/set_operation_node.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -45,21 +47,21 @@ bool SetOperationNode::Equals(const QueryNode *other_p) const {
 	if (this == other_p) {
 		return true;
 	}
-	auto other = (SetOperationNode *)other_p;
-	if (setop_type != other->setop_type) {
+	auto &other = other_p->Cast<SetOperationNode>();
+	if (setop_type != other.setop_type) {
 		return false;
 	}
-	if (!left->Equals(other->left.get())) {
+	if (!left->Equals(other.left.get())) {
 		return false;
 	}
-	if (!right->Equals(other->right.get())) {
+	if (!right->Equals(other.right.get())) {
 		return false;
 	}
 	return true;
 }
 
 unique_ptr<QueryNode> SetOperationNode::Copy() const {
-	auto result = make_unique<SetOperationNode>();
+	auto result = make_uniq<SetOperationNode>();
 	result->setop_type = setop_type;
 	result->left = left->Copy();
 	result->right = right->Copy();
@@ -74,11 +76,26 @@ void SetOperationNode::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
-	auto result = make_unique<SetOperationNode>();
+	auto result = make_uniq<SetOperationNode>();
 	result->setop_type = reader.ReadRequired<SetOperationType>();
 	result->left = reader.ReadRequiredSerializable<QueryNode>();
 	result->right = reader.ReadRequiredSerializable<QueryNode>();
 	return std::move(result);
 }
 
+void SetOperationNode::FormatSerialize(duckdb::FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("set_op_type", setop_type);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+}
+
+unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(duckdb::FormatDeserializer &deserializer) {
+	auto result = make_uniq<SetOperationNode>();
+	deserializer.ReadProperty("set_op_type", result->setop_type);
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/query_node.cpp

@@ -5,6 +5,8 @@
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -14,7 +16,7 @@ CommonTableExpressionMap::CommonTableExpressionMap() {
 CommonTableExpressionMap CommonTableExpressionMap::Copy() const {
 	CommonTableExpressionMap res;
 	for (auto &kv : this->map) {
-		auto kv_info = make_unique<CommonTableExpressionInfo>();
+		auto kv_info = make_uniq<CommonTableExpressionInfo>();
 		for (auto &al : kv.second->aliases) {
 			kv_info->aliases.push_back(al);
 		}
@@ -65,6 +67,16 @@ string CommonTableExpressionMap::ToString() const {
 	return result;
 }
 
+void CommonTableExpressionMap::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("map", map);
+}
+
+CommonTableExpressionMap CommonTableExpressionMap::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = CommonTableExpressionMap();
+	deserializer.ReadProperty("map", result.map);
+	return result;
+}
+
 string QueryNode::ResultModifiersToString() const {
 	string result;
 	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
@@ -141,7 +153,7 @@ void QueryNode::CopyProperties(QueryNode &other) const {
 		other.modifiers.push_back(modifier->Copy());
 	}
 	for (auto &kv : cte_map.map) {
-		auto kv_info = make_unique<CommonTableExpressionInfo>();
+		auto kv_info = make_uniq<CommonTableExpressionInfo>();
 		for (auto &al : kv.second->aliases) {
 			kv_info->aliases.push_back(al);
 		}
@@ -155,6 +167,7 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
 	writer.WriteField<QueryNodeType>(type);
 	writer.WriteSerializableList(modifiers);
 	// cte_map
+
 	writer.WriteField<uint32_t>((uint32_t)cte_map.map.size());
 	auto &serializer = writer.GetSerializer();
 	for (auto &cte : cte_map.map) {
@@ -163,9 +176,46 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
 		cte.second->query->Serialize(serializer);
 	}
 	Serialize(writer);
+
 	writer.Finalize();
 }
 
+// Children should call the base method before their own.
+void QueryNode::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("modifiers", modifiers);
+	serializer.WriteProperty("cte_map", cte_map);
+}
+
+unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deserializer) {
+
+	auto type = deserializer.ReadProperty<QueryNodeType>("type");
+
+	auto modifiers = deserializer.ReadProperty<vector<unique_ptr<ResultModifier>>>("modifiers");
+	auto cte_map = deserializer.ReadProperty<CommonTableExpressionMap>("cte_map");
+
+	unique_ptr<QueryNode> result;
+
+	switch (type) {
+	case QueryNodeType::SELECT_NODE:
+		result = SelectNode::FormatDeserialize(deserializer);
+		break;
+	case QueryNodeType::SET_OPERATION_NODE:
+		result = SetOperationNode::FormatDeserialize(deserializer);
+		break;
+	case QueryNodeType::RECURSIVE_CTE_NODE:
+		result = RecursiveCTENode::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Could not deserialize Query Node: unknown type!");
+	}
+
+	result->type = type;
+	result->modifiers = std::move(modifiers);
+	result->cte_map = std::move(cte_map);
+	return result;
+}
+
 unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	FieldReader reader(main_source);
 
@@ -177,7 +227,7 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	case_insensitive_map_t<unique_ptr<CommonTableExpressionInfo>> new_map;
 	for (idx_t i = 0; i < cte_count; i++) {
 		auto name = source.Read<string>();
-		auto info = make_unique<CommonTableExpressionInfo>();
+		auto info = make_uniq<CommonTableExpressionInfo>();
 		source.ReadStringVector(info->aliases);
 		info->query = SelectStatement::Deserialize(source);
 		new_map[name] = std::move(info);
@@ -219,7 +269,7 @@ void QueryNode::AddDistinct() {
 			break;
 		}
 	}
-	modifiers.push_back(make_unique<DistinctModifier>());
+	modifiers.push_back(make_uniq<DistinctModifier>());
 }
 
 } // namespace duckdb