duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp

@@ -40,19 +40,19 @@ struct CSVReaderOptions {
 	//! See struct above.
 	DialectOptions dialect_options;
 	//! Whether or not we should ignore InvalidInput errors
-	bool ignore_errors = false;
-	//! Rejects table name
-	string rejects_table_name;
+	CSVOption<bool> ignore_errors = false;
+	//! Whether we store CSV Errors in the rejects table or not
+	CSVOption<bool> store_rejects = false;
+	//! Rejects table name (Name of the table the store rejects errors)
+	CSVOption<string> rejects_table_name = {"reject_errors"};
+	//! Rejects Scan name name  (Name of the table the store rejects scans)
+	CSVOption<string> rejects_scan_name = {"reject_scans"};
 	//! Rejects table entry limit (0 = no limit)
 	idx_t rejects_limit = 0;
-	//! Columns to use as recovery key for rejected rows when reading with ignore_errors = true
-	vector<string> rejects_recovery_columns;
-	//! Index of the recovery columns
-	vector<idx_t> rejects_recovery_column_ids;
 	//! Number of samples to buffer
 	idx_t buffer_sample_size = (idx_t)STANDARD_VECTOR_SIZE * 50;
-	//! Specifies the string that represents a null value
-	string null_str;
+	//! Specifies the strings that represents a null value
+	vector<string> null_str = {""};
 	//! Whether file is compressed or not, and if so which compression type
 	//! AUTO_DETECT (default; infer from file extension)
 	FileCompressionType compression = FileCompressionType::AUTO_DETECT;
@@ -85,6 +85,8 @@ struct CSVReaderOptions {
 	//! Whether or not header names shall be normalized
 	bool normalize_names = false;
 	//! True, if column with that index must skip null check
+	unordered_set<string> force_not_null_names;
+	//! True, if column with that index must skip null check
 	vector<bool> force_not_null;
 	//! Number of sample chunks used in auto-detection
 	idx_t sample_size_chunks = 20480 / STANDARD_VECTOR_SIZE;
@@ -107,6 +109,7 @@ struct CSVReaderOptions {
 
 	//! User defined parameters for the csv function concatenated on a string
 	string user_defined_parameters;
+
 	//===--------------------------------------------------------------------===//
 	// WriteCSVOptions
 	//===--------------------------------------------------------------------===//
@@ -147,7 +150,7 @@ struct CSVReaderOptions {
 	void SetNewline(const string &input);
 	//! Set an option that is supported by both reading and writing functions, called by
 	//! the SetReadOption and SetWriteOption methods
-	bool SetBaseOption(const string &loption, const Value &value);
+	bool SetBaseOption(const string &loption, const Value &value, bool write_option = false);
 
 	//! loption - lowercase string
 	//! set - argument(s) to the option
@@ -162,5 +165,16 @@ struct CSVReaderOptions {
 	string ToString() const;
 	//! If the type for column with idx i was manually set
 	bool WasTypeManuallySet(idx_t i) const;
+
+	string NewLineIdentifierToString() {
+		switch (dialect_options.state_machine_options.new_line.GetValue()) {
+		case NewLineIdentifier::SINGLE:
+			return "\\n";
+		case NewLineIdentifier::CARRY_ON:
+			return "\\r\\n";
+		default:
+			return "";
+		}
+	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp

@@ -54,6 +54,10 @@ struct CSVStates {
 		return states[1] == CSVState::CARRIAGE_RETURN;
 	}
 
+	inline bool IsInvalid() {
+		return states[1] == CSVState::INVALID;
+	}
+
 	inline bool IsQuoted() {
 		return states[0] == CSVState::QUOTED;
 	}

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp

@@ -30,7 +30,7 @@ public:
 
 	//! Generates a CSV Scanner, with information regarding the piece of buffer it should be read.
 	//! In case it returns a nullptr it means we are done reading these files.
-	unique_ptr<StringValueScanner> Next();
+	unique_ptr<StringValueScanner> Next(optional_ptr<StringValueScanner> previous_scanner);
 
 	void FillRejectsTable();
 
@@ -75,6 +75,8 @@ private:
 
 	atomic<idx_t> last_file_idx;
 	shared_ptr<CSVBufferUsage> current_buffer_in_use;
+
+	unordered_map<idx_t, idx_t> threads_per_file;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/skip_scanner.hpp

@@ -42,9 +42,6 @@ public:
 	SkipScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,
 	            shared_ptr<CSVErrorHandler> error_handler, idx_t rows_to_skip);
 
-	~SkipScanner() {
-	}
-
 	SkipResult &ParseChunk() override;
 
 	SkipResult &GetResult() override;

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp

@@ -42,17 +42,54 @@ public:
 		}
 		return other.buffer_size - other.buffer_pos + buffer_pos;
 	}
+
+	bool operator==(const LinePosition &other) const {
+		return buffer_pos == other.buffer_pos && buffer_idx == other.buffer_idx && buffer_size == other.buffer_size;
+	}
+
+	idx_t GetGlobalPosition(idx_t requested_buffer_size, bool first_char_nl = false) {
+		return requested_buffer_size * buffer_idx + buffer_pos + first_char_nl;
+	}
 	idx_t buffer_pos = 0;
 	idx_t buffer_size = 0;
 	idx_t buffer_idx = 0;
 };
 
+//! Keeps track of start and end of line positions in regard to the CSV file
+class FullLinePosition {
+public:
+	FullLinePosition() {};
+	LinePosition begin;
+	LinePosition end;
+
+	//! Reconstructs the current line to be used in error messages
+	string ReconstructCurrentLine(bool &first_char_nl,
+	                              unordered_map<idx_t, shared_ptr<CSVBufferHandle>> &buffer_handles);
+};
+
+class CurrentError {
+public:
+	CurrentError(CSVErrorType type, idx_t col_idx_p, LinePosition error_position_p)
+	    : type(type), col_idx(col_idx_p), error_position(error_position_p) {};
+
+	CSVErrorType type;
+	idx_t col_idx;
+	idx_t current_line_size;
+	string error_message;
+	//! Exact Position where the error happened
+	LinePosition error_position;
+
+	friend bool operator==(const CurrentError &error, CSVErrorType other) {
+		return error.type == other;
+	}
+};
+
 class StringValueResult : public ScannerResult {
 public:
 	StringValueResult(CSVStates &states, CSVStateMachine &state_machine,
 	                  const shared_ptr<CSVBufferHandle> &buffer_handle, Allocator &buffer_allocator, idx_t result_size,
-	                  idx_t buffer_position, CSVErrorHandler &error_hander, CSVIterator &iterator, bool store_line_size,
-	                  shared_ptr<CSVFileScan> csv_file_scan, idx_t &lines_read, bool sniffing);
+	                  idx_t buffer_position, CSVErrorHandler &error_handler, CSVIterator &iterator,
+	                  bool store_line_size, shared_ptr<CSVFileScan> csv_file_scan, idx_t &lines_read, bool sniffing);
 
 	~StringValueResult();
 
@@ -61,7 +98,7 @@ public:
 	unsafe_vector<ValidityMask *> validity_mask;
 
 	//! Variables to iterate over the CSV buffers
-	idx_t last_position;
+	LinePosition last_position;
 	char *buffer_ptr;
 	idx_t buffer_size;
 
@@ -69,8 +106,10 @@ public:
 	const uint32_t number_of_columns;
 	const bool null_padding;
 	const bool ignore_errors;
-	const char *null_str_ptr;
-	const idx_t null_str_size;
+
+	unsafe_unique_array<const char *> null_str_ptr;
+	unsafe_unique_array<idx_t> null_str_size;
+	idx_t null_str_count;
 
 	//! Internal Data Chunk used for flushing
 	DataChunk parse_chunk;
@@ -80,16 +119,16 @@ public:
 	//! Information to properly handle errors
 	CSVErrorHandler &error_handler;
 	CSVIterator &iterator;
-	//! Where the previous line started, used to validate the maximum_line_size option
-	LinePosition previous_line_start;
-	LinePosition pre_previous_line_start;
+	//! Line position of the current line
+	FullLinePosition current_line_position;
+	//! Used for CSV line reconstruction on flushed errors
+	unordered_map<idx_t, FullLinePosition> line_positions_per_row;
 	bool store_line_size = false;
 	bool added_last_line = false;
 	bool quoted_new_line = false;
 
 	unsafe_unique_array<std::pair<LogicalTypeId, bool>> parse_types;
 	vector<string> names;
-	unordered_map<idx_t, string> cast_errors;
 
 	shared_ptr<CSVFileScan> csv_file_scan;
 	idx_t &lines_read;
@@ -99,10 +138,13 @@ public:
 	idx_t chunk_col_id = 0;
 
 	//! We must ensure that we keep the buffers alive until processing the query result
-	vector<shared_ptr<CSVBufferHandle>> buffer_handles;
+	unordered_map<idx_t, shared_ptr<CSVBufferHandle>> buffer_handles;
 
-	//! If the current row has an error, we have to skip it
-	bool ignore_current_row = false;
+	//! Requested size of buffers (i.e., either 32Mb or set by buffer_size parameter)
+	idx_t requested_size;
+
+	//! Errors happening in the current line (if any)
+	vector<CurrentError> current_errors;
 
 	bool sniffing;
 	//! Specialized code for quoted values, makes sure to remove quotes and escapes
@@ -119,8 +161,10 @@ public:
 	//! Handles EmptyLine states
 	static inline bool EmptyLine(StringValueResult &result, const idx_t buffer_pos);
 	inline bool AddRowInternal();
-
-	void HandleOverLimitRows();
+	//! Force the throw of a unicode error
+	void HandleUnicodeError(idx_t col_idx, LinePosition &error_position);
+	//! Certain errors should only be handled when adding the line, to ensure proper error propagation.
+	bool HandleError();
 
 	inline void AddValueToVector(const char *value_ptr, const idx_t size, bool allocate = false);
 
@@ -143,9 +187,6 @@ public:
 	                   const shared_ptr<CSVStateMachine> &state_machine,
 	                   const shared_ptr<CSVErrorHandler> &error_handler);
 
-	~StringValueScanner() {
-	}
-
 	StringValueResult &ParseChunk() override;
 
 	//! Flushes the result to the insert_chunk

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_batch_collector.hpp

@@ -14,7 +14,7 @@ namespace duckdb {
 
 class PhysicalBatchCollector : public PhysicalResultCollector {
 public:
-	PhysicalBatchCollector(PreparedStatementData &data);
+	explicit PhysicalBatchCollector(PreparedStatementData &data);
 
 public:
 	unique_ptr<QueryResult> GetResult(GlobalSinkState &state) override;

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_explain_analyze.hpp

@@ -18,7 +18,7 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXPLAIN_ANALYZE;
 
 public:
-	PhysicalExplainAnalyze(vector<LogicalType> types)
+	explicit PhysicalExplainAnalyze(vector<LogicalType> types)
 	    : PhysicalOperator(PhysicalOperatorType::EXPLAIN_ANALYZE, std::move(types), 1) {
 	}
 

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_prepare.hpp

@@ -19,9 +19,9 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PREPARE;
 
 public:
-	PhysicalPrepare(string name, shared_ptr<PreparedStatementData> prepared, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::PREPARE, {LogicalType::BOOLEAN}, estimated_cardinality), name(name),
-	      prepared(std::move(prepared)) {
+	PhysicalPrepare(string name_p, shared_ptr<PreparedStatementData> prepared, idx_t estimated_cardinality)
+	    : PhysicalOperator(PhysicalOperatorType::PREPARE, {LogicalType::BOOLEAN}, estimated_cardinality),
+	      name(std::move(name_p)), prepared(std::move(prepared)) {
 	}
 
 	string name;

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp

@@ -25,7 +25,7 @@ public:
 public:
 	PhysicalSet(const std::string &name_p, Value value_p, SetScope scope_p, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::SET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),
-	      value(value_p), scope(scope_p) {
+	      value(std::move(value_p)), scope(scope_p) {
 	}
 
 public:

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_vacuum.hpp

@@ -20,9 +20,12 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::VACUUM;
 
 public:
-	PhysicalVacuum(unique_ptr<VacuumInfo> info, idx_t estimated_cardinality);
+	PhysicalVacuum(unique_ptr<VacuumInfo> info, optional_ptr<TableCatalogEntry> table,
+	               unordered_map<idx_t, idx_t> column_id_map, idx_t estimated_cardinality);
 
 	unique_ptr<VacuumInfo> info;
+	optional_ptr<TableCatalogEntry> table;
+	unordered_map<idx_t, idx_t> column_id_map;
 
 public:
 	// Source interface

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_rejects_table.hpp

@@ -14,19 +14,24 @@ class ClientContext;
 
 class CSVRejectsTable : public ObjectCacheEntry {
 public:
-	CSVRejectsTable(string name) : name(name), count(0) {
+	CSVRejectsTable(string rejects_scan, string rejects_error)
+	    : count(0), scan_table(std::move(rejects_scan)), errors_table(std::move(rejects_error)) {
 	}
-	~CSVRejectsTable() override = default;
 	mutex write_lock;
 	string name;
 	idx_t count;
+	string scan_table;
+	string errors_table;
 
-	static shared_ptr<CSVRejectsTable> GetOrCreate(ClientContext &context, const string &name);
+	static shared_ptr<CSVRejectsTable> GetOrCreate(ClientContext &context, const string &rejects_scan,
+	                                               const string &rejects_error);
 
 	void InitializeTable(ClientContext &context, const ReadCSVData &options);
-	TableCatalogEntry &GetTable(ClientContext &context);
+	TableCatalogEntry &GetErrorsTable(ClientContext &context);
+	TableCatalogEntry &GetScansTable(ClientContext &context);
+
+	idx_t GetCurrentFileIndex(idx_t query_id);
 
-public:
 	static string ObjectType() {
 		return "csv_rejects_table_cache";
 	}
@@ -34,6 +39,12 @@ public:
 	string GetObjectType() override {
 		return ObjectType();
 	}
+
+private:
+	//! Current File Index being used in the query
+	idx_t current_file_idx = 0;
+	//! Current Query ID being executed
+	idx_t current_query_id = 0;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/physical_operator_states.hpp

@@ -52,7 +52,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);
 	}
 };
@@ -69,7 +69,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);
 	}
 };
@@ -90,7 +90,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);
 	}
 
