duckdb 0.7.2-dev2820.0 → 0.7.2-dev2995.0

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -24,15 +24,15 @@ struct SchedulerThread {
 };
 
 #ifndef DUCKDB_NO_THREADS
-typedef duckdb_moodycamel::ConcurrentQueue<unique_ptr<Task>> concurrent_queue_t;
+typedef duckdb_moodycamel::ConcurrentQueue<shared_ptr<Task>> concurrent_queue_t;
 typedef duckdb_moodycamel::LightweightSemaphore lightweight_semaphore_t;
 
 struct ConcurrentQueue {
 	concurrent_queue_t q;
 	lightweight_semaphore_t semaphore;
 
-	void Enqueue(ProducerToken &token, unique_ptr<Task> task);
-	bool DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task);
+	void Enqueue(ProducerToken &token, shared_ptr<Task> task);
+	bool DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task);
 };
 
 struct QueueProducerToken {
@@ -42,7 +42,7 @@ struct QueueProducerToken {
 	duckdb_moodycamel::ProducerToken queue_token;
 };
 
-void ConcurrentQueue::Enqueue(ProducerToken &token, unique_ptr<Task> task) {
+void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
 	lock_guard<mutex> producer_lock(token.producer_lock);
 	if (q.enqueue(token.token->queue_token, std::move(task))) {
 		semaphore.signal();
@@ -51,26 +51,26 @@ void ConcurrentQueue::Enqueue(ProducerToken &token, unique_ptr<Task> task) {
 	}
 }
 
-bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
+bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
 	lock_guard<mutex> producer_lock(token.producer_lock);
 	return q.try_dequeue_from_producer(token.token->queue_token, task);
 }
 
 #else
 struct ConcurrentQueue {
-	std::queue<unique_ptr<Task>> q;
+	std::queue<shared_ptr<Task>> q;
 	mutex qlock;
 
-	void Enqueue(ProducerToken &token, unique_ptr<Task> task);
-	bool DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task);
+	void Enqueue(ProducerToken &token, shared_ptr<Task> task);
+	bool DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task);
 };
 
