duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -3,6 +3,7 @@
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
@@ -14,6 +15,7 @@
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
+#include "duckdb/parser/parsed_data/create_secret_info.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/planner/binder.hpp"
@@ -39,6 +41,7 @@
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/function/table/table_scan.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
 
 namespace duckdb {
 
@@ -136,12 +139,8 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	if (base.aliases.size() > query_node.names.size()) {
 		throw BinderException("More VIEW aliases than columns in query result");
 	}
-	// fill up the aliases with the remaining names of the bound query
-	base.aliases.reserve(query_node.names.size());
-	for (idx_t i = base.aliases.size(); i < query_node.names.size(); i++) {
-		base.aliases.push_back(query_node.names[i]);
-	}
 	base.types = query_node.types;
+	base.names = query_node.names;
 }
 
 SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
@@ -156,8 +155,8 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	vector<LogicalType> dummy_types;
 	vector<string> dummy_names;
 	// positional parameters
-	for (idx_t i = 0; i < base.function->parameters.size(); i++) {
-		auto param = base.function->parameters[i]->Cast<ColumnRefExpression>();
+	for (auto &param_expr : base.function->parameters) {
+		auto param = param_expr->Cast<ColumnRefExpression>();
 		if (param.IsQualified()) {
 			throw BinderException("Invalid parameter name '%s': must be unqualified", param.ToString());
 		}
@@ -165,27 +164,27 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 		dummy_names.push_back(param.GetColumnName());
 	}
 	// default parameters
-	for (auto it = base.function->default_parameters.begin(); it != base.function->default_parameters.end(); it++) {
-		auto &val = it->second->Cast<ConstantExpression>();
+	for (auto &entry : base.function->default_parameters) {
+		auto &val = entry.second->Cast<ConstantExpression>();
 		dummy_types.push_back(val.value.type());
-		dummy_names.push_back(it->first);
+		dummy_names.push_back(entry.first);
 	}
 	auto this_macro_binding = make_uniq<DummyBinding>(dummy_types, dummy_names, base.name);
 	macro_binding = this_macro_binding.get();
-	ExpressionBinder::QualifyColumnNames(*this, scalar_function.expression);
 
 	// create a copy of the expression because we do not want to alter the original
 	auto expression = scalar_function.expression->Copy();
+	ExpressionBinder::QualifyColumnNames(*this, expression);
 
 	// bind it to verify the function was defined correctly
-	string error;
+	ErrorData error;
 	auto sel_node = make_uniq<BoundSelectNode>();
 	auto group_info = make_uniq<BoundGroupInformation>();
 	SelectBinder binder(*this, context, *sel_node, *group_info);
 	error = binder.Bind(expression, 0, false);
 
-	if (!error.empty()) {
-		throw BinderException(error);
+	if (error.HasError()) {
+		error.Throw();
 	}
 
 	return BindCreateSchema(info);
@@ -214,6 +213,13 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional
 		auto alias = type.GetAlias();
 		type = LogicalType::STRUCT(child_types);
 		type.SetAlias(alias);
+	} else if (type.id() == LogicalTypeId::ARRAY) {
+		auto child_type = ArrayType::GetChildType(type);
+		auto array_size = ArrayType::GetSize(type);
+		BindLogicalType(context, child_type, catalog, schema);
+		auto alias = type.GetAlias();
+		type = LogicalType::ARRAY(child_type, array_size);
+		type.SetAlias(alias);
 	} else if (type.id() == LogicalTypeId::UNION) {
 		auto member_types = UnionType::CopyMemberTypes(type);
 		for (auto &member_type : member_types) {
@@ -237,10 +243,13 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional
 			}
 
 			if (type.id() == LogicalTypeId::INVALID) {
-				type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
+				type = Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, user_type_name);
 			}
 		} else {
-			type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
+			string type_catalog = UserType::GetCatalog(type);
+			string type_schema = UserType::GetSchema(type);
+			BindSchemaOrCatalog(context, type_catalog, type_schema);
+			type = Catalog::GetType(context, type_catalog, type_schema, user_type_name);
 		}
 		BindLogicalType(context, type, catalog, schema);
 	}
