duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

package/src/duckdb/src/main/appender.cpp

@@ -18,12 +18,12 @@
 
 namespace duckdb {
 
-BaseAppender::BaseAppender(Allocator &allocator, AppenderType type_p)
+BaseAppender::BaseAppender(Allocator &allocator, const AppenderType type_p)
     : allocator(allocator), column(0), appender_type(type_p) {
 }
 
-BaseAppender::BaseAppender(Allocator &allocator_p, vector<LogicalType> types_p, AppenderType type_p,
-                           idx_t flush_count_p)
+BaseAppender::BaseAppender(Allocator &allocator_p, vector<LogicalType> types_p, const AppenderType type_p,
+                           const idx_t flush_count_p)
     : allocator(allocator_p), types(std::move(types_p)), collection(make_uniq<ColumnDataCollection>(allocator, types)),
       column(0), appender_type(type_p), flush_count(flush_count_p) {
 	InitializeChunk();
@@ -36,15 +36,22 @@ void BaseAppender::Destructor() {
 	if (Exception::UncaughtException()) {
 		return;
 	}
-	// flush any remaining chunks, but only if we are not cleaning up the appender as part of an exception stack unwind
-	// wrapped in a try/catch because Close() can throw if the table was dropped in the meantime
+	// Flush any remaining chunks, if we are not cleaning up as part of an exception stack unwind wrapped in a
+	// try/catch. Close() can throw if the table was dropped in the meantime.
 	try {
 		Close();
 	} catch (...) { // NOLINT
 	}
 }
 
-InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p, idx_t flush_count_p)
+const vector<LogicalType> &BaseAppender::GetActiveTypes() const {
+	if (active_types.empty()) {
+		return types;
+	}
+	return active_types;
+}
+
+InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p, const idx_t flush_count_p)
     : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes(), AppenderType::PHYSICAL, flush_count_p),
       context(context_p), table(table_p) {
 }
@@ -53,13 +60,17 @@ InternalAppender::~InternalAppender() {
 	Destructor();
 }
 
