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

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

@@ -1,6 +1,8 @@
 #include "duckdb/parser/result_modifier.hpp"
 #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 {
 
@@ -18,6 +20,33 @@ void ResultModifier::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+}
+
+std::unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<ResultModifierType>("type");
+
+	unique_ptr<ResultModifier> result;
+	switch (type) {
+	case ResultModifierType::LIMIT_MODIFIER:
+		result = LimitModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::ORDER_MODIFIER:
+		result = OrderModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::DISTINCT_MODIFIER:
+		result = DistinctModifier::FormatDeserialize(deserializer);
+		break;
+	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
+		result = LimitPercentModifier::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw InternalException("Unrecognized ResultModifierType for Deserialization");
+	}
+	return result;
+}
+
 unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto type = reader.ReadRequired<ResultModifierType>();
@@ -73,6 +102,16 @@ void LimitModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(offset);
 }
 
+void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteOptionalProperty("limit", limit);
+	serializer.WriteOptionalProperty("offset", offset);
+}
+
+unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw NotImplementedException("err");
+}
+
 unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<LimitModifier>();
 	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -103,6 +142,16 @@ void DistinctModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializableList(distinct_on_targets);
 }
 
+void DistinctModifier::FormatSerialize(duckdb::FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("distinct_on_targets", distinct_on_targets);
+}
+
+unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto mod = make_unique<DistinctModifier>();
+	throw NotImplementedException("");
+}
+
 unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<DistinctModifier>();
 	mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
@@ -170,6 +219,16 @@ void OrderByNode::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void OrderByNode::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("null_order", null_order);
+	serializer.WriteProperty("expression", expression);
+}
+
+OrderByNode OrderByNode::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw NotImplementedException("err");
+}
+
 OrderByNode OrderByNode::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto type = reader.ReadRequired<OrderType>();
@@ -183,6 +242,14 @@ void OrderModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteRegularSerializableList(orders);
 }
 
+void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("orders", orders);
+}
+unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw NotImplementedException("err");
+}
+
 unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<OrderModifier>();
 	mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
@@ -219,6 +286,12 @@ void LimitPercentModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(offset);
 }
 
+void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("limit", limit);
+	serializer.WriteProperty("offset", offset);
+}
+
 unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<LimitPercentModifier>();
 	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -226,4 +299,9 @@ unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader
 	return std::move(mod);
 }
 
+unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto mod = make_unique<LimitPercentModifier>();
+	throw NotImplementedException("err");
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/statement/select_statement.hpp"
 
 #include "duckdb/common/serializer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -15,12 +17,22 @@ void SelectStatement::Serialize(Serializer &serializer) const {
 	node->Serialize(serializer);
 }
 
+void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
+	node->FormatSerialize(serializer);
+}
+
 unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &source) {
 	auto result = make_unique<SelectStatement>();
 	result->node = QueryNode::Deserialize(source);
 	return result;
 }
 
+unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<SelectStatement>();
+	deserializer.ReadProperty("node", result->node);
+	return result;
+}
+
 bool SelectStatement::Equals(const SQLStatement *other_p) const {
 	if (type != other_p->type) {
 		return false;

package/src/duckdb/src/parser/tableref/basetableref.cpp

@@ -2,6 +2,8 @@
 
 #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 {
 
@@ -29,6 +31,25 @@ void BaseTableRef::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog_name);
 }
 
+void BaseTableRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("schema_name", schema_name);
+	serializer.WriteProperty("table_name", table_name);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+	serializer.WriteProperty("catalog_name", catalog_name);
+}
+
+unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<BaseTableRef>();
+
+	deserializer.ReadProperty("schema_name", result->schema_name);
+	deserializer.ReadProperty("table_name", result->table_name);
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty("catalog_name", result->catalog_name);
+
+	return std::move(result);
+}
+
 unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<BaseTableRef>();
 

package/src/duckdb/src/parser/tableref/emptytableref.cpp