-void ConcurrentQueue::Enqueue(ProducerToken &token, unique_ptr<Task> task) {
+void ConcurrentQueue::Enqueue(ProducerToken &token, shared_ptr<Task> task) {
 	lock_guard<mutex> lock(qlock);
 	q.push(std::move(task));
 }
 
-bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
+bool ConcurrentQueue::DequeueFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
 	lock_guard<mutex> lock(qlock);
 	if (q.empty()) {
 		return false;
@@ -115,25 +115,37 @@ unique_ptr<ProducerToken> TaskScheduler::CreateProducer() {
 	return make_uniq<ProducerToken>(*this, std::move(token));
 }
 
-void TaskScheduler::ScheduleTask(ProducerToken &token, unique_ptr<Task> task) {
+void TaskScheduler::ScheduleTask(ProducerToken &token, shared_ptr<Task> task) {
 	// Enqueue a task for the given producer token and signal any sleeping threads
 	queue->Enqueue(token, std::move(task));
 }
 
-bool TaskScheduler::GetTaskFromProducer(ProducerToken &token, unique_ptr<Task> &task) {
+bool TaskScheduler::GetTaskFromProducer(ProducerToken &token, shared_ptr<Task> &task) {
 	return queue->DequeueFromProducer(token, task);
 }
 
 void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 #ifndef DUCKDB_NO_THREADS
-	unique_ptr<Task> task;
+	shared_ptr<Task> task;
 	// loop until the marker is set to false
 	while (*marker) {
 		// wait for a signal with a timeout
 		queue->semaphore.wait();
 		if (queue->q.try_dequeue(task)) {
-			task->Execute(TaskExecutionMode::PROCESS_ALL);
-			task.reset();
+			auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
+
+			switch (execute_result) {
+			case TaskExecutionResult::TASK_FINISHED:
+			case TaskExecutionResult::TASK_ERROR:
+				task.reset();
+				break;
+			case TaskExecutionResult::TASK_NOT_FINISHED:
+				throw InternalException("Task should not return TASK_NOT_FINISHED in PROCESS_ALL mode");
+			case TaskExecutionResult::TASK_BLOCKED:
+				task->Deschedule();
+				task.reset();
+				break;
+			}
 		}
 	}
 #else
@@ -146,13 +158,25 @@ idx_t TaskScheduler::ExecuteTasks(atomic<bool> *marker, idx_t max_tasks) {
 	idx_t completed_tasks = 0;
 	// loop until the marker is set to false
 	while (*marker && completed_tasks < max_tasks) {
-		unique_ptr<Task> task;
+		shared_ptr<Task> task;
 		if (!queue->q.try_dequeue(task)) {
 			return completed_tasks;
 		}
-		task->Execute(TaskExecutionMode::PROCESS_ALL);
-		task.reset();
-		completed_tasks++;
+		auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
+
+		switch (execute_result) {
+		case TaskExecutionResult::TASK_FINISHED:
+		case TaskExecutionResult::TASK_ERROR:
+			task.reset();
+			completed_tasks++;
+			break;
+		case TaskExecutionResult::TASK_NOT_FINISHED:
+			throw InternalException("Task should not return TASK_NOT_FINISHED in PROCESS_ALL mode");
+		case TaskExecutionResult::TASK_BLOCKED:
+			task->Deschedule();
+			task.reset();
+			break;
+		}
 	}
 	return completed_tasks;
 #else
@@ -162,15 +186,26 @@ idx_t TaskScheduler::ExecuteTasks(atomic<bool> *marker, idx_t max_tasks) {
 
 void TaskScheduler::ExecuteTasks(idx_t max_tasks) {
 #ifndef DUCKDB_NO_THREADS
-	unique_ptr<Task> task;
+	shared_ptr<Task> task;
 	for (idx_t i = 0; i < max_tasks; i++) {
 		queue->semaphore.wait(TASK_TIMEOUT_USECS);
 		if (!queue->q.try_dequeue(task)) {
 			return;
 		}
 		try {
-			task->Execute(TaskExecutionMode::PROCESS_ALL);
-			task.reset();
+			auto execute_result = task->Execute(TaskExecutionMode::PROCESS_ALL);
+			switch (execute_result) {
+			case TaskExecutionResult::TASK_FINISHED:
+			case TaskExecutionResult::TASK_ERROR:
+				task.reset();
+				break;
+			case TaskExecutionResult::TASK_NOT_FINISHED:
+				throw InternalException("Task should not return TASK_NOT_FINISHED in PROCESS_ALL mode");
+			case TaskExecutionResult::TASK_BLOCKED:
+				task->Deschedule();
+				task.reset();
+				break;
+			}
 		} catch (...) {
 			return;
 		}

package/src/duckdb/src/parser/base_expression.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/parser/base_expression.hpp"
 
+#include "duckdb/main/config.hpp"
 #include "duckdb/common/printer.hpp"
 
 namespace duckdb {
@@ -9,6 +10,11 @@ void BaseExpression::Print() const {
 }
 
 string BaseExpression::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return ToString();
+	}
+#endif
 	return !alias.empty() ? alias : ToString();
 }
 

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

@@ -29,10 +29,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 		auto query_node = TransformSelect(stmt->query, true)->node->Copy();
 		macro_func = make_uniq<TableMacroFunction>(std::move(query_node));
 	}
-	if (HasPivotEntries()) {
-		throw ParserException("Cannot use PIVOT statement syntax in a macro. Use the SQL standard PIVOT syntax in the "
-		                      "FROM clause instead.");
-	}
+	PivotEntryCheck("macro");
 
 	auto info =
 	    make_uniq<CreateMacroInfo>((stmt->function ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY));

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

@@ -26,10 +26,8 @@ unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::
 	info->on_conflict = TransformOnConflict(stmt->onconflict);
 
 	info->query = TransformSelect(stmt->query, false);
-	if (HasPivotEntries()) {
-		throw ParserException("Cannot use PIVOT statement syntax in a view. Use the SQL standard PIVOT syntax in the "
-		                      "FROM clause instead.");
-	}
+
+	PivotEntryCheck("view");
 
 	if (stmt->aliases && stmt->aliases->length > 0) {
 		for (auto c = stmt->aliases->head; c != nullptr; c = lnext(c)) {

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

@@ -18,33 +18,45 @@
 
 namespace duckdb {
 
-void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column) {
+void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column,
+                                unique_ptr<QueryNode> subquery) {
 	if (parent) {
-		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column));
+		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column), std::move(subquery));
 		return;
 	}
 	auto result = make_uniq<CreatePivotEntry>();
 	result->enum_name = std::move(enum_name);
 	result->base = std::move(base);
 	result->column = std::move(column);
+	result->subquery = std::move(subquery);
 
 	pivot_entries.push_back(std::move(result));
 }
 
 bool Transformer::HasPivotEntries() {
-	if (parent) {
-		return parent->HasPivotEntries();
-	}
-	return !pivot_entries.empty();
+	return !GetPivotEntries().empty();
 }
 
 idx_t Transformer::PivotEntryCount() {
+	return GetPivotEntries().size();
+}
+
+vector<unique_ptr<Transformer::CreatePivotEntry>> &Transformer::GetPivotEntries() {
 	if (parent) {
-		return parent->PivotEntryCount();
+		return parent->GetPivotEntries();
 	}
-	return pivot_entries.size();
+	return pivot_entries;
 }
 
+void Transformer::PivotEntryCheck(const string &type) {
+	auto &entries = GetPivotEntries();
+	if (!entries.empty()) {
+		throw ParserException(
+		    "PIVOT statements with pivot elements extracted from the data cannot be used in %ss.\nIn order to use "
+		    "PIVOT in a %s the PIVOT values must be manually specified, e.g.:\nPIVOT ... ON %s IN (val1, val2, ...)",
+		    type, type, entries[0]->column->ToString());
+	}
+}
 unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateTypeInfo>();
@@ -57,23 +69,30 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
 
 	// generate the query that will result in the enum creation
-	auto select_node = std::move(entry->base);
-	auto columnref = entry->column->Copy();
-	auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
-	select_node->select_list.push_back(std::move(cast));
-
-	auto is_not_null = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
-	select_node->where_clause = std::move(is_not_null);
-
-	// order by the column
-	select_node->modifiers.push_back(make_uniq<DistinctModifier>());
-	auto modifier = make_uniq<OrderModifier>();
-	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
-	                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
-	select_node->modifiers.push_back(std::move(modifier));
+	unique_ptr<QueryNode> subselect;
+	if (!entry->subquery) {
+		auto select_node = std::move(entry->base);
+		auto columnref = entry->column->Copy();
+		auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
+		select_node->select_list.push_back(std::move(cast));
+
+		auto is_not_null =
+		    make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
+		select_node->where_clause = std::move(is_not_null);
+
+		// order by the column
+		select_node->modifiers.push_back(make_uniq<DistinctModifier>());
+		auto modifier = make_uniq<OrderModifier>();
+		modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
+		                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
+		select_node->modifiers.push_back(std::move(modifier));
+		subselect = std::move(select_node);
+	} else {
+		subselect = std::move(entry->subquery);
+	}
 
 	auto select = make_uniq<SelectStatement>();
-	select->node = std::move(select_node);
+	select->node = std::move(subselect);
 	info->query = std::move(select);
 	info->type = LogicalType::INVALID;
 
@@ -150,7 +169,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 		auto new_select = make_uniq<SelectNode>();
 		ExtractCTEsRecursive(new_select->cte_map);
 		new_select->from_table = source->Copy();
-		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy());
+		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy(), std::move(col.subquery));
 		col.pivot_enum = enum_name;
 	}
 

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

@@ -59,6 +59,9 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot)
 			col.entries.push_back(std::move(entry));
 		}
 	}
