duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/main/capi/table_function-c.cpp

@@ -1,14 +1,19 @@
-#include "duckdb/main/capi/capi_internal.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/type_visitor.hpp"
+#include "duckdb/common/types.hpp"
+#include "duckdb/function/table_function.hpp"
+#include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb/storage/statistics/node_statistics.hpp"
 
 namespace duckdb {
 
+//===--------------------------------------------------------------------===//
+// Structures
+//===--------------------------------------------------------------------===//
 struct CTableFunctionInfo : public TableFunctionInfo {
-	~CTableFunctionInfo() {
+	~CTableFunctionInfo() override {
 		if (extra_info && delete_callback) {
 			delete_callback(extra_info);
 		}
@@ -25,9 +30,9 @@ struct CTableFunctionInfo : public TableFunctionInfo {
 };
 
 struct CTableBindData : public TableFunctionData {
-	CTableBindData(CTableFunctionInfo &info) : info(info) {
+	explicit CTableBindData(CTableFunctionInfo &info) : info(info) {
 	}
-	~CTableBindData() {
+	~CTableBindData() override {
 		if (bind_data && delete_callback) {
 			delete_callback(bind_data);
 		}
@@ -110,13 +115,50 @@ struct CTableInternalFunctionInfo {
 	string error;
 };
 
+//===--------------------------------------------------------------------===//
+// Helper Functions
+//===--------------------------------------------------------------------===//
+duckdb::TableFunction &GetCTableFunction(duckdb_table_function function) {
+	return *reinterpret_cast<duckdb::TableFunction *>(function);
+}
+
+duckdb::CTableInternalBindInfo &GetCBindInfo(duckdb_bind_info info) {
+	D_ASSERT(info);
+	return *reinterpret_cast<duckdb::CTableInternalBindInfo *>(info);
+}
+
+duckdb_bind_info ToCBindInfo(duckdb::CTableInternalBindInfo &info) {
+	return reinterpret_cast<duckdb_bind_info>(&info);
+}
+
+duckdb::CTableInternalInitInfo &GetCInitInfo(duckdb_init_info info) {
+	D_ASSERT(info);
+	return *reinterpret_cast<duckdb::CTableInternalInitInfo *>(info);
+}
+
+duckdb_init_info ToCInitInfo(duckdb::CTableInternalInitInfo &info) {
+	return reinterpret_cast<duckdb_init_info>(&info);
+}
+
+duckdb::CTableInternalFunctionInfo &GetCFunctionInfo(duckdb_function_info info) {
+	D_ASSERT(info);
+	return *reinterpret_cast<duckdb::CTableInternalFunctionInfo *>(info);
+}
+
+duckdb_function_info ToCFunctionInfo(duckdb::CTableInternalFunctionInfo &info) {
+	return reinterpret_cast<duckdb_function_info>(&info);
+}
+
+//===--------------------------------------------------------------------===//
+// Table Callbacks
+//===--------------------------------------------------------------------===//
 unique_ptr<FunctionData> CTableFunctionBind(ClientContext &context, TableFunctionBindInput &input,
                                             vector<LogicalType> &return_types, vector<string> &names) {
 	auto &info = input.info->Cast<CTableFunctionInfo>();
 	D_ASSERT(info.bind && info.function && info.init);
 	auto result = make_uniq<CTableBindData>(info);
 	CTableInternalBindInfo bind_info(context, input, return_types, names, *result, info);
-	info.bind(&bind_info);
+	info.bind(ToCBindInfo(bind_info));
 	if (!bind_info.success) {
 		throw BinderException(bind_info.error);
 	}
@@ -129,7 +171,7 @@ unique_ptr<GlobalTableFunctionState> CTableFunctionInit(ClientContext &context,
 	auto result = make_uniq<CTableGlobalInitData>();
 
 	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info.init(&init_info);
+	bind_data.info.init(ToCInitInfo(init_info));
 	if (!init_info.success) {
 		throw InvalidInputException(init_info.error);
 	}
@@ -145,7 +187,7 @@ unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ExecutionContext &co
 	}
 
 	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info.local_init(&init_info);
+	bind_data.info.local_init(ToCInitInfo(init_info));
 	if (!init_info.success) {
 		throw InvalidInputException(init_info.error);
 	}
@@ -162,10 +204,10 @@ unique_ptr<NodeStatistics> CTableFunctionCardinality(ClientContext &context, con
 
 void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
-	auto &global_data = (CTableGlobalInitData &)*data_p.global_state;
-	auto &local_data = (CTableLocalInitData &)*data_p.local_state;
+	auto &global_data = data_p.global_state->Cast<CTableGlobalInitData>();
+	auto &local_data = data_p.local_state->Cast<CTableLocalInitData>();
 	CTableInternalFunctionInfo function_info(bind_data, global_data.init_data, local_data.init_data);
-	bind_data.info.function(&function_info, reinterpret_cast<duckdb_data_chunk>(&output));
+	bind_data.info.function(ToCFunctionInfo(function_info), reinterpret_cast<duckdb_data_chunk>(&output));
 	if (!function_info.success) {
 		throw InvalidInputException(function_info.error);
 	}
@@ -176,17 +218,19 @@ void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChun
 //===--------------------------------------------------------------------===//
 // Table Function
 //===--------------------------------------------------------------------===//
+using duckdb::GetCTableFunction;
+
 duckdb_table_function duckdb_create_table_function() {
 	auto function = new duckdb::TableFunction("", {}, duckdb::CTableFunction, duckdb::CTableFunctionBind,
 	                                          duckdb::CTableFunctionInit, duckdb::CTableFunctionLocalInit);
 	function->function_info = duckdb::make_shared_ptr<duckdb::CTableFunctionInfo>();
 	function->cardinality = duckdb::CTableFunctionCardinality;
-	return function;
+	return reinterpret_cast<duckdb_table_function>(function);
 }
 
 void duckdb_destroy_table_function(duckdb_table_function *function) {
 	if (function && *function) {
-		auto tf = (duckdb::TableFunction *)*function;
+		auto tf = reinterpret_cast<duckdb::TableFunction *>(*function);
 		delete tf;
 		*function = nullptr;
 	}
@@ -196,17 +240,17 @@ void duckdb_table_function_set_name(duckdb_table_function function, const char *
 	if (!function || !name) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)function;
-	tf->name = name;
+	auto &tf = GetCTableFunction(function);
+	tf.name = name;
 }
 
 void duckdb_table_function_add_parameter(duckdb_table_function function, duckdb_logical_type type) {
 	if (!function || !type) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto logical_type = (duckdb::LogicalType *)type;
-	tf->arguments.push_back(*logical_type);
+	auto &tf = GetCTableFunction(function);
+	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
+	tf.arguments.push_back(*logical_type);
 }
 
 void duckdb_table_function_add_named_parameter(duckdb_table_function function, const char *name,
@@ -214,9 +258,9 @@ void duckdb_table_function_add_named_parameter(duckdb_table_function function, c
 	if (!function || !type) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto logical_type = (duckdb::LogicalType *)type;
-	tf->named_parameters.insert({name, *logical_type});
+	auto &tf = GetCTableFunction(function);
+	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
+	tf.named_parameters.insert({name, *logical_type});
 }
 
 void duckdb_table_function_set_extra_info(duckdb_table_function function, void *extra_info,
@@ -224,72 +268,82 @@ void duckdb_table_function_set_extra_info(duckdb_table_function function, void *
 	if (!function) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->extra_info = extra_info;
-	info->delete_callback = destroy;
+	auto &tf = GetCTableFunction(function);
+	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
+	info.extra_info = extra_info;
+	info.delete_callback = destroy;
 }
 
 void duckdb_table_function_set_bind(duckdb_table_function function, duckdb_table_function_bind_t bind) {
 	if (!function || !bind) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->bind = bind;
+	auto &tf = GetCTableFunction(function);
+	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
+	info.bind = bind;
 }
 
 void duckdb_table_function_set_init(duckdb_table_function function, duckdb_table_function_init_t init) {
 	if (!function || !init) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->init = init;
+	auto &tf = GetCTableFunction(function);
+	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
+	info.init = init;
 }
 
 void duckdb_table_function_set_local_init(duckdb_table_function function, duckdb_table_function_init_t init) {
 	if (!function || !init) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->local_init = init;
+	auto &tf = GetCTableFunction(function);
+	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
+	info.local_init = init;
 }
 
 void duckdb_table_function_set_function(duckdb_table_function table_function, duckdb_table_function_t function) {
 	if (!table_function || !function) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)table_function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	info->function = function;
+	auto &tf = GetCTableFunction(table_function);
+	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
+	info.function = function;
 }
 
 void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown) {
 	if (!table_function) {
 		return;
 	}
-	auto tf = (duckdb::TableFunction *)table_function;
-	tf->projection_pushdown = pushdown;
+	auto &tf = GetCTableFunction(table_function);
+	tf.projection_pushdown = pushdown;
 }
 
 duckdb_state duckdb_register_table_function(duckdb_connection connection, duckdb_table_function function) {
 	if (!connection || !function) {
 		return DuckDBError;
 	}
-	auto con = (duckdb::Connection *)connection;
-	auto tf = (duckdb::TableFunction *)function;
-	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
-	if (tf->name.empty() || !info->bind || !info->init || !info->function) {
+	auto con = reinterpret_cast<duckdb::Connection *>(connection);
+	auto &tf = GetCTableFunction(function);
+	auto &info = tf.function_info->Cast<duckdb::CTableFunctionInfo>();
+
+	if (tf.name.empty() || !info.bind || !info.init || !info.function) {
 		return DuckDBError;
 	}
+	for (auto it = tf.named_parameters.begin(); it != tf.named_parameters.end(); it++) {
+		if (duckdb::TypeVisitor::Contains(it->second, duckdb::LogicalTypeId::INVALID)) {
+			return DuckDBError;
+		}
+	}
+	for (const auto &argument : tf.arguments) {
+		if (duckdb::TypeVisitor::Contains(argument, duckdb::LogicalTypeId::INVALID)) {
+			return DuckDBError;
+		}
+	}
+
 	try {
 		con->context->RunFunctionInTransaction([&]() {
 			auto &catalog = duckdb::Catalog::GetSystemCatalog(*con->context);
-			duckdb::CreateTableFunctionInfo tf_info(*tf);
-
-			// create the function in the catalog
+			duckdb::CreateTableFunctionInfo tf_info(tf);
 			catalog.CreateTableFunction(*con->context, tf_info);
 		});
 	} catch (...) { // LCOV_EXCL_START
@@ -301,46 +355,54 @@ duckdb_state duckdb_register_table_function(duckdb_connection connection, duckdb
 //===--------------------------------------------------------------------===//
 // Bind Interface
 //===--------------------------------------------------------------------===//
+using duckdb::GetCBindInfo;
+
 void *duckdb_bind_get_extra_info(duckdb_bind_info info) {
 	if (!info) {
 		return nullptr;
 	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	return bind_info->function_info.extra_info;
+	auto &bind_info = GetCBindInfo(info);
+	return bind_info.function_info.extra_info;
 }
 
 void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duckdb_logical_type type) {
 	if (!info || !name || !type) {
 		return;
 	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	bind_info->names.push_back(name);
-	bind_info->return_types.push_back(*(reinterpret_cast<duckdb::LogicalType *>(type)));
+	auto logical_type = reinterpret_cast<duckdb::LogicalType *>(type);
+	if (duckdb::TypeVisitor::Contains(*logical_type, duckdb::LogicalTypeId::INVALID) ||
+	    duckdb::TypeVisitor::Contains(*logical_type, duckdb::LogicalTypeId::ANY)) {
+		return;
+	}
+
+	auto &bind_info = GetCBindInfo(info);
+	bind_info.names.push_back(name);
+	bind_info.return_types.push_back(*logical_type);
 }
 
 idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info) {
 	if (!info) {
 		return 0;
 	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	return bind_info->input.inputs.size();
+	auto &bind_info = GetCBindInfo(info);
+	return bind_info.input.inputs.size();
 }
 
 duckdb_value duckdb_bind_get_parameter(duckdb_bind_info info, idx_t index) {
 	if (!info || index >= duckdb_bind_get_parameter_count(info)) {
 		return nullptr;
 	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	return reinterpret_cast<duckdb_value>(new duckdb::Value(bind_info->input.inputs[index]));
+	auto &bind_info = GetCBindInfo(info);
+	return reinterpret_cast<duckdb_value>(new duckdb::Value(bind_info.input.inputs[index]));
 }
 
 duckdb_value duckdb_bind_get_named_parameter(duckdb_bind_info info, const char *name) {
 	if (!info || !name) {
 		return nullptr;
 	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	auto t = bind_info->input.named_parameters.find(name);
-	if (t == bind_info->input.named_parameters.end()) {
+	auto &bind_info = GetCBindInfo(info);
+	auto t = bind_info.input.named_parameters.find(name);
+	if (t == bind_info.input.named_parameters.end()) {
 		return nullptr;
 	} else {
 		return reinterpret_cast<duckdb_value>(new duckdb::Value(t->second));
@@ -351,20 +413,20 @@ void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_de
 	if (!info) {
 		return;
 	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
-	bind_info->bind_data.bind_data = bind_data;
-	bind_info->bind_data.delete_callback = destroy;
+	auto &bind_info = GetCBindInfo(info);
+	bind_info.bind_data.bind_data = bind_data;
+	bind_info.bind_data.delete_callback = destroy;
 }
 
 void duckdb_bind_set_cardinality(duckdb_bind_info info, idx_t cardinality, bool is_exact) {
 	if (!info) {
 		return;
 	}
-	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
+	auto &bind_info = GetCBindInfo(info);
 	if (is_exact) {
-		bind_info->bind_data.stats = duckdb::make_uniq<duckdb::NodeStatistics>(cardinality);
+		bind_info.bind_data.stats = duckdb::make_uniq<duckdb::NodeStatistics>(cardinality);
 	} else {
-		bind_info->bind_data.stats = duckdb::make_uniq<duckdb::NodeStatistics>(cardinality, cardinality);
+		bind_info.bind_data.stats = duckdb::make_uniq<duckdb::NodeStatistics>(cardinality, cardinality);
 	}
 }
 
@@ -372,19 +434,21 @@ void duckdb_bind_set_error(duckdb_bind_info info, const char *error) {
 	if (!info || !error) {
 		return;
 	}
-	auto function_info = (duckdb::CTableInternalBindInfo *)info;
-	function_info->error = error;
-	function_info->success = false;
+	auto &bind_info = GetCBindInfo(info);
+	bind_info.error = error;
+	bind_info.success = false;
 }
 
 //===--------------------------------------------------------------------===//
 // Init Interface
 //===--------------------------------------------------------------------===//
+using duckdb::GetCInitInfo;
+
 void *duckdb_init_get_extra_info(duckdb_init_info info) {
 	if (!info) {
 		return nullptr;
 	}
-	auto init_info = (duckdb::CTableInternalInitInfo *)info;
+	auto init_info = reinterpret_cast<duckdb::CTableInternalInitInfo *>(info);
 	return init_info->bind_data.info.extra_info;
 }
 
@@ -392,95 +456,97 @@ void *duckdb_init_get_bind_data(duckdb_init_info info) {
 	if (!info) {
 		return nullptr;
 	}
-	auto init_info = (duckdb::CTableInternalInitInfo *)info;
-	return init_info->bind_data.bind_data;
+	auto &init_info = GetCInitInfo(info);
+	return init_info.bind_data.bind_data;
 }
 
 void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy) {
 	if (!info) {
 		return;
 	}
-	auto init_info = (duckdb::CTableInternalInitInfo *)info;
-	init_info->init_data.init_data = init_data;
-	init_info->init_data.delete_callback = destroy;
+	auto &init_info = GetCInitInfo(info);
+	init_info.init_data.init_data = init_data;
+	init_info.init_data.delete_callback = destroy;
 }
 
 void duckdb_init_set_error(duckdb_init_info info, const char *error) {
 	if (!info || !error) {
 		return;
 	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	function_info->error = error;
-	function_info->success = false;
+	auto &init_info = GetCInitInfo(info);
+	init_info.error = error;
+	init_info.success = false;
 }
 
 idx_t duckdb_init_get_column_count(duckdb_init_info info) {
 	if (!info) {
 		return 0;
 	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	return function_info->column_ids.size();
+	auto &init_info = GetCInitInfo(info);
+	return init_info.column_ids.size();
 }
 
 idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index) {
 	if (!info) {
 		return 0;
 	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	if (column_index >= function_info->column_ids.size()) {
+	auto &init_info = GetCInitInfo(info);
+	if (column_index >= init_info.column_ids.size()) {
 		return 0;
 	}
-	return function_info->column_ids[column_index];
+	return init_info.column_ids[column_index];
 }
 
 void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads) {
 	if (!info) {
 		return;
 	}
-	auto function_info = (duckdb::CTableInternalInitInfo *)info;
-	function_info->init_data.max_threads = max_threads;
+	auto &init_info = GetCInitInfo(info);
+	init_info.init_data.max_threads = max_threads;
 }
 
 //===--------------------------------------------------------------------===//
 // Function Interface
 //===--------------------------------------------------------------------===//
+using duckdb::GetCFunctionInfo;
+
 void *duckdb_function_get_extra_info(duckdb_function_info info) {
 	if (!info) {
 		return nullptr;
 	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->bind_data.info.extra_info;
+	auto &function_info = GetCFunctionInfo(info);
+	return function_info.bind_data.info.extra_info;
 }
 
 void *duckdb_function_get_bind_data(duckdb_function_info info) {
 	if (!info) {
 		return nullptr;
 	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->bind_data.bind_data;
+	auto &function_info = GetCFunctionInfo(info);
+	return function_info.bind_data.bind_data;
 }
 
 void *duckdb_function_get_init_data(duckdb_function_info info) {
 	if (!info) {
 		return nullptr;
 	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->init_data.init_data;
+	auto &function_info = GetCFunctionInfo(info);
+	return function_info.init_data.init_data;
 }
 
 void *duckdb_function_get_local_init_data(duckdb_function_info info) {
 	if (!info) {
 		return nullptr;
 	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->local_data.init_data;
+	auto &function_info = GetCFunctionInfo(info);
+	return function_info.local_data.init_data;
 }
 
 void duckdb_function_set_error(duckdb_function_info info, const char *error) {
 	if (!info || !error) {
 		return;
 	}
-	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	function_info->error = error;
-	function_info->success = false;
+	auto &function_info = GetCFunctionInfo(info);
+	function_info.error = error;
+	function_info.success = false;
 }

package/src/duckdb/src/main/capi/value-c.cpp

@@ -158,7 +158,7 @@ duckdb_string duckdb_value_string_internal(duckdb_result *result, idx_t col, idx
 }
 
 duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row) {
-	if (CanFetchValue(result, col, row) && result->__deprecated_columns[col].__deprecated_type == DUCKDB_TYPE_BLOB) {
+	if (CanFetchValue(result, col, row) && result->deprecated_columns[col].deprecated_type == DUCKDB_TYPE_BLOB) {
 		auto internal_result = UnsafeFetch<duckdb_blob>(result, col, row);
 
 		duckdb_blob result_blob;
@@ -174,5 +174,5 @@ bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
 	if (!CanUseDeprecatedFetch(result, col, row)) {
 		return false;
 	}
-	return result->__deprecated_columns[col].__deprecated_nullmask[row];
+	return result->deprecated_columns[col].deprecated_nullmask[row];
 }

package/src/duckdb/src/main/chunk_scan_state/batched_data_collection.cpp

@@ -0,0 +1,57 @@
+#include "duckdb/main/chunk_scan_state/batched_data_collection.hpp"
+#include "duckdb/storage/buffer_manager.hpp"
+
+namespace duckdb {
+
+BatchCollectionChunkScanState::BatchCollectionChunkScanState(BatchedDataCollection &collection,
+                                                             BatchedChunkIteratorRange &range, ClientContext &context)
+    : ChunkScanState(), collection(collection) {
+	collection.InitializeScan(state, range);
+	current_chunk = make_uniq<DataChunk>();
+	auto &allocator = BufferManager::GetBufferManager(context).GetBufferAllocator();
+	current_chunk->Initialize(allocator, collection.Types());
+}
+
+BatchCollectionChunkScanState::~BatchCollectionChunkScanState() {
+}
+
+void BatchCollectionChunkScanState::InternalLoad(ErrorData &error) {
+	if (state.range.begin == state.range.end) {
+		// Signal empty chunk to break out of the loop
+		current_chunk->SetCardinality(0);
+		return;
+	}
+	offset = 0;
+	current_chunk->Reset();
+	collection.Scan(state, *current_chunk);
+	return;
+}
+
+bool BatchCollectionChunkScanState::HasError() const {
+	return false;
+}
+
+ErrorData &BatchCollectionChunkScanState::GetError() {
+	throw NotImplementedException("BatchDataCollections don't have an internal error object");
+}
+
+const vector<LogicalType> &BatchCollectionChunkScanState::Types() const {
+	return collection.Types();
+}
+
+const vector<string> &BatchCollectionChunkScanState::Names() const {
+	throw NotImplementedException("BatchDataCollections don't have names");
+}
+
+bool BatchCollectionChunkScanState::LoadNextChunk(ErrorData &error) {
+	if (finished) {
+		return false;
+	}
+	InternalLoad(error);
+	if (ChunkIsEmpty()) {
+		finished = true;
+	}
+	return true;
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/client_config.cpp

@@ -0,0 +1,17 @@
+#include "duckdb/main/client_config.hpp"
+
+#include "duckdb/common/file_system.hpp"
+
+namespace duckdb {
+
+void ClientConfig::SetDefaultStreamingBufferSize() {
+	auto memory = FileSystem::GetAvailableMemory();
+	auto default_size = ClientConfig().streaming_buffer_size;
+	if (!memory.IsValid()) {
+		streaming_buffer_size = default_size;
+		return;
+	}
+	streaming_buffer_size = MinValue(memory.GetIndex(), default_size);
+}
+
+} // namespace duckdb