@@ -114,7 +114,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);
 	}
 };
@@ -135,7 +135,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);
 	}
 };
@@ -152,7 +152,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/execution/physical_plan_generator.hpp

@@ -28,7 +28,7 @@ public:
 	explicit PhysicalPlanGenerator(ClientContext &context);
 	~PhysicalPlanGenerator();
 
-	DependencyList dependencies;
+	LogicalDependencyList dependencies;
 	//! Recursive CTEs require at least one ChunkScan, referencing the working_table.
 	//! This data structure is used to establish it.
 	unordered_map<idx_t, std::shared_ptr<ColumnDataCollection>> recursive_cte_tables;
@@ -87,6 +87,7 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalSet &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalReset &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalSimple &op);
+	unique_ptr<PhysicalOperator> CreatePlan(LogicalVacuum &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalUnnest &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalRecursiveCTE &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalMaterializedCTE &op);

package/src/duckdb/src/include/duckdb/execution/window_executor.hpp

@@ -131,7 +131,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/execution/window_segment_tree.hpp

@@ -31,7 +31,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/function/aggregate_function.hpp

@@ -79,7 +79,7 @@ typedef void (*aggregate_serialize_t)(Serializer &serializer, const optional_ptr
                                       const AggregateFunction &function);
 typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(Deserializer &deserializer, AggregateFunction &function);
 
