duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -7,16 +7,13 @@
 
 namespace duckdb {
 
-static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry = true) {
+void Transformer::TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry) {
 	if (expr->type == ExpressionType::COLUMN_REF) {
 		auto &colref = expr->Cast<ColumnRefExpression>();
 		if (colref.IsQualified()) {
 			throw ParserException("PIVOT IN list cannot contain qualified column references");
 		}
 		entry.values.emplace_back(colref.GetColumnName());
-	} else if (expr->type == ExpressionType::VALUE_CONSTANT) {
-		auto &constant_expr = expr->Cast<ConstantExpression>();
-		entry.values.push_back(std::move(constant_expr.value));
 	} else if (root_entry && expr->type == ExpressionType::FUNCTION) {
 		auto &function = expr->Cast<FunctionExpression>();
 		if (function.function_name != "row") {
@@ -28,7 +25,11 @@ static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumn
 	} else if (root_entry && expr->type == ExpressionType::STAR) {
 		entry.star_expr = std::move(expr);
 	} else {
-		throw ParserException("PIVOT IN list must contain columns or lists of columns");
+		Value val;
+		if (!Transformer::ConstructConstantFromExpression(*expr, val)) {
+			throw ParserException("PIVOT IN list must contain columns or lists of columns");
+		}
+		entry.values.push_back(std::move(val));
 	}
 }
 

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

@@ -28,7 +28,7 @@ unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRa
 	case duckdb_libpgquery::T_PGFuncCall: {
 		auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(call_tree.get());
 		result->function = TransformFuncCall(*func_call);
-		result->query_location = func_call->location;
+		SetQueryLocation(*result, func_call->location);
 		break;
 	}
 	case duckdb_libpgquery::T_PGSQLValueFunction:

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

@@ -209,6 +209,14 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformDetach(PGCast<duckdb_libpgquery::PGDetachStmt>(stmt));
 	case duckdb_libpgquery::T_PGUseStmt:
 		return TransformUse(PGCast<duckdb_libpgquery::PGUseStmt>(stmt));
+	case duckdb_libpgquery::T_PGCopyDatabaseStmt:
+		return TransformCopyDatabase(PGCast<duckdb_libpgquery::PGCopyDatabaseStmt>(stmt));
+	case duckdb_libpgquery::T_PGCreateSecretStmt:
+		return TransformSecret(PGCast<duckdb_libpgquery::PGCreateSecretStmt>(stmt));
+	case duckdb_libpgquery::T_PGDropSecretStmt:
+		return TransformDropSecret(PGCast<duckdb_libpgquery::PGDropSecretStmt>(stmt));
+	case duckdb_libpgquery::T_PGCommentOnStmt:
+		return TransformCommentOn(PGCast<duckdb_libpgquery::PGCommentOnStmt>(stmt));
 	default:
 		throw NotImplementedException(NodetypeToString(stmt.type));
 	}
@@ -228,4 +236,18 @@ unique_ptr<QueryNode> Transformer::TransformMaterializedCTE(unique_ptr<QueryNode
 	return root;
 }
 
+void Transformer::SetQueryLocation(ParsedExpression &expr, int query_location) {
+	if (query_location < 0) {
+		return;
+	}
+	expr.query_location = optional_idx(idx_t(query_location));
+}
+
+void Transformer::SetQueryLocation(TableRef &ref, int query_location) {
+	if (query_location < 0) {
+		return;
+	}
+	ref.query_location = optional_idx(idx_t(query_location));
+}
+
 } // namespace duckdb

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