-Appender::Appender(Connection &con, const string &schema_name, const string &table_name)
+Appender::Appender(Connection &con, const string &database_name, const string &schema_name, const string &table_name)
     : BaseAppender(Allocator::DefaultAllocator(), AppenderType::LOGICAL), context(con.context) {
-	description = con.TableInfo(schema_name, table_name);
+
+	description = con.TableInfo(database_name, schema_name, table_name);
 	if (!description) {
-		// table could not be found
 		throw CatalogException(StringUtil::Format("Table \"%s.%s\" could not be found", schema_name, table_name));
 	}
+	if (description->readonly) {
+		throw InvalidInputException("Cannot append to a readonly database.");
+	}
+
 	vector<optional_ptr<const ParsedExpression>> defaults;
 	for (auto &column : description->columns) {
 		if (column.Generated()) {
@@ -68,39 +79,50 @@ Appender::Appender(Connection &con, const string &schema_name, const string &tab
 		types.push_back(column.Type());
 		defaults.push_back(column.HasDefaultValue() ? &column.DefaultValue() : nullptr);
 	}
-	auto binder = Binder::CreateBinder(*context);
 
+	auto binder = Binder::CreateBinder(*context);
 	context->RunFunctionInTransaction([&]() {
 		for (idx_t i = 0; i < types.size(); i++) {
 			auto &type = types[i];
 			auto &expr = defaults[i];
 
 			if (!expr) {
-				// Insert NULL
+				// The default value is NULL.
 				default_values[i] = Value(type);
 				continue;
 			}
+
 			auto default_copy = expr->Copy();
 			D_ASSERT(!default_copy->HasParameter());
+
 			ConstantBinder default_binder(*binder, *context, "DEFAULT value");
 			default_binder.target_type = type;
 			auto bound_default = default_binder.Bind(default_copy);
+
+			if (!bound_default->IsFoldable()) {
+				// Not supported yet.
+				continue;
+			}
+
 			Value result_value;
-			if (bound_default->IsFoldable() &&
-			    ExpressionExecutor::TryEvaluateScalar(*context, *bound_default, result_value)) {
-				// Insert the evaluated Value
+			auto eval_success = ExpressionExecutor::TryEvaluateScalar(*context, *bound_default, result_value);
+			// Insert the default Value.
+			if (eval_success) {
 				default_values[i] = result_value;
-			} else {
-				// These are not supported currently, we don't add them to the 'default_values' map
 			}
 		}
 	});
 
 	InitializeChunk();
-	collection = make_uniq<ColumnDataCollection>(allocator, types);
+	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
 }
 
-Appender::Appender(Connection &con, const string &table_name) : Appender(con, DEFAULT_SCHEMA, table_name) {
+Appender::Appender(Connection &con, const string &schema_name, const string &table_name)
+    : Appender(con, INVALID_CATALOG, schema_name, table_name) {
+}
+
+Appender::Appender(Connection &con, const string &table_name)
+    : Appender(con, INVALID_CATALOG, DEFAULT_SCHEMA, table_name) {
 }
 
 Appender::~Appender() {
@@ -108,14 +130,15 @@ Appender::~Appender() {
 }
 
 void BaseAppender::InitializeChunk() {
-	chunk.Initialize(allocator, types);
+	chunk.Destroy();
+	chunk.Initialize(allocator, GetActiveTypes());
 }
 
 void BaseAppender::BeginRow() {
 }
 
 void BaseAppender::EndRow() {
-	// check that all rows have been appended to
+	// Ensure that all columns have been appended to.
 	if (column != chunk.ColumnCount()) {
 		throw InvalidInputException("Call to EndRow before all columns have been appended to!");
 	}
@@ -140,8 +163,8 @@ void BaseAppender::AppendDecimalValueInternal(Vector &col, SRC input) {
 		auto width = DecimalType::GetWidth(type);
 		auto scale = DecimalType::GetScale(type);
 		CastParameters parameters;
-		TryCastToDecimal::Operation<SRC, DST>(input, FlatVector::GetData<DST>(col)[chunk.size()], parameters, width,
-		                                      scale);
+		auto &result = FlatVector::GetData<DST>(col)[chunk.size()];
+		TryCastToDecimal::Operation<SRC, DST>(input, result, parameters, width, scale);
 		return;
 	}
 	case AppenderType::PHYSICAL: {
@@ -155,7 +178,7 @@ void BaseAppender::AppendDecimalValueInternal(Vector &col, SRC input) {
 
 template <class T>
 void BaseAppender::AppendValueInternal(T input) {
-	if (column >= types.size()) {
+	if (column >= GetActiveTypes().size()) {
 		throw InvalidInputException("Too many appends for chunk!");
 	}
 	auto &col = chunk.data[column];
@@ -343,13 +366,35 @@ void BaseAppender::Append(interval_t value) {
 }
 
 template <>
-void BaseAppender::Append(Value value) { // NOLINT: template shtuff
+void BaseAppender::Append(Value value) { // NOLINT: template stuff
 	if (column >= chunk.ColumnCount()) {
 		throw InvalidInputException("Too many appends for chunk!");
 	}
 	AppendValue(value);
 }
 
+void duckdb::BaseAppender::Append(DataChunk &target, const Value &value, idx_t col, idx_t row) {
+	if (col >= target.ColumnCount()) {
+		throw InvalidInputException("Too many appends for chunk!");
+	}
+	if (row >= target.GetCapacity()) {
+		throw InvalidInputException("Too many rows for chunk!");
+	}
+
+	if (value.type() == target.GetTypes()[col]) {
+		target.SetValue(col, row, value);
+	} else {
+		Value new_value;
+		string error_msg;
+		if (value.DefaultTryCastAs(target.GetTypes()[col], new_value, &error_msg)) {
+			target.SetValue(col, row, new_value);
+		} else {
+			throw InvalidInputException("type mismatch in Append, expected %s, got %s for column %d",
+			                            target.GetTypes()[col], value.type(), col);
+		}
+	}
+}
+
 template <>
 void BaseAppender::Append(std::nullptr_t value) {
 	if (column >= chunk.ColumnCount()) {
@@ -364,18 +409,46 @@ void BaseAppender::AppendValue(const Value &value) {
 	column++;
 }
 
-void BaseAppender::AppendDataChunk(DataChunk &chunk) {
-	auto chunk_types = chunk.GetTypes();
-	if (chunk_types != types) {
-		for (idx_t i = 0; i < chunk.ColumnCount(); i++) {
-			if (chunk.data[i].GetType() != types[i]) {
-				throw InvalidInputException("Type mismatch in Append DataChunk and the types required for appender, "
-				                            "expected %s but got %s for column %d",
-				                            types[i].ToString(), chunk.data[i].GetType().ToString(), i + 1);
-			}
+void BaseAppender::AppendDataChunk(DataChunk &chunk_p) {
+	auto chunk_types = chunk_p.GetTypes();
+	auto &appender_types = GetActiveTypes();
+
+	// Early-out, if types match.
+	if (chunk_types == appender_types) {
+		collection->Append(chunk_p);
+		if (collection->Count() >= flush_count) {
+			Flush();
 		}
+		return;
 	}
-	collection->Append(chunk);
+
+	auto count = chunk_p.ColumnCount();
+	if (count != appender_types.size()) {
+		throw InvalidInputException("incorrect column count in AppendDataChunk, expected %d, got %d",
+		                            appender_types.size(), count);
+	}
+
+	// We try to cast the chunk.
+	auto size = chunk_p.size();
+	DataChunk cast_chunk;
+	cast_chunk.Initialize(allocator, appender_types);
+	cast_chunk.SetCardinality(size);
+
+	for (idx_t i = 0; i < count; i++) {
+		if (chunk_p.data[i].GetType() == appender_types[i]) {
+			cast_chunk.data[i].Reference(chunk_p.data[i]);
+			continue;
+		}
+
+		string error_msg;
+		auto success = VectorOperations::DefaultTryCast(chunk_p.data[i], cast_chunk.data[i], size, &error_msg);
+		if (!success) {
+			throw InvalidInputException("type mismatch in AppendDataChunk, expected %s, got %s for column %d",
+			                            appender_types[i].ToString(), chunk_p.data[i].GetType().ToString(), i);
+		}
+	}
+
+	collection->Append(cast_chunk);
 	if (collection->Count() >= flush_count) {
 		Flush();
 	}
@@ -393,7 +466,7 @@ void BaseAppender::FlushChunk() {
 }
 
 void BaseAppender::Flush() {
-	// check that all vectors have the same length before appending
+	// Check that all vectors have the same length before appending.
 	if (column != 0) {
 		throw InvalidInputException("Failed to Flush appender: incomplete append to row!");
 	}
@@ -402,36 +475,105 @@ void BaseAppender::Flush() {
 	if (collection->Count() == 0) {
 		return;
 	}
-	FlushInternal(*collection);
 
+	FlushInternal(*collection);
 	collection->Reset();
 	column = 0;
 }
 
 void Appender::FlushInternal(ColumnDataCollection &collection) {
-	context->Append(*description, collection);
+	context->Append(*description, collection, &column_ids);
 }
 
 void Appender::AppendDefault() {
-	auto it = default_values.find(column);
-	auto &column_def = description->columns[column];
+	auto value = GetDefaultValue(column);
+	Append(value);
+}
+
+void duckdb::Appender::AppendDefault(DataChunk &chunk, idx_t col, idx_t row) {
+	auto value = GetDefaultValue(col);
+	Append(chunk, value, col, row);
+}
+
+Value Appender::GetDefaultValue(idx_t column) {
+	auto index = column;
+
+	if (!column_ids.empty()) {
+		if (column >= column_ids.size()) {
+			throw InvalidInputException("Column index out of bounds");
+		}
+		index = column_ids[column].index;
+	}
+
+	auto it = default_values.find(index);
 	if (it == default_values.end()) {
+		auto &name = description->columns[index].Name();
 		throw NotImplementedException(
-		    "AppendDefault is currently not supported for column \"%s\" because default expression is not foldable.",
-		    column_def.Name());
+		    "AppendDefault is not supported for column \"%s\": not a foldable default expressions.", name);
 	}
-	auto &default_value = it->second;
-	Append(default_value);
+	return it->second;
+}
+
+void Appender::AddColumn(const string &name) {
+	Flush();
+
+	auto exists = false;
+	for (idx_t col_idx = 0; col_idx < description->columns.size(); col_idx++) {
+		auto &col_def = description->columns[col_idx];
+		if (col_def.Name() != name) {
+			continue;
+		}
+
+		// Ensure that we are not adding a generated column.
+		if (col_def.Generated()) {
+			throw InvalidInputException("cannot add a generated column to the appender");
+		}
+
+		// Ensure that we haven't added this column before.
+		for (const auto &column_id : column_ids) {
+			if (column_id == col_def.Logical()) {
+				throw InvalidInputException("cannot add the same column twice");
+			}
+		}
+
+		active_types.push_back(col_def.Type());
+		column_ids.push_back(col_def.Logical());
+		exists = true;
+		break;
+	}
+	if (!exists) {
+		throw InvalidInputException("the column must exist in the table");
+	}
+
+	InitializeChunk();
+	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
+}
+
+void Appender::ClearColumns() {
+	Flush();
+	column_ids.clear();
+	active_types.clear();
+
+	InitializeChunk();
+	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
 }
 
 void InternalAppender::FlushInternal(ColumnDataCollection &collection) {
 	auto binder = Binder::CreateBinder(context);
 	auto bound_constraints = binder->BindConstraints(table);
-	table.GetStorage().LocalAppend(table, context, collection, bound_constraints);
+	table.GetStorage().LocalAppend(table, context, collection, bound_constraints, nullptr);
+}
+
+void InternalAppender::AddColumn(const string &name) {
+	throw InternalException("AddColumn not implemented for InternalAppender");
+}
+
+void InternalAppender::ClearColumns() {
+	throw InternalException("ClearColumns not implemented for InternalAppender");
 }
 
 void BaseAppender::Close() {
-	if (column == 0 || column == types.size()) {
+	if (column == 0 || column == GetActiveTypes().size()) {
 		Flush();
 	}
 }

package/src/duckdb/src/main/attached_database.cpp

@@ -25,7 +25,6 @@ AttachOptions::AttachOptions(const unique_ptr<AttachInfo> &info, const AccessMod
     : access_mode(default_access_mode) {
 
 	for (auto &entry : info->options) {
-
 		if (entry.first == "readonly" || entry.first == "read_only") {
 			// Extract the read access mode.
 
@@ -40,7 +39,6 @@ AttachOptions::AttachOptions(const unique_ptr<AttachInfo> &info, const AccessMod
 
 		if (entry.first == "readwrite" || entry.first == "read_write") {
 			// Extract the write access mode.
-
 			auto read_write = BooleanValue::Get(entry.second.DefaultCastAs(LogicalType::BOOLEAN));
 			if (!read_write) {
 				access_mode = AccessMode::READ_ONLY;
@@ -56,11 +54,12 @@ AttachOptions::AttachOptions(const unique_ptr<AttachInfo> &info, const AccessMod
 			continue;
 		}
 
-		// We allow unrecognized options in storage extensions. To track that we saw an unrecognized option,
-		// we set unrecognized_option.
-		if (unrecognized_option.empty()) {
-			unrecognized_option = entry.first;
+		if (entry.first == "default_table") {
+			default_table = QualifiedName::Parse(StringValue::Get(entry.second.DefaultCastAs(LogicalType::VARCHAR)));
+			continue;
 		}
+
+		options[entry.first] = entry.second;
 	}
 }
 
@@ -93,6 +92,15 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, str
 	} else {
 		type = AttachedDatabaseType::READ_WRITE_DATABASE;
 	}
+	for (auto &entry : options.options) {
+		if (StringUtil::CIEquals(entry.first, "block_size")) {
+			continue;
+		}
+		if (StringUtil::CIEquals(entry.first, "row_group_size")) {
+			continue;
+		}
+		throw BinderException("Unrecognized option for attach \"%s\"", entry.first);
+	}
 
 	// We create the storage after the catalog to guarantee we allow extensions to instantiate the DuckCatalog.
 	catalog = make_uniq<DuckCatalog>(*this);
@@ -163,14 +171,14 @@ string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &f
 	return name;
 }
 
-void AttachedDatabase::Initialize(const optional_idx block_alloc_size) {
+void AttachedDatabase::Initialize(StorageOptions options) {
 	if (IsSystem()) {
 		catalog->Initialize(true);
 	} else {
 		catalog->Initialize(false);
 	}
 	if (storage) {
-		storage->Initialize(block_alloc_size);
+		storage->Initialize(options);
 	}
 }
 

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

@@ -15,18 +15,27 @@ using duckdb::uhugeint_t;
 
 duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
                                     duckdb_appender *out_appender) {
+	return duckdb_appender_create_ext(connection, INVALID_CATALOG, schema, table, out_appender);
+}
+
+duckdb_state duckdb_appender_create_ext(duckdb_connection connection, const char *catalog, const char *schema,
+                                        const char *table, duckdb_appender *out_appender) {
 	Connection *conn = reinterpret_cast<Connection *>(connection);
 
 	if (!connection || !table || !out_appender) {
 		return DuckDBError;
 	}
+	if (catalog == nullptr) {
+		catalog = INVALID_CATALOG;
+	}
 	if (schema == nullptr) {
 		schema = DEFAULT_SCHEMA;
 	}
+
 	auto wrapper = new AppenderWrapper();
 	*out_appender = (duckdb_appender)wrapper;
 	try {
-		wrapper->appender = duckdb::make_uniq<Appender>(*conn, schema, table);
+		wrapper->appender = duckdb::make_uniq<Appender>(*conn, catalog, schema, table);
 	} catch (std::exception &ex) {
 		ErrorData error(ex);
 		wrapper->error = error.RawMessage();
@@ -73,6 +82,14 @@ duckdb_state duckdb_appender_run_function(duckdb_appender appender, FUN &&functi
 	return DuckDBSuccess;
 }
 
+duckdb_state duckdb_appender_add_column(duckdb_appender appender, const char *name) {
+	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.AddColumn(name); });
+}
+
+duckdb_state duckdb_appender_clear_columns(duckdb_appender appender) {
+	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.ClearColumns(); });
+}
+
 const char *duckdb_appender_error(duckdb_appender appender) {
 	if (!appender) {
 		return nullptr;
@@ -128,6 +145,27 @@ duckdb_state duckdb_append_default(duckdb_appender appender) {
 	return DuckDBSuccess;
 }
 
+duckdb_state duckdb_append_default_to_chunk(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col, idx_t row) {
+	if (!appender || !chunk) {
+		return DuckDBError;
+	}
+
+	auto *appender_instance = reinterpret_cast<AppenderWrapper *>(appender);
+
+	auto data_chunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
+
+	try {
+		appender_instance->appender->AppendDefault(*data_chunk, col, row);
+	} catch (std::exception &ex) {
+		ErrorData error(ex);
+		appender_instance->error = error.RawMessage();
+		return DuckDBError;
+	} catch (...) {
+		return DuckDBError;
+	}
+	return DuckDBSuccess;
+}
+
 duckdb_state duckdb_append_bool(duckdb_appender appender, bool value) {
 	return duckdb_append_internal<bool>(appender, value);
 }
@@ -241,7 +279,7 @@ idx_t duckdb_appender_column_count(duckdb_appender appender) {
 		return 0;
 	}
 
-	return wrapper->appender->GetTypes().size();
+	return wrapper->appender->GetActiveTypes().size();
 }
 
 duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx) {
@@ -254,13 +292,18 @@ duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t
 		return nullptr;
 	}
 
-	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(wrapper->appender->GetTypes()[col_idx]));
+	auto &logical_type = wrapper->appender->GetActiveTypes()[col_idx];
+	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(logical_type));
+}
+
+duckdb_state duckdb_append_value(duckdb_appender appender, duckdb_value value) {
+	return duckdb_append_internal<duckdb::Value>(appender, *(reinterpret_cast<duckdb::Value *>(value)));
 }
 
 duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk) {
 	if (!chunk) {
 		return DuckDBError;
 	}
-	auto data_chunk = (duckdb::DataChunk *)chunk;
+	auto data_chunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
 	return duckdb_appender_run_function(appender, [&](Appender &appender) { appender.AppendDataChunk(*data_chunk); });
 }

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

@@ -52,11 +52,11 @@ duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared, du
 	for (idx_t i = 0; i < count; i++) {
 		// Every prepared parameter type is UNKNOWN, which we need to map to NULL according to the spec of
 		// 'AdbcStatementGetParameterSchema'
-		auto type = LogicalType::SQLNULL;
+		const auto type = LogicalType::SQLNULL;
 
 		// FIXME: we don't support named parameters yet, but when we do, this needs to be updated
 		auto name = std::to_string(i);
-		prepared_types.push_back(std::move(type));
+		prepared_types.push_back(type);
 		prepared_names.push_back(name);
 	}
 
@@ -87,8 +87,10 @@ duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *o
 	if (!wrapper->current_chunk || wrapper->current_chunk->size() == 0) {
 		return DuckDBSuccess;
 	}
+	auto extension_type_cast = duckdb::ArrowTypeExtensionData::GetExtensionTypes(
+	    *wrapper->result->client_properties.client_context, wrapper->result->types);
 	ArrowConverter::ToArrowArray(*wrapper->current_chunk, reinterpret_cast<ArrowArray *>(*out_array),
-	                             wrapper->result->client_properties);
+	                             wrapper->result->client_properties, extension_type_cast);
 	return DuckDBSuccess;
 }
 
@@ -98,8 +100,11 @@ void duckdb_result_arrow_array(duckdb_result result, duckdb_data_chunk chunk, du
 	}
 	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
 	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
+	auto extension_type_cast = duckdb::ArrowTypeExtensionData::GetExtensionTypes(
+	    *result_data.result->client_properties.client_context, result_data.result->types);
+
 	ArrowConverter::ToArrowArray(*dchunk, reinterpret_cast<ArrowArray *>(*out_array),
-	                             result_data.result->client_properties);
+	                             result_data.result->client_properties, extension_type_cast);
 }
 
 idx_t duckdb_arrow_row_count(duckdb_arrow result) {

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

@@ -1,6 +1,7 @@
 #include "duckdb/main/capi/capi_internal.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/main/extension_helper.hpp"
 
 using duckdb::DBConfig;
 using duckdb::Value;
@@ -22,19 +23,31 @@ duckdb_state duckdb_create_config(duckdb_config *out_config) {
 }
 
 size_t duckdb_config_count() {
-	return DBConfig::GetOptionCount();
+	return DBConfig::GetOptionCount() + duckdb::ExtensionHelper::ArraySize(duckdb::EXTENSION_SETTINGS);
 }
 
 duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description) {
 	auto option = DBConfig::GetOptionByIndex(index);
-	if (!option) {
+	if (option) {
+		if (out_name) {
+			*out_name = option->name;
+		}
+		if (out_description) {
+			*out_description = option->description;
+		}
+		return DuckDBSuccess;
+	}
+
+	// extension index?
+	auto entry = duckdb::ExtensionHelper::GetArrayEntry(duckdb::EXTENSION_SETTINGS, index - DBConfig::GetOptionCount());
+	if (!entry) {
 		return DuckDBError;
 	}
 	if (out_name) {
-		*out_name = option->name;
+		*out_name = entry->name;
 	}
 	if (out_description) {
-		*out_description = option->description;
+		*out_description = entry->extension;
 	}
 	return DuckDBSuccess;
 }

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

@@ -10,6 +10,9 @@ using duckdb::Timestamp;
 
 using duckdb::date_t;
 using duckdb::dtime_t;
+using duckdb::timestamp_ms_t;
+using duckdb::timestamp_ns_t;
+using duckdb::timestamp_sec_t;
 using duckdb::timestamp_t;
 
 duckdb_date_struct duckdb_from_date(duckdb_date date) {
@@ -99,3 +102,15 @@ duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts) {
 bool duckdb_is_finite_timestamp(duckdb_timestamp ts) {
 	return Timestamp::IsFinite(timestamp_t(ts.micros));
 }
+
+bool duckdb_is_finite_timestamp_s(duckdb_timestamp_s ts) {
+	return Timestamp::IsFinite(timestamp_sec_t(ts.seconds));
+}
+
+bool duckdb_is_finite_timestamp_ms(duckdb_timestamp_ms ts) {
+	return Timestamp::IsFinite(timestamp_ms_t(ts.millis));
+}
+
+bool duckdb_is_finite_timestamp_ns(duckdb_timestamp_ns ts) {
+	return Timestamp::IsFinite(timestamp_ns_t(ts.nanos));
+}