duckdb 1.3.4 → 1.4.0

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

@@ -11,47 +11,6 @@
 
 namespace duckdb {
 
-void Transformer::ParseGenericOptionListEntry(case_insensitive_map_t<vector<Value>> &result_options, string &name,
-                                              duckdb_libpgquery::PGNode *arg) {
-	// otherwise
-	if (result_options.find(name) != result_options.end()) {
-		throw ParserException("Unexpected duplicate option \"%s\"", name);
-	}
-	if (!arg) {
-		result_options[name] = vector<Value>();
-		return;
-	}
-	switch (arg->type) {
-	case duckdb_libpgquery::T_PGList: {
-		auto column_list = PGPointerCast<duckdb_libpgquery::PGList>(arg);
-		for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
-			result_options[name].push_back(Value(target->name));
-		}
-		break;
-	}
-	case duckdb_libpgquery::T_PGAStar:
-		result_options[name].push_back(Value("*"));
-		break;
-	case duckdb_libpgquery::T_PGFuncCall: {
-		auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(arg);
-		auto func_expr = TransformFuncCall(*func_call);
-
-		Value value;
-		if (!Transformer::ConstructConstantFromExpression(*func_expr, value)) {
-			throw ParserException("Unsupported expression in option list: %s", func_expr->ToString());
-		}
-		result_options[name].push_back(std::move(value));
-		break;
-	}
-	default: {
-		auto val = PGPointerCast<duckdb_libpgquery::PGValue>(arg);
-		result_options[name].push_back(TransformValue(*val)->value);
-		break;
-	}
-	}
-}
-
 void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpgquery::PGList> options) {
 	if (!options) {
 		return;
@@ -61,39 +20,16 @@ void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpg
 	// iterate over each option
 	for_each_cell(cell, options->head) {
 		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
-		if (StringUtil::Lower(def_elem->defname) == "format") {
-			// format specifier: interpret this option
-			auto format_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (!format_val || format_val->type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("Unsupported parameter type for FORMAT: expected e.g. FORMAT 'csv', 'parquet'");
-			}
-			info.format = StringUtil::Lower(format_val->val.str);
-			info.is_format_auto_detected = false;
-			continue;
-		}
-
-		// The rest ends up in the options
 		string name = def_elem->defname;
-		ParseGenericOptionListEntry(info.options, name, def_elem->arg);
-	}
-}
-
-string ExtractFormat(const string &file_path) {
-	auto format = StringUtil::Lower(file_path);
-	// We first remove extension suffixes
-	if (StringUtil::EndsWith(format, CompressionExtensionFromType(FileCompressionType::GZIP))) {
-		format = format.substr(0, format.size() - 3);
-	} else if (StringUtil::EndsWith(format, CompressionExtensionFromType(FileCompressionType::ZSTD))) {
-		format = format.substr(0, format.size() - 4);
-	}
-	// Now lets check for the last .
-	size_t dot_pos = format.rfind('.');
-	if (dot_pos == std::string::npos || dot_pos == format.length() - 1) {
-		// No format found
-		return "";
+		if (info.parsed_options.find(name) != info.parsed_options.end()) {
+			throw ParserException("Unexpected duplicate option \"%s\"", name);
+		}
+		unique_ptr<ParsedExpression> expr;
+		if (def_elem->arg) {
+			expr = TransformExpression(*def_elem->arg);
+		}
+		info.parsed_options[name] = std::move(expr);
 	}
-	// We found something
-	return format.substr(dot_pos + 1);
 }
 
 unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGCopyStmt &stmt) {
@@ -102,15 +38,15 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGCopySt
 
 	// get file_path and is_from
 	info.is_from = stmt.is_from;
-	if (!stmt.filename) {
-		// stdin/stdout
-		info.file_path = info.is_from ? "/dev/stdin" : "/dev/stdout";
-	} else {
-		// copy to a file
-		info.file_path = stmt.filename;
-	}
 
-	info.format = ExtractFormat(info.file_path);
+	info.file_path_expression = TransformExpression(*stmt.filename);
+	if (info.file_path_expression->type == ExpressionType::VALUE_CONSTANT) {
+		auto &constant_expr = info.file_path_expression->Cast<ConstantExpression>();
+		if (constant_expr.value.type().id() == LogicalTypeId::VARCHAR) {
+			info.file_path = StringValue::Get(constant_expr.value);
+			info.file_path_expression.reset();
+		}
+	}
 
 	// get select_list
 	if (stmt.attlist) {

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

@@ -20,31 +20,36 @@ unique_ptr<MacroFunction> Transformer::TransformMacroFunction(duckdb_libpgquery:
 	if (!def.params) {
 		return macro_func;
 	}
-	vector<unique_ptr<ParsedExpression>> parameters;
-	TransformExpressionList(*def.params, parameters);
-	for (auto &param : parameters) {
-		Value const_param;
-		if (ConstructConstantFromExpression(*param, const_param)) {
-			// parameters with default value (must have an alias)
-			if (param->GetAlias().empty()) {
-				throw ParserException("Invalid parameter: '%s'", param->ToString());
-			}
-			if (macro_func->default_parameters.find(param->GetAlias()) != macro_func->default_parameters.end()) {
-				throw ParserException("Duplicate default parameter: '%s'", param->GetAlias());
-			}
-			auto constructed_constant = make_uniq<ConstantExpression>(std::move(const_param));
-			constructed_constant->SetAlias(param->GetAlias());
-			macro_func->default_parameters[param->GetAlias()] = std::move(constructed_constant);
-		} else if (param->GetExpressionClass() == ExpressionClass::COLUMN_REF) {
-			// positional parameters
-			if (!macro_func->default_parameters.empty()) {
-				throw ParserException("Positional parameters cannot come after parameters with a default value!");
+
+	case_insensitive_set_t parameter_names;
+	for (auto node = def.params->head; node != nullptr; node = node->next) {
+		auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
+		if (target->type != duckdb_libpgquery::T_PGFunctionParameter) {
+			throw InternalException("TODO");
+		}
+		auto &param = PGCast<duckdb_libpgquery::PGFunctionParameter>(*target);
+
+		// Transform parameter name/type
+		if (!parameter_names.insert(param.name).second) {
+			throw ParserException("Duplicate parameter '%s' in macro definition", param.name);
+		}
+		macro_func->parameters.emplace_back(make_uniq<ColumnRefExpression>(param.name));
+		macro_func->types.emplace_back(param.typeName ? TransformTypeName(*param.typeName) : LogicalType::UNKNOWN);
+
+		// Transform parameter default value
+		if (param.defaultValue) {
+			auto default_expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(param.defaultValue));
+			Value default_value;
+			if (!ConstructConstantFromExpression(*default_expr, default_value)) {
+				throw ParserException("Invalid default value for parameter '%s': %s", param.name,
+				                      default_expr->ToString());
 			}
-			macro_func->parameters.push_back(std::move(param));
-		} else {
-			throw ParserException("Invalid parameter: '%s'", param->ToString());
+			default_expr = make_uniq<ConstantExpression>(std::move(default_value));
+			default_expr->SetAlias(param.name);
+			macro_func->default_parameters[param.name] = std::move(default_expr);
 		}
 	}
+
 	return macro_func;
 }
 

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

@@ -28,7 +28,6 @@ Vector Transformer::PGListToVector(optional_ptr<duckdb_libpgquery::PGList> colum
 		}
 
 		auto entry_value = string(entry_value_node.val.str);
-		D_ASSERT(!entry_value.empty());
 		result_ptr[size++] = StringVector::AddStringOrBlob(result, entry_value);
 	}
 	return result;

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

@@ -11,8 +11,7 @@ ExplainFormat ParseFormat(const Value &val) {
 	auto format_val = val.GetValue<string>();
 	case_insensitive_map_t<ExplainFormat> format_mapping {
 	    {"default", ExplainFormat::DEFAULT}, {"text", ExplainFormat::TEXT},         {"json", ExplainFormat::JSON},
-	    {"html", ExplainFormat::HTML},       {"graphviz", ExplainFormat::GRAPHVIZ},
-	};
+	    {"html", ExplainFormat::HTML},       {"graphviz", ExplainFormat::GRAPHVIZ}, {"yaml", ExplainFormat::YAML}};
 	auto it = format_mapping.find(format_val);
 	if (it != format_mapping.end()) {
 		return it->second;

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

@@ -22,6 +22,26 @@ unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList
 	return std::move(result);
 }
 
+vector<string> Transformer::TransformInsertColumns(duckdb_libpgquery::PGList &cols) {
+	vector<string> result;
+	for (auto c = cols.head; c != nullptr; c = lnext(c)) {
+		auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
+		result.emplace_back(target->name);
+	}
+	return result;
+}
+
+InsertColumnOrder Transformer::TransformColumnOrder(duckdb_libpgquery::PGInsertColumnOrder insert_column_order) {
+	switch (insert_column_order) {
+	case duckdb_libpgquery::PG_INSERT_BY_POSITION:
+		return InsertColumnOrder::INSERT_BY_POSITION;
+	case duckdb_libpgquery::PG_INSERT_BY_NAME:
+		return InsertColumnOrder::INSERT_BY_NAME;
+	default:
+		throw InternalException("Unrecognized insert column order in TransformInsert");
+	}
+}
+
 unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt) {
 	auto result = make_uniq<InsertStatement>();
 	if (stmt.withClause) {
@@ -30,10 +50,7 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGIn
 
 	// first check if there are any columns specified
 	if (stmt.cols) {
-		for (auto c = stmt.cols->head; c != nullptr; c = lnext(c)) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
-			result->columns.emplace_back(target->name);
-		}
+		result->columns = TransformInsertColumns(*stmt.cols);
 	}
 
 	// Grab and transform the returning columns from the parser.
@@ -64,16 +81,7 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGIn
 		result->on_conflict_info = DummyOnConflictClause(stmt.onConflictAlias, result->schema);
 		result->table_ref = TransformRangeVar(*stmt.relation);
 	}
-	switch (stmt.insert_column_order) {
-	case duckdb_libpgquery::PG_INSERT_BY_POSITION:
-		result->column_order = InsertColumnOrder::INSERT_BY_POSITION;
-		break;
-	case duckdb_libpgquery::PG_INSERT_BY_NAME:
-		result->column_order = InsertColumnOrder::INSERT_BY_NAME;
-		break;
-	default:
-		throw InternalException("Unrecognized insert column order in TransformInsert");
-	}
+	result->column_order = TransformColumnOrder(stmt.insert_column_order);
 	result->catalog = qname.catalog;
 	return result;
 }

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

@@ -0,0 +1,111 @@
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/statement/merge_into_statement.hpp"
+#include "nodes/parsenodes.hpp"
+#include "duckdb/common/enum_util.hpp"
+
+namespace duckdb {
+
+unique_ptr<MergeIntoAction> Transformer::TransformMergeIntoAction(duckdb_libpgquery::PGMatchAction &action) {
+	auto result = make_uniq<MergeIntoAction>();
+	if (action.andClause) {
+		result->condition = TransformExpression(action.andClause);
+	}
+	switch (action.actionType) {
+	case duckdb_libpgquery::MERGE_ACTION_TYPE_UPDATE:
+		result->action_type = MergeActionType::MERGE_UPDATE;
+		if (action.updateTargets) {
+			result->update_info = TransformUpdateSetInfo(action.updateTargets, nullptr);
+		}
+		result->column_order = TransformColumnOrder(action.insert_column_order);
+		break;
+	case duckdb_libpgquery::MERGE_ACTION_TYPE_DELETE:
+		result->action_type = MergeActionType::MERGE_DELETE;
+		break;
+	case duckdb_libpgquery::MERGE_ACTION_TYPE_INSERT:
+		result->action_type = MergeActionType::MERGE_INSERT;
+		if (action.insertCols) {
+			result->insert_columns = TransformInsertColumns(*action.insertCols);
+		}
+		if (action.insertValues) {
+			TransformExpressionList(*action.insertValues, result->expressions);
+		}
+		result->column_order = TransformColumnOrder(action.insert_column_order);
+		result->default_values = action.defaultValues;
+		break;
+	case duckdb_libpgquery::MERGE_ACTION_TYPE_DO_NOTHING:
+		result->action_type = MergeActionType::MERGE_DO_NOTHING;
+		break;
+	case duckdb_libpgquery::MERGE_ACTION_TYPE_ERROR:
+		result->action_type = MergeActionType::MERGE_ERROR;
+		if (action.errorMessage) {
+			result->expressions.push_back(TransformExpression(*action.errorMessage));
+		}
+		break;
+	default:
+		throw InternalException("Unsupported merge into action");
+	}
+	return result;
+}
+
+unique_ptr<SQLStatement> Transformer::TransformMergeInto(duckdb_libpgquery::PGMergeIntoStmt &stmt) {
+	auto result = make_uniq<MergeIntoStatement>();
+
+	if (stmt.withClause) {
+		auto with_clause = PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause);
+		TransformCTE(*with_clause, result->cte_map);
+	}
+	result->target = TransformRangeVar(*stmt.targetTable);
+	result->source = TransformTableRefNode(*stmt.source);
+	if (stmt.joinCondition) {
+		result->join_condition = TransformExpression(*stmt.joinCondition);
+	}
+	if (stmt.usingClause) {
+		result->using_columns = TransformUsingClause(*stmt.usingClause);
+	}
+
+	unique_ptr<MergeIntoAction> when_matched_action;
+	unique_ptr<MergeIntoAction> when_not_matched_action;
+
+	map<MergeActionCondition, unique_ptr<MergeIntoAction>> unconditional_actions;
+	for (auto cell = stmt.matchActions->head; cell; cell = cell->next) {
+		auto match_action = PGPointerCast<duckdb_libpgquery::PGMatchAction>(cell->data.ptr_value);
+		auto action = TransformMergeIntoAction(*match_action);
+		MergeActionCondition action_condition;
+		switch (match_action->when) {
+		case duckdb_libpgquery::MERGE_ACTION_WHEN_MATCHED:
+			action_condition = MergeActionCondition::WHEN_MATCHED;
+			break;
+		case duckdb_libpgquery::MERGE_ACTION_WHEN_NOT_MATCHED_BY_SOURCE:
+			action_condition = MergeActionCondition::WHEN_NOT_MATCHED_BY_SOURCE;
+			break;
+		case duckdb_libpgquery::MERGE_ACTION_WHEN_NOT_MATCHED_BY_TARGET:
+			action_condition = MergeActionCondition::WHEN_NOT_MATCHED_BY_TARGET;
+			break;
+		default:
+			throw InternalException("Unknown merge action");
+		}
+		if (!action->condition) {
+			// unconditional action - check if we already have an unconditional action for this match
+			auto entry = unconditional_actions.find(action_condition);
+			if (entry != unconditional_actions.end()) {
+				string action_condition_str = MergeIntoStatement::ActionConditionToString(action_condition);
+				throw ParserException(
+				    "Unconditional %s clause was already defined - only one unconditional %s clause is supported",
+				    action_condition_str, action_condition_str);
+			}
+			unconditional_actions.emplace(action_condition, std::move(action));
+			continue;
+		}
+		result->actions[action_condition].push_back(std::move(action));
+	}
+	// finally add the unconditional actions
+	for (auto &entry : unconditional_actions) {
+		result->actions[entry.first].push_back(std::move(entry.second));
+	}
+	if (stmt.returningList) {
+		TransformExpressionList(*stmt.returningList, result->returning_list);
+	}
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -125,6 +125,8 @@ unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStateme
 		}
 		result->statements.push_back(GenerateCreateEnumStmt(std::move(pivot)));
 	}
