duckdb 1.3.2 → 1.3.3-dev4.0

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

@@ -255,6 +255,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 		break;
 	case TableReferenceType::INVALID:
 	case TableReferenceType::CTE:
+	case TableReferenceType::BOUND_TABLE_REF:
 		throw NotImplementedException("TableRef type not implemented for traversal");
 	}
 	ref_callback(ref);
@@ -316,4 +317,25 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
 	}
 }
 
+void ParsedExpressionIterator::VisitExpressionClass(
+    const ParsedExpression &expr, ExpressionClass expr_class,
+    const std::function<void(const ParsedExpression &child)> &callback) {
+	if (expr.GetExpressionClass() == expr_class) {
+		callback(expr);
+		return;
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](const ParsedExpression &child) { VisitExpressionClass(child, expr_class, callback); });
+}
+
+void ParsedExpressionIterator::VisitExpressionClassMutable(
+    ParsedExpression &expr, ExpressionClass expr_class, const std::function<void(ParsedExpression &child)> &callback) {
+	if (expr.GetExpressionClass() == expr_class) {
+		callback(expr);
+		return;
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](ParsedExpression &child) { VisitExpressionClassMutable(child, expr_class, callback); });
+}
+
 } // namespace duckdb

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

@@ -611,4 +611,9 @@ ColumnList Parser::ParseColumnList(const string &column_list, ParserOptions opti
 	return std::move(info.columns);
 }
 
+ColumnDefinition Parser::ParseColumnDefinition(const string &column_definition, ParserOptions options) {
+	auto column_list = ParseColumnList(column_definition, options);
+	return column_list.GetColumn(LogicalIndex(0)).Copy();
+}
+
 } // namespace duckdb

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