+	if (pivot->subquery) {
+		col.subquery = TransformSelectNode(reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(pivot->subquery));
+	}
 	if (pivot->pivot_enum) {
 		col.pivot_enum = pivot->pivot_enum;
 	}

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

@@ -8,6 +8,8 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
@@ -24,6 +26,7 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
@@ -605,41 +608,27 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::TYPE_ENTRY: {
 		auto &schema = BindCreateSchema(*stmt.info);
-		auto &create_type_info = (CreateTypeInfo &)(*stmt.info);
+		auto &create_type_info = stmt.info->Cast<CreateTypeInfo>();
 		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), &schema);
 		if (create_type_info.query) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
-			auto &select_stmt = create_type_info.query->Cast<SelectStatement>();
-			auto &query_node = *select_stmt.node;
-
-			// We always add distinct modifier implicitly
-			bool need_to_add = true;
-			if (!query_node.modifiers.empty()) {
-				if (query_node.modifiers[0]->type == ResultModifierType::DISTINCT_MODIFIER) {
-					// There are cases where the same column is grouped repeatedly
-					// CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x) x FROM test);
-					// When we push into a constant expression
-					// => CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x, x) x FROM test);
-					auto &distinct_modifier = (DistinctModifier &)*query_node.modifiers[0];
-					if (distinct_modifier.distinct_on_targets.empty()) {
-						need_to_add = false;
-					}
-				}
-			}
-
-			// Add distinct modifier
-			if (need_to_add) {
-				auto distinct_modifier = make_uniq<DistinctModifier>();
-				query_node.modifiers.emplace(query_node.modifiers.begin(), std::move(distinct_modifier));
-			}
-
 			auto query_obj = Bind(*create_type_info.query);
 			auto query = std::move(query_obj.plan);
 
 			auto &sql_types = query_obj.types;
