duckdb 0.7.2-dev717.0 → 0.7.2-dev832.0

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

@@ -16,14 +16,19 @@
 namespace duckdb {
 class FieldWriter;
 class FieldReader;
+class FormatDeserializer;
+class FormatSerializer;
 
-enum ResultModifierType : uint8_t {
+enum class ResultModifierType : uint8_t {
 	LIMIT_MODIFIER = 1,
 	ORDER_MODIFIER = 2,
 	DISTINCT_MODIFIER = 3,
 	LIMIT_PERCENT_MODIFIER = 4
 };
 
+const char *ToString(ResultModifierType value);
+ResultModifierType ResultModifierFromString(const char *value);
+
 //! A ResultModifier
 class ResultModifier {
 public:
@@ -46,6 +51,9 @@ public:
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a ResultModifier
 	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 //! Single node in ORDER BY statement
@@ -65,6 +73,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	string ToString() const;
 	static OrderByNode Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static OrderByNode FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitModifier : public ResultModifier {
@@ -82,6 +93,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class OrderModifier : public ResultModifier {
@@ -97,6 +111,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class DistinctModifier : public ResultModifier {
@@ -112,6 +129,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitPercentModifier : public ResultModifier {
@@ -129,6 +149,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -19,7 +19,8 @@ namespace duckdb {
 //! SQLStatement is the base class of any type of SQL statement.
 class SQLStatement {
 public:
-	explicit SQLStatement(StatementType type) : type(type) {};
+	explicit SQLStatement(StatementType type) : type(type) {
+	}
 	virtual ~SQLStatement() {
 	}
 

package/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp

@@ -10,13 +10,15 @@
 
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/parser/tableref.hpp"
+#include "duckdb/parser/query_node.hpp"
 
 namespace duckdb {
 
 class QueryNode;
+class FormatSerializer;
+class FormatDeserializer;
 
 //! SelectStatement is a typical SELECT clause
 class SelectStatement : public SQLStatement {
@@ -42,5 +44,8 @@ public:
 	static unique_ptr<SelectStatement> Deserialize(Deserializer &source);
 	//! Whether or not the statements are equivalent
 	bool Equals(const SQLStatement *other) const;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<SelectStatement> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp

@@ -38,5 +38,9 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp

@@ -27,5 +27,7 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp

@@ -37,5 +37,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a ExpressionListRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp

@@ -47,5 +47,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp

@@ -24,6 +24,9 @@ struct PivotColumnEntry {
 	void Serialize(Serializer &serializer) const;
 	PivotColumnEntry Copy() const;
 	static PivotColumnEntry Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumnEntry FormatDeserialize(FormatDeserializer &source);
 };
 
 struct PivotColumn {
@@ -39,6 +42,9 @@ struct PivotColumn {
 	void Serialize(Serializer &serializer) const;
 	PivotColumn Copy() const;
 	static PivotColumn Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumn FormatDeserialize(FormatDeserializer &source);
 };
 
 //! Represents a PIVOT or UNPIVOT expression
@@ -72,5 +78,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp

@@ -32,5 +32,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a SubqueryRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp

@@ -40,5 +40,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

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

@@ -48,8 +48,10 @@ public:
 	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a TableRef
 	DUCKDB_API static unique_ptr<TableRef> Deserialize(Deserializer &source);
-
 	//! Copy the properties of this table ref to the target
 	void CopyProperties(TableRef &target) const;
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -206,8 +206,13 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		if (exact_match) {
 			message += "\nAre you using a development build? In this case, extensions might not (yet) be uploaded.";
 		}
-		throw HTTPException(res.value().status, res->body, "Failed to download extension \"%s\" at URL \"%s%s\"\n%s",
-		                    extension_name, url_base, url_local_part, message);
+		if (res.error() == duckdb_httplib::Error::Success) {
+			throw HTTPException(res.value(), "Failed to download extension \"%s\" at URL \"%s%s\"\n%s", extension_name,
+			                    url_base, url_local_part, message);
+		} else {
+			throw IOException("Failed to download extension \"%s\" at URL \"%s%s\"\n%s (ERROR %s)", extension_name,
+			                  url_base, url_local_part, message, to_string(res.error()));
+		}
 	}
 	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
 	std::ofstream out(temp_path, std::ios::binary);

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -424,7 +424,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 			parent_expr =
 			    make_unique<BoundColumnRefExpression>(parent_expr->alias, parent_expr->return_type, it->first);
 			parent_cond.comparison =
-			    parent_delim_get_side == 0 ? child_cond.comparison : FlipComparisionExpression(child_cond.comparison);
+			    parent_delim_get_side == 0 ? child_cond.comparison : FlipComparisonExpression(child_cond.comparison);
 			break;
 		}
 	}

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -604,7 +604,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 
 		// create the ExpressionValueInformation
 		ExpressionValueInformation info;
-		info.comparison_type = left_is_scalar ? FlipComparisionExpression(comparison.type) : comparison.type;
+		info.comparison_type = left_is_scalar ? FlipComparisonExpression(comparison.type) : comparison.type;
 		info.constant = constant_value;
 
 		// get the current bucket of constant values

package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp

@@ -138,7 +138,7 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 					std::swap(join.children[0], join.children[1]);
 					for (auto &cond : join.conditions) {
 						std::swap(cond.left, cond.right);
-						cond.comparison = FlipComparisionExpression(cond.comparison);
+						cond.comparison = FlipComparisonExpression(cond.comparison);
 					}
 				}
 			}
@@ -769,7 +769,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 
 				if (invert) {
 					// reverse comparison expression if we reverse the order of the children
-					cond.comparison = FlipComparisionExpression(cond.comparison);
+					cond.comparison = FlipComparisonExpression(cond.comparison);
 				}
 				join->conditions.push_back(std::move(cond));
 			}
@@ -846,7 +846,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				cond.comparison = comparison.type;
 				if (invert) {
 					// reverse comparison expression if we reverse the order of the children
-					cond.comparison = FlipComparisionExpression(comparison.type);
+					cond.comparison = FlipComparisonExpression(comparison.type);
 				}
 				// now find the join to push it into
 				auto node = result_operator.get();

package/src/duckdb/src/optimizer/rule/move_constants.cpp

@@ -99,7 +99,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 			outer_constant->value = std::move(result_value);
 			// in this case, we should also flip the comparison
 			// e.g. if we have [4 - x < 2] then we should have [x > 2]
-			comparison->type = FlipComparisionExpression(comparison->type);
+			comparison->type = FlipComparisonExpression(comparison->type);
 		}
 	} else {
 		D_ASSERT(op_type == "*");
@@ -129,7 +129,7 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 		}
 		if (inner_value < 0) {
 			// multiply by negative value, need to flip expression
-			comparison->type = FlipComparisionExpression(comparison->type);
+			comparison->type = FlipComparisonExpression(comparison->type);
 		}
 		// else divide the RHS by the LHS
 		// we need to do a range check on the cast even though we do a division

package/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp

@@ -165,7 +165,7 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &
 	if (left.type == ExpressionType::VALUE_CONSTANT && right.type == ExpressionType::BOUND_COLUMN_REF) {
 		constant = (BoundConstantExpression *)&left;
 		columnref = (BoundColumnRefExpression *)&right;
-		comparison_type = FlipComparisionExpression(comparison_type);
+		comparison_type = FlipComparisonExpression(comparison_type);
 	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::VALUE_CONSTANT) {
 		columnref = (BoundColumnRefExpression *)&left;
 		constant = (BoundConstantExpression *)&right;

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

@@ -0,0 +1,19 @@
+#include "duckdb/parser/common_table_expression_info.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
+namespace duckdb {
+
+void CommonTableExpressionInfo::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("aliases", aliases);
+	serializer.WriteProperty("query", query);
+}
+
+unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<CommonTableExpressionInfo>();
+	result->aliases = deserializer.ReadProperty<vector<string>>("aliases");
+	result->query = deserializer.ReadProperty<unique_ptr<SelectStatement>>("query");
+	return result;
+}
+
+} // namespace duckdb

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

@@ -1,5 +1,7 @@
 #include "duckdb/parser/expression/between_expression.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -45,4 +47,19 @@ unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type,
 	return make_unique<BetweenExpression>(std::move(input), std::move(lower), std::move(upper));
 }
 
+void BetweenExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("input", *input);
+	serializer.WriteProperty("lower", *lower);
+	serializer.WriteProperty("upper", *upper);
+}
+
+unique_ptr<ParsedExpression> BetweenExpression::FormatDeserialize(ExpressionType type,
+                                                                  FormatDeserializer &deserializer) {
+	auto input = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("input");
+	auto lower = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("lower");
+	auto upper = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("upper");
+	return make_unique<BetweenExpression>(std::move(input), std::move(lower), std::move(upper));
+}
+
 } // namespace duckdb

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