@@ -23,4 +23,8 @@ unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
 	return make_unique<EmptyTableRef>();
 }
 
+unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &source) {
+	return make_unique<EmptyTableRef>();
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/expressionlistref.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -73,6 +75,21 @@ void ExpressionListRef::Serialize(FieldWriter &writer) const {
 	}
 }
 
+void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("expected_names", expected_names);
+	serializer.WriteProperty("expected_types", expected_types);
+	serializer.WriteProperty("values", values);
+}
+
+unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &source) {
+	auto result = make_unique<ExpressionListRef>();
+	source.ReadProperty("expected_names", result->expected_names);
+	source.ReadProperty("expected_types", result->expected_types);
+	source.ReadProperty("values", result->values);
+	return std::move(result);
+}
+
 unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<ExpressionListRef>();
 	// value list

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -2,6 +2,8 @@
 
 #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 {
 
@@ -82,6 +84,29 @@ void JoinRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(using_columns);
 }
 
+void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+	serializer.WriteOptionalProperty("condition", condition);
+	serializer.WriteProperty("join_type", type);
+	serializer.WriteProperty("ref_type", ref_type);
+	serializer.WriteProperty("using_columns", using_columns);
+}
+
+unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &source) {
+	auto result = make_unique<JoinRef>(JoinRefType::REGULAR);
+
+	source.ReadProperty("left", result->left);
+	source.ReadProperty("right", result->right);
+	source.ReadOptionalProperty("condition", result->condition);
+	source.ReadProperty("join_type", result->type);
+	source.ReadProperty("ref_type", result->ref_type);
+	source.ReadProperty("using_columns", result->using_columns);
+
+	return std::move(result);
+}
+
 unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<JoinRef>(JoinRefType::REGULAR);
 	result->left = reader.ReadRequiredSerializable<TableRef>();

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -2,6 +2,8 @@
 
 #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 {
 
@@ -107,6 +109,12 @@ void PivotColumn::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("entries", entries);
+	serializer.WriteProperty("pivot_enum", pivot_enum);
+}
+
 PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	PivotColumn result;
 	FieldReader reader(source);
@@ -117,6 +125,14 @@ PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	return result;
 }
 
+PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &source) {
+	PivotColumn result;
+	source.ReadProperty("names", result.names);
+	source.ReadProperty("entries", result.entries);
+	source.ReadProperty("pivot_enum", result.pivot_enum);
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // PivotColumnEntry
 //===--------------------------------------------------------------------===//
@@ -136,6 +152,12 @@ void PivotColumnEntry::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void PivotColumnEntry::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("values", values);
+	serializer.WriteOptionalProperty("star_expr", star_expr);
+	serializer.WriteProperty("alias", alias);
+}
+
 PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
 	PivotColumnEntry result;
 	FieldReader reader(source);
@@ -146,6 +168,14 @@ PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
 	return result;
 }
 
+PivotColumnEntry PivotColumnEntry::FormatDeserialize(FormatDeserializer &source) {
+	PivotColumnEntry result;
+	source.ReadProperty("values", result.values);
+	source.ReadOptionalProperty("star_expr", result.star_expr);
+	source.ReadProperty("alias", result.alias);
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // PivotRef
 //===--------------------------------------------------------------------===//
@@ -281,6 +311,17 @@ void PivotRef::Serialize(FieldWriter &writer) const {
 	writer.WriteField<bool>(include_nulls);
 }
 
+void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("source", source);
+	serializer.WriteProperty("aggregates", aggregates);
+	serializer.WriteProperty("unpivot_names", unpivot_names);
+	serializer.WriteProperty("pivots", pivots);
+	serializer.WriteProperty("groups", groups);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+	serializer.WriteProperty("include_nulls", include_nulls);
+}
+
 unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<PivotRef>();
 	result->source = reader.ReadRequiredSerializable<TableRef>();
@@ -293,4 +334,16 @@ unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
 	return std::move(result);
 }
 
+unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &source) {
+	auto result = make_unique<PivotRef>();
+	source.ReadProperty("source", result->source);
+	source.ReadProperty("aggregates", result->aggregates);
+	source.ReadProperty("unpivot_names", result->unpivot_names);
+	source.ReadProperty("pivots", result->pivots);
+	source.ReadProperty("groups", result->groups);
+	source.ReadProperty("column_name_alias", result->column_name_alias);
+	source.ReadProperty("include_nulls", result->include_nulls);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/subqueryref.cpp

@@ -2,6 +2,8 @@
 
 #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 {
 
@@ -35,6 +37,19 @@ void SubqueryRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(column_name_alias);
 }
 
+void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("subquery", subquery);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+}
+
+unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto subquery = deserializer.ReadProperty<unique_ptr<SelectStatement>>("subquery");
+	auto result = make_unique<SubqueryRef>(std::move(subquery));
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	return std::move(result);
+}
+
 unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
 	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
 	auto result = make_unique<SubqueryRef>(std::move(subquery));

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -25,6 +27,21 @@ void TableFunctionRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(column_name_alias);
 }
 
+void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("function", function);
+	serializer.WriteProperty("alias", alias);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+}
+
+unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<TableFunctionRef>();
+	deserializer.ReadProperty("function", result->function);
+	deserializer.ReadProperty("alias", result->alias);
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	return std::move(result);
+}
+
 unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<TableFunctionRef>();
 	result->function = reader.ReadRequiredSerializable<ParsedExpression>();

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

@@ -3,6 +3,8 @@
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/tableref/list.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 #include "duckdb/common/to_string.hpp"
 
 namespace duckdb {
@@ -52,6 +54,50 @@ void TableRef::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void TableRef::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("alias", alias);
+	serializer.WriteOptionalProperty("sample", sample);
+}
+
+unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<TableReferenceType>("type");
+	auto alias = deserializer.ReadProperty<string>("alias");
+	auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
+
+	unique_ptr<TableRef> result;
+
+	switch (type) {
+	case TableReferenceType::BASE_TABLE:
+		result = BaseTableRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::JOIN:
+		result = JoinRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::SUBQUERY:
+		result = SubqueryRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::TABLE_FUNCTION:
+		result = TableFunctionRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::EMPTY:
+		result = EmptyTableRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::EXPRESSION_LIST:
+		result = ExpressionListRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::PIVOT:
+		result = PivotRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::CTE:
+	case TableReferenceType::INVALID:
+		throw InternalException("Unsupported type for TableRef::FormatDeserialize");
+	}
+	result->alias = alias;
+	result->sample = std::move(sample);
+	return result;
+}
+
 unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 

package/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp

@@ -37,7 +37,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::P
 			           next->type <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
 				// NOT on a comparison: we can negate the comparison
 				// e.g. NOT(x > y) is equivalent to x <= y
-				next->type = NegateComparisionExpression(next->type);
+				next->type = NegateComparisonExpression(next->type);
 				result = std::move(next);
 			} else {
 				result = make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(next));

package/src/duckdb/src/parser/transform/expression/transform_operator.cpp

@@ -84,7 +84,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
+			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
 		}
 		return std::move(subquery_expr);

package/src/duckdb/src/parser/transform/expression/transform_subquery.cpp

@@ -44,7 +44,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
-			subquery_expr->comparison_type = NegateComparisionExpression(subquery_expr->comparison_type);
+			subquery_expr->comparison_type = NegateComparisonExpression(subquery_expr->comparison_type);
 			return make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(subquery_expr));
 		}
 		break;

package/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp

@@ -32,6 +32,10 @@ public:
 	void Serialize(FieldWriter &writer) const override {
 		throw InternalException("Cannot serialize bound subquery node");
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const override {
+		throw InternalException("Cannot serialize bound subquery node");
+	}
 };
 
 BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t depth) {

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -33,7 +33,7 @@ static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &le
 		if (left_side == JoinSide::RIGHT) {
 			// left = right, right = left, flip the comparison symbol and reverse sides
 			swap(left, right);
-			condition.comparison = FlipComparisionExpression(expr.type);
+			condition.comparison = FlipComparisonExpression(expr.type);
 		}
 		condition.left = std::move(left);
 		condition.right = std::move(right);

package/src/duckdb/src/planner/expression/bound_expression.cpp

@@ -28,4 +28,8 @@ void BoundExpression::Serialize(FieldWriter &writer) const {
 	throw SerializationException("Cannot copy or serialize bound expression");
 }
 
+void BoundExpression::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("Cannot copy or serialize bound expression");
+}
+
 } // namespace duckdb

package/src/duckdb/src/verification/deserialized_statement_verifier.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
 
 namespace duckdb {

package/src/duckdb/third_party/re2/re2/re2.cc

@@ -566,6 +566,15 @@ static int ascii_strcasecmp(const char* a, const char* b, size_t len) {
   return 0;
 }
 
+RE2::Anchor RE2::Anchored() const {
+  if (prog_->anchor_start()) {
+    if (prog_->anchor_end()) {
+      return Anchor::ANCHOR_BOTH;
+    }
+    return Anchor::ANCHOR_START;
+  }
+  return Anchor::UNANCHORED;
+}
 
 /***** Actual matching and rewriting code *****/
 

package/src/duckdb/third_party/re2/re2/re2.h

@@ -475,6 +475,8 @@ class RE2 {
     ANCHOR_BOTH         // Anchor at start and end
   };
 
+  Anchor Anchored() const;
+
   // Return the number of capturing subpatterns, or -1 if the
   // regexp wasn't valid on construction.  The overall match ($0)
   // does not count: if the regexp is "(a)(b)", returns 2.

package/src/duckdb/ub_extension_json_json_functions.cpp

@@ -20,6 +20,8 @@
 
 #include "extension/json/json_functions/json_valid.cpp"
 
+#include "extension/json/json_functions/json_serialize_sql.cpp"
+
 #include "extension/json/json_functions/read_json.cpp"
 
 #include "extension/json/json_functions/read_json_objects.cpp"

package/src/duckdb/ub_src_common_serializer.cpp

@@ -6,3 +6,5 @@
 
 #include "src/common/serializer/buffered_serializer.cpp"
 
+#include "src/common/serializer/enum_serializer.cpp"
+

package/src/duckdb/ub_src_function_scalar_string_regexp.cpp

@@ -0,0 +1,4 @@
+#include "src/function/scalar/string/regexp/regexp_util.cpp"
+
+#include "src/function/scalar/string/regexp/regexp_extract_all.cpp"
+

package/src/duckdb/ub_src_parser.cpp

@@ -6,6 +6,8 @@
 
 #include "src/parser/constraint.cpp"
 
+#include "src/parser/common_table_expression_info.cpp"
+
 #include "src/parser/expression_util.cpp"
 
 #include "src/parser/keyword_helper.cpp"

package/src/utils.cpp

@@ -18,6 +18,18 @@ static void SetString(Napi::Object &obj, const std::string &key, const std::stri
 
 Napi::Object Utils::CreateError(Napi::Env env, duckdb::PreservedError &error) {
 	auto obj = Utils::CreateError(env, error.Message());
+	if (error.Type() == duckdb::ExceptionType::HTTP) {
+		const auto &e = error.GetError()->AsHTTPException();
+		obj.Set(Napi::String::New(env, "statusCode"), Napi::Number::New(env, e.GetStatusCode()));
+		SetString(obj, "response", e.GetResponseBody());
+		SetString(obj, "reason", e.GetReason());
+
+		auto headers = Napi::Object::New(env);
+		for (const auto &item : e.GetHeaders()) {
+			SetString(headers, item.first, item.second);
+		}
+		obj.Set(Napi::String::New(env, "headers"), headers);
+	}
 
 	SetString(obj, "errorType", duckdb::Exception::ExceptionTypeToString(error.Type()));