-			if (sql_types.size() != 1 || sql_types[0].id() != LogicalType::VARCHAR) {
+			if (sql_types.size() != 1) {
 				// add cast expression?
-				throw BinderException("The query must return one varchar column");
+				throw BinderException("The query must return a single column");
+			}
+			if (sql_types[0].id() != LogicalType::VARCHAR) {
+				// push a projection casting to varchar
+				vector<unique_ptr<Expression>> select_list;
+				auto ref = make_uniq<BoundColumnRefExpression>(sql_types[0], query->GetColumnBindings()[0]);
+				auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(ref), LogicalType::VARCHAR);
+				select_list.push_back(std::move(cast_expr));
+				auto proj = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+				proj->AddChild(std::move(query));
+				query = std::move(proj);
 			}
 
 			result.plan->AddChild(std::move(query));
@@ -660,7 +649,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::DATABASE_ENTRY: {
 		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
-		auto &base = (CreateDatabaseInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateDatabaseInfo>();
 		string database_name = base.name;
 		string source_path = base.path;
 

package/src/duckdb/src/planner/expression/bound_columnref_expression.cpp

@@ -1,8 +1,8 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 
-#include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/to_string.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -35,11 +35,25 @@ bool BoundColumnRefExpression::Equals(const BaseExpression *other_p) const {
 	return other.binding == binding && other.depth == depth;
 }
 
+string BoundColumnRefExpression::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return binding.ToString();
+	}
+#endif
+	return Expression::GetName();
+}
+
 string BoundColumnRefExpression::ToString() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return binding.ToString();
+	}
+#endif
 	if (!alias.empty()) {
 		return alias;
 	}
-	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "]";
+	return binding.ToString();
 }
 
 void BoundColumnRefExpression::Serialize(FieldWriter &writer) const {

package/src/duckdb/src/planner/expression/bound_reference_expression.cpp

@@ -1,9 +1,10 @@
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 
+#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.hpp"
-#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -16,6 +17,11 @@ BoundReferenceExpression::BoundReferenceExpression(LogicalType type, idx_t index
 }
 
 string BoundReferenceExpression::ToString() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return "#" + to_string(index);
+	}
+#endif
 	if (!alias.empty()) {
 		return alias;
 	}

package/src/duckdb/src/planner/operator/logical_aggregate.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/common/string_util.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -117,4 +119,14 @@ vector<idx_t> LogicalAggregate::GetTableIndex() const {
 	return result;
 }
 
+string LogicalAggregate::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() +
+		       StringUtil::Format(" #%llu, #%llu, #%llu", group_index, aggregate_index, groupings_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_column_data_get.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/planner/operator/logical_column_data_get.hpp"
+
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -42,4 +44,13 @@ vector<idx_t> LogicalColumnDataGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalColumnDataGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_cteref.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_cteref.hpp"
+
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -22,4 +24,13 @@ vector<idx_t> LogicalCTERef::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalCTERef::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/planner/operator/logical_delete.hpp"
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/main/config.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 
 namespace duckdb {
@@ -51,4 +52,13 @@ void LogicalDelete::ResolveTypes() {
 	}
 }
 
+string LogicalDelete::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_delim_get.cpp

@@ -1,6 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
 
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 void LogicalDelimGet::Serialize(FieldWriter &writer) const {
@@ -18,4 +20,13 @@ vector<idx_t> LogicalDelimGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalDelimGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_dummy_scan.cpp

@@ -1,6 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 void LogicalDummyScan::Serialize(FieldWriter &writer) const {
@@ -16,4 +18,13 @@ vector<idx_t> LogicalDummyScan::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalDummyScan::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_expression_get.cpp

@@ -1,6 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_expression_get.hpp"
 
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/main/config.hpp"
+
 namespace duckdb {
 
 void LogicalExpressionGet::Serialize(FieldWriter &writer) const {
@@ -30,4 +32,13 @@ vector<idx_t> LogicalExpressionGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalExpressionGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return LogicalOperator::GetName() + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return LogicalOperator::GetName();
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/function_serialization.hpp"
 #include "duckdb/function/table/table_scan.hpp"
+#include "duckdb/main/config.hpp"
 #include "duckdb/storage/data_table.hpp"
 
 namespace duckdb {
@@ -16,10 +17,6 @@ LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<Fun
       bind_data(std::move(bind_data)), returned_types(std::move(returned_types)), names(std::move(returned_names)) {
 }
 
-string LogicalGet::GetName() const {
-	return StringUtil::Upper(function.name);
-}
-
 optional_ptr<TableCatalogEntry> LogicalGet::GetTable() const {
 	return TableScanFunction::GetTableEntry(function, bind_data.get());
 }
@@ -201,4 +198,13 @@ vector<idx_t> LogicalGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+string LogicalGet::GetName() const {
+#ifdef DEBUG
+	if (DBConfigOptions::debug_print_bindings) {
+		return StringUtil::Upper(function.name) + StringUtil::Format(" #%llu", table_index);
+	}
+#endif
+	return StringUtil::Upper(function.name);
+}
+
 } // namespace duckdb