@@ -15,11 +15,15 @@
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
+#include "duckdb/planner/binder.hpp"
 
 #include <algorithm>
 
 namespace duckdb {
 
+BindContext::BindContext(Binder &binder) : binder(binder) {
+}
+
 string BindContext::GetMatchingBinding(const string &column_name) {
 	string result;
 	for (auto &kv : bindings) {
@@ -133,10 +137,10 @@ void BindContext::TransferUsingBinding(BindContext &current_context, optional_pt
 }
 
 string BindContext::GetActualColumnName(const string &binding_name, const string &column_name) {
-	string error;
+	ErrorData error;
 	auto binding = GetBinding(binding_name, error);
 	if (!binding) {
-		throw InternalException("No binding with name \"%s\"", binding_name);
+		throw InternalException("No binding with name \"%s\": %s", binding_name, error.RawMessage());
 	}
 	column_t binding_index;
 	if (!binding->TryGetBindingIndex(column_name, binding_index)) { // LCOV_EXCL_START
@@ -158,10 +162,10 @@ unordered_set<string> BindContext::GetMatchingBindings(const string &column_name
 }
 
 unique_ptr<ParsedExpression> BindContext::ExpandGeneratedColumn(const string &table_name, const string &column_name) {
-	string error_message;
+	ErrorData error;
 
-	auto binding = GetBinding(table_name, error_message);
-	D_ASSERT(binding);
+	auto binding = GetBinding(table_name, error);
+	D_ASSERT(binding && !error.HasError());
 	auto &table_binding = binding->Cast<TableBinding>();
 	auto result = table_binding.ExpandGeneratedColumn(column_name);
 	result->alias = column_name;
@@ -192,7 +196,7 @@ static bool ColumnIsGenerated(Binding &binding, column_t index) {
 
 unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &catalog_name, const string &schema_name,
                                                                 const string &table_name, const string &column_name) {
-	string error_message;
+	ErrorData error;
 	vector<string> names;
 	if (!catalog_name.empty()) {
 		names.push_back(catalog_name);
@@ -204,7 +208,7 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &ca
 	names.push_back(column_name);
 
 	auto result = make_uniq<ColumnRefExpression>(std::move(names));
-	auto binding = GetBinding(table_name, error_message);
+	auto binding = GetBinding(table_name, error);
 	if (!binding) {
 		return std::move(result);
 	}
@@ -233,7 +237,7 @@ optional_ptr<Binding> BindContext::GetCTEBinding(const string &ctename) {
 	return match->second.get();
 }
 
-optional_ptr<Binding> BindContext::GetBinding(const string &name, string &out_error) {
+optional_ptr<Binding> BindContext::GetBinding(const string &name, ErrorData &out_error) {
 	auto match = bindings.find(name);
 	if (match == bindings.end()) {
 		// alias not found in this BindContext
@@ -243,7 +247,8 @@ optional_ptr<Binding> BindContext::GetBinding(const string &name, string &out_er
 		}
 		string candidate_str =
 		    StringUtil::CandidatesMessage(StringUtil::TopNLevenshtein(candidates, name), "Candidate tables");
-		out_error = StringUtil::Format("Referenced table \"%s\" not found!%s", name, candidate_str);
+		out_error = ErrorData(ExceptionType::BINDER,
+		                      StringUtil::Format("Referenced table \"%s\" not found!%s", name, candidate_str));
 		return nullptr;
 	}
 	return match->second.get();
@@ -254,10 +259,10 @@ BindResult BindContext::BindColumn(ColumnRefExpression &colref, idx_t depth) {
 		throw InternalException("Could not bind alias \"%s\"!", colref.GetColumnName());
 	}
 
-	string error;
+	ErrorData error;
 	auto binding = GetBinding(colref.GetTableName(), error);
 	if (!binding) {
-		return BindResult(error);
+		return BindResult(std::move(error));
 	}
 	return binding->Bind(colref, depth);
 }
@@ -363,13 +368,13 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 	} else {
 		// SELECT tbl.* case
 		// SELECT struct.* case
-		string error;
+		ErrorData error;
 		auto binding = GetBinding(expr.relation_name, error);
 		bool is_struct_ref = false;
 		if (!binding) {
 			auto binding_name = GetMatchingBinding(expr.relation_name);
 			if (binding_name.empty()) {
-				throw BinderException(error);
+				error.Throw();
 			}
 			binding = bindings[binding_name].get();
 			is_struct_ref = true;
@@ -403,6 +408,10 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 			}
 		}
 	}
+	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
+		expr.exclude_list.clear();
+		expr.replace_list.clear();
+	}
 	for (auto &excluded : expr.exclude_list) {
 		if (excluded_columns.find(excluded) == excluded_columns.end()) {
 			throw BinderException("Column \"%s\" in EXCLUDE list not found in %s", excluded,
@@ -452,7 +461,7 @@ static string AddColumnNameToBinding(const string &base_name, case_insensitive_s
 	idx_t index = 1;
 	string name = base_name;
 	while (current_names.find(name) != current_names.end()) {
-		name = base_name + ":" + std::to_string(index++);
+		name = base_name + "_" + std::to_string(index++);
 	}
 	current_names.insert(name);
 	return name;

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

@@ -86,7 +86,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
 	AggregateBinder aggregate_binder(binder, context);
-	string error;
+	ErrorData error;
 
 	// Now we bind the filter (if any)
 	if (aggr.filter) {
@@ -114,7 +114,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 	for (auto &child : aggr.children) {
 		aggregate_binder.BindChild(child, 0, error);
 		// We have to negate the fractions for PERCENTILE_XXXX DESC
-		if (error.empty() && ordered_set_agg) {
+		if (!error.HasError() && ordered_set_agg) {
 			NegatePercentileFractions(context, child, negate_fractions);
 		}
 	}
@@ -126,35 +126,35 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 		}
 	}
 
-	if (!error.empty()) {
+	if (error.HasError()) {
 		// failed to bind child
 		if (aggregate_binder.HasBoundColumns()) {
 			for (idx_t i = 0; i < aggr.children.size(); i++) {
 				// however, we bound columns!
 				// that means this aggregation belongs to this node
 				// check if we have to resolve any errors by binding with parent binders
-				bool success = aggregate_binder.BindCorrelatedColumns(aggr.children[i]);
+				auto result = aggregate_binder.BindCorrelatedColumns(aggr.children[i], error);
 				// if there is still an error after this, we could not successfully bind the aggregate
-				if (!success) {
-					throw BinderException(error);
+				if (result.HasError()) {
+					result.error.Throw();
 				}
 				auto &bound_expr = BoundExpression::GetExpression(*aggr.children[i]);
 				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.filter) {
-				bool success = aggregate_binder.BindCorrelatedColumns(aggr.filter);
+				auto result = aggregate_binder.BindCorrelatedColumns(aggr.filter, error);
 				// if there is still an error after this, we could not successfully bind the aggregate
-				if (!success) {
-					throw BinderException(error);
+				if (result.HasError()) {
+					result.error.Throw();
 				}
 				auto &bound_expr = BoundExpression::GetExpression(*aggr.filter);
 				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
 				for (auto &order : aggr.order_bys->orders) {
-					bool success = aggregate_binder.BindCorrelatedColumns(order.expression);
-					if (!success) {
-						throw BinderException(error);
+					auto result = aggregate_binder.BindCorrelatedColumns(order.expression, error);
+					if (result.HasError()) {
+						result.error.Throw();
 					}
 					auto &bound_expr = BoundExpression::GetExpression(*order.expression);
 					ExtractCorrelatedExpressions(binder, *bound_expr);
@@ -162,7 +162,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 			}
 		} else {
 			// we didn't bind columns, try again in children
-			return BindResult(error);
+			return BindResult(std::move(error));
 		}
 	} else if (depth > 0 && !aggregate_binder.HasBoundColumns()) {
 		return BindResult("Aggregate with only constant parameters has to be bound in the root subquery");
@@ -207,7 +207,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 	FunctionBinder function_binder(context);
 	idx_t best_function = function_binder.BindFunction(func.name, func.functions, types, error);
 	if (best_function == DConstants::INVALID_INDEX) {
-		throw BinderException(binder.FormatError(aggr, error));
+		error.AddQueryLocation(aggr);
+		error.Throw();
 	}
 	// found a matching function!
 	auto bound_function = func.functions.GetFunctionByOffset(best_function);

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

@@ -5,31 +5,42 @@
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth) {
 	// first try to bind the children of the case expression
-	string error;
+	ErrorData error;
 	BindChild(expr.input, depth, error);
 	BindChild(expr.lower, depth, error);
 	BindChild(expr.upper, depth, error);
-	if (!error.empty()) {
-		return BindResult(error);
+	if (error.HasError()) {
+		return BindResult(std::move(error));
 	}
 	// the children have been successfully resolved
 	auto &input = BoundExpression::GetExpression(*expr.input);
 	auto &lower = BoundExpression::GetExpression(*expr.lower);
 	auto &upper = BoundExpression::GetExpression(*expr.upper);
 
-	auto input_sql_type = input->return_type;
-	auto lower_sql_type = lower->return_type;
-	auto upper_sql_type = upper->return_type;
+	auto input_sql_type = ExpressionBinder::GetExpressionReturnType(*input);
+	auto lower_sql_type = ExpressionBinder::GetExpressionReturnType(*lower);
+	auto upper_sql_type = ExpressionBinder::GetExpressionReturnType(*upper);
 
 	// cast the input types to the same type
 	// now obtain the result type of the input types
-	auto input_type = BoundComparisonExpression::BindComparison(input_sql_type, lower_sql_type);
-	input_type = BoundComparisonExpression::BindComparison(input_type, upper_sql_type);
+	LogicalType input_type;
+	if (!BoundComparisonExpression::TryBindComparison(context, input_sql_type, lower_sql_type, input_type, expr.type)) {
+
+		throw BinderException(expr,
+		                      "Cannot mix values of type %s and %s in BETWEEN clause - an explicit cast is required",
+		                      input_sql_type.ToString(), lower_sql_type.ToString());
+	}
+	if (!BoundComparisonExpression::TryBindComparison(context, input_type, upper_sql_type, input_type, expr.type)) {
+		throw BinderException(expr,
+		                      "Cannot mix values of type %s and %s in BETWEEN clause - an explicit cast is required",
+		                      input_type.ToString(), upper_sql_type.ToString());
+	}
 	// add casts (if necessary)
 	input = BoundCastExpression::AddCastToType(context, std::move(input), input_type);
 	lower = BoundCastExpression::AddCastToType(context, std::move(lower), input_type);
@@ -39,7 +50,7 @@ BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth
 	PushCollation(context, lower, input_type, false);
 	PushCollation(context, upper, input_type, false);
 
-	if (!input->HasSideEffects() && !input->HasParameter() && !input->HasSubquery()) {
+	if (!input->IsVolatile() && !input->HasParameter() && !input->HasSubquery()) {
 		// the expression does not have side effects and can be copied: create two comparisons
 		// the reason we do this is that individual comparisons are easier to handle in optimizers
 		// if both comparisons remain they will be folded together again into a single BETWEEN in the optimizer

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

@@ -2,33 +2,38 @@
 #include "duckdb/planner/expression/bound_case_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(CaseExpression &expr, idx_t depth) {
 	// first try to bind the children of the case expression
-	string error;
+	ErrorData error;
 	for (auto &check : expr.case_checks) {
 		BindChild(check.when_expr, depth, error);
 		BindChild(check.then_expr, depth, error);
 	}
 	BindChild(expr.else_expr, depth, error);
-	if (!error.empty()) {
-		return BindResult(error);
+	if (error.HasError()) {
+		return BindResult(std::move(error));
 	}
 	// the children have been successfully resolved
 	// figure out the result type of the CASE expression
 	auto &else_expr = BoundExpression::GetExpression(*expr.else_expr);
-	auto return_type = else_expr->return_type;
+	auto return_type = ExpressionBinder::GetExpressionReturnType(*else_expr);
 	for (auto &check : expr.case_checks) {
 		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
-		return_type = LogicalType::MaxLogicalType(return_type, then_expr->return_type);
+		auto then_type = ExpressionBinder::GetExpressionReturnType(*then_expr);
+		if (!LogicalType::TryGetMaxLogicalType(context, return_type, then_type, return_type)) {
+			throw BinderException(
+			    expr, "Cannot mix values of type %s and %s in CASE expression - an explicit cast is required",
+			    return_type.ToString(), then_type.ToString());
+		}
 	}
 
 	// bind all the individual components of the CASE statement
 	auto result = make_uniq<BoundCaseExpression>(return_type);
-	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
-		auto &check = expr.case_checks[i];
+	for (auto &check : expr.case_checks) {
 		auto &when_expr = BoundExpression::GetExpression(*check.when_expr);
 		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
 		BoundCaseCheck result_check;

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

@@ -8,9 +8,9 @@ namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
 	// first try to bind the child of the cast expression
-	string error = Bind(expr.child, depth);
-	if (!error.empty()) {
-		return BindResult(error);
+	auto error = Bind(expr.child, depth);
+	if (error.HasError()) {
+		return BindResult(std::move(error));
 	}
 	// FIXME: We can also implement 'hello'::schema.custom_type; and pass by the schema down here.
 	// Right now just considering its DEFAULT_SCHEMA always
@@ -18,7 +18,7 @@ BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
 	// the children have been successfully resolved
 	auto &child = BoundExpression::GetExpression(*expr.child);
 	if (expr.try_cast) {
-		if (child->return_type == expr.cast_type) {
+		if (ExpressionBinder::GetExpressionReturnType(*child) == expr.cast_type) {
 			// no cast required: type matches
 			return BindResult(std::move(child));
 		}

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

@@ -6,9 +6,9 @@ namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth) {
 	// first try to bind the child of the cast expression
-	string error = Bind(expr.child, depth);
-	if (!error.empty()) {
-		return BindResult(error);
+	auto error = Bind(expr.child, depth);
+	if (error.HasError()) {
+		return BindResult(std::move(error));
 	}
 	auto &child = BoundExpression::GetExpression(*expr.child);
 	if (child->HasParameter()) {