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

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -356,10 +356,9 @@ idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionCont
 	return updated_tuples;
 }
 
-SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
-                                    DataChunk &chunk) const {
-	auto &gstate = state.Cast<InsertGlobalState>();
-	auto &lstate = lstate_p.Cast<InsertLocalState>();
+SinkResultType PhysicalInsert::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+	auto &gstate = input.global_state.Cast<InsertGlobalState>();
+	auto &lstate = input.local_state.Cast<InsertLocalState>();
 
 	auto &table = gstate.table;
 	auto &storage = table.GetStorage();
@@ -372,13 +371,13 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 		}
 
 		idx_t updated_tuples = OnConflictHandling(table, context, lstate);
+		gstate.insert_count += lstate.insert_chunk.size();
+		gstate.insert_count += updated_tuples;
 		storage.LocalAppend(gstate.append_state, table, context.client, lstate.insert_chunk, true);
 
 		if (return_chunk) {
 			gstate.return_collection.Append(lstate.insert_chunk);
 		}
-		gstate.insert_count += lstate.insert_chunk.size();
-		gstate.insert_count += updated_tuples;
 	} else {
 		D_ASSERT(!return_chunk);
 		// parallel append
@@ -392,11 +391,11 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, GlobalSinkState &
 			lstate.local_collection->InitializeAppend(lstate.local_append_state);
 			lstate.writer = &gstate.table.GetStorage().CreateOptimisticWriter(context.client);
 		}
-		lstate.update_count += OnConflictHandling(table, context, lstate);
+		OnConflictHandling(table, context, lstate);
 
 		auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state);
 		if (new_row_group) {
-			lstate.writer->CheckFlushToDisk(*lstate.local_collection);
+			lstate.writer->WriteNewRowGroup(*lstate.local_collection);
 		}
 	}
 
@@ -422,11 +421,10 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 	auto append_count = lstate.local_collection->GetTotalRows();
 
-	if (append_count < LocalStorage::MERGE_THRESHOLD) {
+	lock_guard<mutex> lock(gstate.lock);
+	gstate.insert_count += append_count;
+	if (append_count < RowGroup::ROW_GROUP_SIZE) {
 		// we have few rows - append to the local storage directly
-		lock_guard<mutex> lock(gstate.lock);
-		gstate.insert_count += append_count;
-		gstate.insert_count += lstate.update_count;
 		auto &table = gstate.table;
 		auto &storage = table.GetStorage();
 		storage.InitializeLocalAppend(gstate.append_state, context.client);
@@ -437,14 +435,8 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		});
 		storage.FinalizeLocalAppend(gstate.append_state);
 	} else {
-		// we have many rows - flush the row group collection to disk (if required) and merge into the transaction-local
-		// state
-		lstate.writer->FlushToDisk(*lstate.local_collection);
-		lstate.writer->FinalFlush();
-
-		lock_guard<mutex> lock(gstate.lock);
-		gstate.insert_count += append_count;
-		gstate.insert_count += lstate.update_count;
+		// we have written rows to disk optimistically - merge directly into the transaction-local storage
+		gstate.table.GetStorage().FinalizeOptimisticWriter(context.client, *lstate.writer);
 		gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection);
 	}
 }
