duckdb 0.8.1-dev51.0 → 0.8.1-dev96.0

package/src/duckdb/extension/parquet/column_writer.cpp

@@ -193,8 +193,8 @@ void ColumnWriter::CompressPage(BufferedSerializer &temp_writer, size_t &compres
 	case CompressionCodec::SNAPPY: {
 		compressed_size = duckdb_snappy::MaxCompressedLength(temp_writer.blob.size);
 		compressed_buf = duckdb::unique_ptr<data_t[]>(new data_t[compressed_size]);
-		duckdb_snappy::RawCompress((const char *)temp_writer.blob.data.get(), temp_writer.blob.size,
-		                           (char *)compressed_buf.get(), &compressed_size);
+		duckdb_snappy::RawCompress(const_char_ptr_cast(temp_writer.blob.data.get()), temp_writer.blob.size,
+		                           char_ptr_cast(compressed_buf.get()), &compressed_size);
 		compressed_data = compressed_buf.get();
 		D_ASSERT(compressed_size <= duckdb_snappy::MaxCompressedLength(temp_writer.blob.size));
 		break;
@@ -203,8 +203,8 @@ void ColumnWriter::CompressPage(BufferedSerializer &temp_writer, size_t &compres
 		MiniZStream s;
 		compressed_size = s.MaxCompressedLength(temp_writer.blob.size);
 		compressed_buf = duckdb::unique_ptr<data_t[]>(new data_t[compressed_size]);
-		s.Compress((const char *)temp_writer.blob.data.get(), temp_writer.blob.size, (char *)compressed_buf.get(),
-		           &compressed_size);
+		s.Compress(const_char_ptr_cast(temp_writer.blob.data.get()), temp_writer.blob.size,
+		           char_ptr_cast(compressed_buf.get()), &compressed_size);
 		compressed_data = compressed_buf.get();
 		break;
 	}
@@ -280,6 +280,18 @@ class ColumnWriterPageState {
 public:
 	virtual ~ColumnWriterPageState() {
 	}
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 struct PageInformation {
@@ -412,7 +424,7 @@ void BasicColumnWriter::FlushPageState(Serializer &temp_writer, ColumnWriterPage
 }
 
 void BasicColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = (BasicColumnWriterState &)state_p;
+	auto &state = state_p.Cast<BasicColumnWriterState>();
 	auto &col_chunk = state.row_group.columns[state.col_idx];
 
 	idx_t start = 0;
@@ -448,7 +460,7 @@ duckdb_parquet::format::Encoding::type BasicColumnWriter::GetEncoding(BasicColum
 }
 
 void BasicColumnWriter::BeginWrite(ColumnWriterState &state_p) {
-	auto &state = (BasicColumnWriterState &)state_p;
+	auto &state = state_p.Cast<BasicColumnWriterState>();
 
 	// set up the page write info
 	state.stats_state = InitializeStatsState();
@@ -576,7 +588,7 @@ idx_t BasicColumnWriter::GetRowSize(Vector &vector, idx_t index, BasicColumnWrit
 }
 
 void BasicColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {
-	auto &state = (BasicColumnWriterState &)state_p;
+	auto &state = state_p.Cast<BasicColumnWriterState>();
 
 	idx_t remaining = count;
 	idx_t offset = 0;
@@ -640,7 +652,7 @@ void BasicColumnWriter::SetParquetStatistics(BasicColumnWriterState &state,
 }
 
 void BasicColumnWriter::FinalizeWrite(ColumnWriterState &state_p) {
-	auto &state = (BasicColumnWriterState &)state_p;
+	auto &state = state_p.Cast<BasicColumnWriterState>();
 	auto &column_chunk = state.row_group.columns[state.col_idx];
 
 	// flush the last page (if any remains)
@@ -863,10 +875,10 @@ public:
 		return GetMaxValue();
 	}
 	string GetMinValue() override {
-		return HasStats() ? string((char *)&min, sizeof(bool)) : string();
+		return HasStats() ? string(const_char_ptr_cast(&min), sizeof(bool)) : string();
 	}
 	string GetMaxValue() override {
-		return HasStats() ? string((char *)&max, sizeof(bool)) : string();
+		return HasStats() ? string(const_char_ptr_cast(&max), sizeof(bool)) : string();
 	}
 };
 
@@ -891,8 +903,8 @@ public:
 
 	void WriteVector(Serializer &temp_writer, ColumnWriterStatistics *stats_p, ColumnWriterPageState *state_p,
 	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
-		auto &stats = (BooleanStatisticsState &)*stats_p;
-		auto &state = (BooleanWriterPageState &)*state_p;
+		auto &stats = stats_p->Cast<BooleanStatisticsState>();
+		auto &state = state_p->Cast<BooleanWriterPageState>();
 		auto &mask = FlatVector::Validity(input_column);
 
 		auto *ptr = FlatVector::GetData<bool>(input_column);
@@ -921,7 +933,7 @@ public:
 	}
 
 	void FlushPageState(Serializer &temp_writer, ColumnWriterPageState *state_p) override {
-		auto &state = (BooleanWriterPageState &)*state_p;
+		auto &state = state_p->Cast<BooleanWriterPageState>();
 		if (state.byte_pos > 0) {
 			temp_writer.Write<uint8_t>(state.byte);
 			state.byte = 0;
@@ -971,7 +983,7 @@ public:
 	string GetStats(hugeint_t &input) {
 		data_t buffer[16];
 		WriteParquetDecimal(input, buffer);
-		return string((char *)buffer, 16);
+		return string(const_char_ptr_cast(buffer), 16);
 	}
 
 	bool HasStats() {
@@ -1018,7 +1030,7 @@ public:
 	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
 		auto &mask = FlatVector::Validity(input_column);
 		auto *ptr = FlatVector::GetData<hugeint_t>(input_column);
-		auto &stats = (FixedDecimalStatistics &)*stats_p;
+		auto &stats = stats_p->Cast<FixedDecimalStatistics>();
 
 		data_t temp_buffer[16];
 		for (idx_t r = chunk_start; r < chunk_end; r++) {
@@ -1247,7 +1259,7 @@ public:
 	}
 
 	void Analyze(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) override {
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &state = state_p.Cast<StringColumnWriterState>();
 
 		idx_t vcount = parent ? parent->definition_levels.size() - state.definition_levels.size() : count;
 		idx_t parent_index = state.definition_levels.size();
@@ -1295,7 +1307,7 @@ public:
 	}
 
 	void FinalizeAnalyze(ColumnWriterState &state_p) override {
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &state = state_p.Cast<StringColumnWriterState>();
 
 		// check if a dictionary will require more space than a plain write, or if the dictionary page is going to
 		// be too large
@@ -1311,9 +1323,9 @@ public:
 
 	void WriteVector(Serializer &temp_writer, ColumnWriterStatistics *stats_p, ColumnWriterPageState *page_state_p,
 	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
-		auto &page_state = (StringWriterPageState &)*page_state_p;
+		auto &page_state = page_state_p->Cast<StringWriterPageState>();
 		auto &mask = FlatVector::Validity(input_column);
-		auto &stats = (StringStatisticsState &)*stats_p;
+		auto &stats = stats_p->Cast<StringStatisticsState>();
 
 		auto *ptr = FlatVector::GetData<string_t>(input_column);
 		if (page_state.IsDictionaryEncoded()) {
@@ -1342,18 +1354,18 @@ public:
 				}
 				stats.Update(ptr[r]);
 				temp_writer.Write<uint32_t>(ptr[r].GetSize());
-				temp_writer.WriteData((const_data_ptr_t)ptr[r].GetData(), ptr[r].GetSize());
+				temp_writer.WriteData(const_data_ptr_cast(ptr[r].GetData()), ptr[r].GetSize());
 			}
 		}
 	}
 
 	duckdb::unique_ptr<ColumnWriterPageState> InitializePageState(BasicColumnWriterState &state_p) override {
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &state = state_p.Cast<StringColumnWriterState>();
 		return make_uniq<StringWriterPageState>(state.key_bit_width, state.dictionary);
 	}
 
 	void FlushPageState(Serializer &temp_writer, ColumnWriterPageState *state_p) override {
-		auto &page_state = (StringWriterPageState &)*state_p;
+		auto &page_state = state_p->Cast<StringWriterPageState>();
 		if (page_state.bit_width != 0) {
 			if (!page_state.written_value) {
 				// all values are null
@@ -1366,24 +1378,24 @@ public:
 	}
 
 	duckdb_parquet::format::Encoding::type GetEncoding(BasicColumnWriterState &state_p) override {
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &state = state_p.Cast<StringColumnWriterState>();
 		return state.IsDictionaryEncoded() ? Encoding::RLE_DICTIONARY : Encoding::PLAIN;
 	}
 
 	bool HasDictionary(BasicColumnWriterState &state_p) override {
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &state = state_p.Cast<StringColumnWriterState>();
 		return state.IsDictionaryEncoded();
 	}
 
 	idx_t DictionarySize(BasicColumnWriterState &state_p) override {
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &state = state_p.Cast<StringColumnWriterState>();
 		D_ASSERT(state.IsDictionaryEncoded());
 		return state.dictionary.size();
 	}
 
 	void FlushDictionary(BasicColumnWriterState &state_p, ColumnWriterStatistics *stats_p) override {
-		auto &stats = (StringStatisticsState &)*stats_p;
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &stats = stats_p->Cast<StringStatisticsState>();
+		auto &state = state_p.Cast<StringColumnWriterState>();
 		if (!state.IsDictionaryEncoded()) {
 			return;
 		}
@@ -1401,14 +1413,14 @@ public:
 			stats.Update(value);
 			// write this string value to the dictionary
 			temp_writer->Write<uint32_t>(value.GetSize());
-			temp_writer->WriteData((const_data_ptr_t)(value.GetData()), value.GetSize());
+			temp_writer->WriteData(const_data_ptr_cast((value.GetData())), value.GetSize());
 		}
 		// flush the dictionary page and add it to the to-be-written pages
 		WriteDictionary(state, std::move(temp_writer), values.size());
 	}
 
 	idx_t GetRowSize(Vector &vector, idx_t index, BasicColumnWriterState &state_p) override {
-		auto &state = (StringColumnWriterState &)state_p;
+		auto &state = state_p.Cast<StringColumnWriterState>();
 		if (state.IsDictionaryEncoded()) {
 			return (state.key_bit_width + 7) / 8;
 		} else {
@@ -1471,7 +1483,7 @@ public:
 
 	void WriteVector(Serializer &temp_writer, ColumnWriterStatistics *stats_p, ColumnWriterPageState *page_state_p,
 	                 Vector &input_column, idx_t chunk_start, idx_t chunk_end) override {
-		auto &page_state = (EnumWriterPageState &)*page_state_p;
+		auto &page_state = page_state_p->Cast<EnumWriterPageState>();
 		switch (enum_type.InternalType()) {
 		case PhysicalType::UINT8:
 			WriteEnumInternal<uint8_t>(temp_writer, input_column, chunk_start, chunk_end, page_state);
@@ -1492,7 +1504,7 @@ public:
 	}
 
 	void FlushPageState(Serializer &temp_writer, ColumnWriterPageState *state_p) override {
-		auto &page_state = (EnumWriterPageState &)*state_p;
+		auto &page_state = state_p->Cast<EnumWriterPageState>();
 		if (!page_state.written_value) {
 			// all values are null
 			// just write the bit width
@@ -1515,7 +1527,7 @@ public:
 	}
 
 	void FlushDictionary(BasicColumnWriterState &state, ColumnWriterStatistics *stats_p) override {
-		auto &stats = (StringStatisticsState &)*stats_p;
+		auto &stats = stats_p->Cast<StringStatisticsState>();
 		// write the enum values to a dictionary page
 		auto &enum_values = EnumType::GetValuesInsertOrder(enum_type);
 		auto enum_count = EnumType::GetSize(enum_type);
@@ -1528,7 +1540,7 @@ public:
 			stats.Update(string_values[r]);
 			// write this string value to the dictionary
 			temp_writer->Write<uint32_t>(string_values[r].GetSize());
-			temp_writer->WriteData((const_data_ptr_t)string_values[r].GetData(), string_values[r].GetSize());
+			temp_writer->WriteData(const_data_ptr_cast(string_values[r].GetData()), string_values[r].GetSize());
 		}
 		// flush the dictionary page and add it to the to-be-written pages
 		WriteDictionary(state, std::move(temp_writer), enum_count);
@@ -1599,7 +1611,7 @@ bool StructColumnWriter::HasAnalyze() {
 }
 
 void StructColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = (StructColumnWriterState &)state_p;
+	auto &state = state_p.Cast<StructColumnWriterState>();
 	auto &child_vectors = StructVector::GetEntries(vector);
 	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
 		// Need to check again. It might be that just one child needs it but the rest not
@@ -1611,7 +1623,7 @@ void StructColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *
 }
 
 void StructColumnWriter::FinalizeAnalyze(ColumnWriterState &state_p) {
-	auto &state = (StructColumnWriterState &)state_p;
+	auto &state = state_p.Cast<StructColumnWriterState>();
 	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
 		// Need to check again. It might be that just one child needs it but the rest not
 		if (child_writers[child_idx]->HasAnalyze()) {
@@ -1621,7 +1633,7 @@ void StructColumnWriter::FinalizeAnalyze(ColumnWriterState &state_p) {
 }
 
 void StructColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = (StructColumnWriterState &)state_p;
+	auto &state = state_p.Cast<StructColumnWriterState>();
 
 	auto &validity = FlatVector::Validity(vector);
 	if (parent) {
@@ -1639,14 +1651,14 @@ void StructColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *
 }
 
 void StructColumnWriter::BeginWrite(ColumnWriterState &state_p) {
-	auto &state = (StructColumnWriterState &)state_p;
+	auto &state = state_p.Cast<StructColumnWriterState>();
 	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
 		child_writers[child_idx]->BeginWrite(*state.child_states[child_idx]);
 	}
 }
 
 void StructColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {
-	auto &state = (StructColumnWriterState &)state_p;
+	auto &state = state_p.Cast<StructColumnWriterState>();
 	auto &child_vectors = StructVector::GetEntries(vector);
 	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
 		child_writers[child_idx]->Write(*state.child_states[child_idx], *child_vectors[child_idx], count);
@@ -1654,7 +1666,7 @@ void StructColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t
 }
 
 void StructColumnWriter::FinalizeWrite(ColumnWriterState &state_p) {
-	auto &state = (StructColumnWriterState &)state_p;
+	auto &state = state_p.Cast<StructColumnWriterState>();
 	for (idx_t child_idx = 0; child_idx < child_writers.size(); child_idx++) {
 		// we add the null count of the struct to the null count of the children
 		child_writers[child_idx]->null_count += null_count;
@@ -1713,19 +1725,19 @@ bool ListColumnWriter::HasAnalyze() {
 	return child_writer->HasAnalyze();
 }
 void ListColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = (ListColumnWriterState &)state_p;
+	auto &state = state_p.Cast<ListColumnWriterState>();
 	auto &list_child = ListVector::GetEntry(vector);
 	auto list_count = ListVector::GetListSize(vector);
 	child_writer->Analyze(*state.child_state, &state_p, list_child, list_count);
 }
 
 void ListColumnWriter::FinalizeAnalyze(ColumnWriterState &state_p) {
-	auto &state = (ListColumnWriterState &)state_p;
+	auto &state = state_p.Cast<ListColumnWriterState>();
 	child_writer->FinalizeAnalyze(*state.child_state);
 }
 
 void ListColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count) {
-	auto &state = (ListColumnWriterState &)state_p;
+	auto &state = state_p.Cast<ListColumnWriterState>();
 
 	auto list_data = FlatVector::GetData<list_entry_t>(vector);
 	auto &validity = FlatVector::Validity(vector);
@@ -1782,12 +1794,12 @@ void ListColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *pa
 }
 
 void ListColumnWriter::BeginWrite(ColumnWriterState &state_p) {
-	auto &state = (ListColumnWriterState &)state_p;
+	auto &state = state_p.Cast<ListColumnWriterState>();
 	child_writer->BeginWrite(*state.child_state);
 }
 
 void ListColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t count) {
-	auto &state = (ListColumnWriterState &)state_p;
+	auto &state = state_p.Cast<ListColumnWriterState>();
 
 	auto &list_child = ListVector::GetEntry(vector);
 	Vector child_list(list_child);
@@ -1796,7 +1808,7 @@ void ListColumnWriter::Write(ColumnWriterState &state_p, Vector &vector, idx_t c
 }
 
 void ListColumnWriter::FinalizeWrite(ColumnWriterState &state_p) {
-	auto &state = (ListColumnWriterState &)state_p;
+	auto &state = state_p.Cast<ListColumnWriterState>();
 	child_writer->FinalizeWrite(*state.child_state);
 }
 

package/src/duckdb/extension/parquet/include/cast_column_reader.hpp

@@ -28,7 +28,7 @@ public:
 	unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) override;
 	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override;
 
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, uint8_t *define_out, uint8_t *repeat_out,
+	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
 	           Vector &result) override;
 
 	void Skip(idx_t num_values) override;

package/src/duckdb/extension/parquet/include/column_reader.hpp

@@ -51,7 +51,7 @@ public:
 	                                             const SchemaElement &schema_p, idx_t schema_idx_p, idx_t max_define,
 	                                             idx_t max_repeat);
 	virtual void InitializeRead(idx_t row_group_index, const vector<ColumnChunk> &columns, TProtocol &protocol_p);
-	virtual idx_t Read(uint64_t num_values, parquet_filter_t &filter, uint8_t *define_out, uint8_t *repeat_out,
+	virtual idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
 	                   Vector &result_out);
 
 	virtual void Skip(idx_t num_values);
@@ -143,7 +143,8 @@ private:
 	void PreparePage(PageHeader &page_hdr);
 	void PrepareDataPage(PageHeader &page_hdr);
 	void PreparePageV2(PageHeader &page_hdr);
-	void DecompressInternal(CompressionCodec::type codec, const char *src, idx_t src_size, char *dst, idx_t dst_size);
+	void DecompressInternal(CompressionCodec::type codec, const_data_ptr_t src, idx_t src_size, data_ptr_t dst,
+	                        idx_t dst_size);
 
 	const duckdb_parquet::format::ColumnChunk *chunk = nullptr;
 
@@ -174,7 +175,7 @@ public:
 		if (TARGET::TYPE != PhysicalType::INVALID && type.InternalType() != TARGET::TYPE) {
 			throw InternalException("Failed to cast column reader to type - type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -182,7 +183,7 @@ public:
 		if (TARGET::TYPE != PhysicalType::INVALID && type.InternalType() != TARGET::TYPE) {
 			throw InternalException("Failed to cast column reader to type - type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

package/src/duckdb/extension/parquet/include/column_writer.hpp

@@ -24,6 +24,18 @@ public:
 	vector<uint16_t> definition_levels;
 	vector<uint16_t> repetition_levels;
 	vector<bool> is_empty;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 class ColumnWriterStatistics {
@@ -34,6 +46,18 @@ public:
 	virtual string GetMax();
 	virtual string GetMinValue();
 	virtual string GetMaxValue();
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 class ColumnWriter {

package/src/duckdb/extension/parquet/include/list_column_reader.hpp

@@ -21,7 +21,7 @@ public:
 	ListColumnReader(ParquetReader &reader, LogicalType type_p, const SchemaElement &schema_p, idx_t schema_idx_p,
 	                 idx_t max_define_p, idx_t max_repeat_p, duckdb::unique_ptr<ColumnReader> child_column_reader_p);
 
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, uint8_t *define_out, uint8_t *repeat_out,
+	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
 	           Vector &result_out) override;
 
 	void ApplyPendingSkips(idx_t num_values) override;

package/src/duckdb/extension/parquet/include/parquet_dbp_decoder.hpp

@@ -4,7 +4,7 @@
 namespace duckdb {
 class DbpDecoder {
 public:
-	DbpDecoder(const uint8_t *buffer, uint32_t buffer_len) : buffer_((char *)buffer, buffer_len) {
+	DbpDecoder(data_ptr_t buffer, uint32_t buffer_len) : buffer_(buffer, buffer_len) {
 		//<block size in values> <number of miniblocks in a block> <total value count> <first value>
 		// overall header
 		block_value_count = ParquetDecodeUtils::VarintDecode<uint64_t>(buffer_);
@@ -35,8 +35,8 @@ public:
 	}
 
 	template <typename T>
-	void GetBatch(char *values_target_ptr, uint32_t batch_size) {
-		auto values = (T *)values_target_ptr;
+	void GetBatch(data_ptr_t values_target_ptr, uint32_t batch_size) {
+		auto values = reinterpret_cast<T *>(values_target_ptr);
 
 		if (batch_size == 0) {
 			return;
@@ -97,7 +97,7 @@ public:
 			return;
 		}
 		auto data = duckdb::unique_ptr<uint32_t[]>(new uint32_t[values_left_in_miniblock]);
-		GetBatch<uint32_t>((char *)data.get(), values_left_in_miniblock);
+		GetBatch<uint32_t>(data_ptr_cast(data.get()), values_left_in_miniblock);
 	}
 
 	uint64_t TotalValues() {

package/src/duckdb/extension/parquet/include/parquet_rle_bp_decoder.hpp

@@ -18,9 +18,8 @@ class RleBpDecoder {
 public:
 	/// Create a decoder object. buffer/buffer_len is the decoded data.
 	/// bit_width is the width of each value (before encoding).
-	RleBpDecoder(const uint8_t *buffer, uint32_t buffer_len, uint32_t bit_width)
-	    : buffer_((char *)buffer, buffer_len), bit_width_(bit_width), current_value_(0), repeat_count_(0),
-	      literal_count_(0) {
+	RleBpDecoder(data_ptr_t buffer, uint32_t buffer_len, uint32_t bit_width)
+	    : buffer_(buffer, buffer_len), bit_width_(bit_width), current_value_(0), repeat_count_(0), literal_count_(0) {
 		if (bit_width >= 64) {
 			throw std::runtime_error("Decode bit width too large");
 		}
@@ -29,8 +28,8 @@ public:
 	}
 
 	template <typename T>
-	void GetBatch(char *values_target_ptr, uint32_t batch_size) {
-		auto values = (T *)values_target_ptr;
+	void GetBatch(data_ptr_t values_target_ptr, uint32_t batch_size) {
+		auto values = reinterpret_cast<T *>(values_target_ptr);
 		uint32_t values_read = 0;
 
 		while (values_read < batch_size) {

package/src/duckdb/extension/parquet/include/resizable_buffer.hpp

@@ -19,9 +19,9 @@ namespace duckdb {
 class ByteBuffer { // on to the 10 thousandth impl
 public:
 	ByteBuffer() {};
-	ByteBuffer(char *ptr, uint64_t len) : ptr(ptr), len(len) {};
+	ByteBuffer(data_ptr_t ptr, uint64_t len) : ptr(ptr), len(len) {};
 
-	char *ptr = nullptr;
+	data_ptr_t ptr = nullptr;
 	uint64_t len = 0;
 
 public:
@@ -41,7 +41,7 @@ public:
 	template <class T>
 	T get() {
 		available(sizeof(T));
-		T val = Load<T>((data_ptr_t)ptr);
+		T val = Load<T>(ptr);
 		return val;
 	}
 
@@ -76,7 +76,7 @@ public:
 		if (new_size > alloc_len) {
 			alloc_len = NextPowerOfTwo(new_size);
 			allocated_data = allocator.Allocate(alloc_len);
-			ptr = (char *)allocated_data.get();
+			ptr = allocated_data.get();
 		}
 	}
 

package/src/duckdb/extension/parquet/include/row_number_column_reader.hpp

@@ -26,7 +26,7 @@ public:
 	                      idx_t max_define_p, idx_t max_repeat_p);
 
 public:
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, uint8_t *define_out, uint8_t *repeat_out,
+	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
 	           Vector &result) override;
 
 	unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const vector<ColumnChunk> &columns) override;

package/src/duckdb/extension/parquet/include/struct_column_reader.hpp

@@ -29,7 +29,7 @@ public:
 
 	void InitializeRead(idx_t row_group_idx_p, const vector<ColumnChunk> &columns, TProtocol &protocol_p) override;
 
-	idx_t Read(uint64_t num_values, parquet_filter_t &filter, uint8_t *define_out, uint8_t *repeat_out,
+	idx_t Read(uint64_t num_values, parquet_filter_t &filter, data_ptr_t define_out, data_ptr_t repeat_out,
 	           Vector &result) override;
 
 	void Skip(idx_t num_values) override;

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -343,7 +343,7 @@ public:
 
 	static unique_ptr<GlobalTableFunctionState> ParquetScanInitGlobal(ClientContext &context,
 	                                                                  TableFunctionInitInput &input) {
-		auto &bind_data = (ParquetReadBindData &)*input.bind_data;
+		auto &bind_data = input.bind_data->CastNoConst<ParquetReadBindData>();
 		auto result = make_uniq<ParquetReadGlobalState>();
 
 		result->file_opening = vector<bool>(bind_data.files.size(), false);

package/src/duckdb/extension/parquet/parquet_metadata.cpp

@@ -19,7 +19,7 @@ struct ParquetMetaDataBindData : public TableFunctionData {
 
 public:
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const ParquetMetaDataBindData &)other_p;
+		auto &other = other_p.Cast<ParquetMetaDataBindData>();
 		return other.return_types == return_types && files == other.files;
 	}
 };