duckdb 0.10.2-dev0.0 → 0.10.2-dev5.0

package/src/duckdb/src/include/duckdb/storage/table/row_version_manager.hpp

@@ -15,6 +15,7 @@
 
 namespace duckdb {
 
+struct DeleteInfo;
 class MetadataManager;
 struct MetaBlockPointer;
 
@@ -38,7 +39,7 @@ public:
 	void RevertAppend(idx_t start_row);
 
 	idx_t DeleteRows(idx_t vector_idx, transaction_t transaction_id, row_t rows[], idx_t count);
-	void CommitDelete(idx_t vector_idx, transaction_t commit_id, row_t rows[], idx_t count);
+	void CommitDelete(idx_t vector_idx, transaction_t commit_id, const DeleteInfo &info);
 
 	vector<MetaBlockPointer> Checkpoint(MetadataManager &manager);
 	static shared_ptr<RowVersionManager> Deserialize(MetaBlockPointer delete_pointer, MetadataManager &manager,

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -44,7 +44,7 @@ struct SegmentScanState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -60,7 +60,7 @@ struct IndexScanState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -111,7 +111,7 @@ struct ColumnFetchState {
 
 class CollectionScanState {
 public:
-	CollectionScanState(TableScanState &parent_p);
+	explicit CollectionScanState(TableScanState &parent_p);
 
 	//! The current row_group we are scanning
 	RowGroup *row_group;

package/src/duckdb/src/include/duckdb/storage/table/segment_lock.hpp

@@ -17,7 +17,7 @@ struct SegmentLock {
 public:
 	SegmentLock() {
 	}
-	SegmentLock(mutex &lock) : lock(lock) {
+	explicit SegmentLock(mutex &lock) : lock(lock) {
 	}
 	// disable copy constructors
 	SegmentLock(const SegmentLock &other) = delete;

package/src/duckdb/src/include/duckdb/storage/table/segment_tree.hpp

@@ -320,10 +320,10 @@ private:
 		};
 
 	public:
-		SegmentIterator begin() {
+		SegmentIterator begin() { // NOLINT: match stl API
 			return SegmentIterator(tree, tree.GetRootSegment());
 		}
-		SegmentIterator end() {
+		SegmentIterator end() { // NOLINT: match stl API
 			return SegmentIterator(tree, nullptr);
 		}
 	};
@@ -349,8 +349,8 @@ private:
 		if (!SUPPORTS_LAZY_LOADING) {
 			return;
 		}
-		while (LoadNextSegment(l))
-			;
+		while (LoadNextSegment(l)) {
+		}
 	}
 };
 

package/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp

@@ -23,6 +23,8 @@ public:
 	ValidityColumnData validity;
 
 public:
+	bool HasUpdates() const override;
+
 	void SetStart(idx_t new_start) override;
 	bool CheckZonemap(ColumnScanState &state, TableFilter &filter) override;
 

package/src/duckdb/src/include/duckdb/storage/table/table_index_list.hpp

@@ -41,8 +41,9 @@ public:
 	void CommitDrop(const string &name);
 	//! Returns true, if the index name does not exist
 	bool NameIsUnique(const string &name);
-	//! Initializes unknown indexes that might now be present after an extension load
-	void InitializeIndexes(ClientContext &context, DataTableInfo &table_info);
+	//! Initializes unknown indexes that might now be present after an extension load, optionally throwing an exception
+	//! if a index cant be initialized
+	void InitializeIndexes(ClientContext &context, DataTableInfo &table_info, bool throw_on_failure = false);
 	bool Empty();
 	idx_t Count();
 	void Move(TableIndexList &other);

package/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp

@@ -22,7 +22,7 @@ class Deserializer;
 
 class TableStatisticsLock {
 public:
-	TableStatisticsLock(mutex &l) : guard(l) {
+	explicit TableStatisticsLock(mutex &l) : guard(l) {
 	}
 
 	lock_guard<mutex> guard;

package/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp

@@ -22,7 +22,7 @@ struct UpdateNode;
 
 class UpdateSegment {
 public:
-	UpdateSegment(ColumnData &column_data);
+	explicit UpdateSegment(ColumnData &column_data);
 	~UpdateSegment();
 
 	ColumnData &column_data;

package/src/duckdb/src/include/duckdb/storage/table_storage_info.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/storage/block.hpp"
 #include "duckdb/storage/index_storage_info.hpp"
 #include "duckdb/storage/storage_info.hpp"
+#include "duckdb/common/optional_idx.hpp"
 
 namespace duckdb {
 
@@ -38,7 +39,7 @@ struct ColumnSegmentInfo {
 class TableStorageInfo {
 public:
 	//! The (estimated) cardinality of the table
-	idx_t cardinality = DConstants::INVALID_INDEX;
+	optional_idx cardinality;
 	//! Info of the indexes of a table
 	vector<IndexInfo> index_info;
 };

package/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp

@@ -52,7 +52,7 @@ public:
 
 public:
 	//! Replay the WAL
-	static bool Replay(AttachedDatabase &database, string &path);
+	static bool Replay(AttachedDatabase &database, unique_ptr<FileHandle> handle);
 
 	//! Returns the current size of the WAL in bytes
 	int64_t GetWALSize();

package/src/duckdb/src/include/duckdb/transaction/delete_info.hpp

@@ -20,7 +20,26 @@ struct DeleteInfo {
 	idx_t vector_idx;
 	idx_t count;
 	idx_t base_row;
-	row_t rows[1];
+	//! Whether or not row ids are consecutive (0, 1, 2, ..., count).
+	//! If this is true no rows are stored and `rows` should not be accessed.
+	bool is_consecutive;
+
+	uint16_t *GetRows() {
+		if (is_consecutive) {
+			throw InternalException("DeleteInfo is consecutive - rows are not accessible");
+		}
+		return rows;
+	}
+	const uint16_t *GetRows() const {
+		if (is_consecutive) {
+			throw InternalException("DeleteInfo is consecutive - rows are not accessible");
+		}
+		return rows;
+	}
+
+private:
+	//! The per-vector row identifiers (actual row id is base_row + rows[x])
+	uint16_t rows[1];
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/transaction/transaction.hpp

@@ -66,7 +66,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };

package/src/duckdb/src/include/duckdb/transaction/transaction_data.hpp

@@ -16,7 +16,7 @@ class DuckTransaction;
 class Transaction;
 
 struct TransactionData {
-	TransactionData(DuckTransaction &transaction_p);
+	TransactionData(DuckTransaction &transaction_p); // NOLINT: allow implicit conversion
 	TransactionData(transaction_t transaction_id_p, transaction_t start_time_p);
 
 	optional_ptr<DuckTransaction> transaction;

package/src/duckdb/src/include/duckdb/transaction/undo_buffer.hpp

@@ -28,7 +28,7 @@ public:
 	};
 
 public:
-	UndoBuffer(ClientContext &context);
+	explicit UndoBuffer(ClientContext &context);
 
 	//! Reserve space for an entry of the specified type and length in the undo
 	//! buffer

package/src/duckdb/src/include/duckdb/transaction/update_info.hpp

@@ -27,7 +27,7 @@ struct UpdateInfo {
 	//! The vector index within the uncompressed segment
 	idx_t vector_index;
 	//! The amount of updated tuples
-	sel_t N;
+	sel_t N; // NOLINT
 	//! The maximum amount of tuples that can fit into this UpdateInfo
 	sel_t max;
 	//! The row ids of the tuples that have been updated. This should always be kept sorted!

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

@@ -36,7 +36,7 @@ void BaseAppender::Destructor() {
 	// wrapped in a try/catch because Close() can throw if the table was dropped in the meantime
 	try {
 		Close();
-	} catch (...) {
+	} catch (...) { // NOLINT
 	}
 }
 

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

@@ -96,14 +96,14 @@ string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &f
 	return name;
 }
 
-void AttachedDatabase::Initialize() {
+void AttachedDatabase::Initialize(optional_ptr<ClientContext> context) {
 	if (IsSystem()) {
 		catalog->Initialize(true);
 	} else {
 		catalog->Initialize(false);
 	}
 	if (storage) {
-		storage->Initialize();
+		storage->Initialize(context);
 	}
 }
 
@@ -126,6 +126,10 @@ Catalog &AttachedDatabase::ParentCatalog() {
 	return *parent_catalog;
 }
 
+const Catalog &AttachedDatabase::ParentCatalog() const {
+	return *parent_catalog;
+}
+
 bool AttachedDatabase::IsInitialDatabase() const {
 	return is_initial_database;
 }
@@ -134,6 +138,10 @@ void AttachedDatabase::SetInitialDatabase() {
 	is_initial_database = true;
 }
 
+void AttachedDatabase::SetReadOnlyDatabase() {
+	type = AttachedDatabaseType::READ_ONLY_DATABASE;
+}
+
 void AttachedDatabase::Close() {
 	D_ASSERT(catalog);
 	if (is_closed) {
@@ -162,7 +170,7 @@ void AttachedDatabase::Close() {
 			}
 			storage->CreateCheckpoint(true);
 		}
-	} catch (...) {
+	} catch (...) { // NOLINT
 	}
 }
 

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

@@ -27,8 +27,12 @@ duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema
 		return DuckDBSuccess;
 	}
 	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
-	ArrowConverter::ToArrowSchema((ArrowSchema *)*out_schema, wrapper->result->types, wrapper->result->names,
-	                              wrapper->result->client_properties);
+	try {
+		ArrowConverter::ToArrowSchema((ArrowSchema *)*out_schema, wrapper->result->types, wrapper->result->names,
+		                              wrapper->result->client_properties);
+	} catch (...) {
+		return DuckDBError;
+	}
 	return DuckDBSuccess;
 }
 

package/src/duckdb/src/main/capi/cast/utils-c.cpp

@@ -78,7 +78,7 @@ bool CanUseDeprecatedFetch(duckdb_result *result, idx_t col, idx_t row) {
 	if (!result) {
 		return false;
 	}
-	if (!duckdb::deprecated_materialize_result(result)) {
+	if (!duckdb::DeprecatedMaterializeResult(result)) {
 		return false;
 	}
 	if (col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {

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

@@ -99,7 +99,7 @@ void duckdb_disconnect(duckdb_connection *connection) {
 duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out) {
 	Connection *conn = reinterpret_cast<Connection *>(connection);
 	auto result = conn->Query(query);
-	return duckdb_translate_result(std::move(result), out);
+	return DuckDBTranslateResult(std::move(result), out);
 }
 
 const char *duckdb_library_version() {

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

@@ -162,5 +162,5 @@ duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb
 	}
 
 	wrapper->statement.reset();
-	return duckdb_translate_result(std::move(result), out_result);
+	return DuckDBTranslateResult(std::move(result), out_result);
 }

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

@@ -333,7 +333,7 @@ duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statemen
 	}
 
 	auto result = wrapper->statement->Execute(wrapper->values, false);
-	return duckdb_translate_result(std::move(result), out_result);
+	return DuckDBTranslateResult(std::move(result), out_result);
 }
 
 duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement,
@@ -344,7 +344,7 @@ duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepare
 	}
 
 	auto result = wrapper->statement->Execute(wrapper->values, true);
-	return duckdb_translate_result(std::move(result), out_result);
+	return DuckDBTranslateResult(std::move(result), out_result);
 }
 
 duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement) {

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

@@ -273,7 +273,7 @@ duckdb_state deprecated_duckdb_translate_column(MaterializedQueryResult &result,
 	return DuckDBSuccess;
 }
 
-duckdb_state duckdb_translate_result(unique_ptr<QueryResult> result_p, duckdb_result *out) {
+duckdb_state DuckDBTranslateResult(unique_ptr<QueryResult> result_p, duckdb_result *out) {
 	auto &result = *result_p;
 	D_ASSERT(result_p);
 	if (!out) {
@@ -301,7 +301,7 @@ duckdb_state duckdb_translate_result(unique_ptr<QueryResult> result_p, duckdb_re
 	return DuckDBSuccess;
 }
 
-bool deprecated_materialize_result(duckdb_result *result) {
+bool DeprecatedMaterializeResult(duckdb_result *result) {
 	if (!result) {
 		return false;
 	}
@@ -475,7 +475,7 @@ void *duckdb_column_data(duckdb_result *result, idx_t col) {
 	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	if (!duckdb::deprecated_materialize_result(result)) {
+	if (!duckdb::DeprecatedMaterializeResult(result)) {
 		return nullptr;
 	}
 	return result->__deprecated_columns[col].__deprecated_data;
@@ -485,7 +485,7 @@ bool *duckdb_nullmask_data(duckdb_result *result, idx_t col) {
 	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	if (!duckdb::deprecated_materialize_result(result)) {
+	if (!duckdb::DeprecatedMaterializeResult(result)) {
 		return nullptr;
 	}
 	return result->__deprecated_columns[col].__deprecated_nullmask;

package/src/duckdb/src/main/client_context.cpp

@@ -1235,7 +1235,7 @@ unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relat
 	return ErrorResult<MaterializedQueryResult>(ErrorData(err_str));
 }
 
-SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) {
+SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) const {
 	// first check the built-in settings
 	auto &db_config = DBConfig::GetConfig(*this);
 	auto option = db_config.GetOptionByName(key);
@@ -1270,17 +1270,9 @@ ParserOptions ClientContext::GetParserOptions() const {
 ClientProperties ClientContext::GetClientProperties() const {
 	string timezone = "UTC";
 	Value result;
-	// 1) Check Set Variable
-	auto &client_config = ClientConfig::GetConfig(*this);
-	auto tz_config = client_config.set_variables.find("timezone");
-	if (tz_config == client_config.set_variables.end()) {
-		// 2) Check for Default Value
-		auto default_value = db->config.extension_parameters.find("timezone");
-		if (default_value != db->config.extension_parameters.end()) {
-			timezone = default_value->second.default_value.GetValue<string>();
-		}
-	} else {
-		timezone = tz_config->second.GetValue<string>();
+
+	if (TryGetCurrentSetting("TimeZone", result)) {
+		timezone = result.ToString();
 	}
 	return {timezone, db->config.options.arrow_offset_size};
 }

package/src/duckdb/src/main/client_context_file_opener.cpp

@@ -14,21 +14,33 @@ SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &
 	return context.TryGetCurrentSetting(key, result);
 }
 
-ClientContext *FileOpener::TryGetClientContext(FileOpener *opener) {
+optional_ptr<DatabaseInstance> ClientContextFileOpener::TryGetDatabase() {
+	return context.db.get();
+}
+
+optional_ptr<ClientContext> FileOpener::TryGetClientContext(optional_ptr<FileOpener> opener) {
 	if (!opener) {
 		return nullptr;
 	}
 	return opener->TryGetClientContext();
 }
 
-SettingLookupResult FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result) {
+optional_ptr<DatabaseInstance> FileOpener::TryGetDatabase(optional_ptr<FileOpener> opener) {
+	if (!opener) {
+		return nullptr;
+	}
+	return opener->TryGetDatabase();
+}
+
+SettingLookupResult FileOpener::TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key,
+                                                     Value &result) {
 	if (!opener) {
 		return SettingLookupResult();
 	}
 	return opener->TryGetCurrentSetting(key, result);
 }
 
-SettingLookupResult FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result,
+SettingLookupResult FileOpener::TryGetCurrentSetting(optional_ptr<FileOpener> opener, const string &key, Value &result,
                                                      FileOpenerInfo &info) {
 	if (!opener) {
 		return SettingLookupResult();

package/src/duckdb/src/main/client_data.cpp

@@ -24,6 +24,7 @@ public:
 		auto &config = DBConfig::GetConfig(context);
 		return *config.file_system;
 	}
+
 	optional_ptr<FileOpener> GetOpener() const override {
 		return ClientData::Get(context).file_opener.get();
 	}
@@ -49,6 +50,10 @@ ClientData &ClientData::Get(ClientContext &context) {
 	return *context.client_data;
 }
 
+const ClientData &ClientData::Get(const ClientContext &context) {
+	return *context.client_data;
+}
+
 RandomEngine &RandomEngine::Get(ClientContext &context) {
 	return *ClientData::Get(context).random_engine;
 }