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

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

@@ -21,8 +21,7 @@ class ColumnDataCollection;
 class ExecutionContext;
 
 struct LocalFunctionData {
-	virtual ~LocalFunctionData() {
-	}
+	virtual ~LocalFunctionData() = default;
 
 	template <class TARGET>
 	TARGET &Cast() {
@@ -31,14 +30,13 @@ struct LocalFunctionData {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
 struct GlobalFunctionData {
-	virtual ~GlobalFunctionData() {
-	}
+	virtual ~GlobalFunctionData() = default;
 
 	template <class TARGET>
 	TARGET &Cast() {
@@ -47,14 +45,13 @@ struct GlobalFunctionData {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
 struct PreparedBatchData {
-	virtual ~PreparedBatchData() {
-	}
+	virtual ~PreparedBatchData() = default;
 
 	template <class TARGET>
 	TARGET &Cast() {
@@ -63,18 +60,18 @@ struct PreparedBatchData {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
 struct CopyFunctionBindInput {
+	explicit CopyFunctionBindInput(const CopyInfo &info_p) : info(info_p) {
+	}
+
 	const CopyInfo &info;
 
 	string file_extension;
-
-	CopyFunctionBindInput(const CopyInfo &info_p) : info(info_p) {
-	}
 };
 
 enum class CopyFunctionExecutionMode { REGULAR_COPY_TO_FILE, PARALLEL_COPY_TO_FILE, BATCH_COPY_TO_FILE };
@@ -114,7 +111,7 @@ enum class CopyTypeSupport { SUPPORTED, LOSSY, UNSUPPORTED };
 
 typedef CopyTypeSupport (*copy_supports_type_t)(const LogicalType &type);
 
-class CopyFunction : public Function {
+class CopyFunction : public Function { // NOLINT: work-around bug in clang-tidy
 public:
 	explicit CopyFunction(const string &name)
 	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),

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

@@ -58,13 +58,13 @@ struct FunctionData {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 	// FIXME: this function should be removed in the future
 	template <class TARGET>
 	TARGET &CastNoConst() const {
-		return const_cast<TARGET &>(reinterpret_cast<const TARGET &>(*this));
+		return const_cast<TARGET &>(Cast<TARGET>()); // NOLINT: FIXME
 	}
 };
 
@@ -72,7 +72,7 @@ struct TableFunctionData : public FunctionData {
 	// used to pass on projections to table functions that support them. NB, can contain COLUMN_IDENTIFIER_ROW_ID
 	vector<idx_t> column_ids;
 
-	DUCKDB_API virtual ~TableFunctionData();
+	DUCKDB_API ~TableFunctionData() override;
 
 	DUCKDB_API unique_ptr<FunctionData> Copy() const override;
 	DUCKDB_API bool Equals(const FunctionData &other) const override;

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

@@ -27,26 +27,26 @@ public:
 
 public:
 	//! Bind a scalar function from the set of functions and input arguments. Returns the index of the chosen function,
-	//! returns DConstants::INVALID_INDEX and sets error if none could be found
-	DUCKDB_API idx_t BindFunction(const string &name, ScalarFunctionSet &functions,
-	                              const vector<LogicalType> &arguments, ErrorData &error);
-	DUCKDB_API idx_t BindFunction(const string &name, ScalarFunctionSet &functions,
-	                              vector<unique_ptr<Expression>> &arguments, ErrorData &error);
+	//! returns optional_idx() and sets error if none could be found
+	DUCKDB_API optional_idx BindFunction(const string &name, ScalarFunctionSet &functions,
+	                                     const vector<LogicalType> &arguments, ErrorData &error);
+	DUCKDB_API optional_idx BindFunction(const string &name, ScalarFunctionSet &functions,
+	                                     vector<unique_ptr<Expression>> &arguments, ErrorData &error);
 	//! Bind an aggregate function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
-	DUCKDB_API idx_t BindFunction(const string &name, AggregateFunctionSet &functions,
-	                              const vector<LogicalType> &arguments, ErrorData &error);
-	DUCKDB_API idx_t BindFunction(const string &name, AggregateFunctionSet &functions,
-	                              vector<unique_ptr<Expression>> &arguments, ErrorData &error);
+	//! function, returns optional_idx() and sets error if none could be found
+	DUCKDB_API optional_idx BindFunction(const string &name, AggregateFunctionSet &functions,
+	                                     const vector<LogicalType> &arguments, ErrorData &error);
+	DUCKDB_API optional_idx BindFunction(const string &name, AggregateFunctionSet &functions,
+	                                     vector<unique_ptr<Expression>> &arguments, ErrorData &error);
 	//! Bind a table function from the set of functions and input arguments. Returns the index of the chosen
-	//! function, returns DConstants::INVALID_INDEX and sets error if none could be found
-	DUCKDB_API idx_t BindFunction(const string &name, TableFunctionSet &functions, const vector<LogicalType> &arguments,
-	                              ErrorData &error);
-	DUCKDB_API idx_t BindFunction(const string &name, TableFunctionSet &functions,
-	                              vector<unique_ptr<Expression>> &arguments, ErrorData &error);
+	//! function, returns optional_idx() and sets error if none could be found
+	DUCKDB_API optional_idx BindFunction(const string &name, TableFunctionSet &functions,
+	                                     const vector<LogicalType> &arguments, ErrorData &error);
+	DUCKDB_API optional_idx BindFunction(const string &name, TableFunctionSet &functions,
+	                                     vector<unique_ptr<Expression>> &arguments, ErrorData &error);
 	//! Bind a pragma function from the set of functions and input arguments
-	DUCKDB_API idx_t BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
-	                              ErrorData &error);
+	DUCKDB_API optional_idx BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
+	                                     ErrorData &error);
 
 	DUCKDB_API unique_ptr<Expression> BindScalarFunction(const string &schema, const string &name,
 	                                                     vector<unique_ptr<Expression>> children, ErrorData &error,
@@ -70,20 +70,21 @@ public:
 private:
 	//! Cast a set of expressions to the arguments of this function
 	void CastToFunctionArguments(SimpleFunction &function, vector<unique_ptr<Expression>> &children);
-	int64_t BindVarArgsFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);
-	int64_t BindFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);
+	optional_idx BindVarArgsFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);
+	optional_idx BindFunctionCost(const SimpleFunction &func, const vector<LogicalType> &arguments);
 
 	template <class T>
 	vector<idx_t> BindFunctionsFromArguments(const string &name, FunctionSet<T> &functions,
 	                                         const vector<LogicalType> &arguments, ErrorData &error);
 
 	template <class T>
-	idx_t MultipleCandidateException(const string &name, FunctionSet<T> &functions, vector<idx_t> &candidate_functions,
-	                                 const vector<LogicalType> &arguments, ErrorData &error);
+	optional_idx MultipleCandidateException(const string &name, FunctionSet<T> &functions,
+	                                        vector<idx_t> &candidate_functions, const vector<LogicalType> &arguments,
+	                                        ErrorData &error);
 
 	template <class T>
-	idx_t BindFunctionFromArguments(const string &name, FunctionSet<T> &functions, const vector<LogicalType> &arguments,
-	                                ErrorData &error);
+	optional_idx BindFunctionFromArguments(const string &name, FunctionSet<T> &functions,
+	                                       const vector<LogicalType> &arguments, ErrorData &error);
 
 	vector<LogicalType> GetLogicalTypesFromExpressions(vector<unique_ptr<Expression>> &arguments);
 };

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

@@ -74,7 +74,7 @@ public:
 	template <class FUNC, class CATALOG_ENTRY>
 	static pair<FUNC, unique_ptr<FunctionData>> Deserialize(Deserializer &deserializer, CatalogType catalog_type,
 	                                                        vector<unique_ptr<Expression>> &children,
-	                                                        LogicalType return_type) {
+	                                                        LogicalType return_type) { // NOLINT: clang-tidy bug
 		auto &context = deserializer.Get<ClientContext &>();
 		auto entry = DeserializeBase<FUNC, CATALOG_ENTRY>(deserializer, catalog_type);
 		auto &function = entry.first;

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

@@ -18,7 +18,7 @@ namespace duckdb {
 template <class T>
 class FunctionSet {
 public:
-	explicit FunctionSet(string name) : name(name) {
+	explicit FunctionSet(string name) : name(std::move(name)) {
 	}
 
 	//! The name of the function set

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

@@ -28,7 +28,7 @@ typedef void (*pragma_function_t)(ClientContext &context, const FunctionParamete
 //!   -> this is similar to a call pragma but without parameters
 //! Pragma functions can either return a new query to execute (pragma_query_t)
 //! or they can
-class PragmaFunction : public SimpleNamedParameterFunction {
+class PragmaFunction : public SimpleNamedParameterFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	// Call
 	DUCKDB_API static PragmaFunction PragmaCall(const string &name, pragma_query_t query, vector<LogicalType> arguments,

package/src/duckdb/src/include/duckdb/function/scalar/regexp.hpp

@@ -44,13 +44,13 @@ struct RegexpExtractAll {
 struct RegexpBaseBindData : public FunctionData {
 	RegexpBaseBindData();
 	RegexpBaseBindData(duckdb_re2::RE2::Options options, string constant_string, bool constant_pattern = true);
-	virtual ~RegexpBaseBindData();
+	~RegexpBaseBindData() override;
 
 	duckdb_re2::RE2::Options options;
 	string constant_string;
 	bool constant_pattern;
 
-	virtual bool Equals(const FunctionData &other_p) const override;
+	bool Equals(const FunctionData &other_p) const override;
 };
 
 struct RegexpMatchesBindData : public RegexpBaseBindData {
@@ -105,7 +105,7 @@ struct RegexStringPieceArgs {
 		}
 	}
 
-	RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) {
+	RegexStringPieceArgs &operator=(RegexStringPieceArgs &&other) noexcept {
 		std::swap(this->size, other.size);
 		std::swap(this->capacity, other.capacity);
 		std::swap(this->group_buffer, other.group_buffer);

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -95,7 +95,7 @@ protected:
 	DUCKDB_API virtual void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier);
 };
 
-struct StrfTimeFormat : public StrTimeFormat {
+struct StrfTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in clang-tidy
 	DUCKDB_API idx_t GetLength(date_t date, dtime_t time, int32_t utc_offset, const char *tz_name);
 
 	DUCKDB_API void FormatString(date_t date, int32_t data[8], const char *tz_name, char *target);
@@ -128,7 +128,7 @@ protected:
 	                             char *target);
 };
 
-struct StrpTimeFormat : public StrTimeFormat {
+struct StrpTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in clang-tidy
 public:
 	StrpTimeFormat();
 
@@ -137,15 +137,17 @@ public:
 		int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
 		string tz;
 		string error_message;
-		idx_t error_position = DConstants::INVALID_INDEX;
+		optional_idx error_position;
 
 		bool is_special;
 		date_t special;
 
 		date_t ToDate();
+		dtime_t ToTime();
 		timestamp_t ToTimestamp();
 
 		bool TryToDate(date_t &result);
+		bool TryToTime(dtime_t &result);
 		bool TryToTimestamp(timestamp_t &result);
 
 		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
@@ -160,16 +162,14 @@ public:
 	DUCKDB_API bool Parse(string_t str, ParseResult &result) const;
 
 	DUCKDB_API bool TryParseDate(string_t str, date_t &result, string &error_message) const;
+	DUCKDB_API bool TryParseTime(string_t str, dtime_t &result, string &error_message) const;
 	DUCKDB_API bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message) const;
 
-	date_t ParseDate(string_t str);
-	timestamp_t ParseTimestamp(string_t str);
-
 	void Serialize(Serializer &serializer) const;
 	static StrpTimeFormat Deserialize(Deserializer &deserializer);
 
 protected:
-	static string FormatStrpTimeError(const string &input, idx_t position);
+	static string FormatStrpTimeError(const string &input, optional_idx position);
 	DUCKDB_API void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
 	int NumericSpecifierWidth(StrTimeSpecifier specifier);
 	int32_t TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -12,14 +12,14 @@
 #include "utf8proc.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 
-namespace re2 {
+namespace duckdb_re2 {
 class RE2;
 }
 
 namespace duckdb {
 
 struct LowerFun {
-	static uint8_t ascii_to_lower_map[];
+	static const uint8_t ASCII_TO_LOWER_MAP[];
 
 	//! Returns the length of the result string obtained from lowercasing the given input (in bytes)
 	static idx_t LowerLength(const char *input_data, idx_t input_length);
@@ -31,7 +31,7 @@ struct LowerFun {
 };
 
 struct UpperFun {
-	static uint8_t ascii_to_upper_map[];
+	static const uint8_t ASCII_TO_UPPER_MAP[];
 
 	static void RegisterFunction(BuiltinFunctions &set);
 };

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

@@ -29,14 +29,14 @@ struct FunctionLocalState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 
 class Binder;
 class BoundFunctionExpression;
-class DependencyList;
+class LogicalDependencyList;
 class ScalarFunctionCatalogEntry;
 
 struct FunctionStatisticsInput {
@@ -61,7 +61,7 @@ typedef unique_ptr<FunctionLocalState> (*init_local_state_t)(ExpressionState &st
                                                              const BoundFunctionExpression &expr,
                                                              FunctionData *bind_data);
 //! The type to add the dependencies of this BoundFunctionExpression to the set of dependencies
-typedef void (*dependency_function_t)(BoundFunctionExpression &expr, DependencyList &dependencies);
+typedef void (*dependency_function_t)(BoundFunctionExpression &expr, LogicalDependencyList &dependencies);
 //! The type to propagate statistics for this scalar function
 typedef unique_ptr<BaseStatistics> (*function_statistics_t)(ClientContext &context, FunctionStatisticsInput &input);
 //! The type to bind lambda-specific parameter types
@@ -71,7 +71,7 @@ typedef void (*function_serialize_t)(Serializer &serializer, const optional_ptr<
                                      const ScalarFunction &function);
 typedef unique_ptr<FunctionData> (*function_deserialize_t)(Deserializer &deserializer, ScalarFunction &function);
 
-class ScalarFunction : public BaseScalarFunction {
+class ScalarFunction : public BaseScalarFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	DUCKDB_API ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
 	                          scalar_function_t function, bind_scalar_function_t bind = nullptr,
@@ -135,7 +135,7 @@ public:
 
 public:
 	template <class OP>
-	static scalar_function_t GetScalarUnaryFunction(LogicalType type) {
+	static scalar_function_t GetScalarUnaryFunction(const LogicalType &type) {
 		scalar_function_t function;
 		switch (type.id()) {
 		case LogicalTypeId::TINYINT:
@@ -181,7 +181,7 @@ public:
 	}
 
 	template <class TR, class OP>
-	static scalar_function_t GetScalarUnaryFunctionFixedReturn(LogicalType type) {
+	static scalar_function_t GetScalarUnaryFunctionFixedReturn(const LogicalType &type) {
 		scalar_function_t function;
 		switch (type.id()) {
 		case LogicalTypeId::TINYINT:

package/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp

@@ -35,21 +35,21 @@ enum class ArrowDateTimeType : uint8_t {
 class ArrowType {
 public:
 	//! From a DuckDB type
-	ArrowType(LogicalType type_p)
+	ArrowType(LogicalType type_p) // NOLINT: allow implicit conversion
 	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::NORMAL),
 	      date_time_precision(ArrowDateTimeType::DAYS) {};
 
 	//! From a DuckDB type + fixed_size
-	ArrowType(LogicalType type_p, idx_t fixed_size_p)
+	ArrowType(LogicalType type_p, idx_t fixed_size_p) // NOLINT: work-around bug in clang-tidy
 	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::FIXED_SIZE),
 	      date_time_precision(ArrowDateTimeType::DAYS), fixed_size(fixed_size_p) {};
 
 	//! From a DuckDB type + variable size type
-	ArrowType(LogicalType type_p, ArrowVariableSizeType size_type_p)
+	ArrowType(LogicalType type_p, ArrowVariableSizeType size_type_p) // NOLINT: work-around bug in clang-tidy
 	    : type(std::move(type_p)), size_type(size_type_p), date_time_precision(ArrowDateTimeType::DAYS) {};
 
 	//! From a DuckDB type + datetime type
-	ArrowType(LogicalType type_p, ArrowDateTimeType date_time_precision_p)
+	ArrowType(LogicalType type_p, ArrowDateTimeType date_time_precision_p) // NOLINT: work-around bug in clang-tidy
 	    : type(std::move(type_p)), size_type(ArrowVariableSizeType::NORMAL),
 	      date_time_precision(date_time_precision_p) {};
 

package/src/duckdb/src/include/duckdb/function/table/arrow.hpp

@@ -82,7 +82,7 @@ public:
 struct ArrowScanLocalState;
 struct ArrowArrayScanState {
 public:
-	ArrowArrayScanState(ArrowScanLocalState &state);
+	explicit ArrowArrayScanState(ArrowScanLocalState &state);
 
 public:
 	ArrowScanLocalState &state;
@@ -146,7 +146,7 @@ public:
 		if (it == array_states.end()) {
 			auto child_p = make_uniq<ArrowArrayScanState>(*this);
 			auto &child = *child_p;
-			array_states.emplace(std::make_pair(child_idx, std::move(child_p)));
+			array_states.emplace(child_idx, std::move(child_p));
 			return child;
 		}
 		return *it->second;

package/src/duckdb/src/include/duckdb/function/table/read_csv.hpp

@@ -30,8 +30,6 @@ public:
 };
 
 struct BaseCSVData : public TableFunctionData {
-	virtual ~BaseCSVData() {
-	}
 	//! The file path of the CSV file to read or write
 	vector<string> files;
 	//! The CSV reader options
@@ -55,7 +53,7 @@ struct WriteCSVData : public BaseCSVData {
 	//! The newline string to write
 	string newline = "\n";
 	//! The size of the CSV file (in bytes) that we buffer before we flush it to disk
-	idx_t flush_size = 4096 * 8;
+	idx_t flush_size = 4096ULL * 8ULL;
 	//! For each byte whether or not the CSV file requires quotes when containing the byte
 	unsafe_unique_array<bool> requires_quotes;
 };

package/src/duckdb/src/include/duckdb/function/table/table_scan.hpp

@@ -32,7 +32,7 @@ struct TableScanBindData : public TableFunctionData {
 
 public:
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const TableScanBindData &)other_p;
+		auto &other = other_p.Cast<TableScanBindData>();
 		return &other.table == &table && result_ids == other.result_ids;
 	}
 };

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

@@ -21,7 +21,7 @@
 namespace duckdb {
 
 class BaseStatistics;
-class DependencyList;
+class LogicalDependencyList;
 class LogicalGet;
 class TableFilterSet;
 class TableCatalogEntry;
@@ -36,7 +36,7 @@ struct TableFunctionInfo {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -60,7 +60,7 @@ public:
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -75,7 +75,7 @@ struct LocalTableFunctionState {
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
@@ -83,9 +83,9 @@ struct LocalTableFunctionState {
 struct TableFunctionBindInput {
 	TableFunctionBindInput(vector<Value> &inputs, named_parameter_map_t &named_parameters,
 	                       vector<LogicalType> &input_table_types, vector<string> &input_table_names,
-	                       optional_ptr<TableFunctionInfo> info)
+	                       optional_ptr<TableFunctionInfo> info, optional_ptr<Binder> binder)
 	    : inputs(inputs), named_parameters(named_parameters), input_table_types(input_table_types),
-	      input_table_names(input_table_names), info(info) {
+	      input_table_names(input_table_names), info(info), binder(binder) {
 	}
 
 	vector<Value> &inputs;
@@ -93,6 +93,7 @@ struct TableFunctionBindInput {
 	vector<LogicalType> &input_table_types;
 	vector<string> &input_table_names;
 	optional_ptr<TableFunctionInfo> info;
+	optional_ptr<Binder> binder;
 };
 
 struct TableFunctionInitInput {
@@ -134,7 +135,7 @@ public:
 	optional_ptr<GlobalTableFunctionState> global_state;
 };
 
-enum ScanType { TABLE, PARQUET };
+enum class ScanType : uint8_t { TABLE, PARQUET };
 
 struct BindInfo {
 public:
@@ -145,11 +146,11 @@ public:
 	ScanType type;
 	optional_ptr<TableCatalogEntry> table;
 
-	void InsertOption(const string &name, Value value) {
+	void InsertOption(const string &name, Value value) { // NOLINT: work-around bug in clang-tidy
 		if (options.find(name) != options.end()) {
 			throw InternalException("This option already exists");
 		}
-		options[name] = std::move(value);
+		options.emplace(name, std::move(value));
 	}
 	template <class T>
 	T GetOption(const string &name) {
@@ -199,7 +200,7 @@ typedef BindInfo (*table_function_get_bind_info_t)(const optional_ptr<FunctionDa
 
 typedef double (*table_function_progress_t)(ClientContext &context, const FunctionData *bind_data,
                                             const GlobalTableFunctionState *global_state);
-typedef void (*table_function_dependency_t)(DependencyList &dependencies, const FunctionData *bind_data);
+typedef void (*table_function_dependency_t)(LogicalDependencyList &dependencies, const FunctionData *bind_data);
 typedef unique_ptr<NodeStatistics> (*table_function_cardinality_t)(ClientContext &context,
                                                                    const FunctionData *bind_data);
 typedef void (*table_function_pushdown_complex_filter_t)(ClientContext &context, LogicalGet &get,
@@ -211,7 +212,7 @@ typedef void (*table_function_serialize_t)(Serializer &serializer, const optiona
                                            const TableFunction &function);
 typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(Deserializer &deserializer, TableFunction &function);
 
-class TableFunction : public SimpleNamedParameterFunction {
+class TableFunction : public SimpleNamedParameterFunction { // NOLINT: work-around bug in clang-tidy
 public:
 	DUCKDB_API
 	TableFunction(string name, vector<LogicalType> arguments, table_function_t function,