duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/planner/binder/statement/bind_execute.cpp

@@ -7,11 +7,12 @@
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 
 namespace duckdb {
 
 BoundStatement Binder::Bind(ExecuteStatement &stmt) {
-	auto parameter_count = stmt.n_param;
+	auto parameter_count = stmt.named_param_map.size();
 
 	// bind the prepared statement
 	auto &client_data = ClientData::Get(context);
@@ -30,24 +31,39 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 
 	auto &mapped_named_values = stmt.named_values;
 	// bind any supplied parameters
-	case_insensitive_map_t<Value> bind_values;
+	case_insensitive_map_t<BoundParameterData> bind_values;
 	auto constant_binder = Binder::CreateBinder(context);
 	constant_binder->SetCanContainNulls(true);
 	for (auto &pair : mapped_named_values) {
+		bool is_literal = pair.second->type == ExpressionType::VALUE_CONSTANT;
+
 		ConstantBinder cbinder(*constant_binder, context, "EXECUTE statement");
 		auto bound_expr = cbinder.Bind(pair.second);
-
-		Value value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true);
-		bind_values[pair.first] = std::move(value);
+		BoundParameterData parameter_data;
+		if (is_literal) {
+			auto &constant = bound_expr->Cast<BoundConstantExpression>();
+			LogicalType return_type;
+			if (constant.return_type == LogicalTypeId::VARCHAR &&
+			    StringType::GetCollation(constant.return_type).empty()) {
+				return_type = LogicalTypeId::STRING_LITERAL;
+			} else if (constant.return_type.IsIntegral()) {
+				return_type = LogicalType::INTEGER_LITERAL(constant.value);
+			} else {
+				return_type = constant.value.type();
+			}
+			parameter_data = BoundParameterData(std::move(constant.value), std::move(return_type));
+		} else {
+			auto value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true);
+			parameter_data = BoundParameterData(std::move(value));
+		}
+		bind_values[pair.first] = std::move(parameter_data);
 	}
 	unique_ptr<LogicalOperator> rebound_plan;
 
 	if (prepared->RequireRebind(context, &bind_values)) {
 		// catalog was modified or statement does not have clear types: rebind the statement before running the execute
 		Planner prepared_planner(context);
-		for (auto &pair : bind_values) {
-			prepared_planner.parameter_data.emplace(std::make_pair(pair.first, BoundParameterData(pair.second)));
-		}
+		prepared_planner.parameter_data = bind_values;
 		prepared = prepared_planner.PrepareSQLStatement(entry->second->unbound_statement->Copy());
 		rebound_plan = std::move(prepared_planner.plan);
 		D_ASSERT(prepared->properties.bound_all_parameters);

package/src/duckdb/src/planner/binder/statement/bind_explain.cpp

@@ -10,8 +10,8 @@ BoundStatement Binder::Bind(ExplainStatement &stmt) {
 	// bind the underlying statement
 	auto plan = Bind(*stmt.stmt);
 	// get the unoptimized logical plan, and create the explain statement
-	auto logical_plan_unopt = plan.plan->ToString();
-	auto explain = make_uniq<LogicalExplain>(std::move(plan.plan), stmt.explain_type);
+	auto logical_plan_unopt = plan.plan->ToString(stmt.explain_format);
+	auto explain = make_uniq<LogicalExplain>(std::move(plan.plan), stmt.explain_type, stmt.explain_format);
 	explain->logical_plan_unopt = logical_plan_unopt;
 
 	result.plan = std::move(explain);

package/src/duckdb/src/planner/binder/statement/bind_export.cpp

@@ -117,100 +117,7 @@ string CreateFileName(const string &id_suffix, TableCatalogEntry &table, const s
 	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
 }
 
-static bool IsSupported(CopyTypeSupport support_level) {
-	// For export purposes we don't want to lose information, so we only accept fully supported types
-	return support_level == CopyTypeSupport::SUPPORTED;
-}
-
-static LogicalType AlterLogicalType(const LogicalType &original, copy_supports_type_t type_check) {
-	D_ASSERT(type_check);
-	auto id = original.id();
-	switch (id) {
-	case LogicalTypeId::LIST: {
-		auto child = AlterLogicalType(ListType::GetChildType(original), type_check);
-		return LogicalType::LIST(child);
-	}
-	case LogicalTypeId::ARRAY: {
-		// Attempt to convert the array to a list
-		auto &child = ArrayType::GetChildType(original);
-		return AlterLogicalType(LogicalType::LIST(child), type_check);
-	}
-	case LogicalTypeId::STRUCT: {
-		auto &original_children = StructType::GetChildTypes(original);
-		child_list_t<LogicalType> new_children;
-		for (auto &child : original_children) {
-			auto &child_name = child.first;
-			auto &child_type = child.second;
-
-			LogicalType new_type;
-			if (!IsSupported(type_check(child_type))) {
-				new_type = AlterLogicalType(child_type, type_check);
-			} else {
-				new_type = child_type;
-			}
-			new_children.push_back(std::make_pair(child_name, new_type));
-		}
-		return LogicalType::STRUCT(std::move(new_children));
-	}
-	case LogicalTypeId::UNION: {
-		auto member_count = UnionType::GetMemberCount(original);
-		child_list_t<LogicalType> new_children;
-		for (idx_t i = 0; i < member_count; i++) {
-			auto &child_name = UnionType::GetMemberName(original, i);
-			auto &child_type = UnionType::GetMemberType(original, i);
-
-			LogicalType new_type;
-			if (!IsSupported(type_check(child_type))) {
-				new_type = AlterLogicalType(child_type, type_check);
-			} else {
-				new_type = child_type;
-			}
-
-			new_children.push_back(std::make_pair(child_name, new_type));
-		}
-		return LogicalType::UNION(std::move(new_children));
-	}
-	case LogicalTypeId::MAP: {
-		auto &key_type = MapType::KeyType(original);
-		auto &value_type = MapType::ValueType(original);
-
-		LogicalType new_key_type;
-		LogicalType new_value_type;
-		if (!IsSupported(type_check(key_type))) {
-			new_key_type = AlterLogicalType(key_type, type_check);
-		} else {
-			new_key_type = key_type;
-		}
-
-		if (!IsSupported(type_check(value_type))) {
-			new_value_type = AlterLogicalType(value_type, type_check);
-		} else {
-			new_value_type = value_type;
-		}
-		return LogicalType::MAP(new_key_type, new_value_type);
-	}
-	default: {
-		D_ASSERT(!IsSupported(type_check(original)));
-		return LogicalType::VARCHAR;
-	}
-	}
-}
-
-static bool NeedsCast(LogicalType &type, copy_supports_type_t type_check) {
-	if (!type_check) {
-		return false;
-	}
-	if (IsSupported(type_check(type))) {
-		// The type is supported in it's entirety, no cast is required
-		return false;
-	}
-	// Change the type to something that is supported
-	type = AlterLogicalType(type, type_check);
-	return true;
-}
-
-static unique_ptr<QueryNode> CreateSelectStatement(CopyStatement &stmt, child_list_t<LogicalType> &select_list,
-                                                   copy_supports_type_t type_check) {
+static unique_ptr<QueryNode> CreateSelectStatement(CopyStatement &stmt, child_list_t<LogicalType> &select_list) {
 	auto ref = make_uniq<BaseTableRef>();
 	ref->catalog_name = stmt.info->catalog;
 	ref->schema_name = stmt.info->schema;
@@ -221,14 +128,7 @@ static unique_ptr<QueryNode> CreateSelectStatement(CopyStatement &stmt, child_li
 
 	vector<unique_ptr<ParsedExpression>> expressions;
 	for (auto &col : select_list) {
-		auto &name = col.first;
-		auto &type = col.second;
-
-		auto expression = make_uniq_base<ParsedExpression, ColumnRefExpression>(name);
-		if (NeedsCast(type, type_check)) {
-			// Add a cast to a type supported by the copy function
-			expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(expression));
-		}
+		auto expression = make_uniq_base<ParsedExpression, ColumnRefExpression>(col.first);
 		expressions.push_back(std::move(expression));
 	}
 
@@ -330,11 +230,11 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		// generate the copy statement and bind it
 		CopyStatement copy_stmt;
 		copy_stmt.info = std::move(info);
-		copy_stmt.info->select_statement =
-		    CreateSelectStatement(copy_stmt, select_list, copy_function.function.supports_type);
+		copy_stmt.info->select_statement = CreateSelectStatement(copy_stmt, select_list);
 
 		auto copy_binder = Binder::CreateBinder(context, this);
-		auto bound_statement = copy_binder->Bind(copy_stmt);
+		auto bound_statement = copy_binder->Bind(copy_stmt, CopyToType::EXPORT_DATABASE);
+
 		auto plan = std::move(bound_statement.plan);
 
 		if (child_operator) {

package/src/duckdb/src/planner/binder/statement/bind_extension.cpp

@@ -23,9 +23,9 @@ BoundStatement Binder::Bind(ExtensionStatement &stmt) {
 	auto &get = result.plan->Cast<LogicalGet>();
 	result.names = get.names;
 	result.types = get.returned_types;
-	get.column_ids.clear();
+	get.ClearColumnIds();
 	for (idx_t i = 0; i < get.returned_types.size(); i++) {
-		get.column_ids.push_back(i);
+		get.AddColumnId(i);
 	}
 	return result;
 }

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/statement/insert_statement.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
@@ -12,13 +13,10 @@
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/planner/expression_binder/returning_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
 #include "duckdb/planner/expression_binder/update_binder.hpp"
-#include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/parser/statement/update_statement.hpp"
 #include "duckdb/planner/expression/bound_default_expression.hpp"
-#include "duckdb/storage/data_table.hpp"
 #include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/planner/bound_tableref.hpp"
@@ -54,18 +52,85 @@ void ReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDe
 	expr = ExpandDefaultExpression(column);
 }
 
-void QualifyColumnReferences(unique_ptr<ParsedExpression> &expr, const string &table_name) {
-	// To avoid ambiguity with 'excluded', we explicitly qualify all column references
-	if (expr->type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = expr->Cast<ColumnRefExpression>();
-		if (column_ref.IsQualified()) {
+void ExpressionBinder::DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name,
+                                                  vector<unordered_set<string>> &lambda_params) {
+
+	for (auto &child : function.children) {
+		if (child->expression_class != ExpressionClass::LAMBDA) {
+			DoUpdateSetQualify(child, table_name, lambda_params);
+			continue;
+		}
+
+		// Special-handling for LHS lambda parameters.
+		// We do not qualify them, and we add them to the lambda_params vector.
+		auto &lambda_expr = child->Cast<LambdaExpression>();
+		string error_message;
+		auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message);
+
+		if (!error_message.empty()) {
+			// Possibly a JSON function, qualify both LHS and RHS.
+			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.lhs, [&](unique_ptr<ParsedExpression> &child) {
+				DoUpdateSetQualify(child, table_name, lambda_params);
+			});
+			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
+				DoUpdateSetQualify(child, table_name, lambda_params);
+			});
+			continue;
+		}
+
+		// Push the lambda parameter names of this level.
+		lambda_params.emplace_back();
+		for (const auto &column_ref_expr : column_ref_expressions) {
+			const auto &column_ref = column_ref_expr.get().Cast<ColumnRefExpression>();
+			lambda_params.back().emplace(column_ref.GetName());
+		}
+
+		// Only qualify in the RHS of the expression.
+		ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
+			DoUpdateSetQualify(child, table_name, lambda_params);
+		});
+
+		lambda_params.pop_back();
+	}
+}
+
+void ExpressionBinder::DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, const string &table_name,
+                                          vector<unordered_set<string>> &lambda_params) {
+
+	// We avoid ambiguity with EXCLUDED columns by qualifying all column references.
+	switch (expr->GetExpressionClass()) {
+	case ExpressionClass::COLUMN_REF: {
+		auto &col_ref = expr->Cast<ColumnRefExpression>();
+		if (col_ref.IsQualified()) {
 			return;
 		}
-		auto column_name = column_ref.GetColumnName();
-		expr = make_uniq<ColumnRefExpression>(column_name, table_name);
+
+		// Don't qualify lambda parameters.
+		if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) {
+			return;
+		}
+
+		// Qualify the column reference.
+		expr = make_uniq<ColumnRefExpression>(col_ref.GetColumnName(), table_name);
+		return;
+	}
+	case ExpressionClass::FUNCTION: {
+		// Special-handling for lambdas, which are inside function expressions.
+		auto &function = expr->Cast<FunctionExpression>();
+		if (function.IsLambdaFunction()) {
+			return DoUpdateSetQualifyInLambda(function, table_name, lambda_params);
+		}
+		break;
+	}
+	case ExpressionClass::SUBQUERY: {
+		throw BinderException("DO UPDATE SET clause cannot contain a subquery");
+	}
+	default:
+		break;
 	}
