duckdb 0.8.1-dev65.0 → 0.8.1

package/src/duckdb/src/storage/compression/string_uncompressed.cpp

@@ -33,12 +33,12 @@ unique_ptr<AnalyzeState> UncompressedStringStorage::StringInitAnalyze(ColumnData
 }
 
 bool UncompressedStringStorage::StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (StringAnalyzeState &)state_p;
+	auto &state = state_p.Cast<StringAnalyzeState>();
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
 	state.count += count;
-	auto data = (string_t *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
 		if (vdata.validity.RowIsValid(idx)) {
@@ -53,7 +53,7 @@ bool UncompressedStringStorage::StringAnalyze(AnalyzeState &state_p, Vector &inp
 }
 
 idx_t UncompressedStringStorage::StringFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = (StringAnalyzeState &)state_p;
+	auto &state = state_p.Cast<StringAnalyzeState>();
 	return state.count * sizeof(int32_t) + state.total_string_size + state.overflow_strings * BIG_STRING_MARKER_SIZE;
 }
 
@@ -73,12 +73,12 @@ unique_ptr<SegmentScanState> UncompressedStringStorage::StringInitScan(ColumnSeg
 void UncompressedStringStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
                                                   Vector &result, idx_t result_offset) {
 	// clear any previously locked buffers and get the primary buffer handle
-	auto &scan_state = (StringScanState &)*state.scan_state;
+	auto &scan_state = state.scan_state->Cast<StringScanState>();
 	auto start = segment.GetRelativeIndex(state.row_index);
 
 	auto baseptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
 	auto dict = GetDictionary(segment, scan_state.handle);
-	auto base_data = (int32_t *)(baseptr + DICTIONARY_HEADER_SIZE);
+	auto base_data = reinterpret_cast<int32_t *>(baseptr + DICTIONARY_HEADER_SIZE);
 	auto result_data = FlatVector::GetData<string_t>(result);
 
 	int32_t previous_offset = start > 0 ? base_data[start - 1] : 0;
@@ -124,7 +124,7 @@ void UncompressedStringStorage::StringFetchRow(ColumnSegment &segment, ColumnFet
 
 	auto baseptr = handle.Ptr() + segment.GetBlockOffset();
 	auto dict = GetDictionary(segment, handle);
-	auto base_data = (int32_t *)(baseptr + DICTIONARY_HEADER_SIZE);
+	auto base_data = reinterpret_cast<int32_t *>(baseptr + DICTIONARY_HEADER_SIZE);
 	auto result_data = FlatVector::GetData<string_t>(result);
 
 	auto dict_offset = base_data[row_id];
@@ -223,7 +223,7 @@ idx_t UncompressedStringStorage::RemainingSpace(ColumnSegment &segment, BufferHa
 
 void UncompressedStringStorage::WriteString(ColumnSegment &segment, string_t string, block_id_t &result_block,
                                             int32_t &result_offset) {
-	auto &state = (UncompressedStringSegmentState &)*segment.GetSegmentState();
+	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
 	if (state.overflow_writer) {
 		// overflow writer is set: write string there
 		state.overflow_writer->WriteString(string, result_block, result_offset);
@@ -240,7 +240,7 @@ void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string
 	BufferHandle handle;
 
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
-	auto &state = (UncompressedStringSegmentState &)*segment.GetSegmentState();
+	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
 	// check if the string fits in the current block
 	if (!state.head || state.head->offset + total_length >= state.head->size) {
 		// string does not fit, allocate space for it
@@ -278,7 +278,7 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 
 	auto &block_manager = segment.GetBlockManager();
 	auto &buffer_manager = block_manager.buffer_manager;
-	auto &state = (UncompressedStringSegmentState &)*segment.GetSegmentState();
+	auto &state = segment.GetSegmentState()->Cast<UncompressedStringSegmentState>();
 	if (block < MAXIMUM_BLOCK) {
 		// read the overflow string from disk
 		// pin the initial handle and read the length
@@ -325,7 +325,7 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 		    buffer_manager.Allocate(MaxValue<idx_t>(Storage::BLOCK_SIZE, uncompressed_size));
 		auto decompressed_target_ptr = decompressed_target_handle.Ptr();
 		MiniZStream s;
-		s.Decompress((const char *)decompression_ptr, compressed_size, (char *)decompressed_target_ptr,
+		s.Decompress(const_char_ptr_cast(decompression_ptr), compressed_size, char_ptr_cast(decompressed_target_ptr),
 		             uncompressed_size);
 
 		auto final_buffer = decompressed_target_handle.Ptr();
@@ -345,14 +345,14 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 
 string_t UncompressedStringStorage::ReadString(data_ptr_t target, int32_t offset, uint32_t string_length) {
 	auto ptr = target + offset;
-	auto str_ptr = (char *)(ptr);
+	auto str_ptr = char_ptr_cast(ptr);
 	return string_t(str_ptr, string_length);
 }
 
 string_t UncompressedStringStorage::ReadStringWithLength(data_ptr_t target, int32_t offset) {
 	auto ptr = target + offset;
 	auto str_length = Load<uint32_t>(ptr);
-	auto str_ptr = (char *)(ptr + sizeof(uint32_t));
+	auto str_ptr = char_ptr_cast(ptr + sizeof(uint32_t));
 	return string_t(str_ptr, str_length);
 }
 
@@ -403,7 +403,7 @@ string_t UncompressedStringStorage::FetchString(ColumnSegment &segment, StringDi
 		auto dict_end = baseptr + dict.end;
 		auto dict_pos = dict_end - location.offset;
 
-		auto str_ptr = (char *)(dict_pos);
+		auto str_ptr = char_ptr_cast(dict_pos);
 		return string_t(str_ptr, string_length);
 	}
 }

package/src/duckdb/src/storage/compression/validity_uncompressed.cpp

@@ -188,13 +188,13 @@ unique_ptr<AnalyzeState> ValidityInitAnalyze(ColumnData &col_data, PhysicalType
 }
 
 bool ValidityAnalyze(AnalyzeState &state_p, Vector &input, idx_t count) {
-	auto &state = (ValidityAnalyzeState &)state_p;
+	auto &state = state_p.Cast<ValidityAnalyzeState>();
 	state.count += count;
 	return true;
 }
 
 idx_t ValidityFinalAnalyze(AnalyzeState &state_p) {
-	auto &state = (ValidityAnalyzeState &)state_p;
+	auto &state = state_p.Cast<ValidityAnalyzeState>();
 	return (state.count + 7) / 8;
 }
 
@@ -222,12 +222,12 @@ void ValidityScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t s
 	auto start = segment.GetRelativeIndex(state.row_index);
 
 	static_assert(sizeof(validity_t) == sizeof(uint64_t), "validity_t should be 64-bit");
-	auto &scan_state = (ValidityScanState &)*state.scan_state;
+	auto &scan_state = state.scan_state->Cast<ValidityScanState>();
 
 	auto &result_mask = FlatVector::Validity(result);
 	auto buffer_ptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
 	D_ASSERT(scan_state.block_id == segment.block->BlockId());
-	auto input_data = (validity_t *)buffer_ptr;
+	auto input_data = reinterpret_cast<validity_t *>(buffer_ptr);
 
 #ifdef DEBUG
 	// this method relies on all the bits we are going to write to being set to valid
@@ -345,7 +345,7 @@ void ValidityScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_cou
 
 	auto start = segment.GetRelativeIndex(state.row_index);
 	if (start % ValidityMask::BITS_PER_VALUE == 0) {
-		auto &scan_state = (ValidityScanState &)*state.scan_state;
+		auto &scan_state = state.scan_state->Cast<ValidityScanState>();
 
 		// aligned scan: no need to do anything fancy
 		// note: this is only an optimization which avoids having to do messy bitshifting in the common case
@@ -353,8 +353,8 @@ void ValidityScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_cou
 		auto &result_mask = FlatVector::Validity(result);
 		auto buffer_ptr = scan_state.handle.Ptr() + segment.GetBlockOffset();
 		D_ASSERT(scan_state.block_id == segment.block->BlockId());
-		auto input_data = (validity_t *)buffer_ptr;
-		auto result_data = (validity_t *)result_mask.GetData();
+		auto input_data = reinterpret_cast<validity_t *>(buffer_ptr);
+		auto result_data = result_mask.GetData();
 		idx_t start_offset = start / ValidityMask::BITS_PER_VALUE;
 		idx_t entry_scan_count = (scan_count + ValidityMask::BITS_PER_VALUE - 1) / ValidityMask::BITS_PER_VALUE;
 		for (idx_t i = 0; i < entry_scan_count; i++) {
@@ -364,7 +364,7 @@ void ValidityScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_cou
 			}
 			if (!result_data) {
 				result_mask.Initialize(MaxValue<idx_t>(STANDARD_VECTOR_SIZE, scan_count));
-				result_data = (validity_t *)result_mask.GetData();
+				result_data = result_mask.GetData();
 			}
 			result_data[i] = input_entry;
 		}
@@ -382,7 +382,7 @@ void ValidityFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row
 	auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
 	auto handle = buffer_manager.Pin(segment.block);
 	auto dataptr = handle.Ptr() + segment.GetBlockOffset();
-	ValidityMask mask((validity_t *)dataptr);
+	ValidityMask mask(reinterpret_cast<validity_t *>(dataptr));
 	auto &result_mask = FlatVector::Validity(result);
 	if (!mask.RowIsValidUnsafe(row_id)) {
 		result_mask.SetInvalid(result_idx);
@@ -421,7 +421,7 @@ idx_t ValidityAppend(CompressionAppendState &append_state, ColumnSegment &segmen
 		return append_count;
 	}
 
-	ValidityMask mask((validity_t *)append_state.handle.Ptr());
+	ValidityMask mask(reinterpret_cast<validity_t *>(append_state.handle.Ptr()));
 	for (idx_t i = 0; i < append_count; i++) {
 		auto idx = data.sel->get_index(offset + i);
 		if (!data.validity.RowIsValidUnsafe(idx)) {
@@ -450,7 +450,7 @@ void ValidityRevertAppend(ColumnSegment &segment, idx_t start_row) {
 		idx_t byte_pos = start_bit / 8;
 		idx_t bit_start = byte_pos * 8;
 		idx_t bit_end = (byte_pos + 1) * 8;
-		ValidityMask mask((validity_t *)handle.Ptr() + byte_pos);
+		ValidityMask mask(reinterpret_cast<validity_t *>(handle.Ptr() + byte_pos));
 		for (idx_t i = start_bit; i < bit_end; i++) {
 			mask.SetValid(i - bit_start);
 		}

package/src/duckdb/src/storage/data_table.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/checkpoint/table_data_writer.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 #include "duckdb/storage/table/persistent_table_data.hpp"
 #include "duckdb/storage/table/row_group.hpp"
 #include "duckdb/storage/table/standard_column_data.hpp"
@@ -302,7 +303,7 @@ static void VerifyCheckConstraint(ClientContext &context, TableCatalogEntry &tab
 	UnifiedVectorFormat vdata;
 	result.ToUnifiedFormat(chunk.size(), vdata);
 
-	auto dataptr = (int32_t *)vdata.data;
+	auto dataptr = UnifiedVectorFormat::GetData<int32_t>(vdata);
 	for (idx_t i = 0; i < chunk.size(); i++) {
 		auto idx = vdata.sel->get_index(i);
 		if (vdata.validity.RowIsValid(idx) && dataptr[idx] == 0) {
@@ -834,7 +835,7 @@ void DataTable::RevertAppend(idx_t start_row, idx_t count) {
 	if (!info->indexes.Empty()) {
 		idx_t current_row_base = start_row;
 		row_t row_data[STANDARD_VECTOR_SIZE];
-		Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_data);
+		Vector row_identifiers(LogicalType::ROW_TYPE, data_ptr_cast(row_data));
 		ScanTableSegment(start_row, count, [&](DataChunk &chunk) {
 			for (idx_t i = 0; i < chunk.size(); i++) {
 				row_data[i] = current_row_base + i;
@@ -1201,13 +1202,14 @@ void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
 	// intermediate holds scanned chunks of the underlying data to create the index
 	DataChunk intermediate;
 	vector<LogicalType> intermediate_types;
-	auto column_ids = index->column_ids;
-	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-	for (auto &id : index->column_ids) {
-		auto &col = column_definitions[id];
-		intermediate_types.push_back(col.Type());
+	vector<column_t> column_ids;
+	for (auto &it : column_definitions) {
+		intermediate_types.push_back(it.Type());
+		column_ids.push_back(it.Oid());
 	}
+	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 	intermediate_types.emplace_back(LogicalType::ROW_TYPE);
+
 	intermediate.Initialize(allocator, intermediate_types);
 
 	// holds the result of executing the index expression on the intermediate chunks
@@ -1299,10 +1301,10 @@ void DataTable::CommitDropTable() {
 }
 
 //===--------------------------------------------------------------------===//
-// GetStorageInfo
+// GetColumnSegmentInfo
 //===--------------------------------------------------------------------===//
-void DataTable::GetStorageInfo(TableStorageInfo &result) {
-	row_groups->GetStorageInfo(result);
+vector<ColumnSegmentInfo> DataTable::GetColumnSegmentInfo() {
+	return row_groups->GetColumnSegmentInfo();
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/index.cpp

@@ -59,6 +59,19 @@ bool Index::MergeIndexes(Index &other_index) {
 	}
 }
 
+string Index::VerifyAndToString(const bool only_verify) {
+
+	IndexLock state;
+	InitializeLock(state);
+
+	switch (this->type) {
+	case IndexType::ART:
+		return Cast<ART>().VerifyAndToString(state, only_verify);
+	default:
+		throw InternalException("Unimplemented index type for VerifyAndToString");
+	}
+}
+
 void Index::Vacuum() {
 
 	IndexLock state;

package/src/duckdb/src/storage/single_file_block_manager.cpp

@@ -19,7 +19,7 @@ namespace duckdb {
 const char MainHeader::MAGIC_BYTES[] = "DUCK";
 
 void MainHeader::Serialize(Serializer &ser) {
-	ser.WriteData((data_ptr_t)MAGIC_BYTES, MAGIC_BYTE_SIZE);
+	ser.WriteData(const_data_ptr_cast(MAGIC_BYTES), MAGIC_BYTE_SIZE);
 	ser.Write<uint64_t>(version_number);
 	FieldWriter writer(ser);
 	for (idx_t i = 0; i < FLAG_COUNT; i++) {
@@ -170,7 +170,7 @@ void SingleFileBlockManager::CreateNewDatabase() {
 	h2.free_list = INVALID_BLOCK;
 	h2.block_count = 0;
 	SerializeHeaderStructure<DatabaseHeader>(h2, header_buffer.buffer);
-	ChecksumAndWrite(header_buffer, Storage::FILE_HEADER_SIZE * 2);
+	ChecksumAndWrite(header_buffer, Storage::FILE_HEADER_SIZE * 2ULL);
 	// ensure that writing to disk is completed before returning
 	handle->Sync();
 	// we start with h2 as active_header, this way our initial write will be in h1
@@ -197,7 +197,7 @@ void SingleFileBlockManager::LoadExistingDatabase() {
 	DatabaseHeader h1, h2;
 	ReadAndChecksum(header_buffer, Storage::FILE_HEADER_SIZE);
 	h1 = DeserializeHeaderStructure<DatabaseHeader>(header_buffer.buffer);
-	ReadAndChecksum(header_buffer, Storage::FILE_HEADER_SIZE * 2);
+	ReadAndChecksum(header_buffer, Storage::FILE_HEADER_SIZE * 2ULL);
 	h2 = DeserializeHeaderStructure<DatabaseHeader>(header_buffer.buffer);
 	// check the header with the highest iteration count
 	if (h1.iteration > h2.iteration) {

package/src/duckdb/src/storage/standard_buffer_manager.cpp

@@ -751,7 +751,7 @@ void StandardBufferManager::FreeReservedMemory(idx_t size) {
 // Buffer Allocator
 //===--------------------------------------------------------------------===//
 data_ptr_t StandardBufferManager::BufferAllocatorAllocate(PrivateAllocatorData *private_data, idx_t size) {
-	auto &data = (BufferAllocatorData &)*private_data;
+	auto &data = private_data->Cast<BufferAllocatorData>();
 	auto reservation = data.manager.EvictBlocksOrThrow(size, nullptr, "failed to allocate data of size %s%s",
 	                                                   StringUtil::BytesToHumanReadableString(size));
 	// We rely on manual tracking of this one. :(
@@ -760,7 +760,7 @@ data_ptr_t StandardBufferManager::BufferAllocatorAllocate(PrivateAllocatorData *
 }
 
 void StandardBufferManager::BufferAllocatorFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
-	auto &data = (BufferAllocatorData &)*private_data;
+	auto &data = private_data->Cast<BufferAllocatorData>();
 	BufferPoolReservation r(data.manager.GetBufferPool());
 	r.size = size;
 	r.Resize(0);
@@ -772,7 +772,7 @@ data_ptr_t StandardBufferManager::BufferAllocatorRealloc(PrivateAllocatorData *p
 	if (old_size == size) {
 		return pointer;
 	}
-	auto &data = (BufferAllocatorData &)*private_data;
+	auto &data = private_data->Cast<BufferAllocatorData>();
 	BufferPoolReservation r(data.manager.GetBufferPool());
 	r.size = old_size;
 	r.Resize(size);

package/src/duckdb/src/storage/statistics/list_stats.cpp

@@ -90,7 +90,7 @@ void ListStats::Verify(const BaseStatistics &stats, Vector &vector, const Select
 	UnifiedVectorFormat vdata;
 	vector.ToUnifiedFormat(count, vdata);
 
-	auto list_data = (list_entry_t *)vdata.data;
+	auto list_data = UnifiedVectorFormat::GetData<list_entry_t>(vdata);
 	idx_t total_list_count = 0;
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);

package/src/duckdb/src/storage/statistics/numeric_stats.cpp

@@ -525,7 +525,7 @@ void NumericStats::TemplatedVerify(const BaseStatistics &stats, Vector &vector,
 	UnifiedVectorFormat vdata;
 	vector.ToUnifiedFormat(count, vdata);
 
-	auto data = (T *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<T>(vdata);
 	auto min_value = NumericStats::MinOrNull(stats);
 	auto max_value = NumericStats::MaxOrNull(stats);
 	for (idx_t i = 0; i < count; i++) {

package/src/duckdb/src/storage/statistics/string_stats.cpp

@@ -116,7 +116,7 @@ static void ConstructValue(const_data_ptr_t data, idx_t size, data_t target[]) {
 }
 
 void StringStats::Update(BaseStatistics &stats, const string_t &value) {
-	auto data = (const_data_ptr_t)value.GetData();
+	auto data = const_data_ptr_cast(value.GetData());
 	auto size = value.GetSize();
 
 	//! we can only fit 8 bytes, so we might need to trim our string
@@ -136,12 +136,12 @@ void StringStats::Update(BaseStatistics &stats, const string_t &value) {
 		string_data.max_string_length = size;
 	}
 	if (stats.GetType().id() == LogicalTypeId::VARCHAR && !string_data.has_unicode) {
-		auto unicode = Utf8Proc::Analyze((const char *)data, size);
+		auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(data), size);
 		if (unicode == UnicodeType::UNICODE) {
 			string_data.has_unicode = true;
 		} else if (unicode == UnicodeType::INVALID) {
-			throw InvalidInputException(
-			    ErrorManager::InvalidUnicodeError(string((char *)data, size), "segment statistics update"));
+			throw InvalidInputException(ErrorManager::InvalidUnicodeError(string(const_char_ptr_cast(data), size),
+			                                                              "segment statistics update"));
 		}
 	}
 }
@@ -166,7 +166,7 @@ void StringStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
 FilterPropagateResult StringStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
                                                 const string &constant) {
 	auto &string_data = StringStats::GetDataUnsafe(stats);
-	auto data = (const_data_ptr_t)constant.c_str();
+	auto data = const_data_ptr_cast(constant.c_str());
 	auto size = constant.size();
 
 	idx_t value_size = size > StringStatsData::MAX_STRING_MINMAX_SIZE ? StringStatsData::MAX_STRING_MINMAX_SIZE : size;
@@ -219,10 +219,11 @@ string StringStats::ToString(const BaseStatistics &stats) {
 	auto &string_data = StringStats::GetDataUnsafe(stats);
 	idx_t min_len = GetValidMinMaxSubstring(string_data.min);
 	idx_t max_len = GetValidMinMaxSubstring(string_data.max);
-	return StringUtil::Format(
-	    "[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %s]", string((const char *)string_data.min, min_len),
-	    string((const char *)string_data.max, max_len), string_data.has_unicode ? "true" : "false",
-	    string_data.has_max_string_length ? to_string(string_data.max_string_length) : "?");
+	return StringUtil::Format("[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %s]",
+	                          string(const_char_ptr_cast(string_data.min), min_len),
+	                          string(const_char_ptr_cast(string_data.max), max_len),
+	                          string_data.has_unicode ? "true" : "false",
+	                          string_data.has_max_string_length ? to_string(string_data.max_string_length) : "?");
 }
 
 void StringStats::Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count) {
@@ -230,7 +231,7 @@ void StringStats::Verify(const BaseStatistics &stats, Vector &vector, const Sele
 
 	UnifiedVectorFormat vdata;
 	vector.ToUnifiedFormat(count, vdata);
-	auto data = (string_t *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<string_t>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);
 		auto index = vdata.sel->get_index(idx);
@@ -256,13 +257,13 @@ void StringStats::Verify(const BaseStatistics &stats, Vector &vector, const Sele
 				throw InternalException("Invalid unicode detected in vector: %s", vector.ToString(count));
 			}
 		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE),
-		                          string_data.min) < 0) {
+		if (StringValueComparison(const_data_ptr_cast(data),
+		                          MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE), string_data.min) < 0) {
 			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
 			                        stats.ToString(), vector.ToString(count));
 		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE),
-		                          string_data.max) > 0) {
+		if (StringValueComparison(const_data_ptr_cast(data),
+		                          MinValue<idx_t>(len, StringStatsData::MAX_STRING_MINMAX_SIZE), string_data.max) > 0) {
 			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
 			                        stats.ToString(), vector.ToString(count));
 		}

package/src/duckdb/src/storage/storage_manager.cpp

@@ -12,6 +12,7 @@
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/common/serializer/buffered_file_reader.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -98,6 +99,11 @@ void SingleFileStorageManager::LoadDatabase() {
 	auto &fs = FileSystem::Get(db);
 	auto &config = DBConfig::Get(db);
 	bool truncate_wal = false;
+	if (!config.options.enable_external_access) {
+		if (!db.IsInitialDatabase()) {
+			throw PermissionException("Attaching on-disk databases is disabled through configuration");
+		}
+	}
 
 	StorageManagerOptions options;
 	options.read_only = read_only;

package/src/duckdb/src/storage/table/chunk_info.cpp

@@ -241,7 +241,7 @@ void ChunkVectorInfo::Serialize(Serializer &serializer) {
 	for (idx_t i = 0; i < count; i++) {
 		deleted_tuples[sel.get_index(i)] = false;
 	}
-	serializer.WriteData((data_ptr_t)deleted_tuples, sizeof(bool) * STANDARD_VECTOR_SIZE);
+	serializer.WriteData(data_ptr_cast(deleted_tuples), sizeof(bool) * STANDARD_VECTOR_SIZE);
 }
 
 unique_ptr<ChunkInfo> ChunkVectorInfo::Deserialize(Deserializer &source) {
@@ -250,7 +250,7 @@ unique_ptr<ChunkInfo> ChunkVectorInfo::Deserialize(Deserializer &source) {
 	auto result = make_uniq<ChunkVectorInfo>(start);
 	result->any_deleted = true;
 	bool deleted_tuples[STANDARD_VECTOR_SIZE];
-	source.ReadData((data_ptr_t)deleted_tuples, sizeof(bool) * STANDARD_VECTOR_SIZE);
+	source.ReadData(data_ptr_cast(deleted_tuples), sizeof(bool) * STANDARD_VECTOR_SIZE);
 	for (idx_t i = 0; i < STANDARD_VECTOR_SIZE; i++) {
 		if (deleted_tuples[i]) {
 			result->deleted[i] = 0;

package/src/duckdb/src/storage/table/column_data.cpp

@@ -488,7 +488,8 @@ shared_ptr<ColumnData> ColumnData::Deserialize(BlockManager &block_manager, Data
 	return entry;
 }
 
-void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
+void ColumnData::GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path,
+                                      vector<ColumnSegmentInfo> &result) {
 	D_ASSERT(!col_path.empty());
 
 	// convert the column path to a string
@@ -515,7 +516,10 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		column_info.segment_count = segment->count;
 		column_info.compression_type = CompressionTypeToString(segment->function.get().type);
 		column_info.segment_stats = segment->stats.statistics.ToString();
-		column_info.has_updates = updates ? true : false;
+		{
+			lock_guard<mutex> ulock(update_lock);
+			column_info.has_updates = updates ? true : false;
+		}
 		// persistent
 		// block_id
 		// block_offset
@@ -526,7 +530,7 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		} else {
 			column_info.persistent = false;
 		}
-		result.column_segments.push_back(std::move(column_info));
+		result.emplace_back(column_info);
 
 		segment_idx++;
 		segment = (ColumnSegment *)data.GetNextSegment(segment);

package/src/duckdb/src/storage/table/column_segment.cpp

@@ -331,7 +331,7 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		// similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them)
 		idx_t count_total = 0;
 		SelectionVector result_sel(approved_tuple_count);
-		auto &conjunction_or = (const ConjunctionOrFilter &)filter;
+		auto &conjunction_or = filter.Cast<ConjunctionOrFilter>();
 		for (auto &child_filter : conjunction_or.child_filters) {
 			SelectionVector temp_sel;
 			temp_sel.Initialize(sel);
@@ -357,14 +357,14 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		return approved_tuple_count;
 	}
 	case TableFilterType::CONJUNCTION_AND: {
-		auto &conjunction_and = (const ConjunctionAndFilter &)filter;
+		auto &conjunction_and = filter.Cast<ConjunctionAndFilter>();
 		for (auto &child_filter : conjunction_and.child_filters) {
 			FilterSelection(sel, result, *child_filter, approved_tuple_count, mask);
 		}
 		return approved_tuple_count;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
-		auto &constant_filter = (const ConstantFilter &)filter;
+		auto &constant_filter = filter.Cast<ConstantFilter>();
 		// the inplace loops take the result as the last parameter
 		switch (result.GetType().InternalType()) {
 		case PhysicalType::UINT8: {

package/src/duckdb/src/storage/table/list_column_data.cpp

@@ -167,7 +167,7 @@ void ListColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vec
 	auto &list_validity = list_data.validity;
 
 	// construct the list_entry_t entries to append to the column data
-	auto input_offsets = (list_entry_t *)list_data.data;
+	auto input_offsets = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
 	auto start_offset = child_column->GetMaxEntry();
 	idx_t child_count = 0;
 
@@ -210,7 +210,7 @@ void ListColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vec
 
 	UnifiedVectorFormat vdata;
 	vdata.sel = FlatVector::IncrementalSelectionVector();
-	vdata.data = (data_ptr_t)append_offsets.get();
+	vdata.data = data_ptr_cast(append_offsets.get());
 
 	// append the list offsets
 	ColumnData::AppendData(stats, state, vdata, count);
@@ -337,7 +337,7 @@ unique_ptr<ColumnCheckpointState> ListColumnData::Checkpoint(RowGroup &row_group
 	auto base_state = ColumnData::Checkpoint(row_group, partial_block_manager, checkpoint_info);
 	auto child_state = child_column->Checkpoint(row_group, partial_block_manager, checkpoint_info);
 
-	auto &checkpoint_state = (ListColumnCheckpointState &)*base_state;
+	auto &checkpoint_state = base_state->Cast<ListColumnCheckpointState>();
 	checkpoint_state.validity_state = std::move(validity_state);
 	checkpoint_state.child_state = std::move(child_state);
 	return base_state;
@@ -349,12 +349,13 @@ void ListColumnData::DeserializeColumn(Deserializer &source) {
 	child_column->DeserializeColumn(source);
 }
 
-void ListColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
-	ColumnData::GetStorageInfo(row_group_index, col_path, result);
+void ListColumnData::GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
+                                          vector<duckdb::ColumnSegmentInfo> &result) {
+	ColumnData::GetColumnSegmentInfo(row_group_index, col_path, result);
 	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, col_path, result);
+	validity.GetColumnSegmentInfo(row_group_index, col_path, result);
 	col_path.back() = 1;
-	child_column->GetStorageInfo(row_group_index, col_path, result);
+	child_column->GetColumnSegmentInfo(row_group_index, col_path, result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/table/row_group.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/storage/table/column_data.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
 #include "duckdb/storage/table/update_segment.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 #include "duckdb/common/chrono.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -502,7 +503,7 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s
 					if (column == COLUMN_IDENTIFIER_ROW_ID) {
 						D_ASSERT(result.data[i].GetType().InternalType() == PhysicalType::INT64);
 						result.data[i].SetVectorType(VectorType::FLAT_VECTOR);
-						auto result_data = (int64_t *)FlatVector::GetData(result.data[i]);
+						auto result_data = FlatVector::GetData<int64_t>(result.data[i]);
 						for (size_t sel_idx = 0; sel_idx < approved_tuple_count; sel_idx++) {
 							result_data[sel_idx] = this->start + current_row + sel.get_index(sel_idx);
 						}
@@ -650,7 +651,7 @@ void RowGroup::AppendVersionInfo(TransactionData transaction, idx_t count) {
 			} else {
 				D_ASSERT(version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
 				// use existing vector
-				info = (ChunkVectorInfo *)version_info->info[vector_idx].get();
+				info = &version_info->info[vector_idx]->Cast<ChunkVectorInfo>();
 			}
 			info->Append(start, end, transaction.transaction_id);
 		}
@@ -912,12 +913,12 @@ RowGroupPointer RowGroup::Deserialize(Deserializer &main_source, const vector<Lo
 }
 
 //===--------------------------------------------------------------------===//
-// GetStorageInfo
+// GetColumnSegmentInfo
 //===--------------------------------------------------------------------===//
-void RowGroup::GetStorageInfo(idx_t row_group_index, TableStorageInfo &result) {
+void RowGroup::GetColumnSegmentInfo(idx_t row_group_index, vector<ColumnSegmentInfo> &result) {
 	for (idx_t col_idx = 0; col_idx < GetColumnCount(); col_idx++) {
 		auto &col_data = GetColumn(col_idx);
-		col_data.GetStorageInfo(row_group_index, {col_idx}, result);
+		col_data.GetColumnSegmentInfo(row_group_index, {col_idx}, result);
 	}
 }
 
@@ -985,7 +986,7 @@ void VersionDeleteState::Delete(row_t row_id) {
 			info.version_info->info[vector_idx] =
 			    make_uniq<ChunkVectorInfo>(info.start + vector_idx * STANDARD_VECTOR_SIZE);
 		} else if (info.version_info->info[vector_idx]->type == ChunkInfoType::CONSTANT_INFO) {
-			auto &constant = (ChunkConstantInfo &)*info.version_info->info[vector_idx];
+			auto &constant = info.version_info->info[vector_idx]->Cast<ChunkConstantInfo>();
 			// info exists but it's a constant info: convert to a vector info
 			auto new_info = make_uniq<ChunkVectorInfo>(info.start + vector_idx * STANDARD_VECTOR_SIZE);
 			new_info->insert_id = constant.insert_id.load();
@@ -995,7 +996,7 @@ void VersionDeleteState::Delete(row_t row_id) {
 			info.version_info->info[vector_idx] = std::move(new_info);
 		}
 		D_ASSERT(info.version_info->info[vector_idx]->type == ChunkInfoType::VECTOR_INFO);
-		current_info = (ChunkVectorInfo *)info.version_info->info[vector_idx].get();
+		current_info = &info.version_info->info[vector_idx]->Cast<ChunkVectorInfo>();
 		current_chunk = vector_idx;
 		chunk_row = vector_idx * STANDARD_VECTOR_SIZE;
 	}