@@ -3,8 +3,23 @@
 #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 {
 
+void CaseCheck::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("when_expr", when_expr);
+	serializer.WriteProperty("then_expr", then_expr);
+}
+
+CaseCheck CaseCheck::FormatDeserialize(FormatDeserializer &deserializer) {
+	CaseCheck check;
+	deserializer.ReadProperty("when_expr", check.when_expr);
+	deserializer.ReadProperty("then_expr", check.then_expr);
+	return check;
+}
+
 CaseExpression::CaseExpression() : ParsedExpression(ExpressionType::CASE_EXPR, ExpressionClass::CASE) {
 }
 
@@ -69,4 +84,17 @@ unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, Fi
 	return std::move(result);
 }
 
+void CaseExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("case_checks", case_checks);
+	serializer.WriteProperty("else_expr", *else_expr);
+}
+
+unique_ptr<ParsedExpression> CaseExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto result = make_unique<CaseExpression>();
+	deserializer.ReadProperty("case_checks", result->case_checks);
+	deserializer.ReadProperty("else_expr", result->else_expr);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/expression/cast_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 {
 
 CastExpression::CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast_p)
@@ -48,4 +51,18 @@ unique_ptr<ParsedExpression> CastExpression::Deserialize(ExpressionType type, Fi
 	return make_unique_base<ParsedExpression, CastExpression>(cast_type, std::move(child), try_cast);
 }
 