@@ -86,6 +86,32 @@ QualifiedColumnName::QualifiedColumnName(const BindingAlias &alias, string colum
     : catalog(alias.GetCatalog()), schema(alias.GetSchema()), table(alias.GetAlias()), column(std::move(column_p)) {
 }
 
+QualifiedColumnName QualifiedColumnName::Parse(string &input) {
+	auto components = QualifiedName::ParseComponents(input);
+	if (components.size() == 1) {
+		return QualifiedColumnName(components[0]);
+	} else if (components.size() == 2) {
+		return QualifiedColumnName(components[0], components[1]);
+	} else if (components.size() == 3) {
+		QualifiedColumnName qname;
+		qname.schema = components[0];
+		qname.table = components[1];
+		qname.column = components[2];
+		return qname;
+	} else if (components.size() == 4) {
+		QualifiedColumnName qname;
+		qname.catalog = components[0];
+		qname.schema = components[1];
+		qname.table = components[2];
+		qname.column = components[3];
+		return qname;
+	} else {
+		throw ParserException(
+		    "Expected at most 4 entries (catalog.schema.table.column), but found %zu entries (input: %s)",
+		    components.size(), input);
+	}
+}
+
 string QualifiedColumnName::ToString() const {
 	string result;
 	if (!catalog.empty()) {

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

@@ -34,6 +34,7 @@ unique_ptr<QueryNode> CTENode::Copy() const {
 	result->query = query->Copy();
 	result->child = child->Copy();
 	result->aliases = aliases;
+	result->materialized = materialized;
 	this->CopyProperties(*result);
 	return std::move(result);
 }

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

@@ -106,6 +106,7 @@ string SelectNode::ToString() const {
 		}
 		result += ")";
 	}
+
 	return result + ResultModifiersToString();
 }
 

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

@@ -7,6 +7,7 @@
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
 
 namespace duckdb {
 

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

@@ -24,10 +24,8 @@ string ExportStatement::ToString() const {
 	}
 	auto &path = info->file_path;
 	D_ASSERT(info->is_from == false);
-	auto &options = info->options;
-	auto &format = info->format;
 	result += StringUtil::Format(" '%s'", path);
-	result += CopyInfo::CopyOptionsToString(format, info->is_format_auto_detected, options);
+	result += info->CopyOptionsToString();
 	result += ";";
 	return result;
 }

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

@@ -0,0 +1,167 @@
+#include "duckdb/parser/statement/merge_into_statement.hpp"
+
+namespace duckdb {
+
+MergeIntoStatement::MergeIntoStatement() : SQLStatement(StatementType::MERGE_INTO_STATEMENT) {
+}
+
+MergeIntoStatement::MergeIntoStatement(const MergeIntoStatement &other) : SQLStatement(other) {
+	target = other.target->Copy();
+	source = other.source->Copy();
+	join_condition = other.join_condition ? other.join_condition->Copy() : nullptr;
+	using_columns = other.using_columns;
+	for (auto &entry : other.actions) {
+		auto &action_list = actions[entry.first];
+		for (auto &action : entry.second) {
+			action_list.push_back(action->Copy());
+		}
+	}
+	for (auto &entry : other.returning_list) {
+		returning_list.push_back(entry->Copy());
+	}
+	cte_map = other.cte_map.Copy();
+}
+
+string MergeIntoStatement::ActionConditionToString(MergeActionCondition condition) {
+	switch (condition) {
+	case MergeActionCondition::WHEN_MATCHED:
+		return "WHEN MATCHED";
+	case MergeActionCondition::WHEN_NOT_MATCHED_BY_TARGET:
+		return "WHEN NOT MATCHED";
+	case MergeActionCondition::WHEN_NOT_MATCHED_BY_SOURCE:
+		return "WHEN NOT MATCHED BY SOURCE";
+	default:
+		throw InternalException("Unknown match condition");
+	}
+}
+
+string MergeIntoStatement::ToString() const {
+	string result;
+	result = cte_map.ToString();
+	result += "MERGE INTO ";
+	result += target->ToString();
+	result += " USING ";
+	result += source->ToString();
+	if (join_condition) {
+		result += " ON ";
+		result += join_condition->ToString();
+	} else {
+		result += " USING (";
+		for (idx_t c = 0; c < using_columns.size(); c++) {
+			if (c > 0) {
+				result += ", ";
+			}
+			result += using_columns[c];
+		}
+		result += ")";
+	}
+	for (auto &entry : actions) {
+		for (auto &action : entry.second) {
+			result += " ";
+			result += MergeIntoStatement::ActionConditionToString(entry.first);
+			result += " ";
+			result += action->ToString();
+		}
+	}
+	if (!returning_list.empty()) {
+		result += " RETURNING ";
+		for (idx_t i = 0; i < returning_list.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			auto column = returning_list[i]->ToString();
+			if (!returning_list[i]->GetAlias().empty()) {
+				column +=
+				    StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->GetAlias()));
+			}
+			result += column;
+		}
+	}
+	return result;
+}
+
+unique_ptr<SQLStatement> MergeIntoStatement::Copy() const {
+	return unique_ptr<MergeIntoStatement>(new MergeIntoStatement(*this));
+}
+
+string MergeIntoAction::ToString() const {
+	string result;
+	if (condition) {
+		result += " AND " + condition->ToString() + " ";
+	}
+	result += "THEN ";
+	switch (action_type) {
+	case MergeActionType::MERGE_UPDATE:
+		result += "UPDATE ";
+		if (column_order == InsertColumnOrder::INSERT_BY_NAME) {
+			result += "BY NAME ";
+		}
+		if (update_info) {
+			result += update_info->ToString();
+		}
+		break;
+	case MergeActionType::MERGE_DELETE:
+		result += "DELETE";
+		break;
+	case MergeActionType::MERGE_INSERT:
+		result += "INSERT ";
+		if (column_order == InsertColumnOrder::INSERT_BY_NAME) {
+			result += "BY NAME ";
+		}
+		if (!insert_columns.empty()) {
+			result += "(";
+			for (idx_t c = 0; c < insert_columns.size(); c++) {
+				if (c > 0) {
+					result += ", ";
+				}
+				result += KeywordHelper::WriteOptionallyQuoted(insert_columns[c]);
+			}
+			result += ") ";
+		}
+		if (expressions.empty()) {
+			if (default_values) {
+				result += "DEFAULT VALUES";
+			} else {
+				result += "*";
+			}
+		} else {
+			result += "VALUES (";
+			for (idx_t c = 0; c < expressions.size(); c++) {
+				if (c > 0) {
+					result += ", ";
+				}
+				result += expressions[c]->ToString();
+			}
+			result += ")";
+		}
+		break;
+	case MergeActionType::MERGE_DO_NOTHING:
+		result += "DO NOTHING";
+		break;
+	case MergeActionType::MERGE_ERROR:
+		result += "ERROR";
+		if (!expressions.empty()) {
+			result += " " + expressions[0]->ToString();
+		}
+		break;
+	default:
+		throw InternalException("Unsupported merge action in ToString");
+	}
+	return result;
+}
+
+unique_ptr<MergeIntoAction> MergeIntoAction::Copy() const {
+	auto result = make_uniq<MergeIntoAction>();
+	result->action_type = action_type;
+	result->condition = condition ? condition->Copy() : nullptr;
+	result->update_info = update_info ? update_info->Copy() : nullptr;
+	result->insert_columns = insert_columns;
+	result->default_values = default_values;
+	result->column_order = column_order;
+	for (auto &expr : expressions) {
+		result->expressions.push_back(expr->Copy());
+	}
+	return result;
+}
+
+} // namespace duckdb

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

