duckdb 0.8.2-dev145.0 → 0.8.2-dev1493.0

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

@@ -3,6 +3,7 @@
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
@@ -21,6 +22,7 @@ CommonTableExpressionMap CommonTableExpressionMap::Copy() const {
 			kv_info->aliases.push_back(al);
 		}
 		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
+		kv_info->materialized = kv.second->materialized;
 		res.map[kv.first] = std::move(kv_info);
 	}
 	return res;
@@ -59,7 +61,13 @@ string CommonTableExpressionMap::ToString() const {
 			}
 			result += ")";
 		}
-		result += " AS (";
+		if (kv.second->materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
+			result += " AS MATERIALIZED (";
+		} else if (kv.second->materialized == CTEMaterialize::CTE_MATERIALIZE_NEVER) {
+			result += " AS NOT MATERIALIZED (";
+		} else {
+			result += " AS (";
+		}
 		result += cte.query->ToString();
 		result += ")";
 		first_cte = false;
@@ -159,6 +167,7 @@ void QueryNode::CopyProperties(QueryNode &other) const {
 			kv_info->aliases.push_back(al);
 		}
 		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
+		kv_info->materialized = kv.second->materialized;
 		other.cte_map.map[kv.first] = std::move(kv_info);
 	}
 }
@@ -175,48 +184,13 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
 		serializer.WriteString(cte.first);
 		serializer.WriteStringVector(cte.second->aliases);
 		cte.second->query->Serialize(serializer);
+		writer.WriteField<CTEMaterialize>(cte.second->materialized);
 	}
 	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);
 
@@ -231,6 +205,7 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 		auto info = make_uniq<CommonTableExpressionInfo>();
 		source.ReadStringVector(info->aliases);
 		info->query = SelectStatement::Deserialize(source);
+		info->materialized = reader.ReadField<CTEMaterialize>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT);
 		new_map[name] = std::move(info);
 	}
 	unique_ptr<QueryNode> result;
@@ -244,6 +219,9 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	case QueryNodeType::RECURSIVE_CTE_NODE:
 		result = RecursiveCTENode::Deserialize(reader);
 		break;
+	case QueryNodeType::CTE_NODE:
+		result = CTENode::Deserialize(reader);
+		break;
 	default:
 		throw SerializationException("Could not deserialize Query Node: unknown type!");
 	}

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

@@ -17,33 +17,6 @@ void ResultModifier::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void ResultModifier::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-}
-
-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>();
@@ -99,19 +72,6 @@ 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) {
-	auto mod = make_uniq<LimitModifier>();
-	deserializer.ReadOptionalProperty("limit", mod->limit);
-	deserializer.ReadOptionalProperty("offset", mod->offset);
-	return std::move(mod);
-}
-
 unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_uniq<LimitModifier>();
 	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -142,17 +102,6 @@ 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_uniq<DistinctModifier>();
-	deserializer.ReadProperty("distinct_on_targets", mod->distinct_on_targets);
-	return std::move(mod);
-}
-
 unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_uniq<DistinctModifier>();
 	mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
@@ -256,16 +205,6 @@ 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) {
-	auto mod = make_uniq<OrderModifier>();
-	deserializer.ReadProperty("orders", mod->orders);
-	return std::move(mod);
-}
-
 unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_uniq<OrderModifier>();
 	mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
@@ -302,12 +241,6 @@ void LimitPercentModifier::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(offset);
 }
 
-void LimitPercentModifier::FormatSerialize(FormatSerializer &serializer) const {
-	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteOptionalProperty("limit", limit);
-	serializer.WriteOptionalProperty("offset", offset);
-}
-
 unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_uniq<LimitPercentModifier>();
 	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
@@ -315,11 +248,4 @@ unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader
 	return std::move(mod);
 }
 
-unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto mod = make_uniq<LimitPercentModifier>();
-	deserializer.ReadOptionalProperty("limit", mod->limit);
-	deserializer.ReadOptionalProperty("offset", mod->offset);
-	return std::move(mod);
-}
-
 } // namespace duckdb

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

@@ -31,25 +31,6 @@ 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_uniq<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_uniq<BaseTableRef>();
 

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

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

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