-class AggregateFunction : public BaseScalarFunction {
+class AggregateFunction : public BaseScalarFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
 	                  aggregate_size_t state_size, aggregate_initialize_t initialize, aggregate_update_t update,

package/src/duckdb/src/include/duckdb/function/cast/cast_function_set.hpp

@@ -20,9 +20,9 @@ typedef BoundCastInfo (*bind_cast_function_t)(BindCastInput &input, const Logica
 typedef int64_t (*implicit_cast_cost_t)(const LogicalType &from, const LogicalType &to);
 
 struct GetCastFunctionInput {
-	GetCastFunctionInput(optional_ptr<ClientContext> context = nullptr) : context(context) {
+	explicit GetCastFunctionInput(optional_ptr<ClientContext> context = nullptr) : context(context) {
 	}
-	GetCastFunctionInput(ClientContext &context) : context(&context) {
+	explicit GetCastFunctionInput(ClientContext &context) : context(&context) {
 	}
 
 	optional_ptr<ClientContext> context;
@@ -30,8 +30,8 @@ struct GetCastFunctionInput {
 };
 
 struct BindCastFunction {
-	BindCastFunction(bind_cast_function_t function,
-	                 unique_ptr<BindCastInfo> info = nullptr); // NOLINT: allow implicit cast
+	BindCastFunction(bind_cast_function_t function, // NOLINT: allow implicit cast
+	                 unique_ptr<BindCastInfo> info = nullptr);
 
 	bind_cast_function_t function;
 	unique_ptr<BindCastInfo> info;
@@ -40,7 +40,7 @@ struct BindCastFunction {
 class CastFunctionSet {
 public:
 	CastFunctionSet();
-	CastFunctionSet(DBConfig &config);
+	explicit CastFunctionSet(DBConfig &config);
 
 public:
 	DUCKDB_API static CastFunctionSet &Get(ClientContext &context);

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -30,7 +30,7 @@ struct BindCastInfo {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -48,7 +48,7 @@ struct BoundCastData {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -104,9 +104,9 @@ typedef unique_ptr<FunctionLocalState> (*init_cast_local_state_t)(CastLocalState
 
 struct BoundCastInfo {
 	DUCKDB_API
-	BoundCastInfo(
+	BoundCastInfo( // NOLINT: allow explicit cast from cast_function_t
 	    cast_function_t function, unique_ptr<BoundCastData> cast_data = nullptr,
-	    init_cast_local_state_t init_local_state = nullptr); // NOLINT: allow explicit cast from cast_function_t
+	    init_cast_local_state_t init_local_state = nullptr);
 	cast_function_t function;
 	init_cast_local_state_t init_local_state;
 	unique_ptr<BoundCastData> cast_data;

package/src/duckdb/src/include/duckdb/function/cast/vector_cast_helpers.hpp

@@ -21,7 +21,7 @@ template <class OP>
 struct VectorStringCastOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto result = (Vector *)dataptr;
+		auto result = reinterpret_cast<Vector *>(dataptr);
 		return OP::template Operation<INPUT_TYPE>(input, *result);
 	}
 };
@@ -34,7 +34,7 @@ struct VectorTryCastOperator {
 		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output))) {
 			return output;
 		}
-		auto data = (VectorTryCastData *)dataptr;
+		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
 		return HandleVectorCastError::Operation<RESULT_TYPE>(CastExceptionText<INPUT_TYPE, RESULT_TYPE>(input), mask,
 		                                                     idx, *data);
 	}
@@ -44,7 +44,7 @@ template <class OP>
 struct VectorTryCastStrictOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorTryCastData *)dataptr;
+		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
 		RESULT_TYPE output;
 		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->parameters.strict))) {
 			return output;
@@ -58,7 +58,7 @@ template <class OP>
 struct VectorTryCastErrorOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorTryCastData *)dataptr;
+		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
 		RESULT_TYPE output;
 		if (DUCKDB_LIKELY(OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->parameters))) {
 			return output;
@@ -74,7 +74,7 @@ template <class OP>
 struct VectorTryCastStringOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorTryCastData *)dataptr;
+		auto data = reinterpret_cast<VectorTryCastData *>(dataptr);
 		RESULT_TYPE output;
 		if (DUCKDB_LIKELY(
 		        OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, output, data->result, data->parameters))) {
@@ -99,7 +99,7 @@ template <class OP>
 struct VectorDecimalCastOperator {
 	template <class INPUT_TYPE, class RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input, ValidityMask &mask, idx_t idx, void *dataptr) {
-		auto data = (VectorDecimalCastData *)dataptr;
+		auto data = reinterpret_cast<VectorDecimalCastData *>(dataptr);
 		RESULT_TYPE result_value;
 		if (!OP::template Operation<INPUT_TYPE, RESULT_TYPE>(input, result_value, data->vector_cast_data.parameters,
 		                                                     data->width, data->scale)) {

package/src/duckdb/src/include/duckdb/function/compression_function.hpp

@@ -39,7 +39,7 @@ struct AnalyzeState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -55,7 +55,7 @@ struct CompressionState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -76,7 +76,7 @@ struct CompressedSegmentState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -96,7 +96,7 @@ struct CompressionAppendState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };