duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -130,13 +130,6 @@ void PivotColumn::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("pivot_expressions", pivot_expressions);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("entries", entries);
-	serializer.WriteProperty("pivot_enum", pivot_enum);
-}
-
 PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	PivotColumn result;
 	FieldReader reader(source);
@@ -148,15 +141,6 @@ PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	return result;
 }
 
-PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &source) {
-	PivotColumn result;
-	source.ReadProperty("pivot_expressions", result.pivot_expressions);
-	source.ReadProperty("unpivot_names", result.unpivot_names);
-	source.ReadProperty("entries", result.entries);
-	source.ReadProperty("pivot_enum", result.pivot_enum);
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotColumnEntry
 //===--------------------------------------------------------------------===//
@@ -177,9 +161,9 @@ void PivotColumnEntry::Serialize(Serializer &serializer) const {
 }
 
 void PivotColumnEntry::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("values", values);
-	serializer.WriteOptionalProperty("star_expr", star_expr);
-	serializer.WriteProperty("alias", alias);
+	serializer.WriteProperty(100, "values", values);
+	serializer.WriteOptionalProperty(101, "star_expr", star_expr);
+	serializer.WriteProperty(102, "alias", alias);
 }
 
 PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
@@ -194,9 +178,9 @@ PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
 
 PivotColumnEntry PivotColumnEntry::FormatDeserialize(FormatDeserializer &source) {
 	PivotColumnEntry result;
-	source.ReadProperty("values", result.values);
-	source.ReadOptionalProperty("star_expr", result.star_expr);
-	source.ReadProperty("alias", result.alias);
+	source.ReadProperty(100, "values", result.values);
+	source.ReadOptionalProperty(101, "star_expr", result.star_expr);
+	source.ReadProperty(102, "alias", result.alias);
 	return result;
 }
 
@@ -330,17 +314,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 +326,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/constraint/transform_constraint.cpp

@@ -17,8 +17,58 @@ static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar *input, Foreign
 	fk_info.table = input->relname;
 }
 
+static bool ForeignKeyActionSupported(char action) {
+	switch (action) {
+	case PG_FKCONSTR_ACTION_NOACTION:
+	case PG_FKCONSTR_ACTION_RESTRICT:
+		return true;
+	case PG_FKCONSTR_ACTION_CASCADE:
+	case PG_FKCONSTR_ACTION_SETDEFAULT:
+	case PG_FKCONSTR_ACTION_SETNULL:
+		return false;
+	default:
+		D_ASSERT(false);
+	}
+	return false;
+}
+
+static unique_ptr<ForeignKeyConstraint>
+TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint,
+                              optional_ptr<const string> override_fk_column = nullptr) {
+	D_ASSERT(constraint);
+	if (!ForeignKeyActionSupported(constraint->fk_upd_action) ||
+	    !ForeignKeyActionSupported(constraint->fk_del_action)) {
+		throw ParserException("FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT");
+	}
+	ForeignKeyInfo fk_info;
+	fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
+	ParseSchemaTableNameFK(constraint->pktable, fk_info);
+	vector<string> pk_columns, fk_columns;
+	if (override_fk_column) {
+		D_ASSERT(!constraint->fk_attrs);
+		fk_columns.emplace_back(*override_fk_column);
+	} else if (constraint->fk_attrs) {
+		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
+			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+	}
+	if (constraint->pk_attrs) {
+		for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
+			pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+		}
+	}
+	if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
+		throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
+	}
+	if (fk_columns.empty()) {
+		throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
+	}
+	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
+}
+
 unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) {
 	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
+	D_ASSERT(constraint);
 	switch (constraint->contype) {
 	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
 	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
@@ -36,27 +86,9 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		}
 		return make_uniq<CheckConstraint>(TransformExpression(constraint->raw_expr));
 	}
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-		vector<string> pk_columns, fk_columns;
-		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
-			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-		}
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		if (fk_columns.empty()) {
-			throw ParserException("The set of referencing and referenced columns for foreign keys must be not empty");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint);
+
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
 	}
@@ -96,23 +128,8 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 			                      "dictionary, pfor, bitpacking or fsst");
 		}
 		return nullptr;
-	case duckdb_libpgquery::PG_CONSTR_FOREIGN: {
-		ForeignKeyInfo fk_info;
-		fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-		ParseSchemaTableNameFK(constraint->pktable, fk_info);
-
-		vector<string> pk_columns, fk_columns;
-		fk_columns.emplace_back(column.Name().c_str());
-		if (constraint->pk_attrs) {
-			for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-				pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
-			}
-		}
-		if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
-			throw ParserException("The number of referencing and referenced columns for foreign keys must be the same");
-		}
-		return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
-	}
+	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
+		return TransformForeignKeyConstraint(constraint, &column.Name());
 	default:
 		throw NotImplementedException("Constraint not implemented!");
 	}

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

@@ -27,10 +27,19 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			children.push_back(std::move(result));
 			if (index->is_slice) {
 				// slice
-				children.push_back(!index->lidx ? make_uniq<ConstantExpression>(Value())
-				                                : TransformExpression(index->lidx));
-				children.push_back(!index->uidx ? make_uniq<ConstantExpression>(Value())
-				                                : TransformExpression(index->uidx));
+				// if either the lower or upper bound is not specified, we use an empty const list so that we can
+				// handle it in the execution
+				unique_ptr<ParsedExpression> lower =
+				    index->lidx ? TransformExpression(index->lidx)
+				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+				children.push_back(std::move(lower));
+				unique_ptr<ParsedExpression> upper =
+				    index->uidx ? TransformExpression(index->uidx)
+				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+				children.push_back(std::move(upper));
+				if (index->step) {
+					children.push_back(TransformExpression(index->step));
+				}
 				result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_SLICE, std::move(children));
 			} else {
 				// array access

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_function.cpp

@@ -209,6 +209,9 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			}
 			window_ref = it->second;
 			D_ASSERT(window_ref);
+			if (window_ref->startOffset || window_ref->endOffset || window_ref->frameOptions != FRAMEOPTION_DEFAULTS) {
+				throw ParserException("cannot copy window \"%s\" because it has a frame clause", window_spec->refname);
+			}
 		}
 		in_window_definition = true;
 		TransformWindowDef(*window_ref, *expr);

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/expression/transform_param_ref.cpp

@@ -4,40 +4,59 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
-	auto expr = make_uniq<ParameterExpression>();
+namespace {
+
+struct PreparedParam {
+	PreparedParamType type;
+	string identifier;
+};
+
+} // namespace
+
+static PreparedParam GetParameterIdentifier(duckdb_libpgquery::PGParamRef &node) {
+	PreparedParam param;
+	if (node.name) {
+		param.type = PreparedParamType::NAMED;
+		param.identifier = node.name;
+		return param;
+	}
 	if (node.number < 0) {
 		throw ParserException("Parameter numbers cannot be negative");
 	}
+	param.identifier = StringUtil::Format("%d", node.number);
+	param.type = node.number == 0 ? PreparedParamType::AUTO_INCREMENT : PreparedParamType::POSITIONAL;
+	return param;
+}
 
-	if (node.name) {
-		// This is a named parameter, try to find an entry for it
-		D_ASSERT(node.number == 0);
-		int32_t index;
-		if (GetNamedParam(node.name, index)) {
-			// We've seen this named parameter before and assigned it an index!
-			node.number = index;
-		}
-	}
-	if (node.number == 0) {
-		expr->parameter_nr = ParamCount() + 1;
-		if (node.name && !HasNamedParameters() && ParamCount() != 0) {
-			// This parameter is named, but there were other parameter before it, and they were not named
-			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
+unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
+	auto expr = make_uniq<ParameterExpression>();
+
+	auto param = GetParameterIdentifier(node);
+	idx_t known_param_index = DConstants::INVALID_INDEX;
+	// This is a named parameter, try to find an entry for it
+	GetParam(param.identifier, known_param_index, param.type);
+
+	if (known_param_index == DConstants::INVALID_INDEX) {
+		// We have not seen this parameter before
+		if (node.number != 0) {
+			// Preserve the parameter number
+			known_param_index = node.number;
+		} else {
+			known_param_index = ParamCount() + 1;
+			if (!node.name) {
+				param.identifier = StringUtil::Format("%d", known_param_index);
+			}
 		}
-		if (node.name) {
-			D_ASSERT(!named_param_map.count(node.name));
+
+		if (!named_param_map.count(param.identifier)) {
 			// Add it to the named parameter map so we can find it next time it's referenced
-			SetNamedParam(node.name, expr->parameter_nr);
+			SetParam(param.identifier, known_param_index, param.type);
 		}
-	} else {
-		if (!node.name && HasNamedParameters()) {
-			// This parameter does not have a name, but the named param map is not empty
-			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
-		}
-		expr->parameter_nr = node.number;
 	}
-	SetParamCount(MaxValue<idx_t>(ParamCount(), expr->parameter_nr));
+
+	expr->identifier = param.identifier;
+	idx_t new_param_count = MaxValue<idx_t>(ParamCount(), known_param_index);
+	SetParamCount(new_param_count);
 	return std::move(expr);
 }
 

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);
 	}
 }