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

package/src/duckdb/src/include/duckdb/common/profiler.hpp

@@ -32,8 +32,8 @@ public:
 	//! the total elapsed time. Otherwise returns how far along the timer is
 	//! right now.
 	double Elapsed() const {
-		auto _end = finished ? end : Tick();
-		return std::chrono::duration_cast<std::chrono::duration<double>>(_end - start).count();
+		auto measured_end = finished ? end : Tick();
+		return std::chrono::duration_cast<std::chrono::duration<double>>(measured_end - start).count();
 	}
 
 private:

package/src/duckdb/src/include/duckdb/common/progress_bar/display/terminal_progress_bar_display.hpp

@@ -27,11 +27,11 @@ private:
 	int32_t rendered_percentage = -1;
 	static constexpr const idx_t PARTIAL_BLOCK_COUNT = UnicodeBar::PartialBlocksCount();
 #ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *PROGRESS_EMPTY = " ";
-	const char *const *PROGRESS_PARTIAL = UnicodeBar::PartialBlocks();
-	const char *PROGRESS_BLOCK = UnicodeBar::FullBlock();
-	const char *PROGRESS_START = "\xE2\x96\x95";
-	const char *PROGRESS_END = "\xE2\x96\x8F";
+	const char *PROGRESS_EMPTY = " ";                                  // NOLINT
+	const char *const *PROGRESS_PARTIAL = UnicodeBar::PartialBlocks(); // NOLINT
+	const char *PROGRESS_BLOCK = UnicodeBar::FullBlock();              // NOLINT
+	const char *PROGRESS_START = "\xE2\x96\x95";                       // NOLINT
+	const char *PROGRESS_END = "\xE2\x96\x8F";                         // NOLINT
 #else
 	const char *PROGRESS_EMPTY = " ";
 	const char *const PROGRESS_PARTIAL[PARTIAL_BLOCK_COUNT] = {" ", " ", " ", " ", " ", " ", " ", " "};

package/src/duckdb/src/include/duckdb/common/random_engine.hpp

@@ -19,7 +19,7 @@ class ClientContext;
 struct RandomState;
 
 struct RandomEngine {
-	RandomEngine(int64_t seed = -1);
+	explicit RandomEngine(int64_t seed = -1);
 	~RandomEngine();
 
 public:

package/src/duckdb/src/include/duckdb/common/re2_regex.hpp

@@ -14,8 +14,8 @@ enum class RegexOptions : uint8_t { NONE, CASE_INSENSITIVE };
 
 class Regex {
 public:
-	DUCKDB_API Regex(const std::string &pattern, RegexOptions options = RegexOptions::NONE);
-	Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
+	DUCKDB_API explicit Regex(const std::string &pattern, RegexOptions options = RegexOptions::NONE);
+	explicit Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
 	}
 	const duckdb_re2::RE2 &GetRegex() const {
 		return *regex;
@@ -29,10 +29,10 @@ struct GroupMatch {
 	std::string text;
 	uint32_t position;
 
-	const std::string &str() const {
+	const std::string &str() const { // NOLINT
 		return text;
 	}
-	operator std::string() const {
+	operator std::string() const { // NOLINT: allow implicit cast
 		return text;
 	}
 };
@@ -47,15 +47,15 @@ struct Match {
 		return groups[index];
 	}
 
-	std::string str(uint64_t index) {
+	std::string str(uint64_t index) { // NOLINT
 		return GetGroup(index).text;
 	}
 
-	uint64_t position(uint64_t index) {
+	uint64_t position(uint64_t index) { // NOLINT
 		return GetGroup(index).position;
 	}
 
-	uint64_t length(uint64_t index) {
+	uint64_t length(uint64_t index) { // NOLINT
 		return GetGroup(index).text.size();
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/buffered_file_reader.hpp

@@ -17,6 +17,7 @@ class BufferedFileReader : public ReadStream {
 public:
 	BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type = FileLockType::READ_LOCK,
 	                   optional_ptr<FileOpener> opener = nullptr);
+	BufferedFileReader(FileSystem &fs, unique_ptr<FileHandle> handle);
 
 	FileSystem &fs;
 	unsafe_unique_array<data_t> data;
@@ -33,6 +34,8 @@ public:
 		return file_size;
 	}
 
+	//! Resets reading - beginning at position 0
+	void Reset();
 	void Seek(uint64_t location);
 	uint64_t CurrentOffset();
 

package/src/duckdb/src/include/duckdb/common/serializer/buffered_file_writer.hpp

@@ -17,11 +17,11 @@ namespace duckdb {
 
 class BufferedFileWriter : public WriteStream {
 public:
-	static constexpr uint8_t DEFAULT_OPEN_FLAGS = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE;
+	static constexpr FileOpenFlags DEFAULT_OPEN_FLAGS = FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE;
 
 	//! Serializes to a buffer allocated by the serializer, will expand when
 	//! writing past the initial threshold
-	DUCKDB_API BufferedFileWriter(FileSystem &fs, const string &path, uint8_t open_flags = DEFAULT_OPEN_FLAGS);
+	DUCKDB_API BufferedFileWriter(FileSystem &fs, const string &path, FileOpenFlags open_flags = DEFAULT_OPEN_FLAGS);
 
 	FileSystem &fs;
 	string path;

package/src/duckdb/src/include/duckdb/common/serializer/deserialization_data.hpp

@@ -23,7 +23,7 @@ struct DeserializationData {
 	stack<reference<DatabaseInstance>> databases;
 	stack<idx_t> enums;
 	stack<reference<bound_parameter_map_t>> parameter_data;
-	stack<reference<LogicalType>> types;
+	stack<const_reference<LogicalType>> types;
 
 	template <class T>
 	void Set(T entry) = delete;
@@ -112,7 +112,7 @@ inline void DeserializationData::Unset<CatalogType>() {
 
 template <>
 inline void DeserializationData::Set(ClientContext &context) {
-	contexts.push(context);
+	contexts.emplace(context);
 }
 
 template <>
@@ -129,7 +129,7 @@ inline void DeserializationData::Unset<ClientContext>() {
 
 template <>
 inline void DeserializationData::Set(DatabaseInstance &db) {
-	databases.push(db);
+	databases.emplace(db);
 }
 
 template <>
@@ -146,7 +146,7 @@ inline void DeserializationData::Unset<DatabaseInstance>() {
 
 template <>
 inline void DeserializationData::Set(bound_parameter_map_t &context) {
-	parameter_data.push(context);
+	parameter_data.emplace(context);
 }
 
 template <>
@@ -167,13 +167,24 @@ inline void DeserializationData::Set(LogicalType &type) {
 }
 
 template <>
-inline LogicalType &DeserializationData::Get() {
+inline void DeserializationData::Unset<LogicalType>() {
+	AssertNotEmpty(types);
+	types.pop();
+}
+
+template <>
+inline void DeserializationData::Set(const LogicalType &type) {
+	types.emplace(type);
+}
+
+template <>
+inline const LogicalType &DeserializationData::Get() {
 	AssertNotEmpty(types);
 	return types.top();
 }
 
 template <>
-inline void DeserializationData::Unset<LogicalType>() {
+inline void DeserializationData::Unset<const LogicalType>() {
 	AssertNotEmpty(types);
 	types.pop();
 }

package/src/duckdb/src/include/duckdb/common/serializer/deserializer.hpp

@@ -114,6 +114,18 @@ public:
 		OnOptionalPropertyEnd(true);
 	}
 
+	template <typename T>
+	inline void ReadPropertyWithDefault(const field_id_t field_id, const char *tag, CSVOption<T> &ret,
+	                                    T &&default_value) {
+		if (!OnOptionalPropertyBegin(field_id, tag)) {
+			ret = std::forward<T>(default_value);
+			OnOptionalPropertyEnd(false);
+			return;
+		}
+		ret = Read<T>();
+		OnOptionalPropertyEnd(true);
+	}
+
 	// Special case:
 	// Read into an existing data_ptr_t
 	inline void ReadProperty(const field_id_t field_id, const char *tag, data_ptr_t ret, idx_t count) {

package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/common/shared_ptr.hpp"
 #include "duckdb/common/unique_ptr.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/optional_idx.hpp"
 
 namespace duckdb {
 
@@ -24,6 +25,7 @@ const field_id_t MESSAGE_TERMINATOR_FIELD_ID = 0xFFFF;
 template <class...>
 using void_t = void;
 
+// NOLINTBEGIN: match STL case
 // Check for anything implementing a `void Serialize(Serializer &Serializer)` method
 template <typename T, typename = T>
 struct has_serialize : std::false_type {};
@@ -145,6 +147,8 @@ struct is_atomic<std::atomic<T>> : std::true_type {
 	typedef T TYPE;
 };
 
+// NOLINTEND
+
 struct SerializationDefaultValue {
 
 	template <typename T = void>
@@ -258,6 +262,16 @@ struct SerializationDefaultValue {
 	static inline bool IsDefault(const typename std::enable_if<std::is_same<T, string>::value, T>::type &value) {
 		return value.empty();
 	}
+
+	template <typename T = void>
+	static inline typename std::enable_if<std::is_same<T, optional_idx>::value, T>::type GetDefault() {
+		return optional_idx();
+	}
+
+	template <typename T = void>
+	static inline bool IsDefault(const typename std::enable_if<std::is_same<T, optional_idx>::value, T>::type &value) {
+		return !value.IsValid();
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/serializer.hpp

@@ -17,6 +17,7 @@
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/optional_idx.hpp"
 #include "duckdb/common/value_operations/value_operations.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_option.hpp"
 
 namespace duckdb {
 
@@ -86,6 +87,21 @@ public:
 		OnOptionalPropertyEnd(true);
 	}
 
+	// Specialization for Value (default Value comparison throws when comparing nulls)
+	template <class T>
+	void WritePropertyWithDefault(const field_id_t field_id, const char *tag, const CSVOption<T> &value,
+	                              const T &&default_value) {
+		// If current value is default, don't write it
+		if (!serialize_default_values && (value == default_value)) {
+			OnOptionalPropertyBegin(field_id, tag, false);
+			OnOptionalPropertyEnd(false);
+			return;
+		}
+		OnOptionalPropertyBegin(field_id, tag, true);
+		WriteValue(value.GetValue());
+		OnOptionalPropertyEnd(true);
+	}
+
 	// Special case: data_ptr_T
 	void WriteProperty(const field_id_t field_id, const char *tag, const_data_ptr_t ptr, idx_t count) {
 		OnPropertyBegin(field_id, tag);

package/src/duckdb/src/include/duckdb/common/sort/duckdb_pdqsort.hpp

@@ -46,6 +46,8 @@ using duckdb::make_unsafe_uniq_array;
 using duckdb::FastMemcpy;
 using duckdb::FastMemcmp;
 
+// NOLINTBEGIN
+
 enum {
 	// Partitions below this size are sorted using insertion sort.
 	insertion_sort_threshold = 24,
@@ -704,5 +706,6 @@ inline void pdqsort_branchless(const PDQIterator &begin, const PDQIterator &end,
 	}
 	pdqsort_loop<true>(begin, end, constants, log2(end - begin));
 }
+// NOLINTEND
 
 } // namespace duckdb_pdqsort

package/src/duckdb/src/include/duckdb/common/sort/partition_state.hpp

@@ -209,6 +209,8 @@ public:
 class PartitionGlobalMergeStates {
 public:
 	struct Callback {
+		virtual ~Callback() = default;
+
 		virtual bool HasError() const {
 			return false;
 		}

package/src/duckdb/src/include/duckdb/common/string_util.hpp

@@ -148,8 +148,8 @@ public:
 
 	//! Join multiple items of container with given size, transformed to string
 	//! using function, into one string using the given separator
-	template <typename C, typename S, typename Func>
-	static string Join(const C &input, S count, const string &separator, Func f) {
+	template <typename C, typename S, typename FUNC>
+	static string Join(const C &input, S count, const string &separator, FUNC f) {
 		// The result
 		std::string result;
 
@@ -188,8 +188,8 @@ public:
 	DUCKDB_API static bool CILessThan(const string &l1, const string &l2);
 
 	//! Format a string using printf semantics
-	template <typename... Args>
-	static string Format(const string fmt_str, Args... params) {
+	template <typename... ARGS>
+	static string Format(const string fmt_str, ARGS... params) {
 		return Exception::ConstructMessage(fmt_str, params...);
 	}
 

package/src/duckdb/src/include/duckdb/common/tree_renderer.hpp

@@ -39,36 +39,36 @@ public:
 };
 
 struct TreeRendererConfig {
-	void enable_detailed() {
-		MAX_EXTRA_LINES = 1000;
+	void EnableDetailed() {
+		max_extra_lines = 1000;
 		detailed = true;
 	}
 
-	void enable_standard() {
-		MAX_EXTRA_LINES = 30;
+	void EnableStandard() {
+		max_extra_lines = 30;
 		detailed = false;
 	}
 
-	idx_t MAXIMUM_RENDER_WIDTH = 240;
-	idx_t NODE_RENDER_WIDTH = 29;
-	idx_t MINIMUM_RENDER_WIDTH = 15;
-	idx_t MAX_EXTRA_LINES = 30;
+	idx_t maximum_render_width = 240;
+	idx_t node_render_width = 29;
+	idx_t minimum_render_width = 15;
+	idx_t max_extra_lines = 30;
 	bool detailed = false;
 
 #ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *LTCORNER = "\342\224\214"; // "┌";
-	const char *RTCORNER = "\342\224\220"; // "┐";
-	const char *LDCORNER = "\342\224\224"; // "└";
-	const char *RDCORNER = "\342\224\230"; // "┘";
-
-	const char *MIDDLE = "\342\224\274";  // "┼";
-	const char *TMIDDLE = "\342\224\254"; // "┬";
-	const char *LMIDDLE = "\342\224\234"; // "├";
-	const char *RMIDDLE = "\342\224\244"; // "┤";
-	const char *DMIDDLE = "\342\224\264"; // "┴";
-
-	const char *VERTICAL = "\342\224\202";   // "│";
-	const char *HORIZONTAL = "\342\224\200"; // "─";
+	const char *LTCORNER = "\342\224\214"; // NOLINT "┌";
+	const char *RTCORNER = "\342\224\220"; // NOLINT "┐";
+	const char *LDCORNER = "\342\224\224"; // NOLINT "└";
+	const char *RDCORNER = "\342\224\230"; // NOLINT "┘";
+
+	const char *MIDDLE = "\342\224\274";  // NOLINT "┼";
+	const char *TMIDDLE = "\342\224\254"; // NOLINT "┬";
+	const char *LMIDDLE = "\342\224\234"; // NOLINT "├";
+	const char *RMIDDLE = "\342\224\244"; // NOLINT "┤";
+	const char *DMIDDLE = "\342\224\264"; // NOLINT "┴";
+
+	const char *VERTICAL = "\342\224\202";   // NOLINT "│";
+	const char *HORIZONTAL = "\342\224\200"; // NOLINT "─";
 #else
 	// ASCII version
 	const char *LTCORNER = "<";
@@ -89,7 +89,7 @@ struct TreeRendererConfig {
 
 class TreeRenderer {
 public:
-	explicit TreeRenderer(TreeRendererConfig config_p = TreeRendererConfig()) : config(std::move(config_p)) {
+	explicit TreeRenderer(TreeRendererConfig config_p = TreeRendererConfig()) : config(config_p) {
 	}
 
 	string ToString(const LogicalOperator &op);
@@ -105,10 +105,10 @@ public:
 	void ToStream(RenderTree &root, std::ostream &ss);
 
 	void EnableDetailed() {
-		config.enable_detailed();
+		config.EnableDetailed();
 	}
 	void EnableStandard() {
-		config.enable_standard();
+		config.EnableStandard();
 	}
 
 private:
@@ -144,7 +144,6 @@ private:
 
 	template <class T>
 	unique_ptr<RenderTree> CreateRenderTree(const T &op);
-	string ExtractExpressionsRecursive(ExpressionInfo &states);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/typedefs.hpp

@@ -37,27 +37,27 @@ typedef idx_t column_t;
 typedef idx_t storage_t;
 
 template <class SRC>
-data_ptr_t data_ptr_cast(SRC *src) {
+data_ptr_t data_ptr_cast(SRC *src) { // NOLINT: naming
 	return reinterpret_cast<data_ptr_t>(src);
 }
 
 template <class SRC>
-const_data_ptr_t const_data_ptr_cast(const SRC *src) {
+const_data_ptr_t const_data_ptr_cast(const SRC *src) { // NOLINT: naming
 	return reinterpret_cast<const_data_ptr_t>(src);
 }
 
 template <class SRC>
-char *char_ptr_cast(SRC *src) {
+char *char_ptr_cast(SRC *src) { // NOLINT: naming
 	return reinterpret_cast<char *>(src);
 }
 
 template <class SRC>
-const char *const_char_ptr_cast(const SRC *src) {
+const char *const_char_ptr_cast(const SRC *src) { // NOLINT: naming
 	return reinterpret_cast<const char *>(src);
 }
 
 template <class SRC>
-const unsigned char *const_uchar_ptr_cast(const SRC *src) {
+const unsigned char *const_uchar_ptr_cast(const SRC *src) { // NOLINT: naming
 	return reinterpret_cast<const unsigned char *>(src);
 }
 

package/src/duckdb/src/include/duckdb/common/types/cast_helpers.hpp

@@ -356,8 +356,7 @@ struct UhugeintToStringCast {
 		string_t result = StringVector::EmptyString(vector, str.length());
 		auto data = result.GetDataWriteable();
 
-		// null-termination not required
-		memcpy(data, str.data(), str.length());
+		memcpy(data, str.data(), str.length()); // NOLINT: null-termination not required
 		result.Finalize();
 		return result;
 	}

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp

@@ -28,7 +28,7 @@ public:
 	//! Constructs an in-memory column data collection from an allocator
 	DUCKDB_API ColumnDataCollection(Allocator &allocator, vector<LogicalType> types);
 	//! Constructs an empty (but valid) in-memory column data collection from an allocator
-	DUCKDB_API ColumnDataCollection(Allocator &allocator);
+	DUCKDB_API explicit ColumnDataCollection(Allocator &allocator);
 	//! Constructs a buffer-managed column data collection
 	DUCKDB_API ColumnDataCollection(BufferManager &buffer_manager, vector<LogicalType> types);
 	//! Constructs either an in-memory or a buffer-managed column data collection
@@ -183,39 +183,39 @@ private:
 //! The ColumnDataRowCollection represents a set of materialized rows, as obtained from the ColumnDataCollection
 class ColumnDataRowCollection {
 public:
-	DUCKDB_API ColumnDataRowCollection(const ColumnDataCollection &collection);
+	DUCKDB_API explicit ColumnDataRowCollection(const ColumnDataCollection &collection);
 
 public:
 	DUCKDB_API Value GetValue(idx_t column, idx_t index) const;
 
 public:
 	// container API
-	bool empty() const {
+	bool empty() const { // NOLINT: match stl API
 		return rows.empty();
 	}
-	idx_t size() const {
+	idx_t size() const { // NOLINT: match stl API
 		return rows.size();
 	}
 
 	DUCKDB_API ColumnDataRow &operator[](idx_t i);
 	DUCKDB_API const ColumnDataRow &operator[](idx_t i) const;
 
-	vector<ColumnDataRow>::iterator begin() {
+	vector<ColumnDataRow>::iterator begin() { // NOLINT: match stl API
 		return rows.begin();
 	}
-	vector<ColumnDataRow>::iterator end() {
+	vector<ColumnDataRow>::iterator end() { // NOLINT: match stl API
 		return rows.end();
 	}
-	vector<ColumnDataRow>::const_iterator cbegin() const {
+	vector<ColumnDataRow>::const_iterator cbegin() const { // NOLINT: match stl API
 		return rows.cbegin();
 	}
-	vector<ColumnDataRow>::const_iterator cend() const {
+	vector<ColumnDataRow>::const_iterator cend() const { // NOLINT: match stl API
 		return rows.cend();
 	}
-	vector<ColumnDataRow>::const_iterator begin() const {
+	vector<ColumnDataRow>::const_iterator begin() const { // NOLINT: match stl API
 		return rows.begin();
 	}
-	vector<ColumnDataRow>::const_iterator end() const {
+	vector<ColumnDataRow>::const_iterator end() const { // NOLINT: match stl API
 		return rows.end();
 	}
 

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_iterators.hpp

@@ -43,17 +43,17 @@ private:
 	};
 
 public:
-	ColumnDataChunkIterator begin() {
+	ColumnDataChunkIterator begin() { // NOLINT: match stl API
 		return ColumnDataChunkIterator(&collection, column_ids);
 	}
-	ColumnDataChunkIterator end() {
+	ColumnDataChunkIterator end() { // NOLINT: match stl API
 		return ColumnDataChunkIterator(nullptr, vector<column_t>());
 	}
 };
 
 class ColumnDataRowIterationHelper {
 public:
-	DUCKDB_API ColumnDataRowIterationHelper(const ColumnDataCollection &collection);
+	DUCKDB_API explicit ColumnDataRowIterationHelper(const ColumnDataCollection &collection);
 
 private:
 	const ColumnDataCollection &collection;
@@ -79,8 +79,8 @@ private:
 	};
 
 public:
-	DUCKDB_API ColumnDataRowIterator begin();
-	DUCKDB_API ColumnDataRowIterator end();
+	DUCKDB_API ColumnDataRowIterator begin(); // NOLINT: match stl API
+	DUCKDB_API ColumnDataRowIterator end();   // NOLINT: match stl API
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/column/partitioned_column_data.hpp

@@ -117,7 +117,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/common/types/constraint_conflict_info.hpp

@@ -11,14 +11,13 @@ class Index;
 
 class ConflictInfo {
 public:
-	ConflictInfo(const unordered_set<column_t> &column_ids, bool only_check_unique = true)
+	explicit ConflictInfo(const unordered_set<column_t> &column_ids, bool only_check_unique = true)
 	    : column_ids(column_ids), only_check_unique(only_check_unique) {
 	}
 	const unordered_set<column_t> &column_ids;
 
 public:
 	bool ConflictTargetMatches(Index &index) const;
-	void VerifyAllConflictsMeetCondition() const;
 
 public:
 	bool only_check_unique = true;

package/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp

@@ -131,7 +131,7 @@ public:
 
 	//! Slice all Vectors from other.data[i] to data[i + 'col_offset']
 	//! Turning all Vectors into Dictionary Vectors, using 'sel'
-	DUCKDB_API void Slice(DataChunk &other, const SelectionVector &sel, idx_t count, idx_t col_offset = 0);
+	DUCKDB_API void Slice(const DataChunk &other, const SelectionVector &sel, idx_t count, idx_t col_offset = 0);
 
 	//! Slice a DataChunk from "offset" to "offset + count"
 	DUCKDB_API void Slice(idx_t offset, idx_t count);
@@ -150,7 +150,7 @@ public:
 	DUCKDB_API void Hash(vector<idx_t> &column_ids, Vector &result);
 
 	//! Returns a list of types of the vectors of this data chunk
-	DUCKDB_API vector<LogicalType> GetTypes();
+	DUCKDB_API vector<LogicalType> GetTypes() const;
 
 	//! Converts this DataChunk to a printable string representation
 	DUCKDB_API string ToString() const;

package/src/duckdb/src/include/duckdb/common/types/date.hpp

@@ -18,7 +18,7 @@
 
 namespace duckdb {
 
-struct timestamp_t;
+struct timestamp_t; // NOLINT: primitive case
 
 //! Type used to represent dates (days since 1970-01-01)
 struct date_t { // NOLINT

package/src/duckdb/src/include/duckdb/common/types/hash.hpp

@@ -14,13 +14,13 @@
 namespace duckdb {
 
 struct string_t;
-struct interval_t;
+struct interval_t; // NOLINT
 
 // efficient hash function that maximizes the avalanche effect and minimizes
 // bias
 // see: https://nullprogram.com/blog/2018/07/31/
 
-inline hash_t murmurhash64(uint64_t x) {
+inline hash_t MurmurHash64(uint64_t x) {
 	x ^= x >> 32;
 	x *= 0xd6e8feb86659fd93U;
 	x ^= x >> 32;
@@ -29,13 +29,13 @@ inline hash_t murmurhash64(uint64_t x) {
 	return x;
 }
 
-inline hash_t murmurhash32(uint32_t x) {
-	return murmurhash64(x);
+inline hash_t MurmurHash32(uint32_t x) {
+	return MurmurHash64(x);
 }
 
 template <class T>
 hash_t Hash(T value) {
-	return murmurhash32(value);
+	return MurmurHash32(value);
 }
 
 //! Combine two hashes by XORing them

package/src/duckdb/src/include/duckdb/common/types/hyperloglog.hpp

@@ -13,7 +13,7 @@
 #include "hyperloglog.hpp"
 
 namespace duckdb_hll {
-struct robj;
+struct robj; // NOLINT
 }
 
 namespace duckdb {

package/src/duckdb/src/include/duckdb/common/types/interval.hpp

@@ -12,10 +12,10 @@
 
 namespace duckdb {
 
-struct dtime_t;
-struct date_t;
-struct dtime_tz_t;
-struct timestamp_t;
+struct dtime_t;     // NOLINT: literal casing
+struct date_t;      // NOLINT: literal casing
+struct dtime_tz_t;  // NOLINT: literal casing
+struct timestamp_t; // NOLINT: literal casing
 
 class Serializer;
 class Deserializer;