+	result->stmt_location = statement->stmt_location;
+	result->stmt_length = statement->stmt_length;
 	result->statements.push_back(std::move(statement));
 	// FIXME: drop the types again!?
 	//	for(auto &pivot : pivot_entries) {

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

@@ -52,7 +52,7 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGPragm
 			throw ParserException("PRAGMA statement with assignment should contain exactly one parameter");
 		}
 		if (!info.named_parameters.empty()) {
-			throw InternalException("PRAGMA statement with assignment cannot have named parameters");
+			throw ParserException("PRAGMA statement with assignment cannot have named parameters");
 		}
 		// SQLite does not distinguish between:
 		// "PRAGMA table_info='integers'"

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

@@ -15,8 +15,23 @@ unique_ptr<QueryNode> Transformer::TransformShow(duckdb_libpgquery::PGVariableSh
 	select_node->select_list.push_back(make_uniq<StarExpression>());
 	auto showref = make_uniq<ShowRef>();
 	if (stmt.set) {
-		// describing a set (e.g. SHOW ALL TABLES) - push it in the table name
-		showref->table_name = stmt.set;
+		if (std::string(stmt.set) == "__show_tables_from_database") {
+			showref->show_type = ShowType::SHOW_FROM;
+			auto qualified_name = TransformQualifiedName(*stmt.relation);
+			if (!IsInvalidCatalog(qualified_name.catalog)) {
+				throw ParserException("Expected \"SHOW TABLES FROM database\", \"SHOW TABLES FROM schema\", or "
+				                      "\"SHOW TABLES FROM database.schema\"");
+			}
+			if (qualified_name.schema.empty()) {
+				showref->schema_name = qualified_name.name;
+			} else {
+				showref->catalog_name = qualified_name.schema;
+				showref->schema_name = qualified_name.name;
+			}
+		} else {
+			// describing a set (e.g. SHOW ALL TABLES) - push it in the table name
+			showref->table_name = stmt.set;
+		}
 	} else if (!stmt.relation->schemaname) {
 		// describing an unqualified relation - check if this is a "special" relation
 		string table_name = StringUtil::Lower(stmt.relation->relname);
@@ -24,7 +39,7 @@ unique_ptr<QueryNode> Transformer::TransformShow(duckdb_libpgquery::PGVariableSh
 			showref->table_name = "\"" + std::move(table_name) + "\"";
 		}
 	}
-	if (showref->table_name.empty()) {
+	if (showref->table_name.empty() && showref->show_type != ShowType::SHOW_FROM) {
 		// describing a single relation
 		// wrap the relation in a "SELECT * FROM [table_name]" query
 		auto show_select_node = make_uniq<SelectNode>();
@@ -34,7 +49,10 @@ unique_ptr<QueryNode> Transformer::TransformShow(duckdb_libpgquery::PGVariableSh
 		showref->query = std::move(show_select_node);
 	}
 
-	showref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE;
+	// If the show type is set to default, check if summary
+	if (showref->show_type == ShowType::DESCRIBE) {
+		showref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE;
+	}
 	select_node->from_table = std::move(showref);
 	return std::move(select_node);
 }

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

@@ -10,8 +10,9 @@ unique_ptr<TableRef> Transformer::TransformFrom(optional_ptr<duckdb_libpgquery::
 	}
 
 	if (root->length > 1) {
-		// Cross Product
+		// Implicit Cross Product
 		auto result = make_uniq<JoinRef>(JoinRefType::CROSS);
+		result->is_implicit = true;
 		JoinRef *cur_root = result.get();
 		idx_t list_size = 0;
 		for (auto node = root->head; node != nullptr; node = node->next) {
@@ -24,6 +25,7 @@ unique_ptr<TableRef> Transformer::TransformFrom(optional_ptr<duckdb_libpgquery::
 			} else {
 				auto old_res = std::move(result);
 				result = make_uniq<JoinRef>(JoinRefType::CROSS);
+				result->is_implicit = true;
 				result->left = std::move(old_res);
 				result->right = std::move(next);
 				cur_root = result.get();

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

@@ -8,6 +8,17 @@
 
 namespace duckdb {
 
+vector<string> Transformer::TransformUsingClause(duckdb_libpgquery::PGList &usingClause) {
+	vector<string> result;
+	for (auto node = usingClause.head; node != nullptr; node = node->next) {
+		auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
+		D_ASSERT(target->type == duckdb_libpgquery::T_PGString);
+		auto value = PGCast<duckdb_libpgquery::PGValue>(*target.get());
+		result.push_back(string(value.val.str));
+	}
+	return result;
+}
+
 unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &root) {
 	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
 	switch (root.jointype) {
@@ -61,12 +72,7 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r
 	SetQueryLocation(*result, root.location);
 	if (root.usingClause && root.usingClause->length > 0) {
 		// usingClause is a list of strings.
-		for (auto node = root.usingClause->head; node != nullptr; node = node->next) {
-			auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
-			D_ASSERT(target->type == duckdb_libpgquery::T_PGString);
-			auto value = PGCast<duckdb_libpgquery::PGValue>(*target.get());
-			result->using_columns.push_back(string(value.val.str));
-		}
+		result->using_columns = TransformUsingClause(*root.usingClause);
 		return std::move(result);
 	}
 

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

@@ -5,9 +5,6 @@
 namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRangeFunction &root) {
-	if (root.ordinality) {
-		throw NotImplementedException("WITH ORDINALITY not implemented");
-	}
 	if (root.is_rowsfrom) {
 		throw NotImplementedException("ROWS FROM() not implemented");
 	}
@@ -24,6 +21,9 @@ unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRa
 	}
 	// transform the function call
 	auto result = make_uniq<TableFunctionRef>();
+	if (root.ordinality) {
+		result->with_ordinality = OrdinalityType::WITH_ORDINALITY;
+	}
 	switch (call_tree->type) {
 	case duckdb_libpgquery::T_PGFuncCall: {
 		auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(call_tree.get());

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

@@ -223,6 +223,8 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformDropSecret(PGCast<duckdb_libpgquery::PGDropSecretStmt>(stmt));
 	case duckdb_libpgquery::T_PGCommentOnStmt:
 		return TransformCommentOn(PGCast<duckdb_libpgquery::PGCommentOnStmt>(stmt));
+	case duckdb_libpgquery::T_PGMergeIntoStmt:
+		return TransformMergeInto(PGCast<duckdb_libpgquery::PGMergeIntoStmt>(stmt));
 	default:
 		throw NotImplementedException(NodetypeToString(stmt.type));
 	}
@@ -234,13 +236,12 @@ unique_ptr<QueryNode> Transformer::TransformMaterializedCTE(unique_ptr<QueryNode
 
 	for (auto &cte : root->cte_map.map) {
 		auto &cte_entry = cte.second;
-		if (cte_entry->materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
-			auto mat_cte = make_uniq<CTENode>();
-			mat_cte->ctename = cte.first;
-			mat_cte->query = cte_entry->query->node->Copy();
-			mat_cte->aliases = cte_entry->aliases;
-			materialized_ctes.push_back(std::move(mat_cte));
-		}
+		auto mat_cte = make_uniq<CTENode>();
+		mat_cte->ctename = cte.first;
+		mat_cte->query = TransformMaterializedCTE(cte_entry->query->node->Copy());
+		mat_cte->aliases = cte_entry->aliases;
+		mat_cte->materialized = cte_entry->materialized;
+		materialized_ctes.push_back(std::move(mat_cte));
 	}
 
 	while (!materialized_ctes.empty()) {

package/src/duckdb/src/planner/bind_context.cpp

@@ -625,6 +625,13 @@ void BindContext::AddBinding(unique_ptr<Binding> binding) {
 	bindings_list.push_back(std::move(binding));
 }
 
+void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
+                               const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
+                               TableCatalogEntry &entry, virtual_column_map_t virtual_columns) {
+	AddBinding(
+	    make_uniq<TableBinding>(alias, types, names, bound_column_ids, &entry, index, std::move(virtual_columns)));
+}
+
 void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
                                const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
                                TableCatalogEntry &entry, bool add_virtual_columns) {
@@ -632,8 +639,7 @@ void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<st
 	if (add_virtual_columns) {
 		virtual_columns = entry.GetVirtualColumns();
 	}
-	AddBinding(
-	    make_uniq<TableBinding>(alias, types, names, bound_column_ids, &entry, index, std::move(virtual_columns)));
+	AddBaseTable(index, alias, names, types, bound_column_ids, entry, std::move(virtual_columns));
 }
 
 void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
@@ -724,6 +730,17 @@ void BindContext::AddCTEBinding(idx_t index, const string &alias, const vector<s
 	}
 }
 
+void BindContext::RemoveCTEBinding(const std::string &alias) {
+	auto it = cte_bindings.find(alias);
+	if (it != cte_bindings.end()) {
+		cte_bindings.erase(it);
+	}
+	auto it2 = cte_references.find(alias);
+	if (it2 != cte_references.end()) {
+		cte_references.erase(it2);
+	}
+}
+
 void BindContext::AddContext(BindContext other) {
 	for (auto &binding : other.bindings_list) {
 		AddBinding(std::move(binding));

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

@@ -18,6 +18,7 @@
 #include "duckdb/planner/expression_binder/base_select_binder.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -139,8 +140,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 
 			auto &config = DBConfig::GetConfig(context);
 			const auto &order = aggr.order_bys->orders[0];
-			const auto sense =
-			    (order.type == OrderType::ORDER_DEFAULT) ? config.options.default_order_type : order.type;
+			const auto sense = config.ResolveOrder(context, order.type);
 			negate_fractions = (sense == OrderType::DESCENDING);
 		}
 	}
@@ -160,8 +160,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 			if (order.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
 				auto &const_expr = order.expression->Cast<ConstantExpression>();
 				if (!const_expr.value.type().IsIntegral()) {
-					auto &config = ClientConfig::GetConfig(context);
-					if (!config.order_by_non_integer_literal) {
+					auto order_by_non_integer_literal = DBConfig::GetSetting<OrderByNonIntegerLiteralSetting>(context);
+					if (!order_by_non_integer_literal) {
 						throw BinderException(
 						    *order.expression,
 						    "ORDER BY non-integer literal has no effect.\n* SET order_by_non_integer_literal=true to "
@@ -264,6 +264,13 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 	// found a matching function!
 	auto bound_function = func.functions.GetFunctionByOffset(best_function.GetIndex());
 
+	if (!bound_function.CanAggregate() && bound_function.CanWindow()) {
+		auto msg = StringUtil::Format("Function '%s' can only be used as a window function", bound_function.name);
+		error = BinderException(msg);
+		error.AddQueryLocation(aggr);
+		error.Throw();
+	}
+
 	// Bind any sort columns, unless the aggregate is order-insensitive
 	unique_ptr<BoundOrderModifier> order_bys;
 	if (!aggr.order_bys->orders.empty()) {
@@ -272,8 +279,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 		for (auto &order : aggr.order_bys->orders) {
 			auto &order_expr = BoundExpression::GetExpression(*order.expression);
 			PushCollation(context, order_expr, order_expr->return_type);
-			const auto sense = config.ResolveOrder(order.type);
-			const auto null_order = config.ResolveNullOrder(sense, order.null_order);
+			const auto sense = config.ResolveOrder(context, order.type);
+			const auto null_order = config.ResolveNullOrder(context, sense, order.null_order);
 			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr));
 		}
 	}

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

@@ -155,6 +155,9 @@ void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr,
 	case ExpressionType::FUNCTION: {
 		// Special-handling for lambdas, which are inside function expressions.
 		auto &function = expr->Cast<FunctionExpression>();
+		if (!IsUnnestFunction(function.function_name)) {
+			BindAndQualifyFunction(function, false);
+		}
 		if (function.IsLambdaFunction()) {
 			return QualifyColumnNamesInLambda(function, lambda_params);
 		}