+
 	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { QualifyColumnReferences(child, table_name); });
+	    *expr, [&](unique_ptr<ParsedExpression> &child) { DoUpdateSetQualify(child, table_name, lambda_params); });
 }
 
 // Replace binding.table_index with 'dest' if it's 'source'
@@ -110,18 +175,17 @@ void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert
 		if (expr->type == ExpressionType::VALUE_DEFAULT) {
 			expr = ExpandDefaultExpression(column);
 		}
-		UpdateBinder binder(*this, context);
-		binder.target_type = column.Type();
 
-		// Avoid ambiguity issues
-		QualifyColumnReferences(expr, table_alias);
+		// Qualify and bind the ON CONFLICT DO UPDATE SET expression.
+		UpdateBinder update_binder(*this, context);
+		update_binder.target_type = column.Type();
 
-		auto bound_expr = binder.Bind(expr);
-		D_ASSERT(bound_expr);
-		if (bound_expr->expression_class == ExpressionClass::BOUND_SUBQUERY) {
-			throw BinderException("Expression in the DO UPDATE SET clause can not be a subquery");
-		}
+		// Avoid ambiguity between existing table columns and EXCLUDED columns.
+		vector<unordered_set<string>> lambda_params;
+		update_binder.DoUpdateSetQualify(expr, table_alias, lambda_params);
 