@@ -75,21 +75,6 @@ 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_uniq<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_uniq<ExpressionListRef>();
 	// value list

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

@@ -28,6 +28,9 @@ string JoinRef::ToString() const {
 	case JoinRefType::POSITIONAL:
 		result += "POSITIONAL JOIN ";
 		break;
+	case JoinRefType::DEPENDENT:
+		result += "DEPENDENT JOIN ";
+		break;
 	}
 	result += right->ToString();
 	if (condition) {
@@ -88,29 +91,6 @@ 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_uniq<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_uniq<JoinRef>(JoinRefType::REGULAR);
 	result->left = reader.ReadRequiredSerializable<TableRef>();

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

@@ -330,17 +330,6 @@ 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_uniq<PivotRef>();
 	result->source = reader.ReadRequiredSerializable<TableRef>();
@@ -353,16 +342,4 @@ unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
 	return std::move(result);
 }
 
-unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &source) {
-	auto result = make_uniq<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

@@ -12,6 +12,9 @@ string SubqueryRef::ToString() const {
 	return BaseToString(result, column_name_alias);
 }
 
+SubqueryRef::SubqueryRef() : TableRef(TableReferenceType::SUBQUERY) {
+}
+
 SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
     : TableRef(TableReferenceType::SUBQUERY), subquery(std::move(subquery_p)) {
 	this->alias = std::move(alias_p);
@@ -37,19 +40,6 @@ 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_uniq<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_uniq<SubqueryRef>(std::move(subquery));

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

@@ -27,21 +27,6 @@ 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_uniq<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_uniq<TableFunctionRef>();
 	result->function = reader.ReadRequiredSerializable<ParsedExpression>();

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

@@ -53,50 +53,6 @@ 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_constant.cpp

@@ -1,8 +1,11 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/types/decimal.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
 
@@ -76,4 +79,53 @@ unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::P
 	return TransformValue(c.val);
 }
 
+bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr, Value &value) {
+	// We have to construct it like this because we don't have the ClientContext for binding/executing the expr here
+	switch (expr.type) {
+	case ExpressionType::FUNCTION: {
+		auto &function = expr.Cast<FunctionExpression>();
+		if (function.function_name == "struct_pack") {
+			unordered_set<string> unique_names;
+			child_list_t<Value> values;
+			values.reserve(function.children.size());
+			for (const auto &child : function.children) {
+				if (!unique_names.insert(child->alias).second) {
+					throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
+				}
+				Value child_value;
+				if (!ConstructConstantFromExpression(*child, child_value)) {
+					return false;
+				}
+				values.emplace_back(child->alias, std::move(child_value));
+			}
+			value = Value::STRUCT(std::move(values));
+			return true;
+		} else {
+			return false;
+		}
+	}
+	case ExpressionType::VALUE_CONSTANT: {
+		auto &constant = expr.Cast<ConstantExpression>();
+		value = constant.value;
+		return true;
+	}
+	case ExpressionType::OPERATOR_CAST: {
+		auto &cast = expr.Cast<CastExpression>();
+		Value dummy_value;
+		if (!ConstructConstantFromExpression(*cast.child, dummy_value)) {
+			return false;
+		}
+
+		string error_message;
+		if (!dummy_value.DefaultTryCastAs(cast.cast_type, value, &error_message)) {
+			throw ConversionException("Unable to cast %s to %s", dummy_value.ToString(),
+			                          EnumUtil::ToString(cast.cast_type.id()));
+		}
+		return true;
+	}
+	default:
+		return false;
+	}
+}
+
 } // namespace duckdb

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

@@ -75,6 +75,8 @@ unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery:
 		return TransformStarExpression(PGCast<duckdb_libpgquery::PGAStar>(node));
 	case duckdb_libpgquery::T_PGBooleanTest:
 		return TransformBooleanTest(PGCast<duckdb_libpgquery::PGBooleanTest>(node));
+	case duckdb_libpgquery::T_PGMultiAssignRef:
+		return TransformMultiAssignRef(PGCast<duckdb_libpgquery::PGMultiAssignRef>(node));
 
 	default:
 		throw NotImplementedException("Expression type %s (%d)", NodetypeToString(node.type), (int)node.type);

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