@@ -15,6 +15,21 @@ UpdateSetInfo::UpdateSetInfo(const UpdateSetInfo &other) : columns(other.columns
 	}
 }
 
+string UpdateSetInfo::ToString() const {
+	string result;
+	result += "SET ";
+	D_ASSERT(columns.size() == expressions.size());
+	for (idx_t i = 0; i < columns.size(); i++) {
+		if (i > 0) {
+			result += ", ";
+		}
+		result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
+		result += " = ";
+		result += expressions[i]->ToString();
+	}
+	return result;
+}
+
 unique_ptr<UpdateSetInfo> UpdateSetInfo::Copy() const {
 	return unique_ptr<UpdateSetInfo>(new UpdateSetInfo(*this));
 }
@@ -34,30 +49,18 @@ UpdateStatement::UpdateStatement(const UpdateStatement &other)
 }
 
 string UpdateStatement::ToString() const {
-	D_ASSERT(set_info);
-	auto &condition = set_info->condition;
-	auto &columns = set_info->columns;
-	auto &expressions = set_info->expressions;
 
 	string result;
 	result = cte_map.ToString();
 	result += "UPDATE ";
 	result += table->ToString();
-	result += " SET ";
-	D_ASSERT(columns.size() == expressions.size());
-	for (idx_t i = 0; i < columns.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += KeywordHelper::WriteOptionallyQuoted(columns[i]);
-		result += " = ";
-		result += expressions[i]->ToString();
-	}
+	result += " ";
+	result += set_info->ToString();
 	if (from_table) {
 		result += " FROM " + from_table->ToString();
 	}
-	if (condition) {
-		result += " WHERE " + condition->ToString();
+	if (set_info->condition) {
+		result += " WHERE " + set_info->condition->ToString();
 	}
 	if (!returning_list.empty()) {
 		result += " RETURNING ";

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

@@ -0,0 +1,29 @@
+#include "duckdb/parser/tableref/bound_ref_wrapper.hpp"
+
+namespace duckdb {
+
+BoundRefWrapper::BoundRefWrapper(unique_ptr<BoundTableRef> bound_ref_p, shared_ptr<Binder> binder_p)
+    : TableRef(TableReferenceType::BOUND_TABLE_REF), bound_ref(std::move(bound_ref_p)), binder(std::move(binder_p)) {
+}
+
+string BoundRefWrapper::ToString() const {
+	throw InternalException("Method not implemented for BoundRefWrapper");
+}
+
+bool BoundRefWrapper::Equals(const TableRef &other_p) const {
+	throw InternalException("Method not implemented for BoundRefWrapper");
+}
+
+unique_ptr<TableRef> BoundRefWrapper::Copy() {
+	throw InternalException("Method not implemented for BoundRefWrapper");
+}
+
+void BoundRefWrapper::Serialize(Serializer &serializer) const {
+	throw InternalException("Method not implemented for BoundRefWrapper");
+}
+
+unique_ptr<TableRef> BoundRefWrapper::Deserialize(Deserializer &source) {
+	throw InternalException("Method not implemented for BoundRefWrapper");
+}
+
+} // namespace duckdb

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

@@ -6,6 +6,11 @@
 
 namespace duckdb {
 
+ColumnDataRef::ColumnDataRef(optionally_owned_ptr<ColumnDataCollection> collection_p, vector<string> expected_names)
+    : TableRef(TableReferenceType::COLUMN_DATA), expected_names(std::move(expected_names)),
+      collection(std::move(collection_p)) {
+}
+
 string ColumnDataRef::ToString() const {
 	auto result = collection->ToString();
 	return BaseToString(result, expected_names);
@@ -46,8 +51,28 @@ bool ColumnDataRef::Equals(const TableRef &other_p) const {
 	return true;
 }
 
+optionally_owned_ptr<ColumnDataCollection> CopyCollection(optionally_owned_ptr<ColumnDataCollection> &collection) {
+	auto &unique = collection.get_owned_unique();
+	if (unique) {
+		// uniquely owned - need to copy over all the data and make a new collection
+		auto new_collection = make_uniq<ColumnDataCollection>(collection->GetAllocator(), collection->Types());
+		for (auto &chunk : collection->Chunks()) {
+			new_collection->Append(chunk);
+		}
+		return std::move(new_collection);
+	}
+	auto &shared = collection.get_owned_shared();
+	if (shared) {
+		// shared ptr - we can directly reference it
+		return shared;
+	}
+	// unowned collection - just return the raw reference
+	return collection.get();
+}
+
 unique_ptr<TableRef> ColumnDataRef::Copy() {
-	auto result = make_uniq<ColumnDataRef>(collection, expected_names);
+	auto copied_collection = CopyCollection(collection);
+	auto result = make_uniq<ColumnDataRef>(std::move(copied_collection), expected_names);
 	CopyProperties(*result);
 	return std::move(result);
 }

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

@@ -22,7 +22,7 @@ string JoinRef::ToString() const {
 		result += EnumUtil::ToString(type) + " JOIN ";
 		break;
 	case JoinRefType::CROSS:
-		result += ", ";
+		result += is_implicit ? ", " : "CROSS JOIN ";
 		break;
 	case JoinRefType::POSITIONAL:
 		result += "POSITIONAL JOIN ";
@@ -43,7 +43,7 @@ string JoinRef::ToString() const {
 			if (i > 0) {
 				result += ", ";
 			}
-			result += using_columns[i];
+			result += KeywordHelper::WriteOptionallyQuoted(using_columns[i]);
 		}
 		result += ")";
 	}
@@ -82,6 +82,7 @@ unique_ptr<TableRef> JoinRef::Copy() {
 	for (auto &col : duplicate_eliminated_columns) {
 		copy->duplicate_eliminated_columns.emplace_back(col->Copy());
 	}
+	copy->is_implicit = is_implicit;
 	return std::move(copy);
 }
 

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/tableref/showref.hpp"
+#include "duckdb/parser/keyword_helper.hpp"
 
 namespace duckdb {
 
@@ -9,6 +10,17 @@ string ShowRef::ToString() const {
 	string result;
 	if (show_type == ShowType::SUMMARY) {
 		result += "SUMMARIZE ";
+	} else if (show_type == ShowType::SHOW_FROM) {
+		result += "SHOW TABLES FROM ";
+		string name = "";
+		if (!catalog_name.empty()) {
+			name += KeywordHelper::WriteOptionallyQuoted(catalog_name, '"');
+			if (!schema_name.empty()) {
+				name += ".";
+			}
+		}
+		name += KeywordHelper::WriteOptionallyQuoted(schema_name, '"');
+		result += name;
 	} else {
 		result += "DESCRIBE ";
 	}
@@ -38,6 +50,8 @@ bool ShowRef::Equals(const TableRef &other_p) const {
 unique_ptr<TableRef> ShowRef::Copy() {
 	auto copy = make_uniq<ShowRef>();
 
+	copy->catalog_name = catalog_name;
+	copy->schema_name = schema_name;
 	copy->table_name = table_name;
 	copy->query = query ? query->Copy() : nullptr;
 	copy->show_type = show_type;

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

@@ -9,7 +9,11 @@ TableFunctionRef::TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTI
 }
 
 string TableFunctionRef::ToString() const {
-	return BaseToString(function->ToString(), column_name_alias);
+	auto result = function->ToString();
+	if (with_ordinality == OrdinalityType::WITH_ORDINALITY) {
+		result += " WITH ORDINALITY";
+	}
+	return BaseToString(result, column_name_alias);
 }
 
 bool TableFunctionRef::Equals(const TableRef &other_p) const {
@@ -25,6 +29,7 @@ unique_ptr<TableRef> TableFunctionRef::Copy() {
 
 	copy->function = function->Copy();
 	copy->column_name_alias = column_name_alias;
+	copy->with_ordinality = with_ordinality;
 	CopyProperties(*copy);
 
 	return std::move(copy);

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

@@ -79,7 +79,6 @@ unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery:
 		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_function.cpp

@@ -27,7 +27,10 @@ void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef &window_spec
 		TransformOrderBy(window_spec.orderClause, expr.orders);
 		for (auto &order : expr.orders) {
 			if (order.expression->GetExpressionType() == ExpressionType::STAR) {
-				throw ParserException("Cannot ORDER BY ALL in a window expression");
+				auto &star = order.expression->Cast<StarExpression>();
+				if (!star.expr) {
+					throw ParserException("Cannot ORDER BY ALL in a window expression");
+				}
 			}
 		}
 	}
@@ -60,6 +63,7 @@ static bool IsExcludableWindowFunction(ExpressionType type) {
 	case ExpressionType::WINDOW_CUME_DIST:
 	case ExpressionType::WINDOW_LEAD:
 	case ExpressionType::WINDOW_LAG:
+	case ExpressionType::WINDOW_FILL:
 		return false;
 	default:
 		throw InternalException("Unknown excludable window type %s", ExpressionTypeToString(type).c_str());
@@ -160,6 +164,7 @@ static bool IsOrderableWindowFunction(ExpressionType type) {
 	case ExpressionType::WINDOW_CUME_DIST:
 	case ExpressionType::WINDOW_LEAD:
 	case ExpressionType::WINDOW_LAG:
+	case ExpressionType::WINDOW_FILL:
 	case ExpressionType::WINDOW_AGGREGATE:
 		return true;
 	case ExpressionType::WINDOW_RANK_DENSE:

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

@@ -8,17 +8,14 @@
 
 namespace duckdb {
 
-void RemoveOrderQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
-	if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
-		auto &col_ref = expr->Cast<ColumnRefExpression>();
-		auto &col_names = col_ref.column_names;
-		if (col_names.size() > 1) {
-			col_names = vector<string> {col_names.back()};
-		}
-	} else {
-		ParsedExpressionIterator::EnumerateChildren(
-		    *expr, [](unique_ptr<ParsedExpression> &child) { RemoveOrderQualificationRecursive(child); });
-	}
+void RemoveOrderQualificationRecursive(unique_ptr<ParsedExpression> &root_expr) {
+	ParsedExpressionIterator::VisitExpressionMutable<ColumnRefExpression>(
+	    *root_expr, [&](ColumnRefExpression &col_ref) {
+		    auto &col_names = col_ref.column_names;
+		    if (col_names.size() > 1) {
+			    col_names = vector<string> {col_names.back()};
+		    }
+	    });
 }
 
 unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink &root) {

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

@@ -20,6 +20,9 @@ unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::Copy() {
 	return result;
 }
 
+CommonTableExpressionInfo::~CommonTableExpressionInfo() {
+}
+
 void Transformer::ExtractCTEsRecursive(CommonTableExpressionMap &cte_map) {
 	for (auto &cte_entry : stored_cte_map) {
 		for (auto &entry : cte_entry->map) {

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

@@ -56,11 +56,6 @@ vector<Value> Transformer::TransformTypeModifiers(duckdb_libpgquery::PGTypeName
 	vector<Value> type_mods;
 	if (type_name.typmods) {
 		for (auto node = type_name.typmods->head; node; node = node->next) {
-			if (type_mods.size() > 9) {
-				const auto &name =
-				    *PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
-				throw ParserException("'%s': a maximum of 9 type modifiers is allowed", name);
-			}
 			const auto &const_val = *PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
 			if (const_val.type != duckdb_libpgquery::T_PGAConst) {
 				throw ParserException("Expected a constant as type modifier");
@@ -68,6 +63,10 @@ vector<Value> Transformer::TransformTypeModifiers(duckdb_libpgquery::PGTypeName
 			const auto const_expr = TransformValue(const_val.val);
 			type_mods.push_back(std::move(const_expr->value));
 		}
+		if (type_mods.size() > 9) {
+			const auto name = PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
+			throw ParserException("'%s': a maximum of 9 type modifiers is allowed", name);
+		}
 	}
 	return type_mods;
 }
@@ -150,6 +149,9 @@ LogicalType Transformer::TransformTypeNameInternal(duckdb_libpgquery::PGTypeName
 		D_ASSERT(!children.empty());
 		return LogicalType::STRUCT(children);
 	}
+	if (base_type == LogicalTypeId::VARIANT) {
+		return LogicalType::VARIANT();
+	}
 	if (base_type == LogicalTypeId::MAP) {
 		if (!type_name.typmods || type_name.typmods->length != 2) {
 			throw ParserException("Map type needs exactly two entries, key and value type");

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

@@ -16,13 +16,13 @@ unique_ptr<AttachStatement> Transformer::TransformAttach(duckdb_libpgquery::PGAt
 		duckdb_libpgquery::PGListCell *cell;
 		for_each_cell(cell, stmt.options->head) {
 			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-			Value val;
+			unique_ptr<ParsedExpression> expr;
 			if (def_elem->arg) {
-				val = TransformValue(*PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg))->value;
+				expr = TransformExpression(def_elem->arg);
 			} else {
-				val = Value::BOOLEAN(true);
+				expr = make_uniq<ConstantExpression>(Value::BOOLEAN(true));
 			}
-			info->options[StringUtil::Lower(def_elem->defname)] = std::move(val);
+			info->parsed_options[StringUtil::Lower(def_elem->defname)] = std::move(expr);
 		}
 	}
 	result->info = std::move(info);