@@ -623,19 +632,26 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			result.plan->AddChild(std::move(query));
 		} else if (create_type_info.type.id() == LogicalTypeId::USER) {
 			// two cases:
-			// 1: create a type with a non-existant type as source, catalog.GetType(...) will throw exception.
+			// 1: create a type with a non-existent type as source, Binder::BindLogicalType(...) will throw exception.
 			// 2: create a type alias with a custom type.
 			// eg. CREATE TYPE a AS INT; CREATE TYPE b AS a;
 			// We set b to be an alias for the underlying type of a
-			auto inner_type = Catalog::GetType(context, schema.catalog.GetName(), schema.name,
-			                                   UserType::GetTypeName(create_type_info.type));
-			inner_type.SetAlias(create_type_info.name);
-			create_type_info.type = inner_type;
+			create_type_info.type = Catalog::GetType(context, schema.catalog.GetName(), schema.name,
+			                                         UserType::GetTypeName(create_type_info.type));
+		} else {
+			auto preserved_type = create_type_info.type;
+			BindLogicalType(context, create_type_info.type);
+			create_type_info.type = preserved_type;
 		}
 		break;
 	}
+	case CatalogType::SECRET_ENTRY: {
+		CatalogTransaction transaction = CatalogTransaction(Catalog::GetSystemCatalog(context), context);
+		properties.return_type = StatementReturnType::QUERY_RESULT;
+		return SecretManager::Get(context).BindCreateSecret(transaction, stmt.info->Cast<CreateSecretInfo>());
+	}
 	default:
-		throw Exception("Unrecognized type!");
+		throw InternalException("Unrecognized type!");
 	}
 	properties.return_type = StatementReturnType::NOTHING;
 	properties.allow_stream_result = false;

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

@@ -19,6 +19,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/expression_binder/index_binder.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 
 #include <algorithm>
 
@@ -170,9 +171,9 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
 	auto binder = Binder::CreateBinder(context);
 	binder->bind_context.AddGenericBinding(table_index, base.table, names, types);
 	auto expr_binder = ExpressionBinder(*binder, context);
-	string ignore;
+	ErrorData ignore;
 	auto table_binding = binder->bind_context.GetBinding(base.table, ignore);
-	D_ASSERT(table_binding && ignore.empty());
+	D_ASSERT(table_binding && !ignore.HasError());
 
 	auto bind_order = info.column_dependency_manager.GetBindOrder(base.columns);
 	logical_index_set_t bound_indices;
@@ -211,10 +212,13 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
 void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults) {
 	for (auto &column : columns.Physical()) {
 		unique_ptr<Expression> bound_default;
-		if (column.DefaultValue()) {
+		if (column.HasDefaultValue()) {
 			// we bind a copy of the DEFAULT value because binding is destructive
 			// and we want to keep the original expression around for serialization
-			auto default_copy = column.DefaultValue()->Copy();
+			auto default_copy = column.DefaultValue().Copy();
+			if (default_copy->HasParameter()) {
+				throw BinderException("DEFAULT values cannot contain parameters");
+			}
 			ConstantBinder default_binder(*this, context, "DEFAULT value");
 			default_binder.target_type = column.Type();
 			bound_default = default_binder.Bind(default_copy);
@@ -304,15 +308,4 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 	return BindCreateTableInfo(std::move(info), schema);
 }
 
-vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry &table, CreateIndexInfo &info) {
-	auto index_binder = IndexBinder(*this, this->context, &table, &info);
-	vector<unique_ptr<Expression>> expressions;
-	expressions.reserve(info.expressions.size());
-	for (auto &expr : info.expressions) {
-		expressions.push_back(index_binder.Bind(expr));
-	}
-
-	return expressions;
-}
-
 } // namespace duckdb

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

@@ -50,8 +50,13 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		stmt.info->schema = entry->ParentSchema().name;
 		break;
 	}
+	case CatalogType::SECRET_ENTRY: {
+		//! Secrets are stored in the secret manager; they can always be dropped
+		properties.requires_valid_transaction = false;
+		break;
+	}
 	default:
-		throw BinderException("Unknown catalog type for drop statement!");
+		throw BinderException("Unknown catalog type for drop statement: '%s'", CatalogTypeToString(stmt.info->type));
 	}
 	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, std::move(stmt.info));
 	result.names = {"Success"};

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