@@ -465,7 +457,7 @@ SinkFinalizeType PhysicalInsert::Finalize(Pipeline &pipeline, Event &event, Clie
 //===--------------------------------------------------------------------===//
 class InsertSourceState : public GlobalSourceState {
 public:
-	explicit InsertSourceState(const PhysicalInsert &op) : finished(false) {
+	explicit InsertSourceState(const PhysicalInsert &op) {
 		if (op.return_chunk) {
 			D_ASSERT(op.sink_state);
 			auto &g = op.sink_state->Cast<InsertGlobalState>();
@@ -474,28 +466,24 @@ public:
 	}
 
 	ColumnDataScanState scan_state;
-	bool finished;
 };
 
 unique_ptr<GlobalSourceState> PhysicalInsert::GetGlobalSourceState(ClientContext &context) const {
 	return make_uniq<InsertSourceState>(*this);
 }
 
-void PhysicalInsert::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<InsertSourceState>();
+SourceResultType PhysicalInsert::GetData(ExecutionContext &context, DataChunk &chunk,
+                                         OperatorSourceInput &input) const {
+	auto &state = input.global_state.Cast<InsertSourceState>();
 	auto &insert_gstate = sink_state->Cast<InsertGlobalState>();
-	if (state.finished) {
-		return;
-	}
 	if (!return_chunk) {
 		chunk.SetCardinality(1);
 		chunk.SetValue(0, 0, Value::BIGINT(insert_gstate.insert_count));
-		state.finished = true;
-		return;
+		return SourceResultType::FINISHED;
 	}
 
 	insert_gstate.return_collection.Scan(state.scan_state, chunk);
+	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/persistent/physical_update.cpp

@@ -57,16 +57,15 @@ public:
 	ExpressionExecutor default_executor;
 };
 
-SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
-                                    DataChunk &chunk) const {
-	auto &gstate = state.Cast<UpdateGlobalState>();
-	auto &ustate = lstate.Cast<UpdateLocalState>();
+SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+	auto &gstate = input.global_state.Cast<UpdateGlobalState>();
+	auto &lstate = input.local_state.Cast<UpdateLocalState>();
 
-	DataChunk &update_chunk = ustate.update_chunk;
-	DataChunk &mock_chunk = ustate.mock_chunk;
+	DataChunk &update_chunk = lstate.update_chunk;
+	DataChunk &mock_chunk = lstate.mock_chunk;
 
 	chunk.Flatten();
-	ustate.default_executor.SetChunk(chunk);
+	lstate.default_executor.SetChunk(chunk);
 
 	// update data in the base table
 	// the row ids are given to us as the last column of the child chunk
@@ -77,7 +76,7 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 	for (idx_t i = 0; i < expressions.size(); i++) {
 		if (expressions[i]->type == ExpressionType::VALUE_DEFAULT) {
 			// default expression, set to the default value of the column
-			ustate.default_executor.ExecuteExpression(columns[i].index, update_chunk.data[i]);
+			lstate.default_executor.ExecuteExpression(columns[i].index, update_chunk.data[i]);
 		} else {
 			D_ASSERT(expressions[i]->type == ExpressionType::BOUND_REF);
 			// index into child chunk
@@ -153,7 +152,7 @@ void PhysicalUpdate::Combine(ExecutionContext &context, GlobalSinkState &gstate,
 //===--------------------------------------------------------------------===//
 class UpdateSourceState : public GlobalSourceState {
 public:
-	explicit UpdateSourceState(const PhysicalUpdate &op) : finished(false) {
+	explicit UpdateSourceState(const PhysicalUpdate &op) {
 		if (op.return_chunk) {
 			D_ASSERT(op.sink_state);
 			auto &g = op.sink_state->Cast<UpdateGlobalState>();
@@ -162,28 +161,25 @@ public:
 	}
 
 	ColumnDataScanState scan_state;
-	bool finished;
 };
 
 unique_ptr<GlobalSourceState> PhysicalUpdate::GetGlobalSourceState(ClientContext &context) const {
 	return make_uniq<UpdateSourceState>(*this);
 }
 
-void PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<UpdateSourceState>();
+SourceResultType PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk,
+                                         OperatorSourceInput &input) const {
+	auto &state = input.global_state.Cast<UpdateSourceState>();
 	auto &g = sink_state->Cast<UpdateGlobalState>();
-	if (state.finished) {
-		return;
-	}
 	if (!return_chunk) {
 		chunk.SetCardinality(1);
 		chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
-		state.finished = true;
-		return;
+		return SourceResultType::FINISHED;
 	}
 
 	g.return_collection.Scan(state.scan_state, chunk);
+
+	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/scan/physical_column_data_scan.cpp

@@ -27,17 +27,19 @@ unique_ptr<GlobalSourceState> PhysicalColumnDataScan::GetGlobalSourceState(Clien
 	return make_uniq<PhysicalColumnDataScanState>();
 }
 
-void PhysicalColumnDataScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                     LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<PhysicalColumnDataScanState>();
+SourceResultType PhysicalColumnDataScan::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                 OperatorSourceInput &input) const {
+	auto &state = input.global_state.Cast<PhysicalColumnDataScanState>();
 	if (collection->Count() == 0) {
-		return;
+		return SourceResultType::FINISHED;
 	}
 	if (!state.initialized) {
 		collection->InitializeScan(state.scan_state);
 		state.initialized = true;
 	}
 	collection->Scan(state.scan_state, chunk);
+
+	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/scan/physical_dummy_scan.cpp

@@ -2,27 +2,12 @@
 
 namespace duckdb {
 
-class DummyScanState : public GlobalSourceState {
-public:
-	DummyScanState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalDummyScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<DummyScanState>();
-}
-
-void PhysicalDummyScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                LocalSourceState &lstate) const {
-	auto &state = (DummyScanState &)gstate;
-	if (state.finished) {
-		return;
-	}
+SourceResultType PhysicalDummyScan::GetData(ExecutionContext &context, DataChunk &chunk,
+                                            OperatorSourceInput &input) const {
 	// return a single row on the first call to the dummy scan
 	chunk.SetCardinality(1);
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/scan/physical_empty_result.cpp

@@ -2,8 +2,9 @@
 
 namespace duckdb {
 
-void PhysicalEmptyResult::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
+SourceResultType PhysicalEmptyResult::GetData(ExecutionContext &context, DataChunk &chunk,
+                                              OperatorSourceInput &input) const {
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/parallel/interrupt.hpp"
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 #include "duckdb/transaction/transaction.hpp"
 
@@ -63,7 +64,14 @@ public:
 		if (source_offset >= source.size()) {
 			if (!exhausted) {
 				source.Reset();
-				table.GetData(context, source, global_state, *local_state);
+
+				InterruptState interrupt_state;
+				OperatorSourceInput source_input {global_state, *local_state, interrupt_state};
+				auto source_result = table.GetData(context, source, source_input);
+				if (source_result == SourceResultType::BLOCKED) {
+					throw NotImplementedException(
+					    "Unexpected interrupt from table Source in PositionalTableScanner refill");
+				}
 			}
 			source_offset = 0;
 		}
@@ -146,9 +154,9 @@ unique_ptr<GlobalSourceState> PhysicalPositionalScan::GetGlobalSourceState(Clien
 	return make_uniq<PositionalScanGlobalSourceState>(context, *this);
 }
 
-void PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &output, GlobalSourceState &gstate_p,
-                                     LocalSourceState &lstate_p) const {
-	auto &lstate = lstate_p.Cast<PositionalScanLocalSourceState>();
+SourceResultType PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &output,
+                                                 OperatorSourceInput &input) const {
+	auto &lstate = input.local_state.Cast<PositionalScanLocalSourceState>();
 
 	// Find the longest source block
 	idx_t count = 0;
@@ -158,7 +166,7 @@ void PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &outpu
 
 	//	All done?
 	if (!count) {
-		return;
+		return SourceResultType::FINISHED;
 	}
 
 	// Copy or reference the source columns
@@ -168,6 +176,7 @@ void PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &outpu
 	}
 
 	output.SetCardinality(count);
+	return SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 double PhysicalPositionalScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {

package/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp

@@ -73,14 +73,16 @@ unique_ptr<GlobalSourceState> PhysicalTableScan::GetGlobalSourceState(ClientCont
 	return make_uniq<TableScanGlobalSourceState>(context, *this);
 }
 
-void PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
-                                LocalSourceState &lstate) const {
+SourceResultType PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk,
+                                            OperatorSourceInput &input) const {
 	D_ASSERT(!column_ids.empty());
-	auto &gstate = gstate_p.Cast<TableScanGlobalSourceState>();
-	auto &state = lstate.Cast<TableScanLocalSourceState>();
+	auto &gstate = input.global_state.Cast<TableScanGlobalSourceState>();
+	auto &state = input.local_state.Cast<TableScanLocalSourceState>();
 
 	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
 	function.function(context.client, data, chunk);
+
+	return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 double PhysicalTableScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {

package/src/duckdb/src/execution/operator/schema/physical_alter.cpp

@@ -7,27 +7,11 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class AlterSourceState : public GlobalSourceState {
-public:
-	AlterSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalAlter::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<AlterSourceState>();
-}
-
-void PhysicalAlter::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                            LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<AlterSourceState>();
-	if (state.finished) {
-		return;
-	}
+SourceResultType PhysicalAlter::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 	catalog.Alter(context.client, *info);
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -12,24 +12,9 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class AttachSourceState : public GlobalSourceState {
-public:
-	AttachSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalAttach::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<AttachSourceState>();
-}
 
-void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                             LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<AttachSourceState>();
-	if (state.finished) {
-		return;
-	}
+SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk,
+                                         OperatorSourceInput &input) const {
 	// parse the options
 	auto &config = DBConfig::GetConfig(context.client);
 	AccessMode access_mode = config.options.access_mode;
@@ -91,7 +76,8 @@ void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	new_db->Initialize();
 
 	db_manager.AddDatabase(context.client, std::move(new_db));
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_create_function.cpp

@@ -8,27 +8,12 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class CreateFunctionSourceState : public GlobalSourceState {
-public:
-	CreateFunctionSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateFunction::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<CreateFunctionSourceState>();
-}
-
-void PhysicalCreateFunction::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                     LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<CreateFunctionSourceState>();
-	if (state.finished) {
-		return;
-	}
+SourceResultType PhysicalCreateFunction::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                 OperatorSourceInput &input) const {
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 	catalog.CreateFunction(context.client, *info);
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -85,15 +85,14 @@ unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionConte
 	return std::move(state);
 }
 
-SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
-                                         DataChunk &input) const {
+SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
 
-	D_ASSERT(input.ColumnCount() >= 2);
-	auto &lstate = lstate_p.Cast<CreateIndexLocalSinkState>();
-	auto &row_identifiers = input.data[input.ColumnCount() - 1];
+	D_ASSERT(chunk.ColumnCount() >= 2);
+	auto &lstate = input.local_state.Cast<CreateIndexLocalSinkState>();
+	auto &row_identifiers = chunk.data[chunk.ColumnCount() - 1];
 
 	// generate the keys for the given input
-	lstate.key_chunk.ReferenceColumns(input, lstate.key_column_ids);
+	lstate.key_chunk.ReferenceColumns(chunk, lstate.key_column_ids);
 	lstate.arena_allocator.Reset();
 	ART::GenerateKeys(lstate.arena_allocator, lstate.key_chunk, lstate.keys);
 
@@ -160,9 +159,9 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 // Source
 //===--------------------------------------------------------------------===//
 
-void PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
-	// NOP
+SourceResultType PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk,
+                                              OperatorSourceInput &input) const {
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp

@@ -6,30 +6,15 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class CreateSchemaSourceState : public GlobalSourceState {
-public:
-	CreateSchemaSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateSchema::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<CreateSchemaSourceState>();
-}
-
-void PhysicalCreateSchema::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                   LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<CreateSchemaSourceState>();
-	if (state.finished) {
-		return;
-	}
+SourceResultType PhysicalCreateSchema::GetData(ExecutionContext &context, DataChunk &chunk,
+                                               OperatorSourceInput &input) const {
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 	if (catalog.IsSystemCatalog()) {
 		throw BinderException("Cannot create schema in system catalog");
 	}
 	catalog.CreateSchema(context.client, *info);
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp

@@ -6,27 +6,12 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class CreateSequenceSourceState : public GlobalSourceState {
-public:
-	CreateSequenceSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateSequence::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<CreateSequenceSourceState>();
-}
-
-void PhysicalCreateSequence::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                     LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<CreateSequenceSourceState>();
-	if (state.finished) {
-		return;
-	}
+SourceResultType PhysicalCreateSequence::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                 OperatorSourceInput &input) const {
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 	catalog.CreateSequence(context.client, *info);
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

@@ -16,27 +16,12 @@ PhysicalCreateTable::PhysicalCreateTable(LogicalOperator &op, SchemaCatalogEntry
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
-class CreateTableSourceState : public GlobalSourceState {
-public:
-	CreateTableSourceState() : finished(false) {
-	}
-
-	bool finished;
-};
-
-unique_ptr<GlobalSourceState> PhysicalCreateTable::GetGlobalSourceState(ClientContext &context) const {
-	return make_uniq<CreateTableSourceState>();
-}
-
-void PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
-                                  LocalSourceState &lstate) const {
-	auto &state = gstate.Cast<CreateTableSourceState>();
-	if (state.finished) {
-		return;
-	}
+SourceResultType PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk,
+                                              OperatorSourceInput &input) const {
 	auto &catalog = schema.catalog;
 	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, *info);
-	state.finished = true;
+
+	return SourceResultType::FINISHED;
 }
 
 } // namespace duckdb