+void CastExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("child", *child);
+	serializer.WriteProperty("cast_type", cast_type);
+	serializer.WriteProperty("try_cast", try_cast);
+}
+
+unique_ptr<ParsedExpression> CastExpression::FormatDeserialize(ExpressionType type, FormatDeserializer &deserializer) {
+	auto child = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("child");
+	auto cast_type = deserializer.ReadProperty<LogicalType>("cast_type");
+	auto try_cast = deserializer.ReadProperty<bool>("try_cast");
+	return make_unique_base<ParsedExpression, CastExpression>(cast_type, std::move(child), try_cast);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/expression/collate_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 {
 
 CollateExpression::CollateExpression(string collation_p, unique_ptr<ParsedExpression> child)
@@ -42,4 +45,17 @@ unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type,
 	return make_unique_base<ParsedExpression, CollateExpression>(collation, std::move(child));
 }
 
+void CollateExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("child", *child);
+	serializer.WriteProperty("collation", collation);
+}
+
+unique_ptr<ParsedExpression> CollateExpression::FormatDeserialize(ExpressionType type,
+                                                                  FormatDeserializer &deserializer) {
+	auto child = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("child");
+	auto collation = deserializer.ReadProperty<string>("collation");
+	return make_unique_base<ParsedExpression, CollateExpression>(collation, std::move(child));
+}
+
 } // namespace duckdb

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

@@ -5,6 +5,9 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/qualified_name.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
@@ -100,4 +103,16 @@ unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType typ
 	return std::move(expression);
 }
 
+void ColumnRefExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("column_names", column_names);
+}
+
+unique_ptr<ParsedExpression> ColumnRefExpression::FormatDeserialize(ExpressionType type,
+                                                                    FormatDeserializer &deserializer) {
+	auto column_names = deserializer.ReadProperty<vector<string>>("column_names");
+	auto expression = make_unique<ColumnRefExpression>(std::move(column_names));
+	return std::move(expression);
+}
+
 } // namespace duckdb

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

@@ -4,6 +4,9 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 ComparisonExpression::ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
@@ -42,4 +45,17 @@ unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType ty
 	return make_unique<ComparisonExpression>(type, std::move(left_child), std::move(right_child));
 }
 
+void ComparisonExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+}
+
+unique_ptr<ParsedExpression> ComparisonExpression::FormatDeserialize(ExpressionType type,
+                                                                     FormatDeserializer &deserializer) {
+	auto left = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("left");
+	auto right = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("right");
+	return make_unique<ComparisonExpression>(type, std::move(left), std::move(right));
+}
+
 } // namespace duckdb

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

@@ -3,6 +3,9 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression_util.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 ConjunctionExpression::ConjunctionExpression(ExpressionType type)
@@ -65,4 +68,16 @@ unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType t
 	return std::move(result);
 }
 
+void ConjunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("children", children);
+}
+
+unique_ptr<ParsedExpression> ConjunctionExpression::FormatDeserialize(ExpressionType type,
+                                                                      FormatDeserializer &deserializer) {
+	auto result = make_unique<ConjunctionExpression>(type);
+	result->children = deserializer.ReadProperty<vector<unique_ptr<ParsedExpression>>>("children");
+	return std::move(result);
+}
+
 } // namespace duckdb

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

@@ -5,6 +5,9 @@
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/value_operations/value_operations.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 ConstantExpression::ConstantExpression(Value val)
@@ -38,4 +41,15 @@ unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type
 	return make_unique<ConstantExpression>(std::move(value));
 }
 
+void ConstantExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+	serializer.WriteProperty("value", value);
+}
+
+unique_ptr<ParsedExpression> ConstantExpression::FormatDeserialize(ExpressionType type,
+                                                                   FormatDeserializer &deserializer) {
+	auto value = deserializer.ReadProperty<Value>("value");
+	return make_unique<ConstantExpression>(std::move(value));
+}
+
 } // namespace duckdb

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

@@ -2,6 +2,9 @@
 
 #include "duckdb/common/exception.hpp"
 
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
 namespace duckdb {
 
 DefaultExpression::DefaultExpression() : ParsedExpression(ExpressionType::VALUE_DEFAULT, ExpressionClass::DEFAULT) {
@@ -24,4 +27,8 @@ unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type,
 	return make_unique<DefaultExpression>();
 }
 
+void DefaultExpression::FormatSerialize(FormatSerializer &serializer) const {
+	ParsedExpression::FormatSerialize(serializer);
+}
+
 } // namespace duckdb

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,
@@ -122,4 +125,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_unique<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