duckdb 0.7.2-dev717.0 → 0.7.2-dev865.0

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -25,10 +25,12 @@ class RowGroupCollection;
 class UpdateSegment;
 class TableScanState;
 class ColumnSegment;
+class ColumnSegmentTree;
 class ValiditySegment;
 class TableFilterSet;
 class ColumnData;
 class DuckTransaction;
+class RowGroupSegmentTree;
 
 struct SegmentScanState {
 	virtual ~SegmentScanState() {
@@ -45,6 +47,8 @@ typedef unordered_map<block_id_t, BufferHandle> buffer_handle_set_t;
 struct ColumnScanState {
 	//! The column segment that is currently being scanned
 	ColumnSegment *current = nullptr;
+	//! Column segment tree
+	ColumnSegmentTree *segment_tree = nullptr;
 	//! The current row index of the scan
 	idx_t row_index = 0;
 	//! The internal row index (i.e. the position of the SegmentScanState)
@@ -114,10 +118,12 @@ private:
 class CollectionScanState {
 public:
 	CollectionScanState(TableScanState &parent_p)
-	    : row_group_state(*this), max_row(0), batch_index(0), parent(parent_p) {};
+	    : row_group_state(*this), row_groups(nullptr), max_row(0), batch_index(0), parent(parent_p) {};
 
 	//! The row_group scan state
 	RowGroupScanState row_group_state;
+	//! Row group segment tree
+	RowGroupSegmentTree *row_groups;
 	//! The total maximum row index
 	idx_t max_row;
 	//! The current batch index
@@ -129,6 +135,7 @@ public:
 	AdaptiveFilter *GetAdaptiveFilter();
 	bool Scan(DuckTransaction &transaction, DataChunk &result);
 	bool ScanCommitted(DataChunk &result, TableScanType type);
+	bool ScanCommitted(DataChunk &result, SegmentLock &l, TableScanType type);
 
 private:
 	TableScanState &parent;

package/src/duckdb/src/include/duckdb/storage/table/segment_base.hpp

@@ -13,13 +13,14 @@
 
 namespace duckdb {
 
+template <class T>
 class SegmentBase {
 public:
 	SegmentBase(idx_t start, idx_t count) : start(start), count(count), next(nullptr) {
 	}
 	virtual ~SegmentBase() {
 	}
-	SegmentBase *Next() {
+	T *Next() {
 #ifndef DUCKDB_R_BUILD
 		return next.load();
 #else
@@ -34,9 +35,9 @@ public:
 	//! The next segment after this one
 
 #ifndef DUCKDB_R_BUILD
-	atomic<SegmentBase *> next;
+	atomic<T *> next;
 #else
-	SegmentBase *next;
+	T *next;
 #endif
 };
 

package/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp

@@ -10,71 +10,316 @@
 
 #include "duckdb/common/constants.hpp"
 #include "duckdb/storage/storage_lock.hpp"
-#include "duckdb/storage/table/segment_base.hpp"
 #include "duckdb/storage/table/segment_lock.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/mutex.hpp"
+#include "duckdb/common/string_util.hpp"
 
 namespace duckdb {
 
+template <class T>
 struct SegmentNode {
 	idx_t row_start;
-	unique_ptr<SegmentBase> node;
+	unique_ptr<T> node;
 };
 
 //! The SegmentTree maintains a list of all segments of a specific column in a table, and allows searching for a segment
 //! by row number
+template <class T, bool SUPPORTS_LAZY_LOADING = false>
 class SegmentTree {
+private:
+	class SegmentIterationHelper;
+
 public:
+	explicit SegmentTree() : finished_loading(true) {
+	}
+	virtual ~SegmentTree() {
+	}
+
 	//! Locks the segment tree. All methods to the segment tree either lock the segment tree, or take an already
 	//! obtained lock.
-	SegmentLock Lock();
+	SegmentLock Lock() {
+		return SegmentLock(node_lock);
+	}
 
-	bool IsEmpty(SegmentLock &);
+	bool IsEmpty(SegmentLock &l) {
+		return GetRootSegment(l) == nullptr;
+	}
 
 	//! Gets a pointer to the first segment. Useful for scans.
-	SegmentBase *GetRootSegment();
-	SegmentBase *GetRootSegment(SegmentLock &);
+	T *GetRootSegment() {
+		auto l = Lock();
+		return GetRootSegment(l);
+	}
+
+	T *GetRootSegment(SegmentLock &l) {
+		if (nodes.empty()) {
+			LoadNextSegment(l);
+		}
+		return nodes.empty() ? nullptr : nodes[0].node.get();
+	}
 	//! Obtains ownership of the data of the segment tree
-	vector<SegmentNode> MoveSegments(SegmentLock &);
+	vector<SegmentNode<T>> MoveSegments(SegmentLock &l) {
+		LoadAllSegments(l);
+		return std::move(nodes);
+	}
 	//! Gets a pointer to the nth segment. Negative numbers start from the back.
-	SegmentBase *GetSegmentByIndex(int64_t index);
-	SegmentBase *GetSegmentByIndex(SegmentLock &, int64_t index);
+	T *GetSegmentByIndex(int64_t index) {
+		auto l = Lock();
+		return GetSegmentByIndex(l, index);
+	}
+	T *GetSegmentByIndex(SegmentLock &l, int64_t index) {
+		if (index < 0) {
+			// load all segments
+			LoadAllSegments(l);
+			index = nodes.size() + index;
+			if (index < 0) {
+				return nullptr;
+			}
+			return nodes[index].node.get();
+		} else {
+			// lazily load segments until we reach the specific segment
+			while (idx_t(index) >= nodes.size() && LoadNextSegment(l)) {
+			}
+			if (idx_t(index) >= nodes.size()) {
+				return nullptr;
+			}
+			return nodes[index].node.get();
+		}
+	}
+	//! Gets the next segment
+	T *GetNextSegment(T *segment) {
+		if (!SUPPORTS_LAZY_LOADING) {
+			return segment->Next();
+		}
+		if (finished_loading) {
+			return segment->Next();
+		}
+		auto l = Lock();
+		return GetNextSegment(l, segment);
+	}
+	T *GetNextSegment(SegmentLock &l, T *segment) {
+		if (!segment) {
+			return nullptr;
+		}
+#ifdef DEBUG
+		D_ASSERT(nodes[segment->index].node.get() == segment);
+#endif
+		return GetSegmentByIndex(l, segment->index + 1);
+	}
 
 	//! Gets a pointer to the last segment. Useful for appends.
-	SegmentBase *GetLastSegment();
-	SegmentBase *GetLastSegment(SegmentLock &);
+	T *GetLastSegment(SegmentLock &l) {
+		LoadAllSegments(l);
+		if (nodes.empty()) {
+			return nullptr;
+		}
+		return nodes.back().node.get();
+	}
 	//! Gets a pointer to a specific column segment for the given row
-	SegmentBase *GetSegment(idx_t row_number);
-	SegmentBase *GetSegment(SegmentLock &, idx_t row_number);
+	T *GetSegment(idx_t row_number) {
+		auto l = Lock();
+		return GetSegment(l, row_number);
+	}
+	T *GetSegment(SegmentLock &l, idx_t row_number) {
+		return nodes[GetSegmentIndex(l, row_number)].node.get();
+	}
 
 	//! Append a column segment to the tree
-	void AppendSegment(unique_ptr<SegmentBase> segment);
-	void AppendSegment(SegmentLock &, unique_ptr<SegmentBase> segment);
+	void AppendSegmentInternal(SegmentLock &l, unique_ptr<T> segment) {
+		D_ASSERT(segment);
+		// add the node to the list of nodes
+		if (!nodes.empty()) {
+			nodes.back().node->next = segment.get();
+		}
+		SegmentNode<T> node;
+		segment->index = nodes.size();
+		node.row_start = segment->start;
+		node.node = std::move(segment);
+		nodes.push_back(std::move(node));
+	}
+	void AppendSegment(unique_ptr<T> segment) {
+		auto l = Lock();
+		AppendSegment(l, std::move(segment));
+	}
+	void AppendSegment(SegmentLock &l, unique_ptr<T> segment) {
+		LoadAllSegments(l);
+		AppendSegmentInternal(l, std::move(segment));
+	}
 	//! Debug method, check whether the segment is in the segment tree
-	bool HasSegment(SegmentBase *segment);
-	bool HasSegment(SegmentLock &, SegmentBase *segment);
+	bool HasSegment(T *segment) {
+		auto l = Lock();
+		return HasSegment(l, segment);
+	}
+	bool HasSegment(SegmentLock &, T *segment) {
+		return segment->index < nodes.size() && nodes[segment->index].node.get() == segment;
+	}
 
 	//! Replace this tree with another tree, taking over its nodes in-place
-	void Replace(SegmentTree &other);
-	void Replace(SegmentLock &, SegmentTree &other);
+	void Replace(SegmentTree<T> &other) {
+		auto l = Lock();
+		Replace(l, other);
+	}
+	void Replace(SegmentLock &l, SegmentTree<T> &other) {
+		other.LoadAllSegments(l);
+		nodes = std::move(other.nodes);
+	}
 
 	//! Erase all segments after a specific segment
-	void EraseSegments(SegmentLock &, idx_t segment_start);
+	void EraseSegments(SegmentLock &l, idx_t segment_start) {
+		LoadAllSegments(l);
+		if (segment_start >= nodes.size() - 1) {
+			return;
+		}
+		nodes.erase(nodes.begin() + segment_start + 1, nodes.end());
+	}
 
 	//! Get the segment index of the column segment for the given row
-	idx_t GetSegmentIndex(idx_t row_number);
-	idx_t GetSegmentIndex(SegmentLock &, idx_t row_number);
-	bool TryGetSegmentIndex(SegmentLock &, idx_t row_number, idx_t &);
+	idx_t GetSegmentIndex(SegmentLock &l, idx_t row_number) {
+		idx_t segment_index;
+		if (TryGetSegmentIndex(l, row_number, segment_index)) {
+			return segment_index;
+		}
+		string error;
+		error = StringUtil::Format("Attempting to find row number \"%lld\" in %lld nodes\n", row_number, nodes.size());
+		for (idx_t i = 0; i < nodes.size(); i++) {
+			error += StringUtil::Format("Node %lld: Start %lld, Count %lld", i, nodes[i].row_start,
+			                            nodes[i].node->count.load());
+		}
+		throw InternalException("Could not find node in column segment tree!\n%s%s", error, Exception::GetStackTrace());
+	}
+
+	bool TryGetSegmentIndex(SegmentLock &l, idx_t row_number, idx_t &result) {
+		// load segments until the row number is within bounds
+		while (nodes.empty() || (row_number >= (nodes.back().row_start + nodes.back().node->count))) {
+			if (!LoadNextSegment(l)) {
+				break;
+			}
+		}
+		if (nodes.empty()) {
+			return false;
+		}
+		D_ASSERT(!nodes.empty());
+		D_ASSERT(row_number >= nodes[0].row_start);
+		D_ASSERT(row_number < nodes.back().row_start + nodes.back().node->count);
+		idx_t lower = 0;
+		idx_t upper = nodes.size() - 1;
+		// binary search to find the node
+		while (lower <= upper) {
+			idx_t index = (lower + upper) / 2;
+			D_ASSERT(index < nodes.size());
+			auto &entry = nodes[index];
+			D_ASSERT(entry.row_start == entry.node->start);
+			if (row_number < entry.row_start) {
+				upper = index - 1;
+			} else if (row_number >= entry.row_start + entry.node->count) {
+				lower = index + 1;
+			} else {
+				result = index;
+				return true;
+			}
+		}
+		return false;
+	}
 
-	void Verify(SegmentLock &);
-	void Verify();
+	void Verify(SegmentLock &) {
+#ifdef DEBUG
+		idx_t base_start = nodes.empty() ? 0 : nodes[0].node->start;
+		for (idx_t i = 0; i < nodes.size(); i++) {
+			D_ASSERT(nodes[i].row_start == nodes[i].node->start);
+			D_ASSERT(nodes[i].node->start == base_start);
+			base_start += nodes[i].node->count;
+		}
+#endif
+	}
+	void Verify() {
+#ifdef DEBUG
+		auto l = Lock();
+		Verify(l);
+#endif
+	}
+
+	SegmentIterationHelper Segments() {
+		return SegmentIterationHelper(*this);
+	}
+
+protected:
+	atomic<bool> finished_loading;
+
+	//! Load the next segment - only used when lazily loading
+	virtual unique_ptr<T> LoadSegment() {
+		return nullptr;
+	}
 
 private:
 	//! The nodes in the tree, can be binary searched
-	vector<SegmentNode> nodes;
+	vector<SegmentNode<T>> nodes;
 	//! Lock to access or modify the nodes
 	mutex node_lock;
+
+private:
+	class SegmentIterationHelper {
+	public:
+		explicit SegmentIterationHelper(SegmentTree &tree) : tree(tree) {
+		}
+
+	private:
+		SegmentTree &tree;
+
+	private:
+		class SegmentIterator {
+		public:
+			SegmentIterator(SegmentTree &tree_p, T *current_p) : tree(tree_p), current(current_p) {
+			}
+
+			SegmentTree &tree;
+			T *current;
+
+		public:
+			void Next() {
+				current = tree.GetNextSegment(current);
+			}
+
+			SegmentIterator &operator++() {
+				Next();
+				return *this;
+			}
+			bool operator!=(const SegmentIterator &other) const {
+				return current != other.current;
+			}
+			T &operator*() const {
+				D_ASSERT(current);
+				return *current;
+			}
+		};
+
+	public:
+		SegmentIterator begin() {
+			return SegmentIterator(tree, tree.GetRootSegment());
+		}
+		SegmentIterator end() {
+			return SegmentIterator(tree, nullptr);
+		}
+	};
+
+	//! Load the next segment, if there are any left to load
+	bool LoadNextSegment(SegmentLock &l) {
+		if (finished_loading) {
+			return false;
+		}
+		auto result = LoadSegment();
+		if (result) {
+			AppendSegmentInternal(l, std::move(result));
+			return true;
+		}
+		return false;
+	}
+
+	//! Load all segments, if there are any left to load
+	void LoadAllSegments(SegmentLock &l) {
+		while (LoadNextSegment(l))
+			;
+	}
 };
 
 } // 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