@@ -284,7 +284,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 			auto full_path = fs.JoinPath(directory, name);
 			info->file_path = full_path;
 			auto insert_result = table_name_index.insert(info->file_path);
-			if (insert_result.second == true) {
+			if (insert_result.second) {
 				// this name was not yet taken: take it
 				break;
 			}
@@ -326,7 +326,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		if (child_operator) {
 			// use UNION ALL to combine the individual copy statements into a single node
 			auto copy_union = make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
-			                                                 std::move(plan), LogicalOperatorType::LOGICAL_UNION);
+			                                                 std::move(plan), LogicalOperatorType::LOGICAL_UNION, true);
 			child_operator = std::move(copy_union);
 		} else {
 			child_operator = std::move(plan);

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

@@ -26,6 +26,7 @@
 #include "duckdb/planner/tableref/bound_dummytableref.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
 
 namespace duckdb {
 
@@ -41,8 +42,8 @@ static void CheckInsertColumnCountMismatch(int64_t expected_columns, int64_t res
 }
 
 unique_ptr<ParsedExpression> ExpandDefaultExpression(const ColumnDefinition &column) {
-	if (column.DefaultValue()) {
-		return column.DefaultValue()->Copy();
+	if (column.HasDefaultValue()) {
+		return column.DefaultValue().Copy();
 	} else {
 		return make_uniq<ConstantExpression>(Value(column.Type()));
 	}
@@ -269,12 +270,13 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		if (!found_matching_indexes) {
 			throw BinderException(
 			    "There are no UNIQUE/PRIMARY KEY Indexes that refer to this table, ON CONFLICT is a no-op");
-		}
-		if (insert.action_type != OnConflictAction::NOTHING && found_matching_indexes != 1) {
-			// When no conflict target is provided, and the action type is UPDATE,
-			// we only allow the operation when only a single Index exists
-			throw BinderException("Conflict target has to be provided for a DO UPDATE operation when the table has "
-			                      "multiple UNIQUE/PRIMARY KEY constraints");
+		} else if (storage_info.index_info.size() != 1) {
+			if (insert.action_type != OnConflictAction::NOTHING) {
+				// When no conflict target is provided, and the action type is UPDATE,
+				// we only allow the operation when only a single Index exists
+				throw BinderException("Conflict target has to be provided for a DO UPDATE operation when the table has "
+				                      "multiple UNIQUE/PRIMARY KEY constraints");
+			}
 		}
 	}
 
@@ -322,9 +324,9 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		throw InternalException("Could not locate a table_index from the children of the insert");
 	}
 
-	string unused;
+	ErrorData unused;
 	auto original_binding = bind_context.GetBinding(table_alias, unused);
-	D_ASSERT(original_binding);
+	D_ASSERT(original_binding && !unused.HasError());
 
 	auto table_index = original_binding->index;
 

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

@@ -4,33 +4,57 @@
 #include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/function/function_binder.hpp"
+#include "duckdb/planner/expression_binder/constant_binder.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
 
-BoundStatement Binder::Bind(PragmaStatement &stmt) {
+unique_ptr<BoundPragmaInfo> Binder::BindPragma(PragmaInfo &info, QueryErrorContext error_context) {
+	vector<Value> params;
+	named_parameter_map_t named_parameters;
+
+	// resolve the parameters
+	ConstantBinder pragma_binder(*this, context, "PRAGMA value");
+	for (auto &param : info.parameters) {
+		auto bound_value = pragma_binder.Bind(param);
+		auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
+		params.push_back(std::move(value));
+	}
+
+	for (auto &entry : info.named_parameters) {
+		auto bound_value = pragma_binder.Bind(entry.second);
+		auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
+		named_parameters.insert(make_pair(entry.first, std::move(value)));
+	}
+
 	// bind the pragma function
-	auto &entry =
-	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->name);
-	string error;
+	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
 	FunctionBinder function_binder(context);
-	idx_t bound_idx = function_binder.BindFunction(entry.name, entry.functions, *stmt.info, error);
+	ErrorData error;
+	idx_t bound_idx = function_binder.BindFunction(entry.name, entry.functions, params, error);
 	if (bound_idx == DConstants::INVALID_INDEX) {
-		throw BinderException(FormatError(stmt.stmt_location, error));
+		D_ASSERT(error.HasError());
+		error.AddQueryLocation(error_context);
+		error.Throw();
 	}
 	auto bound_function = entry.functions.GetFunctionByOffset(bound_idx);
-	if (!bound_function.function) {
+	// bind and check named params
+	BindNamedParameters(bound_function.named_parameters, named_parameters, error_context, bound_function.name);
+	return make_uniq<BoundPragmaInfo>(std::move(bound_function), std::move(params), std::move(named_parameters));
+}
+
+BoundStatement Binder::Bind(PragmaStatement &stmt) {
+	// bind the pragma function
+	QueryErrorContext error_context(stmt.stmt_location);
+	auto bound_info = BindPragma(*stmt.info, error_context);
+	if (!bound_info->function.function) {
 		throw BinderException("PRAGMA function does not have a function specified");
 	}
 
-	// bind and check named params
-	QueryErrorContext error_context(root_statement, stmt.stmt_location);
-	BindNamedParameters(bound_function.named_parameters, stmt.info->named_parameters, error_context,
-	                    bound_function.name);
-
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	result.plan = make_uniq<LogicalPragma>(bound_function, *stmt.info);
+	result.plan = make_uniq<LogicalPragma>(std::move(bound_info));
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }

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

@@ -2,7 +2,8 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_set.hpp"
 #include "duckdb/planner/operator/logical_reset.hpp"
-#include <algorithm>
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression_binder/constant_binder.hpp"
 
 namespace duckdb {
 
@@ -11,7 +12,12 @@ BoundStatement Binder::Bind(SetVariableStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
-	result.plan = make_uniq<LogicalSet>(stmt.name, stmt.value, stmt.scope);
+	// evaluate the scalar value
+	ConstantBinder default_binder(*this, context, "SET value");
+	auto bound_value = default_binder.Bind(stmt.value);
+	auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
+
+	result.plan = make_uniq<LogicalSet>(stmt.name, std::move(value), stmt.scope);
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }

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

@@ -17,9 +17,11 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
+
 	auto entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
 	                               stmt.info->name, stmt.info->if_not_found);
 	if (entry) {
+		D_ASSERT(!entry->deleted);
 		auto &catalog = entry->ParentCatalog();
 		if (!entry->temporary) {
 			// we can only alter temporary tables/views in read-only mode

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

@@ -1,11 +1,13 @@
 #include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/show_statement.hpp"
-#include "duckdb/planner/operator/logical_show.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
+#include "duckdb/parser/tableref/showref.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/planner/bound_tableref.hpp"
 
 namespace duckdb {
 
@@ -61,20 +63,30 @@ static unique_ptr<ParsedExpression> SummarizeCreateNullPercentage(string column_
 	    SummarizeCreateBinaryFunction("-", make_uniq<ConstantExpression>(Value::DOUBLE(1)), std::move(null_percentage));
 	auto percentage_x =
 	    SummarizeCreateBinaryFunction("*", std::move(negate_x), make_uniq<ConstantExpression>(Value::DOUBLE(100)));
-	auto round_x = SummarizeCreateBinaryFunction("round", std::move(percentage_x),
-	                                             make_uniq<ConstantExpression>(Value::INTEGER(2)));
-	auto concat_x =
-	    SummarizeCreateBinaryFunction("concat", std::move(round_x), make_uniq<ConstantExpression>(Value("%")));
 
-	return concat_x;
+	return make_uniq<CastExpression>(LogicalType::DECIMAL(9, 2), std::move(percentage_x));
 }
 
-BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
-	auto query_copy = stmt.info->query->Copy();
+unique_ptr<BoundTableRef> Binder::BindSummarize(ShowRef &ref) {
+	unique_ptr<QueryNode> query;
+	if (ref.query) {
+		query = std::move(ref.query);
+	} else {
+		auto table_name = QualifiedName::Parse(ref.table_name);
+		auto node = make_uniq<SelectNode>();
+		node->select_list.push_back(make_uniq<StarExpression>());
+		auto basetableref = make_uniq<BaseTableRef>();
+		basetableref->catalog_name = table_name.catalog;
+		basetableref->schema_name = table_name.schema;
+		basetableref->table_name = table_name.name;
+		node->from_table = std::move(basetableref);
+		query = std::move(node);
+	}
+	auto query_copy = query->Copy();
 
 	// we bind the plan once in a child-node to figure out the column names and column types
-	auto child_binder = Binder::CreateBinder(context);
-	auto plan = child_binder->Bind(*stmt.info->query);
+	auto child_binder = Binder::CreateBinder(context, this);
+	auto plan = child_binder->Bind(*query);
 	D_ASSERT(plan.types.size() == plan.names.size());
 	vector<unique_ptr<ParsedExpression>> name_children;
 	vector<unique_ptr<ParsedExpression>> type_children;
@@ -95,7 +107,8 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 		type_children.push_back(make_uniq<ConstantExpression>(Value(plan.types[i].ToString())));
 		min_children.push_back(SummarizeCreateAggregate("min", plan.names[i]));
 		max_children.push_back(SummarizeCreateAggregate("max", plan.names[i]));
-		unique_children.push_back(SummarizeCreateAggregate("approx_count_distinct", plan.names[i]));
+		unique_children.push_back(make_uniq<CastExpression>(
+		    LogicalType::BIGINT, SummarizeCreateAggregate("approx_count_distinct", plan.names[i])));
 		if (plan.types[i].IsNumeric()) {
 			avg_children.push_back(SummarizeCreateAggregate("avg", plan.names[i]));
 			std_children.push_back(SummarizeCreateAggregate("stddev", plan.names[i]));
@@ -130,8 +143,10 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 	select_node->select_list.push_back(SummarizeWrapUnnest(null_percentage_children, "null_percentage"));
 	select_node->from_table = std::move(subquery_ref);
 
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return Bind(*select_node);
+	auto select_stmt = make_uniq<SelectStatement>();
+	select_stmt->node = std::move(select_node);
+	auto subquery = make_uniq<SubqueryRef>(std::move(select_stmt));
+	return Bind(*subquery);
 }
 
 } // namespace duckdb

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

@@ -51,7 +51,7 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 			ColumnRefExpression colref(col_name, table.name);
 			auto result = bind_context.BindColumn(colref, 0);
 			if (result.HasError()) {
-				throw BinderException(result.error);
+				result.error.Throw();
 			}
 			select_list.push_back(std::move(result.expression));
 		}

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -75,7 +75,7 @@ unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context
 }
 
 unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
-	QueryErrorContext error_context(root_statement, ref.query_location);
+	QueryErrorContext error_context(ref.query_location);
 	// CTEs and views are also referred to using BaseTableRefs, hence need to distinguish here
 	// check if the table name refers to a CTE
 
@@ -225,8 +225,13 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		view_binder->can_contain_nulls = true;
 		SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(view_catalog_entry.query->Copy()));
 		subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
-		subquery.column_name_alias =
-		    BindContext::AliasColumnNames(subquery.alias, view_catalog_entry.aliases, ref.column_name_alias);
+		// construct view names by first (1) taking the view aliases, (2) adding the view names, then (3) applying
+		// subquery aliases
+		vector<string> view_names = view_catalog_entry.aliases;
+		for (idx_t n = view_names.size(); n < view_catalog_entry.names.size(); n++) {
+			view_names.push_back(view_catalog_entry.names[n]);
+		}
+		subquery.column_name_alias = BindContext::AliasColumnNames(subquery.alias, view_names, ref.column_name_alias);
 		// bind the child subquery
 		view_binder->AddBoundView(view_catalog_entry);
 		auto bound_child = view_binder->Bind(subquery);
@@ -237,9 +242,14 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		D_ASSERT(bound_child->type == TableReferenceType::SUBQUERY);
 		// verify that the types and names match up with the expected types and names
 		auto &bound_subquery = bound_child->Cast<BoundSubqueryRef>();
-		if (GetBindingMode() != BindingMode::EXTRACT_NAMES &&
-		    bound_subquery.subquery->types != view_catalog_entry.types) {
-			throw BinderException("Contents of view were altered: types don't match!");
+		if (GetBindingMode() != BindingMode::EXTRACT_NAMES) {
+			if (bound_subquery.subquery->types != view_catalog_entry.types) {
+				throw BinderException("Contents of view were altered: types don't match!");
+			}
+			if (bound_subquery.subquery->names.size() == view_catalog_entry.names.size() &&
+			    bound_subquery.subquery->names != view_catalog_entry.names) {
+				throw BinderException("Contents of view were altered: names don't match!");
+			}
 		}
 		bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery,
 		                     *bound_subquery.subquery, &view_catalog_entry);

package/src/duckdb/src/planner/binder/tableref/bind_expressionlistref.cpp

@@ -11,6 +11,7 @@ unique_ptr<BoundTableRef> Binder::Bind(ExpressionListRef &expr) {
 	auto result = make_uniq<BoundExpressionListRef>();
 	result->types = expr.expected_types;
 	result->names = expr.expected_names;
+	auto prev_can_contain_nulls = this->can_contain_nulls;
 	// bind value list
 	InsertBinder binder(*this, context);
 	binder.target_type = LogicalType(LogicalTypeId::INVALID);
@@ -23,16 +24,18 @@ unique_ptr<BoundTableRef> Binder::Bind(ExpressionListRef &expr) {
 			}
 		}
 
+		this->can_contain_nulls = true;
 		vector<unique_ptr<Expression>> list;
 		for (idx_t val_idx = 0; val_idx < expression_list.size(); val_idx++) {
 			if (!result->types.empty()) {
 				D_ASSERT(result->types.size() == expression_list.size());
 				binder.target_type = result->types[val_idx];
 			}
-			auto expr = binder.Bind(expression_list[val_idx]);
-			list.push_back(std::move(expr));
+			auto bound_expr = binder.Bind(expression_list[val_idx]);
+			list.push_back(std::move(bound_expr));
 		}
 		result->values.push_back(std::move(list));
+		this->can_contain_nulls = prev_can_contain_nulls;
 	}
 	if (result->types.empty() && !expr.values.empty()) {
 		// there are no types specified
@@ -44,10 +47,14 @@ unique_ptr<BoundTableRef> Binder::Bind(ExpressionListRef &expr) {
 		for (idx_t list_idx = 0; list_idx < result->values.size(); list_idx++) {
 			auto &list = result->values[list_idx];
 			for (idx_t val_idx = 0; val_idx < list.size(); val_idx++) {
-				result->types[val_idx] =
-				    LogicalType::MaxLogicalType(result->types[val_idx], list[val_idx]->return_type);
+				auto &current_type = result->types[val_idx];
+				auto next_type = ExpressionBinder::GetExpressionReturnType(*list[val_idx]);
+				result->types[val_idx] = LogicalType::MaxLogicalType(context, current_type, next_type);
 			}
 		}
+		for (auto &type : result->types) {
+			type = LogicalType::NormalizeType(type);
+		}
 		// finally do another loop over the expressions and add casts where required
 		for (idx_t list_idx = 0; list_idx < result->values.size(); list_idx++) {
 			auto &list = result->values[list_idx];

package/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp

@@ -205,7 +205,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			}
 			error_msg += "\n   Left candidates: " + left_candidates;
 			error_msg += "\n   Right candidates: " + right_candidates;
-			throw BinderException(FormatError(ref, error_msg));
+			throw BinderException(ref, error_msg);
 		}
 		break;
 	}

package/src/duckdb/src/planner/binder/tableref/bind_named_parameters.cpp

@@ -22,8 +22,8 @@ void Binder::BindNamedParameters(named_parameter_type_map_t &types, named_parame
 			} else {
 				error_msg = "Candidates:\n" + named_params;
 			}
-			throw BinderException(error_context.FormatError("Invalid named parameter \"%s\" for function %s\n%s",
-			                                                kv.first, func_name, error_msg));
+			throw BinderException(error_context, "Invalid named parameter \"%s\" for function %s\n%s", kv.first,
+			                      func_name, error_msg);
 		}
 		if (entry->second.id() != LogicalTypeId::ANY) {
 			kv.second = kv.second.DefaultCastAs(entry->second);