+		auto bound_expr = update_binder.Bind(expr);
+		D_ASSERT(bound_expr);
 		insert.expressions.push_back(std::move(bound_expr));
 	}
 
@@ -137,7 +201,8 @@ void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert
 	for (idx_t i = 0; i < logical_column_ids.size(); i++) {
 		auto &column = logical_column_ids[i];
 		if (indexed_columns.count(column)) {
-			throw BinderException("Can not assign to column '%s' because it has a UNIQUE/PRIMARY KEY constraint",
+			throw BinderException("Can not assign to column '%s' because it has a UNIQUE/PRIMARY KEY constraint or is "
+			                      "referenced by an INDEX",
 			                      column_names[i]);
 		}
 	}
@@ -230,7 +295,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 			auto entry = specified_columns.find(col.Name());
 			if (entry != specified_columns.end()) {
 				// column was specified, set to the index
-				insert.on_conflict_filter.insert(col.Oid());
+				insert.on_conflict_filter.insert(col.Physical().index);
 			}
 		}
 		bool index_references_columns = false;
@@ -247,8 +312,8 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		if (!index_references_columns) {
 			// Same as before, this is essentially a no-op, turning this into a DO THROW instead
 			// But since this makes no logical sense, it's probably better to throw an error
-			throw BinderException(
-			    "The specified columns as conflict target are not referenced by a UNIQUE/PRIMARY KEY CONSTRAINT");
+			throw BinderException("The specified columns as conflict target are not referenced by a UNIQUE/PRIMARY KEY "
+			                      "CONSTRAINT or INDEX");
 		}
 	} else {
 		// When omitting the conflict target, the ON CONFLICT applies to every UNIQUE/PRIMARY KEY on the table
@@ -288,23 +353,26 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	// add a bind context entry for it
 	auto excluded_index = GenerateTableIndex();
 	insert.excluded_table_index = excluded_index;
-	auto table_column_names = columns.GetColumnNames();
-	auto table_column_types = columns.GetColumnTypes();
+	vector<string> table_column_names;
+	vector<LogicalType> table_column_types;
+	for (auto &col : columns.Physical()) {
+		table_column_names.push_back(col.Name());
+		table_column_types.push_back(col.Type());
+	}
 	bind_context.AddGenericBinding(excluded_index, "excluded", table_column_names, table_column_types);
 
 	if (on_conflict.condition) {
-		// Avoid ambiguity between <table_name> binding and 'excluded'
-		QualifyColumnReferences(on_conflict.condition, table_alias);
-		// Bind the ON CONFLICT ... WHERE clause
 		WhereBinder where_binder(*this, context);
+
+		// Avoid ambiguity between existing table columns and EXCLUDED columns.
+		vector<unordered_set<string>> lambda_params;
+		where_binder.DoUpdateSetQualify(on_conflict.condition, table_alias, lambda_params);
+
+		// Bind the ON CONFLICT ... WHERE clause.
 		auto condition = where_binder.Bind(on_conflict.condition);
-		if (condition && condition->expression_class == ExpressionClass::BOUND_SUBQUERY) {
-			throw BinderException("conflict_target WHERE clause can not be a subquery");
-		}
 		insert.on_conflict_condition = std::move(condition);
 	}
 
-	auto bindings = insert.children[0]->GetColumnBindings();
 	optional_idx projection_index;
 	reference<vector<unique_ptr<LogicalOperator>>> insert_child_operators = insert.children;
 	while (!projection_index.IsValid()) {
@@ -363,14 +431,14 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
 
 	if (set_info.condition) {
-		// Avoid ambiguity between <table_name> binding and 'excluded'
-		QualifyColumnReferences(set_info.condition, table_alias);
-		// Bind the SET ... WHERE clause
 		WhereBinder where_binder(*this, context);
+
+		// Avoid ambiguity between existing table columns and EXCLUDED columns.
+		vector<unordered_set<string>> lambda_params;
+		where_binder.DoUpdateSetQualify(set_info.condition, table_alias, lambda_params);
+
+		// Bind the SET ... WHERE clause.
 		auto condition = where_binder.Bind(set_info.condition);
-		if (condition && condition->expression_class == ExpressionClass::BOUND_SUBQUERY) {
-			throw BinderException("conflict_target WHERE clause can not be a subquery");
-		}
 		insert.do_update_condition = std::move(condition);
 	}
 
@@ -403,7 +471,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	if (!table.temporary) {
 		// inserting into a non-temporary table: alters underlying database
 		auto &properties = GetStatementProperties();
-		properties.modified_databases.insert(table.catalog.GetName());
+		properties.RegisterDBModify(table.catalog, context);
 	}
 
 	auto insert = make_uniq<LogicalInsert>(table, GenerateTableIndex());
@@ -487,7 +555,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		expr_list.expected_types.resize(expected_columns);
 		expr_list.expected_names.resize(expected_columns);
 
-		D_ASSERT(expr_list.values.size() > 0);
+		D_ASSERT(!expr_list.values.empty());
 		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
 		                               table.name.c_str());
 

package/src/duckdb/src/planner/binder/statement/bind_set.cpp

@@ -4,6 +4,8 @@
 #include "duckdb/planner/operator/logical_reset.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
+#include "duckdb/parser/tableref/emptytableref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 
 namespace duckdb {
 
@@ -13,15 +15,29 @@ BoundStatement Binder::Bind(SetVariableStatement &stmt) {
 	result.names = {"Success"};
 
 	// evaluate the scalar value
-	ConstantBinder default_binder(*this, context, "SET value");
-	auto bound_value = default_binder.Bind(stmt.value);
-	if (bound_value->HasParameter()) {
-		throw NotImplementedException("SET statements cannot have parameters");
+	Value value;
+	unique_ptr<LogicalOperator> op;
+	if (stmt.scope != SetScope::VARIABLE) {
+		ConstantBinder default_binder(*this, context, "SET value");
+		auto bound_value = default_binder.Bind(stmt.value);
+		if (bound_value->HasParameter()) {
+			throw NotImplementedException("SET statements cannot have parameters");
+		}
+		value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
+	} else {
+		auto select_node = make_uniq<SelectNode>();
+		select_node->select_list.push_back(std::move(stmt.value));
+		select_node->from_table = make_uniq<EmptyTableRef>();
+		auto bound_select = Bind(*select_node);
+		if (bound_select.types.size() > 1) {
+			throw BinderException("SET variable expected a single input");
+		}
+		op = std::move(bound_select.plan);
 	}
-	auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
-
 	result.plan = make_uniq<LogicalSet>(stmt.name, std::move(value), stmt.scope);
-
+	if (op) {
+		result.plan->children.push_back(std::move(op));
+	}
 	auto &properties = GetStatementProperties();
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

package/src/duckdb/src/planner/binder/statement/bind_simple.cpp

@@ -35,9 +35,12 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 	if (entry) {
 		D_ASSERT(!entry->deleted);
 		auto &catalog = entry->ParentCatalog();
+		if (catalog.IsSystemCatalog()) {
+			throw BinderException("Can not comment on System Catalog entries");
+		}
 		if (!entry->temporary) {
 			// we can only alter temporary tables/views in read-only mode
-			properties.modified_databases.insert(catalog.GetName());
+			properties.RegisterDBModify(catalog, context);
 		}
 		stmt.info->catalog = catalog.GetName();
 		stmt.info->schema = entry->ParentSchema().name;

package/src/duckdb/src/planner/binder/statement/bind_summarize.cpp

@@ -1,7 +1,9 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/case_expression.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
 #include "duckdb/parser/tableref/showref.hpp"
@@ -64,7 +66,16 @@ static unique_ptr<ParsedExpression> SummarizeCreateNullPercentage(string column_
 	auto percentage_x =
 	    SummarizeCreateBinaryFunction("*", std::move(negate_x), make_uniq<ConstantExpression>(Value::DOUBLE(100)));
 
-	return make_uniq<CastExpression>(LogicalType::DECIMAL(9, 2), std::move(percentage_x));
+	auto comp_expr = make_uniq<ComparisonExpression>(ExpressionType::COMPARE_GREATERTHAN, SummarizeCreateCountStar(),
+	                                                 make_uniq<ConstantExpression>(Value::BIGINT(0)));
+	auto case_expr = make_uniq<CaseExpression>();
+	CaseCheck check;
+	check.when_expr = std::move(comp_expr);
+	check.then_expr = std::move(percentage_x);
+	case_expr->case_checks.push_back(std::move(check));
+	case_expr->else_expr = make_uniq<ConstantExpression>(Value());
+
+	return make_uniq<CastExpression>(LogicalType::DECIMAL(9, 2), std::move(case_expr));
 }
 
 unique_ptr<BoundTableRef> Binder::BindSummarize(ShowRef &ref) {
@@ -112,12 +123,15 @@ unique_ptr<BoundTableRef> Binder::BindSummarize(ShowRef &ref) {
 		if (plan.types[i].IsNumeric()) {
 			avg_children.push_back(SummarizeCreateAggregate("avg", plan.names[i]));
 			std_children.push_back(SummarizeCreateAggregate("stddev", plan.names[i]));
+		} else {
+			avg_children.push_back(make_uniq<ConstantExpression>(Value()));
+			std_children.push_back(make_uniq<ConstantExpression>(Value()));
+		}
+		if (plan.types[i].IsNumeric() || plan.types[i].IsTemporal()) {
 			q25_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.25)));
 			q50_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.50)));
 			q75_children.push_back(SummarizeCreateAggregate("approx_quantile", plan.names[i], Value::FLOAT(0.75)));
 		} else {
-			avg_children.push_back(make_uniq<ConstantExpression>(Value()));
-			std_children.push_back(make_uniq<ConstantExpression>(Value()));
 			q25_children.push_back(make_uniq<ConstantExpression>(Value()));
 			q50_children.push_back(make_uniq<ConstantExpression>(Value()));
 			q75_children.push_back(make_uniq<ConstantExpression>(Value()));

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -97,7 +97,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	if (!table.temporary) {
 		// update of persistent table: not read only!
 		auto &properties = GetStatementProperties();
-		properties.modified_databases.insert(table.catalog.GetName());
+		properties.RegisterDBModify(table.catalog, context);
 	}
 	auto update = make_uniq<LogicalUpdate>(table);
 
@@ -131,9 +131,10 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	table.BindUpdateConstraints(*this, *get, *proj, *update, context);
 
 	// finally add the row id column to the projection list
-	proj->expressions.push_back(make_uniq<BoundColumnRefExpression>(
-	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));
-	get->column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
+	auto &column_ids = get->GetColumnIds();
+	proj->expressions.push_back(
+	    make_uniq<BoundColumnRefExpression>(LogicalType::ROW_TYPE, ColumnBinding(get->table_index, column_ids.size())));
+	get->AddColumnId(COLUMN_IDENTIFIER_ROW_ID);
 
 	// set the projection as child of the update node and finalize the result
 	update->AddChild(std::move(proj));

package/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp

@@ -17,7 +17,7 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator>
 	D_ASSERT(vacuum.column_id_map.empty());
 	auto bound_table = Bind(*info.ref);
 	if (bound_table->type != TableReferenceType::BASE_TABLE) {
-		throw InvalidInputException("Can only vacuum/analyze base tables!");
+		throw InvalidInputException("can only vacuum or analyze base tables");
 	}
 	auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(std::move(bound_table));
 	auto &table = ref->table;
@@ -35,7 +35,8 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator>
 	vector<string> non_generated_column_names;
 	for (auto &col_name : columns) {
 		if (column_name_set.count(col_name) > 0) {
-			throw BinderException("Vacuum the same column twice(same name in column name list)");
+			throw BinderException("cannot vacuum or analyze the same column twice, i.e., there is a duplicate entry in "
+			                      "the list of column names");
 		}
 		column_name_set.insert(col_name);
 		if (!table.ColumnExists(col_name)) {
@@ -63,10 +64,11 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator>
 
 	auto &get = table_scan->Cast<LogicalGet>();
 
-	D_ASSERT(select_list.size() == get.column_ids.size());
-	D_ASSERT(info.columns.size() == get.column_ids.size());
-	for (idx_t i = 0; i < get.column_ids.size(); i++) {
-		vacuum.column_id_map[i] = table.GetColumns().LogicalToPhysical(LogicalIndex(get.column_ids[i])).index;
+	auto &column_ids = get.GetColumnIds();
+	D_ASSERT(select_list.size() == column_ids.size());
+	D_ASSERT(info.columns.size() == column_ids.size());
+	for (idx_t i = 0; i < column_ids.size(); i++) {
+		vacuum.column_id_map[i] = table.GetColumns().LogicalToPhysical(LogicalIndex(column_ids[i])).index;
 	}
 
 	auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));