@@ -0,0 +1,44 @@
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/transformer.hpp"
+
+namespace duckdb {
+
+unique_ptr<ParsedExpression> Transformer::TransformMultiAssignRef(duckdb_libpgquery::PGMultiAssignRef &root) {
+	// Multi assignment for the ROW function
+	if (root.source->type == duckdb_libpgquery::T_PGFuncCall) {
+		auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*root.source);
+
+		// Explicitly only allow ROW function
+		char const *function_name =
+		    PGPointerCast<duckdb_libpgquery::PGValue>(func.funcname->tail->data.ptr_value)->val.str;
+		if (function_name == nullptr || strlen(function_name) != 3 || strncmp(function_name, "row", 3) != 0) {
+			return TransformExpression(root.source);
+		}
+
+		// Too many columns (ie. (x, y) = (1, 2, 3) )
+		if (root.ncolumns < func.args->length) {
+			throw ParserException(
+			    "Could not perform multiple assignment, target only expects %d values, %d were provided", root.ncolumns,
+			    func.args->length);
+		}
+
+		// Get the expression corresponding with the current column
+		idx_t idx = 1;
+		auto list = func.args->head;
+		while (list && idx < static_cast<idx_t>(root.colno)) {
+			list = list->next;
+			++idx;
+		}
+
+		// Not enough columns (ie. (x, y, z) = (1, 2) )
+		if (!list) {
+			throw ParserException(
+			    "Could not perform multiple assignment, target expects %d values, only %d were provided", root.ncolumns,
+			    func.args->length);
+		}
+		return TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(list->data.ptr_value));
+	}
+	return TransformExpression(root.source);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transform/helpers/transform_cte.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 
 namespace duckdb {
 
@@ -10,6 +11,7 @@ unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::Copy() {
 	auto result = make_uniq<CommonTableExpressionInfo>();
 	result->aliases = aliases;
 	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	result->materialized = materialized;
 	return result;
 }
 
@@ -29,7 +31,8 @@ void Transformer::ExtractCTEsRecursive(CommonTableExpressionMap &cte_map) {
 	}
 }
 
-void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map) {
+void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map,
+                               vector<unique_ptr<CTENode>> &materialized_ctes) {
 	// TODO: might need to update in case of future lawsuit
 	stored_cte_map.push_back(&cte_map);
 
@@ -79,6 +82,21 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause,
 			// can't have two CTEs with same name
 			throw ParserException("Duplicate CTE name \"%s\"", cte_name);
 		}
+
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeDefault) {
+#else
+		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeAlways) {
+#endif
+			auto materialize = make_uniq<CTENode>();
+			materialize->query = info->query->node->Copy();
+			materialize->ctename = cte_name;
+			materialize->aliases = info->aliases;
+			materialized_ctes.push_back(std::move(materialize));
+
+			info->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+		}
+
 		cte_map.map[cte_name] = std::move(info);
 	}
 }

package/src/duckdb/src/parser/transform/statement/transform_copy.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/core_functions/scalar/struct_functions.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/transformer.hpp"
@@ -47,6 +49,17 @@ void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpg
 		case duckdb_libpgquery::T_PGAStar:
 			info.options[def_elem->defname].push_back(Value("*"));
 			break;
+		case duckdb_libpgquery::T_PGFuncCall: {
+			auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(def_elem->arg);
+			auto func_expr = TransformFuncCall(*func_call);
+
+			Value value;
+			if (!Transformer::ConstructConstantFromExpression(*func_expr, value)) {
+				throw ParserException("Unsupported expression in COPY options: %s", func_expr->ToString());
+			}
+			info.options[def_elem->defname].push_back(std::move(value));
+			break;
+		}
 		default: {
 			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
 			info.options[def_elem->defname].push_back(TransformValue(*val)->value);

package/src/duckdb/src/parser/transform/statement/transform_delete.cpp

@@ -5,8 +5,13 @@ namespace duckdb {
 
 unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGDeleteStmt &stmt) {
 	auto result = make_uniq<DeleteStatement>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map,
+		             materialized_ctes);
+		if (!materialized_ctes.empty()) {
+			throw NotImplementedException("Materialized CTEs are not implemented for delete.");
+		}
 	}
 
 	result->condition = TransformExpression(stmt.whereClause);